This repository contains source code developed as part of my Bachelor's Thesis (TFG):
-
Bachelor's Thesis URL: https://hdl.handle.net/2117/439429
-
Video Showcase: https://youtu.be/A4NfI6ALey8
-
Nous Engine Repository: https://github.com/francesctr4/Nous-Engine
-
Multithreading Library: https://github.com/francesctr4/NOUS_Multithreading.h
Author: Francesc Teruel Rodriguez (francesctr4 on GitHub)
Created: 11/07/2025
Published Version: v0.3
License: CC-BY-NC-SA License
Attribution-NonCommercial-ShareAlike 4.0 International
Copyright (©) 2025 Francesc Teruel Rodríguez
Pull requests are welcome! If you'd like to suggest improvements, add features, or report issues, feel free to open a GitHub issue or PR.
- Home
- Changelog
- Dependencies
- Context
- Features
- Third Party Libraries
- Third Party Assets
- Installation
- Controls
- Known Bugs
- Future Roadmap
The v0.5 release introduces major architectural improvements, new Scripting System, and powerful tooling upgrades across the entire engine:
- Dynamic scripting using DLLs with an exposed EngineAPI (create, edit and recompile scripts on engine runtime).
- Hot reload support for instant iteration.
- Jobified script dynamic library recompilation.
- Engine bindings for function usage on scripting.
- Project files and folders reorganization.
- Modularized into multiple CMakeLists.txt using a clean recursive structure.
- Engine executable split into, editor executable and game executable with DLL + LIB layers (EditorApp.exe / GameApp.exe).
- Clear separation between Editor, Game, and Engine Core.
- Updated internal structure documented with a Lucidchart diagram.
- Expanded Logger system with channel-based filtering.
- Complete refactor and improvements to the Event System.
- New console window with new log channels and multiple ways to filter logs.
- Scene serialization supporting Save/Load (jobified).
- New hierarchy and inspector windows for ECS (Scene, GameObjects and Components).
- Upgraded Memory Manager and DynamicAllocator to fully support polymorphic types.
- New Memory Window to monitor tagged allocations in real time.
- New STL allocator integrated inside STL containters (e.g. NOUS_Vector).
- MemoryTag refactor using magic_enum library for reflective memory tagging.
- Added unit testing support with GoogleTest.
- Integrated CTest target for automated test execution.
- Doxygen script for automated documentation generation.
- Development Environment: Migrated project to CLion for improved cross-platform IDE support.
- Build System: Rebuilt the project using CMake with support for vcpkg (manifest mode) and CMake presets.
- Dependency Management: All third-party libraries are now handled through vcpkg, simplifying setup and updates.
- Cross-Platform Foundations: Refactored the codebase to begin supporting Linux and macOS, in addition to Windows.
- Library Updates:
- Upgraded from SDL2 → SDL3
- Replaced MathGeoLib → glmath for math utilities
- CMake Minimum Version: Now requires CMake 3.21 or higher
- Bachelor's Thesis: Final Delivery.
- Bachelor's Thesis: Delivery 2.
- Bachelor's Thesis: Delivery 1.
Important
-
Visual Studio Community 2022: Download and install Visual Studio Community 2022 with the following workloads:
- Desktop development with C++
- Make sure to include the latest C++ toolset and Windows SDK.
-
Vulkan SDK 1.3.296.0: Download and install the Vulkan SDK 1.3.296.0. This provides the Vulkan runtime, headers, and tools (like
glslcfor shader compilation). -
CMake (≥ 3.21): Build system.
-
Ninja: Build generator (specified in CMakePresets).
-
C++23 Compiler: e.g., MSVC, GCC ≥ 11, Clang ≥ 14...
-
vcpkg: Clone the repository on the same parent directory as this project (e.g. Nous-Engine/../vcpkg).
The project uses vcpkg to manage the following dependencies. They will be automatically installed and built when configuring the project with CMake.
- SDL3 (with Vulkan support enabled)
- Vulkan (Headers and libraries)
- Assimp (Asset import library)
- Dear ImGui (with features: docking-experimental, SDL3-binding, SDL3-renderer-binding, Vulkan-binding)
- STB (Single-file image loading library)
- Parson (Lightweight JSON library)
- Tracy (Profiling tool)
- GLM (Mathematics library for graphics)
- gtest (Unit testing framework)
- magic-enum (Header-only enum reflection library)
To install all required dependencies in classic mode:
vcpkg install vulkan sdl3[vulkan] assimp imgui[docking-experimental,sdl3-binding,sdl3-renderer-binding,vulkan-binding] stb parson tracy glm gtest magic-enum
Multithreading is a powerful yet complex area of software development, especially when applied to game engines. While professional ones include advanced multithreading systems, their internal implementations are rarely shared publicly. Moreover, existing tutorials often lack depth, leaving many developers unprepared for production level usage.
This project aims to bridge that gap by providing a beginner-friendly and practical introduction to multithreading, answering essential questions around performance, architecture, challenges, and limitations. The goal is to create a custom solution built from scratch, offering a solid starting point for developers interested in concurrent programming and game engine architecture on how to use multithreading effectively.
The practical part of the bachelor's thesis consists on developing a multithreaded game engine written in C++, featuring a Vulkan-based renderer to take advantage of its multithreading affinity. The chosen approach for the multithreading implementation is a thread-based job system built on top of a thread pool.
Nous Engine is a modular C++ game engine with a focus on multithreaded performance and low-level rendering control. Below is an overview of its key features:
- Modular engine structure (Renderer, Resource Manager, Input, etc.)
- Thread-based Job System built on top of a Thread Pool
- Memory management system with custom allocators and tagging
- Event system for module communication
- Logging and assertion utilities
- Vulkan renderer backend
- Camera controls
- Offscreen rendering support (Scene and Game viewports)
- 3D Geometry, Material and Texture loading
- Resource manager with support for meshes, textures, and materials
- Custom file system and serialization for accessing engine assets
- ImGui editor UI
- Asset browser for visual resource management
- Debugging tools for multithreading and resources
- Custom script to build the engine
SDL2 - Download
Vulkan - Download
Assimp - Download
ImGui - Download
stb_image - Download
MathGeoLib - Download
Tracy - Download
Parson - Download
Wolf by Juan_Puerta
Important
In order to download and execute the engine you have to Download the Latest Release and extract the zip.
It is recommended that you extract the zip on the parent folder of the disk, so that the path doesn't get too long.
(e.g. D:\Nous-Engine-v0.3)
In this case, the executable path will be as follows:
D:\Nous-Engine-v0.3\Nous-Engine\Nous-Engine.exe
The 3D editor camera supports smooth navigation using a combination of mouse and keyboard inputs. Controls are only active when the scene viewport is hovered.
| Input | Action |
|---|---|
Right Mouse Button (RMB) + W |
Move Forward |
Right Mouse Button (RMB) + S |
Move Backward |
Right Mouse Button (RMB) + A |
Move Left |
Right Mouse Button (RMB) + D |
Move Right |
Right Mouse Button (RMB) + E |
Move Up |
Right Mouse Button (RMB) + Q |
Move Down |
Shift (Hold while moving) |
Speed Boost |
Right Mouse Button (RMB) + Mouse Drag |
Rotate Camera |
Alt + Right Mouse Button (RMB) + Mouse Drag |
Orbit around target (origin) |
Middle Mouse Button (MMB) + Mouse Drag |
Pan camera (move on X/Y axes) |
Mouse Wheel Scroll |
Zoom In / Out |
This tool provides real-time visibility into the Job System and thread pool usage in the engine. It is divided into two main sections:
- Job System Overview
- Job Queue
This section displays the current state of the thread pool and job processing.
| Label | Description |
|---|---|
| Max Hardware Threads | Number of hardware threads detected on the system (std::thread::hardware_concurrency() - 1). |
| Total Worker Threads | Number of active worker threads in the pool (excluding the main thread). |
| Total Jobs | Total number of jobs currently being handled or queued. |
| Active Threads | Visual indicator showing how many threads are actively running jobs (green bar). |
| Thread Count Spinner | Lets you configure the number of worker threads. Setting it to 0 disables multithreading. |
| Resize Pool Button | Applies the new thread count, resizing the thread pool at runtime. |
| Multithreaded Mode | Indicates if the job system is currently in multithreaded mode. |
Displays the current state of each thread (including the main thread).
| Column | Description |
|---|---|
| ID | Unique identifier for each thread. |
| Name | Friendly label for the thread (e.g., Main Thread, Worker Thread 1, etc.). |
| State | Thread status — either RUNNING (executing a job) or READY (idle). |
| Current Job | The name of the job currently being executed. None if the thread is idle. |
| Time (s) | Duration (in seconds) the current job has been running / has taken to complete. |
This section lists all pending jobs that are waiting to be assigned to threads.
| Column | Description |
|---|---|
| Job Name | The label of the pending job, useful for tracking or debugging. |
| (count) | Displays the number of currently queued jobs. |
You can dynamically resize the thread pool using the spinner and Resize Pool button.
- Setting the worker count to
0switches the system to single-threaded mode. - The thread count can be adjusted in the range:
[0, (std::thread::hardware_concurrency() - 1) * 2]
These shortcuts trigger test jobs and resource loading using the job system for debugging and performance testing.
| Key | Action Description |
|---|---|
F1 |
Submits a job to load Lagiacrus Head mesh and material. |
F2 |
Submits a job to load Cypher mesh and material. |
F3 |
Submits a job to load Queen Xenomorph mesh and material. |
F4 |
Submits a job to load Wolf mesh and material. |
F5 |
Submits 4 staggered jobs, each loading a mesh and material with delays. |
F6 |
Clears all loaded resources on the scene. |
F7 |
Submits a test job that sleeps for 5 seconds. |
F8 |
Submits 100 CPU-bound jobs doing heavy dummy work for stress testing. |
The following issues are primarily related to the Resource Manager and the Vulkan Renderer Backend. While these fall outside the core focus of the thesis (which is centered on multithreading and the job system architecture), they are acknowledged and will be addressed in the near future:
- Submesh support is currently unimplemented; only a single mesh per entity is rendered.
- Crashes may occur when uploading multiple instances of the same textured mesh.
- Vulkan synchronization issues may happen when uploading geometry concurrently (RNG).
- Vulkan validation layer errors may appear when rendering multiple geometries on the scene.
These issues do not affect the multithreading implementation, which is functioning as intended.
While the current version of Nous Engine delivers promising results, it remains a foundation for much broader possibilities. Future development will focus on expanding the engine's capabilities:
Planned improvements to the Job System include:
- Work-stealing mechanisms for better load balancing
- Interruptible and cooperative threads
- Lock-free concurrency algorithms
- Job prioritization
- Job dependencies and graph-based scheduling
- Callback support on job completion or failure
To evolve into a more complete engine, future modules and tools may include:
- Scripting system
- Physics engine
- Animation system
- Audio engine
- User Interface (UI) system
- Particle system
- Artificial Intelligence (AI) module
- Shader system
Additionally, planned core tools include:
- Scene graph and hierarchy system
- Inspector and property editor
- Mouse picking and object selection
- Frustum culling
- Advanced time management
- Resource manager and asset browser enhancements
The render engine will continue to evolve with both foundational and advanced techniques:
- Forward and Deferred rendering pipelines
- Phong and Blinn-Phong lighting models
- Physically-Based Rendering (PBR) with Image-Based Lighting (IBL)
- Shadow Mapping
- Screen Space Ambient Occlusion (SSAO)
- Environment and Relief mapping
- Multi-pass bloom and Water effects
- More Multithreaded Rendering features
As development continues, both the engine’s architecture and its multithreading capabilities will be refined and extended. Nous Engine remains an evolving project.