RV
Robert Vokáč C++ Game Runtime Programmer
Modern C++ · Game Runtimes · Compatibility Layers

C++ programmer building game runtimes and compatibility layers

Designed and implemented custom replacements for XNA, DirectX 3, and WinAPI-style APIs, enabling real-world games to run across Windows, Linux, Web, and Android without original runtime dependencies. Native C++ runtime running the same game codebase on Windows, Linux, Web, and Android.

Ported XNA game from C# to native C++ Runs on Windows · Linux · Web · Android Replaced XNA / MonoGame / DirectX dependencies Built compatibility layers over SDL3
Play Speedy Blupi 2013 View CNA Free Direct Free API GitHub Contact

About

Focused on modern C++, game runtime architecture, compatibility layers, and cross-platform native/Web systems validated through real games.

C++ programmer building game runtime systems, compatibility layers, and native frameworks through public projects.

Experience: 9 years of professional software development experience
Work type: Employee
Work location: Prague · onsite or remote
Core stack: Modern C++, Linux, CMake, Git, SDL3, SQLite, OpenGL, system design
Current direction: C++ game runtime systems, API compatibility layers, cross-platform native software, engine and tooling development

I build native C++ runtimes, platform layers, and compatibility frameworks. My work includes reimplementations of XNA, DirectX 3, and WinAPI-style APIs used to run real-world legacy games on top of SDL3 without original runtime dependencies across Windows, Linux, Web, and Android.

My strongest public work is CNA, a native C++ reimplementation of the XNA 4.0 programming model used to run Speedy Blupi (2013) ported from C# / XNA to C++ on Windows, Linux, Web, and Android. I also build Free Direct + Free API, SDL3-backed compatibility layers for legacy DirectX 3 / WinAPI games.

I am looking for C++ roles focused on game technology, runtime systems, compatibility layers, engine and tooling development, or cross-platform native software.

Email me GitHub OpenEggbert GitHub Download CV
  • Modern C++ development tied directly to substantial public codebases and long-term implementation.
  • Strong preference for explicit design, maintainable internals, modular boundaries, and reusable abstractions.
  • Systems-oriented thinking: ownership, lifecycle, extension points, resource management, and architectural clarity.
  • Interested in game runtimes, compatibility layers, frameworks, backend platforms, engine and tooling development, and infrastructure-style systems.
  • Developing CNA as a cross-platform C++ runtime that reimplements the XNA 4.0 programming model and runs Speedy Blupi 2013 on Windows, Linux, Web, and Android.
  • Developing Free Direct and Free API as SDL3-backed compatibility layers for legacy DirectX 3 / WinAPI games.
  • Supporting runtime work with easy-gl and sharp-runtime.
  • Hive is retained as an archived C++ backend/platform architecture showcase.
Czech University of Life Sciences Prague
BSc in Computer Science (2014–2017)
Secondary Technical School Hořovice
Informatics in Economics (2008–2012)
  • Self-directed long-term C++ curriculum built around books, implementation, and technical notes.
  • Current study areas: modern C++, runtime architecture, rendering infrastructure, engine and tooling design, concurrency fundamentals, and reusable library design.
  • Learning model: theory from books combined with real implementation in public repositories.

Selected books from my long-term C++ and software architecture study.

Selected books
  • Effective Modern C++
  • C++ Software Design
  • API Design for C++
  • C++ Concurrency in Action
  • C++ High Performance
  • The C++ Programming Language
  • C++ Templates
  • Large-Scale C++ Software Design
  • Embracing Modern C++ Safely
  • C++ Core Guidelines Explained

Technologies

Modern C++ first, with game runtime architecture, compatibility engineering, systems thinking, and framework design made visible through real code.

Domains

Modern C++
Runtime architecture
Compatibility layers
Framework design
Engine-level development

C++

C++20/23
API design
Ownership & lifecycle
Modular architecture
Maintainable code

Systems

Concurrency fundamentals
Rendering infrastructure
Backend platforms
Cross-platform native development
Performance awareness

Tooling

CMake
Git
Linux
GCC / Clang
Bash

Data & Storage

SQLite
Schema design
Migrations
REST APIs
Practical persistence

Engineering style

Readable APIs
Explicit design
Architecture-first thinking
Testing mindset
Long-term maintainability

Projects

Public projects showing game runtime architecture, compatibility layers, and C++ systems design validated on real applications.

MainCNA
SDL3

CNA

Cross-platform C++ runtime reimplementing the XNA 4.0 programming model

GitHub: github.com/openeggbert/cna · Stack: C++20, SDL3, CMake, OpenGL/easy-gl, bgfx, native runtime design, Windows/Linux/Web/Android

  • XNA-style API in native C++ under Microsoft::Xna::Framework.
  • Custom multi-platform game runtime with rendering, input, audio surfaces, resource lifecycle, and backend abstraction.
  • Backend abstraction over SDL3, OpenGL/easy-gl, and bgfx.

Real-world usage:

  • Native C++ runtime replacing XNA / MonoGame dependencies.
  • Runs Speedy Blupi (2013) ported from C# / XNA 4.0 to C++ on Windows, Linux, Web, and Android.
  • Public playable web build available; desktop and Android builds run the same C++/CNA codebase.
  • Gameplay behavior closely matches the original version.
  • Current builds run smoothly across supported platforms.
Playable web build Video demo Repository
DX3
CPP

Free Direct

DirectX 3 (2D) compatibility layer implemented in modern C++

GitHub: github.com/openeggbert/free-direct · Stack: C++20, SDL3, DirectDraw subset, DirectSound subset

  • Reimplements a narrow DirectDraw / DirectSound subset over SDL3.
  • Implements CPU surface model, blitting, color keys, palette support, locking, and presentation.
  • Designed as a replacement for original DirectX 3 SDK dependencies in selected legacy games.

Real-world usage:

  • Runs Speedy Blupi / Speedy Eggbert 2 (1998/2001) together with Free API, with a public playable web build.
  • Used for legacy DirectX 3 game compatibility without the original SDK.
Playable web build Video demo Repository
WIN
API

Free API

WinAPI (~1998) compatibility layer implemented in C++

GitHub: github.com/openeggbert/free-api · Stack: C++20, SDL3, WinAPI-style headers, message loop, timers, MCI/MIDI

  • Implements WinAPI-like windowing, message loop, input translation, timers, and selected multimedia APIs.
  • SDL3-backed implementation for cross-platform execution without Microsoft Windows.
  • Works together with Free Direct as the system/runtime side of legacy game compatibility.

Real-world usage:

  • Used together with Free Direct to run Speedy Blupi (1998/2001).
  • Planet Blupi (1996) is partially working; some areas still require compatibility debugging.
Playable web build Repository
HIVE

Hive (archived)

Archived architecture showcase

40k+ LOC C++ backend platform formerly developed as Mind-Net

GitHub: github.com/robertvokac/hive · Stack: C++23, Crow, SQLite, custom ORM/model layer, plugin architecture

  • 40k+ LOC C++ backend platform.
  • Metadata-driven architecture, custom ORM, migrations, and generated REST APIs.
  • Plugin system, scheduler, triggers, validators, jobs, and queries.

Status: Archived; retained as a backend/platform architecture showcase.

Repository
EASY
GL

easy-gl

Graphics support library for rendering infrastructure and reusable native abstractions

GitHub: github.com/openeggbert/easy-gl · Focus: rendering support, graphics abstraction, OpenGL-oriented infrastructure

  • Focused graphics infrastructure library used to isolate and validate rendering abstractions.
  • Supports the broader engine/framework direction by isolating graphics infrastructure concerns into a reusable library.
Repository
CPP
.NET

Sharp Runtime

Foundation library for reusable system-level building blocks

GitHub: github.com/openeggbert/sharp-runtime · Focus: exceptions, events, delegates, utility types, framework foundations

  • Provides reusable foundation-layer building blocks such as exceptions, events, delegates, and utility abstractions.
  • Acts as a lower-level support library for higher-level native C++ runtime and framework work.
Repository
LEXI
CON

Lexicon

Desktop knowledge dictionary for structured learning and technical notes

GitHub: github.com/robertvokac/lexicon · Stack: C++23, Qt Widgets, SQLite

  • Local-first desktop tool for maps, terms, metadata, backlinks, and Markdown-based technical notes.
  • Built around practical search, filtering, pagination, and structured learning workflows.
Repository
BIT
BACKUP

bit-backup

Command-line utility for long-term data integrity and bit rot detection

GitHub: github.com/robertvokac/bit-backup · Stack: C++23, SQLite, OpenSSL

  • Stores and verifies SHA-512 checksums in a local SQLite database to detect silent corruption over time.
  • Focused on reliability, local control, and practical long-term data integrity.
Repository
Professional software development backgroundPrague · onsite or remote

Professional software development experience

9 years of professional software development experience. Public portfolio intentionally focused on current C++ direction, runtime systems, compatibility layers, and cross-platform native development.

  • Worked on long-lived production backend systems with focus on maintainability and system stability.
  • Applied system design principles in large, evolving codebases.
  • Designed and optimized database structures and data flows.
  • Experience with real-world constraints, debugging, and production issues.