Bit Blast!

Bit Blast teaches logic through play! Varying bit-blocks drop onto an 8-bit register and perform a bit operation on impact. Match the register's goal state to clear it. Think fast, master the mask.

Comment

Inspiration

As computer architecture students, we know how essential bits are to the entire scope of computer science. We also know that quizzing yourself over ones and zeros isn't very fun. We wanted to build a game that took a relatively dry core CS topic and turned it into an engaging, exciting, and genuinely fun experience.

XOR, AND, and NAND are operations that sound confusing in a textbook, but click the instant you see them in Bit Blast form. Beyond that, the convenience of a quick, pick-up-and-play game creates natural spaced repetition—shown across multiple studies to be the most effective method for building lasting knowledge.

What it does

Bit Blast is a falling-block puzzle game built around boolean logic gate operations.

An 8-bit register sits at the bottom of the screen. Blocks of 1 to 4 bits fall from the top, each level labeled with its gate operation—XOR, AND, or NAND. When a block lands, it applies its operation to whatever register bits it touches.

The goal changes by gate:

  • XOR and NAND → flip all 8 bits to 1 to clear
  • AND → push all 8 bits to 0 to clear

Scoring:

  • +100 for every bit flipped toward the goal state
  • -100 for every bit flipped away from the goal state
  • +25 for every bit touched but not changed

Clear the register and survive — levels get faster the further you go.

A live truth table on the right panel updates with the current gate, so players always have a reference. The further you go, the more you internalize it—and soon you won't need it at all.

How we built it

Built entirely in Unity 2D using C# in under 24 hours.

  • Single GameManager.cs script owns all register state, gate logic, win detection, scoring, and level progression
  • All visuals are Unity UI Canvas elements: Image components and RectTransform positioning, no 3D physics
  • Variable block widths (1–4 bits) spawn randomly, keeping every drop unpredictable
  • TextMesh Pro for all in-game text
  • Unity Input System for keyboard and on-screen button controls

Challenges we ran into

Coordinate mapping was the hardest problem. Translating a falling block's pixel X position into the correct register array index required careful math between Unity's local coordinate space and the play area bounds. Supporting variable block widths from 1 to 4 bits meant that spawn position, movement clamps, landing detection, and gate alignment all had to adapt dynamically from a single size value.

Gate-dependent win conditions added complexity we didn't anticipate. AND wants all 0s while XOR and NAND want all 1s, so the scoring direction, goal display, and win detection all had to branch correctly per gate type.

Double-trigger prevention on landing required a lock delay coroutine to ensure the gate operation fired exactly once per drop without race conditions.

Neither of us had shipped a Unity project before, so we also hit a real learning curve getting the Canvas hierarchy and anchor system to behave, but we got there.

Accomplishments that we're proud of

The moment the mechanic clicked during playtesting—watching someone instinctively start thinking two drops ahead to avoid flipping bits the wrong way—that was when we knew the design worked.

We're proud that:

  • All three gate types feel meaningfully different from each other
  • The truth table sidebar teaches the gate without ever pausing the game
  • The entire game loop fits in one clean, readable script with no outside dependencies
  • We shipped a polished, playable game in under 24 hours with barely any prior Unity experience

Most of all, the CS concept is never explained anywhere in the game. You just feel it.

What we learned

Unity's anchored position system behaves very differently depending on pivot points, and getting that wrong early costs hours of debugging.

Supporting variable block widths taught us to think carefully about how a single parameter change ripples through an entire system, something that felt directly relevant to real software engineering.

On the design side, the best educational games don't teach by explaining. They teach by making the wrong answer feel wrong. Every time you accidentally flip a bit away from the goal, you understand the gate better than any textbook ever could.

What's next for Bit Blast!

  • More number bases: we want to expand past binary into hex, octal, and even ASCII. This would be especially effective at teaching bit masking, which is essential to the principles of computer architecture
  • Two-player mode: both players share the same register but drop their own blocks, mixing cooperation with accidental sabotage
  • World progression: each world introduces one new gate with levels designed to teach it through play, building from basic gates through bit masking and two's complement arithmetic
  • Mobile support: touch controls so you can learn boolean logic anywhere, not just at a desk

Built With

Share this project:

Updates