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 explicit systems: reverse-engineering tools, rendering libraries, data formats, code generators, and low-level Windows-facing utilities.
This site is meant as a technical profile: a concise view of the kinds of problems I choose, the domains where I developed my engineering instincts, and the projects that best show how I think.
Rough milestones for the tools, languages, and kinds of systems work that shaped how I build software.
My first serious systems-adjacent programming came from calculator projects: working within hard limits, understanding memory, and learning to care about how the machine actually behaves.
I spent these years deep in C and C++, building up the habits that still define my work: explicit control, data-oriented thinking, debugging close to the runtime, and comfort with lower-level APIs. By 2017, that chapter had mostly closed out in both personal and professional work.
When I moved into company work, C# became the 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.
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.
Around three years ago, work shifted from C# toward Python, which is still my main professional language today. I mostly use it in practical production settings rather than as a personal-language focus.
Most of my notable personal work since then has been Rust: rendering libraries, reverse-engineering tools, binary/data-format work, Windows-facing utilities, and reusable developer infrastructure.
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.
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.
This domain taught me to work under performance pressure, keep abstractions honest, and build APIs that stay explicit even when the underlying platform details are messy.
A remaster of Chip's Challenge with desktop, web, mobile, and editor workflows, built as a complete interactive game stack.
A unified Rust rendering library spanning OpenGL and WebGL, with explicit control over buffers, textures, shaders, uniforms, and draw calls.
A compact graphics-oriented math library for vectors, transforms, geometry, and ray tracing without trying to be a general-purpose numeric package.
An encrypted archive format based on Quake's PAK structure, used for game-related asset packaging and distribution.
A pure Rust client for the ViGEmBus Windows driver, providing a safe and idiomatic API for virtual controller emulation.
A cross-platform Rust library for native dialogs and notifications, with backend-specific behavior kept visible instead of hidden behind vague abstractions.
This is the most traditional-hacker part of my background: understanding how software actually behaves, recovering structure from opaque systems, and building tools to interact with them.
A large reverse-engineering-heavy Apex Legends instrumentation project in Rust, built around sampled prediction, configurable automation, live game-state tooling, and externally observed process state.
An external Quake III Arena reverse-engineering project with offset handling, runtime tooling, trainer-style features, and a browser-based control panel.
A write-up and demo for solving projectile interception against moving targets under simple ballistic physics, with SVG visualizations and implementation notes.
A Rust library for unsafe cross-process interaction on Windows, covering handles, virtual memory, process enumeration, and low-level OS-facing primitives.
A lightweight, memory-safe, zero-allocation library for reading and navigating PE binaries on disk or in memory.
Safe transmute and byte-view primitives for POD-like data, built around explicit access to underlying byte buffers.
Explicitly sized and typed pointer abstractions for memory outside the current address space, especially other processes.
Compile-time string obfuscation for Rust, including temporary deobfuscation and related helpers.
Rust bindings for the infamous Capcom driver, kernel-mode access from unprivileged user-mode.
A browser-based Portable Executable viewer that brings the lower-level PE parsing work into a reverse-engineering-oriented UI.
A WebApp for live HTML visualization, used as a browser-facing surface for inspecting and controlling live reverse-engineering data.
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.
Simple mobile-friendly web apps that you can pin to your home screen and use offline, built directly with HTML, CSS, and JavaScript.
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.
A small, fast, forgiving HTML-ish parser in Rust with selector queries and recovery for messy real-world markup.
Xml-like compile-time templating for Rust with inline expressions, escaping rules, and control flow aimed at generating structured markup directly.
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.
UDF is a simple, self-describing structured binary file format for storing arrays and their relationships.
A code generator for C APIs described by the cradle IDL, aimed at explicit interfaces and repeatable generation across systems boundaries.
A thin executable proxy that forwards stdin, stdout, stderr, arguments, and environment to another program with a small config file.
A straightforward BitSet API for no_std Rust, designed around primitive containers and compiler-friendly vectorization.
A super-fast streaming INI parser for Rust with no_std support and intentionally minimal assumptions about the format.
A configuration system for long-lived program state, exposing properties, actions, and hierarchies through a string-driven interface.
Extended formatting syntax for Rust with compile-time generation, control flow, and minimal runtime overhead.
A procedural macro that rewrites enums into C-style named constant wrappers when explicit numeric control matters more than exhaustive matching.
A randomness crate focused on consumer ergonomics, explicit state, and a smaller, easier-to-follow API surface than the usual alternatives.
Base16, Base32, and Base64 encoding and decoding with a simple API, no_std support, and optional SIMD acceleration.
A proc-macro for defining structs with explicit size, alignment, offsets, and field access rules when layout needs to be spelled out directly.
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.
I build systems step by step. Real architecture comes from understanding pressure and constraints, not from designing every abstraction upfront.
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.
Most of my work gravitates toward infrastructure, runtimes, rendering systems, tooling, build systems, and the technical foundations other software depends on.