Embedded Firmware in Rust

Firmware die werkt, en werkbaar blijft

Firmware is vaak het onzichtbare fundament van je product. Tot het misgaat. Random crashes, onverklaarbaar gedrag, een codebase waar niemand meer aan durft te komen. Wij bouwen firmware die betrouwbaar is én onderhoudbaar blijft, in Rust.

Herkenbaar?

  • Je firmware is fragiel: elke aanpassing breekt iets anders
  • Random crashes die je niet kunt reproduceren
  • De codebase is een black box geworden, zelfs voor je eigen team
  • Je firmware developer is vertrokken en niemand snapt de code
  • Het werkt, maar je durft er niks aan te veranderen
  • Je wilt nieuwe functionaliteit toevoegen, maar het voelt als een mijnenveld

Wij bouwen firmware waar je op kunt bouwen. Letterlijk.

Waarom Rust?

Niet omdat het nieuw is, maar omdat het betere firmware oplevert.

Minder bugs

Hele categorieën fouten, zoals null pointers, buffer overflows en race conditions, bestaan simpelweg niet in Rust. De compiler vangt ze af voordat je code draait.

Begrijpelijke code

Rust dwingt je tot expliciete keuzes. Dat maakt code leesbaarder, ook voor wie er later instapt.

Onderhoudbaar op lange termijn

Aanpassingen maken zonder angst. De compiler vertelt je wat er breekt, voordat je het uittest op hardware.

Moderne tooling

Dependency management, testing, debugging: het werkt gewoon. Geen losse scripts en handmatige configuraties.

Wij werken inmiddels vijf jaar met Rust op embedded. We zijn er productiever in dan in C, en de kwaliteit ligt hoger.

Wat we doen

Nieuwe firmware

Van scratch, op jouw hardware of op een platform dat we samen kiezen. Schone architectuur, gebouwd om mee te groeien.

Firmware bij PCB-ontwerp

We ontwerpen ook hardware. Als wij beide doen, zijn ze vanaf het begin op elkaar afgestemd.

Firmware op bestaande hardware

Je hebt al een PCB, van jezelf of van een derde. Wij schrijven de firmware die erop draait.

Hoe we werken

Pragmatisch

We bouwen wat je nodig hebt. Geen over-engineering, geen tech om de tech.

Directe lijnen

Je praat met de engineers die de code schrijven. Geen tussenpersonen.

Kennisoverdracht

We documenteren wat we bouwen en leggen uit waarom. Je blijft niet afhankelijk van ons.

Wat je krijgt

  • Firmware die doet wat het moet, betrouwbaar
  • Code die leesbaar en onderhoudbaar is
  • Documentatie die je team verder helpt
  • Optioneel: begeleiding bij het zelf verder ontwikkelen

Liever firmware in C?

Kan ook. We hebben ruime ervaring met C op embedded.

Wel eerlijk: een C-project kost doorgaans meer tijd dan hetzelfde project in Rust. Niet omdat we C minder goed kennen, maar omdat het meer discipline en testwerk vraagt om dezelfde kwaliteit te halen. Dat zie je terug in de prijs.

Heb je een bestaande C-codebase die je wilt uitbreiden of onderhouden? Dan is C vaak de logische keuze. Voor nieuwe projecten adviseren we Rust, maar de keuze is aan jou.

Over ons

Jitter werkt al vijf jaar met Rust op embedded systemen, voornamelijk op STM32. We hebben de leercurve doorgemaakt en weten waar de valkuilen zitten. Die ervaring zetten we in voor jouw project.

Firmware-uitdaging waar je tegenaan loopt?

Neem Contact Op