Enjin Engine

COMPREHENSIVE TECHNICAL ANALYSIS // 2026-03-08 // C++20 | VULKAN | CMAKE

0
Full Features
🧩
0
Component Types
📜
0
Script Bindings
🔗
0
VS Nodes
💎
0
RT Shaders
1

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.

System Architecture
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 / IPhysicsBackend2D interfaces allow swapping Jolt or Box2D at runtime via PhysicsBackendFactory. 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/ and Tests/Integration/ with a shared EnjinTest.h framework.
2

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

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.

Engine Evolution Timeline
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

4. Rendering Pipeline Flowchart

This diagram details the complete rendering pipeline for a single frame, including the 2D/2.5D/3D branching logic.

Rendering Pipeline
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

  1. Scene Classification Gate: 2D-only scenes skip shadow passes entirely, saving 4+ render passes per frame.
  2. 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.
  3. 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.
  4. 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.
  5. LOD with Hysteresis: Screen-space LOD selection with hysteresis band prevents LOD popping during camera movement.
  6. Per-Frame Linear Allocator: FrameAllocator provides O(1) allocation with single reset per frame for transient render data.
  7. Descriptor Caching: m_LastBound tracking skips vkUpdateDescriptorSets when texture/bone pointers are unchanged.
  8. Play Mode Skip: m_SkipMainPassRendering flag prevents double-drawing (offscreen Game View + main swapchain).
  9. Shadow Caster Cache: Pre-filtered list avoids redundant per-cascade entity iteration.
  10. Async Compute Overlap: GPU culling and cluster assignment run on async compute queue, overlapping with CPU-side scene preparation.
5

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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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

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

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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. "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

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)

Frame Budget Breakdown
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

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
Push constant flags 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 Low Low
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
SimplePhysics legacy RESOLVED — Removed entirely (Feb 2026). Source files deleted, enum entry removed, factory updated. Low Low

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

  1. Expand unit test coverageCOMPLETE: Expanded from 8 to 50 CTest targets with ~700+ test cases covering Physics2D, VisualScript, BehaviorTree, UISystem, Networking, StressFuzz, and more. All tests passing
  2. Extract EditorLayer panels into individual classes to reduce file size and improve maintainability
  3. Replace XOR obfuscation with authenticated encryption for commercial releases
  4. Restrict script #include paths to project directory to prevent path traversal — partially mitigated by lexically_normal() validation
  5. Deprecation timeline for SimplePhysicsCOMPLETE: Removed entirely Feb 2026
  6. Asset pack format versioning — Add version header to .enjpak format for forward compatibility (identified in serialization audit)
  7. Address 13 remaining deferred audit findings — Mostly low-severity items across asset pack format and string length validation
10

10. Feature Dependency Graph

This diagram shows which major features depend on which other features, illustrating the engine's internal coupling.

Feature Dependency Graph
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

  1. 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.

  2. 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.

  3. Physics abstraction is well-isolated: IPhysicsBackend cleanly separates consumers from implementations. Swapping between Jolt and Box2D requires zero changes to gameplay code. The legacy SimplePhysics backend has been fully removed.

  4. 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.

  5. 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.

  6. 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.

  7. RT pipeline is cleanly optional: Ray tracing flows through RTCapabilities detection and gracefully falls back. The raster pipeline is completely independent.

  8. 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.

  9. Steam Audio is a cross-system dependency: SteamAudioProcessor bridges 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.

  10. 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.

  11. 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.

11

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 matrices
  • docs/ARCHITECTURE.md -- System architecture documentation
  • docs/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 round
  • docs/AUDIT_2026_02_18.md -- Beta 0.8 audit report
  • docs/AUDIT_ECS.md -- ECS subsystem audit (O(1) validation, 40 tests)
  • docs/AUDIT_RENDERER.md -- Vulkan renderer hardening audit
  • docs/AUDIT_SERIALIZATION.md -- Serialization and type safety audit
  • docs/AUDIT_ASSET_PACK.md -- Asset packer security audit
  • docs/AUDIT_PHYSICS_AUDIO.md -- Physics and audio hardening audit
  • docs/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.