I build the layers beneath the tools.
Languages, compilers, an engine, an init system — built from scratch to understand the layer below.
The descent
Five projects, each one level lower than the last — from the editor you type in down to the first process the kernel starts.
JulIde
An IDE for the Julia programming language
“When Juno was deprecated, Julia didn’t have a fully-featured IDE anymore. I wanted to build one that treated the language as a first-class experience.”
A full-featured Julia IDE built with Tauri, React, and Rust, including deep language integration and extensibility.
- Monaco-based editor with Julia-specific tooling
- LSP-powered intelligence (LanguageServer.jl)
- Integrated REPL, debugger, and Git support
- Plugin system with customizable themes
Open-Reality
A Julia framework for building interactive 3D experiences
“Most game engines are built editor-first, with code treated as a secondary interface. I wanted the opposite—an engine designed for programmers, where code is the primary way you interact with the system.”
A declarative, code-first game engine written in Julia, with physically-based rendering, ECS architecture, and multi-backend support (OpenGL, Vulkan, WebGPU).
- Predictable ECS with O(1) operations
- Rendering pipeline designed to be reasoned about—not hidden
- Multi-backend graphics support
- Physics, animation, audio, and particle systems
WSharp
A statically typed, compiled programming language built on LLVM 18
“I wanted a language with the flexibility and expressiveness of Julia—but statically typed, more predictable, and designed from the ground up for backend development.”
W# is a statically typed language implemented in Rust, featuring Hindley–Milner type inference, multiple dispatch, and a dual LLVM-based JIT/AOT compiler.
- HTTP status-aware multiple dispatch for web backends
- Powerful type inference with minimal annotations
- JIT + AOT compilation via LLVM
- Async/await with compiler-generated coroutines
SQL++
A library for faster and safer SQL
“I was curious what lies beneath SQL—and why most tools stop there. I wanted to explore what happens when you go lower and push that control back into the type system.”
A compile-time type-safe SQL library for Rust that compiles directly to PostgreSQL’s wire protocol.
- Compile-time query validation and type safety
- Zero runtime overhead (queries compiled at build time)
- Direct use of PostgreSQL protocol
- SQL injection impossible by design
dynamod
A Linux init system built from scratch with Erlang/OTP-inspired supervisor trees
“I wanted a modern init system without systemd’s complexity—something lightweight, predictable, and still usable on a desktop system.”
A Linux init system combining a minimal Zig-based PID 1 with a Rust service manager inspired by Erlang/OTP supervision trees.
- Supervision tree model for services
- Dependency-aware parallel startup
- cgroups v2 resource control
- Desktop-compatible D-Bus interfaces
Profile
Who's drawing this.
I build developer tools and the systems under them — a full IDE for Julia, a code-first game engine, a statically typed language on LLVM, a type-safe SQL layer that speaks Postgres’ wire protocol, and a Linux init system with a Zig PID 1. All of it open source, all MIT.
The through-line is going one level lower. When a tool stops where I want to keep reasoning, I build the layer beneath it — because the fastest way to understand a system is to implement it.
I work top to bottom: React and TypeScript at the surface, Rust and Zig underneath. I care about clean architecture, honest APIs, and pipelines you can reason about instead of guess at.
Toolset
What I reach for, grouped by role — a legend for the drawings above.
Get in touch
Building something that needs a layer underneath it? Let's talk.
I take on freelance work across the stack — from language and compiler internals to the interfaces on top of them. Send a note below, or find the source for everything here on GitHub.
github.com/sinisterMage