Alexey Sudachen
Staff Systems Engineer | AI Infrastructure & Low-Level Distributed Systems
Location: Remote, Chile (CLT, UTC-4) | Email: alexey@sudachen.name
GitHub: github.com/sudachen |LinkedIn: linkedin.com/in/sudachen
Overview
Principal Systems Engineer with 10+ years of experience in hardware-software co-design, OS kernel internals, and high-throughput networking. I specialize in building the underlying data planes and infrastructure for compute-intensive workloads (Distributed AI, DePIN, Core Infrastructure). Expert in asynchronous Rust (Tokio), P2P network protocols, and kernel-level abstractions (eBPF/XDP concepts, bare-metal C/C++). I bridge the gap between heavy ML/Data architectures and physical hardware limits, taking full ownership of system architecture, performance benchmarking, and production reliability.
CORE EXPERTISE
- Systems Architecture & Memory: Async & Unsafe Rust (Tokio, FFI, Syscalls), Go (Cgo), C/C++, Memory Allocators, Zero-Allocation Pipelines, OS Internals.
- Networking & Data Planes: High-Throughput Ingestion, Custom Packet Filtering (eBPF/XDP concepts), TCP/IP L3 Tunneling, P2P Protocols, Backpressure & Ring-Buffering.
- AI Infrastructure & Data Systems: Embeddable SLM Inference Engines, Native CPython Extensions (PyO3/C-API), WASM Compute Isolation.
- Engineering Ownership & Reliability: Performance Benchmarking Harnesses, Fuzzing & Regression Testing, Continuous Integration Infrastructure, Production Operations.
SELECTED OPEN SOURCE & SYSTEMS R&D
- slm_inference_rs (
github.com/sudachen/slm_inference_rs): Lightweight, embeddable Rust inference framework for Small Language Models (GGUF format) with C/C++ backend bindings and zero-allocation weight mapping.
- xdp_rs (
github.com/sudachen/xdp_rs): High-performance Rust abstractions and bindings for Linux eBPF/XDP (eXtended Data Path) kernel packet processing.
EXPERIENCE
Staff Systems Engineer ║ Remote — 2025–2026
Full-time remote IC role focusing on core network infrastructure, cloud-managed WireGuard VPN architectures, and edge DPI traffic filtering.
- Custom L3 Tunneling: Engineered a custom TCP/IP L3 tunneling extension in Golang for an existing remote access platform, enabling secure network overlays and seamless protocol encapsulation.
- Cloud-Managed VPN Architecture: Architected a high-throughput, cloud-managed VPN infrastructure based on the WireGuard protocol utilizing Rust for core control/data logic and Kubernetes (K8s) for scalable control-plane orchestration.
- Edge DPI & Analytics: Implemented a lightweight DPI-based (Deep Packet Inspection) traffic filtering engine in Rust for resource-constrained OpenWrt routers, integrated with cloud-based analytics and management pipelines (Python/Bash).
Senior Software Engineer / Founding Engineer ║ Analog One (Remote) — 2022–2025
Architected and led the core engineering of a high-throughput, fault-tolerant distributed data ingestion engine in Rust.
- Architectural Ownership: Owned the technical roadmap and architecture from initial prototype to mainnet production, establishing core data models, network interfaces, and state-consistency guarantees.
- High-Throughput Ingestion Engine: Engineered a high-concurrency event processing system in Rust, scaling throughput to 100,000+ data-retrieval triggers/min across decentralized nodes using Tokio async, sharding, and WASM-sandboxed execution for read-only blockchain actions.
- Systems Reliability & Testing Harness: Architected an automated testing and performance-benchmarking harness in Rust, achieving 90% test coverage, isolating concurrency race conditions, and preventing performance regressions prior to production releases.
- Production Deployment: Built deterministic CI/CD pipelines and deployment workflows (Docker/AWS) ensuring 99.9% uptime and zero-downtime node upgrades.
Senior Systems Engineer (P2P/Consensus) ║ Spacemesh.io (Remote) — 2020–2022
Core developer within the consensus engineering team for a Layer-1 blockchain (go-spacemesh), specializing in P2P propagation, deterministic math, and Go/Rust VM boundaries.
- Fast Consensus & Eligibility Engine: Owned the implementation of core modules within the fast Hare consensus protocol, including dynamic participant election, role assignment, and vote aggregation per epoch.
- Deterministic Fixed-Point Math: Developed a high-performance, deterministic fixed-point math library in Go to guarantee hardware-independent reward and consensus weight calculations across heterogeneous node architectures.
- P2P Message Propagation: Optimized P2P networking layers (libp2p) for rapid transaction and consensus message propagation, reducing block propagation delays under high node concurrency.
- Go/Rust VM Integration: Managed Cgo/FFI execution boundaries between the Go node and the Rust-based Virtual Machine (SVM/Wasmer), minimizing memory allocation overhead and call latency during smart-contract execution.
- Distributed Liveness & Infrastructure: Resolved critical timing and synchronization issues within the Proof-of-Elapsed-Time (PoET) service to prevent network-wide epoch liveness stalls; maintained deterministic integration testing pipelines.
ML Systems Engineer / Data Scientist II ║ Vacasa (Hybrid) — 2018–2020
Bridged Machine Learning workflows with low-level systems engineering, building automated ETL data pipelines and optimizing Python model inference via native C++/Rust extensions.
- High-Performance ML Extensions: Built predictive models (Python, SQL) and accelerated critical execution paths by writing native C++/Rust extension modules to eliminate Python interpreter bottlenecks during real-time inference.
- Data Pipeline Infrastructure: Architected and automated high-volume ETL ingestion pipelines (Airflow, Terraform, Docker), ensuring data consistency and low-latency access for downstream ML model execution.
R&D Engineer / C++ Developer ║ Kaspersky Lab / DLP Research (Remote) — 2012–2018
Engineered pre-OS security solutions and driver architecture using EDK II / TianoCore within the UEFI environment.
- Bare-Metal Network Drivers (PCI/MAC): Ported Linux network device drivers to the UEFI environment (EDK II), interacting directly with PCI configuration space, MMIO registers, MAC/PHY layers, and DMA ring buffers for pre-boot network access.
- USB SmartCard & Token Drivers: Developed custom UEFI DXE drivers implementing USB CCID protocol parsing and APDU packet handling within the pre-boot DXE environment.
- Pre-OS Process Isolation: Created a proprietary Windows DLL abstraction loader operating directly inside the UEFI memory space, enabling secure pre-boot execution before OS kernel initialization.
- Encrypted Storage Interception: Implemented low-level interception mechanisms for encrypted GPT disk operations during the pre-boot phase.
EARLY HIGHLIGHTS & FOUNDING R&D
- MoleBox (Founder & Lead Developer): Architected a commercial Windows executable packer and runtime virtual file system (C/C++, Assembly, Win32 Internals). Enabled transparent file encryption and DLL virtualization without application modifications.
- SpriteCraft Engine (Founder and Developer): Built a 2D/3D graphics engine from scratch in C++, featuring custom memory allocators, asset pipelines, and low-level rendering optimizations.
- High-Throughput Telecom Engines: Designed and built a high-availability SMSC/USSD messaging gateway for a Tier-1 telecom provider, managing high-volume concurrent SS7/SMPP protocol traffic under strict uptime guarantees.
- Real-Time Media & Streaming: Built a 0-to-1 MVP video streaming platform (RTSP/RTP) and developed a high-concurrency VoIP media-switching engine for low-latency voice routing.
- Embedded & Driver Development: Engineered a custom kernel-mode display driver for handheld devices (WinCE/ARM), implementing hardware-level framebuffer scaling and memory-optimized graphics algorithms without 3D acceleration.