Nearly 30 years building high-throughput systems where mechanical sympathy meets product scale. Zero-trust architectures, zero silent systemic debt.
Matheus Santos
Head of Platform
I started programming out of obsessive curiosity. I wanted to dismantle things and understand how they work at the base level. Today I build at the exact intersection of low-level system mechanics, scalable architecture, and high-level product strategy.
My engineering philosophy is rooted in mechanical sympathy and semantic consistency. Over the past decade I've designed foundational platform ecosystems: from standardising Python orchestration layers to building custom zero-copy messaging kernels in Rust and C++, pushing past runtime ceilings and eliminating latency on 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 empower developers to deploy into mission-critical, ACID-compliant environments without introducing silent systemic debt.
High-throughput distributed systems, event-driven topologies (NATS/ZMQ), and microservice boundary enforcement at scale.
Deep OS-level primitives: epoll/kqueue reactors, POSIX fork safety, sync/async impedance resolution, and latency optimisation in Rust, C++, and Python.
ACID/BASE compliance, strict tenant-scoping in multi-cloud environments, and aligning deep-tech infrastructure with product monetisation goals.
Building developer culture via semantic consistency, precise taxonomies, and ADR-driven decision-making. Bridging business vision to bare-metal precision.
A Python-based modular framework for building scalable, event-driven platform ecosystems. Designed around semantic consistency and strict boundary enforcement.
A high-performance, Rust-native ZeroMQ-compatible messaging runtime built on io_uring. Designed to outperform libzmq while preserving Rust's memory safety guarantees. Zero-copy message handling, syscall-minimal IO, and runtime-agnostic architecture.
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.
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.
Contributor to this C++ framework for distributed systems. High-performance, low-latency primitives for systems that can't afford the overhead of conventional approaches.
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.
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.
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.
Available for consulting on distributed systems architecture, platform strategy, and engineering leadership.