Hire Contract
Systems Rust Developers

Rewrote a production compiler targeting x86 and ARM, enabling a product launch through lower-level code-generation work. Delivered CUDA implementations achieving 10–20x speedups and applies Rust, C++, assembly, reverse engineering, and runtime development across blockchain, game-engine, and systems projects.

• LLVM compiler toolchain development
• Ghidra and IDA Pro binary analysis
• ARM and x86 assembly programming
• GPU kernel optimization with CUDA

Designed and implemented distributed systems for high-availability services using Rust and Python. Led teams in developing blockchain-based applications with a focus on smart contract security.

• Optimized SQL databases for performance and scalability
• Authored technical documentation for complex system architectures
• Contributed to open-source distributed ledger projects

Designs Rust and Python distributed services around PostgreSQL, cryptographic protocols, and auditable storage. Recent work includes a protocol workspace for verifiable inter-organisation healthcare data exchange with deterministic binary formats, explicit trust boundaries, replay protection, and crash recovery.

• Ed25519 signatures and BLAKE3 hashing
• Append-only audit trails with fail-closed authorization
• PostgreSQL query optimization and schema migrations
• Healthcare interoperability using ICD-10-SE and KVÅ

Develops crash-resilient Rust and Python services around asynchronous event streams, binary protocols, WAL-backed storage, and POSIX concurrency primitives. Combines API security engineering with property-based testing, constant-time cryptography, and distributed resilience patterns.

• BOLA and IDOR authorization boundary audits
• PostgreSQL WAL and SQLite FTS5 systems
• Circuit breakers and concurrency bulkheads
• AST-based query gating for secure APIs

Provided consulting on high-performance computing with Rust and C++. Developed custom compilers and interpreters for domain-specific languages.

• Explored functional programming with Scheme and Racket
• Optimized algorithms for computational efficiency
• Developed mathematical models in Haskell

Built an asynchronous Rust storage and streaming platform using Axum, Tokio, OpenDAL, and SeaORM, with PostgreSQL and SQLite persistence. Designed non-buffering payload delivery, transactional repository abstractions, schema migrations, and RFC-compliant parser crates for HTTP metadata.

• Background cleanup service for stored objects
• Multi-module entity relationship modeling
• Standalone RFC 6266 and 8187 parsers
• Open-source database infrastructure contributions

Works across kernel-space networking, low-latency trading infrastructure, and on-chain financial protocols, including Linux drivers, order books, and automated market makers. Builds Rust systems ranging from no_std components and C-interoperable modules to high-load Axum services.

• Implemented Solana governance using program-derived addresses
• Developed token-based voting smart contracts
• Built Rust backends with Rocket and Axum
• Integrated eBPF traffic-control instrumentation

Built a Rust complex-event-processing engine that composes reusable processing blocks into Kafka-consuming and Kafka-producing deployments. The system uses Tokio tasks, NATS stage transport, embedded Python execution, and dependency-aware input routing to reproduce production-grade stream-processing architecture.

• Implemented bidirectional PyO3 type marshalling across the FFI boundary
• Managed Python GIL boundaries for in-process block execution
• Developed Linux filesystem drivers and embedded firmware
• Built distributed event-driven backends in Scala, Java, and Go

Contributed to a multi-chain cryptocurrency bridge on the Ergo blockchain, implementing secure cross-chain asset transfers and integrations for Bitcoin Runes and Base. Designs event-sourced, domain-driven systems for real-time processing, using distributed messaging and containerized infrastructure across mission-critical environments.

• Retrieval-augmented generation systems
• Agentic workflow implementation
• NATS and RabbitMQ messaging
• Kubernetes and OpenShift operations

Developed compiler infrastructure for a zero-knowledge proof language, spanning DSL design, type systems, SSA-based intermediate representations, and optimization passes. Worked across arithmetic circuits, ACIR, R1CS, proving backends, and applied cryptography for performance-critical proof generation.

• LLVM backend and code-generation expertise
• Rust and C++ systems programming
• FIPS 140.2 cryptographic implementation context
• Blockchain protocol architecture

Develops low-level distributed and hardware-integrated systems spanning Rust, virtual machines, WebAssembly, RISC-V, and compiler engineering. Recent protocol work includes deterministic execution environments and performance improvements for weakly coherent distributed storage.

• Embedded Linux and real-time systems
• RS485 and Modbus industrial integrations
• ARM and x86 assembly
• GCC and reverse-engineering workflows

Architected scalable database systems using Rust, focusing on high availability and fault tolerance. Led the design of business applications with a strong emphasis on technical specifications.

• Developed distributed database engines from the ground up
• Designed architecture for large-scale data warehousing
• Optimized query execution plans for performance gains

Develops payment-platform services spanning fraud detection, authorization, digital wallets, and region-specific payment integrations. Delivered backend changes across North American and European payment flows while improving fraud detection by more than 200%.

• Google Pay and PayPal payment-method integration
• Company-wide authorization migration design
• Encryption and secure data-handling controls
• Multi-service API expansion for new markets

Designed a stable ABI for cross-language Rust interoperability, including an intermediate representation, generated type conversions, validity checks, opaque types, generics, custom DSTs, and runtime tagged dispatch. Added WebAssembly smart-contract execution to Hyperledger Iroha and corrected consensus, fault-handling, and peer-synchronization defects.

• Unsafe Rust and memory-layout engineering
• Procedural macro and code-generation tooling
• cbindgen associated-type resolution
• Concurrent Java ETL and stream replication