• I take ownership in new projects and in existing ones. At Miden I wrote the first frontend of the compiler, and started the SDK, the test infrastructure and the release process. At Ergo I first worked on the existing Scala interpreter and node, and then started the Rust implementation.
• I treat the developer experience as part of the product. I supported outside developers from the bug report to the released fix.
• I lead technical work. I led a change across 4 codebases owned by different teams, interviewed candidates, mentored new team members, ran 2 contributor bounty programs and grew a contributor into a co-maintainer.
• I measure the results. The execution cost of compiled programs went down by up to 48% and the compiled contract size by 60%.
• I own what I run in production. I built a service, ran it with outside operators, built its observability (health checks, metrics and dashboards) and was on call for it.
• I work with AI coding agents every day. I also built an agentic fuzzer where AI agents search for compiler bugs, and prototyped an eval harness for AI agent skills.

Miden · 2023 to Present

I'm one of the two core engineers who built the Rust compiler for the Miden VM, a zero-knowledge (ZK) virtual machine. The VM is a stack machine. It has no registers, no jumps and no byte-addressable memory, and it computes on field elements instead of machine integers. The standard Rust toolchain takes us only to WebAssembly. Everything after that is our own code: an IR modeled after LLVM's MLIR, the transformation and optimization passes, and the code generator. I joined in its first months. About half of it is my work, and I work on all of its parts. I designed and own the WebAssembly frontend and the Rust SDK, along with everything else outside developers touch (the build tooling and the releases). Today I do this work by orchestrating AI coding agents.

• Profiled compiled Rust on the VM and reworked code generation based on the profiles. The execution cost went down by up to 48%. Cut compiled contract size by 60%.
• Fixed miscompilations reported from real user programs in the IR, optimization passes and code generation. Made the compiler output deterministic.
• Designed and built an agentic differential fuzzer. AI agents search for compiler bugs by checking compiled programs against native Rust, with compiler code coverage as feedback. It finds most compiler bugs before users do.
• Shaped the AI agent skills that teach coding agents to write programs for the platform. Prototyped an eval harness to score them.
• Designed and built a sandboxed WebAssembly runtime for running untrusted extension code inside the VM.
• Created a code coverage tool for Miden Assembly (line, function and branch coverage collected from VM execution).
• Led changes across 4 codebases owned by different teams, from proof of concept to rollout.
• Reviewed design and code across the team, interviewed candidates and mentored 2 new team members.
• Contributed upstream to the WebAssembly ecosystem.

3 years, first at Polygon and then at Miden after the spin-out. All of it is open source: 0xMiden/compiler

Ergo Platform · 2018 to 2023

I was a core developer of Ergo, an open-source smart contract platform for financial applications, built on zero-knowledge proofs. I created and led sigma-rust. It's the Rust implementation of the contract interpreter, cryptographic protocols, transaction building and signing, and wallets are built on it. Before that I worked in Scala on the reference interpreter and the node.

• Led sigma-rust for more than 3 years. I did the roadmap and the design decisions, and reviewed pull requests from 24 outside contributors.
• Architected sigma-rust as one Rust core shipped to 3 platforms through WebAssembly/JavaScript, C/Swift (iOS) and JNI (Android) bindings. The Yoroi and Nautilus wallets use it.
• Initiated and ran 2 contributor bounty programs. I wrote 92 issues as self-contained specs and reviewed the work. Grew one contributor into a co-maintainer.
• Led the new oracle application that posts price data on chain. It was built from the ground up: on-chain contracts, an off-chain application and a public mainnet run with outside operators.
• Built that application to run unattended as a service. It keeps running when its dependencies fail. It has log rotation, config migration, secrets kept out of config files, health endpoints, Prometheus metrics and a Grafana dashboard.
• Ran the oracle pools myself and was on call for them. I diagnosed outages down to the node and the contracts, and turned operator reports into fixes and releases.
• Worked on the consensus-critical parts of the Scala interpreter: the binary serialization format, hardening the deserializer against malicious input, and the cost accounting that bounds script execution.

All open source: ergoplatform/sigma-rust