Software Engineer · Cloud & Web · Runtime & Compiler Engineering · Embedded Systems

I build software across the stack — from cloud platforms and web applications to virtual machines, compilers, embedded systems and connected hardware.

Website · ERD-TSVM Playground · Engineering Journal

I'm a software engineer from Belgium with a strong interest in understanding and building systems from the ground up.

My work spans high-level web and cloud applications, SaaS platforms and frontend development, all the way down to runtime architecture, compiler design, virtual machines, embedded systems and hardware integration.

I enjoy building complete systems rather than isolated pieces: designing the architecture, implementing the low-level foundations, creating the developer tooling around them, and making the result approachable enough for others to build upon.

Some of the areas I work in:

• Cloud-native web applications and SaaS platforms
• Runtime & virtual machine architecture
• Compiler engineering
• Embedded systems and microcontrollers
• TypeScript / JavaScript language tooling
• C++ systems programming
• Delphi / Object Pascal
• Developer tooling and IDEs
• Industrial IoT and automation
• Hardware/software integration
• Networking and connected devices

One of my largest ongoing projects is ERD-TSVM, a complete TypeScript execution platform consisting of an AOT compiler, bytecode format, virtual machine, runtime, debugger and development toolchain.

The goal is to make it possible to write modern TypeScript and execute the same application architecture across constrained embedded devices, desktop systems, servers and WebAssembly.

TypeScript → Lexer/Parser → Analysis → Type Checking → Optimizer → Code Generator → Bytecode → ERD-TSVM
                                                                                              ├─ ESP32 / FreeRTOS
                                                                                              ├─ Linux / Server
                                                                                              ├─ macOS / Windows
                                                                                              └─ WebAssembly

• Modern TypeScript / ECMAScript support
• Self-hosted AOT compiler
• Hybrid register/stack bytecode VM
• Generational moving garbage collector
• Hidden classes and inline caches
• Multi-pass optimizer
• DAP-compatible and native debugger
• ESP32, desktop, server and WebAssembly targets

ERD-TSVM is not open source yet. The project is currently being developed towards its first public release, with the intention of open-sourcing the platform in 2027.

In the meantime, architecture documentation, technical articles, platform information and a working browser playground are already publicly available.

👉 Explore ERD-TSVM 👉 Technical architecture 👉 Try the ERD-TSVM Playground 👉 Read the engineering journal

I maintain several open-source Delphi projects covering automotive diagnostics, hardware integration, custom VCL components and connected devices.

Some of them are pinned below, including Delphi-OBD, HID Macro Keyboard, Delphi Inspector and Philips Hue.

👉 Browse all repositories

I don't really define my work by a fixed technology stack — the technology depends on what layer of the system I'm working on.

Languages

C++ · TypeScript · JavaScript · Delphi / Object Pascal · C · WebAssembly · PHP · Python

Web & Cloud

SaaS · Web Applications · REST APIs · HTTP · WebSockets · Docker · Cloud Infrastructure · MongoDB · Authentication · Multi-tenant Applications

Runtime & Compiler

VM Architecture · Bytecode · AOT Compilation · Garbage Collection · Language Semantics · Optimization

Embedded

ESP32 · ESP-IDF · FreeRTOS · GPIO · I²C · SPI · UART · BLE · WiFi

Application Development

Node.js · TypeScript · React · Vue · Meteor · VCL · Native Desktop

Systems & Tooling

CMake · DAP · VS Code · Docker · Linux · macOS · Windows

I'm particularly interested in the boundary between high-level developer experience and low-level system design.

A lot of my work revolves around one question:

How much low-level complexity can we hide without giving up control, determinism or performance?

That applies equally to a TypeScript VM running on a microcontroller, a compiler toolchain, an embedded hardware API or a Delphi component.

I like systems where developers can start at a high level, but where every layer underneath remains understandable and accessible.

ERDesigns is where I publish my larger engineering projects, experiments and technical documentation.

The main focus is currently on embedded runtimes, compiler engineering, developer tooling and industrial IoT.

🌍 https://erdesigns.be

There you'll find:

• ERD-TSVM architecture and documentation
• The online TypeScript playground
• Embedded projects
• Technical articles
• Runtime and compiler development updates
• Industrial IoT projects
• Downloads and tooling

From idea to impact.

erdesigns.be