Projects

“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

“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

“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

“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

“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