Getting to Know Nau Engine: Building an Open-Source Game Engine from Source

Nau Engine has been talked about a lot, but hearing announcements at conferences is one thing, and actually diving into the public repository to get hands-on with the code is another. The repository is open, the source code is available on GitHub, and anyone can clone the project to their machine to evaluate the architecture or try building a test build.

The authors immediately declare an open distribution model: the engine is free for any purpose, including commercial game releases, with no licensing fees or hidden royalties. The source code is publicly available, so the community can create forks, extensions, and pull requests.

What's Inside the Repository

If you open the NauEnginePublic repository, you'll immediately notice a classic C++ stack for large-scale projects. There's no attempt to reinvent the wheel with a custom package manager: dependencies are pulled in via vcpkg, and builds are managed through modern CMake presets.

The engine itself is written in C++, actively relies on submodules, and requires up-to-date tooling:

• MSVC v143 from Visual Studio 2022
• Current version of Windows 10 SDK
• Python 3.10 or newer for build scripts
• CMake build system with CMakePresets support

At the current stage, the repository has a clear focus on the Windows platform. The documentation describes presets for Visual Studio 2022 and the Clang-CL with Ninja combination. Support for Linux or macOS is not yet detailed in the README, so the primary working scenario is currently tied to the Microsoft stack.

Environment and Dependencies Setup

Building a game engine from scratch always requires patience. The first thing after cloning the repository is to pull the submodules—without them, the project simply won't configure:

git clone https://github.com/NauEngine/NauEnginePublic.git
cd NauEnginePublic
git submodule update --init --recursive

Next comes working with the vcpkg package manager. If you don't have it installed yet, the authors recommend cloning it to a separate directory, for example at c:\tools\vcpkg, and running the initialization:

cd c:\tools
git clone https://github.com/microsoft/vcpkg
.\vcpkg\bootstrap-vcpkg.bat

After that, you need to set the VCPKG_ROOT environment variable. Without this variable, CMake won't know where to look for libraries.

By the way, there's a useful hint in the repository: if the vcpkg.json file changes in a branch, it's best to do a clean build by clearing the working directory with git clean -d -x -f. The key thing is to save all your unsaved changes beforehand, otherwise git will erase them without warning.

Configuration and Build Process

Once the dependencies are in place, CMake takes over. The project has ready-made presets configured, so you won't need to manually specify dozens of compiler flags.

To generate the project for Visual Studio 2022, run:

cmake --preset win_vs2022_x64

If you prefer the Ninja and Clang combination, there's an alternative preset:

cmake --preset win_ninja_clangcl-debug

You can also simply open the project folder in VS Code or Visual Studio. The IDE will automatically pick up the CMakePresets.json file and suggest selecting the desired configuration in the interface.

The compilation process itself is launched via CLI or directly from the IDE:

cmake --build build\win_vs2022_x64 --config=Debug

After compilation completes, you can install the engine to a local directory output:

cmake --install build\win_vs2022_x64 --config=Debug

In this folder, you'll get a build ready for further integration.

Why Developers Should Study This Code

Nau Engine is interesting not only for those planning to make games with it, but also for regular C++ programmers.

First, it's a fresh codebase. Many popular engines carry the baggage of twenty-year-old decisions. Here you can see how a modern project on the latest C++ standard is organized, how modules are split, and how the asset processing pipeline works.

Second, the project is fully open for contributors. There are open issues and pull requests in the repository, and the community is gradually starting to participate in improving the engine. If you've been looking for a complex system-level open source project where you can contribute optimizations or new features, Nau Engine offers that opportunity without the bureaucracy of proprietary licenses.

Third, it's a good testing ground for experimenting with custom renderers, physics engines, or scripting wrappers. Having a ready modular structure saves weeks of tedious environment setup work.

Fourth, for game studios, it's a real chance to get a technology stack that doesn't depend on the whims of foreign vendors and sudden changes in licensing agreements.

Where to Start

If the project interests you, start simple: clone the repository, follow the build guide steps, and try building the engine in Debug mode. Read through the directory structure, look at the implementation of basic subsystems in the source code, and check the Issues tab on GitHub. For those interested in game engine development from the inside, this is excellent study material.