C++ software engineer building cross-platform systems and compatibility layers

Mesh Craft

3D scene editor and modeling application for the MC3 format

GitHub: github.com/openeggbert/mesh-craft · Website: meshcraft3d.com · meshcraft.openeggbert.com · Stack: C++23, CNA, sharp-runtime, Dear ImGui · Native .mc3.xml format compiled to glTF/GLB · ≈16.5k LOC

• 3D modeler with primitive shapes (box, sphere, cylinder, cone, plane, torus, capsule, disk), CSG boolean operations (union, difference, intersection via Manifold), materials, PBR textures, and hierarchical groups.
• Animation support: position, rotation, scale, visibility, material color, and deform channels; reusable prefab/instance definitions, layers, tags, collision hints, fog and environment settings.
• Native .mc3.xml format: human-readable XML-based editable source compiled to glTF/GLB or binary MCB via included CLI tools (mc3togltf, mc3tomcb).
• Built on CNA + sharp-runtime; exercises the full C++ engine stack as a real editor application.

Status: Actively developed — full XML load/save roundtrip, all primitives, CSG booleans, extrude, keyframe animation, and glTF/GLB export working.

Mesh World

Procedural 3D world generator and real-time explorer built on the Mesh Craft ecosystem

GitHub: github.com/openeggbert/mesh-world · Website: meshworld3d.com · meshworld.openeggbert.com · Stack: C++23, Mesh Craft, CNA, sol2/Lua 5.4, SQLite · ≈8.6k LOC

• Generates infinite 3D city and landscape chunks from a simple JSON config — 20 C++ chunk generators and 17 Lua object generators covering parks, roads, buildings, and terrain.
• Lua scripting sandbox (sol2 + Lua 5.4) for content modding: add new generators by dropping a Lua file into the generators directory; auto-discovered at startup.
• SQLite content packs: taxonomy registry, material registry, and generator bundles packed into portable .sqlite files for distribution.
• Real-time 3D explorer (MeshWorldApp): streams and renders chunks around the player using Mesh Craft + CNA (SDL3/OpenGL).

Status: 119 tests passing, zero warnings, CI on every push. Core chunk generation pipeline and Lua scripting complete.

CNA

Cross-platform C++ framework implementing an XNA-style API

GitHub: github.com/openeggbert/cna · Website: libcna.com · cna.openeggbert.com · Stack: C++20, SDL3, CMake, OpenGL/easy-gl, bgfx, Windows/Linux/WebAssembly/Android · ≈61.5k LOC

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

• Native C++/SDL3 implementation replacing XNA / MonoGame dependencies.
• Used to port a real C# / XNA application to C++.
• Same C++ codebase builds for desktop, WebAssembly, and Android targets.

CNA Samples

C++ ports of the Microsoft XNA Game Studio 4.0 sample collection running on CNA

GitHub: github.com/openeggbert/cna-samples · Stack: C++23, CNA, sharp-runtime, CMake · ≈32.3k LOC

• C++ ports of the official Microsoft XNA Game Studio 4.0 samples (Platformer, HoneycombRush, NinjAcademy, card games, and more), running on the CNA framework.
• A continuously growing compatibility test bed proving CNA's API coverage on real XNA-era code.

Status: Migration in progress · Web demos coming soon.

Sharp Runtime

C++ reimplementation of a broad C#/.NET runtime subset — System::* API in native C++

GitHub: github.com/openeggbert/sharp-runtime · Website: sharpruntime.openeggbert.com · Stack: C++20/23, CMake · Broad .NET coverage: System::* namespaces, events, delegates, exceptions, collections · ≈36.4k LOC

• Implements a broad subset of .NET/C# types under System::* namespaces in idiomatic, modern C++ — familiar API design for C# developers.
• Covers exceptions, events, delegates, collections, and other system-level building blocks; tracks implementation status per class (Todo / Stub / Partial / Implemented / Verified).
• Foundation layer for CNA, Mesh Craft, Mesh World, and Galaxy Eggbert; not a CLR — a practical native subset designed for real cross-platform use.

Free Direct

DirectX 3 / DirectDraw compatibility layer implemented in modern C++

GitHub: github.com/openeggbert/free-direct · Website: freedirect.openeggbert.com · Stack: C++20, SDL3, DirectDraw subset, DirectSound subset · ≈3.2k LOC

• 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 applications.

• Used together with Free API for selected legacy DirectX 3 / WinAPI compatibility work.
• Designed for legacy graphics behavior reproduction without original SDK dependencies.

Free API

WinAPI-style compatibility layer implemented in C++

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

• 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 application compatibility.

• Works together with Free Direct as the system/platform side of legacy application compatibility.
• Covers windowing, input, timers, message loop behavior, and selected multimedia APIs.

Free Eggbert

Reverse-engineered reconstruction of Speedy Eggbert 2, made portable via SDL3

GitHub: github.com/openeggbert/free-eggbert · Website: freeeggbert.openeggbert.com · Stack: C++, Free API, Free Direct, SDL3, Emscripten · ≈28.1k LOC

• Game-preservation project: buildable reconstruction of the 1998–2001 game Speedy Eggbert 2, reverse-engineered from original binaries (Ghidra, IDA, ILSpy) and cross-referenced against the official Planet Blupi sources.
• Runs on Free API + Free Direct instead of Windows/DirectX 3 — portable to Linux, the web, and beyond.
• Emscripten web build with IndexedDB save persistence.

Status: Work in progress — partially playable.

Mobile Eggbert

C++ port of Speedy Blupi (2013 Windows Phone XNA game) running on CNA

GitHub: github.com/openeggbert/mobile-eggbert · Website: mobileeggbert.openeggbert.com · Stack: C++, CNA, SDL3, Emscripten · ≈20.5k LOC

• Migration chain: original C# XNA 4.0 → ILSpy decompilation → MonoGame → native C++ on CNA.
• Playable on desktop and in the browser; web build persists saves via IndexedDB.
• The canonical playable C++ version and reference implementation for Galaxy Eggbert.

Galaxy Eggbert

3D remake of Speedy Blupi built on the CNA engine stack

GitHub: github.com/openeggbert/galaxy-eggbert · Website: galaxyeggbert.openeggbert.com · Stack: C++23, CNA, SDL3, easy-gl, bgfx · Targets: Linux, Windows, WebAssembly, Android · ≈5.4k LOC

• 3D game built on the full CNA stack — validates the framework as a real cross-platform game runtime.
• Targets Linux, Windows, WebAssembly, and Android from a single C++ codebase; multiple rendering backends: SDL_RENDERER, easy-gl, bgfx.
• Custom world format and game content pipeline.

easy-gl

Toolkit-independent C++20 OpenGL/OpenGL ES wrapper used by CNA as graphics backend

GitHub: github.com/openeggbert/easy-gl · Website: easygl.openeggbert.com · Stack: C++20, OpenGL/OpenGL ES, CMake · No windowing lock-in; host owns GL context lifecycle · ≈3.6k LOC

• Toolkit-independent wrapper over OpenGL and OpenGL ES — no windowing or context creation in the library.
• Host application owns window, GL context, and swap; easy-gl owns all OpenGL interaction.
• Built on top of meta-gl (low-level type-safe function loader) and used by CNA as its OpenGL rendering backend.

easy-3d

Small C++23 helper library beside CNA for lightweight 3D projects

GitHub: github.com/openeggbert/easy-3d · Website: easy3d.openeggbert.com · Stack: C++23, CNA, CMake · ≈0.7k LOC

• Cameras (Camera3D, OrbitCamera, FollowCamera), texture atlas, billboard and cube batching, and debug draw.
• Deliberately a helper library beside CNA — not a game engine; no ECS, physics, or networking.
• First concrete consumer: Galaxy Eggbert.

meta-gl

Low-level, type-safe C++23 OpenGL ES 2.0+ function loader and wrapper

GitHub: github.com/openeggbert/meta-gl · Website: metagl.openeggbert.com · Stack: C++23, OpenGL ES 2.0+, CMake · Foundation layer used by easy-gl · ≈7.8k LOC

• Runtime OpenGL function loading via a host-supplied GetProcAddress callback — no windowing, no context creation.
• Type-safe enum class wrappers for all OpenGL constants (buffer targets, shader types, texture formats, etc.).
• Thin inline-style wrapper functions in the metagl namespace; foundation layer consumed by easy-gl and the broader CNA rendering stack.

Mobile Eggbert Legacy

Legacy C#/MonoGame preservation archive of Mobile Eggbert (Speedy Blupi)

GitHub: github.com/openeggbert/mobile-eggbert-legacy · Stack: C#, XNA 4.0, MonoGame, .NET

• Preserved C#/MonoGame stage of the Mobile Eggbert migration: ILSpy-decompiled Windows Phone XNA 4.0 sources.
• Related repositories merged via git subtree for historical preservation.

Mobile Eggbert LibGDX

Java/LibGDX port of Speedy Blupi (Mobile Eggbert)

GitHub: github.com/openeggbert/mobile-eggbert-libgdx · Stack: Java, LibGDX, Gradle

• Continues the port lineage (C# XNA → MonoGame → C++/CNA → Java/LibGDX) with a small XNA/.NET compatibility bridge in the core module.
• Desktop (LWJGL3), Android, and HTML targets.

Sprite Utils

Small C++23 sprite utility library and assets

GitHub: github.com/openeggbert/sprite-utils · Stack: C++23, CMake · ≈1.2k LOC

• Sprite utilities and assets (number spritesheets, web component) supporting the game projects.

YouTube Frontend

C++23 static HTML index generator for ArchiveBox video archives

GitHub: github.com/openeggbert/youtube-frontend · Website: youtube.openeggbert.com · Stack: C++23, OpenCV, FFmpeg, libcurl · ≈1.4k LOC

• Generates static HTML index pages for ArchiveBox video archives.
• Uses OpenCV, FFmpeg libraries, and libcurl.

Hive

C++ universal data server and backend platform

GitHub: github.com/robertvokac/hive · Website: hive.robertvokac.com · Stack: C++23, Crow, SQLite, nlohmann/json, GoogleTest · Frontend: Vanilla JS · ≈45.0k LOC

• Metadata-driven architecture: one model definition drives storage, auto-generated REST API (/api/v1/<model>), validation, and dynamic Vanilla JS frontend UI.
• Custom model/ORM layer with strongly-typed entities, column metadata, repository abstraction, and transactional migration integrity checks (checksums/chain hashes).
• Plugin system: plugins contribute models, migrations, validators, triggers (Before/After/InsteadOf), cron jobs, and custom SQL queries — domain behavior stays local to each plugin.
• Token-based authentication lifecycle: login, logout, refresh token, register, change password; hashed token storage with revocation and session tracking.
• Domain plugins: Slipbox (knowledge management — notes, maps, links, tags, HTML export), Repetition (spaced repetition — sessions, reviews, scheduling), Dictionary (lexicon — terms, aliases, fulltext search).
• Cron scheduler with job registry sync and persisted run history; trigger pipeline and event-driven behavior per CRUD operation.

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 · ≈3.1k LOC

• 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.

Lexicon

Desktop knowledge dictionary for structured learning and technical notes

GitHub: github.com/robertvokac/lexicon · Website: lexicon.robertvokac.com · Stack: C++23, Qt Widgets, SQLite · ≈2.8k LOC

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