Scope date: 2026-10-03. Status: proposed for Elikem’s review. Programme: Oshun V1.x; consumer/product brand: Lilith; engine domains: Maya and Neith; integration domain: Bellona. This is a full release commitment, not a statement that the capabilities are already implemented.
1. The decision this scope proposes#
Make V1.6 the complete living-world engine and game-creation release. Deliver both a competitive engine platform and a finished open-world game that proves it in sustained use. Fully implement every capability family from the Unreal/RAGE assessment: native runtime and graphics, production rendering and animation, coherent simulation, editor and pipeline, multiplayer, audio, supported platforms, SDK/ecosystem, AI authoring and cognition, research capabilities and independently measured production quality.
The release contains 126 mandatory requirements across 24 workstreams. Every listed build obligation and acceptance clause is normative. Milestones sequence the work; none is a substitute for final scope. “Industry-leading” is an evidence-based verdict on declared dimensions against a frozen contemporary benchmark, not a promise to exceed every proprietary capability or all future inventions. The intended outcome is parity across the required platform/game dimensions and demonstrated leadership in integrated living-world continuity, human/agent creative control and measured creation efficiency.
The companion delivery and acceptance contract defines exact benchmark profiles, scenes, final content floors, dependency order and requirement-to-work-package coverage. Its gates apply to every requirement here. Both documents must be reviewed together; no scope reduction may hide inside a task decomposition.
2. Place in the existing release series#
V1.3 is the personal agent; V1.4 is the channels; V1.5 is the film/series studio; V1.6 is Living Worlds. V1.6 reuses rather than duplicates their agent runtime, typed creative operations, canon, character/voice identities, rights/provenance, asset graph, production budgets and distribution services.
- V1.3 scope — inspected revision 44.
- V1.4 scope — inspected revision 20.
- V1.5 studio scope — inspected revision 39.
- Content workbenches scope — inspected revision 18.
- Brand record — inspected revision 3, in review; linked as context, not represented as a new approval.
Existing decisions remain binding unless explicitly amended: Blender remains the ground truth for V1.5 film frames; Maya is the real-time game runtime, with a deliberate shared-asset/preview bridge. Existing studio placement decisions are preserved; the game editor’s exact host is an architecture decision that must reuse the approved shell where suitable rather than invent a competing studio. English-first V1.5 production remains unchanged. V1.6 must support Unicode, text shaping, localization-ready data, captions and language-pack architecture; it does not silently authorize a separate translated-film or dubbing programme. Mature creative work remains supported; the game’s actual content and destination rules are decided explicitly.
3. Starting evidence and gaps#
The assessment inspected commit 82b8e72c5504caf6bcae74d3733a1d20cd849ec4. It was static code inspection, not a full build, benchmark or assurance that an implementation is absent everywhere. Re-audit current main before implementation. Maya’s engine workspace lists 86 members; Neith’s much broader workspace includes many non-game packages, so crate counts are not maturity scores.
- Maya backend availability in maya-renderer/src/backend.rs is configuration-based; it does not prove a physical device rendered a game frame.
- neith-gpu has a software device and queue bookkeeping; a separate forge-render-wgpu implementation does request a real wgpu device and submit commands. Reuse should be evaluated, but a canvas renderer is not proof of an integrated Maya 3D engine.
- No direct cross-workspace Maya/Neith Cargo dependency or Maya executable main.rs was found in that inspection. Integration therefore needs positive executable evidence, not an assumption from names.
- maya-sim-lod stress tests sum configured tier costs; they do not establish real 10,000-NPC CPU performance. MockLlamaBackend does not establish production inference.
- GI conformance includes explicit pending external hardware gates; the tolerances need calibration against real image/temporal reference data.
- Maya’s default Nx test/check/build targets select ten crates, and kernel/plugin integration tests do not exercise a complete shipped game.
- Unreal-to-Neith renderer mappings are approximations. Parsed synthetic interchange scenes and in-process collaboration tests do not prove actual file imports or live multi-editor convergence.
- Hair CPU timings, routing-graph checks and QUIC framing benchmarks are useful bounded evidence, not full-frame rendering, living-city or distributed-server capacity proof.
These are priority verification targets, not a mandate to discard existing code. Inventory each implementation and repair/reuse it where the evidence supports doing so.
4. Architecture and product boundaries#
Neith owns the selected native systems substrate: devices, render execution, platform abstractions and shared low-level services. Maya owns the integrated world/game runtime, gameplay and creator tools. Bellona owns cross-domain and external-tool integration. Final ADRs may refine package boundaries, but must preserve single ownership of authoritative state and avoid duplicate schedulers, asset registries, entitlement systems or competing renderers without a documented reason.
The shipping composition has one canonical asset graph, a versioned world-state contract, explicit render/simulation projections, a typed operation plane shared by human and agent tools, a cook/package pipeline, and correlated diagnostics. Native clients and headless servers execute real implementations; web/mobile/XR use explicit supported fidelity profiles. All profiles preserve gameplay/state semantics within declared limits.
Cross-family dependency resolution is itself delivery work. Read live Eve tasks in lilith-v1-3, lilith-v1-4, lilith-v1-5, content-workbenches and relevant Isis/Bellona/Maya/Neith families; bind exact keys and revisions, identify overlaps and schedule the required slices before consumers. Do not wait on completion of entire unrelated releases or create a cross-family dependency cycle. A missing shared prerequisite is a real implementation task, not a stub that counts as integration.
5. Definition of fully implemented#
Every requirement must have working production code or production content as appropriate; user-facing authoring/operations; integration into the executable engine; correct persistence/network/platform behaviour where relevant; failure handling and diagnostics; documentation and migration; automated verification; real-hardware evidence; and the applicable independent creator/player review. Each requirement reaches the relevant final evidence level: specification, component, integrated, hardware, production. A paper design, trait, enum, generated interface, fixed response, mock backend, synthetic time estimate or unexercised test cannot satisfy a higher level.
Scope approval does not authorize purchases, new accounts, privileged SDK access, external messages, self-review, public publication or UAT promotion. Those are recorded separately when concrete. An unavailable external dependency remains visible and blocks its gate until supplied or explicitly removed from scope by Elikem.
6. Mandatory capability catalogue#
GOV — Programme, ownership and honest capability accounting#
Accountable discipline: Product direction / architecture. Earliest delivery phase: M0. Prerequisite workstreams: none. Starting code/service anchors: Eve release records, libs/oshun/navigation/src/release-scope.ts. Anchors describe candidates, not an approved new folder layout.
LW-GOV-01 — Release contract#
Implement: Register Lilith V1.6 Living Worlds as the next Oshun V1.x programme, with the complete engine, studio, SDK and flagship game in this scope. Preserve the separate developer names Maya and Neith. Update the brand/features records through Eve after approval.
Accept only when: Every requirement has an owner, implementation task, integration route, verification case and evidence record; a milestone cannot silently remove a release requirement.
LW-GOV-02 — Repository evidence audit#
Implement: Inventory every relevant crate, service, UI, adapter and test against real behaviour: specified, algorithm-tested, integrated, hardware-verified or production-proven. Record reuse, repair, replacement or retirement decisions. Reconcile obsolete Maya/Neith descriptions in Eve.
Accept only when: A clean-checkout inventory names actual paths, dependency edges and runnable targets; configuration adapters, software devices and mocks are visibly distinguished from shipping implementations.
LW-GOV-03 — Architecture and responsibility decisions#
Implement: Approve the engine/editor/service boundary, renderer and physics ownership, scripting runtime, asset model, threading, network model, persistence and supported profiles in independently reviewed ADRs. Map each shared V1.3–V1.5 capability to one canonical owner.
Accept only when: ADRs include alternatives, data-flow and failure-flow diagrams, migration plans and executable contract tests; no duplicated source of truth or unresolved ownership at milestone exit.
LW-GOV-04 — Resource and production plan#
Implement: Assign accountable roles for engine, rendering, animation, physics, AI, tools, technical art, world/game design, writing, audio, UX, QA, security, platform operations and developer support. Estimate work from measured spikes; maintain capacity, costs and critical path.
Accept only when: Named people or agent roles cover every discipline and review boundary; estimates distinguish engineering, content, hardware and operations. Spending, staffing and platform agreements require Elikem decisions, not scope approval by implication.
LW-GOV-05 — Scope and decision control#
Implement: Keep all capabilities below inside V1.6 through the final milestone. Track blockers and exact changes in Eve; preserve approved preceding release decisions. Publish a requirement-by-requirement scorecard and separate platform/game verdicts.
Accept only when: No estimated metric, absent device, unavailable SDK, fake asset or paper design can pass implementation. Elikem must explicitly amend scope to remove a requirement; a blocked item remains blocked.
CORE — One shipping native runtime#
Accountable discipline: Maya runtime / Neith systems. Earliest delivery phase: M1. Prerequisite workstreams: GOV. Starting code/service anchors: libs/maya/engine-core, libs/neith/core, libs/neith/hal, libs/neith/integration-maya. Anchors describe candidates, not an approved new folder layout.
LW-CORE-01 — Executable composition#
Implement: Build actual player, editor-host and headless server entry points with Maya gameplay/world systems calling a defined Neith native substrate. Resolve competing allocators, job systems, ECS ownership, reflection, scheduling and plugin lifecycle without circular dependencies.
Accept only when: A clean build boots, loads a cooked scene, plays, saves and exits on real devices; traces prove the selected native implementations execute. No no-op adapter can satisfy a runtime capability.
LW-CORE-02 — Canonical world contracts#
Implement: Specify versioned entity and asset identities, units, coordinate handedness, transforms, large-world precision, time domains, fixed ticks, event ordering and ownership. Provide explicit C/Rust/TypeScript or other language boundaries and compatibility errors.
Accept only when: Round trips across editor, runtime, network, save and imports preserve identity and transforms; incompatible versions fail with actionable migration information rather than silently changing state.
LW-CORE-03 — Scheduling and memory#
Implement: Implement bounded job/fiber scheduling, task dependencies, frame budgets, allocators, pools, cancellation and backpressure. Separate simulation, rendering, streaming, inference and audio deadlines; instrument contention and memory residency.
Accept only when: Real concurrent workloads survive starvation, memory pressure and cancellation tests, with no unbounded queue; CPU/GPU budgets are measured end to end and overload degrades by policy.
LW-CORE-04 — Lifecycle and recovery#
Implement: Implement startup/shutdown, focus and suspend/resume, device recovery, resource lifetime, hot reload, headless operation, plugin unload and error propagation. Recover unsaved editor changes and surface runtime failures.
Accept only when: Repeated load/unload, crash/restart, mobile suspend, shader failure and device-loss injections produce correct recovery or a safe diagnostic exit without corrupting project or save state.
LW-CORE-05 — Shared semantic state#
Implement: Expose authoritative weather, material/surface state, damage, sound events, ownership, object affordances, NPC knowledge and consequences to all consuming systems with explicit cached/approximated representations.
Accept only when: A broken rain-soaked market stall changes collision, navigation, audio, animation, witnesses, mission state and persistence consistently, including after streaming and reconnect.
GPU — Real graphics devices and render infrastructure#
Accountable discipline: Neith graphics. Earliest delivery phase: M2. Prerequisite workstreams: CORE. Starting code/service anchors: libs/neith/hal/crates/neith-gpu, libs/neith/forge-core/crates/forge-render-wgpu, libs/maya/engine-core/crates/maya-renderer. Anchors describe candidates, not an approved new folder layout.
LW-GPU-01 — Native backend execution#
Implement: Implement and validate Vulkan, DirectX 12 and Metal backends and the WebGPU profile through the selected architecture. Detect actual device features and limits at runtime; keep software/test devices clearly separate.
Accept only when: Each backend creates a real device, uploads assets, executes commands, presents frames and produces a capture identifying GPU, driver and API. Unavailable capabilities report honestly and select tested fallbacks.
LW-GPU-02 — Render graph and resource safety#
Implement: Implement pass scheduling, barriers/layouts, descriptor binding, transient allocation, residency, fences, synchronization, async compute and multi-queue execution with portable semantics.
Accept only when: GPU validation and stress runs show no lifetime, barrier, synchronization or out-of-bounds errors; aliasing and async scheduling demonstrably reduce measured cost without rendering changes.
LW-GPU-03 — Shader and pipeline toolchain#
Implement: Ship material-to-shader compilation, reflection, cross-target translation, permutations, diagnostics, shader debugging and offline PSO preparation with versioned caches. Preserve artist-authored graphs and source mappings.
Accept only when: Cold and warm builds run real materials across backends, report compilation failures in the editor and stay within the hitch budget on first traversal; cache invalidation and driver changes are tested.
LW-GPU-04 — GPU observability and robustness#
Implement: Support timestamp queries, markers, captures, memory accounting, device-loss recovery and crash correlation. Include multi-vendor validation and headless GPU test execution where supported.
Accept only when: A reviewer can correlate one slow frame across GPU and CPU and reproduce a captured fault on its declared hardware; missing counters are explicit and never replaced by invented values.
LW-GPU-05 — Feature profiles and parity#
Implement: Define full, performance, mobile, browser, XR and server feature profiles, including shader limits, precision, compute, ray tracing and memory constraints. Validate scene semantics under each profile.
Accept only when: The same canonical project cooks into each supported profile with a machine-readable capability report and acceptable visual fallbacks; unsupported content fails during cook, not silently at runtime.
GEO — Virtualized geometry and visibility#
Accountable discipline: Neith rendering / Maya scene. Earliest delivery phase: M3. Prerequisite workstreams: GPU, DATA. Starting code/service anchors: libs/maya/engine-core/crates/maya-meshlet, libs/maya/engine-core/crates/maya-vegetation, libs/neith. Anchors describe candidates, not an approved new folder layout.
LW-GEO-01 — Virtual geometry pipeline#
Implement: Implement mesh clustering/meshlets, hierarchical selection, compressed pages, GPU-driven culling, indirect draws and streaming for production meshes, with offline builders and inspectable error metrics.
Accept only when: Dense imported scenes meet fixed screen-error, residency and frame budgets on native GPUs while traversing LOD boundaries; tests include holes, thin structures and invalid data.
LW-GEO-02 — Skinned, foliage and translucent geometry#
Implement: Support animation-aware bounds and LOD, instancing, vegetation wind and deformation, alpha-tested coverage and appropriate translucency paths. Provide explicit fallback render paths where virtual geometry is unsuitable.
Accept only when: Moving crowds, wind-driven forests and close-up characters retain silhouettes and temporal stability; geometry and shader costs are captured rather than inferred from triangle counts.
LW-GEO-03 — Visibility and occlusion#
Implement: Implement hierarchical frustum/occlusion culling, HLOD, portals/interiors where useful and visibility policies shared with streaming. Handle camera cuts, disocclusion and rapid reversal.
Accept only when: A standardized camera route has no missing newly visible objects or late collision because of stale visibility; CPU and GPU culling scale with the declared scene.
LW-GEO-04 — Authoring and diagnostics#
Implement: Expose geometry quality, collision proxies, source-to-cooked mapping, residency, overdraw, LOD error, culling and streaming budgets in the editor. Allow per-asset artist overrides.
Accept only when: An artist finds and fixes a visible LOD defect without source-code changes, reimports the asset and preserves the override through recook and collaboration.
LIGHT — Lighting, shadows and reconstruction#
Accountable discipline: Neith rendering. Earliest delivery phase: M3. Prerequisite workstreams: GPU, DATA. Starting code/service anchors: libs/neith/gi-conformance, libs/neith, libs/maya/engine-core/crates/maya-renderer. Anchors describe candidates, not an approved new folder layout.
LW-LIGHT-01 — Dynamic global illumination#
Implement: Ship integrated hardware-ray-traced and scalable software/hybrid GI, reflections, probe/cache updates, emissive lighting and interior/exterior transitions. Include reference path-traced or offline ground truth for validation.
Accept only when: Dynamic lights, moving geometry and time of day meet calibrated image and temporal error gates against reference scenes; leaks, lag and noise are explicitly tested on supported tiers.
LW-LIGHT-02 — Many lights and shadows#
Implement: Implement scalable dynamic light selection, area lights, contact shadows and virtualized or equivalent high-resolution shadowing with residency and invalidation. Provide useful art direction and quality controls.
Accept only when: The fixed many-light scene maintains shadow continuity under movement and destruction within frame/memory budgets; no light disappears without an authored culling rule.
LW-LIGHT-03 — Temporal reconstruction#
Implement: Implement motion vectors, history validation, temporal AA/upscaling, disocclusion handling and denoising, including hair, foliage, particles, transparency and camera cuts. Integrate optional vendor upscalers through capability-checked adapters.
Accept only when: Frame sequences pass temporal artifact review and fixed image tests at declared input/output resolutions. Native and reconstructed modes are measured separately; frame generation cannot mask a failed base-frame budget.
LW-LIGHT-04 — Reference rendering and look development#
Implement: Provide deterministic reference captures, exposure controls, physically meaningful lights, colour transforms and reproducible material/lighting presets. Bridge real-time look development to the existing film pipeline.
Accept only when: An approved asset and lighting setup retains documented appearance between Maya and Blender within defined tolerances; differences are visible and correctable, not described as perfect parity.
LW-LIGHT-05 — Scalable quality and power#
Implement: Provide tuneable lighting budgets, dynamic resolution and fallback methods across platforms, with stable transitions and power/thermal accounting.
Accept only when: Each shipping profile meets its declared quality and sustained-performance gate; resolution, ray counts and dynamic quality changes are logged alongside the measurements.
LOOK — Materials, atmosphere and effects#
Accountable discipline: Rendering / technical art. Earliest delivery phase: M3. Prerequisite workstreams: GPU, DATA. Starting code/service anchors: libs/maya/engine-core/crates/maya-character-render, libs/maya/engine-core/crates/maya-atmosphere, libs/maya/engine-core/crates/maya-vfx. Anchors describe candidates, not an approved new folder layout.
LW-LOOK-01 — Material authoring and shading#
Implement: Ship a layered PBR material graph with parameter instances, textures/virtual textures, decals, anisotropy, subsurface scattering, skin, eyes, hair, cloth, glass, clearcoat, water and stylized looks.
Accept only when: A curated real-asset material corpus renders correctly on all relevant profiles and supports reimport, compilation errors, animation and live parameter editing.
LW-LOOK-02 — Atmosphere and weather#
Implement: Integrate sky, sun/moon, clouds, fog, volumetric scattering, seasons, rain/snow, wetness and wind with lighting, audio, physical surfaces, ecology and NPC response. Keep artist overrides explicit.
Accept only when: A recorded day/night and weather cycle has coherent sky/reflections/exposure, precipitation shelter and persistent surface state; transition and performance gates pass in the flagship.
LW-LOOK-03 — VFX and environmental interaction#
Implement: Provide authorable CPU/GPU particle and effect graphs, collisions, decals, volumetrics, smoke/fire, destruction effects, pooling and deterministic seed/replay options where feasible.
Accept only when: Gameplay-triggered effects survive streaming, save/reload and replication with bounded cost; particle overdraw and GPU memory are measurable and editable.
LW-LOOK-04 — HDR and colour management#
Implement: Support calibrated SDR/HDR output, wide-gamut authoring, texture colour-space metadata, exposure and tone mapping, and accessibility adjustments without corrupting art assets.
Accept only when: Known test patterns and representative scenes pass capture/display review on declared devices; no double transforms, clipped UI or unreadable accessibility overlays.
LW-LOOK-05 — Production art quality#
Implement: Build an art bible, technical-art constraints and high-quality environment, character, prop, material and effect libraries for the flagship. Establish visual consistency and independent art reviews.
Accept only when: Final gameplay, close-ups, motion and weather are reviewed as complete scenes against the frozen target; isolated hero stills cannot compensate for poor in-motion or background quality.
WORLD — Large worlds and coordinated streaming#
Accountable discipline: Maya world / Neith I/O. Earliest delivery phase: M3. Prerequisite workstreams: CORE, GPU, DATA. Starting code/service anchors: libs/maya/engine-core/crates/maya-streaming, libs/maya/engine-core/crates/maya-world, libs/maya/engine-core/crates/maya-vram-budget. Anchors describe candidates, not an approved new folder layout.
LW-WORLD-01 — World partition and precision#
Implement: Implement persistent cell/region identities, large-world coordinate precision, spatial indexing, data layers, HLOD and editable world partitions. Support interiors, vertical spaces, water and moving origin where required.
Accept only when: Large-distance traversal, physics, ray queries, networking and authoring remain stable; cell migration never duplicates identities or loses references.
LW-WORLD-02 — Coordinated resource streaming#
Implement: Schedule geometry, textures, materials, collision, navmesh, audio, animation, AI state and gameplay dependencies through asynchronous I/O, decompression, residency and predictive prefetch.
Accept only when: Fast vehicle/flight, teleport, cold launch and rapid camera reversal routes have correct collision and gameplay readiness within hitch/memory budgets, including deliberately slow storage.
LW-WORLD-03 — World creation and procedural systems#
Implement: Ship terrain sculpting, roads, rivers, urban generation, interiors, vegetation and biome tools with procedural graphs, nondestructive edits, seed control and persistent manual overrides.
Accept only when: Creators build and revise a playable region without losing authored exceptions; regenerated terrain updates navigation, collision, streaming and gameplay references consistently.
LW-WORLD-04 — World layers and collaboration#
Implement: Support per-object/cell editing, change review, locking where needed, branch/merge, snapshots and conflict recovery for large scenes. Keep editor loading independent of full-world residency.
Accept only when: Concurrent edits to adjacent cells and shared assets merge safely over a real network; conflicting transforms or deletions require explicit resolution and preserve recoverable history.
LW-WORLD-05 — Streaming correctness under failure#
Implement: Implement prioritized load cancellation, partial/corrupt asset handling, storage pressure, out-of-memory policy and save integration during cell transitions.
Accept only when: Fault injection never allows walking through unloaded collision or commits an inconsistent save; recovery has a bounded timeout and a useful user-facing failure state.
ANIM — Character movement, acting and animation tools#
Accountable discipline: Maya animation / technical animation. Earliest delivery phase: M3. Prerequisite workstreams: CORE, DATA, GPU. Starting code/service anchors: libs/maya/engine-core/crates/maya-motion-matching, libs/maya/engine-core/crates/maya-ml-locomotion, libs/maya/engine-core/crates/maya-facial-capture. Anchors describe candidates, not an approved new folder layout.
LW-ANIM-01 — Animation graph and authoring#
Implement: Provide skeletal/curve animation, layers, state machines, blend spaces, timelines, procedural rigs, debugging and live preview with hot reload and streaming.
Accept only when: Artists author, inspect and correct an animation graph, cook it and reproduce its behaviour in the packaged game; malformed graphs and missing clips have clear diagnostics.
LW-ANIM-02 — Motion matching and learned locomotion#
Implement: Integrate real capture/animation databases, feature extraction, searchable motion matching and trained learned-locomotion options with dataset/version provenance and conventional fallbacks.
Accept only when: Held-out paths, speeds, stops, turns, slopes and obstacle interactions pass latency, foot-sliding and transition-quality gates on real character assets; mocked or memorized samples cannot pass.
LW-ANIM-03 — Retargeting and contact#
Implement: Implement retargeting, IK, motion/root warping, feet/hands/body contacts, root motion and varied body proportions with artist correction tools.
Accept only when: Humans and nonhuman rigs move over uneven terrain, use props and interact in paired scenes without unacceptable penetration, sliding or lost contact across declared character types.
LW-ANIM-04 — Facial performance and dialogue#
Implement: Implement facial capture/import, blend shapes or equivalent rigs, eye focus, gaze, emotional expression and audio-aligned lip sync with editable curves and retargeting.
Accept only when: Dialogue and interrupted conversations retain synchronization and believable gaze in real-time close-up review; captions, facial performance and audio share timing.
LW-ANIM-05 — Physical animation and recovery#
Implement: Integrate active ragdolls, balance, impacts, falls, getting up, partial-body physics and transitions back to animation. Support contextual reactions comparable in outcome to high-quality physical-character systems.
Accept only when: Repeated impacts on slopes, stairs, vehicles and moving objects recover plausibly without explosive joints or uncontrolled clipping; gameplay control and network correction remain responsive.
LW-ANIM-06 — Animals, mounts and interactions#
Implement: Support quadrupeds, mounts, crowds, carrying, climbing, swimming, entering vehicles and synchronized multi-character interactions with correct affordances and interruption policies.
Accept only when: The flagship demonstrates believable mounting/riding, obstacle anticipation, paired interaction and safe interruption at each animation phase under physics and streaming load.
PHYS — Physics, vehicles and material simulation#
Accountable discipline: Maya simulation / Neith physics substrate. Earliest delivery phase: M3. Prerequisite workstreams: CORE, DATA. Starting code/service anchors: libs/maya/engine-core/crates/maya-physics, libs/maya/engine-core/crates/maya-vehicles, libs/maya/engine-core/crates/maya-chemistry. Anchors describe candidates, not an approved new folder layout.
LW-PHYS-01 — Rigid bodies and collision#
Implement: Integrate real broad/narrow phase, collision shapes, queries, CCD, joints, constraints, contacts, sleeping and character controllers with consistent units and scheduling.
Accept only when: Stacks, fast projectiles, moving platforms and character interactions pass stability and tunnelling tests at declared tick rates and under rollback where supported.
LW-PHYS-02 — Destruction and deformable terrain#
Implement: Implement authorable fracture, damage propagation, debris budgets and terrain deformation coupled to rendering, collision, navigation, materials and saved state.
Accept only when: A player destroys and deforms a region, leaves it, reconnects and reloads a save with correct consequences; debris does not cause unbounded cost or state growth.
LW-PHYS-03 — Cloth, hair and soft simulation#
Implement: Provide collision-aware cloth, hair/grooms and selected soft-body simulation with authoring, constraints, LOD and platform fallbacks.
Accept only when: Dressed characters and dynamic props remain stable during fast motion, impacts and LOD changes; real GPU/CPU measurements include collision and render costs.
LW-PHYS-04 — Water, fluids and reactive materials#
Implement: Implement waves, buoyancy, currents, water interaction and bounded fluid/fire/smoke/material-reaction systems linked to weather, surfaces, damage and AI perception.
Accept only when: Boats, swimming, wet surfaces and spreading/extinguishing fire behave consistently and persist/replicate at defined fidelity; artistic controls and bounded approximations are documented.
LW-PHYS-05 — Vehicles and transport#
Implement: Ship drivable wheeled vehicles, boats and the selected aerial traversal vehicle with suspension, traction, damage, cameras, input/haptics and AI traffic integration.
Accept only when: Real driving/sailing/flight routes cover entry/exit, collisions, passengers, network correction and high-speed streaming; tuning is editable and regression-tested.
LW-PHYS-06 — Simulation contracts and debug tools#
Implement: Define determinism boundaries, substepping, asynchronous simulation, rollback compatibility and cross-platform tolerances; provide collision, joint and contact visualization plus replay.
Accept only when: Recorded failures can be inspected and reproduced within the advertised boundary; no unsupported claim of bitwise cross-GPU or cross-platform determinism.
LIFE — Persistent living-world simulation#
Accountable discipline: Maya AI / world design. Earliest delivery phase: M4. Prerequisite workstreams: WORLD, PHYS, ANIM. Starting code/service anchors: libs/maya/engine-core/crates/maya-npc-life, libs/maya/engine-core/crates/maya-city-sim, libs/maya/engine-core/crates/maya-sim-lod. Anchors describe candidates, not an approved new folder layout.
LW-LIFE-01 — Perception and navigation#
Implement: Implement sensory perception, occlusion, uncertainty, knowledge boundaries, dynamic navigation, crowds, formations and obstacle replanning with useful debugging.
Accept only when: NPCs react only to available evidence, navigate changed/destructible scenes and recover from blocked goals without oscillation or knowledge leaks.
LW-LIFE-02 — Routines and social life#
Implement: Integrate needs, schedules, occupations, relationships, personality, emotions, social interactions, cooperation, memory and gossip into persistent individual identities.
Accept only when: Named NPCs sustain a day/night routine and remember witnessed events after unloading or save/reload; social propagation has traceable causes and bounded memory.
LW-LIFE-03 — Economy, justice and missions#
Implement: Implement production/consumption, inventories, prices, ownership, theft/witnesses, law response, factions and designer-authored quests/encounters using common event/state contracts.
Accept only when: Player actions create coherent and inspectable economic, social and mission consequences without dead-end mission states; designers can tune and override emergent behaviour.
LW-LIFE-04 — Ecology and traffic#
Implement: Integrate wildlife, populations, vegetation/biomes, environmental resources, traffic and infrastructure responses with weather and world changes.
Accept only when: Wildlife and vehicles behave credibly in the same streamed world as gameplay; simulation budgets and recovery from blocked roads or resource loss are verified.
LW-LIFE-05 — Simulation LOD continuity#
Implement: Execute real high-fidelity, reduced and aggregate simulation with attention-based budgets, state projection and promotion/demotion preserving identity, commitments and causality.
Accept only when: Measured CPU work meets the population contract; repeated LOD transitions do not teleport essential state, duplicate goods or forget witnessed crimes. Estimated per-tier costs are insufficient evidence.
LW-LIFE-06 — World history and causal debugging#
Implement: Persist consequential events, snapshots, provenance and explainable decision traces with bounded storage and privacy controls. Provide time inspection and controlled reproduction tools.
Accept only when: A designer traces a mission/world anomaly from observation to perception, decision, action and stored consequence; long runs retain required continuity without unbounded logs.
NPC — Real model-backed cognition#
Accountable discipline: Maya cognition / shared model services. Earliest delivery phase: M4. Prerequisite workstreams: LIFE, OPS. Starting code/service anchors: libs/maya/engine-core/crates/maya-slm-runtime, libs/maya/engine-core/crates/maya-cognition, libs/maya/engine-core/crates/maya-npc-planning. Anchors describe candidates, not an approved new folder layout.
LW-NPC-01 — Production inference runtime#
Implement: Replace mock-only paths with at least one licensed, real local model backend plus a separately configured hosted option. Support model loading, quantization, batching, cancellation and resource isolation.
Accept only when: A packaged offline scene runs real inference on target hardware with measured latency and memory; hosted credentials are isolated and hosted failure never stalls the frame loop.
LW-NPC-02 — Grounded planning and constrained action#
Implement: Bind dialogue/planning to authorized world facts, NPC knowledge and typed action affordances. Validate preconditions and effects outside the model; prevent fabricated world mutations.
Accept only when: Adversarial and held-out scenarios show no unauthorized actions or impossible item creation; action failures lead to recoverable replanning and visible diagnostics.
LW-NPC-03 — Memory and character consistency#
Implement: Implement versioned episodic/semantic memory, salience, retrieval, bounded context, forgetting policies and personality/relationship consistency with editable author controls.
Accept only when: Long-session evaluation measures recall, contradiction, persona consistency and memory deletion; private knowledge is not exposed to unrelated NPCs or players.
LW-NPC-04 — Latency and graceful fallback#
Implement: Keep model decisions asynchronous with interruptible actions, cached routine behaviour and deterministic fallback dialogue/plans when inference is late, unavailable or disallowed.
Accept only when: Under inference overload the game still meets frame and interaction budgets, pending plans cancel correctly and fallback preserves mission solvability.
LW-NPC-05 — Evaluation and voice integration#
Implement: Connect generated speech/intent to the approved voice pipeline, captions, lipsync and dialogue timing; record consent/provenance and evaluate cognition with human-reviewed and deterministic checks.
Accept only when: Real conversations, interruptions and voice input pass latency, grounding, character and accessibility gates on held-out cases; model-as-judge alone cannot approve quality.
GAME — Reusable gameplay and narrative framework#
Accountable discipline: Maya gameplay / game design. Earliest delivery phase: M4. Prerequisite workstreams: LIFE, ANIM, PHYS, AUDIO. Starting code/service anchors: libs/maya/engine-core/crates/maya-gameplay-systems, libs/maya/engine-core/crates/maya-combat, libs/maya/engine-core/crates/maya-investigation. Anchors describe candidates, not an approved new folder layout.
LW-GAME-01 — Gameplay framework#
Implement: Ship entities/components, abilities, interactions, inventories, equipment, progression, spawning, cameras, game modes and save-aware state machines exposed to both code and creator tools.
Accept only when: Two materially different game projects use the same public framework without modifying engine internals or hard-coding the flagship.
LW-GAME-02 — Player systems#
Implement: Implement polished traversal, combat, stealth, investigation, survival/resource mechanics and vehicle/mount play with configurable input, feedback and difficulty.
Accept only when: Complete missions combine these systems under streaming and multiplayer; input latency, camera comfort and failure/retry UX pass playtests.
LW-GAME-03 — Narrative and mission authoring#
Implement: Provide branching dialogue, quest/mission graphs, cutscenes, sequences, conditions, objective tracking, checkpoints and world-state consequences with editable canon bindings.
Accept only when: Writers/designers author and debug a branching mission; interrupted, reordered and multiplayer actions cannot strand progression or corrupt canon.
LW-GAME-04 — UI, input and accessibility#
Implement: Provide runtime HUD/menu/UI framework, keyboard/mouse/controller/touch/XR action mapping, rebinding, subtitles/captions, text scaling, contrast, reduced motion and assist options.
Accept only when: Automated navigation and accessibility checks plus human device tests cover complete start/play/settings/save/quit flows with no mandatory inaccessible interaction.
LW-GAME-05 — Content quality and audience#
Implement: Create a mature-audience-capable flagship art/narrative/gameplay direction with coherent pacing, level design, encounters, animation, sound and performance. Record actual content/rating requirements per destination.
Accept only when: Independent playtesters complete the intended experience and rate the frozen craft rubric; technology demos, filler missions and automatic praise cannot pass this gate.
AUDIO — Spatial audio, dialogue and music#
Accountable discipline: Maya audio / shared voice and music. Earliest delivery phase: M3. Prerequisite workstreams: CORE, DATA. Starting code/service anchors: libs/maya/engine-core/crates/maya-audio, libs/maya/engine-core/crates/maya-acoustics, libs/maya/engine-core/crates/maya-music-engine. Anchors describe candidates, not an approved new folder layout.
LW-AUDIO-01 — Production audio runtime#
Implement: Implement real low-latency device output, bus/mix graph, DSP, streaming, voice allocation, priorities, ducking and device-change handling with sample-accurate scheduling where needed.
Accept only when: Packaged games play real decoded audio without underruns at the declared worst-case mix load; mute, focus, suspend and output-device changes recover correctly.
LW-AUDIO-02 — Spatial acoustics#
Implement: Integrate positional audio, occlusion, obstruction, room/portal reverb, environmental propagation and listener motion with scene geometry and world streaming.
Accept only when: Indoor/outdoor transitions, moving sources and dynamic obstructions sound coherent in blind listening review and pass measured audio timing/cost gates.
LW-AUDIO-03 — Dialogue and voice#
Implement: Implement conversation scheduling, interruptions, radio/spatial voice, lipsync timing, captions, recording/mute controls and approved voice synthesis integration.
Accept only when: Multi-speaker gameplay, packet loss and interruption tests retain intelligibility and consent settings; voice and transcript retention follow configured policy.
LW-AUDIO-04 — Interactive music and ambience#
Implement: Ship adaptive music states/stems, transitions, ambience zones and surface/material-driven sound events with editing and preview.
Accept only when: Weather, danger, traversal and mission changes drive musically coherent transitions and correct foley without duplicate or stale events after streaming.
LW-AUDIO-05 — Audio tools and accessibility#
Implement: Provide mixer, profiling, source visualization, acoustic authoring, loudness/headroom checks, caption authoring and hearing-accessibility settings.
Accept only when: A sound designer fixes a scene entirely through supported tools; final mixes pass speaker/headphone/device listening and clipping/underrun checks.
DATA — Assets, builds and interchange#
Accountable discipline: Asset pipeline / Bellona. Earliest delivery phase: M2. Prerequisite workstreams: CORE. Starting code/service anchors: libs/neith/engine-interchange, libs/neith/integration-maya, libs/bellona, libs/isis/3d-post-pipeline. Anchors describe candidates, not an approved new folder layout.
LW-DATA-01 — Canonical asset graph#
Implement: Create stable asset IDs, metadata, typed references, dependency DAGs, source hashes, variants, ownership, provenance and migrations. Reuse existing canon/asset registries rather than invent parallel stores.
Accept only when: Edits, moves, duplication, cross-project reuse and delete/restore preserve or deliberately remap references; dangling dependencies fail validation with source locations.
LW-DATA-02 — Real import and export#
Implement: Implement actual glTF and USD scene/asset exchange, Blender round trips and FBX support through a legally usable implementation. Handle meshes, UVs, rigs, animation, materials, textures, lights and audio as declared.
Accept only when: A licensed real-file corpus round-trips with measured losses and explicit unsupported-feature reports; synthetic SourceScene objects and field renaming do not establish file-format support.
LW-DATA-03 — Reimport and artistic control#
Implement: Preserve authored overrides, rig corrections, material assignments, collision/navigation annotations and generated/manual ownership across reimport and procedural regeneration.
Accept only when: An artist updates upstream geometry and animation without losing downstream work; ambiguous remapping produces a reviewable diff and reversible conflict resolution.
LW-DATA-04 — Cook, cache and packaging#
Implement: Implement incremental deterministic cooking, platform transforms/compression, shader/PSO caches, derived-data cache, remote build support, dependency invalidation and reproducible manifests.
Accept only when: Cold/warm builds and one-asset edits meet latency gates; clean independent builds match canonical content hashes except explicitly isolated signing/time fields.
LW-DATA-05 — Patch and compatibility#
Implement: Ship chunking, differential patches, versioned content manifests, install/update validation, rollback, missing-content diagnostics and compatible DLC/mod asset resolution.
Accept only when: An interrupted or corrupt update recovers to a usable prior build; saves and approved plugins migrate or fail safely with a recovery path.
LW-DATA-06 — Migration from existing engines#
Implement: Deliver supported Unreal export/import and project-migration tooling for declared scenes, materials, animations and gameplay constructs; use Bellona bridges where appropriate.
Accept only when: Real licensed sample projects migrate and run with a fidelity report. Approximate Lumen/Nanite or Blueprint mappings are disclosed; unsupported binary assets or executable scripts are never claimed as automatic parity.
EDIT — A complete creator editor#
Accountable discipline: Maya tools / Lilith creator experience. Earliest delivery phase: M3. Prerequisite workstreams: CORE, GPU, DATA, OPS. Starting code/service anchors: libs/maya, libs/neith/integration-maya, Existing approved studio shell; final host chosen by architecture ADR. Anchors describe candidates, not an approved new folder layout.
LW-EDIT-01 — Workspace and visual design#
Implement: Deliver a real editable viewport with object hierarchy, inspector, content browser, timeline, command search, dockable panels and context-sensitive tools. Follow frontend-skill: calm hierarchy, readable dense controls and restrained chrome.
Accept only when: Creators complete core tasks using actual scene state; keyboard/focus, scaling, contrast, layout persistence and responsive behaviour pass automation and observed usability review.
LW-EDIT-02 — Scene manipulation and play mode#
Implement: Ship selection, transforms, snapping, placement, camera/navigation, grouping, prefabs/templates, components, play/simulate/pause/step and editing during play with explicit commit/discard.
Accept only when: A creator builds and debugs a playable scene, changes state during play and chooses exactly which changes persist; no hidden runtime/editor divergence.
LW-EDIT-03 — Specialist authoring tools#
Implement: Integrate material, animation/rig, terrain/roads/vegetation, physics/destruction, navigation, audio, VFX, mission and UI editors with live previews and shared asset operations.
Accept only when: Every specialist capability has an end-to-end author-preview-cook-play workflow with error states, undo and accessible controls; a panel that only displays mock data fails.
LW-EDIT-04 — Transactions and recovery#
Implement: Implement undo/redo, grouped transactions, checkpoints, autosave, crash recovery, diff/merge and scoped locks across UI and agent changes, including expensive asynchronous operations.
Accept only when: Mixed human/agent edits, cancelled jobs and injected crashes restore consistent assets/world state; destructive merges require explicit resolution with recoverable versions.
LW-EDIT-05 — Real collaboration#
Implement: Provide authenticated multi-user sessions, presence, permissions, locks/conflict handling, reviewable changes, offline edits and reconnect across real processes and network conditions.
Accept only when: At least eight simultaneous editors manipulate a real shared project under latency/loss; convergence, attribution and conflicting deletions are verified beyond in-process CRDT tests.
LW-EDIT-06 — Creator journeys and help#
Implement: Provide project creation, templates, contextual errors/help, onboarding, asset browsing, build/export and performance diagnosis with complete user journeys and diagnostics.
Accept only when: Independent creators install, build, modify and package projects without engine-author intervention; task time, errors and support needs are measured against the fixed comparison brief.
SCRIPT — Programming and visual scripting#
Accountable discipline: Maya developer experience. Earliest delivery phase: M3. Prerequisite workstreams: CORE, DATA, OPS. Starting code/service anchors: libs/maya/engine-core/crates/maya-reflect, libs/maya/engine-core/crates/maya-plugin-api, Editor scripting implementation selected by ADR. Anchors describe candidates, not an approved new folder layout.
LW-SCRIPT-01 — Supported programming surfaces#
Implement: Define stable native extension APIs and an embedded gameplay scripting language/runtime with reflection, serialization, safe resource access and platform support. Record the choice and alternatives in an ADR.
Accept only when: A standalone project implements gameplay and extensions using documented APIs; hot reload, failure isolation and packaged execution work on every supported profile.
LW-SCRIPT-02 — Visual gameplay scripting#
Implement: Ship typed node/graph authoring, validation, compilation/execution, reusable functions, events, data inspection and source-controlled diffs for non-programmer creators.
Accept only when: Designers implement a real branching mission and reusable ability without native code; graph errors identify the exact node and survive round-trip serialization.
LW-SCRIPT-03 — Debugger and live iteration#
Implement: Provide breakpoints, stepping, watches, call stacks, variable inspection, graph execution tracing and profiler linkage for local and remote runtime sessions.
Accept only when: A user reproduces, pauses and fixes a live gameplay fault in both text and visual code, then reloads safely without losing unrelated world state.
LW-SCRIPT-04 — Plugin compatibility and sandbox#
Implement: Implement plugin discovery, versions, dependency resolution, capability permissions, signatures, lifecycle and migration. Constrain untrusted scripts and editor automation.
Accept only when: Malformed, incompatible and malicious plugins fail safely; unload/update/restart works and documented API compatibility is checked automatically.
LW-SCRIPT-05 — Developer tooling quality#
Implement: Ship command-line build/cook/run/test tools, language/editor integrations, schema inspection, diagnostics and reproducible project generation.
Accept only when: A fresh developer environment runs documented commands and CI without private paths or undocumented manual steps; error output provides actionable file/asset locations.
OPS — One typed operation system for humans and agents#
Accountable discipline: Shared agent platform / Maya tools. Earliest delivery phase: M2. Prerequisite workstreams: CORE. Starting code/service anchors: libs/bellona/mcp-gateway, Existing V1.3 agent and V1.5 studio operation services, Maya editor operation adapters. Anchors describe candidates, not an approved new folder layout.
LW-OPS-01 — Unified editable operations#
Implement: Expose the same versioned typed create/read/edit/simulate/build/test operations to editor UI, scripts and agents, with stable asset/world IDs, preconditions, attribution and idempotency.
Accept only when: Every supported creator action can be inspected and replayed through the shared contract; duplicate requests, stale revisions and concurrent edits are handled correctly.
LW-OPS-02 — Granular artistic control#
Implement: Allow Elikem to inspect and adjust every meaningful creative parameter, lock assets/regions/traits, bound randomness and choose manual, assisted or autonomous execution per operation/project.
Accept only when: Agent runs preserve all locks and constraints; the user can intervene, pause, edit and resume without losing intent, parameters or provenance.
LW-OPS-03 — Isolation and authority#
Implement: Run generated code, tools and model jobs in bounded environments with explicit file/network/account/spending capabilities and short-lived credentials. Reuse existing approval semantics.
Accept only when: Prompt injection through imported assets, tool output or dialogue cannot expand permissions, publish, spend or access secrets; failures leave a useful trace and reversible state.
LW-OPS-04 — Plans, previews and checkpoints#
Implement: Provide inspectable plans, dry runs, diffs, cost estimates, checkpoints, cancellation, rollback and selective merge for agent work. Show actual changed assets and validation evidence.
Accept only when: Creators can reject or accept individual changes and reproduce the result; failed multi-step runs recover without a half-applied project.
LW-OPS-05 — Measured autonomous creation#
Implement: Implement real asset, scene, script, animation, lighting, sound, optimization and test workflows with versioned model/skill profiles and budget caps. Evaluate on held-out briefs and independent ratings.
Accept only when: At least 30 varied briefs measure task completion, quality, manual correction, elapsed time and cost. A final playable project is produced and revised through supported operations; simulated tool calls fail acceptance.
NET — Production multiplayer and online worlds#
Accountable discipline: Maya networking / online services. Earliest delivery phase: M4. Prerequisite workstreams: CORE, WORLD, PHYS, GAME. Starting code/service anchors: libs/maya/engine-core/crates/maya-nexus, libs/neith/integration-maya/src/metaverse-platform. Anchors describe candidates, not an approved new folder layout.
LW-NET-01 — Authoritative networking#
Implement: Implement real transports, session establishment, server authority, replication schemas, interest/relevance management, secure RPCs and state compression with version negotiation.
Accept only when: Real client/server processes exchange gameplay state under latency, jitter, loss and reordering; unauthorized mutations and malformed messages are rejected.
LW-NET-02 — Responsive simulation#
Implement: Implement client prediction, reconciliation, interpolation, lag compensation and rollback where appropriate, including character, vehicle and selected physics state.
Accept only when: Interactive tests measure correction size, hit/interaction consistency and local response at declared network conditions; divergence is bounded and visible in traces.
LW-NET-03 — World lifecycle and scale#
Implement: Support join-in-progress, reconnect, travel, region handoff, persistence, server restart, load shedding and capacity management with clear single-region and multi-region consistency rules.
Accept only when: Clients retain identity, inventory and consequences through process/network failure and region crossing; load tests measure actual compute/memory/network at the production population.
LW-NET-04 — Player services#
Implement: Integrate identity, parties, discovery/matchmaking, invitations, sessions, presence, chat/voice controls, reporting and moderation through existing shared services where owned.
Accept only when: Complete multiplayer journeys work across platform accounts and supported cross-play profiles; failed authentication and blocked users cannot enter unauthorized sessions.
LW-NET-05 — Security and abuse resistance#
Implement: Validate economic actions, rate limits, replay protection, authority boundaries, suspicious clients and mod trust levels; provide privacy-respecting telemetry and incident tools.
Accept only when: Adversarial tests cannot duplicate items, forge entitlement or crash the server; moderation/account and data-retention behaviour is testable and auditable.
LW-NET-06 — True network measurement#
Implement: Replace encode/copy-only throughput claims with live distributed tests, packet captures, server profiles and long soaks. Document deployment topology, tick rate, payload and client behaviour.
Accept only when: The 32-client integration gate and 128-client final gate both run actual networked clients; server count extrapolation and in-memory framing tests do not count as capacity evidence.
SAVE — Persistence and world recovery#
Accountable discipline: Maya persistence / shared storage. Earliest delivery phase: M4. Prerequisite workstreams: CORE, DATA, WORLD. Starting code/service anchors: libs/maya/engine-core/crates/maya-save-system, libs/maya/engine-core/crates/maya-world-history. Anchors describe candidates, not an approved new folder layout.
LW-SAVE-01 — Versioned saves and checkpoints#
Implement: Persist world/entity state, missions, relationships, inventory, environmental damage, streaming references and required random state with schemas and migration tools.
Accept only when: Golden saves from every supported release migrate and load; missing optional content and incompatible data have clear safe handling.
LW-SAVE-02 — Crash consistency#
Implement: Implement atomic save commits, journals/snapshots where appropriate, integrity verification, interruption recovery and bounded autosave.
Accept only when: Power/process failure at every write stage yields either the prior or new consistent save, never partial inventory, lost quests or corrupted canonical assets.
LW-SAVE-03 — Offline and cloud continuity#
Implement: Provide offline play, optional cloud synchronization, conflict resolution, account changes and export/delete controls using shared storage policies.
Accept only when: Two devices create conflicting progress and recover through a clear user decision; offline availability and deletion propagate as documented.
LW-SAVE-04 — Server persistence and replay#
Implement: Support authoritative snapshots, event histories, recovery points, backups and selective replay with clear determinism limits and migration compatibility.
Accept only when: A failed server restores to the declared recovery point without duplicated transactions; recovery time and data-loss bounds are measured under a real workload.
PLAT — Shipping platform coverage#
Accountable discipline: Platform product integration / platform-ops. Earliest delivery phase: M5. Prerequisite workstreams: GPU, DATA, CORE. Starting code/service anchors: Maya player/server packaging, Existing platform build and release systems. Anchors describe candidates, not an approved new folder layout.
LW-PLAT-01 — Desktop clients and servers#
Implement: Ship installable Windows, Linux and macOS players/editors plus headless dedicated server packages, with actual Vulkan/DX12/Metal use, input/audio/display integration and signed distribution where required.
Accept only when: Clean-device install, play, save, update, rollback and uninstall pass on the exact support matrix; GPU backend names alone do not establish support.
LW-PLAT-02 — Browser and mobile#
Implement: Ship an explicit WebGPU browser profile and native Android/iOS players with touch, lifecycle, permissions, thermal/power budgets and mobile asset/graphics tiers.
Accept only when: Actual browser and phone/tablet builds run the shared conformance project and a coherent flagship-derived experience; physical-device automation and sustained thermal tests pass.
LW-PLAT-03 — XR#
Implement: Ship OpenXR support for PC VR and Quest-class devices plus the approved visionOS integration, with stereo rendering, tracking, hands/controllers, locomotion comfort, haptics and spatial audio.
Accept only when: Device tests meet the declared native refresh budget and interaction/accessibility contract, including tracking loss, recentering and thermal soak. Reprojection is reported separately.
LW-PLAT-04 — Consoles#
Implement: Provide platform backends, builds, controller/user/storage integration and certification evidence for PlayStation 5, Xbox Series X/S and Switch 2 as explicit V1.6 targets, subject to legitimate SDK/devkit access.
Accept only when: Authorized physical-device runs and required certification checks pass. Missing agreements, hardware or credentials remain release blockers; scope does not grant spending or platform access.
LW-PLAT-05 — Release engineering and operations#
Implement: Integrate reproducible builds, signing, symbols/crash collection, staged rollout, install/patch/rollback, support diagnostics and service recovery with the dedicated Build/CI, Dev and UAT fleet.
Accept only when: Platform-ops owns server/deploy work and supplies evidence; product workers own adapters and tests. No new GitHub Pages or unapproved alternate hosting, and no publication without its own permission.
LW-PLAT-06 — Compatibility lifecycle#
Implement: Maintain supported OS/browser/driver/device versions, minimum requirements, deprecation/migration policy and regression corpus. Test upgrades and constrained/offline environments.
Accept only when: Each support claim links a current successful device run and known-limitations record; unsupported profiles fail clearly rather than entering the full-feature scorecard.
SDK — Engine product, ecosystem and adoption#
Accountable discipline: Developer experience / product. Earliest delivery phase: M5. Prerequisite workstreams: EDIT, SCRIPT, DATA, PLAT. Starting code/service anchors: Maya public SDK, Eve documentation and examples, Existing package registry and rights services. Anchors describe candidates, not an approved new folder layout.
LW-SDK-01 — Public SDK and documentation#
Implement: Deliver versioned API references, architecture guides, tutorials, examples, CLI reference, migration guidance and source/debug distribution under clear licence terms.
Accept only when: A clean independent environment follows the docs to build, debug and ship a project without private knowledge; documentation examples execute in CI.
LW-SDK-02 — Templates and sample projects#
Implement: Provide at least three complete templates spanning open-world action, a materially different small game genre and networked play, with source assets, scripts and tests.
Accept only when: Each template produces a playable distributable and demonstrates the public workflow; no template requires copying private flagship internals.
LW-SDK-03 — Packages, plugins and mods#
Implement: Provide a usable package/asset catalogue, dependency resolution, provenance, licensing, permission disclosure, signing and compatibility checks; support safe mod creation and distribution.
Accept only when: Install/update/remove workflows work with real packages and conflicting versions, including an independently produced extension; unsafe plugins cannot inherit privileged editor authority.
LW-SDK-04 — Creator distribution and business readiness#
Implement: Define project ownership, asset/model licence handling, supported distribution destinations, support commitments and optional commercial terms through explicit product decisions.
Accept only when: Creators can understand rights and export their work; no unapproved fees, account creation, purchases or external publication are introduced by the engine workflow.
LW-SDK-05 — External validation and support#
Implement: Run independent developer onboarding, issue reporting, diagnostics, compatibility/support processes and a maintained release channel. Prove the engine on a second game made through public APIs.
Accept only when: An external creator or separately operated independent team ships the second project with measured support load; a maintained pilot demonstrates patching and compatibility over the required observation period.
RND — Cutting-edge methods that earn production use#
Accountable discipline: Rendering / animation research. Earliest delivery phase: M5. Prerequisite workstreams: LIGHT, GEO, ANIM, LOOK. Starting code/service anchors: libs/neith research/rendering crates, libs/maya/engine-core/crates/maya-ml-locomotion. Anchors describe candidates, not an approved new folder layout.
LW-RND-01 — Neural texture compression#
Implement: Implement a real train/encode/decode and runtime residency path for neural texture compression, with licensing/provenance, GPU cost and conventional compressed-texture fallback.
Accept only when: Production assets are evaluated for quality, memory, bandwidth, training/cook time and runtime cost across target GPUs; results are reproducible and the supported mode is usable in the editor.
LW-RND-02 — Neural radiance caching#
Implement: Implement an operational neural radiance-cache lighting mode alongside the conventional GI path, with training/update policy, moving-scene handling and bounded memory/compute.
Accept only when: Dynamic reference scenes demonstrate actual inference/update in the integrated renderer, quality and failure cases are measured, and users can fall back without changing scene semantics.
LW-RND-03 — Learned animation and reconstruction#
Implement: Implement and compare learned motion/animation and advanced learned or analytical reconstruction options against established production baselines with real datasets and held-out scenes.
Accept only when: The selected defaults meet measurable quality/performance goals; alternative modes remain implemented, documented and testable, even when they do not outperform the baseline on every tier.
LW-RND-04 — Capture and novel representations#
Implement: Implement a photogrammetry/scan workflow and a Gaussian-splat or comparable captured-scene mode with editing, streaming, lighting limits and explicit collision/navigation proxies.
Accept only when: A real capture becomes an editable playable environment; dynamic interaction and relighting limits are surfaced, and proxies pass gameplay tests. A captured video is not a playable scene.
LW-RND-05 — Research-to-product discipline#
Implement: Integrate all named research families as working selectable capabilities with benchmarks, editor controls, provenance and supported fallback policies. Record negative results and choose defaults on evidence.
Accept only when: No research requirement closes with a literature survey or empty interface. Production enablement requires stable quality, performance, security and licensing; marketing only claims demonstrated advantages.
VERIFY — Proof, diagnostics and release quality#
Accountable discipline: QA / performance / independent review. Earliest delivery phase: M1. Prerequisite workstreams: GOV. Starting code/service anchors: libs/maya/engine-core/project.json, libs/maya/engine-core/crates/maya-integration-tests, libs/neith/gi-conformance, Existing repository automation. Anchors describe candidates, not an approved new folder layout.
LW-VERIFY-01 — Full verification topology#
Implement: Map and execute relevant lint, typecheck, unit, property/fuzz, integration, contract/schema/migration, build, GPU, performance, security, accessibility and end-to-end gates for every shipping component.
Accept only when: All shipping crates and feature profiles are covered by appropriate targets; the existing narrow default Maya Nx selection cannot stand in for the whole engine.
LW-VERIFY-02 — Correlated observability#
Implement: Integrate CPU/GPU/I/O/streaming/network/audio/AI traces, frame markers, memory snapshots, crashes, source symbols and world/entity IDs in editor and packaged builds.
Accept only when: A failing benchmark produces enough evidence to locate the slow or incorrect subsystem and replay the relevant input/state within stated determinism limits.
LW-VERIFY-03 — Realistic test scenes and failure injection#
Implement: Maintain licensed real assets, recorded gameplay routes, adversarial scenes, fault injection, malformed-data fuzzing, concurrency stress and upgrade/recovery fixtures.
Accept only when: Tests exercise actual renderer, transport, inference, audio and asset parsers; mocks remain useful unit fixtures but cannot pass system or production gates.
LW-VERIFY-04 — Fair competitive assessment#
Implement: Freeze versioned Unreal comparison projects, settings, hardware and routes; compare RAGE through shipped-game outcomes and public developer evidence, with explicit limits on equivalence.
Accept only when: Reports separate equivalent-workload engine measurements from qualitative shipped-game references, include raw results and experimental feature labels, and make no claim about inaccessible RAGE internals.
LW-VERIFY-05 — Usability, accessibility and craft review#
Implement: Run deep Playwright for web/editor surfaces and appropriate native/mobile/XR automation, plus independent creator/player, visual, animation and audio review on fixed rubrics.
Accept only when: Automated passes and human evidence are both present; no self-authored approval or AI-only grade can establish release quality.
LW-VERIFY-06 — Sustained reliability and release evidence#
Implement: Run 8-hour interactive sessions, 72-hour server soaks, update/rollback drills and a 30-day maintained pilot. Retain raw traces, device manifests and benchmark artefacts in Eve media or approved artefact storage.
Accept only when: No open release-blocking defects, corrupt saves, unauthorized actions or unexplained performance regressions; final evidence is bound to exact commits, content revisions and build hashes.
SHIP — Flagship game and final platform demonstration#
Accountable discipline: Game production / programme. Earliest delivery phase: M6. Prerequisite workstreams: GAME, NPC, NET, SAVE, SDK, RND, PLAT, VERIFY. Starting code/service anchors: New flagship project using public Maya SDK, Second independent project, Eve release evidence. Anchors describe candidates, not an approved new folder layout.
LW-SHIP-01 — Maya Living World flagship#
Implement: Deliver a complete playable open-world game on the integrated engine, with final assets, narrative, missions, NPC society, vehicles/mounts, interiors, weather, destruction, sound and persistent consequences.
Accept only when: The final 64 km² world, content/population contract and full gameplay campaign in the acceptance document pass end-to-end. An early district, short demo or isolated feature reel is a milestone only.
LW-SHIP-02 — Cross-system consequence proof#
Implement: Implement the canonical market-stall scenario plus extended mission, ecology and multiplayer scenarios that combine physical action, animation, navigation, perception, dialogue, economy, justice, audio and persistence.
Accept only when: Each scenario passes continuous play, streamed unload/reload, save migration and network reconnection with observable consistent causes and consequences.
LW-SHIP-03 — Independent second game#
Implement: Deliver a different-genre game through the public editor/SDK, created by an independent workflow/team, and at least one third-party or independently authored plugin.
Accept only when: The second game runs and packages without engine forks or privileged flagship APIs; measured creator tasks expose and close missing platform workflows.
LW-SHIP-04 — Full production delivery#
Implement: Complete onboarding, settings/accessibility, credits/licences, save/load, installer/update, diagnostics, support process and the authorized pilot for the engine and games.
Accept only when: A fresh end user can install, play to completion, update, recover a failure and receive support; the 30-day pilot supplies real reliability and adoption evidence.
LW-SHIP-05 — Final release adjudication#
Implement: Assess every requirement, target profile and integrated benchmark against the frozen contract; record independent technical and product reviews and Elikem’s release decision.
Accept only when: V1.6 is complete only when all mandatory requirements and hardware gates pass or Elikem explicitly changes the scope. Release approval and each publication/promotion remain separate recorded decisions.
7. Benchmark sources and limits#
Source baseline checked 2026-10-03. Freeze exact revisions/configurations in M0, and refresh the comparison before final adjudication without moving an agreed gate silently.
- Epic: Unreal Engine 5.8 release announcement establishes the current inspected UE release and distinguishes production, beta and experimental features. Its broad platform/tooling coverage sets a comparison baseline; matching a feature name does not establish parity.
- Epic: World Partition, PSO precaching, Zen Storage Server and Unreal Insights inform streaming, iteration and diagnostic comparison cases.
- Rockstar’s SIGGRAPH 2019 atmospheric-world presentation listing and Rockstar’s GDC presentation on RDR2 horses establish public evidence for integrated atmosphere and believable animal behaviour. They do not reveal all RAGE internals.
- Rockstar: GTA V provides a shipped-game visual/platform reference. RDR2 and GTA V Enhanced supply outcome references; upcoming GTA VI claims are excluded from achieved capability evidence.
- NVIDIA RTX neural texture compression SDK and Ubisoft La Forge learned motion matching are implementation/research references. Their existence does not establish suitability, licensing clearance or a measured win in this engine.
RAGE is proprietary. Do not claim to have audited its source, renderer design or private tools. Competitive claims must name the scene/workflow, metric, device, build and confidence limits. Engine performance comparisons use equivalent licensed assets and workloads; different shipped games support qualitative outcome review, not an apples-to-apples millisecond ranking.
8. Completion and review#
All 126 requirements, the companion’s platform and benchmark gates, both finished projects, required production assets and the maintained pilot are part of V1.6. Approval order is this PRD, then the companion specification pinned to the independently approved PRD revision; architecture decisions are separately approved before dependent implementation. Scope documents remain in Eve. Implementation tasks and their completion evidence belong to the live Eve board, not historical Markdown trackers. Product code follows the repository’s verification, commit and origin/main rules.
Creating this scope neither completes V1.6 nor launches unattended implementation. After approval, decompose the work packages into small claimable tasks with all prerequisites and acceptance tests, preserving full coverage. Development builds may be shown earlier with their actual capability level; they must not be described as the complete V1.6 release.