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.

Clustered Forward+ over Three.js, with the supporting cast — instancing, virtual textures, decals, highlights, MikkT tangents, hierarchical occlusion — built in and wired through the ECS.

• Clustered Forward+ lighting
  Thousands of dynamic lights via 3D cluster culling, without per-fragment cost of unclustered forward rendering.
• Point, spot, and directional lights
  Full light-type coverage with efficient GPU buffers and shadow-casting variants.
• Variance shadow maps
  Soft shadow filtering via VSM with efficient summed-area buffers.
• Hierarchical Z occlusion culling
  GPU-accelerated visibility determination via Hi-Z buffers for batch occlusion.
• GPU-driven decals
  Projected decals integrated with the Forward+ light cluster, scaling to large persistent-damage scenes.
• Outline & highlight rendering
  Per-object edge highlights with Gaussian blur and dilation passes.
• Hardware instancing
  Draw-call coalescing for repeated meshes; vegetation, projectiles, crowds.
• Static geometry merging
  Automatic batching of static meshes for reduced draw-call overhead.
• Virtual texturing
  Streamed high-resolution texture tiles via GPU feedback for vast worlds.
• MikkT tangent generation
  Standards-compliant tangent/bitangent computation for correct normal-map shading across tools.
• Ribbon & trail geometry
  Dynamic ribbon primitives with per-segment physics for projectile trails, slashes, sweeping effects.
• 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.

Real-time GI on the web, on commodity hardware. Spherical-harmonics light propagation, physically-based sky, light probes, and a pure-JS path tracer for offline reference.

• Spherical Harmonics (SH3) GI
  Third-order spherical-harmonic representation of indirect lighting for diffuse global illumination.
• Light Propagation Volumes
  Real-time LPV bounce-light propagation in dynamic scenes.
• Hosek physically-based sky
  Hosek-Wilkie analytic sky model with SH3 and LPV integration.
• Light probes
  Octahedral and tetrahedral probe interpolation for per-object indirect lighting.
• Sky cubemap capture
  Runtime cubemap baking for environment reflections and IBL.
• 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.

Two complete particle systems — a zero-allocation runtime engine and a node-graph editor with shader codegen — plus the supporting effects (decals, outlines, ribbons).

• Particular engine
  Zero-allocation GPU particle system with emitter shapes, force simulation, billboard rendering, compiled into four shaders to eliminate state-switching overhead.
• Node-based particle graphs
  Visual particle editor that generates GLSL simulation shaders, with attribute binding and transform feedback.
• Particle forces
  Built-in acceleration, drag, curl noise, and custom-attribute forces 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.
• Highlight outlines
  Per-object outline rendering with configurable colour, width, and edge softness.
• Decal projection (v2)
  Forward+ integrated decals for persistent surface details — battle damage, footprints, environmental marks.

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.
• Skeletal mesh skinning
  GPU-skinned mesh deformation with precomputed bone bounds for fast culling.
• Animation optimization
  Bone-importance analysis for selectively updating only the bones that matter at distance.

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, well beyond the 4-layer limits of common engines.
• Terrain cloud shadows
  Procedural cloud-shadow projection for atmospheric outdoor scenes.
• 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.

View-independent impostor systems for filling vast scenes with distant detail at near-zero per-instance cost.

• Octahedral impostors
  View-independent impostor rendering via octahedral depth-map baking — distant LODs at billboard cost.
• Card-cluster impostors
  Face-plane impostor assignment for vegetation, debris, and high-instance-count props.
• Impostor atlas baking
  Automated impostor atlas generation from source meshes with alpha-based silhouette extraction.

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.

A spatial Web Audio layer with positional sound, attenuation, and ducking for thousands of concurrent sources at zero per-source overhead.

• Web Audio engine wrapper
  AudioContext lifecycle management with built-in handling for browser autoplay rules.
• Spatial sound emitters
  3D-positioned sources with configurable panning models and distance attenuation curves.
• Multi-track sound management
  Per-track playback control, flags, and channel routing for music, SFX, ambient, and UI buses.
• Volume / dB conversions
  Linear-to-decibel utilities for realistic audio mixing and falloff curves.
• Sound culling
  Distance and visibility-based emitter culling for scenes with thousands of potential sources.

Targeted physics — GJK collision, MLS-MPM fluids, intercept solvers — and a complete navmesh-based pathfinding layer integrated with the scene BVH.

• GJK collision detection
  Gilbert-Johnson-Keerthi convex collision queries for fast, robust intersection tests.
• 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.

• Unified input devices
  Single API across mouse, touch, pointer, and keyboard, with device-switch detection.
• 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 rendering
  WebGL minimap with terrain layers, marker overlays, and camera frustum visualization.
• Mesh & canvas preview widgets
  Embedded Three.js mesh 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.
• 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.

Built by an engineer for engineers. The defaults reward correctness in development, get out of the way in production, and never lock you into a black box.

• 4,500+ 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.
• 4,000+ handwritten tests
  Test coverage of critical algorithms, edge cases, and architectural invariants.
• 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
  ~3,000 modules that tree-shake to only what you reference — the engine boots fast and starts streaming assets sooner.
• Optional Three.js peer dep
  3D rendering integrates with Three.js as an optional peer — non-graphics uses don't pull it in.
• No editor required
  Code-first by design. No proprietary scene format, no opaque project files. Edit code, not GUIs.