// Freelance Rust & C Systems Engineer

I solve the problems
your team won't touch.

No garbage collector. No runtime. No abstraction tax.
I write production Rust and C23 for companies that need bare-metal performance, post-quantum security, and zero excuses. Fixed-fee. Full ownership. Build and ship.

Start a Project See What I've Built

// why void*

Why hire a Rust & C engineer?

Because some problems don't get solved by adding another abstraction layer.

*ptr

No GC. No Pauses. No Surprises.

Rust gives you memory safety without a garbage collector. Your service doesn't pause at 3AM because the GC decided now was a good time. Latency is deterministic.

unsafe {}

When You Need to Go Lower

C23 for kernel interfaces, FFI boundaries, embedded targets, and CUDA kernel pipelines. I know when to reach for it and — more importantly — when not to.

Security at the Type Level

Post-quantum cryptography (ML-KEM, ML-DSA — NIST FIPS 203/204), AES-256-GCM, ML-DSA signed audit chains. Baked into the type system, not bolted on after the fact.

→ done

Fixed-Fee. Full Ownership.

Every engagement is scoped, priced flat, and delivered complete. No hourly billing, no retainers, no scope creep negotiations. I own the outcome.

⚡ CUDA

GPU-Accelerated Pipelines

ONNX Runtime with CUDA execution provider. Embedding inference at A100 throughput. If your pipeline needs a GPU, I know how to feed it without wasting cycles.

∅ deps

Minimal Dependency Surface

I don't reach for a crate when I can write a tight implementation. Small binaries, auditable dependencies, zero mystery frameworks. You can read every line.

// What "no abstraction tax" looks like in practice
pub async fn query(&self, req: QueryRequest) -> Result<QueryResponse> {
    let embedding = self.embed_cuda(&req.query).await?;   // CUDA EP, zero copy
    let shards   = self.vault.search_hnsw(&embedding, TOP_K)?;  // encrypted at rest
    let context  = decrypt_and_rerank(shards, &req.query)?;   // plaintext only in memory
    self.llm.generate(context).await                        // local inference, no API
}
// 1.7s end-to-end. A100 80GB SXM. 150-document legal corpus. Zero external calls.
  

// what I build

Systems that don't apologize for existing.

Bring me a hard problem. I'll scope it, price it flat, and ship it.

PRIVATE AI INFRASTRUCTURE

Air-gapped RAG pipelines for regulated industries. Your data never leaves your infrastructure.

Hybrid vector search (HNSW + BM25)
ONNX CUDA embedding inference
PQC vault encryption (ML-KEM-768)
ML-DSA signed audit chain
Leptos WASM frontend

SYSTEMS & ORCHESTRATION

Masterless distributed systems, mesh protocols, and orchestration that doesn't require a platform team to operate.

Masterless UDP mesh (no leader election)
PQC authenticated command propagation
HTTP/2 ingress with TLS termination
cgroups v2 resource enforcement
5 MB binary. No dependencies.

PERFORMANCE ENGINEERING

When your team says "we need to scale the cluster," I ask if we need the cluster at all.

DuckDB single-node analytics (172M rows/sec)
Spark → DuckDB migration with benchmarks
CUDA kernel optimization
Columnar pipeline design
Signed, auditable deliverables

SECURITY ENGINEERING

Post-quantum cryptography, zero-trust architecture, and HIPAA/HITRUST compliance — implemented in the type system, not in comments.

ML-KEM-768 key encapsulation
AES-256-GCM shard encryption
HITRUST audit remediation
Zero-trust AI architecture
Attorney-client privilege data flows

// how I work

Simple. Fast. Done.

No retainers. No status meetings. No surprise invoices.

You describe the problem

One email. Tell me what's broken, what's slow, or what needs to exist. I'll ask the right follow-up questions.

I scope and price it flat

You get a fixed price and a delivery date. Not an estimate. Not a range. A number. If scope changes, we renegotiate — I don't silently run the meter.

I build it

Full ownership. Every line of code. Rust where performance and safety matter. C23 where the metal demands it. No framework cargo-culting.

You own it completely

Full source, documentation, and transfer. No lock-in, no "maintenance contract required to understand the code." You walk away with a system you own.

I solve the problemsyour team won't touch.