Inspiration

Cooking videos show what to do, but not how it feels to do it. A beginner watching one still does not know how hard to crack an egg, how long a flip takes, or when "golden" has arrived. Those are things hands learn, and VR is the one screen that has hands in it.

The printed sheet came from a simple idea: if every ingredient is drawn at its real size, the page stops being a list to read and becomes a place to put things. Setting the table teaches the recipe before the stove is even on.

What it does

Page to Pan is a seated, hands-only VR cooking game for people who have never cooked. A recipe sheet lies on the kitchen table with every ingredient printed as a life-size outline. You place each ingredient onto its outline, the way a careful cook sets everything out first, and then the game walks you through the dish one step at a time.

Each step is a real kitchen motion:

  • Crack an egg by pinching it with both hands and pulling them apart over the bowl.
  • Whisk in circles and tip the shaker to season.
  • Flick your wrist to toss and flip the omelette.

The food changes color on the heat, steam rises, the sizzle changes pitch, and you decide when to lift the pan. A card beside the table says why each step matters, so the game teaches the logic behind the cooking, not just button prompts.

When you serve, you get a score, up to three stars, tips on what to do better, and a short "Try it at home" note on how to cook the same dish in a real kitchen.

  • Three recipes: Omelette (also the tutorial), Nasi Goreng, and Pancake.
  • Chef Exam mode removes the guide rings and tip cards so you cook from memory.
  • Chef rank: your best stars add up from Kitchen Newcomer to Head Chef, and the title card tells you how many stars the next rank takes.
  • Accessible: every step can be read aloud, a high-contrast mode turns cards into light text on black, one pinch holds everything, and on Meta VR Glasses buttons press with a look and pinch.
  • Easy in, easy out: one pinch on Start and the first ingredient is in your hand within about ten seconds. Hold an empty palm up to pause; the game also pauses by itself when the headset is removed.

How I built it

  • Meta Immersive Web SDK (Three.js, an entity-component system). It runs as a web page, so it opens from a link in the Meta Quest Browser with nothing to install.
  • Hands first. Objects are held with a pinch, and every gesture is driven by smoothed hand motion: how far two hands pull apart, how many circles a tool tip draws, how far a wrist tips, and how fast it flicks.
  • No asset files. Every model is built in code and all audio is synthesized with the Web Audio API. The game ships no model, texture, or audio files, so it loads fast (about 1.3 MB of compressed code).
  • Recipes are data. A new dish is one data file; the systems that run steps, gestures, cooking, and scoring are shared. Nasi Goreng and Pancake were built on the same systems as the omelette.
  • Scoring is a pure function. Doneness $d$ tracks how long the pan is on the heat, with the sweet spot at $0.7$:

$$\text{timing} = \operatorname{clamp}\left(1 - \frac{|d - 0.7|}{0.7},\, 0,\, 1\right)$$

$$\text{score} = 100 \times \left(0.4\,\text{timing} + 0.4\,\text{seasoning} + 0.2\,\text{technique}\right)$$

  • Tested like software. Scoring and gesture logic are unit-tested (Vitest), and a script plays every recipe from the title to the score in the headset emulator and fails if any step does not advance or the console logs an error.
  • Inside the Quest 2 budget: at most 88 draw calls in the scene, with one directional light and no real-time shadows.

Challenges I ran into

  • Building for a headset I don't own. Everything was developed in the Immersive Web Emulator, where hands never shake. So I designed for noise: a generous 7 cm snap radius, smoothed hand tracking before any gesture is read, every threshold in one tuning file, and a checklist of things to verify on a real Quest.
  • Holding tools like tools. A pinch grabs the whisk by its handle. Early on the whisk head wandered out of the bowl. Now the handle sits in the pinching fingers, leans toward the player like a real grip, and circles are counted at the tool's tip, not at the hand.
  • Flipping an omelette without a physics engine. The toss is a hand-written arc. The first versions clipped through the pan or landed beside it; it took several passes (giving the arc a higher apex, landing it folded in the pan) before a flick felt like a flip.
  • Seated scale. I first placed the table 70–75 cm below head height, like standing over a counter. It now sits 42 cm below the head, calibrated once each time you enter VR.
  • Making everything in code, cheaply. Procedural geometry had to stay under 100 draw calls, and thin layered surfaces had to be fixed so nothing flickered when you turn your head.

What I learned

  • Forgiving beats precise. For a beginner, a wide tolerance feels like skill; a tight one feels like the game is broken.
  • Doneness is a feeling, not a number. Color, steam, and sizzle together let players judge the pan without reading anything.
  • Data-driven design pays off. Nasi Goreng and Pancake reused the exact same systems built for the omelette: new steps, new food, the same engine.
  • You can test XR without a headset, as long as automated scripts play full recipes in the emulator—running full recipes caught regressions that clicking around never would.

What's next

  • Test and tune every gesture on a real Quest, where hand tracking is noisier than in the emulator.
  • More recipes, grouped into short courses that each teach a new kitchen technique.

Target launch date: Playable now at https://pagetopan.voltatile.tech — full release is planned for April 2027.

Built With

Share this project:

Updates

Submission history