ZPU
Open-source stack microprocessor for FPGAs
The ZPU is a minimal microprocessor designed by Zylin AS to run supervisory code within field-programmable gate arrays. Released as open-source in 2008, it uses a stack architecture to minimise logic usage, allowing more space for custom hardware designs.
- Designed by Zylin AS for FPGA supervisory code
- Released as open-source in 2008
- Uses stack architecture to minimise logic
- Requires as few as 446 lookup-tables
- Compatible with GNU Compiler Collection
What it is
The ZPU is a microprocessor core built specifically for use inside field-programmable gate arrays (FPGAs). Designed by the Norwegian firm Zylin AS, it handles supervisory tasks such as user interfaces or system control. Its primary goal is to occupy the smallest possible amount of electronic logic. This efficiency allows engineers to use smaller, cheaper FPGAs while leaving ample resources for high-speed custom algorithms. The design sacrifices raw processing speed to achieve this compact footprint.
How it came about
Zylin AS created the ZPU to address the inefficiency of adding separate microprocessors to FPGA projects. Many designs required a CPU for minor tasks, which wasted valuable logic space. By making the processor extremely small, Zylin enabled the use of less expensive hardware. In 2008, the company released the ZPU as open-source. This move allowed wider distribution for security inspections and educational purposes, overcoming the licensing restrictions common with proprietary FPGA CPUs.
Inside the chip
The ZPU operates as a stack machine, storing intermediate calculation results in memory rather than in registers. This approach minimises the number of flip-flops required in the FPGA. It features a minimal instruction set that is fully compatible with the GNU Compiler Collection. Code size is significantly reduced because instructions do not need to specify register IDs. A 32-bit value can be stored in as little as one byte, compared to eight bytes on many RISC processors. About two-thirds of its instructions can be emulated via firmware, further reducing hardware complexity.
How it was made
The core is designed to fit into very small logic structures. The base implementation requires as few as 446 lookup-tables, which equates to roughly 1700 electronic logic gates. It includes a 32-bit data path, with a 16-bit variant available for even greater savings. The design includes a reset vector and a single interrupt vector. Implementers often add a stack cache or replace emulated instructions with hardware to improve performance, though the base design prioritises minimal resource usage over speed.
Where it went
Engineers use the ZPU for miscellaneous system tasks that are best handled by software, such as managing user interfaces. It is ideal for projects where code size must be small or where wide compiler support is needed. Because it is open-source, it suits applications requiring security audits or educational distribution. An emulator can also implement the ZPU instruction set on other target CPUs, allowing developers to use its compact code generation tools even without the specific hardware.
Versions and family
Several models of the ZPU core exist beyond the original Zylin design. The ZPUino core offers practical speed improvements and can replace emulated instructions with hardware, often embedded in a system-on-chip framework. The ZPUFlex core is designed to utilise external memory blocks and also supports hardware replacement for emulated instructions. The original Zylin core remains focused on the minimal FPGA footprint and includes a 16-bit version for extreme space saving.
Why it matters
The ZPU demonstrated that a functional CPU could be implemented with extremely few logic gates. Its open-source nature provided an alternative to proprietary cores locked to specific FPGA vendors. Academic projects have studied its power efficiency and reliability. One implementation reduced power usage by 46 per cent using a stack cache and clock gating, bringing it in line with other small open-source cores like Amber. It enabled the use of standard debugging tools and compilers in constrained environments.
Questions people ask about ZPU
What is the main advantage of the ZPU?
The ZPU is designed to use very little electronic logic within an FPGA. This allows engineers to use smaller, cheaper chips and leave more space for custom high-speed hardware algorithms.
How does the ZPU store data?
It uses a stack machine architecture. Instead of using registers, it keeps intermediate calculation results in memory on a push-down stack, which reduces the number of required flip-flops.
Is the ZPU fast?
No, the ZPU is very slow. It sacrifices speed to achieve a small size. However, this allows high-speed tasks to be handled by dedicated hardware logic in the FPGA instead.
Can I use standard compilers with the ZPU?
Yes. The ZPU has a port of the GNU Compiler Collection. This makes it easier to use than many other FPGA CPUs that lack compiler support, enabling access to a wide range of tools.
Good reading and sources
The facts on this page come from the Wikipedia article "ZPU (processor)", written by its contributors and used under the CC BY-SA 4.0 licence, and from its Wikidata record (CC0). EveryChip rewrote the text in its own words, with AI assistance, and compares every page with the article to make sure no passage is copied. It may be reused under the same CC BY-SA 4.0 licence with a link back.
It may contain mistakes, and figures change over time. Nothing here is investment or buying advice. If something is wrong, tell us. Last refreshed 2026-11-14.