Hire Contract
Fintech Rust Developers in France

Architected scalable data processing systems with Scala and FS2 for large-scale analytics. Developed RESTful APIs using Http4s, ensuring high throughput and low latency.

• Led migration to cloud infrastructure using Kubernetes
• Enhanced data serialization with Circe for JSON processing
• Designed event-driven architectures using Kafka

Architected distributed systems with Rust and C++ for high-frequency trading platforms. Spearheaded performance optimization projects reducing latency by over 50% in critical systems. Developed low-latency communication protocols for financial data exchange.

• Enhanced multi-threading capabilities in systems software
• Implemented custom memory management techniques
• Led refactoring of legacy C++ codebases to Rust

Developed decentralized applications on the Solana blockchain, using Rust and Anchor for smart contract development. Designed scalable backend services for financial platforms.

• Implemented TypeScript-based UI for blockchain interactions
• Optimized SQL queries for high-volume data processing
• Integrated Java-based middleware for cross-chain compatibility

Developed back-end services with C++ and Python for high-availability systems. Contributed to Qt-based interfaces for desktop applications.

• Enhanced Rust libraries for better concurrency support
• Integrated JavaScript for responsive UI components
• Optimized C code for embedded systems

Led development of distributed systems using Rust and Go, emphasizing consistency and availability. Architected scalable microservices with TypeScript for cloud environments.

• Implemented serverless functions with Python
• Developed frontend frameworks with JavaScript
• Optimized database 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

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

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

Implemented a C memory allocator and a shell interpreter, applying low-level memory-management and process-control concepts. Built Rust and GTK4 neural-network tooling alongside a C/GTK OCR-based Sudoku solver, combining numerical computation with desktop interfaces.

• x86-64 and 68000 assembly programming
• Ansible API and REST backend development
• Active Directory and GNS3 networking
• OCaml and Haskell programming

Technical background centers on scientific documentation, experimental protocol design, and structured research preparation. Produces instructional materials and exercises for physics-related learning and experimentation.

• Experimental procedure development
• Scientific literature research
• Physics course preparation
• Learning-activity design