Hire Contract
Rust Developers in Netherlands

Engineered blockchain solutions on Solana with Rust for decentralized applications. Developed iOS applications using Swift and Objective-C, integrating Parse Platform for backend services. Specialized in smart contract development and optimization.

• Built blockchain solutions on Solana
• Developed iOS apps with Swift
• Smart contract development expertise

Led development of Wasm modules in Rust for blockchain platforms, with a focus on smart contract execution.

• Built Solidity-based applications for decentralized finance
• Implemented TypeScript front-ends for blockchain interfaces
• Optimized Angular applications for cross-chain compatibility

Developed real-time communication systems with Rust, specializing in TCP/UDP protocols and WebRTC for low-latency streaming. Focused on asynchronous networking techniques.

• Built real-time communication systems
• Specialized in TCP/UDP and WebRTC
• Expertise in asynchronous networking

Provided consulting on high-performance computing with Rust and C++. Developed custom compilers and interpreters for domain-specific languages.

• Explored functional programming with Scheme and Racket
• Optimized algorithms for computational efficiency
• Developed mathematical models in Haskell

Designed Rust execution and storage infrastructure for distributed ledgers, including a payment engine benchmarked at multi-million transactions per second and replay protection using per-account nonces and intent deduplication. Built full-node storage integration, chain reorganization handling, and zero-knowledge-compatible data-availability verification, raising production throughput to 5,000 TPS.

• Consensus fork selection and state finalization
• Celestia data publishing integration
• Prover and verifier storage coordination
• Production observability infrastructure

Engineered backend systems using Scala and Rust, focusing on high-availability and real-time data processing. Developed scalable microservices with TypeScript and Spring Boot for enterprise solutions.

• Implemented Kotlin for reactive programming
• Optimized Java applications for distributed systems
• Developed REST APIs for seamless integration

Developed complex frontend applications with TypeScript and JavaScript, integrating Rust for performance-critical components. Enhanced user interfaces using F# and C#.

• Implemented responsive designs with Ruby
• Built interactive web elements in Rust
• Optimized client-side performance

Architected distributed systems leveraging Kafka and ClickHouse for real-time data processing. Developed scalable backend solutions in Rust and Scala.

• Architected real-time distributed systems
• Leveraged Kafka and ClickHouse
• Developed backend in Rust and Scala

Refactored embedded GNSS software from Python to Rust around a hardware-abstraction microservice and ZeroMQ broker. Built a single-threaded Tokio data path for Bluetooth, Radino, and CAN interfaces, using exclusive handle ownership and latest-wins channels to control latency and staleness.

• Yocto-based embedded OS deployment automation
• Trait-based correction-feed and output-sink contracts
• ZMQ Pub/Sub and Push/Pull abstractions
• Independent GNSS read and correction-write tasks

Designs distributed event-streaming and data-platform systems for payments and personalized media, including Kafka and ClickHouse pipelines processing billions of records. Production work spans Scala, Java, Kotlin, and Rust services with migrations across messaging, storage, and service architectures.

• Implemented event-sourced and CQRS service architectures
• Used Kafka, gRPC, and Protobuf for interservice transport
• Deployed workloads through Kubernetes and Argo CD
• Instrumented systems with Prometheus, Grafana, and Jaeger

Pioneered compiler engineering projects with a focus on performance tuning and optimization. Led teams to develop high-performance systems programming solutions in Rust and C++.

• Engineered custom performance analysis tools
• Developed runtime optimizations for complex algorithms
• Designed architectures for scalable systems

Developed embedded systems using Rust and C/C++, focusing on real-time performance. Specialized in driver development for RTOS platforms.

• Optimized object-oriented designs for embedded applications
• Implemented real-time algorithms with RTOS
• Developed hardware interfaces with C/C++

Managed distributed systems projects leveraging Rust and Kubernetes on AWS. Implemented CI/CD pipelines for seamless deployment and continuous integration. Optimized key-value data stores for high availability and performance.

• Managed distributed systems with Kubernetes
• Implemented CI/CD pipelines
• Optimized key-value data stores

Owned and operated a software consultancy specializing in Rust and Golang for high-performance computing solutions. Developed simulation tools using Matlab for scientific research applications.

• Implemented cross-platform applications in C/C++
• Developed real-time data analysis tools in Python
• Contributed to open-source projects in C#