The software that brings your hardware to life
We build the firmware that turns a board into a product: one that makes the most of every resource, holds up and updates in the field. That invisible layer that makes everything, quite simply, work.
A good board with bad firmware is a nasty surprise waiting to happen
Firmware is invisible until it fails. Then you really notice it: the device that freezes, the battery that lasts half what was promised, the feature that stutters, the product you have to recall to update by hand. The software layer closest to the hardware is also the one that forgives the least.
And it is exactly the one most often neglected. The board gets contracted out one way and the firmware another, with no conversation between them, or it gets left to the end in a rush. The result? A product that works almost always, which is the worst category of product there is.
So we treat the firmware as what it is: the heart of the product. We develop it right next to the hardware, tuned for power and memory, able to weather the unexpected and ready to update securely. So it works always, not almost always.
The layer that connects the hardware to the world
From the driver to the cloud protocol. This is what we put to work inside your product.
Custom firmware
Software cut to fit your board and your case: not one library too many, not a single resource thrown away.
Drivers and low level
We program the layer that talks directly to the hardware: sensors, peripherals and actuators.
Communications and protocols
We implement BLE, Wi-Fi, MQTT, Modbus and whatever protocols your product needs.
Real time
We make things happen when they have to happen, with real-time systems (RTOS).
OTA updates
We design secure field updates so your product improves without a trip to the workshop.
Power optimization
We tune the firmware to stretch the runtime, because software drinks battery too.
Firmware built on rock, not on sand
Five stages for embedded software that is reliable and maintainable.
Architecture
We set the firmware architecture and the timing and power requirements.
Low level
We program the drivers and the layer that talks to the hardware.
Logic and comms
We build the product logic and the communications.
Testing
We validate on real hardware: endurance, power and edge cases.
OTA and support
We leave secure updates ready and keep providing support.
Firmware from the people who also designed the board
When the same team that writes the firmware designed the electronics, the misunderstandings disappear. We know what is underneath, which registers to touch and where the limits are. And it shows: fewer bugs, less power draw and a product that ships sooner.
We have spent years building embedded software for products that sell and get used, with teams in Barcelona, Madrid, London and Los Angeles. And we build it to last: clean, documented code, made so someone can maintain it tomorrow.
We know the hardware
We write the firmware for boards we designed ourselves.
Robustness first
Built not to freeze and, if something happens, to recover on its own.
Improvable from afar
With secure OTA your product evolves without a trip to the workshop.
Maintainable code
Clean and documented so it lives for years, not a couple of months.
Case · Triton BMS
Software where failure is not an option
In the Battery Monitoring System for Triton Submarines, the firmware manages a submarine's power. There the software cannot almost work. It has to work, full stop.
View the caseFirmware for every sector
It does not matter the product: if it has a board inside, it has firmware, and that firmware has to be flawless.
What we get asked most
Do you work with low-power microcontrollers?
Yes. We tune the firmware to get the most out of the runtime: low-power modes, good peripheral management and code that does not waste cycles.
Do you include field updates (OTA)?
When the product calls for it, yes. We design secure updates so you can fix and improve without recalling devices from your customers.
Can you take over firmware that already exists?
Yes. We review the current code, document it and improve it or keep developing it, even if we did not write it.
What is an RTOS and when is it needed?
A real-time operating system ensures certain tasks happen within strict deadlines. You need it when the product has to respond predictably, not whenever it happens to get around to it.
Do you also do the electronics or only the software?
Both, and that is our advantage. Designing the board and the firmware together takes the biggest source of trouble in electronic products off your plate.
How do you make sure the firmware is reliable?
We test it on real hardware, not just in simulation: edge cases, power, failure recovery and stress. Reliability is won in the testing, not on paper.
Is the firmware documented and ours?
Yes. We hand over clean, documented code and ownership of the work, so you never depend on anyone to maintain it down the road.
Shall we bring your hardware to life?
Tell us about your product and we will tell you how we would approach the firmware, what it takes and where to start. We get back to you quickly.