The Context

[renanbomtempo]

The Context

For years, I've been obsessed with understanding what actually happens between a keyboard press, the OS, and a single pixel rendering inside a window on screen. That curiosity is what originally sparked this EldritchCodex project, where I can explore how real-time interactive applications, engines, and simulations work under the hood.

The Spark (2022)

Its roots trace back to an undergrad Computer Graphics course. My first assignment was a messy 2D Galaxian clone in OpenGL, with no separation between game logic and engine, just code thrown together to make it work. For the next assignment, a 3D boids simulation, I wanted something cleaner. I glued myself to TheCherno’s Game Engine series on YouTube, typing along line-by-line to get my hands dirty with windowing, layer stacks, event systems, and basic rendering pipelines.

After the course, I adapted that codebase to visualize numerical simulators for my undergrad research. That was the turning point, where I dove into canonical books like Jason Gregory’s Game Engine Architecture, Eric Lengyel’s Foundations of Game Engine Development, and Akenine-Möller et al.’s Real-Time Rendering, beginning to treat the project not just as a toy engine, but as a broader foundation for future projects.

The Academic Detour

When I started my Master's research on Lagrangian-Eulerian methods for 2D hyperbolic conservation laws, my initial ambition was to run the some computational fluid dynamics directly inside this framework. I managed to get a crude version running, but reality set in quickly: the architecture wasn't nearly polished or robust enough, and I was fighting my own architectural debt and derailing the research itself. I quickly then made the pragmatic choice to pivot to Python for rapid prototyping and focused on completing the degree.

The Renaissance

Now that my thesis is defended and published, I’ve returned to the project with fresh eyes and even more motivated. Looking back at my old tutorial-born OOP code, I realized it was time to tear down some naive abstractions and rebuild the architecture around modern C++20/23 and data-oriented models.

Instead of building a monolithic engine, I’ve organized the project into focused, decoupled modules:

1. Nodens (The Core)

The backbone of the ecosystem. It is designed to handle the foundation of any interactive application:

• Layer Stack: Dictates the lifetime, update order, and render flow.
• Data-Oriented Event System: Replaced the old OOP event hierarchy and dynamic casting with flat Plain Old Data (POD) structs, strictly validated via C++20 concepts. Input events routes synchronously through the layer stack, while subsystem events dispatch through an event bus or get deferred into a double-buffered byte array queue.
• Cooperative Concurrency: Non-blocking workloads run on a lightweight job system backed by a std::jthread pool, using std::stop_token for clean cooperative cancellation.
• UI & Visual Telemetry: Integrated Dear ImGui alongside ImPlot and ImPlot3D for live parameter tuning and 2D/3D data inspection directly inside running simulations.
• Frame Profiling: Native integration with Tracy for deep, low-overhead frame and memory profiling from day one.

2. Nyar (The Real-Time Renderer)

Sitting alongside Nodens is Nyar. It will be a completely separate module designed to render arbitrary geometry to the screen in real-time, integrating with Nodens only when an application actually requires hardware-accelerated graphics. Having gutted the legacy OpenGL pipeline from earlier Nodens versions, I am currently architecting a dedicated Vulkan backend from scratch, moving beyond the classic triangle milestone to establish clean frame abstractions and pipeline management.

The Road Ahead

This is fundamentally an ongoing learning project. I don’t pretend the architecture is production-hardened AAA tech yet; it’s an evolving testbed where I can constantly iterate on data layouts, modern language features, and low-level systems design.

Because the entire ecosystem is designed around isolated modules, Nodens and Nyar are just the foundation. As the framework matures, I plan to expand the EldritchCodex ecosystem with entirely new, independent subsystems. The immediate roadmap includes developing a custom physics engine to explore real-time rigid body dynamics and collision detection, as well as building an offline renderer module focused on path tracing and physically based rendering (PBR). By keeping these systems decoupled, I have a permanent sandbox where I can tackle complex engine domains one by one without tangling them into a monolithic web of dependencies.

Another milestone, once the core fundamentals are rock-solid, is to port my Master’s research out of Python and back into this C++ framework, giving my Lagrangian-Eulerian solver the high-performance, real-time visualization home it was originally meant to have.

In the meantime, if anyone needs a lightweight, modern C++ scaffold to jumpstart their own interactive tools, simulators, or graphics experiments, feel free to use Nodens.