Kill the Bit (1975) is a runnable microcontroller simulation example on SensBench — open the wired circuit, inspect the code, and compile real firmware in your browser, no install needed. Last updated Aug 14, 2026.

FREE SIMULATOR EXAMPLE · ADVANCED

Kill the Bit (1975)

This example runs Kill the Bit — the 1975 Intel 8080 front-panel game — on an emulated chip: a traveling bit races across eight LEDs and you flip switches to stop it. The original assembly source, executed instruction-for-instruction.

▶ Open in the Simulator
Board Programmable Z80 chip (Zilog Z80, standalone — no Arduino)
Difficulty advanced
Category games
Libraries None — just the Arduino core
Runs in Sensbench browser simulator — free, no account
Kill the Bit — the 1975 Intel 8080 game running on an emulated chip in the Sensbench simulator

The exact circuit you get when you open this example — already wired, ready to run.

The sketch

 Kill the Bit -- Dean McDaniel, May 15, 1975. Public domain.
;
; The classic Altair 8800 front-panel reflex game adapted to SENSBENCH.
; A single LED walks across the 8 LEDs; press the matching button at
; the right moment to "kill" the bit. Miss, and an extra bit lights up
; next pass. Get all bits out to win.
;
; This file is the ROM image for the programmable i8080-cpu chip. Click
; Compile to assemble it (calls /api/compile-rom on the backend), then
; click Run to start the 8080 emulator.

        ORG 0x0000

        LXI  SP, 0xBFFF      ; stack at top of RAM
        LXI  H, 0x0000       ; delay accumulator
        MVI  D, 0x80         ; D = bit pattern (start: LED7 lit)
        LXI  B, 0x0E00       ; delay step

beat:
        DAD  B               ; loop ~18 times per visible frame
        JNC  beat

        ; One tick: show pattern + sample buttons + advance bit.
        MOV  A, D
        STA  0xC000          ; LED port

        LDA  0xC003          ; button bitmap
        XRA  D               ; matching bits cancel
        RRC                  ; rotate right
        MOV  D, A

        JMP  beat

How it works

The emulated 8080 runs the original Kill the Bit program: a lit LED travels left across the bus, and the player flips switches to place a wall in its path. A successful intercept lights the win pattern and the bit restarts. The entire game is port I/O — switches in, LEDs out, nothing else.

The assembly source (killbits.s) is the real historical program, viewable in the chip’s editor. The game’s speed is set by instruction-counted delay loops, which is why it feels exactly like the 1975 original — the emulator executes the same instructions at the same relative rate.

Before you build it for real

The game’s timing is instruction-counted, not clocked: the bit travels at whatever rate the emulated CPU executes NOP loops, so the difficulty is historical rather than tunable. The switches are port-mapped and un-debounced — the original hardware had the same characteristic, and a slow flip mid-travel simply misses. This is a game about polling discipline: the program reads the switch port every loop iteration, and the window to intercept is exactly one travel step — the same reaction-time constraint the 1975 players felt.

Related examples

Intel 8080 Banner StreamerRun in simulator →Intel 8080 Button CounterRun in simulator →Z80 Comet ScannerRun in simulator →

FAQ

What is Kill the Bit?

The classic 8080 demo game from 1975: a bit travels across eight LEDs and the player flips switches to intercept it — kill the traveling bit before it reaches the end. It was the original showpiece for the Altair 8800’s front panel, and it runs here on an emulated 8080 with the same I/O model.

Why is the game in assembly?

Because that is how it was written in 1975: killbits.s is the assembly source, assembled to machine code the 8080 executes. The game’s timing comes from instruction counting, not timers — the 8080 has no timer peripheral, so the bit’s travel speed is literally a loop of NOPs.