Wicked Engine lists six platforms and builds four of them from the public repo
3D engine with modern graphics
At a glance
- What is it?
- Wicked Engine is a C++ 3D engine with an editor, a native WISCENE model format and Lua scripting, under an MIT licence. Four of the six platforms in its list can be built from the public tree; the console extension files for the other two are private.
- Who is it for?
- Wicked Engine suits a reader who wants a C++ rendering framework with a real editor, a scripting layer and sample projects to read, and who can live inside one graphics API per platform. It does not suit a console target, a team that needs a supported commercial licence, or a reader who expects stable prebuilt editors, since the nightly packaged editor builds sit behind a GitHub sign in and the console files are private.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly C++, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- turanszkij/WickedEngine7,356 ★ · +112
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| turanszkij/WickedEngine | 7.2k | 7.4k |
112 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Xbox and PlayStation build from files you cannot see
The platform list at the top of the project names six targets: Windows, Linux, Mac OS, iOS, Xbox Series X|S and PlayStation 5. One sentence below that list settles what to do with the last two: console specific extension files required for building are currently private. So the public tree carries build files you can actually open for four platforms, and names the other two as targets the engine supports without shipping the pieces that compile them. For a reader this cuts two ways. A project that has to ship on a console cannot be built from this repository, so those two entries describe intent rather than something actionable.
F5 builds the editor, but a library user has to set search paths first
On Windows there are two routes, and only one of them is a single keypress. Open WickedEngine.sln with the latest Visual Studio and press F5: the engine and the Editor application are built and then start, and other sample projects in the solution can be checked out as well. If you are writing a C++ application that uses the engine, you build the WickedEngine_Windows static library project and link against it. Including "WickedEngine.h" will attempt to link the binaries for the appropriate platform, but the search directories have to be set up beforehand, for example by adding $(SolutionDir)BUILD\$(Platform)\$(Configuration) to the additional library directories. The header tries to finish the job and cannot. Samples/Template_Windows, Samples/Tests and Editor_Windows are the reference projects. There is also a cmake path for the same platform:
cmake -B build
cmake --build build --config ReleaseOnly the Linux route spells out its dependencies
The Linux section is the only one with a dependency list: Cmake 3.7 or newer, a g++ compiler that is C++ 17 compliant, and SDL2, installed with three commands. The build itself is four more, ending in make. The only script offered anywhere is a sample Ubuntu build script in the linux section of .github/workflows/build.yml, so the recipe is written for one distribution. On Fedora, Arch or anything else the list has to be translated by hand.
Apple builds are four project files and no instructions
For Mac OS and iOS the project hands over Xcode project files instead of commands. WickedEngine/WickedEngine.xcodeproj builds the static library, Editor/Editor.xcodeproj builds the Wicked Editor, and Samples/Template_MacOS/Template_MacOS.xcodeproj and Samples/Template_iOS/Template_iOS.xcodeproj are minimal template applications meant to be used as a base for your own. No Xcode version and no macOS deployment target is named, no signing or provisioning step is described, and unlike Windows and Linux there is no cmake route for Apple systems here. The consequence is that the Apple path assumes you already know how to open a project, choose a scheme and answer whatever the toolchain asks. Set that beside the Windows one keypress build and the Ubuntu script, and the Apple route is the one that needs prior experience rather than the one that needs a download.
The only prebuilt editor sits behind a GitHub sign in
Getting the source is the easy half: clone https://github.com/turanszkij/WickedEngine.git with Git, or take it as a zip. Prebuilt binaries are the narrow half. Nightly packaged builds of the Editor are published through GitHub Actions, and getting them requires Github sign in, so there is no stable download URL and no versioned package index. What you receive is whatever a workflow produced on a given night. The release tags tell the release story instead: v0.72.139 on 3 November 2026, v0.72.120 on 2 October 2026, v0.72.113 on 24 August 2026, roughly four to six weeks apart. The most recent push to the default branch, master, is dated 2 November 2026, the day before the newest tag.
The default renderer changes with the platform and the flags carry no prefix
The renderer is not one API. The default is DirectX 12 on Windows, Vulkan on Linux and Metal on Apple systems, so an assumption written into one graphics path will not survive a move to another. Switching happens through command line arguments passed without any prefix, and the visible options include: vulkan selects the Vulkan rendering device on Windows, and debugdevice turns on the debug layer for graphics API validation, which the notes say degrades performance and writes graphics warnings and errors to the Output window. A Linux first assumption therefore cannot be checked on Windows without that flag. Debug device mode also has a real cost, so it belongs to a debugging session rather than to a profiling run.
Assets have to become WISCENE before anything else can open them
The native model format is WISCENE, and the design rule is that any application using the engine opens this format efficiently. The Editor is the conversion point: it imports OBJ, FBX, GLTF, GLB, VRM, VRMA and PLY, and you save the result as WISCENE. Loading then goes through LoadModel with a .wiscene path, after the application has been initialized and a render path activated:
application.Initialize(); // application will start initializing at this point (asynchronously). If you start calling engine functionality immediately before application.Run() gets called, then you must first initialize the application yourself.
wi::RenderPath3D myGame; // Declare a game screen component, aka "RenderPath" (you could also override its Update(), Render() etc. functions).
application.ActivatePath(&myGame); // Register your game to the application. It will call Start() once, then Update(), Render(), etc. from now on every frame...
wi::scene::LoadModel("myModel.wiscene");Sample models and scripts ship in Content/models and Content/scripts.
Three doors into Lua, and one of them runs before you ask
Lua is the scripting face of the engine and there are three ways in. Any included application, the Editor among them, has a scripting input method toggled by the Home key, which presents a text screen for typing LUA commands, and that screen is also called the backlog. A startup.lua placed near the application is always executed on application startup if it is found. A script can be pulled in with dofile("script.lua"). The API mirrors the C++ calls closely:
-- Set a rendering path for the application
path = RenderPath3D;
application.SetActivePath(path); -- "application" is created automatically by wi::Application
-- Load a model entity into the global scene:
entity = LoadModel("myModel.wiscene");
-- Load a model entity into a separate scene:
scene2 = Scene()
entity2 = LoadModel(scene2, "myModel2.wiscene");
-- Combine the separate scene with the global scene:
scene.Merge(scene2);
-- Get the current global scene:
scene = GetScene();
-- Move model to the right using the entity-component system:
transform = scene.Component_GetTransformThe scene model is the part to check first, since a script can write into the global scene or build a private one and merge it in.
Editorial conclusion
Wicked Engine suits a reader who wants a C++ rendering framework with a real editor, a scripting layer and sample projects to read, and who can live inside one graphics API per platform. It does not suit a console target, a team that needs a supported commercial licence, or a reader who expects stable prebuilt editors, since the nightly packaged editor builds sit behind a GitHub sign in and the console files are private. Before starting, read the platform list next to the private files note, check the LICENSE.txt and third_party_software.txt files, and plan for a cmake build rather than a download.
Frequently asked questions
What is Wicked Engine?
It is an open source 3D engine in C++ with modern graphics, offered as a framework for graphics projects, a standalone 3D editor, a LUA scripting environment or a way to learn. The licence is MIT.
How do you build and run Wicked Engine for the first time?
On Windows, open WickedEngine.sln with the latest Visual Studio and press F5, which builds the engine and the Editor application and starts them. On Linux the route is cmake with Cmake 3.7 or newer, a C++ 17 compliant g++ and SDL2 installed first.
Which games have been made with Wicked Engine?
The repository links a Steam store page for Wicked Engine and an itch.io page, but neither is named as a game built with the engine.
How does Wicked Engine compare with Unreal Engine?
The project page lists its own six platforms, its cmake and Xcode build routes, and the sample projects under Samples/.
Is Wicked Engine the best C++ game engine for a new project?
The project states that console specific extension files required for building are currently private, and that the model format every application reads is WISCENE, produced by the Editor.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/turanszkij-wickedengine)Star history chart for your README
[](https://hysenlabs.com/projects/turanszkij-wickedengine)Was this useful?