Light by default. Loaded when you need it.

A strict, data-oriented foundation. One component per type per entity. Predictable memory, O(1) cached queries, hierarchy and scene-graph composition without giving up flat-array speed.

• Pure ECS core
  EntityManager + EntityComponentDataset with strict one-component-per-type discipline, observers, and lifecycle signals.
• High-level Entity builder
  Chainable Entity.add().build(dataset) construction that hides low-level dataset calls when you don't need them.
• Entity hierarchy
  Parent/child links that propagate transforms and cleanup down trees, on top of the flat ECS storage.
• System scheduling
  Automatic execution order derived from each system's declared component dependencies and access kinds.
• Component queries
  Cached, incremental queries by component shape - querying a million matches costs the same per-iteration as a hundred.
• Bone attachment sockets
  Type-aware attachment points for connecting props, weapons, and accessories to skeletal rigs at runtime.
• Dynamic rule engine
  Author conditional rules with cooldowns, predicates, and blackboard state that fire entity actions.
• Entity fitness evaluation
  Point-based fitness functions over entity configurations for procedural placement and optimization.
• Multi-scene architecture
  Independent scenes with isolated entity datasets, transitions, and full serialization.
• Entity reference safety
  Stable entity references that survive generation rollover, save/load, and scene transitions.

Shade: a GPU-driven, visibility-buffer deferred renderer on WebGPU, built into the engine. Meshlet-clustered geometry, GPU culling, froxel-binned deferred lights, temporal resolve and upscaling - and a declared extension point where your own passes go.

• GPU-driven rendering
  Geometry is clustered into meshlets ahead of time and lives GPU-resident in one buffer; culling runs on the GPU and draws are indirect. What is drawn, and in what order, is the renderer's decision rather than a draw call you issue.
• Visibility-buffer deferred shading
  The rasterizer writes a visibility buffer and a G-buffer instead of shading as it draws, so shading cost follows pixels on screen rather than triangles submitted.
• Clustered (froxel) lighting
  Thousands of point and spot lights binned into view froxels on the GPU each frame and applied deferred. Nothing to size or register - the clustering is internal.
• ReSTIR direct lighting
  Reservoir spatiotemporal importance resampling for many-light scenes, replacing the froxel loop in the deferred pass when it is enabled.
• Shadows
  Cascaded shadow maps for the sun and an atlas for local lights, with a resolution policy that spends the atlas where it shows.
• Order-independent transparency
  Transparent surfaces composite without a per-frame CPU sort, on top of the deferred opaque pass.
• Virtual geometry
  Stream .vgeo meshlet hierarchies with GPU detail selection, RAM/VRAM page budgets and renderer integration; explicit runtime and feedback setup.
• Virtual texturing
  Streamed page tables per material via GPU feedback; albedo, normal and ORM come from streamed pages instead of whole textures.
• GPU-driven decals
  Frustum-culled and cluster-assigned on the GPU, composited against the G-buffer out of a shared atlas. Capacity grows with the record buffer rather than sitting behind a fixed cap.
• Outline & highlight rendering
  Per-object outlines resolved as a neighbourhood test on the visibility buffer, with configurable thickness.
• GPU animation & skinning
  Skins and clips registered once and evaluated on the GPU, with the CPU keeping the clock so gameplay reads the pose that is on screen.
• Render extensions
  Your own passes declare a frame phase and an ordering against other extensions, and exchange typed records with the frame - no patching of the pipeline, and work nothing consumes is elided by the frame graph.
• Dynamic meshes
  A separate path for content whose vertices change every frame - trails, ribbons, debug lines - drawn without paying for a meshlet build.
• Async batched picking
  Picking queries are batched and answered off the GPU-driven scene index. There is no synchronous pick, by design.
• Render to texture
  The canvas is one target among others: render a frame into a texture you own, for thumbnails, previews and image-based tests.
• Camera shake
  Trauma-based procedural camera shake driven by impact events.
• Distance field generation
  Signed and unsigned distance fields baked from geometry, for UI, effects, and procgen.

The image half of the renderer: temporal resolve, upscaling, and a post chain that is part of the frame rather than a stack you assemble.

• TAA
  Variance-clip temporal anti-aliasing in YCoCg with a Blackman-Harris resolve, doubling as the upscale stage.
• Neural super sampling
  A kernel-prediction network upscaler shipped with trained weights, selectable in place of TAA.
• Dynamic resolution scaling
  Internal resolution driven from measured frame time, with warmup, probing and hysteresis rather than a hard switch.
• Ground-truth ambient occlusion
  GTAO with bent normals and optional diffuse indirect, denoised and reprojected. On by default.
• Screen-space reflections
  Trace, prefilter, reproject, denoise and combine, for surfaces the environment probe cannot describe.
• Depth of field
  Two implementations - a ray-marched aperture model and a gather-based cinematic one - sharing autofocus, aperture shape and presets.
• Motion blur
  Tile-max and neighbour-max reconstruction from the per-object velocity buffer.
• Bloom & automatic exposure
  A Karis-average bloom chain that also feeds histogram-based auto-exposure with temporal adaptation.
• Contrast-adaptive sharpening
  RCAS sharpening after the upscale, so an upscaled frame does not read soft.
• GPU path tracing
  An accumulating path tracer inside the renderer for reference images, alongside the pure-JS CPU tracer that runs off the engine's own BVH.

Indirect light on the web, on commodity hardware: an image-based default, a baked volumetric lightmap for scenes that want bounce, and a propagation volume that updates every frame.

• Image-based indirect lighting
  The environment map is both the background and the ambient term, sampled for diffuse and specular indirect. A scene without one renders unlit, so one is installed by default.
• Brick4 volumetric lightmap
  A sparse volumetric lightmap baked from the scene and carried at runtime by a component, for bounce light that survives moving cameras and dynamic objects.
• Light propagation volumes
  Progressive per-frame GPU probe propagation for coarse dynamic bounce.
• Volumetric fog & participating media
  Fog, smoke, dust and cloud volumes posed as entities and composited with the lit frame, parameterised by scattering rather than by a colour and a density slider.
• Hosek physically-based sky
  Hosek-Wilkie analytic sky rendered on the CPU into an environment map you assign to the scene.
• Environment loading
  Cube folders and equirectangular sources converted to the octahedral projection the renderer samples, with no separate prefilter step.
• Pure-JS path tracer
  Monte-Carlo path tracer with Russian-roulette termination, material sampling, and BVH acceleration - runs entirely in JS for offline reference renders.

GPU particle simulations authored as node graphs, carried by ParticleEffect components and composited through Shade, plus decals, outlines and trails.

• Particle graph authoring
  Explicit particle state with INIT and UPDATE graphs for spawning, movement, lifetime, colour and size curves. Graphs compile to reusable simulation bytecode.
• GPU particles
  ParticleEffect ECS components drive GPU spawning and simulation, with serialization, prewarming, measured bounds, shared texture atlases and order-independent transparency.
• Particle forces
  Compose acceleration, drag, noise and custom state in simulation graphs for organic motion.
• Soft particles
  Depth-aware particle blending that avoids hard intersections with scene geometry.
• Automatic atlassing
  Particle textures packed into atlases automatically to keep batches tight.
• Trails
  Tube trails extruded behind moving entities, rewritten every frame, with age, width, spawn mode and colour driven from the component.
• Highlight outlines
  Per-object outline rendering with configurable colour and thickness, resolved against the visibility buffer.
• Decal projection
  Projected surface overrides for persistent detail - battle damage, footprints, environmental marks - with separate albedo, normal, ORM and emissive channels.

State-machine animation graphs with N-D blend spaces, humanoid skeletons, and multiple IK solvers - FABRIK for arbitrary chains, two-bone for limbs, surface alignment for foot placement on terrain.

• Animation state machines
  Multi-state animation controllers with transition conditions, layering, and per-bone masking.
• Blend spaces
  N-dimensional parameter interpolation for smooth motion blending - locomotion, aim poses, mood.
• Animation clip events
  Frame-synced event firing from animation clips for foot plants, sound triggers, gameplay hooks.
• Humanoid skeleton mapping
  Standard humanoid bone taxonomy for retargeting and IK-ready rig setup.
• FABRIK inverse kinematics
  Iterative IK solver for arbitrary chain lengths - bipeds, quadrupeds, tentacles, tails.
• Two-bone IK
  Closed-form solver for arm and leg chains with pole-target control.
• Surface-alignment IK
  One-bone surface-snap solver for foot placement and contact alignment on uneven terrain.
• GPU skinning
  Skins and animation clips registered with the renderer and evaluated on the GPU, with per-entity instances of one loaded model.
• Clip optimization
  Redundant keyframes removed from a loaded clip before it is registered, so a long animation costs what it needs to.

A complete world layer - tile-based heightfield terrain with worker-thread LOD, splat-mapped materials, water with shore transitions, and procedurally-driven cloud shadows.

• Tile-based terrain
  Chunked heightfield terrain with auto-culling, worker-thread LOD generation, and seamless tile transitions.
• Multi-layer splat mapping
  Splatmap-driven material blending across many terrain layers - bounded by the device's texture-array depth rather than by an engine constant.
• Terrain overlays
  Dynamic overlay rendering for fog of war, area markers, build placement previews.
• Cling-to-terrain
  Component that snaps and aligns objects to the heightfield automatically.
• Water rendering
  Wave simulation, depth-based fog, shore transitions, and light scattering through the water column.

What you reach for when the picture is wrong or the frame is slow: a GPU capture format, a software device that runs shaders' validation without a GPU, and an editor that attaches to a running game.

• GPU profile capture
  Hand the renderer a profile session and it writes a self-framed capture of pass timings, frame-graph structure, dispatch and draw counts. The writer and the reader both ship, and the container is specified.
• Software WebGPU device
  A validating software device and a WGSL interpreter, so your own pipelines and bindings can be exercised in tests on a machine with no GPU.
• In-app editor
  Opt-in editor that attaches to a running engine and detaches again: entity inspection, gizmo tools, particle authoring, docked panels and layout persistence.
• Model thumbnails
  Render a loaded model to an off-screen target with a fixed framing and light rig, for inventory icons and asset browsers.
• Debug drawing
  Gizmo primitives drawn through the renderer for physics shapes, paths, bounds and one-off diagnostics.

Industry-standard AI primitives rare in JS engines - behavior trees with full composite/decorator/event toolkit, blackboards, MCTS, and a resource-allocation solver for strategic planning.

• Behavior trees
  Composite, decorator, selector, and primitive nodes with the full toolkit for hierarchical agent AI.
• Blackboards
  Shared context storage with signal dispatchers for inter-node and inter-agent communication.
• Monte-Carlo Tree Search
  AlphaGo-family planner for turn-based decisions and game-theoretic optimization.
• Resource allocation solver
  Strategic multi-bid solver that distributes limited resources (ammo, health, currency, time) optimally across competing demands.
• State graphs / FSM
  Declarative finite-state machines with signal-driven transitions, suitable for actor controllers.
• Weighted random selectors
  Probabilistic behavior selection with weighted choice for non-deterministic agent variety.
• Event-driven behaviors
  Send/wait/kill event behaviors for cross-agent communication within behavior trees.
• Promise-based behaviors
  Async task wrappers for long-running AI operations - loading, network calls, animated sequences.
• Behavior serialization
  Full save/load adapters for in-flight behavior trees, including pending states and timers.

A composable marker-and-rule procedural pipeline for grid-based worlds, with 25+ cell filters and a theme system that bundles biomes end-to-end.

• Marker-based generation
  Rule-and-marker composable pipeline - emit markers, match patterns, transform the grid.
• Cellular automata
  Neighbor-sum rules for cave generation, smoothing, and emergent terrain patterns.
• Multi-layer grid generation
  Stack-of-layers generator with per-layer rules and cross-layer matchers.
• Theme system
  Bundled biome definitions - terrain layers, marker rules, transformation rules - applied as one unit.
• Cell filters
  25+ filters: dilate, erode, blur, gradients, Sobel edges, step/lerp/saturate, Gaussian, lookup tables.
• Distance fields
  Unsigned distance fields over grid cells for obstacle-aware placement and falloff.
• Pattern matchers
  Local neighborhood pattern detection with arbitrary mask shapes and rotational variants.
• Predicate combinators
  AND/OR/NOT/any/none predicates over markers and cell data for expressive rules.
• Weighted random placement
  Probability-driven action selection over candidate cells with weight functions.

The foundations every engine needs done right - a memory-tight BVH, robust geometric predicates, splines, noise, and a color toolkit that includes modern perceptually-uniform spaces.

• Bounding Volume Hierarchy
  Memory-optimized BVH at 40 bytes/node with SAH layout for ray, AABB, sphere, and frustum queries.
• Incremental BVH updates
  Dynamic-scene BVH maintenance via Morton-code reordering without full rebuild.
• Ray intersection suite
  Ray-triangle, ray-sphere, ray-AABB intersection with barycentric output for bulk queries.
• Frustum classification
  Inside/intersect/outside frustum-AABB tests for LOD culling and streaming decisions.
• Catmull-Rom splines
  Uniform and non-uniform splines with derivative computation for camera paths and smooth motion.
• Simplex & curl noise
  2D and 3D simplex noise plus 3D+time curl noise for organic motion and procedural detail.
• Robust geometric predicates
  Orient3D, in-sphere, barycentric tests with adaptive precision for reliable mesh operations.
• Delaunay tetrahedralization
  Cavity-based 3D point-cloud triangulation for volumetric meshing.
• Winged-edge topology
  Manifold mesh data structure for editing, traversal, and validation.
• Vector / matrix / quaternion
  Complete linear algebra with in-place math operations to avoid allocations in hot loops.
• Eigenvalue decomposition
  Spectral analysis for mesh quality assessment and graph partitioning.
• Graph algorithms
  Greedy/MCS coloring, Laplacian/adjacency matrices, K-means, METIS partitioning, multigraph coarsening.
• Hemioct normal encoding
  Octahedron-mapped unit-vector compression to 2 bytes for tight G-buffers and vertex streams.
• RGBE9995 HDR
  Compact high-dynamic-range colour encoding for linear-space rendering.

A scientific-grade color toolkit - perceptually-uniform spaces, gamut mapping, color temperature, CMFs - that takes color seriously where most engines wave their hands.

• OKLab / Okhsv
  Perceptually-uniform color spaces for accurate gradients and color blending - handles hue/lightness without the kinks of HSL.
• Gamut mapping
  Max-saturation computation and gamut intersection for safe color transitions in OKLab and Okhsv.
• Color temperature
  Planckian-radiance Kelvin conversion with D65 spectral power distribution.
• Color matching functions
  Tabulated CIE colour-matching functions for spectral-to-tristimulus conversions.
• sRGB / linear conversions
  Standards-compliant gamma conversions with both fast and high-precision paths.
• YCbCr encoding
  Compact color storage for compression pipelines.

An event-driven audio engine over Web Audio - authorable sound events, a mixer bus tree with effects, live parameters, snapshots, and spatial 3D that scales to ~100k registered emitters - driven through ECS with one component and one system.

• Event-driven playback
  Sound events are plain, serializable engine data: a clip graph plus routing, 3D, and voice configuration - owned by an AudioEmitter component, no global sound bank.
• Clip containers
  Sequence, weighted-random (with avoid-repeat), parameter-driven switch, and parameter-blended layering - composed into trees, resolved at trigger time.
• Mixer bus tree with effects & sends
  Hierarchical buses with EQ, compressor, and procedural-IR reverb inserts, plus post-fader aux sends for shared reverbs.
• Live parameters
  Named runtime values drive clip selection and bus-volume automation through curves - surface-aware footsteps, tension-driven music.
• Snapshots & ducking
  Named mix states applied as click-safe ramps, and play-state ducking rules - dialogue over music, impacts over ambience.
• Spatial 3D at scale
  HRTF or equal-power panning with curve-driven attenuation and voice virtualization; a live/dormant budget lets a scene register ~100,000 positional emitters while only the audible few cost anything.
• Deterministic playback
  Random selection and per-trigger randomization run on seeded RNG - networked clients resolve identical audio under lockstep.

A rigid-body physics engine built into the box - pure JS, deterministic and bit-exact across V8, scaled for massive worlds, with a full joint and constraint system - plus GJK collision, MLS-MPM fluids, and a navmesh pathfinding layer on the scene BVH.

• Rigid-body physics engine
  Built-in rigid-body simulation - Static / Dynamic / Kinematic bodies, sphere / box / capsule colliders, friction and restitution. No WASM, no third-party library to wire up.
• Deterministic & bit-exact
  Fixed-timestep TGS solver that produces the same result bit-for-bit across every V8 runtime - the foundation for lockstep netcode, replays, and reproducible tests.
• Dual-BVH broadphase
  Separate static and dynamic broadphase trees; level geometry is inserted once and never refit, so per-frame cost tracks the moving set, not the world size.
• Island solving & atomic sleeping
  The awake contact graph is partitioned into islands; settled piles sleep - and wake - as a unit, dropping out of the active set entirely.
• Contact events & sensors
  ContactBegin/Stay/End events dispatched per entity, and sensor colliders for triggers, with a user contact filter and layer/mask collision groups.
• Spatial queries
  Raycasts, convex shape-casts (swept time-of-impact), and speculative overlap tests against both physics BVHs - the backbone of character controllers and hit detection.
• Joints & constraints
  A configurable 6-DOF Joint - ball-socket, hinge, slider, weld, cone-twist - with per-axis limits, springs, and motors. Chains and ropes, ragdolls, doors, suspension, powered hinges.
• GJK collision detection
  Gilbert-Johnson-Keerthi convex collision queries for fast, robust intersection tests.
• Volumetric fluid simulation
  An incompressible-flow solver on a staggered grid - ECS fluid volumes stirred by wake, impulse, and wind effectors, with a world-space velocity-sampling API for gameplay (bending trees, drifting particles).
• MLS-MPM fluid simulation
  Material-Point-Method fluid dynamics for water, mud, granular materials, and particle physics.
• Intercept point calculation
  Closed-form intercept solver for predictive aiming, targeting, and pursuit.
• Navigation meshes
  Pre-baked navmesh support with face-based pathfinding accelerated by the scene BVH.
• Navigation agents
  Agent abstraction for applying navmesh-driven movement to entities with steering and avoidance.

A unified input abstraction across mouse, touch, pointer, and keyboard, with event-driven and query-based APIs and stateful controller contexts - up to a complete first-person character controller.

• First-person character controller
  A kinematic-capsule mover with procedural camera feel - gait-driven head bob, exertion-scaled breathing, jump anticipation, landing recovery, coyote time, variable jump height - and an opt-in parkour ability set (slide, mantle, wall-run, wall-jump, ledge-grab) over a shared sensor layer. Driven by an input-agnostic intent surface; publishes read-only state, signals, and pose channels for HUDs, audio, and rigs.
• Unified input devices
  Single API across mouse, touch, pointer, keyboard and gamepad, with device-switch detection.
• Input maps & bindings
  Actions bound to keys, buttons, chords, sequences and holds, arranged in layers within a map and arbitrated between maps by order and occlusion.
• Control context state machines
  Stateful controllers that own input state and orchestrate transitions cleanly.
• Locational interaction
  Per-event position and hit-test context for UI and worldspace interactions.
• Cursor type control
  Programmatic cursor changes driven by interaction state.

A complete in-house UI system - zero-garbage, GPU-friendly - covering everything from tooltips and currency displays to radial menus and virtual lists. Optional: swap in React, Vue, or your own if you prefer.

• Radial menu
  Donut-ring contextual menus with weighted item layout and focus highlighting.
• Tooltip GML parser
  Game Markup Language for rich-text tooltips with style tokens, references, and embedded values.
• Currency display system
  Multi-denomination coin/currency rendering with sorted value hierarchies and animated transitions.
• Segmented resource bars
  Multi-segment progress bars for stacked resources like health pips or ammo clips.
• Radial progress
  Circular progress indicators with smooth animations.
• GUI controls
  Adaptive input controls - numeric, vector, vector3, dropdown, checkbox, color picker - bound to game state.
• Drag and drop
  Drag-and-drop with target/source abstractions and visual feedback.
• Virtual list view
  Viewport-recycling scrolling for large data sets without DOM bloat.
• Modal dialogs
  Built-in modals with confirmation patterns and accessible dismissal.
• Toast notifications
  Transient notification queue with achievement-style pop-ups and log views.
• Tab navigation
  ViewStack for hierarchical view management and breadcrumbed navigation.
• Minimap
  Canvas2D minimap composited from data the CPU already owns - terrain image cache, markers, camera frustum and the renderer's own fog-of-war mask.
• Model & canvas preview widgets
  Off-screen model thumbnails and canvas previews for inventory icons and inspectors.

Production-grade save/load - binary serialization with versioned migration, IndexedDB or in-memory backends, transient marking, and entity refs that survive transitions.

• Binary serialization
  Compact, fast binary save format for entities and components.
• Versioned format migration
  Per-component upgrader chains automatically migrate save files across engine versions.
• Storage backends
  IndexedDB, in-memory, and pluggable backends for browser and embedded scenarios.
• Transient entity marking
  Flag entities and components to skip serialization - for runtime-only effects, debug spawns, or session state.
• Entity references
  References that remain valid across save/load and scene transitions.

Deterministic action replication for true client-side prediction. Server-authoritative or peer-to-peer. Built for multi-client games without bolting a netcode library on top.

• Action replication
  Forward action logs between peers with scope filtering; receivers re-execute actions locally for client-side prediction.
• Server-authoritative mode
  Server-driven sessions with role-based state management and authoritative simulation.
• Peer-to-peer mode
  Symmetric peer-to-peer sessions for cooperative play without a central server.
• Entity scope filtering
  Replicate only entities relevant to each peer based on ownership or spatial proximity.
• Interpolation & time-sync
  Adaptive render delay and time dilation to smooth network latency and jitter.
• Network identity & ownership
  Per-entity ownership and network identifiers for multi-peer synchronization.

The supporting cast every shipping game needs - asset pipeline, plugins, options, achievements, localization, metrics, and a live performance dashboard.

• Priority-based asset loading
  Async asset pipeline with configurable concurrency and priority queueing.
• Asset transformers
  Extensible loader pipeline for custom formats and preprocessing.
• Cross-origin asset config
  Per-asset CORS and credential controls for hosted content.
• In-engine image codecs
  PNG at every bit depth, JPEG, and a from-scratch AVIF encoder and decoder in pure JavaScript - no WebAssembly - behind a decoder that prefers the browser's own where there is one.
• Off-thread image decoding
  Workers spawned lazily for image decode and encode, self-terminating when idle, and falling back inline where no worker can be had.
• In-engine image codecs
  PNG at every bit depth, JPEG, and a from-scratch AVIF encoder and decoder in pure JavaScript - no WebAssembly - behind a decoder that prefers the browser's own where there is one.
• Off-thread image decoding
  Workers spawned lazily for image decode and encode, self-terminating when idle, and falling back inline where no worker can be had.
• Plugin architecture
  Engine plugins that hook startup, frame updates, and shutdown without forking the core.
• Options framework
  Hierarchical settings with reactive UI bindings - generate options panels from definitions.
• Achievement system
  Achievement tracking, persistence, and notification-driven unlock animations.
• Localization
  i18n keys with formatter support across UI, tooltips, and notifications.
• Performance dashboard
  Ring-buffer metrics with a live in-browser overlay for profiling during play.
• Pluggable logging
  Console, void, and Elasticsearch backends - route logs without touching call sites.
• Metrics & analytics
  Categorized event tracking with Google Analytics integration and pluggable backends.
• Notification system
  Engine-wide notification queue for UI, achievements, and system messages.

Defaults reward correctness in development, get out of the way in production, and never lock you into a black box.

• 6,000+ runtime assertions
  Asserts at the source of every invariant - caught instantly in dev, stripped entirely from production builds.
• Strip plugin integration
  @rollup/plugin-strip removes every assertion in production for native-speed runtime.
• 15,000+ handwritten tests
  Critical algorithms, edge cases, determinism, adversarial cases and shader emulation, in the engine's own suites.
• Source-available
  Full engine source ships in the npm package - no binary blobs, no obfuscation, no closed precompiled modules.
• JSDoc-typed JavaScript
  Authored in JavaScript with JSDoc; TypeScript declarations generated by the build for TS users.
• Fine-grained ES modules
  ~6,000 modules that tree-shake to only what you reference - the engine boots fast and starts streaming assets sooner.
• Two dependencies
  opentype.js and robust-predicates. The renderer is part of the engine, not a peer you install alongside it.
• No editor required
  Code-first by design: no proprietary scene format and no opaque project files. An in-app editor is there when you want to inspect a running game, and nothing depends on it.
• WebGPU target
  One backend, no fallback path and no degradation tiers. Hardware below the device floor gets a clear failure message instead of a quietly worse frame.
• Headless testing
  A validating software WebGPU device lets engine-facing tests run in CI without a GPU.