Hire
Embedded Rust Developers

Owns an embedded Linux IoT platform from U-Boot and kernel bring-up through systemd, factory testing, and fleet operations. Migrated application components to Rust on Buildroot and implemented fleet management, OTA updates, remote administration, monitoring, and production Zigbee devices deployed across more than 3,000 automations.

• FreeRTOS and Linux real-time systems
• Nordic SoC Zigbee device development
• Industrial CI and factory-line validation
• Secure boot and embedded platform hardening

Built safety-critical automotive firmware using C, RTOS scheduling, real-time state machines, and ISO 26262/MISRA C practices on resource-constrained microcontrollers. Also develops Rust services with Axum, Tokio, SQLx, custom error types, and asynchronous concurrency from API design through persistence.

• BLE GATT and custom wireless protocol implementations
• CAN, UART, SPI, and I2C device communication
• LittleFS and Dhara flash translation layers
• Wear-leveling drivers for raw NAND and NOR flash

Builds Rust-based embedded Linux software for EV charging systems, including OCPP 2.0.1 implementations, ISO 15118 integration, MQTT APIs, and interoperability testing between charging stations and backend services. Has developed cloud-connected software for large sensor fleets and low-power IoT deployments spanning hardware integration and scalable backend services.

• Prototyped PCBs for AC charging station hardware
• Implemented LoRaWAN and Zigbee device communication
• Integrated Modbus sensors into energy systems
• Maintained CI/CD pipelines for embedded software

Developed embedded automotive systems across Embedded Linux and QNX, including BSPs, device drivers, Linux kernel components, and multithreaded applications. Covered hardware bring-up, Ethernet and serial communications, AUTOSAR integration, and SIL validation through production deployment.

• Yocto-based embedded image construction
• C++11 through C++20 codebases
• MISRA and ISO 26262 compliance
• Jenkins and CMake build automation

Develops security-critical Bitcoin firmware and operating-system components in Rust, including transaction validation that detects tampering before signing. Has ported an asynchronous Rust operating system to the STM32H7 and built embedded hardware-abstraction layers under strict memory constraints.

• Implemented zero-allocation animated QR transmission libraries
• Developed fuel-gauge, LCD, and camera device drivers
• Built embedded firmware spanning C, Rust, and MicroPython
• Contributes to low-level open-source C and C++ projects

Expert in low-level systems programming with Assembly and C for performance-critical applications. Developed complex shell scripts in bash for automation and integration tasks. Utilized Rust for memory-safe concurrent programming in system utilities.

• Specialized in low-level systems programming
• Developed automation scripts in bash
• Utilized Rust for concurrent programming

Developed embedded Linux systems with Rust for real-time applications. Designed custom kernel modules to enhance system performance.

• Integrated SQL databases for embedded data management
• Implemented C-based drivers for hardware interfaces
• Optimized Bash scripts for system automation

Developed a type-safe Rust control layer for industrial inkjet printheads, including asynchronous execution and hardware-constrained resource management. Built backend infrastructure connecting firmware devices through service discovery, telemetry messaging, and relational storage.

• napi-rs native Node.js addon packaging
• mDNS device discovery over isolated VLANs
• Mosquitto MQTT telemetry handling
• High-throughput computational print-plan generation

Develops embedded Rust firmware and backend middleware across bare-metal MSP430, STM32, ESP32, and RP2350 platforms. Implements async Embassy and no_std systems for industrial metering, cellular connectivity, LoRa telemetry, vending controls, displays, and BLE peripherals.

• SX1262 LoRa range-testing hardware
• PPP and CMUX cellular modem support
• LVGL display interfaces
• Bootloader and OTA update mechanisms

Designs C++14 communication middleware for AUTOSAR Adaptive, supporting inter-process, intra-process, and ECU-to-ECU communication in ISO 26262 safety-critical environments up to ASIL-B. Previously developed AUTOSAR Classic switch firmware covering IP routing and central-ECU integration for electric-vehicle platforms.

• SOME/IP and POSIX middleware implementation
• Functional-safety development under ISO 26262
• ASPICE-compliant automotive software processes
• VHDL and MATLAB engineering background

Built a Rust complex-event-processing engine that composes reusable processing blocks into Kafka-consuming and Kafka-producing deployments. The system uses Tokio tasks, NATS stage transport, embedded Python execution, and dependency-aware input routing to reproduce production-grade stream-processing architecture.

• Implemented bidirectional PyO3 type marshalling across the FFI boundary
• Managed Python GIL boundaries for in-process block execution
• Developed Linux filesystem drivers and embedded firmware
• Built distributed event-driven backends in Scala, Java, and Go

Works close to the Linux platform through embedded systems, Buildroot, kernel development, and network-protocol implementation. Telecommunications work includes hands-on engineering for 4G LTE and 5G NR systems, alongside embedded microcontroller and signal-processing projects.

• Linux kernel customization
• Buildroot image engineering
• LTE and NR protocol stacks
• Embedded computer vision

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

Builds distributed workflow, data, and scientific-computing infrastructure across Rust, Go, Python, and systems-level C/C++. Designed job scheduling with PostgreSQL state management and worker dispatch, and contributed to published DeepVariant evaluation research alongside genomics pipeline engineering.

• Implemented FPGA RTL with SystemVerilog and Yosys
• Developed STM32 bare-metal peripherals over I2C and UART
• Built cloud ETL pipelines with Parquet and BigQuery
• Operated Kubernetes workloads across GKE and ECS