## Inspiration
Every major stadium shares the same unsolved problem, and it isn't the stadium. Sixty to ninety thousand people arrive over three hours and leave in one. Between the venue and wherever they came from — a rail station, a remote parking lot, a freeway exit — lies a one-to-two-mile corridor that is somebody's neighborhood and home to local small businesses. Cities plan the venue, and cities plan the transit line, but almost nobody plans the last mile for everyone who uses it at once. Spectators, residents, and shop owners want fundamentally incompatible things, and planners lack a shared surface to make those tradeoffs visible.
We used the Rose Bowl (LA28 Olympic football) as our default scenario: a ~90,000-seat venue with no direct rail station, where fans bridge the gap from Metro's Memorial Park Station through the residential streets of the Arroyo Seco and past Old Pasadena's storefronts. That local tension inspired a general, venue-agnostic planning instrument — one you could hand to a city planner, drop onto a community-meeting table, or just as easily point at a downtown arena on the other side of the country.
## How we built it
We started our four-person, six-hour sprint by locking a shared TypeScript contract
(lib/sim/types.ts) in world metres centered on the venue, before anyone wrote feature
code. All screen-pixel conversion lives in exactly one file, lib/transform.ts, and the
network builder + simulation engine are pure, deterministic functions with a seeded RNG —
no server round-trip, so dragging a piece stays at 60 fps and scorePlan() recomputes the
weighted score from existing metrics without re-simulating.
From that frozen core we built outward in every direction a planner might actually want
to touch the plan from. The mouse-and-SVG planner (PlanCanvas, WorldLayer,
PieceLayer) came first. Then a physical tabletop mode reading printed ArUco markers via
two-point calibration. Then we went further and built a plain-playing-card recognizer from
scratch — contour outlining, perspective-normalized appearance matching, cosine similarity
— so a planner can enroll an ordinary deck instead of printing anything. Then hand-gesture
control: MediaPipe tracks palm landmarks in the browser, and ratios of palm span (never raw
pixels) drive pinch-to-grab, two-hand rotation, and a fist-hold to recenter — no markers, no
camera rig, just a laptop webcam.
The feature we're proudest of sits on top of all of it: a real-time voice advisor (built on ElevenLabs' conversational agent SDK) that a planner can simply ask "where should this go instead?" We made one hard design rule for it: the LLM parses intent and narrates, but it never invents a coordinate. When asked for a better spot, it sweeps real candidate positions through our actual simulation engine and reports what the engine found — so every number the advisor says out loud is one we actually computed, not one a language model guessed.
## Challenges we ran into
Local-contrast beat brightness. Our first card detector used one global brightness threshold to find card edges. On real phone photos of cards on a table — with glare and a pale grey surface — it found nothing: a white card on a pale table doesn't split into two brightness classes. We rebuilt the outline step around local contrast instead (a pixel darker than its own neighborhood, not darker than some global cutoff), unioned across two window sizes, and went from outlining zero of nine real cards correctly to all twenty-one card instances across nine real photographs.
A pinch is not a fist. In a closed fist, thumb and index fingertips are touching too, so the raw pinch distance alone can't tell a grab from a reset gesture. We added a second discriminator — fingertip-to-wrist distance — and two separate thresholds for "pinch started" versus "pinch released," because a single threshold sits exactly where camera noise lives and the gesture flickers on and off several times a second without it.
SVG and three.js disagreeing about whose rotation wins. Framer Motion writes its
spring animation as an inline CSS transform, and a CSS transform silently overrides an
SVG element's own transform="translate(...) rotate(...)" attribute — so an animated
piece would snap back to the canvas origin the instant it moved. The fix was nesting the
animated motion.g inside a separately-positioned outer <g>, so the two transforms never
compete for the same node.
Honesty under a 200ms budget. We set ourselves a 200ms simulation budget early and mostly hit it — but stacking resident routing, card recognition, and vision processing together pushed several of our own measured runs to 300-450ms. Rather than quietly raise the target or claim a number we hadn't measured, we logged every real timing we saw and kept the gap visible. The same discipline applied to the physical demo itself: our card recognizer is validated against nine real photographs with real glare, not a live camera feed, and we say so plainly rather than let a working software demo imply more than it has actually proven.
## What we learned
Frozen contracts unlock parallel velocity. Spending our first twenty minutes locking
types.ts and folder boundaries let four people build the simulation engine, the
interactive planner, the vision/gesture inputs, and the voice advisor in parallel without
a single merge collision over shared state.
Plausible topology beats geographic perfection. Abstracting the corridor into a metre-accurate but synthetic road network — instead of tracing a real street map — saved hours of data cleanup and kept every hour of the hackathon pointed at the actual question: what does this tradeoff do to the people who live here, not whether we drew the right street correctly.
Built With
- next.js
- react
- tailwind
- typescript
