FPGAs should be everywhere in creative hardware. They are the right tool for anything needing deterministic timing at speed — video synthesis, custom DSP, driving huge LED arrays, real-time signal mangling with no operating system underneath to introduce jitter.
They are not everywhere, because the on-ramp is brutal: vendor-locked toolchains measured in tens of gigabytes, a hardware description language that punishes software habits, and almost no reusable code you can trust.
CERN has released colibri, which addresses the last of those.
What’s in it
- Over 100 components, functions and procedures
- Standard communication protocols including SPI and I2C
- Self-checking testbenches
- Formal verification — genuinely rare in FPGA development, and essentially unheard of in hobbyist-accessible resources
- Vendor-independent code
- Published under the CERN Open Hardware Licence
- Hosted on GitLab at
gitlab.com/colibri-cern/colibri
Why the boring parts are the valuable parts
Anyone can publish an SPI implementation. Plenty of people have. The problem with the existing supply is that you cannot tell which ones work.
A found VHDL snippet for an I2C master may be correct, may be correct only at the clock rate its author used, may have a subtle bug that appears once every few thousand transactions, or may never have been tested outside one board. Debugging it means debugging someone else’s hardware description language while also debugging your own design — and on an FPGA, the tooling for that is an order of magnitude less pleasant than a software debugger.
Self-checking testbenches mean each component ships with a test that asserts its own correctness. Formal verification goes further: rather than testing specific cases, it proves properties hold across all inputs. That is a level of assurance most commercial FPGA code doesn’t carry, and CERN has a straightforward reason for it — their instruments run in places you cannot go and fix.
Vendor independence is the other quiet win. Xilinx and Altera/Intel toolchains encourage vendor-specific primitives, and a design built on them is a design you cannot move. Portable code means a project outliving a toolchain licence or a product line.
What a creative technologist would do with it
Concretely, the things an FPGA is genuinely better at than a microcontroller:
- Video synthesis and glitch — generating or mangling video signals at pixel clock rates, the hardware lineage behind analogue video synthesisers
- Massive parallel LED driving — hundreds of independent channels with no timing drift, where a microcontroller starts bit-banging and hoping
- Audio DSP with genuinely low latency — no OS, no buffer, deterministic sample-by-sample processing
- Bespoke sensor interfaces — reading unusual or many-channel sensors in true parallel
- Retrocomputing and hardware emulation — reimplementing old chips as logic rather than simulating them
Every one of those needs the same unglamorous foundation: reliable SPI and I2C to talk to the rest of the world, plus clock management and buffering. Getting that as tested, portable, formally verified code means the first weekend goes on your idea rather than on reimplementing a bus.
The remaining barrier is still real, and colibri doesn’t remove it — the toolchains are still enormous, still mostly vendor-controlled, and VHDL is still VHDL. But “there is no trustworthy reusable code” was the excuse with the least life left in it, and CERN just took it away.