2003-2006
TI-83+ calculators and Z80 assembly
My first introduction to programming came through the TI-83+: working within hard limits, understanding memory, and learning the low-level details of the machine itself.
Systems Software Engineer
Building software close to the machine.
I'm Casper, a systems software engineer based in Western Europe. My background runs from TI-83+ calculators and Z80 assembly through C and C++, into C#, Python, and Rust-first systems work.
By day I work on industrial software in the 3D printing space. Outside work I build systems: reverse-engineering, rendering, video game architecture, data formats, parsers, code generators, and more.
This site is meant as a technical portfolio: a concise view of the kinds of problems I solve, the domains where I developed my engineering chops, and the projects that best show how I think.
systems-overview.log
$ areas_of_interest
systems programming
game engine architecture
graphics & rendering
tooling & infrastructure
reverse engineering
developer tooling
$ languages
Rust
x86_64 SIMD
C#
Javascript
Python
C/C++
$ engineering_values
explicit systems
incremental architecture
long-term maintainability
local reasoning
Timeline
Rough milestones for the tools, languages, and kinds of systems work that shaped how I build software.
2006-2017
C/C++ development
I spent years deep in C and C++, building up the habits that still define my work: explicit control, reverse engineering, debugging close to the machine, and comfort with lower-level APIs. By 2017, that chapter had mostly closed in both personal and professional work.
2016-present
Rust becomes the main personal language
I picked up Rust not long after the 1.0 release, and by 2016 it had become the default choice for serious personal work. It was the first language in a long time that felt like it matched how I wanted to build systems software.
Most of my notable personal work since then has been in Rust: rendering libraries, video games, parsing and binary-data-format work, and reusable developer infrastructure.
2018-2023
C# in professional software development
When I moved into company work, I started on the C++ side and gradually transitioned into C#, which became my main day-job language for several years. That period was focused on industrial software and reinforced the same preference for explicit systems, just in a more application-facing environment. The C# code interfaced with C++ algorithms, and I helped build the binding layer before later moving further into the application layer.
2023-present
Python for industrial software
Work shifted from C# toward Python, which is still my main professional language today. The domain is still industrial software for 3D printing, but the day-to-day implementation is now in Python.
Ongoing
JavaScript for browser-facing products and tools
In parallel, I keep using JavaScript on and off for personal web projects, lightweight apps, dashboards, and browser-based interfaces. It has never been a professional focus, but it remains one of the most effective ways to ship supporting tools around other systems work.
Projects
I keep this list broad on purpose. Different domains forced me to learn different constraints: graphics made performance and APIs concrete, reverse engineering sharpened binary reasoning and tooling, and library work forced me to care about interface design, maintenance, and long-term clarity.
Domains of expertise
Graphics and Video Games
Rendering APIs, runtime code, math-heavy infrastructure, and cross-platform video game work.
This domain taught me graphics math, ray tracing, rendering APIs, game architecture, and how to build complex systems with real-time constraints and interactive state.
It also pushed me into cross-platform delivery across desktop, web, and mobile, along with asset packaging and archive-format design.
chipdx
A remaster of the classic video game Chip's Challenge with desktop, web, mobile, and editor workflows, built as a complete interactive game stack.
shade
A unified Rust rendering library spanning OpenGL and WebGL, with explicit control over buffers, textures, shaders, uniforms, and draw calls.
cvmath
A compact graphics-oriented math library for vectors, transforms, geometry, and ray tracing without trying to be a general-purpose numeric package.
paks
An encrypted archive format based on Quake's PAK structure, used for game-related asset packaging and distribution.
rustydialogs
A cross-platform Rust library for native dialogs and notifications, with backend-specific behavior kept visible instead of hidden behind vague abstractions.
Rust Libraries
Reusable crates and developer-facing building blocks across parsing, formatting, configuration, encoding, randomness, and low-level data handling.
cvar
A configuration system for long-lived program state, exposing properties, actions, and hierarchies through a string-driven interface.
urandom
A randomness crate focused on consumer ergonomics, explicit state, and a smaller, easier-to-follow API surface than the standard rand crate.
basenc
Base16, Base32, and Base64 encoding and decoding with a simple API, no_std support, and optional SIMD acceleration.
obfstr
Compile-time string obfuscation for Rust, including temporary deobfuscation and related helpers.
dataview
Safe transmute and byte-view primitives for POD-like data, built around explicit access to underlying byte buffers.
fmtools
Extended formatting syntax for Rust with compile-time generation, control flow, and minimal runtime overhead.
intptr
Explicitly sized and typed pointer abstractions for memory outside the current address space, especially other processes.
format_xml
Xml-like compile-time templating for Rust with inline expressions, escaping rules, and control flow aimed at generating structured markup directly.
named_constants
A procedural macro that rewrites enums into C-style named constant wrappers when explicit numeric control matters more than exhaustive matching.
struct_layout
A proc-macro for defining structs with explicit size, alignment, offsets, and field access rules when layout needs to be spelled out directly.
bitset-core
A straightforward BitSet API for no_std Rust, designed around primitive containers and compiler-friendly vectorization.
ini_core
A super-fast streaming INI parser for Rust with no_std support and intentionally minimal assumptions about the format.
Web Frontend
Progressive web apps, browser-facing tools, lightweight frontend workflows, and web-adjacent utilities.
I do not approach frontend as a design-system specialization. I use it as a practical surface for shipping tools, visualizing data, and giving systems work an interface people can actually operate.
Here I learned reactivity, state management, and how to build interactive user interfaces. My main tools are Vue and Alpine.
In my style I implemented my own Vue sfc parser and compiler avoiding the usual npm-heavy stack.
PocketApps
Simple mobile-friendly web apps that you can pin to your home screen and use offline, built directly with HTML, CSS, and JavaScript.
Vue-Script
A small build tool for Vue single-file components that avoids the usual npm-heavy stack and assembles templates, scripts, imports, and styles into one final HTML file.
tagsoup
A small, fast, forgiving HTML-ish parser in Rust with selector queries and recovery for messy real-world markup.
Reverse Engineering
Binary formats, process memory, instrumentation, OS-facing APIs, and low-level inspection work.
This is the most traditional-hacker part of my background: reverse engineering video games and integrating with them from the outside.
This domain taught me to read assembly, understand binary formats, work with OS APIs for process interaction, and build tools that let me inspect and manipulate complex software externally.
apexdream
An external Apex Legends reverse-engineering project. Built around prediction, configurable automation, live game-state tooling, and externally observed process state.
q3mod
An external Quake III Arena reverse-engineering project. With offset handling, runtime tooling, trainer-style features, and a browser-based control panel.
ProjectileSolverDemo
A write-up and demo for solving projectile interception against moving targets under simple ballistic physics, with SVG visualizations and implementation notes.
external
A Rust library for unsafe cross-process interaction on Windows, covering handles, virtual memory, process enumeration, and low-level OS-facing primitives.
pelite
A lightweight, memory-safe, zero-allocation library for reading and navigating PE binaries on disk or in memory.
capcom0
Rust bindings for the infamous Capcom driver, kernel-mode access from unprivileged user-mode.
pekit
A browser-based Portable Executable viewer that brings the lower-level PE parsing work into a reverse-engineering-oriented UI.
vigem-client
A pure Rust client for the ViGEmBus Windows driver, providing a safe and idiomatic API for virtual controller emulation.
aurascope
A WebApp for live HTML visualization, used as a browser-facing surface for inspecting and controlling live reverse-engineering data.
Day Job
Data pipelines, structured formats, interface generation, and software that supports manufacturing-oriented workflows.
This work is related to my day job in the 3D printing space, where I build tools for working with geometry, materials, and machine instructions.
UntitledDataFormat
UDF is a simple, self-describing structured binary file format for storing arrays and their relationships.
cradle
A code generator for C APIs described by the cradle IDL, aimed at explicit interfaces and repeatable generation across systems boundaries.
program-proxy
A thin executable proxy that forwards stdin, stdout, stderr, arguments, and environment to another program with a small config file.
Engineering Approach
Explicit Architecture
I prefer systems with visible data flow, clear ownership, and predictable behavior. I value code that can be understood and debugged locally over heavily abstracted magic.
Incremental Design
I build systems step by step. Real architecture comes from understanding pressure and constraints, not from designing every abstraction upfront.
Long-Term Maintainability
I care about leaving projects in a state that is still pleasant to work in years later. Sustainable foundations matter more than short-term velocity.
Systems & Foundations
Most of my work gravitates toward infrastructure, runtimes, rendering systems, tooling, build systems, and the technical foundations other software depends on.