Enjin Engine
COMPREHENSIVE TECHNICAL ANALYSIS // 2026-03-08 // C++20 | VULKAN | CMAKE
1. System Architecture Diagram
The Enjin engine is organized in a strict layered architecture. The Core layer has zero engine dependencies, the Engine layer builds on Core, and the Application layer (Editor, Player) consumes Engine. All inter-system communication flows through well-defined interfaces.
graph TB
subgraph ApplicationLayer["Application Layer"]
Editor["Editor App
(EditorLayer, ImGui)"]
Player["Player App
(Standalone Runtime)"]
Hub["Hub App
(Project Launcher)"]
end
subgraph EditorSystems["Editor Systems"]
PlayMode["PlayMode
(Play/Pause/Stop)"]
PlayModeDiff["PlayModeDiff
(Cherry-pick Changes)"]
ScenePicker["ScenePicker
(Ray Cast Selection)"]
Gizmos["ImGuizmo
(Transform Gizmos)"]
TemplateSystem["Template System
(44 Templates + Creator
+ Marketplace)"]
InspectorUndo["Inspector Undo/Redo
(PropertyEditCommand)"]
Panels["32 Editor Panels
(Hierarchy, Inspector,
Console, Asset Browser...)"]
Notifications["Toast Notifications
(4 Types, Slide-in)"]
CommandPalette["Command Palette
(Ctrl+P, Fuzzy Search)"]
end
subgraph RendererLayer["Renderer"]
VulkanContext["VulkanContext
(Instance, Device, Queues)"]
VulkanRenderer["VulkanRenderer
(Swapchain, Frame Sync)"]
VulkanPipeline["VulkanPipeline
(Graphics Pipeline,
Descriptor Sets)"]
VulkanBuffer["VulkanBuffer
(Vertex, Index, Uniform,
Storage Buffers)"]
RenderSystem["RenderSystem
(Entity Rendering,
Material Sort, Caching)"]
PostProcessing["PostProcessing
(Bloom, Vignette, FXAA,
DoF, Tilt-Shift, Film Grain,
Color Grading, Stipple/Dither,
SSAO, God Rays, Contact
Shadows, Caustics, Fog Shafts)"]
ShadowSystem["Shadow System
(4-Cascade CSM, Point
Cubemap, Spot 2D Array)"]
SpriteBatch["SpriteBatchRenderer
(GPU Instanced)"]
SpriteAtlas["SpriteTextureAtlas
(4096x4096 Shelf-Pack)"]
ParticleRenderer["ParticleRenderer
(GPU Instanced Billboards,
16384 Particles)"]
RetroEffects["RetroEffects
(CRT, Pixelation, Dither)"]
Skybox["Skybox
(Cubemap, Procedural,
Solid Color)"]
subgraph RayTracing["Ray Tracing Pipeline"]
RTCapabilities["RTCapabilities
(Extension Detection)"]
AccelStructures["AccelerationStructureManager
(BLAS Cache, TLAS Rebuild)"]
RTPipeline["RTPipeline
(SBT Construction)"]
RTShadows["RTShadows (R16F)"]
RTReflections["RTReflections (RGBA16F)"]
RTAO["RTAO (R16F)"]
RTGI["RTGI (RGBA16F)"]
PathTracer["PathTracer
(Progressive Accumulation)"]
SVGFDenoiser["SVGFDenoiser
(3-Pass Compute)"]
OIDNDenoiser["OIDNDenoiser
(Intel Neural Denoise)"]
RTCompositor["RTCompositor
(Fullscreen Compute)"]
end
subgraph AdvancedRendering["Advanced Rendering"]
SHProbes["SH Light Probes
(L2, Grid Baking)"]
SDFScene["SDF Scene
(6 Primitives, 6 Ops)"]
OIT["OIT
(Weighted Blended)"]
CelShading["Cel Shading
(Band Quantization,
Sobel Outlines)"]
VXGI["Voxel Cone Tracing
(Diffuse/Specular GI)"]
NonEuclidean["Non-Euclidean Geometry
(Portal, Hyperbolic,
Spherical, Toroidal)"]
Metaballs["Metaball Rendering
(Marching Cubes)"]
end
subgraph GPUDriven["GPU-Driven Pipeline"]
GPUCulling["GPUCulling
(Two-Phase HiZ
Occlusion Culling)"]
ClusteredLighting["ClusteredLighting
(16x9x24 Grid,
Compute Dispatch)"]
LODSystem["LOD System
(Screen-Space Sizing,
Hysteresis)"]
VRSSystem["Variable Rate Shading
(VK_KHR_fragment_shading_rate)"]
VirtualTex["Virtual Texturing
(Page Streaming,
Indirection Table)"]
VisBuffer["Visibility Buffer
(Deferred Material Resolve)"]
FrameAlloc["FrameAllocator
(Per-Frame Linear Alloc)"]
end
end
subgraph ECSLayer["ECS Architecture"]
World["ECS::World
(Thread-Safe, Deferred
Destroy, Name Cache)"]
Entity["ECS::Entity (u64 ID)"]
Components["70+ Component Types"]
subgraph ComponentCategories["Component Categories"]
CoreComponents["Core: Transform, Mesh,
Material, Light, Camera,
Name, Notes"]
PhysicsComponents["Physics: Rigidbody,
Box/Sphere/Capsule Collider,
6 Joint Types, Ragdoll"]
GameplayComponents["Gameplay: Health, Damage,
Inventory, SaveData,
Quest, HUD, Cinematic"]
VisualComponents["Visual: Sprite2D, Tilemap,
ParticleEmitter, Billboard,
AnimatedSprite2D"]
ControllerComponents["Controllers: Platformer2D,
TopDown2D/3D, FPS, TPS,
Vehicle"]
AIComponents["AI: AIController,
BehaviorTree, Waypoint,
FollowTarget, LookAtTarget"]
NetworkComponents["Network: NetworkIdentity,
NetworkTransform"]
end
subgraph Systems["ECS Systems"]
ControllerSystem["ControllerSystem
(6 Controller Types)"]
AISystem["AISystem
(Patrol/Chase/Flee/
Wander/Navmesh)"]
end
end
subgraph PhysicsLayer["Physics"]
IPhysicsBackend["IPhysicsBackend
(Abstract 3D Interface)"]
IPhysicsBackend2D["IPhysicsBackend2D
(Abstract 2D Interface)"]
JoltBackend["JoltBackend
(Jolt v5.2.0, Multi-threaded,
CCD, 6 Joint Types)"]
Box2DBackend["Box2DBackend
(Box2D v3.0.0, Sub-stepping,
5 Joint Types, CCD)"]
PhysicsFactory["PhysicsBackendFactory
(Auto/Jolt/Box2D)"]
SpatialHash["SpatialHashGrid
(Broad-Phase O(N) vs O(N^2))"]
end
subgraph AudioLayer["Audio"]
SimpleAudio["SimpleAudio
(miniaudio Backend)"]
SteamAudio["SteamAudioProcessor
(HRTF Binaural Rendering,
Occlusion + Transmission,
Geometry-Aware 3D)"]
Audio3D["3D Spatialization"]
AudioMixing["Multi-Channel Mixing"]
MIDIInput["MIDI Input
(WinMM, 12 AS Bindings)"]
AudioEventGraph["Audio Event Graph
(Runtime Execution,
.enjaudiopkg)"]
end
subgraph ScriptingLayer["Scripting"]
AngelScript["AngelScript Engine
(~844 Bindings,
Hot-Reload)"]
TegeBehavior["TegeBehavior
(Base Script Class)"]
VisualScript["Visual Scripting
(222+ Nodes, Debugger,
Profiler)"]
StateMachine["State Machines
(Script Callbacks)"]
Coroutines["Coroutines
(Yield/Resume)"]
EventBus["EventBus
(Pub/Sub Events)"]
FlashShim["Flash API Shim
(~40 Bindings,
AS2/AS3 Transpiler)"]
DataAssets["DataAsset System
(Schemas + Instances)"]
end
subgraph EffectsLayer["Effects & Procedural"]
Weather["WeatherSystem
(Rain, Snow, Fog, Storm)"]
Water3D["Water3D
(Gerstner Waves)"]
InteractiveWater["Interactive Water
(Spring-Damper, Buoyancy)"]
ParticleSystem["ParticleSystem
(CPU Sim, 5 Shapes,
12 Presets)"]
FluidSim["Fluid Simulation
(Stable Fluids, 5 Presets)"]
FluidTerrain["FluidTerrainCoupling
(Erosion + Accumulate)"]
ReactionDiffusion["Reaction-Diffusion
(Gray-Scott, 9 Presets)"]
CellularAutomata["CA Geometry
(7 Rules, 3 Mesh Modes)"]
Physarum["Physarum Simulation
(50K+ Agents)"]
FourierMesh["Fourier Mesh
(DFT, 3D Extrusion)"]
Projection4D["4D Projection
(5 Polytopes)"]
WindSystem["Wind System"]
WorldTime["World Time / Seasons"]
subgraph ProceduralGen["Procedural Generation"]
CellularAutomataGen["Cellular Automata
(Cave Gen)"]
BSP["BSP
(Room-Corridor Dungeons)"]
DiamondSquare["Diamond-Square
(Heightmap Terrain)"]
LSystem["L-System
(3D Stochastic Rules)"]
WFC["Wave Function Collapse
(Tile-Based)"]
Voronoi["Voronoi
(3 Distance Metrics)"]
RandomWalker["Random Walker"]
Grammar["Grammar Rules"]
PrefabAssembler["Prefab Assembler
(Snap-Together Rooms)"]
FractalTerrain["Fractal Terrain
(fBm, Erosion)"]
end
end
subgraph NetworkingLayer["Networking"]
LANMultiplayer["LAN Multiplayer
(Host-Authoritative UDP)"]
NetworkSecurity["Network Security
(HMAC-SHA256, Replay
Protection)"]
HTTPClient["HTTP Client
(WinHTTP + libcurl)"]
NewgroundsAPI["Newgrounds.io API
(Medals, Scores, Cloud)"]
SteamBackend["Steam Save Backend
(ENJIN_STEAM)"]
end
subgraph GUILayer["GUI / UI System"]
UICanvas["UICanvasComponent
(Element Tree, Themes)"]
UISystem["UISystem
(Layout, Render, Input,
Focus Navigation)"]
UIWidgets["8 Widget Types
(Panel, Button, Label,
Image, Progress, Slider,
Checkbox, Toggle)"]
NineSlice["Nine-Slice Sprites"]
DialogueBox["DialogueBoxComponent
(Auto-Build UI)"]
FocusNav["Focus Navigation
(Tab/DPad/Arrow, WCAG)"]
end
subgraph AccessibilityLayer["Accessibility"]
ColorblindFilter["Colorblind Filter
(8 Modes + Safe Palettes)"]
SubtitleSystem["Subtitle System"]
ContentWarning["Content Warning System"]
ReducedMotion["Reduced Motion"]
ScreenReader["Screen Reader Announcer"]
SwitchAccess["Switch Access
(One-Button Scanning)"]
DwellClick["Dwell-Click / Sticky Drag"]
AltInput["Alternative Input
(Eye Tracking, Head
Tracking, Sip-and-Puff)"]
HighContrast["High Contrast Themes
(WCAG AAA 7:1+)"]
FontScaling["Font Scaling /
Dyslexia Mode"]
end
subgraph BuildLayer["Build & Assets"]
BuildPipeline["BuildPipeline
(Scan, Validate, Pack,
NSIS Installer, CPack)"]
AssetPacker["AssetPacker
(.enjpak, CRC32, XOR)"]
GLTFLoader["GLTFLoader
(Native glTF/GLB)"]
AssimpLoader["AssimpLoader
(FBX/OBJ/DAE/PLY/VOX)"]
SceneImporter["SceneImporter
(Auto-Detect Format)"]
PrefabManager["PrefabManager
(.enjprefab)"]
HTML5Export["HTML5 Export
(Canvas, Preloader,
Newgrounds Template)"]
SceneSerializer["SceneSerializer
(JSON)"]
LevelStreaming["Level Streaming
(StreamingVolume/Portal)"]
end
subgraph ToolsLayer["Graph Editors & Tools"]
ShaderGraph["Shader Graph
(62 Nodes, GLSL Codegen,
.enjshader)"]
ParticleGraph["Particle Graph
(Compiler to Emitter,
.enjparticle)"]
DialogueEditor["Dialogue Editor
(7 Node Types, .enjdlg)"]
BehaviorTreeEditor["Behavior Tree Editor
(20 Node Types)"]
QuestFlowEditor["Quest Flow Editor"]
TimelineEditor["Timeline Editor
(Flash-Style, Keyframes)"]
PixelEditor["Pixel Editor
(8 Tools, 9 Retro Presets)"]
VectorDrawing["Vector Drawing Editor
(7 Shapes, SVG Export)"]
Profiler["Profiler
(P50/P95/P99, CSV Export)"]
PluginSystem["Plugin System
(Hot-Reload, PluginSDK.h)"]
end
subgraph CoreLayer["Core Layer (No Engine Dependencies)"]
Application["Application"]
Window["Window (GLFW)"]
Input["Input System"]
MathLib["Math Library
(Vector, Matrix, Quaternion,
Spline, Noise)"]
Memory["Memory Allocators
(Stack, Pool, Linear)"]
Logging["Logging
(Thread-Safe, Categorized)"]
Platform["Platform Abstraction
(PlatformTarget)"]
Types["Type Aliases
(u8-u64, i8-i64, f32/f64)"]
end
%% Application -> Editor Systems
Editor --> PlayMode
Editor --> Panels
Editor --> ScenePicker
Editor --> Gizmos
Editor --> TemplateSystem
Editor --> Notifications
Editor --> CommandPalette
%% Editor -> Engine
PlayMode --> RenderSystem
PlayMode --> PhysicsFactory
PlayMode --> AngelScript
PlayMode --> VisualScript
PlayMode --> AISystem
PlayMode --> SimpleAudio
%% Player -> Engine
Player --> RenderSystem
Player --> PhysicsFactory
Player --> AngelScript
Player --> VisualScript
Player --> ParticleSystem
Player --> PostProcessing
%% Renderer connections
RenderSystem --> VulkanPipeline
RenderSystem --> VulkanBuffer
RenderSystem --> ShadowSystem
RenderSystem --> SpriteBatch
RenderSystem --> SpriteAtlas
RenderSystem --> ParticleRenderer
RenderSystem --> Skybox
RenderSystem --> SHProbes
VulkanPipeline --> VulkanContext
VulkanBuffer --> VulkanContext
VulkanRenderer --> VulkanContext
PostProcessing --> VulkanPipeline
RetroEffects --> PostProcessing
%% RT connections
RenderSystem --> AccelStructures
AccelStructures --> RTPipeline
RTPipeline --> RTShadows
RTPipeline --> RTReflections
RTPipeline --> RTAO
RTPipeline --> RTGI
RTPipeline --> PathTracer
RTShadows --> SVGFDenoiser
RTReflections --> SVGFDenoiser
RTAO --> SVGFDenoiser
RTGI --> SVGFDenoiser
SVGFDenoiser --> RTCompositor
OIDNDenoiser --> RTCompositor
%% Physics
PhysicsFactory --> JoltBackend
PhysicsFactory --> Box2DBackend
PhysicsFactory --> SimplePhysics
JoltBackend --> IPhysicsBackend
Box2DBackend --> IPhysicsBackend2D
ControllerSystem --> IPhysicsBackend
ControllerSystem --> IPhysicsBackend2D
%% ECS
World --> Entity
World --> Components
RenderSystem --> World
ControllerSystem --> World
AISystem --> World
%% Scripting
AngelScript --> TegeBehavior
AngelScript --> World
AngelScript --> SimpleAudio
VisualScript --> World
VisualScript --> IPhysicsBackend
%% Build
BuildPipeline --> AssetPacker
BuildPipeline --> SceneSerializer
SceneImporter --> GLTFLoader
SceneImporter --> AssimpLoader
%% Core dependencies
RenderSystem --> MathLib
World --> Memory
Application --> Window
Window --> Input
Application --> Logging
Application --> Platform
Architectural Highlights
- Strict layering: Core has zero Engine dependencies. Engine never references Editor or Player.
- Physics abstraction:
IPhysicsBackend/IPhysicsBackend2Dinterfaces allow swapping Jolt or Box2D at runtime viaPhysicsBackendFactory. The legacy SimplePhysics backend was removed entirely in Feb 2026, eliminating technical debt. - Thread safety: ECS World uses recursive mutex for structural operations; entity destruction is deferred and flushed at frame start. O(1) entity validation via
unordered_set(Feb 2026 ECS audit). - Spatial audio pipeline: Steam Audio HRTF binaural rendering with geometry-aware occlusion and transmission, layered on top of the miniaudio backend.
- Hardened codebase: 10+ audit rounds, 205+ findings fixed across Vulkan renderer, ECS, serialization, physics, and scripting subsystems. All VkResult calls checked; null guards on all physics/audio paths.
- GPU-driven rendering: Two-phase HiZ occlusion culling, clustered forward lighting (16x9x24 grid), 64-bit material sort keys, per-frame linear allocator (
FrameAllocator), async compute overlap, LOD with screen-space sizing and hysteresis. Optional subsystems behind CMake flags: Variable Rate Shading (VK_KHR_fragment_shading_rate), Virtual Texturing (page-based streaming), Visibility Buffer (deferred material resolve). - Advanced materials: PBR with transmission, IOR, thickness, subsurface scattering (intensity/radius/color).
MaterialGPU= 80 bytes. - Test infrastructure: 50 CTest targets (~700+ test cases) organized into
Tests/Unit/andTests/Integration/with a sharedEnjinTest.hframework.
2. Feature Completeness Matrix
This matrix compares Enjin's current feature set against five established game engines. Ratings are based on the depth and production-readiness of each feature area.
Rating Key:
- Full -- Feature-complete, production-ready, comparable to or exceeding competitors
- Partial -- Functional but missing some capabilities vs. competitors
- Basic -- Implemented but limited scope
- Stub -- Interface exists, minimal implementation
- None -- Not present
| Category | Enjin | Unity | Godot | Unreal | GameMaker | Construct |
|---|---|---|---|---|---|---|
| 2D Rendering | Full | Full | Full | Full | Full | Full |
| 3D Rendering | Full | Full | Partial | Full | None | None |
| PBR Materials | Full | Full | Full | Full | None | None |
| Ray Tracing | Full | Full | None | Full | None | None |
| Post-Processing | Full | Full | Full | Full | Basic | Basic |
| Shadows (CSM/Point/Spot) | Full | Full | Full | Full | None | None |
| Sprite Batching/Atlas | Full | Full | Full | Partial | Full | Full |
| Skeletal Animation | Full | Full | Full | Full | Basic | None |
| Sprite Animation | Full | Full | Full | Partial | Full | Full |
| 3D Physics (Production) | Full | Full | Full | Full | None | None |
| 2D Physics (Production) | Full | Full | Full | Partial | Basic | Basic |
| Physics Joints | Full | Full | Full | Full | None | None |
| Audio Engine | Full | Full | Full | Full | Full | Full |
| 3D Spatial Audio | Full | Full | Full | Full | None | None |
| MIDI Input | Basic | Partial | None | None | None | None |
| Text Scripting | Full | Full | Full | Full | Full | None |
| Visual Scripting | Full | Partial | Full | Full | Partial | Full |
| Hot-Reload | Full | Full | Partial | Full | N/A | N/A |
| State Machines | Full | Partial | Partial | Full | None | None |
| Editor (GUI) | Full | Full | Full | Full | Full | Full |
| Scene Hierarchy | Full | Full | Full | Full | Basic | Basic |
| Inspector/Properties | Full | Full | Full | Full | Partial | Partial |
| Undo/Redo | Full | Full | Full | Full | Full | Full |
| Multi-Select | Full | Full | Full | Full | Partial | Partial |
| Transform Gizmos | Full | Full | Full | Full | None | None |
| Asset Browser | Full | Full | Full | Full | Partial | Partial |
| Tilemap Editing | Full | Full | Full | None | Full | Full |
| Terrain Sculpting | Partial | Full | Partial | Full | None | None |
| Prefab System | Full | Full | Full | Full | None | None |
| Build/Export Pipeline | Full | Full | Full | Full | Full | Full |
| HTML5 Export | Full | Partial | Full | None | Full | Full |
| Console Support | Stub | Full | Partial | Full | Full | Partial |
| Mobile Support | None | Full | Full | Full | Full | Full |
| LAN Multiplayer | Full | Partial | Partial | Full | Basic | Partial |
| HTTP/REST Client | Full | Full | Partial | Full | Full | Full |
| Save System | Full | Basic | Basic | Partial | Basic | Basic |
| Quest System | Full | None | None | None | None | None |
| Dialogue Trees | Full | None | None | None | None | None |
| AI / Behavior Trees | Full | None | None | Full | None | None |
| Navmesh / Pathfinding | Full | Full | Full | Full | Basic | Partial |
| UI System (Runtime) | Full | Full | Partial | Full | Basic | Full |
| Accessibility | Full | Partial | Partial | Partial | None | Basic |
| Procedural Generation | Full | None | None | Partial | None | None |
| Weather System | Full | None | None | None | None | None |
| Particle System | Full | Full | Full | Full | Full | Partial |
| Shader Graph | Full | Full | Full | Full | None | None |
| Plugin/Extension System | Full | Full | Full | Full | Partial | Partial |
| Profiler | Full | Full | Partial | Full | Basic | None |
| Localization | Full | Partial | Full | Full | None | Partial |
| Level Streaming | Full | Full | None | Full | None | None |
| Retro/CRT Effects | Full | Basic | None | None | None | None |
| Flash/SWF Import | Full | None | None | None | None | None |
| Newgrounds Integration | Full | None | None | None | None | None |
| HRTF Binaural Audio | Full | Partial | None | Full | None | None |
| Audio Occlusion/Transmission | Full | Partial | None | Full | None | None |
| Sprite Normal Map Lighting | Full | Full | Full | N/A | None | None |
| Automated Test Suite | Full | Full | Partial | Full | None | None |
| Clustered Forward Lighting | Full | Full | None | Full | None | None |
| GPU Occlusion Culling | Full | Full | None | Full | None | None |
| LOD System | Full | Full | Basic | Full | None | None |
| Variable Rate Shading | Basic | Partial | None | Full | None | None |
| Virtual Texturing | Basic | Full | None | Full | None | None |
| Visibility Buffer | Basic | Partial | None | Full | None | None |
Summary by Engine
| Engine | Full | Partial | Basic | Stub | None |
|---|---|---|---|---|---|
| Enjin | 56 | 1 | 4 | 1 | 1 |
| Unity | 41 | 9 | 2 | 0 | 7 |
| Godot | 31 | 10 | 2 | 0 | 16 |
| Unreal | 44 | 6 | 0 | 0 | 9 |
| GameMaker | 14 | 5 | 9 | 0 | 30 |
| Construct | 13 | 9 | 5 | 0 | 31 |
Enjin achieves surprisingly broad feature coverage for a single-developer engine, now including Steam Audio HRTF spatial audio, sprite normal map lighting, clustered forward lighting, GPU two-phase HiZ occlusion culling, LOD with hysteresis, and a 50-target automated test suite (~700+ test cases). Its main gaps are mobile platform support and console certification (which require licensed devkits and partnership agreements). Variable Rate Shading, Virtual Texturing, and Visibility Buffer are implemented behind compile-time feature flags (OFF by default).
3. Engine Evolution Timeline
This timeline shows the actual development history reconstructed from git commit dates. The entire engine was built in approximately 11 weeks, starting December 23, 2025.
gantt
title Enjin Engine Development Phases (Actual Git History)
dateFormat YYYY-MM-DD
axisFormat %m/%d
section Foundation (Week 1)
Project Init & Vulkan Swapchain :done, f1, 2025-12-23, 2025-12-24
3D Rendering Pipeline & GPU Culling :done, f2, 2025-12-24, 2025-12-25
Core Layer (Types, Math, Platform) :done, f3, 2025-12-23, 2025-12-25
section Renderer & Editor (Week 2)
Shader Compilation & Triangle Fix :done, r1, 2026-01-22, 2026-01-27
Engine Infrastructure (Input, glTF, ImGui) :done, r2, 2026-01-27, 2026-01-28
Blinn-Phong Lighting & PBR Materials :done, r3, 2026-01-27, 2026-01-28
Shadow Mapping (CSM) :done, r4, 2026-01-28, 2026-01-28
section Core Systems (Week 3)
Post-Processing & Retro Effects :done, s1, 2026-01-28, 2026-01-30
Weather, Water, Wind & Vegetation :done, s2, 2026-01-29, 2026-01-30
Skeletal Animation (GPU Skinning) :done, s3, 2026-01-30, 2026-01-30
Physics & Collision Detection :done, s4, 2026-01-30, 2026-01-30
Parallax & Normal Mapping :done, s5, 2026-01-30, 2026-01-30
section Editor & Audio (Week 4)
Scene Management & 21 Templates :done, e1, 2026-01-31, 2026-01-31
Accessibility, Input Remapping, UI System :done, e2, 2026-01-31, 2026-01-31
Skybox, Undo/Redo, IK Solvers, Prefabs :done, e3, 2026-01-31, 2026-01-31
Audio (miniaudio Backend) :done, e4, 2026-01-31, 2026-01-31
Build Pipeline & Splitscreen :done, e5, 2026-02-01, 2026-02-01
section 2D Pipeline (Week 5)
Terrain Sculpting :done, d1, 2026-02-02, 2026-02-02
2D Editor Tools (Sprite, Tilemap) :done, d2, 2026-02-02, 2026-02-02
Runtime UI System & 2.5D Lit Sprites :done, d3, 2026-02-02, 2026-02-02
Particle & Sprite Batch Renderers :done, d4, 2026-02-02, 2026-02-03
Collision Filtering (32-group Bitmask) :done, d5, 2026-02-03, 2026-02-03
section Scripting & Tools (Week 6)
Dialogue Trees & State Machines :done, t1, 2026-02-04, 2026-02-04
AngelScript Bindings & Shader Hot-Reload :done, t2, 2026-02-04, 2026-02-04
Noise Library & Tweening (25 Easings) :done, t3, 2026-02-04, 2026-02-04
29 Enhanced Templates & 2D/3D Mode :done, t4, 2026-02-04, 2026-02-05
9-Slice, Asset Metadata, 2D Camera :done, t5, 2026-02-05, 2026-02-05
section Visual Scripting & Perf (Week 7)
Visual Scripting (Phases 1-4) :done, v1, 2026-02-06, 2026-02-06
Shadow Optimization & Descriptor Caching :done, v2, 2026-02-06, 2026-02-08
Soft Shadows, Point/Spot Shadow Maps :done, v3, 2026-02-07, 2026-02-08
Sprite Texture Atlas (4096x4096) :done, v4, 2026-02-08, 2026-02-08
Fence-Based GPU Sync (18 Subsystems) :done, v5, 2026-02-07, 2026-02-07
section Massive Expansion (Week 8)
AI/BT, 2D Physics, Proc Gen, Destructibles :done, m1, 2026-02-09, 2026-02-09
Localization, Fluid Sim, Pixel Editor :done, m2, 2026-02-09, 2026-02-09
SVG, Empty States, Dialogue Box, Icons :done, m3, 2026-02-09, 2026-02-09
RT Pipeline, Collaborative Editing :done, m4, 2026-02-10, 2026-02-10
Newgrounds API, HTML5 Export, Vector Editor :done, m5, 2026-02-10, 2026-02-10
Cel Shading, Save System, PlayMode Diff :done, m6, 2026-02-10, 2026-02-10
section Physics & Platform (Week 9)
IPhysicsBackend + Jolt v5.2.0 Backend :done, p1, 2026-02-11, 2026-02-11
Box2D v3.0.0 Backend :done, p2, 2026-02-11, 2026-02-11
Template Redesign (38 → 22 → 43) :done, p3, 2026-02-12, 2026-02-13
Stipple/Dither, Camera Presets, DoF :done, p4, 2026-02-12, 2026-02-12
OIT, SH Probes, SDF Scene, POM Modes :done, p5, 2026-02-13, 2026-02-13
Physics Phase 4-5 (Jolt/Box2D Default) :done, p6, 2026-02-13, 2026-02-13
section Advanced & Exotic (Week 10)
Linux/Steam Deck, Switch Stub, Hub App :done, a1, 2026-02-14, 2026-02-14
9 Exotic Rendering Systems :done, a2, 2026-02-14, 2026-02-14
Shader/Audio/Particle Graphs, MIDI Input :done, a3, 2026-02-14, 2026-02-14
Symbol Library, Newgrounds Game Page :done, a4, 2026-02-14, 2026-02-14
Template Marketplace, Gamepad Editor :done, a5, 2026-02-14, 2026-02-14
section Polish & Audits (Week 11)
Audio Rewrite (miniaudio), Audio Mixer :done, q1, 2026-02-15, 2026-02-15
Post-Process Volumes, Screen-Space Effects :done, q2, 2026-02-15, 2026-02-15
InputAction System, NSIS Installer :done, q3, 2026-02-16, 2026-02-16
Networking Security (HMAC-SHA256) :done, q4, 2026-02-16, 2026-02-17
5+ Security/Stability Audit Rounds :done, q5, 2026-02-11, 2026-02-17
section Hardening & Audio (Week 12)
SimplePhysics Legacy Backend Removed :done, h1, 2026-02-18, 2026-02-18
Steam Audio HRTF Phase 1 (Binaural) :done, h2, 2026-02-18, 2026-02-18
Steam Audio Phase 2 (Occlusion/Transmission):done, h3, 2026-02-18, 2026-02-18
ECS Tier 1 Audit (O(1) Validation, 40 Tests):done, h4, 2026-02-17, 2026-02-17
Vulkan Renderer Hardening (VkResult/Leaks) :done, h5, 2026-02-17, 2026-02-18
80+ Medium-Severity Audit Fixes (23 Files) :done, h6, 2026-02-17, 2026-02-18
42 More Audit Fixes (Physics/Script/Scene) :done, h7, 2026-02-18, 2026-02-18
Serialization & Asset Pack Hardening :done, h8, 2026-02-18, 2026-02-18
6 New Test Suites (Physics2D, VS, BT, UI, Net, Fuzz) :done, h9, 2026-02-17, 2026-02-17
3 More Test Suites + Unit/Integration Reorg :done, h10, 2026-02-19, 2026-02-19
MaturityTier Badges (Hub + Marketplace) :done, h11, 2026-02-19, 2026-02-19
Sprite Normal Map Lighting + Drop Shadows :done, h12, 2026-02-18, 2026-02-18
CSM Cascade Blending + Tether Rework :done, h13, 2026-02-18, 2026-02-18
Player Auto Title Screen + Pause Menu :done, h14, 2026-02-18, 2026-02-18
Editor Viewport Camera/Gizmos in Play Mode :done, h15, 2026-02-18, 2026-02-18
section GPU-Driven & Advanced (Weeks 13-14)
Clustered Forward Lighting (16x9x24) :done, g1, 2026-02-20, 2026-02-25
GPU Two-Phase HiZ Occlusion Culling :done, g2, 2026-02-20, 2026-02-25
LOD Hysteresis + Screen-Space Sizing :done, g3, 2026-02-22, 2026-02-25
64-bit Material Sort Keys :done, g4, 2026-02-22, 2026-02-25
FrameAllocator (Per-Frame Linear Alloc) :done, g5, 2026-02-23, 2026-02-25
Variable Rate Shading (VK_KHR) :done, g6, 2026-02-25, 2026-03-01
Virtual Texturing (Page Streaming) :done, g7, 2026-02-28, 2026-03-05
Visibility Buffer (Deferred Resolve) :done, g8, 2026-03-01, 2026-03-05
Material Enhancements (Transmission/SSS) :done, g9, 2026-02-25, 2026-03-01
Async Compute Overlap :done, g10, 2026-02-25, 2026-03-01
Box2D Sensor Body Sync :done, g11, 2026-03-03, 2026-03-05
Elemental System + AngelScript Bindings :done, g12, 2026-03-05, 2026-03-07
BSL 1.1 Open-Source License Decision :done, g13, 2026-03-07, 2026-03-07
Test Expansion (26 to 50 targets, 700+ cases):done, g14, 2026-03-01, 2026-03-08
section Planned
macOS (MoltenVK) :active, pl1, 2026-03-01, 2026-06-01
Console Platforms :active, pl2, 2026-06-01, 2027-06-01
Mobile (Android/iOS) :active, pl3, 2026-09-01, 2027-03-01
VR/XR (OpenXR) :active, pl4, 2027-01-01, 2027-06-01
Note: There is a ~4-week gap between the initial Dec 23-25, 2025 foundation commits and the resumption of active development on Jan 22, 2026. The bulk of the engine (150+ features) was built in the subsequent 4 weeks (Jan 22 - Feb 17, 2026). Week 12 (Feb 17-19) focused on hardening: 120+ audit findings fixed, SimplePhysics removed, Steam Audio integrated, and test coverage expanded from 8 to 26 executables. Weeks 13-14 (Feb 20 - Mar 8) added GPU-driven rendering features: clustered lighting, HiZ occlusion culling, LOD hysteresis, VRS, virtual texturing, visibility buffer, 64-bit material sort keys, FrameAllocator, and material enhancements (transmission/SSS). Test coverage was further expanded to 50 CTest targets (~700+ cases). The BSL 1.1 open-source license was adopted on Mar 7.
4. Rendering Pipeline Flowchart
This diagram details the complete rendering pipeline for a single frame, including the 2D/2.5D/3D branching logic.
flowchart TB
FrameStart["Frame Start
(VulkanRenderer::BeginFrame)"] --> FlushDestroy["Flush Deferred
Entity Destruction"]
FlushDestroy --> UpdateSystems["Update ECS Systems
(Controllers, Physics,
Scripts, AI)"]
UpdateSystems --> ClassifyScene["ClassifySceneComposition()"]
ClassifyScene --> Is2D{Scene Type?}
Is2D -->|"Scene2D: Sprites/Tilemaps Only"| Path2D["2D Fast Path"]
Is2D -->|"Scene2_5D: Sprites + Lights"| Path25D["2.5D Path"]
Is2D -->|"Scene3D: 3D Meshes Present"| Path3D["3D Full Path"]
subgraph Path2DBlock["2D Pipeline"]
Path2D --> SkipShadows2D["Skip ALL Shadow Passes"]
SkipShadows2D --> MinimalUBO["Upload Minimal LightingUBO
(Ambient + Fog Only)"]
MinimalUBO --> SkipNormalMap["Skip Normal Map
Descriptor Writes"]
end
subgraph Path25DBlock["2.5D Pipeline"]
Path25D --> SkipShadows25D["Skip Shadow Passes"]
SkipShadows25D --> FullLightingUBO["Upload Full LightingUBO
(Lights for Lit Sprites)"]
FullLightingUBO --> BindNormalMap25D["Bind Normal Map
Descriptors"]
end
subgraph Path3DBlock["3D Full Pipeline"]
Path3D --> ShadowCasterCache["Build Shadow Caster
Cache (Pre-filtered)"]
ShadowCasterCache --> DirShadow["Directional Light
Shadow Pass"]
subgraph CSMCascades["4-Cascade CSM"]
DirShadow --> C0["Cascade 0
(Near)"]
DirShadow --> C1["Cascade 1"]
DirShadow --> C2["Cascade 2"]
DirShadow --> C3["Cascade 3
(Far)"]
end
ShadowCasterCache --> PointShadow["Point Light Shadows
(Up to 4 Cubemaps,
512^2 per face)"]
ShadowCasterCache --> SpotShadow["Spot Light Shadows
(Up to 4, 2D Array,
1024^2)"]
C3 --> FullUBO3D["Upload Full LightingUBO
(Multi-Light Arrays,
Shadow Data, SH Probes)"]
PointShadow --> FullUBO3D
SpotShadow --> FullUBO3D
FullUBO3D --> BindNormalMap3D["Bind Normal Map
Descriptors"]
BindNormalMap3D --> RTCheck{"RT Hardware Available?"}
RTCheck -->|Yes| RTPipelineExec["Ray Tracing Pipeline"]
subgraph RayTracingBlock["Ray Tracing (Scene3D Only)"]
RTPipelineExec --> BuildTLAS["Rebuild TLAS
(Per-Frame)"]
BuildTLAS --> DispatchRT["Dispatch RT Effects"]
DispatchRT --> RTShadowsD["RT Shadows
(1 SPP)"]
DispatchRT --> RTReflectD["RT Reflections
(Specular)"]
DispatchRT --> RTAOD["RT AO
(Hemisphere)"]
DispatchRT --> RTGID["RT GI
(Multi-Bounce)"]
RTShadowsD --> Denoise["Denoise
(SVGF or OIDN)"]
RTReflectD --> Denoise
RTAOD --> Denoise
RTGID --> Denoise
Denoise --> Composite["RT Compositor
(Fullscreen Compute)"]
end
RTCheck -->|No| SkipRT["Skip RT"]
end
SkipNormalMap --> MainPass
BindNormalMap25D --> MainPass
BindNormalMap3D --> MainPass
Composite --> MainPass
SkipRT --> MainPass
subgraph MainRenderPass["Main Render Pass"]
MainPass["Begin Render Pass"] --> SkyboxR["Render Skybox
(if type != None)"]
SkyboxR --> SortEntities["Sort Entities by
64-bit Material Sort Key"]
SortEntities --> HiZCull["GPU Two-Phase HiZ
Occlusion Culling"]
HiZCull --> ClusterAssign["Clustered Light
Assignment (16x9x24)"]
ClusterAssign --> LODSelect["LOD Selection
(Screen-Space + Hysteresis)"]
LODSelect --> OpaquePass["Opaque Pass"]
subgraph OpaqueLoop["Per-Entity Rendering"]
OpaquePass --> CheckVisible{entity.visible?}
CheckVisible -->|No| SkipEntity["Skip"]
CheckVisible -->|Yes| PushConstants["Upload Push Constants
(128 bytes: Model Matrix,
Material Props, Flags)"]
PushConstants --> DescCache{"Descriptor Cache Hit?"}
DescCache -->|Yes| SkipDescWrite["Skip Descriptor Write"]
DescCache -->|No| UpdateDesc["Update Descriptors
(Bindings 3/5/6/7/8/9,
14-15 Cluster, 16-17 VT)"]
SkipDescWrite --> DrawCall["vkCmdDrawIndexed"]
UpdateDesc --> DrawCall
end
DrawCall --> OITCheck{"OIT Entities Present?"}
OITCheck -->|Yes| OITPass["OIT Weighted Blended
Pass + Composite"]
OITCheck -->|No| SkipOIT["Skip OIT"]
OITPass --> SpritePass
SkipOIT --> SpritePass
SpritePass["Sprite Batch Rendering"] --> AtlasCheck{"Atlas Sprites?"}
AtlasCheck -->|Yes| AtlasBatch["Single Instanced Draw
(Atlas Texture)"]
AtlasCheck -->|No| IndividualDraw["Individual Draws
(Oversized/Excluded)"]
AtlasBatch --> ParticlePass
IndividualDraw --> ParticlePass
ParticlePass["Particle Rendering
(GPU Instanced Billboards)"]
ParticlePass --> VegetationPass["Vegetation Pass
(Grass/Shrub/Tree)"]
VegetationPass --> WaterPass["Water Rendering
(Gerstner Waves)"]
WaterPass --> DebugViz["Debug Visualization
(Collider Wireframes,
Joint Lines, SH Probes)"]
end
DebugViz --> PostProcess
subgraph PostProcessBlock["Post-Processing Chain"]
PostProcess["Post-Processing"] --> Bloom["Bloom
(Threshold + Blur)"]
Bloom --> SSAO_PP["SSAO
(Multiplicative, HDR)"]
SSAO_PP --> ContactShadows_PP["Contact Shadows
(Ray March, HDR)"]
ContactShadows_PP --> Caustics_PP["Fake Caustics
(Additive, HDR)"]
Caustics_PP --> GodRays_PP["God Rays
(Radial Blur, HDR)"]
GodRays_PP --> FogShafts_PP["Fog Shafts
(Volumetric, HDR)"]
FogShafts_PP --> DOF["Depth of Field
(Poisson Disc)"]
DOF --> TiltShift["Tilt-Shift
(Focus Band Blur)"]
TiltShift --> CelOutlines["Cel Shading Outlines
(Sobel Edge Detection)"]
CelOutlines --> StippleDither["Stipple / Dither
(8 Patterns, 3 Color
Modes)"]
StippleDither --> ColorGrading["Color Grading"]
ColorGrading --> FXAA["FXAA"]
FXAA --> Vignette["Vignette"]
Vignette --> FilmGrain["Film Grain"]
FilmGrain --> RetroFX["Retro Effects
(CRT, Pixelation)"]
end
RetroFX --> EditorOverlay
subgraph EditorOverlayBlock["Editor Overlay (Editor Only)"]
EditorOverlay["ImGui Overlay"] --> ImGuiPanels["Editor Panels
(Hierarchy, Inspector,
Console, etc.)"]
ImGuiPanels --> GameView["Game View Viewport
(RenderToTarget)"]
GameView --> GizmoOverlay["Gizmo Overlay
(ImGuizmo)"]
end
GizmoOverlay --> Present["Present
(vkQueuePresentKHR)"]
style Path2DBlock fill:#1a3a1a,stroke:#4a8a4a
style Path25DBlock fill:#2a2a3a,stroke:#6a6aaa
style Path3DBlock fill:#3a1a1a,stroke:#aa4a4a
style RayTracingBlock fill:#2a1a3a,stroke:#8a4aaa
style PostProcessBlock fill:#1a2a3a,stroke:#4a7aaa
Key Pipeline Optimizations
- Scene Classification Gate: 2D-only scenes skip shadow passes entirely, saving 4+ render passes per frame.
- 64-bit Material Sort Keys: Entities sorted by pipeline + material + texture key so identical materials draw consecutively, minimizing state changes and maximizing descriptor cache hits.
- GPU Two-Phase HiZ Occlusion Culling: Hierarchical-Z buffer used for two-pass GPU-driven occlusion culling via async compute, eliminating invisible geometry before draw submission.
- Clustered Forward Lighting: 16x9x24 grid subdivides the view frustum; lights assigned to clusters via compute shader. Per-fragment lookups reduce per-light cost from O(N) to O(K) where K is the cluster light count.
- LOD with Hysteresis: Screen-space LOD selection with hysteresis band prevents LOD popping during camera movement.
- Per-Frame Linear Allocator:
FrameAllocatorprovides O(1) allocation with single reset per frame for transient render data. - Descriptor Caching:
m_LastBoundtracking skipsvkUpdateDescriptorSetswhen texture/bone pointers are unchanged. - Play Mode Skip:
m_SkipMainPassRenderingflag prevents double-drawing (offscreen Game View + main swapchain). - Shadow Caster Cache: Pre-filtered list avoids redundant per-cascade entity iteration.
- Async Compute Overlap: GPU culling and cluster assignment run on async compute queue, overlapping with CPU-side scene preparation.
5. Market Positioning Analysis
Target Audience
Enjin occupies a unique position in the game engine market by targeting several underserved audiences simultaneously:
| Audience Segment | Why Enjin Appeals | Primary Competitors |
|---|---|---|
| Indie Developers | All-in-one 2D+3D with built-in gameplay systems (save, quest, dialogue, AI) that competitors require plugins for. Hardened codebase with 50 test targets builds production confidence | Unity, Godot |
| Flash Game Creators | SWF import, AS2/AS3 transpiler, Newgrounds.io API, HTML5 export, Flash-style timeline editor -- no other engine offers this combination | None (Enjin is unique) |
| Retro Game Makers | CRT effects, pixel editor, 9 retro resolution presets, dithered gradients, stipple patterns, sprite sheet workflow | GameMaker, Pico-8 |
| Students & Educators | Built-in behavior trees, visual scripting, procedural generation, and comprehensive accessibility -- strong teaching tool | Godot, Scratch |
| Accessibility-First Developers | 8 colorblind modes, screen reader, switch access, dwell-click, high contrast (WCAG AAA), font scaling, reduced motion -- most comprehensive in any engine | None (Enjin leads) |
| Hobbyist/Prototypers | 44 startup templates with MaturityTier badges, template marketplace, pixel editor, drag-and-drop import, visual scripting -- minimal barrier to entry | Construct, GameMaker |
| Audio-Focused Developers | Steam Audio HRTF binaural rendering with geometry-aware occlusion/transmission -- professional spatial audio without middleware | Unity (via plugin), Unreal |
Competitive Advantages
vs. Godot
- Ray tracing pipeline (Godot has none)
- Production physics via Jolt + Box2D (Godot uses custom physics)
- Built-in gameplay systems (save/quest/dialogue/AI) -- Godot requires addons
- Flash ecosystem support (SWF import, Newgrounds API)
- Deeper accessibility (switch access, eye tracking, dwell-click, WCAG AAA themes)
- Shader graph with GLSL codegen (Godot has visual shaders but different approach)
- Steam Audio HRTF spatial audio with occlusion/transmission (Godot has no equivalent)
- Hardened codebase with 10+ audit rounds and 50 test targets (Godot community-tested only)
vs. Unity
- Open-source under BSL 1.1 with free game development use (Unity's pricing has alienated developers)
- Built-in game systems without paid plugins (dialogue, quest, save, AI behavior trees)
- Flash game revival toolkit (unique to Enjin)
- Retro/pixel art pipeline built-in (Unity requires third-party assets)
- Accessibility-first design (Unity's accessibility is addon-dependent)
- Simpler, focused scope (less bloat than Unity's multi-purpose platform)
- Built-in Steam Audio HRTF without middleware setup (Unity requires separate Steam Audio plugin)
vs. Unreal
- Dramatically simpler -- approachable for solo devs and small teams
- 2D as a first-class citizen (Unreal's 2D is an afterthought)
- Lightweight -- no multi-GB install or "learning Unreal" curve
- HTML5 export for web games (Unreal dropped HTML5)
- Visual scripting without the complexity of Unreal Blueprints
vs. GameMaker
- Full 3D support with ray tracing, PBR, skeletal animation
- Visual scripting (GameMaker only has GML)
- Production physics (Jolt/Box2D vs. GameMaker's basic collision)
- Shader graph, behavior trees, quest systems -- far deeper feature set
- Open-source under BSL 1.1 (GameMaker requires paid license)
vs. Construct
- Full native C++ performance (Construct is browser-based JavaScript)
- Complete 3D pipeline (Construct is 2D-only with minimal 3D)
- Text scripting (AngelScript vs. Construct's event sheets only)
- Desktop/console export without additional licenses
- Advanced rendering (ray tracing, PBR, post-processing)
Unique Selling Points
Flash Game Revival Platform: The only engine with SWF import, AS2/AS3 transpilation, Newgrounds.io integration (medals, scoreboards, cloud saves), HTML5 export with Newgrounds game page templates, Flash-style timeline editor, and SharedObject persistence mapping. This is a market of one.
Accessibility Leadership: With 8 colorblind modes, screen reader announcer, switch access scanning, dwell-click, eye tracking stubs, WCAG AAA high-contrast themes, dyslexia-friendly fonts, reduced motion, and runtime font scaling, Enjin has the most comprehensive accessibility suite of any game engine on the market.
All-in-One Gameplay Systems: Quest system, dialogue trees with 7 node types, tiered save system with 20 slots and cloud backends, AI with behavior trees and navmesh, cinematic camera, destructible environments, HUD overlay -- all built-in, not plugins.
Retro Art Pipeline: Pixel editor with 9 retro resolution presets, CRT/scanline/dithering post-processing, dithered gradient rendering, full-screen stipple patterns, sprite sheet importer with auto-slicing -- purpose-built for retro game development.
9+ Procedural Generation Algorithms: Cellular automata, BSP, diamond-square, L-system (3D stochastic), WFC, Voronoi, random walker, grammar rules, prefab assembler, fractal terrain with hydraulic/thermal erosion -- all with editor preview panels and script bindings.
Physics-Based Spatial Audio: Steam Audio HRTF binaural rendering with geometry-aware occlusion and transmission. Collider meshes double as acoustic geometry -- no separate audio mesh authoring required. Fallback to miniaudio built-in spatialization on hardware without HRTF support.
Audited, Hardened Codebase: 10+ systematic audit rounds with 205+ findings fixed across Vulkan renderer, ECS, serialization, physics, and scripting. Published audit reports demonstrate production-grade code quality. Trust zone boundary map documents all system interaction points.
Market Gaps Filled
- Post-Flash web game development: No engine specifically targets the Flash game community
- Accessibility-first game creation: Existing engines treat accessibility as an afterthought
- Solo dev all-in-one: Reduces dependency on plugin ecosystems and third-party assets
- Retro game creation with modern tooling: Bridges pixel art workflow with modern rendering pipeline
- Educational game engine: Built-in visual scripting, behavior trees, and procedural generation make it ideal for teaching
- Indie spatial audio: Professional HRTF audio without Wwise/FMOD middleware costs or setup complexity
6. Licensing & Revenue Model Analysis
Current License: BSL 1.1 (Business Source License)
As of March 2026, Enjin is licensed under the Business Source License 1.1. Key terms:
- Use Grant: Free to use Enjin to make and sell games. No fees, no revenue share, no restrictions on commercial game releases.
- Restriction: You may not fork Enjin and sell it as a competing game engine product.
- Change Date: 4 years from each release, the license automatically converts to Apache 2.0 (fully permissive open source).
- Source Access: Full source code available to all users.
This model eliminates all adoption friction while protecting against engine-as-a-product competition. Game developers pay nothing -- ever.
Historical Analysis: Alternative Models Considered
The following models were evaluated prior to the BSL 1.1 decision and are retained for reference.
Model A: Pay-Per-Copy (One-Time Purchase)
| Tier | Price | Features | Target User |
|---|---|---|---|
| Indie | $49 | Full engine, editor, 2D+3D, all built-in systems, community support | Solo devs, students, hobbyists |
| Pro | $149 | Indie + commercial license, priority support, console export stubs, source access | Small studios (1-5 people) |
| Enterprise | $499/seat | Pro + multi-seat license, dedicated support channel, custom branding removal, build server license | Studios (5+ people) |
Pros:
- Simple, transparent pricing that developers appreciate (post-Unity backlash)
- No ongoing revenue obligations for developers
- Competitive with GameMaker ($99) and Construct ($199/yr)
- One-time cost removes friction for adoption
- No surprise price changes or retroactive fee structures
Cons:
- Revenue is front-loaded with no recurring income
- Must continuously release new versions to drive upgrade revenue
- No revenue from successful games made with the engine
- Harder to fund long-term development without recurring revenue
- Price anchoring -- once purchased, users resist paying for upgrades
Revenue Projections (Pay-Per-Copy):
| Year | Indie Sales | Pro Sales | Enterprise | Total Revenue |
|---|---|---|---|---|
| Year 1 | 2,000 x $49 = $98K | 300 x $149 = $44.7K | 20 x $499 = $10K | $152.7K |
| Year 2 | 5,000 x $49 = $245K | 800 x $149 = $119.2K | 50 x $499 = $25K | $389.2K |
| Year 3 | 10,000 x $49 = $490K | 1,500 x $149 = $223.5K | 100 x $499 = $49.9K | $763.4K |
| Year 5 | 20,000 x $49 = $980K | 3,000 x $149 = $447K | 200 x $499 = $99.8K | $1.53M |
Model B: Free-to-Create (Revenue Share)
| Tier | Price | Revenue Share | Target User |
|---|---|---|---|
| Free / Personal | $0 | 5% revenue share above $100K/year gross | Everyone -- zero barrier to entry |
| Education | $0 | None | Schools, students, non-commercial |
| Pro | $99/year | No revenue share | Devs wanting clean licensing |
| Enterprise | $299/year/seat | No revenue share, priority support | Studios |
Pros:
- Zero barrier to entry maximizes adoption and community growth
- Revenue scales with developer success (aligned incentives)
- The $100K threshold means hobbyists and students never pay
- Education tier builds next-generation developer loyalty
- Follows proven Unity/Unreal model (but with fairer terms)
- Recurring revenue from Pro/Enterprise subscriptions
Cons:
- Revenue share enforcement is difficult for small/solo devs
- Revenue delayed until developers ship and succeed
- Requires legal infrastructure for revenue share tracking
- Pro tier must be compelling enough to convert free users
- Community may resist any revenue share (Godot is fully free)
Revenue Projections (Free-to-Create):
| Year | Users | Pro Subs | Enterprise Subs | Rev Share (est.) | Total Revenue |
|---|---|---|---|---|---|
| Year 1 | 10,000 | 200 x $99 = $19.8K | 10 x $299 = $3K | $5K | $27.8K |
| Year 2 | 40,000 | 1,000 x $99 = $99K | 40 x $299 = $12K | $30K | $141K |
| Year 3 | 100,000 | 3,000 x $99 = $297K | 100 x $299 = $29.9K | $120K | $446.9K |
| Year 5 | 300,000 | 8,000 x $99 = $792K | 300 x $299 = $89.7K | $500K | $1.38M |
Model Comparison
| Factor | Model A (Pay-Per-Copy) | Model B (Free-to-Create) |
|---|---|---|
| Barrier to Entry | $49 minimum | $0 |
| Year 1 Revenue | ~$153K | ~$28K |
| Year 5 Revenue | ~$1.53M | ~$1.38M |
| Break-Even Point | Immediate | ~Year 4 |
| User Base Growth | Moderate | Rapid |
| Community Size | Smaller but paying | Larger, more engaged |
| Legal Complexity | Simple | Revenue share tracking |
| Developer Goodwill | Neutral (fair price) | High (free for most) |
| Long-term Sustainability | Needs upgrade sales | Scales with ecosystem |
| Competitive Position | Like GameMaker/Construct | Like Unity/Unreal (but fairer) |
Outcome
BSL 1.1 was selected as the licensing model, superseding the above alternatives. BSL 1.1 provides the maximum adoption advantage (zero cost, full source access, no revenue share) while protecting against competitive forking. The 4-year change date to Apache 2.0 builds long-term community trust and ensures the codebase becomes fully open over time. This approach aligns with the Enjin philosophy of removing all barriers for game developers.
7. Market Share Potential
Total Addressable Market
The global game engine market is estimated at $3.5-4.5B (2025), with the indie/hobbyist segment representing approximately $800M-1.2B. Key market metrics:
| Metric | Estimate | Source Basis |
|---|---|---|
| Game devs worldwide | ~2.5M active | GDC surveys, itch.io registrations |
| Indie developers | ~1.5M | Using non-AAA engines |
| Hobbyist/student devs | ~800K | Game jams, educational use |
| Flash game community | ~50K-100K active | Newgrounds, Kongregate legacy, web game forums |
| Game engine market CAGR | 12-15% | Industry reports |
Realistic Market Capture Estimates
| Timeframe | Users | Market Share (of Indie) | Key Milestone |
|---|---|---|---|
| Year 1 | 5,000-15,000 | 0.3-1.0% | Launch, early adopter community |
| Year 2 | 25,000-50,000 | 1.7-3.3% | First games shipped, word-of-mouth |
| Year 3 | 75,000-150,000 | 5-10% | Established community, tutorials, courses |
| Year 5 | 200,000-400,000 | 13-27% | Mature ecosystem, console support |
For context, Godot reached ~2,500 monthly contributors and an estimated 500K-1M users over 10 years. Enjin's broader built-in feature set could accelerate adoption but its single-developer origin may slow community trust-building.
Key Growth Drivers
Post-Unity migration wave: Unity's pricing changes created a lasting trust deficit. Developers actively seeking alternatives have already boosted Godot significantly; Enjin could capture a portion of this migration.
Flash game nostalgia + revival: The Flash game community (Newgrounds, Kongregate legacy) has no dedicated modern engine. Enjin's SWF import, AS transpiler, and Newgrounds API integration make it the only viable migration path.
Accessibility regulations: Growing legal requirements for accessible software (EU Accessibility Act 2025, US Section 508) make Enjin's built-in accessibility suite increasingly valuable as a compliance advantage.
Education market: Universities and boot camps need engines with built-in visual scripting, behavior trees, and procedural generation for teaching. Enjin's all-in-one approach reduces setup time for curricula.
"Hit game" effect: A single commercially successful game built with Enjin would dramatically boost adoption (the "Hollow Knight effect" for Unity, "Baldi's Basics" for Unreal).
Risk Factors
| Risk | Severity | Mitigation |
|---|---|---|
| Single-developer bus factor | Critical | Open-source core, contributor onboarding docs, modular architecture |
| Godot momentum | High | Differentiate via Flash revival, accessibility, built-in gameplay systems, Steam Audio HRTF, and audited codebase |
| Unity/Unreal price corrections | Medium | Enjin's unique features (retro, Flash, accessibility) are not price-dependent |
| Console certification barriers | Medium | Partner with porting houses; focus on PC/web/mobile first |
| Community building | High | Invest in documentation, tutorials, Discord, game jams |
| Performance perception | Medium | Benchmark comparisons, demo projects, 50 test targets, published audit reports build confidence |
| API stability concerns | Medium | Semver, deprecation policy, migration guides |
8. Performance Diagnostics Summary
Optimization Status
All performance issues from P0 through P6 have been resolved. The engine has undergone 10+ rounds of auditing (performance + security + stability + feature wiring) with 205+ findings fixed across 7 formal audit reports (AUDIT_2026_02_11 through AUDIT_2026_02_18, plus per-subsystem reports for ECS, Renderer, Serialization, Asset Pack, and Physics/Audio).
Resolved Optimizations (Good Patterns)
| Category | Optimization | Impact |
|---|---|---|
| GPU Sync | vkDeviceWaitIdle() replaced with fence-based WaitForGPU() across 18 subsystems |
Eliminated GPU stalls |
| Entity Iteration | GetAllEntities() + filter replaced with GetEntitiesWithComponent<T>() everywhere |
O(N) -> O(M) where M << N |
| Descriptor Caching | m_LastBound state tracks texture/bone pointers, skips unchanged vkUpdateDescriptorSets |
~60-80% descriptor write reduction |
| Material Sort | Entities sorted by 64-bit material sort key (pipeline + material + texture) so identical materials draw consecutively | Maximizes cache hits, minimizes state changes |
| Texture Caching | cachedBaseColorTexture etc. on MaterialComponent, invalidated on path change |
Eliminates per-frame string lookups |
| Shadow Caster Cache | Pre-filtered shadow caster list avoids per-cascade redundant iteration | 4x reduction in shadow pass iteration |
| Play Mode Skip | m_SkipMainPassRendering flag prevents double-draw during play mode |
Halves geometry rendering cost |
| Frame Pacing | timeBeginPeriod(1) on Windows for 1ms sleep resolution + 2ms spin margin |
Eliminates 5-14ms frame jitter |
| Collision Broad-Phase | SpatialHashGrid with oversized entity fallback |
100 colliders: 4950 pairs -> ~200 |
| Name Cache | m_NameCache on World for O(1) FindEntityByName() |
Script entity lookup from O(N) to O(1) |
| Quaternion Helpers | GetRotationZ(), GetForward()/GetRight()/GetUp() avoid ToEuler()/ToMatrix() |
Single atan2 vs. full decomposition |
| Component Flags | Pre-classified entity component flags avoid 6+ optional GetComponent calls |
Reduces per-entity branch count |
| Scene Classification | 2D scenes skip shadow passes, minimal UBO upload, skip normal map descriptors | 4+ render passes eliminated for 2D |
| Sprite Atlas | Runtime shelf-packing into 4096x4096 GPU texture | Many draw calls -> 1 instanced draw |
| Script Query Cache | Single cached GetEntitiesWithComponent<ScriptComponent>() shared across Update/FixedUpdate/LateUpdate |
6 queries -> 1 per frame |
| GPU HiZ Occlusion Culling | Two-phase hierarchical-Z culling via async compute eliminates invisible geometry before draw submission | Significant draw call reduction in occluded scenes |
| Clustered Forward Lighting | 16x9x24 frustum grid with compute-shader light assignment; per-fragment cluster lookup via SSBOs (bindings 14-15) | Per-light cost O(N) -> O(K) per fragment |
| 64-bit Material Sort Keys | Pipeline + material + texture encoded in 64-bit key for cache-friendly draw ordering | Minimizes pipeline/descriptor state changes |
| Per-Frame Linear Allocator | FrameAllocator provides O(1) bump allocation for transient render data, reset once per frame |
Eliminates per-object heap allocations in render loop |
| LOD Hysteresis | Screen-space LOD selection with hysteresis band prevents rapid LOD switching during camera movement | Eliminates LOD popping artifacts |
| Async Compute Overlap | GPU culling and cluster assignment dispatch on async compute queue, overlapping with CPU scene prep | Better GPU utilization, reduced frame time |
Current Performance Profile
| Metric | Target | Achieved | Notes |
|---|---|---|---|
| Frame Time (Empty Scene) | < 2ms | ~1ms | Minimal overhead |
| Frame Time (1000 Entities, 3D) | < 16ms (60fps) | < 16ms with Jolt | Production physics backend |
| Frame Time (1000 Sprites, 2D) | < 8ms | < 5ms | Atlas batching effective |
| Shadow Pass (4 CSM Cascades) | < 4ms total | ~3ms | Caster caching helps |
| Descriptor Cache Hit Rate | > 70% | ~75-85% | Material sort driven |
| Entity Lookup (by name) | < 0.01ms | O(1) | Hash map cache |
| Physics (1000 Colliders, Jolt) | < 4ms | ~2-3ms | Multi-threaded Jolt |
| Entity Validation | O(1) | O(1) | unordered_set for IsValid() (ECS audit) |
Performance Tier Classification
Enjin sits firmly in the "Indie Production" tier, capable of handling:
- 2D games with thousands of sprites at 60fps (atlas batching + normal map lighting)
- 3D games with hundreds of entities and full shadow/lighting at 60fps (CSM w/ cascade blending)
- Ray tracing on supported hardware (RT-capable GPU required)
- HRTF spatial audio with geometry-aware occlusion (Steam Audio)
- LAN multiplayer with 20Hz state sync and client-side prediction
With recent additions of virtual texturing (page-based streaming), LOD with hysteresis, GPU HiZ occlusion culling, and clustered forward lighting, the engine is closing the gap toward mid-tier production quality. It is not positioned for AAA-scale rendering (no Nanite-style mesh streaming, no massive open-world streaming), but it significantly exceeds the requirements of its target market (indie/hobbyist/retro/Flash) and can handle moderately complex 3D scenes efficiently.
Frame Budget Breakdown (Typical 3D Scene, 16.67ms Budget)
pie title Frame Budget Breakdown (3D, 60fps)
"Shadow Passes (CSM + Point + Spot)" : 2.5
"GPU Culling + Cluster Assign (Async)" : 0.8
"Scene Classification + UBO Upload" : 0.4
"Main Render Pass (Opaque)" : 3.5
"Sprite Batch Rendering" : 1.5
"Particle Rendering" : 1.0
"Post-Processing Chain" : 2.5
"ECS Systems (Physics, AI, Scripts)" : 3.0
"ImGui / Editor Overlay" : 1.0
"Remaining Headroom" : 0.47
9. Technical Debt Assessment
Code Health Indicators
| Metric | Assessment | Evidence |
|---|---|---|
| Architecture | Strong | Clean 3-layer separation (Core/Engine/App), no circular dependencies |
| Thread Safety | Good | ECS World uses recursive mutex (incl. IsValid/IsPendingDestruction), deferred destruction with set-cleared on Clear(), atomic refcounts |
| Error Handling | Strong | Vulkan VkResult checks at 25+ sites (all hardened Feb 2026), JSON .contains() validation, bounds checking, GPU loop caps, null guards on all physics/audio paths |
| Memory Management | Good | Custom allocators (Stack/Pool/Linear/Frame), per-frame FrameAllocator for transient render data, reserve() on hot-path vectors, leak-free Vulkan failure paths (verified in renderer audit) |
| API Consistency | Good | Consistent naming conventions (Get/Set/Is), ENJIN_API export macro |
| Test Coverage | Good | Custom CTest framework with 50 test targets and ~700+ test cases across unit and integration suites. Tests organized into Tests/Unit/ and Tests/Integration/ (expanded from 8 to 26 in Feb 2026 audit campaign, then to 50 in Mar 2026) |
| Documentation | Strong | CLAUDE.md (~150 lines), CLAUDE_REFERENCE.md, 20+ doc files (incl. 7 audit reports), trust zone boundary map, generated API docs, inline tooltips |
Areas Needing Refactoring
| Area | Issue | Severity | Effort |
|---|---|---|---|
| EditorLayer size | Single file handles all 32 panels, ~38,000 lines | Medium | High -- extract panel classes |
| RenderSystem scope | Handles sprites, particles, vegetation, water, debug viz -- too many responsibilities | Medium | High -- extract sub-renderers |
| Script binding files | 30+ separate ScriptBindings_*.cpp files with similar patterns | Low | Medium -- code generation |
| RESOLVED -- 64-bit material sort keys now encode pipeline + material + texture; push constant flags field still 32-bit but usage rationalized with dedicated sort key | |||
| XOR obfuscation | Asset pack uses trivially breakable XOR (not cryptographically secure) | Medium | Medium -- replace with AES-GCM |
| Script #include paths | Resolved via lexically_normal() but not restricted to script directory |
Medium | Low -- add path validation |
| 32 editor panel bits | All 32 bits of EditorPanel used; graph editors use IsOpen()/SetOpen() workaround |
Low | Medium -- refactor to bitset or map |
| RESOLVED — Removed entirely (Feb 2026). Source files deleted, enum entry removed, factory updated. |
Scalability Concerns
| Concern | Current Limit | Mitigation Path |
|---|---|---|
| Entity count | Warning at 10,000+ | Archetype ECS migration for cache-friendly iteration |
| Draw calls | Dependent on material variety | Indirect rendering + GPU HiZ occlusion culling reduces visible draw count; 64-bit material sort keys minimize state changes |
| Shadow map resolution | 2048^2 per CSM cascade, 1024^2 per spot, 512^2 per point face | Configurable, could add virtual shadow maps |
| Particle count | 16,384 per emitter | GPU compute simulation would lift this |
| Visual script nodes | Warning at 500+ | Subgraph/function nodes already mitigate this |
| Network players | LAN scale (4-16 typical) | Dedicated server architecture for larger scale |
| Texture memory | Single 4096x4096 atlas (sprites); Virtual Texturing available for large 3D scenes (CMake flag) | Multiple atlas pages for sprites; VT page streaming for 3D texture-heavy scenes |
Maintenance Burden Estimate
| Component | Files (actual) | Maintenance Level | Notes |
|---|---|---|---|
| Core Layer | ~24 | Low | Stable foundation, rarely changes |
| Vulkan Renderer + RT + GPU-Driven | ~140 | High | Largest subsystem -- Vulkan, shadows, RT, post-process, clustered lighting, GPU culling, VRS, VT, visibility buffer |
| ECS & Components | ~62 | Medium | Component count grows with features |
| Editor | ~67 | High | UI code has high churn, user-facing |
| Scripting & Visual Script | ~51 | Medium | Bindings grow with each feature |
| Effects & Procedural | ~68 | Low | Self-contained, rarely touched after creation |
| Build & Assets | ~43 | Low | Stable pipeline, import/export |
| GUI & Localization | ~31 | Medium | UI canvas, dialogue, menus, localization |
| Physics (2 backends) | ~18 | Low | Jolt + Box2D stable, SimplePhysics removed. Both hardened (null guards, input clamping) |
| Gameplay & Networking | ~40 | Medium | Save system, quests, LAN multiplayer |
| Accessibility & Audio | ~25 | Low | Content warnings, miniaudio + Steam Audio HRTF backend |
| Tests | ~51 | Low | 50 CTest targets (~700+ test cases), shared EnjinTest.h framework |
| Other (AI, Animation, Scene, Plugin, Input, Debug) | ~57 | Low | Many small self-contained modules |
| Total | ~653 | Medium overall | Modular architecture helps; major debt reduced by audit campaign; GPU-driven features cleanly isolated behind CMake flags |
Recommended Priority Actions
Expand unit test coverage— COMPLETE: Expanded from 8 to 50 CTest targets with ~700+ test cases covering Physics2D, VisualScript, BehaviorTree, UISystem, Networking, StressFuzz, and more. All tests passing- Extract EditorLayer panels into individual classes to reduce file size and improve maintainability
- Replace XOR obfuscation with authenticated encryption for commercial releases
- Restrict script #include paths to project directory to prevent path traversal — partially mitigated by
lexically_normal()validation Deprecation timeline for SimplePhysics— COMPLETE: Removed entirely Feb 2026- Asset pack format versioning — Add version header to
.enjpakformat for forward compatibility (identified in serialization audit) - Address 13 remaining deferred audit findings — Mostly low-severity items across asset pack format and string length validation
10. Feature Dependency Graph
This diagram shows which major features depend on which other features, illustrating the engine's internal coupling.
graph TB
subgraph CoreDeps["Core Dependencies"]
Types["Types (u8-u64)"]
MathLib["Math Library"]
Logging["Logging System"]
Memory["Memory Allocators"]
Platform["Platform Layer"]
Window["Window (GLFW)"]
Input["Input System"]
end
subgraph VulkanDeps["Vulkan Foundation"]
VkContext["VulkanContext
(25+ VkResult Checks)"]
VkRenderer["VulkanRenderer"]
VkPipeline["VulkanPipeline"]
VkBuffer["VulkanBuffer"]
VkImage["VulkanImage"]
end
subgraph ECSDeps["ECS Foundation"]
World["ECS::World
(O(1) Entity Validation)"]
Entity["ECS::Entity"]
Components["Component Types"]
end
subgraph RenderFeatures["Rendering Features"]
RenderSys["RenderSystem"]
Shadows["Shadow Mapping
(CSM w/ Cascade Blending,
Point/Spot)"]
PostProc["Post-Processing"]
SpriteBatch["Sprite Batching
(Normal Map Lighting,
Drop Shadows)"]
SpriteAtlas["Sprite Atlas"]
ParticleRend["Particle Renderer"]
Skybox["Skybox"]
SHProbes["SH Light Probes"]
OIT["OIT"]
CelShade["Cel Shading"]
RetroFX["Retro Effects"]
GPUCull["GPU HiZ Occlusion Culling"]
ClusteredLt["Clustered Forward Lighting
(16x9x24)"]
LODSys["LOD System
(Hysteresis)"]
MatSortKeys["64-bit Material Sort Keys"]
FrameAlloc["FrameAllocator"]
end
subgraph OptionalRender["Optional Render Features (CMake Flags)"]
VRSSys["Variable Rate Shading"]
VTSys["Virtual Texturing"]
VisBuf["Visibility Buffer"]
end
subgraph RTFeatures["Ray Tracing Features"]
RTCaps["RT Capabilities"]
AccelStruct["Acceleration Structures"]
RTPipe["RT Pipeline"]
RTShadow["RT Shadows"]
RTReflect["RT Reflections"]
RTAO["RT AO"]
RTGI["RT GI"]
PathTrace["Path Tracer"]
SVGF["SVGF Denoiser"]
OIDN["OIDN Denoiser"]
RTComp["RT Compositor"]
end
subgraph PhysicsFeatures["Physics Features"]
IPhysics["IPhysicsBackend"]
IPhysics2D["IPhysicsBackend2D"]
Jolt["Jolt Backend"]
Box2D["Box2D Backend"]
PhysicsFactory["Backend Factory
(Jolt/Box2D Only)"]
Collision["Collision Detection"]
SpatialHash["Spatial Hash Grid"]
Joints["Joint System"]
Ragdoll["Ragdoll"]
end
subgraph ScriptFeatures["Scripting Features"]
ASEngine["AngelScript Engine"]
Bindings["Script Bindings (~844)"]
VisScript["Visual Scripting"]
VSDebugger["VS Debugger"]
VSProfiler["VS Profiler"]
StateMachine["State Machines"]
Coroutines["Coroutines"]
EventBus["Event Bus"]
FlashShim["Flash API Shim"]
Transpiler["AS2/AS3 Transpiler"]
DataAssets["DataAsset System"]
end
subgraph GameplayFeatures["Gameplay Features"]
SaveSystem["Tiered Save System"]
SaveBackends["Save Backends
(Local/NG/Steam)"]
QuestSys["Quest System"]
DialogueSys["Dialogue System"]
AISys["AI System"]
BehaviorTree["Behavior Trees"]
Navmesh["Navmesh / A*"]
Destructible["Destructible System"]
HUD["HUD System"]
Cinematic["Cinematic Camera"]
Localization["Localization"]
ObjectPool["Object Pooling"]
end
subgraph EditorFeatures["Editor Features"]
EditorLayer["EditorLayer"]
PlayMode["PlayMode"]
Inspector["Inspector Panel"]
Hierarchy["Hierarchy Panel"]
ScenePicker["Scene Picker"]
Gizmos["Transform Gizmos"]
Templates["Template System
(MaturityTier Badges)"]
Marketplace["Template Marketplace"]
Undo["Undo/Redo"]
CmdPalette["Command Palette"]
end
subgraph EffectFeatures["Effects Features"]
Weather["Weather System"]
Water["Water3D"]
Particles["Particle System"]
FluidSim["Fluid Simulation"]
FluidTerrain["Fluid-Terrain Coupling"]
ProcGen["Procedural Generation"]
WindSys["Wind System"]
WorldTime["World Time"]
end
subgraph AudioFeatures["Audio Features"]
SimpleAudioSys["SimpleAudio
(miniaudio)"]
SteamAudioProc["SteamAudioProcessor
(HRTF, Occlusion,
Transmission)"]
AudioEvents["Audio Event Graph"]
MIDI["MIDI Input"]
end
subgraph TestFeatures["Test Infrastructure"]
TestFramework["EnjinTest.h Framework"]
UnitTests["22 Unit Test Suites"]
IntegrationTests["4 Integration Tests"]
end
subgraph NetworkFeatures["Networking"]
LANMulti["LAN Multiplayer"]
NetSecurity["HMAC-SHA256 Auth"]
HTTP["HTTP Client"]
Newgrounds["Newgrounds API"]
end
subgraph BuildFeatures["Build & Export"]
BuildPipe["Build Pipeline"]
AssetPack["Asset Packer (.enjpak)"]
HTML5["HTML5 Export"]
PlayerApp["Player App"]
SceneSerial["Scene Serializer"]
end
subgraph UIFeatures["UI System"]
UICanvas["UICanvasComponent"]
UISys["UISystem"]
FocusNav["Focus Navigation"]
DialogueBox["Dialogue Box"]
end
subgraph AccessFeatures["Accessibility"]
Colorblind["Colorblind Filter"]
ScreenReader["Screen Reader"]
SwitchAccess["Switch Access"]
HighContrast["High Contrast"]
FontScale["Font Scaling"]
end
subgraph GraphEditors["Graph Editors"]
ShaderGraph["Shader Graph"]
AudioGraph["Audio Event Graph"]
ParticleGraph["Particle Graph"]
DialogueEd["Dialogue Editor"]
BTEditor["BT Editor"]
QuestEditor["Quest Flow Editor"]
end
%% Core -> Vulkan
Types --> VkContext
Platform --> VkContext
MathLib --> VkBuffer
Window --> VkRenderer
%% Vulkan -> Renderer
VkContext --> VkRenderer
VkContext --> VkPipeline
VkContext --> VkBuffer
VkContext --> VkImage
VkPipeline --> RenderSys
VkBuffer --> RenderSys
VkImage --> RenderSys
%% ECS -> Renderer
World --> RenderSys
Components --> RenderSys
MathLib --> World
%% Renderer -> Sub-features
RenderSys --> Shadows
RenderSys --> PostProc
RenderSys --> SpriteBatch
SpriteBatch --> SpriteAtlas
RenderSys --> ParticleRend
RenderSys --> Skybox
RenderSys --> SHProbes
RenderSys --> OIT
PostProc --> CelShade
PostProc --> RetroFX
RenderSys --> GPUCull
RenderSys --> ClusteredLt
RenderSys --> LODSys
RenderSys --> MatSortKeys
RenderSys --> FrameAlloc
RenderSys --> VRSSys
RenderSys --> VTSys
RenderSys --> VisBuf
VkContext --> ClusteredLt
VkContext --> GPUCull
VkContext --> VRSSys
VkContext --> VTSys
VkContext --> VisBuf
%% RT Dependencies
VkContext --> RTCaps
RTCaps --> AccelStruct
AccelStruct --> RTPipe
RTPipe --> RTShadow
RTPipe --> RTReflect
RTPipe --> RTAO
RTPipe --> RTGI
RTPipe --> PathTrace
RTShadow --> SVGF
RTReflect --> SVGF
RTAO --> SVGF
RTGI --> SVGF
RTShadow --> OIDN
SVGF --> RTComp
OIDN --> RTComp
RTComp --> RenderSys
RenderSys --> AccelStruct
%% Physics Dependencies
World --> IPhysics
World --> IPhysics2D
IPhysics --> Jolt
IPhysics2D --> Box2D
PhysicsFactory --> Jolt
PhysicsFactory --> Box2D
Collision --> SpatialHash
IPhysics --> Joints
Joints --> Ragdoll
%% Scripting Dependencies
World --> ASEngine
ASEngine --> Bindings
Bindings --> IPhysics
Bindings --> IPhysics2D
World --> VisScript
VisScript --> VSDebugger
VisScript --> VSProfiler
ASEngine --> Coroutines
ASEngine --> EventBus
ASEngine --> StateMachine
ASEngine --> FlashShim
FlashShim --> Transpiler
ASEngine --> DataAssets
%% Gameplay Dependencies
World --> SaveSystem
SaveSystem --> SaveBackends
SaveBackends --> Newgrounds
World --> QuestSys
World --> DialogueSys
World --> AISys
AISys --> Navmesh
AISys --> BehaviorTree
IPhysics --> AISys
World --> Destructible
IPhysics --> Destructible
World --> Cinematic
World --> ObjectPool
%% Editor Dependencies
RenderSys --> EditorLayer
World --> EditorLayer
EditorLayer --> PlayMode
PlayMode --> IPhysics
PlayMode --> ASEngine
PlayMode --> VisScript
PlayMode --> AISys
EditorLayer --> Inspector
EditorLayer --> Hierarchy
EditorLayer --> ScenePicker
EditorLayer --> Gizmos
EditorLayer --> Templates
Templates --> Marketplace
EditorLayer --> Undo
EditorLayer --> CmdPalette
%% Effects Dependencies
World --> Weather
World --> Particles
RenderSys --> Water
FluidSim --> FluidTerrain
World --> ProcGen
%% Network Dependencies
World --> LANMulti
LANMulti --> NetSecurity
HTTP --> Newgrounds
%% Build Dependencies
SceneSerial --> BuildPipe
BuildPipe --> AssetPack
BuildPipe --> HTML5
BuildPipe --> PlayerApp
PlayerApp --> RenderSys
PlayerApp --> PhysicsFactory
%% UI Dependencies
World --> UICanvas
UICanvas --> UISys
UISys --> FocusNav
DialogueSys --> DialogueBox
UICanvas --> DialogueBox
UISys --> ScreenReader
%% Accessibility Dependencies
PostProc --> Colorblind
UISys --> SwitchAccess
UISys --> FontScale
%% Audio Dependencies
SimpleAudioSys --> SteamAudioProc
SteamAudioProc --> IPhysics
PlayMode --> SteamAudioProc
PlayerApp --> SteamAudioProc
Bindings --> SimpleAudioSys
SimpleAudioSys --> AudioEvents
Input --> MIDI
%% Test Infrastructure
TestFramework --> UnitTests
TestFramework --> IntegrationTests
World --> UnitTests
IPhysics --> UnitTests
SceneSerial --> IntegrationTests
ASEngine --> IntegrationTests
%% Graph Editor Dependencies
VkPipeline --> ShaderGraph
Particles --> ParticleGraph
DialogueSys --> DialogueEd
BehaviorTree --> BTEditor
QuestSys --> QuestEditor
style CoreDeps fill:#1a2a1a,stroke:#4a8a4a
style VulkanDeps fill:#1a1a2a,stroke:#4a4a8a
style ECSDeps fill:#2a1a1a,stroke:#8a4a4a
style RTFeatures fill:#2a1a2a,stroke:#8a4a8a
style AudioFeatures fill:#2a2a2a,stroke:#9a6a3a
style TestFeatures fill:#1a2a1a,stroke:#6a9a6a
style PhysicsFeatures fill:#1a2a2a,stroke:#4a8a8a
style ScriptFeatures fill:#2a2a1a,stroke:#8a8a4a
style GameplayFeatures fill:#2a1a2a,stroke:#8a4a8a
style OptionalRender fill:#1a1a2a,stroke:#5a5aaa
Key Dependency Observations
VulkanContext is the foundation: Everything rendering-related flows through it, including the new GPU-driven subsystems (GPUCulling, ClusteredLighting, VRS, VirtualTexture, VisibilityBuffer). A backend abstraction layer exists (
RenderBackend) but Vulkan is the only implementation.ECS::World is the central hub: Almost every system depends on World for entity management. This is appropriate for an ECS architecture but means World stability is critical.
Physics abstraction is well-isolated:
IPhysicsBackendcleanly separates consumers from implementations. Swapping between Jolt and Box2D requires zero changes to gameplay code. The legacy SimplePhysics backend has been fully removed.Scripting has broad reach: Script bindings touch nearly every system (physics, audio, UI, gameplay, effects, procedural gen). Adding new systems requires adding new bindings to remain accessible.
PlayMode is a system compositor: It wires together physics, scripting, visual scripting, AI, audio, and more. It is the most complex integration point in the engine.
Graph editors are leaf nodes: Shader Graph, Audio Event Graph, and Particle Graph depend on their respective systems but nothing depends on them. They can be added or removed without architectural impact.
RT pipeline is cleanly optional: Ray tracing flows through
RTCapabilitiesdetection and gracefully falls back. The raster pipeline is completely independent.GPU-driven features are modular: Clustered lighting (ON by default) and GPU HiZ culling are core optimizations. VRS, Virtual Texturing, and Visibility Buffer are behind CMake feature flags (OFF by default) and can be enabled independently without affecting the base pipeline.
Steam Audio is a cross-system dependency:
SteamAudioProcessorbridges audio with physics — it uses collider geometry for occlusion/transmission calculations. This is the only place audio and physics directly interact, and it gracefully falls back to miniaudio built-in spatialization when Steam Audio is unavailable.Test infrastructure is a parallel tree: Tests depend on core systems (World, Physics, Serializer, ScriptEngine) but nothing in production depends on tests. The 50 test targets can be added or removed without affecting the engine.
Serializer is a trust boundary: The scene serializer and asset packer have been hardened (array caps, type safety, path traversal prevention) because they process external data. The trust zone boundary map documents all such interaction points.
Appendix: Data Sources
All data in this document is derived from:
CLAUDE.md-- Primary project context (~150 lines of verified feature documentation)docs/ROADMAP.md-- Technical roadmap with implementation details and priority matricesdocs/ARCHITECTURE.md-- System architecture documentationdocs/ENGINE_ANALYSIS.md-- This document (comprehensive technical analysis)docs/AUDIT_2026_02_11.md-- Comprehensive audit (98 findings)docs/AUDIT_2026_02_12.md-- Follow-up audit (96 findings)docs/AUDIT_2026_02_12_R2.md-- Third audit round (83 findings)docs/AUDIT_2026_02_13.md-- Fourth audit rounddocs/AUDIT_2026_02_18.md-- Beta 0.8 audit reportdocs/AUDIT_ECS.md-- ECS subsystem audit (O(1) validation, 40 tests)docs/AUDIT_RENDERER.md-- Vulkan renderer hardening auditdocs/AUDIT_SERIALIZATION.md-- Serialization and type safety auditdocs/AUDIT_ASSET_PACK.md-- Asset packer security auditdocs/AUDIT_PHYSICS_AUDIO.md-- Physics and audio hardening auditdocs/SECURITY_AUDIT.md-- Security audit (35 findings)
Feature counts, component counts, binding counts, node counts, and all technical specifications reference verified codebase data as documented in these files. Market analysis figures are estimates based on publicly available industry data and reasonable projections for a new entrant.
Document updated 2026-03-08. Enjin Engine is licensed under BSL 1.1 (Business Source License). Free to use for making games; 4-year change date to Apache 2.0.