Firmware that performs under pressure. Deterministic, secure, field-updatable.
We write the software that runs our own unmanned systems — from real-time control on microcontrollers to autonomy on edge compute — and the same for clients in defense, motorsport and industry. The same engineers who design the board write its firmware, so timing, interfaces and failure modes are solved together.
Source code ownership · Secure boot & signed updates · QMS aligned with EN 9100 (in progress)
One software stack. Proven in our own systems.
Hard real-time control on the flight controller, perception and autonomy on the companion computer — built as one architecture across our quadcopter, interceptor and fixed-wing platforms.
- Layer 4 — AutonomyMission logic, perception, navigation in GNSS-degraded conditions · NVIDIA Jetson module· Linux / ROS 2
- Layer 3 — CommunicationTelemetry & command link · MAVLink / custom protocol · encrypted datalink · onboard bus (CAN / DroneCAN, Ethernet)
- Layer 2 — ControlSensor fusion, state estimation, real-time control loops · RTOS · own stack / PX4 / ArduPilot-based
- Layer 1 — HardwareDrivers, bootloader, HAL for our own flight controller and carrier board · MCU family
What we build.
Real-time firmware
Deterministic code where every microsecond is accounted for.
- Bare-metal and RTOS firmware
- Control loops, motor control, actuators
- Device drivers and bootloaders
- Timing analysis on real hardware
Edge & autonomy
Processing on the aircraft, not in the cloud.
- Embedded Linux, BSP and Yocto images
- Computer vision on Jetson-class compute
- Sensor fusion and state estimation
- GNSS-degraded navigation
Communication
Robust links between sensors, subsystems and the operator.
- CAN / DroneCAN, Ethernet, UART, SPI
- MAVLink and custom protocols
- Real-time telemetry, high-rate data logging
- Interface control documents (ICD)
Tooling & updates
Maintainable beyond the prototype.
- Configuration and calibration tools
- Field firmware updates with rollback
- Reproducible builds, CI pipeline
- Diagnostics for operators and service
Software that fails safe and can't be tampered with.
On a mission or on track, a software fault is a system failure. We design for degraded conditions, lost links and hostile environments — and test for them before delivery.
- Fail-safe behaviour
- Watchdogs, health monitoring, defined behaviour on link loss, sensor failure and low power
- Secure boot & updates
- Signed firmware, verified boot chain, authenticated update process if implemented.
- Link security
- Encrypted command and telemetry links, AES-256 / per-project keys
- Development process
- Coding standard MISRA C / own, code review, static analysis, traceability from requirement to test; DO-178C-informed practices
- Supply chain
- SBOM for every release, licence review of third-party code, EU-based development
Tested on the bench before it leaves the ground.
Software-in-the-loop
Control and mission logic run against simulated dynamics on every commit.
Hardware-in-the-loop
Real boards, real sensors and actuators, simulated flight — including fault injection.
Field testing
Validated in real operating conditions with full logging and post-test analysis.
From requirement to released firmware in five steps.
Start from scratch, port an existing codebase to new hardware, or bring a prototype up to production quality. Every phase ends with a review and a clear go / no-go.
- 01
Requirements
Functions, timing budgets, interfaces, safety cases. NDA signed.
- 02
Architecture
Software architecture, ICDs, toolchain. Review with your engineers.
- 03
Implementation
Iterative builds on real hardware, SIL tests on every commit.
- 04
Integration & HIL
System integration, fault injection, field tests.
- 05
Release & support
Versioned release, documentation, update tooling, long-term maintenance.
What you receive.
Everything you need to build, test, certify and maintain the software — with or without us.
- Production firmware
- Signed, versioned release binaries with release notes
- Source & build environment
- Full source, reproducible containerised build, CI configuration
- Interface documentation
- ICDs, protocol specifications, API reference
- Test procedures & reports
- SIL / HIL test suites, results, requirement traceability
- SBOM & licences
- Software bill of materials and third-party licence report
- Tools
- Configuration, calibration and field-update tooling
Before you ask.
Can you work on hardware you didn't design?
Yes. We write firmware for third-party boards and port existing code to new hardware. Designing both gives the best result, but it is not required.
Do we get the source code?
Yes. Full source and build environment are part of the delivery, under the agreed contract terms.
Is your stack based on open-source autopilots?
Our flight stack is based on PX4 / ArduPilot with our extensions. Every release includes an SBOM and licence review, so you know exactly what you ship.
Can you support certification?
We work with requirement traceability, code review and test evidence that support certification. Formal DO-178C / other certification support: describe what you offer.
Do you provide long-term maintenance?
Yes. Bug fixes, security updates and feature releases under a support agreement .
Send us your requirements. Talk to an engineer, not a sales desk.
Share a spec, an interface document or the problem you need solved. A software engineer replies within 2 working days — under NDA if you need it.