Wicked Engine is an open-source, cross-platform 3D graphics engine designed for developers who need a modern, high-performance foundation for games, simulations, or educational projects. Built in C++ with support for DirectX 12 on Windows and Vulkan on Linux, it provides a complete pipeline from rendering and physics to audio and input handling. Unlike monolithic game engines, Wicked Engine is structured as a flexible C++ framework that can be embedded into custom applications or used via its integrated editor. It supports entity-component-system architecture, physically based rendering (PBR), real-time raytracing, and full Lua scripting for rapid iteration. Its lightweight design makes it ideal for developers who want control over the engine internals without the overhead of larger engines like Unity or Unreal.
What You Get
- Modern Graphics APIs - Supports DirectX 12 on Windows and Vulkan on Linux with PBR, raytracing, global illumination, and FXAA post-processing for high-fidelity rendering.
- Lua Scripting Integration - Full Lua API access to scene management, audio, input, and rendering systems; enables rapid prototyping via live scripting in the editor or startup.lua files.
- Entity-Component-System (ECS) Architecture - Manage 3D entities and their components (transform, model, material) through a clean API with scene merging and component queries.
- Cross-Platform Support - Native builds for Windows, Linux, macOS, Xbox Series X|S, and PlayStation 5 (with proprietary SDKs required for console builds).
- Integrated 3D Editor - Full-featured editor with model import (FBX, GLTF, OBJ, VRM), scene editing, lighting, and live scripting console accessible via the HOME key.
- Audio System - Supports sound loading, instance-based playback, volume control (master and per-instance), and real-time audio manipulation via C++ or Lua.
- Input Handling - Unified input system for keyboard, mouse, and gamepad with press/down state detection for both C++ and Lua scripts.
- WISCENE Native Format - Efficient binary scene format for production use, with importers for common formats like FBX and GLTF to streamline asset pipelines.
Common Use Cases
- Building a cross-platform 3D application with PBR and raytracing - Developers create desktop applications using DirectX 12 or Vulkan, leveraging Wicked Engine’s built-in render paths and lighting systems without relying on external engines.
- Rapid prototyping of game mechanics with Lua scripting - Indie developers use the live Lua console in the editor to test physics behaviors, camera controls, or UI flows without recompiling C++ code.
- Learning modern graphics programming - Students and hobbyists use the engine’s clean C++ API and sample projects to understand ECS, render pipelines, and GPU-driven rendering techniques like global illumination.
- DevOps teams managing custom 3D tools - Teams building internal visualization tools (e.g., architectural or medical simulators) use Wicked Engine as a lightweight rendering backend with custom C++ extensions and Lua automation scripts.
- Game development with console-targeted graphics - Developers targeting Xbox Series X|S or PlayStation 5 use the engine’s modern rendering stack and platform-specific build configurations to deploy high-fidelity games.
- Problem: Need a lightweight engine for embedded 3D UI → Solution: Use Wicked Engine - Teams building AR/VR or kiosk applications use the engine’s small footprint and C++ embedding to integrate 3D interfaces into existing native apps.
Under The Hood
The Wicked Engine is a high-performance game engine built with a focus on real-time rendering, visual fidelity, and extensibility. It integrates modern graphics APIs like DirectX and Vulkan with a component-based architecture that supports flexible scene composition and runtime modifications. The engine emphasizes modular design and cross-platform compatibility, making it suitable for advanced game development workflows.
Architecture
This engine follows a layered, modular architecture designed for scalability and maintainability in game development environments.
- Component-based system design enables flexible object composition and runtime behavior modification
- Clear separation between core engine systems, editor components, and content management modules
- Editor-window abstraction patterns promote reusability and extensibility across different development tools
Tech Stack
The engine is primarily implemented in C++ and C, with integration of modern graphics and physics technologies.
- Built using C++ for performance-critical systems and C for low-level operations and system interfaces
- Leverages DirectX and Vulkan APIs for advanced rendering capabilities and GPU acceleration
- Integrates third-party libraries such as Assimp for asset loading and math utilities for graphics calculations
- Utilizes CMake for cross-platform builds and Visual Studio solutions for Windows development
Code Quality
Code quality shows a mixed state with moderate consistency and limited automated testing infrastructure.
- Runtime validation through Lua scripts and content-based test scenes is the primary testing approach
- Error handling varies across modules, with basic exception patterns in some third-party integrations
- Code style is moderately consistent but shows signs of technical debt in core implementation areas
- Limited automated test coverage and sparse unit testing infrastructure are notable gaps
What Makes It Unique
The engine distinguishes itself through its hybrid approach of high-performance core systems and flexible scripting support.
- Deep integration of HLSL shaders with the C++ rendering pipeline enables custom visual effects without breaking render loops
- Modular component architecture supports real-time scene editing and hot-reloading of content
- Extensive use of content pipelines and asset management systems enables dynamic lighting and particle effects
- Custom implementations of advanced features like volumetric lighting and global illumination provide unique visual capabilities