On this page
The Bare Metal Core
Education & Perspective
My 6 years of Computer Engineering education were not just for a degree; they were for a perspective. During my Bachelor's, I focused on what was happening under the hood to the point where I often found myself explaining system architecture to my instructors. I knew better than them and I was the one telling what is happening under the hood.
My interest in understanding bare metal gave me a whole new perspective. That is why I love to understand more and more low level until I reach the bare metal. I do not just see a variable; I see a memory address and a cache line. This mindset informs every system I build in Unreal Engine and beyond.
Vanilla C++ vs. UE++
I was using UE++ which is completely different than vanilla C++. UE++ wraps everything in macros, reflection systems, and garbage collection. But I was actively learning vanilla C++ alongside it. I am driven to work closer to the metal, potentially on custom engines, to fully leverage memory safety and CPU architecture. I am looking for opportunities to work on custom engines and work with vanilla C++ to get deeper understanding of how things really work.
Custom Engine Research
The Engine Venture: Building From Scratch
I tried to make my own game engine with DearImGUI, SDL, WickedRenderEngine, and Jolt Physics Engine. Of course, graphics programming is a whole new subject. Since I was a 3D modeler as well, I understand a bit about how rendering works, but building a rendering pipeline that includes PBR rendering, RayTracing, or dynamic GI from scratch is a massive undertaking.
I chose to use a pre-built render engine so I could focus more on the other engine fundamentals. But I failed hard. I tried so hard to understand every piece, and I am still going forward to understand and make it work.
This failure was my greatest teacher. It forced me to confront the absolute mess of modern vs. legacy GPU APIs and the complexity of cross-platform handling. It solidified my understanding of graphics programming and gave me a curiosity that drives me to continue exploring how to do things without the safety net of Unreal or Unity or Godot. This shows my curiosity as a game developer to do something without relying on a commercial game engine.
GPU APIs & Graphics
I understand the basics of GPU APIs and the entire landscape of modern vs. legacy graphics APIs and the challenges of cross-platform handling. The world of GPU APIs is genuinely messy right now: you have Vulkan, DirectX 12, Metal on the modern side, and OpenGL, DirectX 11 on the legacy side, each with their own philosophy and trade-offs.
This knowledge extends beyond just graphics; it informs how I think about performance, memory layout, and hardware utilization in every system I build. Understanding the GPU pipeline makes me a better game engineer even when I am working at the engine level rather than the API level.
OS & CPU Internals
I also understand OS and CPU, how they work under the hood. I do not know what is inside an i9 Intel CPU at the transistor level, but I understand old microprocessors to know how they work under the hood and why ARM and x86 are different architectures. I know about SIMD (Single Instruction, Multiple Data), registers, paging, kernel, and device drivers.
It is still limited knowledge since it is too deep and out of my scope right now, but the foundation is solid and it informs everything I build. Understanding paging helps me understand memory allocation in game engines. Understanding kernel interrupts helps me understand why certain operations cause frame hitches.
Compilers, Linkers & WASM
I also wanted to know how developers make multiple languages work together. Then I learned how compilers work and how linkers combine different compiled objects. They produce platform-specific assembly which later becomes machine code that runs on that platform. I also studied GCC and LLVM, understanding the differences between modern and legacy compiler toolchains, and the nuances between x86 and ARM instruction sets.
WASM: The Browser's Assembly
I also discovered WASM (WebAssembly), which is essentially a portable assembly format that can run in a sandbox on any platform. Modern browsers support it and it achieves near-native execution speed in the browser. This makes running computationally intensive applications like games in browsers practical and opens up entirely new possibilities for game distribution without traditional installs. Combined with what I know about backend infrastructure, this could enable entirely new multiplayer architectures.