Features

This page provides a complete overview of what Web Engine Dev offers, organized by package category. Each package listed here is a real, importable @web-engine-dev/* npm package with its own test suite.

Core (12 packages)

Foundation packages with minimal or zero dependencies.

@web-engine-dev/math

High-performance vector, matrix, and quaternion math library with zero dependencies.

• Types: Vec2, Vec3, Vec4, Mat3, Mat4, Quat, DualQuat, Transform, AABB, Plane, Frustum, Color
• Three API tiers: Immutable (default), Mutable (addMut, scaleMut), Batch (BatchMath on Float32Arrays)
• MathPool: Object pooling with scoped acquire/release for zero-allocation hot paths
• MathUtils: Bezier curves, barycentric coordinates, easing functions, angle interpolation
• Conventions: Right-handed, Y-up, column-major matrices, radians

@web-engine-dev/ecs

Archetype-based Entity Component System with SoA columnar storage.

• Components: Typed schema (f32, i32, u8, bool, etc.), tags (zero-size markers), sparse components
• Queries: Builder pattern with with, without, withOptional, read, write access declarations
• Query filters: Added, Changed, Removed for change detection
• Systems: defineSystem with automatic dependency-based scheduling
• Commands: Deferred world mutations via command queue (spawn, insert, remove, despawn)
• Events: Double-buffered event queues (write this frame, read next frame)
• Observers: Component lifecycle triggers (OnAdd, OnRemove, OnChange)
• Resources: Typed global singletons via defineResource
• Relations: Entity-to-entity relationships with hierarchy support
• Parallel execution: Web Worker support with SharedArrayBuffer, conflict detection
• Snapshots: Serialize/deserialize world state

@web-engine-dev/events

Standalone double-buffered event system with typed event descriptors.

@web-engine-dev/time

Frame time management with fixed timestep support, time scaling, and pause.

@web-engine-dev/scheduler

System scheduling with stages, system sets, run conditions, topological ordering, and async concurrency.

@web-engine-dev/hierarchy

Parent-child relationship management for non-ECS contexts (DOM, scene graphs).

@web-engine-dev/resources

Typed resource container with defineResource, lazy initialization, and change tracking.

@web-engine-dev/change-detection

Proxy-based reactive change detection for non-ECS scenarios.

@web-engine-dev/serialization

Binary and JSON serialization with schema versioning and type handlers.

@web-engine-dev/reflection

Runtime type reflection system for component introspection and editor integration.

@web-engine-dev/scripting

Script lifecycle management with hot reload support and ECS integration.

@web-engine-dev/splines

Catmull-Rom and Bezier splines with arc-length parameterization, SplineFollower, and mesh deformation.

Rendering (12 packages)

Graphics pipeline from device abstraction to post-processing.

@web-engine-dev/renderer

Complete rendering pipeline with a WebGPU runtime backend.

• Device abstraction: Unified GpuDevice interface for WebGPU runtime execution
• Materials: PBR metallic-roughness (glTF-aligned), PBR Advanced (clearcoat, transmission, sheen, iridescence), Unlit
• Lighting: Directional, point, and spot lights with clustered forward rendering
• Shadows: Cascaded shadow maps (directional), cube map shadows (point), spot shadow maps, alpha-test shadow casting
• Image-based lighting: Equirect-to-cubemap conversion, irradiance maps, prefiltered environment maps, BRDF LUT, multi-scatter compensation
• Post-processing: 22 effects including Bloom, FXAA, TAA, SSAO, SSGI, Depth of Field, Color Grading, Tonemapping (ACES, Reinhard), Vignette, FSR, CAS
• Geometry: Box, sphere, plane, cylinder, torus, and custom mesh creation with instanced rendering
• Culling: CPU frustum culling and GPU occlusion culling (compute shader on WebGPU)
• GPU-driven rendering: Indirect draw with SoA instance layout
• ECS integration: Transform3D, CameraComponent, light components, MeshComponent, MaterialComponent, ForwardRenderSystem
• Render bundles: Cached draw command recording on WebGPU for reduced CPU overhead
• Runtime optimizations: Render bundles, variant caches, clustered lighting, and GPU-driven rendering paths

@web-engine-dev/render-graph

DAG-based render pass scheduling with automatic resource management and lifetime tracking.

@web-engine-dev/shader-compiler

WGSL tooling package with preprocessor directives, shader variants, manifest workflows, and transpilation utilities.

@web-engine-dev/gltf

glTF 2.0 and GLB loader with PBR material mapping, skeletal animation, morph targets, and ECS entity spawning. Uses createImageBitmap with straight alpha preservation for texture loading.

@web-engine-dev/particles

GPU particle systems with compute-shader simulation and an optional CPU simulation backend. Supports emission shapes, forces, color/size over lifetime, and looping emitters.

@web-engine-dev/sprites

2D sprite rendering with SpriteBatcher, sprite sheets, source rectangles, and SpritePlugin for ECS integration.

@web-engine-dev/text

Text rendering with font loading and glyph management.

@web-engine-dev/terrain

CDLOD terrain rendering with heightmap-based mesh generation, instanced patch rendering, level-of-detail morphing, and skirt geometry.

@web-engine-dev/tilemap

Tile-based map rendering with layer support.

@web-engine-dev/ui

In-game UI components with a layout engine and Canvas2D backend.

@web-engine-dev/vfx

Visual effects system for combining particle effects and post-processing.

@web-engine-dev/gizmos

Editor gizmo rendering for transform handles, selection highlighting, and debug visualization. Supports audio source gizmos and component-specific gizmo registration.

Systems (17 packages)

Runtime systems for input, physics, audio, networking, and more.

@web-engine-dev/input

Unified input with action mapping across keyboard, mouse, gamepad, and touch.

• Action maps: Abstract actions from physical inputs with rebindable bindings
• Value types: Button (pressed/justPressed/justReleased), Axis1D, Axis2D, Axis3D
• Input contexts: Stack-based priority system for UI vs. gameplay input routing
• Touch gestures: Tap, double tap, long press, swipe, pinch, rotate, pan
• Gamepad: Standard mapping, deadzone, haptic feedback
• Pointer lock: FPS-style raw mouse input
• Recording/playback: Input replay for testing and demos

@web-engine-dev/audio

Game audio engine built on Web Audio API.

• Audio buses: Hierarchical mixing with effects (reverb, compressor, EQ, delay, chorus, flanger)
• Spatial audio: HRTF panning, distance attenuation models (linear, inverse, exponential), Doppler effect
• Sound pools: Pre-allocated pools with voice stealing policies (oldest, lowest-priority, least-audible, combined)
• Adaptive music: Layered tracks, beat-synchronized transitions, parameter-driven triggers
• Voice management: Priority-based allocation, spatial culling, per-bus voice limits
• Audio node pooling: Reusable GainNode/PannerNode to reduce garbage collection

@web-engine-dev/physics2d

2D physics interface: rigid bodies, shapes (circle, box, polygon, edge, chain), fixtures, joints, collision detection, raycasting, and sensors.

@web-engine-dev/physics3d

3D physics interface: rigid bodies, shapes, joints, raycasting, and collision groups.

@web-engine-dev/physics2d-rapier

Rapier WASM adapter implementing the physics2d interface.

@web-engine-dev/physics3d-rapier

Rapier WASM adapter implementing the physics3d interface.

@web-engine-dev/animation

Skeletal animation system with comprehensive features.

• Clips and tracks: Keyframe animation for position, rotation, scale, morph weights, and color
• Interpolation: Step, linear, cubic spline, Catmull-Rom
• State machines: Parameter-driven transitions with conditions
• Blend trees: 1D, 2D (Cartesian, Directional, GradientBand), additive, select
• Animation layers: Override and additive blending with masking
• IK solvers: CCD, FABRIK, Two-Bone, Limb, LookAt, Aim, Full Body, Foot IK
• Procedural animation: Breathing, jiggle physics, noise-based modifiers, spring dynamics
• Root motion: Extraction and application from animation clips
• Compression: Meshopt-based keyframe reduction and quantization
• glTF integration: Direct creation of clips from glTF channels

@web-engine-dev/spatial

Spatial indexing and queries (spatial hashing, grid-based lookups).

@web-engine-dev/netcode

Game networking with client-server and rollback models.

• State sync: Full snapshots, delta compression, interest management
• Client prediction: Input prediction with server reconciliation
• Lag compensation: Server rewind for hit validation
• Rollback: Deterministic simulation for fighting/sports games
• Transport: WebSocket, WebRTC, and WebTransport support

@web-engine-dev/netcode-ecs

ECS integration layer for the netcode package, mapping network state to ECS components.

@web-engine-dev/netcode-server

Authoritative game server with Node.js and Deno support, frame codec, and compression.

@web-engine-dev/matchmaking

Matchmaking system for player lobby management and game session coordination.

@web-engine-dev/character

Character controller systems for first-person and third-person movement.

@web-engine-dev/gesture

Gesture recognition for complex touch input patterns.

@web-engine-dev/cloth

Cloth simulation with 2D and 3D solvers, grid-based mesh generation, sphere/box colliders, and distance constraints.

@web-engine-dev/ragdoll

Ragdoll physics simulation with joint constraints.

@web-engine-dev/destruction

Destructible object systems.

Gameplay (5 packages)

Game logic systems for AI, pathfinding, and procedural generation.

@web-engine-dev/ai

Game AI toolkit with multiple decision-making approaches.

• Finite State Machines (FSM): States, transitions, conditions
• Behavior Trees: Sequence, Selector, Parallel, Decorator, Action, Condition nodes; event-driven ticking
• GOAP: A* and backward-chaining planners with plan caching
• Utility AI: Response curves (linear, quadratic, logistic, exponential, sine), consideration scoring, cooldowns
• Perception: Visual sense (line-of-sight, FOV), audio sense, stimulus memory with decay
• Blackboard: Typed shared knowledge base with observers
• Steering behaviors: Seek, flee, arrive, pursue, evade, wander, separation, alignment, cohesion

@web-engine-dev/ai-ml

Machine learning integration for game AI (neural networks, reinforcement learning).

@web-engine-dev/pathfinding

Navigation and pathfinding with multiple algorithms.

• A*: Standard pathfinding with configurable heuristics (Manhattan, Euclidean, Chebyshev, Octile)
• Jump Point Search (JPS): Optimized for uniform-cost grids
• HPA*: Hierarchical pathfinding for large maps with incremental dirty-cluster updates
• Theta* / Lazy Theta*: Any-angle pathfinding with line-of-sight checks
• D* Lite: Dynamic replanning for changing environments
• Flow Fields: Vector field navigation for many agents sharing a goal
• NavMesh: 3D polygon-based navigation with spatial hash acceleration
• RVO: Reciprocal Velocity Obstacles for collision-free crowd simulation with KD-tree neighbor queries
• Async pathfinding: Frame-budgeted execution and Web Worker offloading
• NavigationGrid: 2D grid with obstacle management and cost modification

@web-engine-dev/procgen

Procedural generation utilities (noise functions, terrain generation).

@web-engine-dev/state

Game state management with finite state machines and state stacks.

Infrastructure (16 packages)

Asset loading, scene management, serialization, and build tooling.

Package	Description
assets	Asset loading, caching, and reference management
asset-pipeline	Build-time asset processing and optimization (Node.js)
scene	Scene graph management, entity hierarchy serialization
prefab	Prefab templates with override tracking
save	Save/load game state persistence
level	Level management and loading
build	Production build system with tree-shaking and bundling (Node.js)
debug	Debug utilities, invariant() assertions, diagnostic bus
storage	Abstract storage interface (localStorage, IndexedDB, file system)
streaming	Asset streaming and progressive loading
pooling	Object pool management for reusable resources
hot-reload	Development-time hot module replacement (Node.js)
binary-compression	Binary data compression utilities
texture-compression	GPU texture compression (BCn, ASTC, ETC2)
geometry-compression	Mesh geometry compression
identity	Entity identity and lifecycle management

Meta (14 packages)

Engine umbrella, editor packages, and development utilities.

Package	Description
engine	Umbrella package re-exporting all modules with presets (Game2DPreset, Game3DPreset, HeadlessPreset, etc.)
editor-core	Editor backend: command history, selection, clipboard, configuration, plugins, sessions, viewport management
editor-ui	Editor UI layer: auto-inspector, property editors, shortcuts, drag-and-drop, ECS world bridge
editor-viewport	Editor viewport management and camera controls
camera	Camera utilities (orbit, fly, follow, cinematic)
tween	Tweening library with easing functions
timer	Timer management (one-shot, repeating, scaled)
signals	Reactive signals system
replay	Game replay recording and playback
timeline	Timeline system for sequenced events
design-tokens	Design token definitions for UI theming
devtools	Development tools and debug overlays
benchmark	Performance benchmarking infrastructure
screenshot	Canvas screenshot capture utilities

Player (4 packages)

Player-facing features for internationalization, achievements, and accessibility.

Package	Description
i18n	Internationalization with locale management
achievements	Achievement and trophy system
accessibility	Accessibility features (screen reader support, high contrast, input remapping)
telemetry	Analytics and telemetry collection

Platform (9 packages)

Platform services for publishing, social features, and monetization.

Package	Description
analytics	Analytics platform integration
social	Social features (friends, leaderboards, sharing)
monetization	In-app purchase and monetization
ugc	User-generated content management
moderation	Content moderation tools
discovery	Game discovery and recommendation
sandbox	Sandboxed execution environment
embed	Embeddable game widget support
publishing	Game publishing and distribution

Runtime (3 packages)

Runtime targets for different platforms.

Package	Description
mobile	Mobile platform optimizations and native bridge
pwa	Progressive Web App support (service worker, manifest, offline)
xr	WebXR integration for VR and AR

Games (1 package)

Package	Description
space-shooter	Reference 2D space shooter game demonstrating ECS, sprites, physics, input, audio, and particle systems

Next Steps

• Comparison with Other Engines -- How these features stack up
• Getting Started -- Start building with Web Engine Dev
• Package Reference -- Detailed documentation for each package