"Recursion" — A Genre-Shifting Browser Platformer

Main Campaign Interface
Guide (How to play?)
Levels

Inspiration

We were inspired by the idea of turning software debugging into gameplay. Most platformers give players a fixed set of rules and ask them to master those rules. We wanted to create something different: a game where players can actually change the rules of the world.

This led to Recursion, a genre-shifting platformer where the player progresses from a normal platforming experience into a programmable debugging environment and finally into a system that is actively collapsing.

What it does

Recursion is a browser-based platformer with three distinct acts:

Act 1 — System Baseline: Players navigate platforms, avoid spikes, fight enemies, collect data fragments, and reach the terminal portal.
Act 2 — Kernel Breach: Players gain access to a CRT terminal and can execute commands such as gravity, spawn platform, and enemy friendly.
Act 3 — System Collapse: The environment becomes unstable, commands can misfire, visual glitches appear, and the player must escape before a 30-second countdown reaches zero.

The terminal is connected directly to the game engine, so commands produce real gameplay changes rather than being cosmetic.

How we built it

We built Recursion as a zero-dependency HTML5 browser game using:

HTML5 Canvas for rendering
Vanilla JavaScript for gameplay and state management
CSS for the interface and CRT/cyberpunk effects
Web Audio API for procedural sound effects and background music

The project is divided into modules for physics, rendering, entities, levels, terminal commands, audio, and game-state management.

We implemented features such as AABB collision detection, coyote time, jump buffering, enemy AI, projectiles, particles, camera tracking, terminal command parsing, dynamic gravity, runtime platform spawning, enemy behavior modification, glitch effects, and procedural audio.

Challenges we ran into

One of our biggest challenges was making multiple systems work together reliably in real time. Physics, enemies, projectiles, particles, audio, terminal commands, and visual effects all need to run smoothly inside the browser.

Another challenge was designing the terminal so that it actually interacted with the game state. Commands needed proper validation and error handling without breaking the game.

Act 3 was especially challenging because we wanted the system to feel unstable while remaining playable. The countdown, screen glitches, command misfires, and corrupted effects all had to create tension without making the game unfair.

Accomplishments that we're proud of

We are particularly proud of creating a complete playable experience without external libraries or assets.

Some highlights include:

A fully playable three-act campaign
Real-time terminal commands that modify gameplay
Dynamic gravity manipulation
Runtime platform creation
Enemy AI modification
Responsive platformer physics
Procedural Web Audio sound effects
CRT and cyberpunk visual effects
Dynamic glitch and screen-shake effects
A timed final escape sequence
Functional menus, pause system, HUD, victory, and game-over states

The biggest accomplishment is that the terminal is not just part of the story—it becomes an actual gameplay tool.

What we learned

We learned how important it is to design a game around a clear core mechanic rather than simply adding features.

Technically, we gained experience with browser game development, Canvas rendering, collision detection, physics, AI behavior, state management, command parsing, procedural audio, and real-time visual effects.

We also learned that debugging a complex interactive system requires careful separation of responsibilities between different modules. Keeping physics, rendering, entities, audio, and game state organized made the project much easier to develop and test.

What's next for "Recursion" — A Genre-Shifting Browser Platformer

The current version establishes the core concept, but there is plenty of room to expand Recursion.

Future updates could include:

More terminal commands and programmable mechanics
Additional puzzle chambers
More enemy types and AI behaviors
Procedurally generated levels
Multiple endings based on player decisions
A level editor controlled through the terminal
Speedrun mode and global leaderboards
More advanced glitch and corruption effects
Save/progression systems
Additional acts exploring completely different game genres

Our long-term goal is to make the player feel like they are gradually moving from playing a game to controlling its underlying code—and eventually surviving when that code breaks.

Recursion: Don't just play the system. Debug it.