Dolphin Beyond: how I built a physics arcade game

You control one dolphin. You dive to build speed, launch off the surface, pull tricks in the air and re-enter the water cleanly to keep the momentum going. String it together well and you climb through four worlds — ocean, sky, space and galaxy — across a curved sea-planet.

It is skill-first by design. Cosmetics never change the physics, so a rare skin looks great but flies exactly like the starter dolphin. Around that core there is a meta loop — Pearls, missions, a shop and daily rewards — inspired by the layered goals in games like Subway Surfers, but deliberately without revive spam or any pay-to-win effect on how the dolphin actually moves.

Dolphin Beyond ships as a first-class product on both platforms rather than a port with an afterthought attached:

• Mobile — a native iOS app for iPhone and iPad, built with Capacitor, played in portrait with touch controls.
• Web — playable directly in the browser. Desktop gets a dedicated landscape keyboard build with its own competitive ruleset, while phone and tablet browsers get the same portrait touch experience as the app.

Because the desktop keyboard build plays differently from the touch build, their scores do not mix — each has its own leaderboard so competition stays fair within a single input model.

On mobile the game uses a two-thumb layout. The left half of the screen is an analog vertical pitch control — how sharply you angle the dive. The right half handles the tricks: corkscrew, tailslide and starslide. Pointer ownership is sticky, so if your thumbs drift or cross, each side keeps the action it started with instead of swapping under you.

On desktop web it is keyboard-only, with ramped analog turning so a quick tap still nudges you precisely while a held key builds into a full turn. Either way, the real skill is the same as the original inspiration: angle and timing. Clean entries, a variety of tricks and reading the water beat button-mashing every time.

Dolphin Beyond is a fan homage to Alan Rawkins’ Dolphin Olympics and Dolphin Olympics 2, the classic Flash games. It is not affiliated with or endorsed by the original, and it reuses none of its assets or its name.

To get the feel right I studied the original closely — including its decompiled ActionScript behaviour — to understand what actually made it sing: Nice and Perfect entries acting as the game’s speed economy, the latched water tailslide that pops you into a launch, the timing on a corkscrew, and combo scoring where repeating the same trick pays less each time (the nth repeat adds only 1/n), which quietly forces you to vary your moves.

The shipping game is an independent TypeScript rebuild with all-original art, audio, landmarks and branding. There are no Dolphin Olympics assets in it, and — for trademark and App Store reasons — the product name never contains the word “Olympics”.

The app shell and hub screens are built with Vite, React, TypeScript and Tailwind CSS — the same modern, mobile-first toolchain I use across my other apps and products. The game itself does not lean on that, though.

• Hand-rolled physics. No Box2D or Matter.js — every rule is my own, and every constant lives in a live tuning table I can adjust and re-test.
• Capacitor for native iOS. It has to feel native, so there are haptics, audio that respects the mute switch, a safe-area HUD, no white flash on launch, and a fixed camera field of view so taller phones can’t get an unfair scoring advantage.
• Firebase. Auth, Firestore and Cloud Functions power accounts, verified runs, leaderboards, the Pearls economy and over-the-air live updates.
• One codebase, different shells. The portrait chrome for phone and iPad and the dedicated landscape hub for desktop are two presentations of the same core.

The constraint I cared about most is determinism: the same seed plus the same inputs must produce an identical outcome, forever. The game uses a seeded pseudo-random generator only, and a fixed physics timestep. That single rule is what makes ghosts, daily seeds, replays and automated tests even possible.

• A pure engine. It is plain TypeScript that imports nothing from React, Firebase or the UI, so it can run headless in Node.
• Read-only rendering. The canvas reads game state and never writes it, and there is no per-frame React — the game loop owns the mutable state and the UI subscribes at a low throttle.
• Golden replays. Fixture files store a seed, the inputs and the expected score, and the sims assert an exact match. Balance is measured with seeded bot sweeps rather than by vibes.
• Verified scores. Before a leaderboard score is accepted, the server replays the submitted input stream and checks the result — so a posted score has to be reproducible, not just claimed.

The dolphin has a clay, cartoon identity. Master sprites start as AI-generated images and are then packed into atlases, but most of the animation is procedural — squash and stretch, the face, blinks hashed off the game tick — which keeps it consistent and, crucially, deterministic.

The corkscrew is the exception that proves the rule: instead of flickering AI pose frames it uses a baked 24-frame roll atlas rendered from 3D meshes in Blender. The space vista, the splash, boosters and emblems are generated and baked offline too, with procedural fallbacks so the game still runs even with zero art assets loaded. All the juice — haptics, combo VFX, the rolling score counter — is presentation only. It never touches the simulation, so it can never break determinism.

There is more to do than a single endless dive:

• Modes. Classic ascent, Slipstream (a distance mode) and a Levels campaign that works as a booster-free skill ladder.
• Economy. Earn Pearls during a run and for verified runs, then spend them in a shop on skins and boosters. There is a mystery chest, missions, a daily ladder, a Planet Hunt and achievements.

The server verifies runs before awarding currency or unlocks, which keeps the economy honest and ties directly back to the deterministic engine underneath.

I built Dolphin Beyond as a solo developer, leaning heavily on AI coding agents — but under hard project rules: a file map, a decisions log, and explicit iOS and desktop contracts the agents have to honour.

Agents are allowed to retune the physics and the feel, but they have to prove determinism with the sims and re-bless the golden fixtures whenever an outcome changes on purpose. The final judge is never a test alone — it is how the game feels under real thumbs on a real device, and under a real keyboard on the desktop build.