Building video games with 20 year old tech
Bastian Eicher
Gulaschprogrammiernacht 24 (GPN24) · Day 4 · ZKM Kubus
Overview
In a fascinating journey back to the roots of modern video game graphics, Bastian Eicher presented "Building video games with 20 year old tech" at GPN24. Eicher, a software engineer by profession who typically works on "cloud adjacent stuff," shared his long-standing hobby project: a custom graphics engine built using DirectX 9.0c, an API that was state-of-the-art around 2004. The talk offered a unique blend of nostalgia, technical deep dive, and practical demonstration, showcasing how the fundamental principles of 3D rendering evolved and how surprisingly capable "ancient" technology remains today.

Key moments
- 0:00 Introduction and talk overview
- 4:00 DirectX 7: The Fixed Function Pipeline
- 6:00 DirectX 9: Per-pixel lighting and post-screen effects
- 9:00 Live Demo: Fixed vs. Per-pixel lighting comparison
- 11:45 Game Demo: Unique time-rewind gameplay mechanic
- 12:50 Why build games with 20-year-old technology?
- 17:00 How modern drivers emulate fixed function pipeline
Building video games with 20 year old tech
Speakers: Bastian Eicher, Software Engineer
Conference: GPN24
YouTube: https://www.youtube.com/watch?v=kZd7Em-MM0c
Overview
In a fascinating journey back to the roots of modern video game graphics, Bastian Eicher presented "Building video games with 20 year old tech" at GPN24. Eicher, a software engineer by profession who typically works on "cloud adjacent stuff," shared his long-standing hobby project: a custom graphics engine built using DirectX 9.0c, an API that was state-of-the-art around 2004. The talk offered a unique blend of nostalgia, technical deep dive, and practical demonstration, showcasing how the fundamental principles of 3D rendering evolved and how surprisingly capable "ancient" technology remains today.
The core of Eicher's presentation explored the pivotal transition in graphics rendering, from the rigid fixed function pipeline of DirectX 7 to the highly programmable shader-based approach that became dominant with DirectX 8 and 9. He meticulously detailed the stages of a 3D rendering pipeline and illustrated how increasing hardware programmability unlocked sophisticated visual effects, such as per-pixel lighting, normal mapping, and real-time reflections. Beyond the historical context, Eicher provided live demos of his engine, highlighting the visual differences between rendering techniques and culminating in the "release" of his never-before-seen game, built entirely on this two-decade-old foundation.
This talk is particularly relevant for anyone interested in the history of computer graphics, game development fundamentals, or the trade-offs between using off-the-shelf engines versus building custom solutions. It serves as a testament to the enduring power of foundational knowledge and the unexpected longevity of well-designed APIs, even as the industry continually pushes towards newer, more complex paradigms. Eicher's passion for the low-level mechanics of rendering shone through, offering valuable insights into the "why" behind modern graphics techniques and the satisfaction of mastering one's own codebase.
Background
▶ Watch: Introduction and talk overview (0:00)
To appreciate the journey into 20-year-old game technology, it's essential to understand the landscape of PC gaming in the early 2000s and the fundamental concepts of 3D rendering. This era, particularly from 1999 to 2006, was a period of rapid innovation in graphics hardware and APIs, primarily on Windows PCs.
Eicher began by establishing a common vocabulary for 3D rendering steps:
- Vertexes: Points in 3D space defining an object.
- Transformation: Placing objects in the world, accounting for the camera view, and projecting them onto a flat 2D surface. This involves multiplication by a 4x4 matrix.
- Culling: Discarding vertex data outside the visible frustum for performance.
- Rasterization: Converting geometric data into pixels on the screen.
- Texturing: Applying images to pixels by performing lookups in texture maps to determine color.
- Lighting: Calculating the brightness of each visible pixel based on light sources and material properties.
- Depth Test: Determining if an object is obscured by another in the scene.
- Blending: Combining colors, often for transparency effects.
In the 2000s, the two dominant graphics APIs were OpenGL and DirectX. While OpenGL offered cross-platform support, DirectX was Microsoft's proprietary API, deeply integrated with Windows, and the focus of Eicher's talk. The API acts as an interface between the game and the graphics card driver, which then communicates with the underlying hardware.
The evolution of DirectX versions marked significant shifts in rendering capabilities:
- DirectX 7 (circa 1999): This was the era of the fixed function pipeline. Games like Counter-Strike and the original Deus Ex utilized this approach. In essence, developers fed vertex data, transformation matrices, and light parameters into the API, and the graphics card, in hardware, executed a predefined sequence of operations to produce an image. This was largely a "black box" operation. Crucially, lighting calculations happened before rasterization. This meant that the brightness of each point in a 3D mesh was calculated per-vertex, and the color between vertices was then linearly interpolated across the polygon. This often resulted in less realistic, "smooth" shading where specular highlights could appear dull or spread out, lacking sharp definition.
- DirectX 8 (circa 2001): This version brought about a revolution with the introduction of shaders. Games like Halo (originally Xbox, but technologically derived from Windows/DirectX) and Splinter Cell showcased these new capabilities. Shaders were small, programmable pieces of code that could replace specific parts of the fixed function pipeline, particularly the transform and lighting steps. Developers could write these programs in HLSL (High-Level Shading Language). Early shaders were quite primitive; for instance, they couldn't efficiently perform conditional branching (if-else statements), as the compiler would often execute both branches and discard one result. Despite these limitations, shaders enabled groundbreaking effects such as skeletal animations, mesh deformations (e.g., wobbly water surfaces), bump mapping (simulating surface detail with a texture), and detail texturing (swapping textures based on proximity for finer detail up close).
- DirectX 9 (circa 2002-2004): This is where Eicher's "heart lives" and the foundation of his engine began. Seminal titles like Half-Life 2 and Far Cry pushed the boundaries with DirectX 9. The most significant advancement was the substantial increase in shader instruction limits, allowing for much longer and more complex shader programs—up to five times longer than in DirectX 8. This extended programmability finally made per-pixel lighting feasible. Instead of interpolating vertex lighting, now each individual pixel could calculate its own light intensity, leading to dramatically sharper and more realistic lighting, shadows, and specular highlights. DirectX 9 also introduced the ability to implement post-screen effects, where the entire rendered scene could be treated as a texture and processed further by another pixel shader to create effects like bloom (light bleeding over edges).
- DirectX 9.0c (later 2004): Considered the "last version of the classic way of rendering things," DirectX 9.0c saw games like F.E.A.R. and The Elder Scrolls IV: Oblivion. It further increased shader instruction limits and, crucially, enabled dynamic branching within shaders, allowing for more complex, logic-driven programs. This facilitated advanced effects such as depth of field, motion blur, and simulated HDR tone mapping (not the modern display standard, but an in-engine effect).
- DirectX 10 (circa 2006 and later): With games like Crysis, DirectX 10 marked a hard cut. The fixed function pipeline was entirely removed. Developers were now forced to write shaders for every rendering step, even basic vertex transformations. While this offered ultimate flexibility, it significantly increased the baseline complexity for new developers, pushing many towards using comprehensive off-the-shelf game engines like Unity, Unreal Engine, or Godot, which abstract away these low-level details. Eicher, however, chose the harder path, building his own engine from scratch, leveraging the capabilities of DirectX 9.0c.
Key Findings
▶ Watch: DirectX 9: Per-pixel lighting and post-screen effects (6:00)
Bastian Eicher's talk provided several key insights into the evolution of 3D graphics and the practicalities of working with legacy technology:
- The Paradigm Shift from Fixed Function to Programmable Shaders: The most significant finding is the profound impact of moving from a rigid, hardware-defined fixed function pipeline (DirectX 7) to a flexible, software-programmable shader model (DirectX 8 onwards). This transition fundamentally changed how developers could control and manipulate graphics, enabling a level of visual fidelity and artistic expression previously impossible.
- Per-Pixel Lighting as a Game Changer: The ability to perform lighting calculations for each individual pixel, largely enabled by the increased complexity allowed in DirectX 9 pixel shaders, was a monumental leap. It dramatically improved the realism of lighting, shadow boundaries, and especially specular highlights, moving beyond the linearly interpolated, often "plastic-like" appearance of earlier per-vertex lighting.
- Shaders Unlocked Complex Visual Effects: The programmability offered by shaders allowed for a cascade of sophisticated effects. From normal mapping (simulating surface detail without more polygons) and detail texturing (dynamic texture resolution based on distance) introduced in DirectX 8, to real-time reflections, bloom effects, depth of field, and motion blur in DirectX 9.0c, shaders proved to be the engine of modern graphical realism.
- DirectX 9.0c as a "Sweet Spot": Eicher highlighted DirectX 9.0c as a particularly interesting version, representing a balance where powerful shaders were available, but some basic functionality could still be handled by a built-in fixed function pipeline. This allowed for a hybrid approach that offered both customizability and convenience, unlike DirectX 10 where everything required custom shaders.
- The Enduring Power of Legacy APIs: Despite being "20-year-old tech," DirectX 9.0c remains surprisingly capable. Eicher demonstrated that with clever implementation, it can still produce visually impressive results that hold up well today. Furthermore, modern graphics drivers often provide robust backward compatibility, emulating older APIs (e.g., translating DirectX 9 fixed-function calls into DirectX 12 shaders), ensuring that legacy software continues to function on contemporary hardware.
- Learning Value of Low-Level Development: Eicher emphasized that while building a custom engine from scratch is inefficient for commercial game development, it offers an unparalleled learning experience. Understanding the low-level rendering pipeline provides deep insight into how graphics work, which is invaluable for any aspiring or professional game developer.
- Performance Headroom on Modern Hardware: A practical benefit of using older, less demanding rendering techniques is the immense performance headroom on modern machines. Eicher noted his engine runs "hundreds of frames per second" on a gaming PC and even performs well on "Intel integrated graphics from 10 years ago," demonstrating that optimization concerns are significantly reduced.
Technical Deep Dive
▶ Watch: Live Demo: Fixed vs. Per-pixel lighting comparison (9:00)
Bastian Eicher's technical deep dive provided a comprehensive look at the evolution of 3D graphics rendering, focusing on the transition from fixed-function hardware pipelines to programmable shaders within the DirectX ecosystem.
The fundamental steps of the 3D rendering pipeline were outlined:
- Vertex Processing: Input vertexes (points in 3D space) are subjected to transformations. This involves multiplying their coordinates by 4x4 matrices to move them from their local model space into the world, then accounting for the camera's view, and finally projecting them onto a 2D screen.
- Culling: Optimizations like back-face culling and frustum culling discard polygons or objects that are not visible to the camera, reducing the amount of data processed.
- Rasterization: The transformed and culled geometry is converted into a grid of pixels on the screen.
- Texturing: For each pixel, a texture lookup is performed to determine its base color from an image.
- Lighting: The color is then modified based on light sources, material properties, and surface normals.
- Depth Testing: Ensures that only the closest objects are rendered for each pixel, handling occlusion.
- Blending: Final pixel colors might be combined, for example, to achieve transparency effects.
Fixed Function Pipeline (DirectX 7)
In the era of DirectX 7 (around 1999), the graphics card driver and hardware handled most of these steps in a predefined, inflexible manner. This was the fixed function pipeline. Developers provided input data—vertex positions, normals, texture coordinates, light parameters—and the hardware executed a set sequence of operations. A key characteristic was that lighting calculations occurred before rasterization, on a per-vertex basis. The brightness and color of each vertex were calculated, and then these values were linearly interpolated across the polygon during rasterization. This approach, often referred to as Gouraud shading, resulted in softer light transitions and less precise specular highlights, giving objects a somewhat "plastic-like" appearance, as the speaker later noted.
Programmable Pipeline: The Advent of Shaders (DirectX 8 onwards)
The introduction of shaders with DirectX 8 (around 2001) marked the beginning of the programmable pipeline. Shaders are small programs that run directly on the Graphics Processing Unit (GPU), allowing developers to customize parts of the rendering process.
- Vertex Shaders: These programs operate on individual vertices, replacing the fixed-function transformation and some lighting steps. They can manipulate vertex positions, normals, and texture coordinates. Early vertex shaders were quite limited, unable to perform complex conditional logic (e.g.,
if-elsestatements) efficiently, as the hardware would often execute both branches and discard the unwanted result. - Pixel Shaders (Fragment Shaders): These programs operate on individual pixels (or fragments before depth testing and blending). Initially, they were primarily used to program the texture lookup process, enabling effects like bump mapping (where an extra texture defines per-pixel normal vectors, simulating surface detail without increasing polygon count) and detail texturing (where a higher-resolution texture is blended in as the camera gets closer to an object).
DirectX 9: The Rise of Per-Pixel Realism
DirectX 9 (2002-2004) significantly expanded the capabilities of shaders. The instruction limits for both vertex and pixel shaders were drastically increased (up to five times longer), allowing for much more complex computations. This was crucial for:
- Per-Pixel Lighting: With longer pixel shaders, it became feasible to calculate lighting for every single pixel on a surface. This meant that light sources, normals, and material properties could be evaluated at pixel-level precision, leading to dramatically sharper light/shadow transitions and far more realistic and precise specular highlights. Eicher demonstrated this clearly by toggling between fixed-function and per-pixel lighting, showing the stark difference in sharpness.
- Post-Screen Effects: DirectX 9 enabled techniques where the entire rendered scene could be captured into a texture. This texture could then be processed by another pixel shader to create sophisticated post-processing effects like bloom (simulating light bleeding from bright areas), depth of field (blurring distant or near objects), and motion blur. The speaker showed his bloom effect by rendering the bright parts of the scene, blurring them, and overlaying them.
DirectX 9.0c: Dynamic Branching and Advanced Effects
DirectX 9.0c (late 2004) further refined the shader model by introducing dynamic branching. This allowed shaders to execute true conditional logic efficiently, without the performance penalty of earlier versions. This capability, combined with even higher instruction limits, enabled more advanced and context-aware effects such as more sophisticated HDR tone mapping (a simulated high dynamic range effect, not related to modern HDR displays) and improved depth of field and motion blur implementations.
Speaker's Custom Engine
Bastian Eicher's custom graphics engine, initiated in 2004, leverages DirectX 9.0c. It embodies a hybrid approach, utilizing the fixed function pipeline for basic operations where customizability isn't needed, and employing shaders for more advanced effects. This pragmatic design allowed him to selectively implement programmable features while benefiting from the built-in capabilities of the API. The engine demonstrates several sophisticated effects:
- Per-Pixel Lighting with Normal Mapping: Utilizes a normal map texture to provide per-pixel normal vectors, giving the illusion of intricate surface detail on relatively simple geometry.
- Detail Texturing: Dynamically swaps or blends textures based on camera distance, making surfaces like grass appear more detailed when viewed up close and smoother from a distance.
- Real-time Reflections (Water): A complex effect achieved by rendering the scene multiple times:
- The standard view of the scene.
- The scene rendered from the perspective of the water surface, but flipped vertically.
- The scene rendered with objects clipped below the water surface.
- A pixel shader then composites these multiple passes, blending the reflected scene with the water texture and other effects.
- Bloom Effect: As a post-screen effect, bright areas of the rendered scene are extracted, blurred, and then re-composited over the original scene to create a glowing aura around light sources.
The engine's ability to achieve these effects using a 20-year-old API highlights the power and flexibility that DirectX 9.0c offered, even before the complete removal of the fixed function pipeline in DirectX 10, which mandated a fully shader-driven approach for all rendering.
Demo / Proof of Concept
▶ Watch: Why build games with 20-year-old technology? (12:50)
Bastian Eicher provided compelling live demonstrations of his custom graphics engine, showcasing various rendering techniques and culminating in a preview of his unreleased game.
The first demo presented a super simple 3D scene featuring a single point light source and a standard 3D mesh (a model from the DirectX sample set). Eicher used this to illustrate the fundamental difference between fixed-function and per-pixel lighting:
- Fixed Function Pipeline Rendering: Initially, the scene was rendered using the fixed function pipeline, akin to what was possible with DirectX 7 before 2000. The lighting appeared softer, with linearly interpolated brightness across the polygons, and specular highlights were subtle and diffuse.
- Per-Pixel Lighting with Shaders: Eicher then toggled to per-pixel lighting, which leveraged a shader. The difference was immediately apparent: the light-dark transitions became much sharper, and the specular highlights on the model's shoulder became significantly more defined and focused. He further enhanced this with normal mapping, where an additional texture defined per-pixel normal vectors, creating the illusion of intricate surface detail (e.g., bumps and grooves) without increasing the actual polygon count of the model.
The second, more advanced demo showcased a more complex scene with multiple sophisticated effects, all running within his DirectX 9.0c engine:
- Detail Texturing: Demonstrated on a grass texture, the scene dynamically loaded a more detailed texture as the camera moved closer to the ground, providing a sense of higher resolution up close while keeping distant textures blurrier for performance.
- Real-time Reflections: A prominent feature was the real-time reflections on a water surface. Eicher explained the multi-pass technique behind this: the entire scene is rendered multiple times—once from the regular camera perspective, once from a flipped perspective below the water surface, and once with parts clipped above/below the water. A shader then composites these rendered images to create the convincing reflection effect.
- Bloom Effect: The scene exhibited a bloom effect, where bright light sources appeared to bleed or glow beyond their edges. Eicher toggled this post-screen shader off and on, revealing how the effect was achieved by rendering bright parts of the scene, blurring them, and then overlaying them onto the main render.
Finally, Eicher unveiled a small, previously unreleased game that utilizes this very rendering framework. The game features a single player-controlled character navigating a map. A notable visual aspect was the characters appearing in T-poses, as Eicher admitted he "never got around to implementing skeletal animations," highlighting a common challenge in custom engine development. The unique gameplay concept involves the player completing a task, after which time rewinds, and the player controls a different character while their previous actions are replayed by an NPC (Non-Player Character). This conceptual demo served as the "release" of his game, with a QR code provided for attendees to try it out.
Regarding performance, Eicher noted the engine has fallbacks that allow it to run on older hardware from the 2000s by disabling resource-intensive effects like water reflections and detail mapping. Crucially, he highlighted the significant performance headroom: the engine runs "just fine" on "Intel integrated graphics from 10 years ago" (his laptop) and achieves "hundreds of frames per second" on a modern gaming PC, underscoring the efficiency of older rendering techniques on contemporary hardware.
Defensive Implications
▶ Watch: How modern drivers emulate fixed function pipeline (17:00)
This talk primarily focuses on the technical evolution of 3D graphics rendering and game development, rather than direct security vulnerabilities or defensive strategies. Therefore, there are no immediate defensive implications in the traditional cybersecurity sense, such as identifying new attack vectors, patching specific vulnerabilities, or implementing security controls.
However, one can derive some indirect insights relevant to software development and long-term system maintenance, which can have security adjacent considerations:
- Understanding Legacy Codebases: Eicher's deep dive into DirectX 9.0c and the fixed function pipeline highlights the complexity of legacy software. For organizations maintaining older applications (not just games) that rely on deprecated graphics APIs, understanding these historical rendering paradigms is crucial. Security teams or developers tasked with auditing or updating such systems need to be aware of the underlying technology stack, as unexpected behavior or vulnerabilities might arise from interactions with modern drivers or operating systems.
- Backward Compatibility Layers and Emulation: The fact that modern graphics drivers "fake" the fixed function pipeline by translating older API calls into modern shader code (e.g., DirectX 9 to DirectX 12) is a testament to robust backward compatibility efforts. While generally beneficial, any translation layer introduces a potential for subtle bugs or performance regressions. From a security perspective, an imperfect translation could theoretically lead to unexpected memory access patterns or rendering artifacts that might be exploited in highly specific scenarios, though this is a theoretical stretch in the context of typical software vulnerabilities.
- The "Build Your Own" vs. "Off-the-Shelf" Dilemma: Eicher's choice to build his own engine versus using Unity or Unreal Engine touches upon a broader software development debate. While off-the-shelf engines offer speed and robust features (including security features, if applicable), a custom engine provides complete control and transparency over the codebase. In critical infrastructure or highly sensitive applications, this level of control could be seen as a defensive advantage, as every line of code is known and auditable, reducing reliance on third-party black boxes. However, the immense effort and expertise required to maintain a secure custom engine often outweigh this benefit for most use cases.
- Performance and Resource Management: The observation that older rendering techniques offer "huge amount of headroom" and "hundreds of frames per second" on modern hardware suggests that for applications where resource efficiency and minimal attack surface are paramount (e.g., embedded systems, lightweight clients), deliberately choosing simpler, older graphics paradigms could be a viable strategy. Less complex code often means fewer potential bugs and easier auditing.
In summary, while the talk doesn't present direct cybersecurity findings, it offers a valuable historical and technical perspective that can inform discussions around legacy system maintenance, the implications of API abstraction layers, and the trade-offs in software development choices that indirectly touch upon aspects of control, auditability, and resource management.
Key Takeaways
- The evolution from the fixed function pipeline (DirectX 7) to programmable shaders (DirectX 8 onwards) fundamentally transformed 3D graphics, enabling unprecedented control over rendering and leading to modern visual realism.
- DirectX 9.0c represented a pivotal era, offering a powerful balance of shader programmability (allowing for per-pixel lighting, normal mapping, and post-screen effects like bloom) while still retaining some built-in fixed-function capabilities.
- Building a custom graphics engine, even with "20-year-old tech," provides invaluable deep insights into the low-level mechanics of 3D rendering, offering a profound learning experience despite being impractical for commercial game development.
- Modern graphics drivers ensure robust backward compatibility by emulating older APIs; for instance, fixed function pipeline calls from DirectX 9 are often translated into DirectX 12 shaders, allowing legacy software to run on contemporary hardware.
- Older rendering techniques, when optimized, can achieve significant performance headroom on modern hardware, demonstrating that visual fidelity doesn't always necessitate the latest, most resource-intensive rendering paradigms.
- Bastian Eicher successfully built and effectively "released" a game using his custom DirectX 9.0c engine, proving the viability and enduring charm of working with foundational graphics technology.
About the Speaker(s)
Bastian Eicher is a software engineer by profession, whose day job involves working with "cloud adjacent stuff." Outside of his professional life, Eicher is a dedicated hobby game developer with a long-standing passion for understanding the intricacies of low-level graphics programming. While he had been "dabbling in game dev" for years, he had never formally released a game until his presentation at GPN24. His talk reflects a deep personal interest in the historical evolution of 3D graphics APIs and the satisfaction of building a custom engine from scratch, even if it uses technology from two decades ago.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Competent hobbyist retrospective on DirectX 7-9 evolution with live demos. Nothing novel for anyone who lived through that era or read GPU Gems, but Eicher's enthusiasm is genuine and the presentation is clear. Fills a slot for newcomers to graphics programming; veterans can skip.
Heather Calloway (CISO) — SOLID
A hobbyist's nostalgic deep-dive into DirectX 9.0c graphics programming. No security relevance whatsoever. This is a game development history talk at a community conference — well-executed for its audience, but entirely outside the security lane.