Hire
Systems Rust Developers in Germany

Contributed to the development of Linux toolchains and compilers with a focus on Rust integration. Enhanced system performance by optimizing kernel interactions.

• Developed custom modules for illumos and FreeBSD
• Optimized compilers for cross-platform compatibility
• Led open-source contributions to the Linux kernel

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

Architected high-performance query engines with vectorized execution for OLAP systems. Developed database internals for optimized data retrieval using Apache Arrow. Expertise in designing vector indexes for large-scale data processing.

• Architected high-performance query engines
• Developed database internals with Apache Arrow
• Designed vector indexes for data processing

Developed compilers, debuggers, integrated development environments, and measurement software for real-time data acquisition systems. Built low-latency test-operation interfaces, real-time measurement analysis, logging tools, and gRPC bridges connecting acquisition software with Python and LabVIEW.

• Rocket-engine test instrumentation
• C# data-acquisition software
• Lean proof-assistant study
• C and C++ systems programming

Architected a high-performance distributed database system, enhancing concurrency and fault-tolerance using Rust and Erlang. Designed a novel consensus protocol to ensure data consistency across distributed nodes.

• Led migration from monolithic to microservices architecture
• Implemented custom query optimizer in Haskell
• Developed a multi-threaded storage engine in C

Built and maintained web platforms using Ruby on Rails, JavaScript, React, Node.js, and Linux-based infrastructure. Applied event-store patterns, domain-driven design, test-driven development, and continuous delivery across full-stack applications and service integrations.

• Elixir service development
• MQTT messaging systems
• Hotwire application interfaces
• Nginx and Apache operations

Built scalable backend systems using Rust and Golang for cloud-native applications. Automated CI/CD pipelines with GitHub Actions and Docker. Developed low-level system utilities for container orchestration.

• Built scalable backend systems with Rust and Golang
• Automated CI/CD with GitHub Actions
• Developed system utilities for container orchestration

Architected and deployed distributed backend systems using Go and Python to handle high-volume transaction processing. Specialized in designing SQL databases optimized for scalable and consistent data retrieval.

• Developed event-driven microservices architecture
• Integrated complex caching mechanisms with Redis
• Implemented real-time data processing pipelines

Optimized Rust microservices running on Tokio in cloud environments and built internal tooling for accessing Amazon RDS databases. Their systems background also spans embedded Linux, ROS, PostgreSQL, SQLite, and data-processing workflows.

• Ported custom big-data workflows
• Built Axum and Flask backend services
• Developed OpenCV and PyTorch processing pipelines
• Worked across C, Zig, VHDL, and Haskell

Engineered high-performance backend systems for AI-driven applications. Specialized in building scalable distributed systems and microservices with a focus on REST and WebSockets.

• Built AI-driven backend systems
• Specialized in distributed systems
• Utilized REST and WebSockets extensively

Architected cross-platform software solutions with a focus on embedded systems and performance optimization using Rust. Developed complex backend systems and integrated them with cloud services for enhanced scalability.

• Specialized in building real-time systems with C++ and Rust
• Expertise in designing microservices architectures
• Proficient in multi-language interoperability for seamless integrations

Led the development of a high-frequency trading platform using C++ and Rust, ensuring low-latency and fault-tolerant operations. Specialized in optimizing algorithmic trading strategies through efficient code and system design.

• Built microservices with Go for distributed computing
• Developed a real-time monitoring dashboard using JavaScript
• Enhanced security protocols in TypeScript for data protection

Led the development of a container orchestration platform utilizing Rust and Kubernetes, optimizing resource allocation for large-scale microservices. Spearheaded a high-frequency trading system in Go, achieving sub-millisecond latency across distributed environments.

• Implemented a custom service mesh in C++
• Architected a multi-region deployment strategy
• Developed a real-time analytics engine in Ruby

Developed complex automation systems and developer tools, enhancing productivity and code quality. Designed scalable software architectures for high-performance applications.

• Built developer tooling for large-scale applications
• Architected automation systems for CI/CD pipelines
• Enhanced system performance through optimized architecture