Wicked Engine takes a modular approach to 3D rendering that allows developers to decouple game logic from rendering pipelines. This means you can swap between different rendering paths or add custom post-processing effects without rewriting core engine loops — a flexibility that’s hard to come by in many engines.
what Wicked Engine is and how it is built
At its core, Wicked Engine is an open-source, cross-platform 3D engine written in C++. It supports Windows, Linux, macOS, and extends to consoles like PS5 and Xbox through private extensions. The engine uses a modern deferred rendering pipeline, which defers shading calculations until after geometry processing, enabling efficient handling of complex lighting and shading scenarios.
Scene management is handled through an Entity-Component System (ECS), a design pattern that separates data (components) from behavior (systems). This separation allows for flexible, data-driven scene composition and decouples game logic from rendering concerns.
The engine also integrates Lua scripting, which provides a fast iteration loop for prototyping game logic or scene modifications without recompiling C++ code. This improves the developer experience, especially during experimentation or rapid development phases.
Architecturally, Wicked Engine is built around modular RenderPath components. Each RenderPath represents a rendering pipeline or stage — for example, 2D rendering, 3D rendering, or post-processing effects. These can be swapped or combined at runtime, enabling customization and extension without touching the engine’s core rendering loops.
Wicked Engine ships both as a standalone editor application and as a static library that you can embed in your own C++ projects. This dual approach makes it suitable both for learning and for production-grade rendering projects.
what makes Wicked Engine’s architecture stand out
The defining feature here is the clear decoupling of game logic from rendering via ECS and RenderPath architectures. This pattern allows you to manage scene data independently from how it’s rendered, which is useful for complex games or simulations where you might want to change rendering approaches on the fly.
The RenderPath system is particularly interesting because it modularizes rendering pipelines into components that can be composed or swapped. For example, you could switch between a 2D or 3D rendering pipeline or inject custom post-processing effects without rewriting the core rendering loop. This flexibility is rare in open-source engines and can save time when experimenting with graphics effects.
Lua scripting integration is another practical feature. It enables rapid prototyping and reduces the iteration time needed to test gameplay or visual changes. Instead of recompiling C++ code, you can tweak scripts and see results immediately.
Under the hood, the engine uses asynchronous initialization and modular components, which improves startup performance and maintains clean separation of responsibilities. The codebase is mature and well-structured, balancing performance with readability.
That said, the tradeoff is complexity. The modularity and ECS paradigm require some upfront learning, especially if you’re used to monolithic engines. Also, console support is limited to private extensions, which means if you want to target those platforms you’ll need access to those specific SDKs.
how to get started with Wicked Engine
Windows
To build Wicked Engine for Windows 10 or newer, open the WickedEngine.sln solution file with the latest Visual Studio. When it’s opened, press F5, then Wicked Engine and the Editor application will be built and then start. You can check out other sample projects in the solution too.
If you want to develop a C++ application that uses Wicked Engine, you can build the WickedEngine_Windows static library project and link against it. Including the "WickedEngine.h" header will attempt to link the binaries for the appropriate platform, but search directories should be set up beforehand. For example, you can set additional library directories to $(SolutionDir)BUILD\$(Platform)\$(Configuration) by default. For examples, see the Samples/Template_Windows, Samples/Tests, and Editor_Windows projects.
You can also use cmake to build on windows with these commands:
cmake -B build
cmake --build build --config Release
Linux
To build the engine for Linux, use Cmake. You can find a sample build script for Ubuntu here (in the linux section).
On Linux you will need to ensure some additional dependencies are installed, such as Cmake (3.7 or newer), g++ compiler (C++ 17 compliant version) and SDL2. For Ubuntu 20.04, you can use the following commands to install dependencies:
sudo apt update
sudo apt install libsdl2-dev
sudo apt install build-essential
To build the engine, editor and tests, use cmake and then make:
mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make
If you want to develop an application that uses Wicked Engine, you will have to link to libWickedEngine.a and #include "WickedEngine.h" into the source code. For examples, look at the Cmake files, or the Tests and the Editor applications.
Mac OS
To build the engine for Mac OS, use the provided .xcodeproj files with the Xcode development environment, for example:
- WickedEngine/WickedEngine.xcodeproj to build static
verdict: who is Wicked Engine for?
Wicked Engine is a solid choice if you want a flexible, open-source 3D engine that lets you customize rendering pipelines without digging into monolithic core loops. Its modular RenderPath system and ECS architecture offer a clean separation between game logic and rendering, which can accelerate experimentation and graphics prototyping.
That said, it assumes familiarity with C++ and some experience with ECS patterns. The Lua integration helps with prototyping but the engine isn’t a plug-and-play game maker — you’ll need to be comfortable building and integrating components yourself.
If you want a modern deferred renderer with cross-platform support and a static library that you can embed into your projects, Wicked Engine is worth exploring. Just be aware that console support requires private extensions and the learning curve is steeper than some simpler engines.
Overall, it’s a pragmatic, well-structured framework for developers who want control over rendering architecture and scene management in C++ without starting from scratch.
→ GitHub Repo: turanszkij/WickedEngine ⭐ 7,018 · C