GECOWAVE: The Flux of Coscience

A world that is generated, then played

I didn't want to place a thousand rooms by hand, and I didn't want a generator that only looks right. Each chapter is written as a sequence: where the story happens, where the bosses and the secrets go. An offline generator lays that sequence out as a region of rooms, using its own model of how far the gecko can jump.

A model can be wrong, so it doesn't get the last word. A simulated gecko does, with the same physics as the game, the same collisions with the tiles and the same controls as the player. From the spawn it tries every walk, drop and jump from every place it can stand. A region ships only if the exit and every part of the story are within reach and no pit traps you. Ability gates are checked twice: a reward you can see early must be out of reach with that chapter's abilities, and within reach with the ones that come later.

The same game on every screen

The logic runs in fixed steps of 1/60 of a second, whatever the monitor does. At 60, 120 or 144 Hz the jumps reach the same height and the fights keep the same timing, and a slow frame never turns into a faster gecko. On top of that sits the movement the genre expects: some grace after you run off a ledge, a jump pressed slightly early that still counts, a slide that nothing can hit, and a downward strike that bounces you off enemies.

A cast drawn by code

The backgrounds are painted. Everything that moves is drawn by code. Enemies, bosses, characters and passers-by come out of a small ink toolkit: shaky outlines, cross-hatching on the side away from the light, stippling. All of it is seeded, so a creature is drawn the same way every time. Each sheet gets a normal map derived from its silhouette, so the lights in the level really shape it, and an emissive layer that keeps the eyes glowing in the dark. Textures are drawn at twice their size and scaled down, so a boss stays sharp when it is scaled up.

Memories shot as films

The flashbacks are not videos recorded somewhere else. They are short films the engine shoots live from a script: a set, a time of day, a cast on their marks, props, and a list of shots. Every shot has a length, a camera with its framing and an optional move, a shallow focus for close-ups, and gestures timed to the millisecond: walking, turning, nodding, handing over an object, saying a line, switching on a screen, dimming a light. The film plays in its own scene, in sepia, letterboxed, with grain and the actors' shadows on the wall, while the game waits underneath.

Two players, one world

Co-op runs over the internet, peer to peer. I split authority by what each player feels most. You own your gecko, so your movement never waits for the network. The host owns the world: enemies, bosses, projectiles, drops, the story and the save. When the guest hits something, it sends a request and the host settles it.

A game that replays itself

A game this size breaks where nobody is looking. So I built a harness that runs the real build in a headless browser with a fake clock and seeded randomness: the same input always produces the same game, down to the bit. On every frame a probe records a fingerprint of everything you could observe, from the gecko and the bosses to the lights, the sounds, the interface and the save.

On top of that sit 200 scenarios: every chapter from its entrance and from its save, every ending, the fights, the systems, recorded key tapes, and a bot that plays the whole campaign from start to finish. A change that shouldn't alter the game has to produce identical traces. When two traces differ, the harness names the first frame where they split and the source line that caused it.

Out on three systems

The game is wrapped in Electron and built natively on each operating system. Pushing a version tag builds the Windows installer, the macOS disk image and the Linux AppImage in CI and publishes them as a release. That release is where the download link above points.