This is a submission for the June Solstice Game Jam

What I Built

HELIOS — The Longest Day is a real-time light-routing logic puzzle. On the longest day of the year, sunlight is your only tool: you bend the sun's beam with mirrors, divide it with splitters, and channel it through optical logic gates to wake dormant crystals before the sun sets.

The goal was to fuse the two themes into a single mechanic instead of bolting them together:

• 🌅 Solstice — light is the resource, the sun's arc across the sky is your timer, and dusk is the fail state.


• 🧠 Turing — you literally build computation out of light, gate by gate. The final level has you wire up a working logic circuit to wake "the Oracle" — a machine that thinks.

So it's not light-as-decoration. Light is the gameplay, and logic gates are the core mechanic.

Video Demo

Note: the video has no sound, so here's exactly what you're watching:

• ☀️ A level loads — a sun emitter fires a beam toward a dark crystal


• 🪞 I drag a mirror onto the grid to bend the beam 90°, then click it to rotate
  


• 💎 The crystal lights up green the instant the beam reaches it


• 🔀 Later levels add splitters (one beam becomes two) and logic gates (AND, OR, XOR, NOT, NAND, NOR)


• 🧩 The final level wires up a circuit to wake the Oracle
  


• 🌇 The sky darkens the whole time — that's the daylight clock counting down

▶️ Play it live: https://muhmdusman.github.io/solistice-game/

Code

How I Built It

It's pure vanilla JavaScript + HTML5 Canvas — no frameworks, no build step, and no asset files (even the sound is synthesized at runtime with the Web Audio API). The whole game is a tiny, self-contained bundle.

The interesting technical part — simulating light as a circuit:

A simple beam-tracer is easy. The hard part is that gates can feed other gates, and beams can loop through mirrors. A gate's output depends on its inputs, which may depend on another gate's output. That's not a straight line — it's a circuit.

So the engine iterates to a fixpoint, exactly like simulating real digital logic:

1. Assume every gate is off, trace all beams


2. Re-check each gate based on the light now hitting it


3. Re-trace — repeat until nothing changes (the circuit settles)


4. If it never settles, flag it as unstable instead of hanging
   

// Iterate gate states until the circuit reaches a stable fixpoint.

for (let i = 0; i < maxIter; i++) {

  const next = {};

  let changed = false;

  for (const g of gates) {

    const ports = gatePorts(g.gateType, g.dir);

    const bits  = ports.inputs.map((p) => !!trace.gateInputs[g.id][p]);

    const out   = evalGate(g.gateType, bits);

    next[g.id] = out;

    if (out !== gateOn[g.id]) changed = true;

  }

  gateOn = next;

  trace  = traceBeams(board, gateOn);

  if (!changed) break;       // settled ✅

}

Making the puzzles provably fair: I built the engine to run headlessly in Node, then wrote a brute-force validator that tries every piece placement on all 10 levels and confirms each one is solvable and not already solved at the start. It caught a real bug — one level was accidentally pre-solved before the player touched it.

Project structure:

• 
  js/light.js — the optical simulation engine (ray-tracing + fixpoint gate solver)


• 
  js/levels.js — 10 hand-designed, validated puzzles


• 
  js/render.js — Canvas renderer with animated, flowing beams


• 
  js/sky.js — the animated dawn-to-dusk solstice sky


• 
  js/game.js — game loop, input, scoring


• 
  tools/validate-levels.js — the solvability prover

Prize Category

🧠 Best Ode to Alan Turing

This is the soul of the project. Turing's foundational insight was that computation is substrate-independent — it doesn't matter whether logic is built from relays, valves, or beams of light. HELIOS lets you feel that idea:

• The core mechanic is building working logic gates (including NAND, the universal gate from which any circuit can be built)


• The campaign escalates from "bend one beam" to "assemble a logic circuit"


• The finale wakes the Oracle — a machine that reasons — and the game closes on Turing's 1950 line: "We can only see a short distance ahead, but we can see plenty there that needs to be done."
  


• The horizon silhouette is a nod to the huts of Bletchley Park, where Turing worked

🤖 Best Google AI Usage

I used Google's Gemini as a development collaborator throughout the build:

• I used Gemini to pressure-test the design — talking through how to fuse the solstice and Turing themes into one mechanic rather than two separate gimmicks


• I leaned on it to reason about the trickiest engineering problem: how to correctly simulate logic gates that feed into each other, which led to the fixpoint iteration approach in the engine


• I used it to help shape the headless test strategy and the brute-force level validator that proves every puzzle is fair

Thanks for reading, and happy solstice. 🌞 Built with vanilla JS, HTML5 Canvas, and the Web Audio API. Licensed MIT.