Oven Roadmap

Design goals

• Lightweight and portable. Keep the browser runtime lean. Projects can take only the modules they need, pin dependencies locally, and build on another machine from the same source.
• Designed for agents and people. Make APIs, game boundaries, and supported commands discoverable. An agent should be able to open a project, find the right engine version, run the game and its bots, and understand failures from the reports.
• Accessibility by default. Make colorblind readability, subtitles, and sound captions work across 2D, 3D, and mixed scenes. The goal is zero extra game-specific implementation when a project uses Oven’s standard UI, dialogue, and audio hooks.
• Deterministic and lightweight. The same starting state and inputs should produce the same gameplay results across supported platforms, from local play to bots, replays, and multiplayer. Games load the physics and networking modules they use.

Up next

• Game launcher and doctor. Let an existing game find its pinned runtime and local Oven tools. Add a one-command starter that opens a playable game with a ready signal and starter bot. The read-only doctor gives specific fixes for a missing engine, browser, SDK, signing setup, or config.
• Possible second smoke scenario. Run MFK’s HOME camp camera scenario with the same browser runner Age Ray uses. MFK owns the camera expectations and can continue using Three.js.

Feature inventory

Rendering and game runtime

• WebGL2 renderer. Scene hierarchy, meshes and materials, directional shadows, render targets, frustum culling, instancing, and mipmaps.
• Spatial tools. Triangle picking, independent draw and pick policies, camera occlusion helpers, and orbit and touch controls.
• Core building blocks. Seeded procedural geometry, fixed-step loop, texture and image loading, and save and backup helpers. Games own their save schemas and mechanics.

Audio and accessibility

• Audio hooks and procedural sound. Games trigger named sound events through a common hook. Oven handles volume groups, limiting, ducking, voice limits, and playback of generated sounds, recorded samples, and loops.
• Spatial audio. Camera-relative sound sources and directional captions for labeled cues, including when effects are muted.
• Procedural and adaptive music. Code-built instruments and recorded stems share a beat clock. Gameplay events can change layers, mixes, songs, tempo, and stingers.

Determinism and multiplayer

• Determinism. Fixed-tick simulation contract, deterministic math, input frames, state hashes with field-level diffs, replays, and tick self-checks.
• Peer-to-peer multiplayer. Oven ships lockstep with rollback, automatic away mode, and transports for local testing, direct WebRTC, and its deployed relay. Games opt in through the deterministic simulation contract. Multiplayer guide

Development and releases

• Pinned engine updates. Preview, apply, roll back, and upstream game-side fixes. Manifests record exact engine commits and per-file hashes.
• Source control and local iteration. Git tracks project history. Oven adds folder snapshots, hot reload, and an optional live-engine overlay for development.
• Live update UX. Build stamps and a themed dev menu. Players can accept or defer an available update.
• Bot testing. Headless Chrome checks readiness, advancing frames, blank screens, console errors, and game-owned assertions. Age Ray’s local River bot exercises checkpoint reload. Oven also runs a quick multiplayer check for games that opt in. Smoke runner
• Generated documentation. The module catalog and API reference follow runtime exports, consumers, and examples. Module catalog

Analytics

• Available on main. Native collection for sessions, play time, errors, frame hitches, and update adoption, with a dev-menu view and game-defined events.
• Storage. Local folders and S3-compatible storage are implemented. The Drive API adapter has fixture coverage. Analytics guide

Later

Games and rendering

• 2D games that feel like living inside a frame. Author foreground, playfield, and background layers once. On a flat screen, camera movement produces parallax and makes the frame feel like a window into the world. In XR, head motion reveals real depth between the same layers.
• Native XR and AR passthrough. Support immersive VR and AR alongside flat-screen play. In passthrough, drop layers marked as backdrops so the framed 2D world can sit in the player’s real room. Support first- and third-person 3D as well as layered 2D.
• Portal-linked spaces. Carry views, physics, picking, audio, and camera through portals, including XR comfort.
• Native deterministic physics. Build Oven’s own fixed-tick physics for 2D, 3D, and mixed games. Collision results and physics state should agree across supported machines and support snapshots, replays, and rollback. Keep Jolt available as a pluggable physics backend.
• Renderer backends. Keep Three.js available as a pluggable renderer and add features such as spotlights, fog, tone mapping, and eventually WebGPU.

Accessibility across 2D and 3D

• Colorblind readability. Provide shared palette controls and pair color with shape, symbols, or text for engine-owned indicators. Use the same settings across 2D, 3D, and mixed scenes.
• Subtitles and sound captions. Reuse the dialogue text, speaker, and sound cue labels already supplied through standard engine hooks. Oven handles presentation and player settings, including when sound is muted.
• Spatial captions. Use existing emitter positions and the active view to show where a sound came from. Use screen-relative directions in 2D and listener-relative directions in 3D, with a consistent presentation when the two share a scene. The same cue can be spatial without a separate caption hookup.

Content, deployment, and tools

• Music resynthesis. Rebuild recordings as editable synth arrangements. Age Ray and MFK soundtracks are the first targets.
• Cross-platform builds. Build the same project for the browser, a self-contained offline web file, a universal Android APK, desktop for Steam, and an iOS shell. The game should be web-playable, with shared build stamps across its exports.
• Lightweight website builder. Reuse Oven modules for interactive sites and web games, with each project loading only the pieces it needs.
• Authoring and diagnostics. Performance HUD and frame history, resource lifecycle and leak checks, narrative rules, shared config, generated constants, and portability checks.
• Effortless multiplayer setup. Let players join peers directly or use lightweight matchmaking to find a session. Matchmaking handles discovery and connection setup. Both entry paths use the same deterministic simulation and rollback.
• Automated nightly tests. Run game-owned bots, browser smoke scenarios, and applicable multiplayer checks on a schedule. Tie reports to the build and surface failures with enough context to reproduce them.

Tooling to borrow from Cartridge

Cartridge is a reference for these workflows. Use its current Drive source to compare behavior while designing Oven’s own tools. Cartridge project folder

• Build, run, and publish. Stage one portable web build for each set of exports. Add installable web apps, device install and launch with a device picker, and adapters for destinations such as itch.io, Steam, and Google Play. Keep local builds separate from explicit publishing, with build profiles, signing checks, and visible job logs.
• Platform services. Give games one optional interface for sign-in, achievements, stats, leaderboards, cloud saves, overlays, and purchases. Use an in-memory adapter for tests and report unavailable capabilities on each platform. Keep platform responses outside the deterministic tick.
• Testing tools inside the dev menu. Start or cancel quick and full bot runs, see the latest result, and offer opt-in runs on save. Give smoke tests a phone viewport, real input, screenshots, and an offline mode that reports unexpected network requests.
• One simulation fingerprint. Stamp the declared simulation code and its dependencies into builds, bot reports, replays, and multiplayer handshakes. Include runtime modules injected by the host so a stale report or mismatched peer is easy to identify.
• One input contract. Map keyboard, pointer, touch, gamepad, and XR to the same input frames that bots, replays, and multiplayer use. Compare that behavior across export targets.
• Portable project setup. Validate a shared game config, generate constants from it, and keep machine paths and SDK settings in a local overlay. Resolve secrets by name, check credentials stay out of build artifacts, and report engine code that depends on game-specific settings.
• Agent tools for existing games. Provide repo-local operating rules and a read-only extraction planner that identifies engine candidates, import dependencies, and blockers. Give agents and people the same local commands and reports.
• Hot reload diagnostics. Show whether a phone or browser is connected to the dev server. Keep play state on reload, surface syntax errors, and let compatible assets update in place.

Parked

• Remote engine controls. A phone-friendly control plane for running approved engine operations. Revisit when remote access needs go beyond the current Mac workflow.
• Jam mode. Co-develop on one branch with live edits, shared snapshots, and conflict preservation. Each person keeps control of their commits. Revisit when a second person needs it.