WickedEngine

Wicked Engine is an open-source, cross-platform 3D graphics engine written in C++ that targets modern graphics APIs: DirectX 12 on Windows, Vulkan on Linux, and Metal on Apple platforms including iOS. It is designed to be used as a C++ static library framework for custom applications, a full-featured standalone 3D editor, or a Lua scripting environment — with no engine fees, no telemetry, and no proprietary runtime lock-in.

The engine ships with a comprehensive feature set that covers the full real-time rendering pipeline: physically based rendering (PBR), real-time ray tracing with DXR and Vulkan ray tracing extensions, Dynamic Diffuse Global Illumination (DDGI), Surfel GI, Screen Space Global Illumination (SSGI), lightmap baking via GPU path tracing, Forward+ tiled rendering, and Gaussian Splat rendering. On top of rendering, it integrates Jolt Physics for rigid body, soft body, ragdoll, vehicle, and character physics; a job system designed around CPU parallelism; 3D audio via XAudio2 and FAudio; and UDP networking.

Wicked Engine’s Entity-Component System (ECS) is the organizational spine of the runtime. Components such as transforms, meshes, materials, lights, animations, physics bodies, and humanoid rigs are registered in a ComponentLibrary at compile time and iterated in linear memory layouts for cache efficiency. The Scene structure manages all component managers and exposes a clean API for loading WISCENE, GLTF, FBX, OBJ, PLY, and VRM/VRMA models. A Lua scripting API gives access to the full engine at runtime, and the included editor runs on all desktop platforms out of the box.

With 57 versioned releases, active monthly commits, CI pipelines for Windows, Linux, and macOS, and console-platform support for Xbox Series X|S and PlayStation 5 via private SDKs, Wicked Engine is a mature and well-maintained choice for indie game developers, graphics researchers, and teams building custom real-time 3D tools.

What You Get

• Multi-API Renderer (DX12 / Vulkan / Metal) — The engine selects the optimal backend per platform: DirectX 12 on Windows, Vulkan on Linux, and Metal on Apple systems, exposing a unified graphics abstraction for shaders, command lists, and resource barriers.
• Real-Time Ray Tracing and Global Illumination — DXR and Vulkan ray tracing extensions enable ray-traced ambient occlusion, shadows, and reflections; DDGI, Surfel GI, SSGI, and voxel GI provide multiple global illumination approaches selectable at runtime.
• Entity-Component System (ECS) — Components (transforms, meshes, materials, lights, physics bodies, animations, humanoid rigs, Gaussian splats) are registered in a ComponentLibrary and stored in contiguous arrays for cache-efficient iteration and serialization.
• Jolt Physics Integration — Rigid body, soft body, ragdoll, vehicle, character, and constraint simulation via Jolt Physics, with GPU-accelerated force field and particle-depth-buffer collisions alongside SPH fluid simulation.
• Lua Scripting API — Full access to engine systems at runtime: load models, control audio, manage scenes, configure render paths, handle input, and run integration tests — all from Lua scripts without recompiling.
• Cross-Platform Editor — A standalone 3D editor with scene graph, material editor, animation, content browser, lightmap baker, and scripting console that runs natively on Windows, Linux, and macOS with no internet dependency.
• Procedural Terrain and Gaussian Splat Rendering — The terrain system supports procedural generation with spline modifiers and LOD-aware spawning; Gaussian Splat rendering provides photorealistic capture-based scene reconstruction.
• Wide Model Format Support — Native WISCENE binary format for fast loading, plus import of GLTF/GLB (with extensive KHR extension support), FBX, OBJ, PLY, VRM 0.0 and VRM 1.0 (including VRMA animation) for humanoid avatars.

Common Use Cases

• Indie 3D game development with Lua scripting — A solo developer links WickedEngine as a static library, uses the Lua API to script gameplay logic, loads characters as VRM models, and builds a physics-driven game without writing a renderer from scratch.
• Real-time graphics research and prototyping — A university lab compiles the engine on Linux with Vulkan to implement and test new global illumination algorithms, ray tracing sampling strategies, or custom render passes using the extensible RenderPath3D class.
• Interactive 3D visualization tools — An architecture or product design firm uses the PBR renderer, GLTF import, and physics to build a real-time walkaround viewer for building models or industrial equipment without cloud rendering dependencies.
• Cross-platform game engine tooling — A studio building a proprietary pipeline uses Wicked Engine as the runtime foundation on Windows and Linux (with private console SDKs for Xbox and PS5), leveraging the editor for scene authoring and the job system for multi-threaded asset processing.
• VRM avatar applications — A developer building a virtual streamer or virtual event application imports VRM 1.0 models with spring bone and expression support, animates them via the humanoid rig system, and scripts interactions via Lua.
• GPU-accelerated effects and simulation — A technical artist uses the GPU-driven particle system, hair/grass simulation, ocean FFT simulation, and force field GPU simulation for real-time environmental effects in a custom application.

Under The Hood

Architecture Wicked Engine is organized as a layered, modular C++ codebase. At the foundation is a custom Entity-Component System where all scene data — transforms, meshes, materials, physics bodies, lights, animations, humanoid rigs, terrain, Gaussian splats, and scripts — is registered at startup via a ComponentLibrary that allocates each component type in a contiguous array. The Scene struct owns all ComponentManagers and exposes the full world state through a clean API; it supports multiple independent Scene instances that can be merged at runtime. Rendering is decoupled through a hierarchy of RenderPath classes: RenderPath2D handles sprites and fonts, while RenderPath3D inherits from it and adds the full 3D pipeline with configurable post-process effects (FXAA, TAA, MSAA, bloom, SSAO, HBAO, MSAO, RTAO, motion blur, depth of field, chromatic aberration, eye adaptation, and more). The job system exposes priorities (High, Low, Streaming) with HLSL-style dispatch arguments (jobIndex, groupID, groupIndex), mirroring the GPU threading model on the CPU.

Tech Stack The engine is implemented in C++17 and targets DirectX 12 on Windows (using the D3D12 Memory Allocator for GPU heap management), Vulkan on Linux (with Vulkan ray tracing extensions), and Metal 4 on macOS and iOS (via Objective-C++ bridge files). HLSL shaders are compiled offline by the included OfflineShaderCompiler using DXC (dxcompiler), with an optional embedded shader dump for distribution builds. SDL2 provides cross-platform windowing and input on Linux. The build system is CMake 3.19+ with optional IPO/LTO and AddressSanitizer/UBSan/TSan modes for Unix platforms; Visual Studio solutions are maintained in parallel for Windows. Third-party dependencies bundled in-tree include Jolt Physics, FAudio, D3D12MemAlloc, meshoptimizer, lodepng, and mikktspace.

Code Quality The codebase maintains consistent naming conventions (wi:: namespace prefix for all engine types, wi prefix for filenames) and uses custom container types (wiVector, wiUnorderedMap, wiUnorderedSet) and a fixed-size function type to avoid heap allocations in the job system hot path. CI runs on Windows, Linux, and macOS via GitHub Actions with ccache for incremental builds. Testing is handled through a visual Tests application that enumerates render scenarios (physics, particles, hair, IK, networking, cloth, lightmap baking) rather than automated unit tests with assertions — there are no automated pass/fail unit tests in the traditional sense. Error handling uses assertion macros with platform error string lookup rather than C++ exceptions. The absence of a linter or static analysis tool in CI is notable for a project of this size, though the team relies on compiler warnings and manual review.

What Makes It Unique Wicked Engine’s breadth of rendering techniques in a single open-source codebase is uncommon: it simultaneously supports DDGI, Surfel GI, SSGI, voxel GI, and GPU path-traced lightmap baking, giving developers the ability to switch between or combine GI approaches without a commercial engine license. The Gaussian Splat renderer, added alongside traditional rasterization and ray tracing, places it at the frontier of modern rendering research. The VRM 1.0 support with spring bone, humanoid rig, and animation retargeting is a differentiator for avatar-driven applications. The GPU-driven particle system, ocean FFT simulation, SPH fluid simulation, and 3D path finding are self-contained subsystems rarely found integrated together in a free engine. Console support for Xbox Series X|S and PlayStation 5 via private SDK extensions makes it viable as a commercial shipping target beyond PC.

Self-Hosting

Wicked Engine is released under the MIT License, which is one of the most permissive open-source licenses available. You can use it freely in commercial products, modify the source code, distribute it, and sublicense it — including in closed-source applications — without any royalties, engine fees, or requirement to open your own source code. The only obligation is to include the original copyright notice and license text in your distribution. This makes it unambiguously safe for commercial game development, tooling, and any other proprietary application.

Running Wicked Engine yourself means taking on full responsibility for the infrastructure and build pipeline. The engine has no server-side component, no telemetry, and no cloud dependency — it is a local C++ library and editor. You will need to maintain your own build toolchain (MSVC on Windows, g++/clang on Linux, Xcode on macOS), keep shaders recompiled as the HLSL sources evolve, and manage platform SDK updates (DX12 Agility SDK, Vulkan SDK, Metal). Console support for Xbox and PlayStation requires acquiring the platform-specific extension files from the console vendor directly, as those are not included in the public repository. The community is active on Discord and GitHub Issues, and the project ships monthly releases, so staying on a recent version requires periodic integration work.

Because Wicked Engine has no hosted or managed commercial tier, there is no SaaS alternative with an SLA, managed updates, or enterprise support contract. What you trade for the zero-cost MIT license is the absence of commercial support, guaranteed uptime for any cloud features, or a dedicated customer success team. For teams evaluating it against commercial engines like Unity or Unreal Engine, the trade-off is maximum licensing freedom and full source access at the cost of self-managed infrastructure, no marketplace, and a smaller contributor community than the large commercial engines provide.