Lazarus Ebi
Architecting robust, secure, and highly optimized embedded systems and low-level software.
About Me
I am an Embedded Software Engineer deeply immersed in systems programming and hardware-level development. My expertise bridges the gap between hardware and software, focusing on Linux environments, bare-metal C/C++, and memory-safe Rust implementations. I build systems where every byte and clock cycle matters; rigorously addressing CPU, memory, and I/O constraints. By proactively identifying attack surfaces and prioritizing threat modeling, I ensure my firmware and low-level architectures mitigate concurrency risks, undefined behavior, and common misconfigurations before they reach production.
Career Journey
2022 - Present
Embedded Software Engineer
EbiTechnologies.
- Developed RTOS-based firmware for ARM Cortex-M (STM32) microcontrollers.
- Wrote and maintained custom Embedded Linux device drivers for SPI and I2C sensors.
- Architected secure bootloaders and implemented cryptographic protocols for IoT devices.
2018 - 2022
Junior-level programmer
Bemint — Empowering Africans.
- Optimized legacy C/C++ data processing pipelines, reducing CPU overhead by 40%.
- Introduced Rust into the stack to eliminate memory safety vulnerabilities in concurrent modules.
- Conducted rigorous technical security analysis and threat modeling across distributed systems.
2016 - 2018
Firmware Engineering Intern
Industrial Training Fund.
- Assisted in writing bare-metal C routines for Arduino and 8-bit AVR microcontrollers.
- Developed Python scripts for automated hardware-in-the-loop (HIL) testing.
My Tech Stack
A collection of the primary languages, architectures, and tools I use for low-level development.
C
C++
Rust
Assembly
Python
Linux Kernel
STM32 / ARM
Arduino
Secure Coding
SQL
Featured Projects
Scroll to explore my open-source firmwares, memory management utilities, and low-level software architectures, ordered from foundational systems to complex operating systems.
Custom Memory Allocator
A custom implementation of `malloc`, `calloc`, `realloc`, and `free` using the `sbrk` system call. Features an explicit free list, block splitting, and pointer arithmetic optimization to strictly manage heap memory.
Rust CLI System Monitor
A lightweight, zero-allocation terminal monitoring tool that parses `/proc` virtual filesystems directly to display real-time CPU, memory, and I/O constraints with absolute memory safety.
Linux HID Event Logger
A low-level input subsystem monitor (educational keylogger) that interfaces directly with `/dev/input/event*`. Demonstrates secure handling of device file descriptors, ring buffers, and system interrupt handling.
Bare-Metal USB Stack
Implemented a USB Human Interface Device (HID) class from scratch on an STM32 bare-metal setup, interacting directly with USB peripheral registers without HAL libraries to save memory.
Multithreaded HTTP Server
A high-performance web server built natively in C. Uses socket programming, a custom pre-allocated thread pool, and strict memory pooling to eliminate memory leaks and mitigate concurrency risks under high load.
Zero-Copy TCP Proxy
An asynchronous networking utility written in Rust utilizing the Tokio runtime. Routes traffic seamlessly while enforcing zero-copy data transfer to heavily optimize memory bandwidth and reduce CPU overhead.
IoT Sensor Node (Secure Boot)
An ESP32-based Arduino project collecting telemetry data. Designed with comprehensive threat modeling, implementing secure boot and encrypted MQTT payload transmission.
Automotive CAN Bus Logger
Built a high-speed CAN logging device capable of parsing OBD-II diagnostics and proprietary vehicle telemetry. Ensured zero packet loss through interrupt-driven buffers.
Wearable BLE Health Monitor
Firmware for a Nordic nRF52-based health monitor using Zephyr RTOS. Managed low-power states, PPG sensor acquisition, and robust Bluetooth Low Energy GATT service profiles.
Embedded Linux Device Driver
A custom character device driver integrated into the Linux kernel for a proprietary environmental sensor array. Managed memory-mapped I/O and strict DMA protocols.
Fault-Tolerant Flash File System
Ported and heavily modified LittleFS for a custom SPI NOR Flash chip array. Ensured wear-leveling and power-loss resilience for critical system configuration data.
Custom RTOS Kernel for STM32
Developed a preemptive Real-Time Operating System from scratch for ARM Cortex-M microcontrollers. Includes custom schedulers, mutexes, and zero undefined-behavior constraints.
Rust Flight Controller Firmware
A memory-safe quadcopter flight controller using Rust. Handled complex sensor fusions (I2C/SPI), PID loops, and concurrency risks natively through Rust's strict compiler guarantees.
RISC-V Hypervisor Port
Experimental port of a lightweight Type-1 hypervisor to a RISC-V architecture using Rust. Handled hardware virtualization extensions, memory isolation, and trap delegation.
Get In Touch
Need a secure, optimized firmware solution? Send me a message, and I'll get back to you soon.