Building toward AI for science

A from-scratch CUDA inference engine for the all-MiniLM-L6-v2 bi-encoder, written to actually understand what a transformer forward pass costs on a GPU. I hand-wrote the kernels (MatMul, LayerNorm, GELU, Embedding) rather than reaching for a library, and built parity tests that check each kernel's output against PyTorch.

Underneath the kernels sits a custom DeviceBuffer/Tensor runtime for memory and shape management, a CMake build, and a Python benchmark pipeline that measures the engine against torch.compile as a baseline. I worked through the full CUDA Programming Guide while building it.

A Rust reimplementation and extension of the Computational Life research - the BFF primordial-soup simulation in which random programs interact and, over time, begin to self-replicate. The question that pulls me in: how does self-replication and complexity emerge from a simple computational substrate, with no goal baked in?

This is the work that sits closest to where I want to end up. Studying emergence in artificial systems is squarely adjacent to AI for science, and rebuilding it from the paper is how I'm learning to ask the questions rigorously instead of just watching the pixels move.

A research direction I've scoped but not yet built, asking whether ontology induction can be made deterministic. The idea: train sparse autoencoders to expand a fine-tuned embedding model's representations, surface the composite features the model is actually using, and distill those features into a reproducible taxonomy, instead of relying on prompt-by-prompt LLM guesses.

It's grounded in the mechanistic interpretability literature (Elhage, Bricken, Park, Turner) and it's a proposal rather than a result so far, but the goal is concrete: a pipeline that turns learned representations into structure you can re-derive and audit. A natural extension is runtime feature steering, nudging the encoder's activations to handle categories that split, merge, or emerge at inference time, without retraining.

A Clojure dialect implemented from scratch in Rust. It compiles to native machine code through MLIR/LLVM, targets GPU kernels via a compute DSL, and offers Rust and WASM/JS interop. The shorthand I keep using: "Mojo, but Clojure."

It's the systems-and-compilers counterweight to the ML work - a way to go deep on codegen, MLIR, and GPU compute while keeping a language I enjoy thinking in.

FourthsHub is a free, ad-free web app for guitar players exploring alternative tunings - interactive scale, arpeggio, and chord visualizers built around fourths and other non-standard tunings. Built with SvelteKit and still actively maintained.

A real-time 3D guitar configurator built for Tosin Abasi of Animals as Leaders, letting users visualize and customize guitar designs in the browser. Built with Three.js and React.

A run of graphics experiments: 3D environment art in Blender (Cycles), WebGL and shader work, generative art, and a software ray tracer written from scratch in C++ - ray-plane intersection, basic materials and lighting, and Python scripts to drive animations. Where my interest in GPU programming first took root.

Grave Defender is a tower-defense / top-down-shooter hybrid built in five days for Brackeys Game Jam 2021.2 - learning Godot from scratch while handling programming, music, and design.

A podcast on programming language design, the Rust ecosystem, and systems engineering. Currently on hiatus, but it scratched the same systems-programming itch the compiler work does now.