Five broken pixel games where exploiting the glitch is the only way to win.

Built for the GLITCHED GAMES hackathon. Every mode is a different retro genre that looks unbeatable until you discover and abuse its built-in glitch — flip gravity, phase through walls, clip an invisible wall, read an inverted world, or slip time.

Runs entirely in the browser. Keyboard (WASD / arrows) and full on-screen touch controls for phone & iPad.

Online: open the deployed link (HTML5 export — just open index.html after building).

Local:

npm install --legacy-peer-deps
npm run dev      # http://localhost:2000

Build the HTML5 export for submission:

npm run build    # outputs ./dist  (~0.9 MB, well under the 50 MB limit)

Verify every game is beatable (automated):

npm test         # headless solver plays & clears all 5 games

On-screen controls appear automatically on any touch device (verified to show on iPad, where the G and P glitch buttons are required to finish 3 of the games).

Every game is a long, speed-escalating gauntlet — not a single screen. Death respawns you at the last checkpoint (not the start), and a deaths counter tracks the grind, so each game is hard-but-fair and takes many attempts to clear.

An auto-runner with spikes lining both the floor and the ceiling and open holes in each surface. Speed steps up at every checkpoint. You cannot dodge by jumping.

• Trigger: press Space / W / ↑ while on a surface to flip gravity and fall to the opposite surface.
• Exploit: swap surfaces to dodge spikes — but the floor and ceiling have open-space holes, so flipping into one drops you straight into the void. Reflex flips kill you; the holes demand precise timing, and it gets faster after every checkpoint.

A Geometry-Dash-style runner of short jump-blocks and three tall walls that are impossible to jump.

• Trigger: press G to enter a ghost/phase state (player turns cyan) — the window is short, so it must be timed.
• Exploit: you only get 3 phase charges — one per wall. Each wall is immediately followed by a trap block: you exit the phase and must instantly jump. Mis-time a jump, fumble the short phase, or waste a charge and the next wall is a dead end.

Three escalating Sokoban rooms; clear all three to win.

• Glitch A — clip the wall: the left wall has an invisible gap — walk straight through it. (Press G to peek and reveal hidden walls.)
• Glitch B — crush the crate: shove the crate east into the too-small right gap and keep pushing; after 10 compressions it crushes down and slips through.
• Room 3 makes you combine what you learned.

Neon Dash with the same blocks, walls, and 3 phase charges — but the screen is mirrored vertically (top-to-bottom only, not left-right).

• Trigger: jump + G phase as in game 2, except the view is flipped, so pressing jump looks like it drops you downward. Trust the glitch, not your eyes.

A 3-lane runner (A/D lanes, Space jump) with two overload zones where obstacles arrive too fast to react to — fatal at normal speed.

• Trigger: press P inside an overload zone to slow time.
• Exploit: slow-mo is the only way through each fast cluster, and it has a cooldown — you must save one charge for the second zone.

• React + Vite, games rendered on a single <canvas> (image-rendering: pixelated for the crisp pixel look).
• Pure state-machine game loop — input lives outside React (src/engine/keyboard.js) so nothing is dropped, and the same input path feeds both keyboard and touch.
• Per-game neon palettes, particle bursts, motion trails, screen shake, and animated win/death sequences (src/games/gameRenderers.js).
• Checkpoints & deaths — runner games respawn you at the last checkpoint and count your deaths, so long hard levels stay achievable.
• Automated beatability harness (scripts/test-games.mjs, run via npm test): a headless canvas + scripted solver clears all 5 games every build, and confirms an idle player never wins (so the games are real, not trivially auto-winning).

• Playtime: a flawless speedrun of all five is ~75 seconds, but the levels are long and escalating with real failure — a first-time player learning the flip timing, saving phase charges, and timing slow-mo realistically grinds through ~15 minutes of attempts.
• The win screen uses a Three.js "hyperspeed" effect, which is the bulk of the ~0.9 MB bundle. It's off the pixel aesthetic but kept for flair; it could be swapped for a canvas effect to shrink the build further.
• Audio is not implemented.
• Best experienced in a modern Chromium/Safari/Firefox browser; very old browsers without requestAnimationFrame are unsupported.