Hire Freelance
Embedded Rust Developers in France

Architected embedded systems with a focus on Linux-based platforms using Yocto. Developed real-time applications in Rust for resource-constrained environments.

• Created custom Linux kernel modules
• Implemented C++ solutions for hardware interfacing
• Automated build processes with Bash scripting

Developed machine learning models in Python for predictive analytics. Built backend services in Rust for data-intensive applications.

• Implemented SQL-based data warehousing solutions.
• Developed data visualization tools using R.
• Worked on C# applications for enterprise solutions.

Builds Rust backend services, compilers, domain-specific languages, and embedded-systems software. Created a Rust implementation of a custom programming language, shipped PostgreSQL-backed production APIs, and maintains open-source packages across crates.io and npm.

• Designed REST and WebSocket interfaces
• Optimized PostgreSQL queries and schemas
• Built reproducible environments with NixOS
• Won an IEEE hardware-demo award for side-channel tooling

Develops Rust systems spanning embedded control software for marine vessels and drones, backend services, and WebAssembly applications. Co-created a real-time collaborative audio workstation using Rust, WASM, and CRDTs, combining low-latency state synchronization with cross-platform interfaces.

• ESP32 and NVIDIA Jetson embedded targets
• CAN, Modbus, and NMEA protocol integration
• Flight-controller software for autonomous drones
• Substrate and Ink! smart-contract development

Focused on network function virtualization using Rust and eBPF. Built high-speed packet processing applications with DPDK and P4. Expert in developing core engine components for networking solutions.

• Built high-speed packet processing applications
• Developed core engine components for networking
• Expert in network function virtualization

Architected large-scale low-level systems using Rust and C for Unix environments. Developed high-performance Linux-based applications focusing on system reliability.

• Optimized Python scripts for system-level automation
• Led Unix kernel module development projects
• Designed distributed systems with Rust for fault tolerance

Developed a machine learning model for image recognition tasks using PyTorch and ONNX. Integrated Rust for performance-critical components in AI workflows.

• Implemented neural network optimizations with NASM.
• Built data preprocessing pipelines in Python.
• Collaborated on open-source AI libraries using Candle.

Managed the development of cross-platform applications using Rust and C++. Spearheaded product strategy for distributed systems in a microservices architecture. Expert in integrating Rust with existing Java and Kotlin codebases.

• Led cross-platform app development
• Spearheaded distributed systems strategy
• Integrated Rust with Java and Kotlin

Developed high-performance applications using C and C++, focusing on system-level efficiency and resource management. Integrated Rust for enhanced concurrency and safety in application design.

• Built dynamic web interfaces with Vue.js
• Implemented Python scripts for automation tasks
• Optimized Java applications for performance

Develops Web3 applications and infrastructure across Rust, Solidity, TypeScript, and EVM tooling. Optimized an Ethereum event aggregation database by 60%, deployed load-balanced Ethereum nodes, and built trading interfaces with portfolio analysis.

• Uniswap v4 Rust hook development
• Foundry and Alloy toolchains
• Kafka-based event processing
• Digital twins for autonomous shuttles

Developed a Bevy-based game engine in Rust with mlua integration for executing Luau scripts. Built web interfaces with React and TypeScript while applying C-based systems programming and Docker-based development workflows.

• Luau scripting runtime integration
• Rust ownership-oriented systems design
• React and TypeScript application development
• C-based algorithm implementation

Built an open-source, multi-tenant distributed key-value and object store in Rust with Raft replication, two-phase commit, write-ahead logging, virtual sharding, and S3/REST/gRPC interfaces. Also develops low-level systems and machine-learning tooling spanning x86-64 assembly, RocksDB, Transformers, Polars, and whisper.cpp.

• Standard-library-only Raft key-value library
• Role-based access control and storage encryption
• Compiler and virtual-machine implementations
• 200-plus automated tests across published projects

Builds native Android and iOS products alongside production Rust backends using Axum, taking systems from application design through deployment and monitoring. Applies retrieval-augmented generation and agent orchestration to shipped software, with additional work in interactive 3D and simulation using Bevy.

• Developed Kotlin applications for Android
• Built Swift applications for iOS
• Operated deployments with Firebase and Supabase
• Prototyped 3D simulations using Bevy

Develops asynchronous concurrent Rust services on Tokio for algorithmic digital-asset trading across more than 140 centralized and decentralized exchanges. Built exchange connectivity for roughly 20 venues using FIX, REST, and WebSocket protocols, with latency-sensitive order and market-data paths below 100 milliseconds.

• Founded an audited on-chain protocol
• Supported more than 12,000 blockchain identities
• Implemented NATS-based service messaging
• Built EVM integrations using The Graph and Multicall