How I Built a Turing inspired Treasure-Run Game Where Australia Saves the Sun

This is a submission for the June Solstice Game Jam What I Built For this game jam, I...

This is a submission for the June Solstice Game Jam

What I Built

For this game jam, I built Dawn Dashers, an adventure runner set during the June Solstice, the longest night of the year in Australia.

The idea started with a simple question:

What if the longest night didn't end?

In Dawn Dashers, a rogue machine called the Turing Engine has stolen the sunrise and scattered seven Sun Fragments across Australia. Players race through deserts, bushland trails, coastal cliffs, and hidden ruins to recover the fragments and bring daylight back.

The game takes inspiration from the June solstice, but with an Australian treasure-hunting twist. Along the way, players dodge obstacles, collect relics, unlock animal abilities, and solve quick logic puzzles inspired by Alan Turing.

One thing I wanted to avoid was making the solstice just part of the story. Instead, it's part of the gameplay itself. At the start, the world is trapped in darkness. As players recover Sun Fragments, the environment gradually becomes brighter, warmer, and more alive until the final sunrise returns.

The goal was simple:

Build something fun first, while using the June Solstice as the heart of the adventure.

Video Demo

{% embed https://youtu.be/x-U4mGISDJw %}

You can also try:

• Running through the Australian Outback
• Discovering treasure clues
• Solving Turing-inspired logic challenges
• Collecting Sun Fragments
• Unlocking animal abilities
• Watching the world transform from the longest night back into daylight

... directly through the deployed game (using Vercel) {% embed https://dawn-dashers.vercel.app/ %}

Code

GitHub Repository

Built with:

• Vanilla JavaScript — game.js is the entire game engine (~6500+ lines)
• Three.js — 3D terrain rendering behind the 2D gameplay HUD
• Web Audio API
• HTML/CSS — index.html, inline UI modals, HUD
• GitHub Copilot

How I Built It

I started by focusing on the core gameplay loop:

Run → Dodge → Collect → Discover → Restore Light

Once movement felt fun, I started layering in everything else.

Making the Solstice Matter

The biggest design decision was making the June Solstice an actual game mechanic rather than just background lore.

The game begins during the longest night of the year. Every Sun Fragment recovered pushes the world closer to dawn.

As players progress:

• Darkness slowly recedes
• New areas become visible
• Lighting becomes warmer
• The world feels more hopeful

By the end of the game, the player has literally restored the sunrise.

Building an Australian Adventure

Rather than using generic fantasy locations, I wanted the game to feel distinctly Australian.

The adventure takes players through:

• Outback ruins

• Bushland trails

• A quirky roadside servo

• Coastal lighthouse cliffs

• Mangroves

• Blue Mountains

• Nullarbor

• Observatory

• Aurora-lit Tasmania

Each region introduces new obstacles and visual themes while keeping the action moving.

A Nod to Alan Turing

Since June is also Alan Turing's birth month, I wanted to include a tribute without turning the game into a history lesson.

The game's antagonist, the Turing Engine, believes that endless night is the most logical state of existence.

Players encounter quick puzzles based on:

• Pattern recognition
• Binary switches
• Signal routing
• Light circuits

The puzzles are short and designed to support the action rather than interrupt it.

TM Corridors — Turing's Run

At three points in the expedition, the world stops being a runner and becomes a Turing Machine you operate by hand. The level fades away and you step into a glowing sci-fi corridor rendered in one-point perspective — a hallway that is the tape, charging toward a vanishing-point portal.

The story is told in three chapters, framed as Alan Turing bypassing three sealed gates:

Art Direction

One of the biggest pivots during development was moving away from a bright arcade aesthetic and leaning into a treasure-hunting adventure style.

The world uses:

• Warm desert colours
• Ancient ruins
• Dust particles
• Golden sunlight effects
• Treasure-map inspired UI

This direction helped tie together the themes of the solstice, exploration, and treasure hunt.

Technology

The game was built using:

• Vanilla JavaScript — game.js is the entire game engine (~6500+ lines)
• Three.js — 3D terrain rendering behind the 2D gameplay HUD
• Web Audio API
• HTML/CSS — index.html, inline UI modals, HUD
• Vercel Deployment
• GitHub Copilot for development acceleration

The focus throughout was on keeping the project lightweight, responsive, and playable directly in the browser.

Prize Category

Best Ode to Alan Turing

Dawn Dashers is a love letter to Alan Turing, the mathematician, codebreaker, and father of Theoretical computer scientist who was born on 23 June 1912.

Rather than focusing on historical events, I wanted to celebrate the ideas that made his work so influential: logic, patterns, problem-solving, and computation.

The Turing Engine serves as the main antagonist, and players overcome its challenges through quick puzzles inspired by computational thinking.

P.S. For fellow nerds (like me 😄), each puzzle comes with a little extra bit of knowledge. Just click "Learn why this puzzle matters".

In the characters

The 27 playable dashers are all Australian animals and each character's power and quirk are inspired by concepts from Turing's work:

• Emu — relentless forward motion (Turing's unstoppable curiosity)
• Wombat — burrow-dodge (evasion, steganography)
• Echidna — spiny defence (cryptographic hardening)
• Cassowary — apex predator speed (Colossus, the world's first electronic computer)

The "special" dashers can only be unlocked by solving enough treasure puzzles — a direct nod to the idea that Turing's deeper insights were hidden behind layers of prior work.

In the Game engine

The game's lifecycle is modelled as a real Turing Machine (see Architecture below). States are labelled q_*, input symbols σ_*, and every transition is written to a tape with a head that advances R, stays S, or — on a level abort — rewinds L. This isn't just a metaphor: the implementation is a literal δ(q, σ) → (q′, dir) transition table.

┌─────────────────────────────────────────────────────────────────────┐
│  Browser                                                            │
│                                                                     │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │  game.js  (core)                                             │   │
│  │                                                              │   │
│  │   Run loop / input                                           │   │
│  │        │                                                     │   │
│  │        │  sendFlow(σ_*)        ┌─────────────────────────┐   │   │
│  │        ├─────────────────────► │   game-state.js         │   │   │
│  │        │  ◄── state flags ──── │                         │   │   │
│  │        │                       │   Turing Machine        │   │   │
│  │        │                       │   Q  states  (q_*)      │   │   │
│  │        │                       │   Σ  symbols (σ_*)      │   │   │
│  │        │                       │   δ  transition table   │   │   │
│  │        │                       │   tape[]  head ptr      │   │   │
│  │        │                       └─────────────────────────┘   │   │
│  │        │                                                      │   │
│  │        ├── Puzzle pick & dedup ──► puzzle-tracker.js          │   │
│  │        │                               │                      │   │
│  │        │                          puzzle-filter.js            │   │
│  │        │                               │                      │   │
│  │        │                          puzzle-data.js              │   │
│  │        │                          ├── questions-easy.js       │   │
│  │        │                          ├── questions-medium.js     │   │
│  │        │                          └── questions-hard.js       │   │
│  │        │                                                      │   │
│  │        ├── Three.js + Canvas render                           │   │
│  │        │        └── terrain-styles.js                         │   │
│  │        │                                                      │   │
│  │        └── Config reads                                       │   │
│  │             ├── character-config.js                           │   │
│  │             ├── game-data.js                                   │   │
│  │             └── game-settings.js                              │   │
│  │                                                               │   │
│  │  game-ui.js ──ctx callbacks──► game.js                        │   │
│  └──────────────────────────────────────────────────────────────┘   │
│                                                                     │
│  index.html  (loads all modules via <script> tags)                  │
└─────────────────────────────────────────────────────────────────────┘
         ▲
         │  served by
┌────────┴────────┐
│  Nginx (Docker) │
│  docker-compose │
└─────────────────┘

Best Google AI Usage

I'm also submitting for Best Google AI Usage.

I'll be honest: I'm much more comfortable building systems and writing backend code than designing beautiful interfaces.

One of the challenges during this project was figuring out how to make Dawn Dashers feel cohesive visually. I had a rough idea of the atmosphere I wanted—an Australian treasure-hunting adventure, but translating that into colours, layouts, typography, and UI design isn't my strongest skill.

That's where Google Stitch helped.

I used Stitch to explore rapidly:

• UI layouts and screen structure
• Menu and HUD designs
• Colour palettes
• Typography combinations
• Visual hierarchy
• Overall art direction

What impressed me most was how easy it was to iterate. Instead of spending hours moving elements around in a design tool, I could describe the feeling I wanted and quickly generate multiple directions to evaluate.

For example, I started with a fairly generic arcade-style look, but through a few iterations in Stitch, I landed on a much stronger visual identity built around:

• Warm desert colours
• Treasure-map inspired UI
• Gold accents
• Weathered parchment styling
• Adventure-game aesthetics

Those explorations directly influenced the final design language of the game.

I also used Gemini extensively during the design phase.

One challenge was incorporating Alan Turing-inspired puzzles without making the game feel like a classroom exercise. I wanted puzzles based on logic, patterns, and computation, but they also needed to feel like they belonged in an Australian treasure-hunting adventure.

Gemini helped me brainstorm and refine puzzle concepts such as:

• Pattern recognition challenges
• Binary switch puzzles
• Signal routing mechanics
• Treasure clues tied to Australian locations and wildlife
• Turing-inspired logic challenges that could be solved quickly during gameplay

For example, I used Gemini to take abstract puzzle ideas and re-theme them into Australian contexts, turning generic logic puzzles into clues involving lighthouses, Outback landmarks, wildlife, and hidden Sun Fragments.

The combination of Stitch and Gemini helped bridge two areas where I typically spend a lot of time: design exploration and content creation. Instead of starting from a blank page, I could rapidly iterate on ideas, evaluate options, and focus more of my time on building and polishing the game itself.

The AI tools didn't replace the creative decisions—they helped me reach better ones faster.

As a solo developer, having a tool that could help bridge the gap between "I know what I want it to feel like" and "I know how to design it" was incredibly valuable. It let me spend more time building gameplay while still ending up with a much more polished visual experience.

Google Stitch didn't replace the design decisions—it helped me discover and refine them much faster.

Happy Dashing !!!

Thanks for checking out Dawn Dashers 🌅

It was a lot of fun combining the June Solstice, Australian landscapes, treasure hunting, arcade runners, and a small nod to Alan Turing into one adventure.