🚀 Launch Day in Review: SivaGames Anima Card Game

Hey everyone,

Tomorrow’s the big day. After a full year of locking myself away and coding in solitude, I’m finally launching my very first mobile game: SivaGames Anima Card Game on Android.

---

💡 A Bit of Context

I’m actually a systems developer by trade. My usual side projects are more like "build my own programming language" or "write a custom OS kernel from scratch." So yeah, card games are way outside my comfort zone. But I really wanted to create something based on a simple philosophy: a game I would genuinely enjoy playing, without ever feeling like I’m getting ripped off.

That’s why I set one non-negotiable rule from day one: zero pay-to-win. You can’t spend a single real-world cent on cards, gems, or booster packs. Ever. Free players and paying players are always on the same level. The only things you can buy are purely cosmetic themes.

---

🎯 The Twist: Real-World Rarity

It’s an anime card collector, but the rarity isn’t rigged by some shady, profit-driven algorithm. Instead, it’s tied directly to real MyAnimeList (MAL) popularity data. So if a character has a massive fanbase in real life, they’ll naturally be harder to pull. No artificial scarcity—just pure community-driven stats.

---

🎮 What’s in the Game:

• 🎴 A huge collection with 5 rarity tiers, all linked to MAL data.
• 🛒 A full TCG economy: Booster pack openings, a fusion system to upgrade cards, and an open player marketplace for trading and selling.
• 🎲 Always something to do: 9 mini-games, daily quests, streak rewards, and a weekly bingo.
• 🎨 Customization: 32 visual themes to unlock and switch up your UI.

---

⭐ Beta Feedback (and Why It Means the World to Me)

I ran a closed beta recently, and the feedback honestly blew me away (testers gave it 5 stars across the board). But the comment that kept coming up—and the one that made me the happiest—was:

> "The game just feels completely fair."

Testers loved that progress is earned purely through playing, not paying. They raved about how fast and responsive the app is, with bright colors, smooth animations, and—most importantly for a dev—rock-solid stability (zero crashes during testing!). The marketplace and fusion mechanics were big hits too.

Quick note for the future: A few testers mentioned adding deeper card search filters and more detailed collection stats. I’ve already got those on the roadmap for the first updates!

---

---

🔗 Check It Out / Get Involved

The game officially drops tomorrow. It’s completely free, no strings attached, and no sneaky traps. If you want to give it a try or show some love, here are the links:

• 📱 Get it on the Play Store: SivaGames Anima Card Game
• 🎥 Watch the preview: YouTube Short

If you’ve got any questions—about the game design, how I’m parsing the MAL data, or the tech stack behind it all—ask away! I’d love to chat.

Hey r/indiegaming!

I'm a solo dev and I've been building an anime card collection game for the past year. It's called SivaGames Anima Card Game, launching on Android mid-July.

The main mechanic I'm most curious about: rarity is based on real MyAnimeList popularity data. So characters like Naruto or Goku are actually harder to pull because they have more MAL favorites — not because I decided they should be rare.

I also went full zero pay-to-win. No real money for coins, gems or boosters. Ever. Only cosmetics are paid. Free players and paying players are equal — I'm a gacha player myself and I was tired of feeling exploited by the games I play.

There's also a game room with 9 mini-games (card duels, anime quiz, reflexes, weekly bingo...) so you're not just waiting 30 min between drops doing nothing.

Stack: React Native, ASP.NET Core 8, MongoDB, MyAnimeList & AniList APIs.

Gameplay clip in the comments. Would love honest feedback — especially on the rarity mechanic!

GenAI disclosure: AI assistance was used for copywriting suggestions. All code and design decisions are mine.

Hey everyone,

I'm a solo developer launching a mobile companion app for SivaGames — a card collection game featuring characters from the entire MyAnimeList database (anime, manga, webtoons).

🎮 Quick overview:

• 100% free, zero pay-to-win — no real money for cards, ever.
• Drop rarity based on real MyAnimeList popularity data.
• Free booster available every few minutes.
• Card fusion system + Adventure quiz mode.

📋 How to join the Closed Beta:

I need 20 testers to meet Google Play's strict closed testing requirement (14 days minimum). All you need to do is install it and open the app a few times over the next two weeks.

The deadline is tight, so any help is hugely appreciated! 🙏

1. First, join our Google Group (mandatory by Google to unlock access): https://groups.google.com/g/sivagames
2. Then, access the game on Google Play:
   • 📱 Download via Android Device (If you are on your phone)
   • 💻 Opt-in via Web Browser (If you are on a PC)

Happy to answer any questions about the app or the tech behind it!

Hi everyone,

I’ve spent the last few months building FluxSharp, a systems programming language that brings C# syntax (Classes, Inheritance, Async) to a bare-metal environment. The compiler is written in Rust using the Pest PEG parser, but instead of targeting LLVM or a VM, it generates raw x86-64 Assembly (NASM).

I wanted to share some technical insights and challenges I faced, specifically regarding the async/await implementation without a heavy runtime.

1. The "No-Runtime" Async Challenge Unlike the .NET CLR, FluxSharp doesn't have a managed thread pool. To make async/await work, I had to implement a custom State Machine at the assembly level.

• When a function is marked async, the compiler transforms its AST into a series of states.
• The "Promise" system is actually a struct in memory that holds a function pointer (the continuation) and a context pointer.
• The Event Loop: I wrote a minimal event loop in ASM that polls these promises. When an I/O operation (or a timer) completes, the loop restores the registers and jumps to the continuation address.

2. Direct x86-64 Code Generation Since I'm not using LLVM, I have to handle register allocation and stack frames manually.

• Calling Convention: I'm following a modified version of the System V AMD64 ABI.
• Safety: To implement null-safety and bounds checking, the compiler injects CMP and JE/JNE instructions before every array access or object dereference. If it fails, it triggers a syscall to exit with a specific error code.

3. Parsing with Pest (Rust) Using PEG (Parsing Expression Grammars) via the Pest crate was a game changer for the C#-like syntax. However, mapping the concrete syntax tree (CST) to a lean AST for ASM generation required a recursive descent pass that collapses nested expressions to avoid stack overflows during compilation of complex logic.

Technical Stack:

• Frontend: Rust + Pest (Grammar)
• Backend: Custom x86-64 ASM Generator
• Assembler/Linker: NASM & LD
• Security: Built-in overflow protection and bounds checking at the instruction level.

I'm particularly interested in hearing from anyone who has worked on Assembly-level coroutines. My current approach saves the minimal set of registers (RBX, RSP, RBP, R12-R15), but I'm curious if there are more efficient ways to handle the "State Machine" transition in raw ASM without bloating the binary size.

The project is open-source (MIT), and you can see the compiler source and the generated ASM output in the repo:https://github.com/Yvan4001/FluxSharp

Full documentation on the architecture is here:https://flux-sharp.sivagames.eu/docs/

Looking forward to your technical feedback!