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, Nova3D, sharp-runtime, Dear ImGui · Native .mc3.xml format compiled to glTF/GLB

• 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 + Nova3D + sharp-runtime; exercises the full C++ engine stack as a real editor application.

Status: Early prototype — project structure, core class skeletons, and MC3 library in place.

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

• 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

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

Nova3D

3D engine — Urho3D source base with CNA replacing native graphics backends

GitHub: github.com/openeggbert/nova-3d · Website: libnova3d.com · nova3d.openeggbert.com · Stack: C++20/23, CNA, SDL3, OpenGL/easy-gl, Urho3D scene/resource/math

• Modified Urho3D engine: reuses Urho3D source (math, containers, scene graph, resource system) and replaces its native OpenGL/Direct3D backends with CNA.
• Public API is namespace Urho3D — game code written against Urho3D compiles against Nova3D with minimal changes.
• Architecture: Game code → Nova3D public API → scene/renderer → CNA (SDL3 / OpenGL / OpenGL ES).

simple-3d

Clean, minimalistic 3D/2D game framework for C++ and Lua built on top of Nova3D

GitHub: github.com/openeggbert/simple-3d · Website: libsimple3d.com · simple3d.openeggbert.com · Stack: C++20/23, Lua, Nova3D, CNA, SDL3, OpenGL/Vulkan/bgfx

• Thin, high-level wrapper over a Nova3D / Urho3D fork — exposes nothing from Urho3D in its public API except math primitives as Simple3D:: type aliases.
• Supports both C++ and Lua game code; architecture: Game → simple-3d API → Urho3D fork → CNA/Nova3D → Vulkan/GLES/bgfx → SDL3.
• Designed for clean, ergonomic game development on top of the full CNA + Nova3D stack.

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

• 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

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

Hive (archived)

Archived architecture showcase

~44k LOC C++ universal data server and backend platform

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

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

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

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

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

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

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

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

• 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, Nova3D, Mesh Craft, and Galaxy Eggbert; not a CLR — a practical native subset designed for real cross-platform use.

Galaxy Eggbert

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

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

• 3D game built on the full CNA + Nova3D 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.

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.

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.