This is a submission for the June Solstice Game Jam.
What I Built
I built Solstice Leap, a 3D browser arcade game where a glowing sun leaps across floating daylight platforms before the day fades out.
The game starts with a very simple input: hold to charge, release to jump. From there, each run becomes a small timing puzzle about reading distance, managing daylight, and choosing how far to push the streak. The player lands on normal platforms, prism boosts, shadow tiles, moving ledges, and binary tape platforms that write bits into a Turing-inspired protocol.
Live game: https://huanglianggit.github.io/solstice-leap/
Source code: https://github.com/huanglianggit/solstice-leap
Video demo: Watch the 34-second MP4 demo
Video Demo
The demo shows the opening run, distance-based jumping, binary tape platforms, prism boosts, and the first protocol transition from Dawn Tape into Prism Relay.
Direct video link: solstice-leap-demo-short.mp4
How It Fits the Theme
The solstice theme is built into the core loop rather than only the visuals.
The player is literally carrying a sun across the longest day. Daylight acts as the run timer, and every jump either preserves, restores, or drains that light. Prism platforms restore daylight, shadow tiles make survival harder, and the color palette shifts around warm sunlit platforms against a darker evening world.
I wanted the game to feel like a tiny ritual of keeping the day alive: charge, leap, land, recover light, and keep moving before sunset catches up.
Gameplay
Solstice Leap is intentionally readable at first, but it adds pressure through platform variety and protocol goals:
- Daylight platforms are the baseline landing targets.
- Prism boosts restore daylight and reward momentum.
- Binary tape platforms write the current protocol bit.
- Shadow tiles are smaller and drain daylight.
- Moving ledges appear later and add timing pressure.
The player scores more for clean center landings and for building streaks. If a jump is undercharged but the sun still lands on the original platform, the run continues. The player only loses when the sun actually falls between platforms or daylight runs out.
How I Built It
The game is a static web project built with:
- HTML
- CSS
- JavaScript
- Three.js
- Web Audio API
The 3D scene is rendered with Three.js. I used simple geometry, custom materials, canvas-generated textures, lighting, shadows, particle trails, and platform animations instead of external art assets.
The jump system is based on charge duration. A held input maps to travel distance, and the landing check compares the final position against the target platform and the original platform. That made the game feel more fair: a tiny hop that stays on the same pillar is not treated as a miss.
The protocol system generates binary platforms in sequence. Landing on a binary platform writes the next bit into the active tape. Completing a tape advances the run into the next named protocol, starting with Dawn Tape and then moving into Prism Relay, Turing Noon, and Longest Day.
I also added responsive HUD layout, local best-score storage, touch-friendly controls, and a GitHub Pages deployment so the game can be played directly in the browser.
Prize Category
I am submitting this for Best Ode to Alan Turing.
The game uses protocol names, binary tape, deterministic bit targets, and tape-writing platforms as a playful arcade interpretation of computation. The player is not only jumping across platforms. They are also helping a tiny sun-powered machine write and complete binary sequences before daylight runs out.
What I Learned
The most interesting design challenge was balancing a one-button arcade game with enough structure to feel fresh. A pure jumping game became much more interesting once the platforms also carried meaning: daylight recovery, risk, binary progress, and protocol transitions.
I also learned that small fairness details matter a lot. The jump should only fail when the player truly misses the platform, not when they make a harmless hop in place. Fixing that made the controls feel more trustworthy.
What's Next
If I continue developing Solstice Leap, I would like to add:
- A sound toggle and richer landing sounds
- More protocol variations
- A few visual transitions between dawn, noon, and sunset
- A leaderboard or shareable run summary
- Optional mobile haptics for jump charging and landing
Thanks for checking it out.
Top comments (1)
The binary tape platforms are a smart way to bring the Turing angle into the actual run instead of leaving it in the write-up. I also like the simple hold/release input because it makes the game readable quickly. One thing I would add is a short example of what a successful tape sequence means in-game, since that is the most distinctive mechanic and deserves to be understood immediately.