Principal Systems Architect & Head of Platform

Engineering at the
intersection of
bare-metal and strategy

Nearly 30 years building high-throughput distributed systems in Rust, C++, and Python. Zero-trust security, every change gated through CI and design review.

Explore Expertise Open Source ↗
Background
Matheus Santos

Matheus Santos

Head of Platform

Started at 14.
Still dismantling things.

I started programming out of obsessive curiosity. I wanted to dismantle things and understand how they work at the base level. Today I work across low-level systems and product decisions, from bare-metal I/O to platform architecture.

I optimize for how the machine actually executes and keep structure consistent so systems stay legible. Over the past decade I've standardised Python orchestration layers, built zero-copy messaging kernels in Rust and C++, and removed latency from the critical path.

I don't rely on default abstractions. I enforce execution isolation and backward planning, creating frameworks and strict CI/CD governance that let developers deploy into mission-critical, ACID-compliant environments without accumulating silent technical debt.

Core Competencies

What I build.
How I think.

Systems architecture

High-throughput distributed systems, event-driven topologies (NATS/ZMQ), and microservice boundary enforcement at scale.

Concurrency & performance

Deep OS-level primitives: epoll/kqueue reactors, POSIX fork safety, sync/async impedance resolution, and latency optimisation in Rust, C++, and Python.

Data integrity & strategy

ACID/BASE compliance, strict tenant-scoping in multi-cloud environments, and aligning deep-tech infrastructure with product monetisation goals.

Engineering leadership

Building developer culture through consistent naming, precise taxonomies, and ADR-driven decision-making. Bridging business vision to bare-metal execution.

Technical Expertise

Languages and tools.

Languages
Rust C++ C Python Go Java Kotlin Lisp JavaScript Bash
Message Brokers
NATS ZeroMQ RabbitMQ (AMQP/MQTT) ActiveMQ SQS (AWS)
Databases
PostgreSQL MongoDB MySQL
Frameworks
Envoxy (Python) Flask (Python) Django (Python) FastAPI (Python) Actix-web (Rust) Zapata (C++) Echo (Go) Spring (Java) EJB (Java) JPA (Java)
Open Source

Code I've
put into the world.

Envoxy Platform Framework

A Python-based modular framework for building scalable, event-driven platform ecosystems. Built around semantic consistency and strict boundary enforcement.

Python github.com/habitio/envoxy
↗

Monocoque

A Rust-native messaging runtime that speaks ZeroMQ's wire protocol, ZMTP 3.1, implemented from scratch with no FFI boundary. All 11 socket types, CURVE and PLAIN authentication, TCP and IPC transports, and reconnection and heartbeating on every socket. io_uring by default through compio, with tokio and smol selectable at compile time over the same protocol layer and buffer model. Zero-copy fan-out via refcounted buffers, allocation-free receive, and vectored writes that keep large frame bodies out of userspace.

Rust io_uring ZMTP 3.1 github.com/vorjdux/monocoque
↗

ZMQ Arena

A benchmark harness for ZMTP that measures twenty-one series across eight engines and seven languages under the same conditions. Every target is built inside a pinned image and then run outside any container: the orchestrator chroots into the exported filesystem, so the process it measures is the target itself, in a cgroup v2 leaf with a declared cpuset and a per-run network namespace. Each cell reports throughput, latency quantiles, CPU seconds split across both ends, peak RSS, and syscall counts from perf tracepoints scoped to that cgroup. The host is sampled rather than declared, so a run without bare metal, the performance governor, turbo off and root publishes itself as not admissible with the reasons attached. Results live only in the public dashboard.

Rust Python cgroup v2 perf github.com/vorjdux/zmq-arena
↗

Dux

A statically-typed compiled language with Python-like syntax and an LLVM backend. Ref-counted strings, hybrid inline/heap allocation, and a clean type system. Built from scratch to understand language design at the metal level.

C++ C LLVM github.com/vorjdux/dux-lang
↗

Wire Probe

A lightweight TCP telemetry agent that measures Layer 4 handshake latency with no external dependencies. Server mode uses io_uring to handle connections at ~500 KB RSS; probe mode exports RTT metrics to Telegraf or Collectd. Ships as a 370 KB statically-linked binary.

Rust github.com/vorjdux/wire-probe
↗

txc

Offline text utilities for the terminal: 143 operations across encoding, hashing, case conversion, and generators. Everything the online text tool sites do, done locally, with no network call and nothing to paste into a web form. Usable as an argument, over a pipe, or from a full-screen interactive interface.

Rust CLI github.com/vorjdux/txc
↗

Zapata

Contributor to this C++ framework for distributed systems. High-performance, low-latency primitives for systems that can't absorb the overhead of conventional approaches.

C++ github.com/naazgull/zapata
↗
Writing

Things I've
figured out the hard way.

2026-08 Benchmarking Systems Rust

Judge and Contestant: Benchmarking a Library You Wrote

I wrote Monocoque, one of the libraries in this benchmark. That is exactly why I built ZMQ Arena. Twenty-one ZMTP series across eight engines and seven languages, each target its own program on its own toolchain, every cell pinned to its own cgroup, and a host profile the harness measures rather than a claim I get to make.

Read →
2026-06 Rust Systems Networking

Safe Rust, Corrupt Wire

Rust gives you memory safety by construction and stops there. Building Monocoque, a pure-Rust ZeroMQ runtime over io_uring, made that boundary concrete: async cancellation is Drop, which cleans up your buffers and leaves your peer mid-parse. The fix has to be structural for the same reason the memory fix was.

Read →
2026-06 Rust OS Systems

Hardware Is Asynchronous. Most of Our Operating Systems Still Aren't.

A thread about wire-probe turned into a long back-and-forth with someone building a from-scratch OS in Rust. One idea came out of it that I haven't been able to put down: the dominant POSIX model is a synchronous fiction layered over fundamentally asynchronous hardware, and we have spent thirty years bolting async back on rather than starting from it.

Read →
2026-06 Networking Azure Rust

The ICMP Illusion: Bypassing Cloud SDN to Measure True L4 Latency

If you run stateful workloads on Azure, your ICMP telemetry may be lying to you. Under compute load, ICMP rides the contended software path while TCP's accelerated-networking datapath is unaffected, manufacturing a network bottleneck that doesn't exist at L4 or L7. How we diagnosed a persistent 4-6 ms latency floor and built wire-probe to stop trusting ping.

Read →
Contact

Let's build
something precise.

Available for consulting on distributed systems architecture, platform strategy, and engineering leadership.

⌥
GitHub
◈
LinkedIn
✉
Email