Game creation platforms
Build browser-based creation tools on composable packages.
Combine editor, scripting, asset, UGC, moderation, and publishing modules to support creator-focused workflows.
TypeScript game engine
Ship platforms,
not prototypes.
The infrastructure layer for interactive web products.
A modular engine in 94 TypeScript packages. For teams building game creation platforms, visual editors, and interactive tools on the web.
TypeScript
import { createWorld, defineComponent } from '@web-engine-dev/ecs'
const Position = defineComponent('Position', { x: 'f32', y: 'f32' })
const Velocity = defineComponent('Velocity', { x: 'f32', y: 'f32' })
const world = createWorld()
const entity = world.spawn()
world.insert(entity, Position, { x: 0, y: 0 })
world.insert(entity, Velocity, { x: 1, y: 0.5 }) 94 packages
10 package groups
WebGPU renderer
Strict TypeScript baseline
ES2022 target
Why teams choose Web Engine
Adopt incrementally
Use one package or compose many. The monorepo currently exposes 94 package modules across 10 groups.
TypeScript-first baseline
Repo defaults use strict TypeScript settings and ES2022 targets, with declarations and tests maintained at package level.
WebGPU rendering stack
Rendering packages are aligned on a WebGPU-only runtime with dedicated modules for render graph, assets, effects, and UI.
Editor and runtime building blocks
Editor and engine packages can be integrated into your own application shell, workflows, and deployment model.
Built for the teams creating the next generation of game creation platforms , visual editors , interactive training tools , product configurators , and web-based game engines
Who builds on Web Engine
Professional game engines
Assemble a full web engine stack from typed modules.
Start from editor packages, customize panels and inspectors, and pair them with renderer, physics, and gameplay modules.
Interactive applications
Power interactive product and simulation experiences.
Use WebGPU rendering, physics packages, and platform modules like analytics, telemetry, and accessibility in one stack.
Build it yourself, or start building your product
This comparison focuses on implementation scope inside this monorepo: what you would need to build in-house versus what is already available as workspace package modules.
Build in-house With Web Engine
Starting scope Define package boundaries and architecture from scratch Start from existing packages and compose only what you need
Subsystem coverage Build and integrate each subsystem yourself 94 packages across core, systems, rendering, tooling, and runtime groups
Renderer stack Implement and maintain your own GPU abstraction Use the existing WebGPU renderer plus render-graph packages
Editor foundation Build panel/layout/inspector infrastructure Adopt editor-core, editor-ui, and editor-viewport packages
Physics integrations Write backend adapters and maintenance layers Use physics2d/physics3d with Rapier-backed implementations
Networking modules Build protocol, server, and matchmaking separately Use netcode, netcode-ecs, netcode-server, and matchmaking packages
Upgrade strategy Maintain every subsystem internally Adopt package updates incrementally and independently
How it works
1
Pick your packages
Install only what you need. A math library. An ECS. A full renderer. Each package works on its own.
2
Build your product
Wire packages into your application, editor, or platform. Use the visual editor as a starting point or build your own UI on top.
3
Deploy by runtime target
Ship for WebGPU-capable browsers first, then add PWA/mobile/XR runtime packages as your product requires.
What's in the box
94 packages across 10 package groups. Adopt one package at a time or compose multiple modules as your product grows.
01
Archetype-based ECS
Typed component schemas, archetype storage, world/query APIs, and scheduler/resource integration in @web-engine-dev/ecs.
02
WebGPU renderer
WebGPU-only renderer and render-graph packages with supporting modules for sprites, tilemaps, particles, text, terrain, and UI.
03
Editor package stack
The editor is split into editor-core, editor-ui, and editor-viewport packages, plus a dockview-based app shell.
04
2D & 3D physics
Interface packages for 2D/3D physics plus Rapier-backed implementations: physics2d-rapier and physics3d-rapier.
05
Networking & netcode
Dedicated packages for netcode, ECS netcode integration, server runtime, and matchmaking.
06
AI & pathfinding
Gameplay modules include ai, ai-ml, pathfinding, procgen, and state packages.
07
Assets & content pipeline
assets, asset-pipeline, scene, prefab, streaming, storage, and compression packages cover loading and authoring workflows.
08
TypeScript-first workspace
ESM packages with TypeScript declarations, strict compiler defaults at repo level, and package-level test suites.
A visual editor
you can make yours
The editor is three packages: editor-core,
editor-ui, and editor-viewport.
Not a monolith you fork and modify. You pick the parts you
need and wire them into your product.
Swap out panels, write custom inspectors, replace the viewport renderer. Plug in your own asset browser and apply your brand.
- Dockable panel layout via dockview
- Component inspector driven by engine metadata
- Scene hierarchy with drag-and-drop reparenting
- Undo / redo command history
- Prefab system with nested overrides
- Plugin architecture for extensions
Inspector
Position 0, 0, 0
Rotation 0, 0, 0
Scale 1, 1, 1
RigidBody2D
Mass 1.0
Damping 0.1
Composable package layers across the monorepo.
Import one package, compose several packages together,
or start from the umbrella @web-engine-dev/engine export.
9 Games space-shooter
8 Runtime mobile, pwa, xr
7 Platform analytics-platform, social, monetization, ugc, moderation, discovery, sandbox, embed, publishing
6 Player i18n, achievements, telemetry, accessibility
5 Meta engine, editor-core, editor-ui, editor-viewport, signals, tween, timer, camera, replay, devtools, benchmark, screenshot, timeline, design-tokens
4 Infrastructure assets, asset-pipeline, scene, prefab, save, streaming, pooling, debug, hot-reload, build, storage, identity, level, binary-compression, texture-compression, geometry-compression
3 Gameplay ai, ai-ml, pathfinding, procgen, state
2 Systems input, audio, physics2d, physics3d, physics2d-rapier, physics3d-rapier, animation, character, gesture, spatial, netcode, netcode-ecs, netcode-server, matchmaking, cloth, destruction, ragdoll
1 Rendering renderer, render-graph, shader-compiler, shader-lib, gltf, particles, sprites, text-rendering, terrain, tilemap, ui, vfx, gizmos
0 Core math, ecs, events, time, scheduler, hierarchy, resources, change-detection, serialization, reflection, scripting, splines
Use one package
import { Vec3, Mat4 } from '@web-engine-dev/math'Or compose several
import { createWorld } from '@web-engine-dev/ecs'
import { createDevice } from '@web-engine-dev/renderer'
import { GLTFLoader } from '@web-engine-dev/gltf'Or use the umbrella
import { create2DEngine } from '@web-engine-dev/engine'Enterprise
Built for teams that ship production software
Web Engine is commercially licensed software designed for product teams that need implementation control, package-level governance, and composable architecture.
Proprietary licensing
Repository licensing is proprietary and commercial. Source and package usage are governed by direct agreement with your team.
Deployment control
Apps and services in this monorepo can be run inside your own infrastructure, with your own release and environment policies.
Auditable package boundaries
Core systems are separated into scoped packages, making dependency review, ownership, and rollout strategy explicit.
Extension-ready architecture
Editor and engine layers expose plugin/extension points so teams can add product-specific workflows without forking everything.
The full inventory
Package names and counts here match the current monorepo layout. Packages ship TypeScript declarations and version independently, so you can adopt one module or compose many.
Category Count Packages
Core 12 math · ecs · events · time · scheduler · hierarchy · resources · change-detection · serialization · reflection · scripting · splines
Rendering 13 renderer · render-graph · shader-compiler · shader-lib · gltf · particles · sprites · text-rendering · terrain · tilemap · ui · vfx · gizmos
Systems 17 input · audio · physics2d · physics3d · physics2d-rapier · physics3d-rapier · animation · character · gesture · spatial · netcode · netcode-ecs · netcode-server · matchmaking · cloth · destruction · ragdoll
Gameplay 5 ai · ai-ml · pathfinding · procgen · state
Infrastructure 16 assets · asset-pipeline · scene · prefab · save · streaming · pooling · debug · hot-reload · build · storage · identity · level · binary-compression · texture-compression · geometry-compression
Meta 14 engine · editor-core · editor-ui · editor-viewport · signals · tween · timer · camera · replay · devtools · benchmark · screenshot · timeline · design-tokens
Player 4 i18n · achievements · telemetry · accessibility
Platform 9 analytics-platform · social · monetization · ugc · moderation · discovery · sandbox · embed · publishing
Runtime 3 mobile · pwa · xr
Games 1 space-shooter
Total 94
Questions
Can I use just one package?
Yes. Every package has its own package entry, types, and tests. Use @web-engine-dev/math and you get a math library module without pulling the full stack.
Does the renderer support WebGL?
No. The renderer targets WebGPU exclusively. It requires a runtime environment with WebGPU support.
Is Web Engine open source?
No. The repository is proprietary/commercially licensed (UNLICENSED package metadata plus proprietary license terms).
Can I use the engine with React or Vue?
Yes. The engine is framework-agnostic TypeScript. Mount the WebGPU canvas in your component and drive the update loop from requestAnimationFrame.
What TypeScript version do I need?
This monorepo is currently built with TypeScript 5.x and targets ES2022. Check package docs for any package-specific compatibility constraints.
How do I get support?
Email contact@web-engine.dev to discuss licensing, integration scope, and support options.
How is Web Engine licensed?
Web Engine uses a commercial license. Pricing is tailored to each team based on scope, scale, and support needs. Reach out to discuss what works for your project.
Can I integrate Web Engine into my existing product?
Yes. Every package works independently. You can adopt a single package into an existing codebase, or use the full engine as the foundation for a new product. No all-or-nothing commitment.
Let's talk about your project
We work with platform teams directly. Tell us what you're building, and we'll show you how Web Engine fits. Custom integrations, dedicated support, and engineering time focused on what you need.