Embedded firmware

Embedded firmware development, done in Rust.

We design and build production firmware for connected devices. Sensors, wearables and radio products that have to be reliable, secure and frugal with power, and keep running for years in the field. We write it in Rust, which rules out whole categories of memory bugs before they ever ship.

  • Rust on ESP32, STM32 and Nordic nRF
  • BLE, Sub-GHz, Thread / Matter and LoRa
  • Secure FOTA with signed images and safe rollback
  • Power profiling down to microamps
SensorESP32 · Rust
WearablenRF52 · Rust
TrackerSTM32 · Rust
BLE · Sub-GHz · LoRa
Edge gateway
nRF53 · Rust
Mobile app
Flutter · BLE
Ethernet · 4G/5GWi-Fi · 4G/5G
Cloud platform
Ingest · OTA · telemetry
Realtime
What we build

Everything the embedded firmware layer needs.

MCU platforms

Board bring-up and production firmware across the chips you actually ship on.

Wireless & radio

Rock-solid connectivity and pairing across short- and long-range protocols.

FOTA updates

Secure firmware-over-the-air with signed images, A/B partitions and safe rollback — so the fleet stays current and recoverable.

Ultra-low-power

µA-class sleep currents, power profiling and duty-cycling that turn a coin cell into years of battery life.

Drivers & HAL

Sensor and peripheral drivers on bare-metal or RTOS, plus app- and cloud-side integration so the whole stack speaks one language.

Security

Secure boot, signed images, encrypted storage and hardware-backed crypto — protection designed in from the first commit.

How we work

A low-risk way to start.

01

We work out if we're a fit

A short call to understand the device, the constraints and the timeline. If we're not the right team, we'll tell you and point you somewhere that is.

02

We prototype in a two-week Sprint

A fixed-price sprint that turns the core idea into something real you can test, so you decide on the full build with evidence instead of a guess.

03

We build, and review everything

Weekly, working releases you can use. AI handles the repetitive parts and a senior engineer reviews and tests every change before it ships.

04

We ship and stick around

We help you release, then support and extend it. Because you own all of the code, you can take it in-house whenever you want.

The stack

The firmware stack we work in

Rust (no_std)Embassy / RTICESP32STM32Nordic nRF52 / nRF53BLESub-GHzThread / MatterLoRaWi-FiFOTARTOS & bare-metalSecure boot
Questions

Answered straight.

Which MCUs and radios do you work with?

Mainly ESP32, STM32 and Nordic nRF52 / nRF53, across BLE, Sub-GHz, Thread / Matter, LoRa and Wi-Fi. If you're on a different part, tell us and we'll be straight about whether we're the right team for it.

Why do you write firmware in Rust?

Rust removes whole classes of memory bugs at compile time, which is exactly the kind of fault that turns into a field failure or a recall on a device you can't easily patch. You still get C-level performance and footprint.

Can you do over-the-air (FOTA) updates?

Yes. We build secure firmware-over-the-air with signed images, A/B partitions and safe rollback, so a whole fleet stays current and recoverable even if an update goes wrong.

Do you handle board bring-up and drivers?

We do board bring-up, write sensor and peripheral drivers on bare-metal or an RTOS, and connect the device up to the app and cloud so the whole stack speaks one language.

Can you take a device from prototype to production?

Yes. We can start at a proof of concept and carry it through to production firmware, including power optimisation, security and the update pipeline you'll need for a real fleet.

Do we own the firmware?

All of it. Source, build setup, documentation and IP are yours, with no lock-in and no hidden dependencies you can't replace.

Tell us what you're building.

We'll come back within one business day with how we'd approach it, and a no-pressure consultation.