# EuroPi turns a Raspberry Pi Pico into a Eurorack module you reprogram in MicroPython

> EuroPi is an open source Eurorack module by Allen Synthesis built on the Raspberry Pi Pico, with six control voltage outputs, two knobs, a 0-12V input, an OLED and an I2C expansion header, running your own MicroPython. The hardware, firmware and documentation are all released under free licences.

**Allen-Synthesis/EuroPi** — EuroPi: A reprogrammable Eurorack module based on the Raspberry Pi Pico

- Repository: https://github.com/Allen-Synthesis/EuroPi
- Stars: 584 · Forks: 108
- Language: Python
- License: CC0-1.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/allen-synthesis-europi

## A Eurorack module with a general purpose computer inside it

The EuroPi is a user reprogrammable Eurorack module developed by Allen Synthesis that uses the Raspberry Pi Pico to process and produce modular level signals, based on code written in MicroPython. The entire project is open source, and the README states that plainly at the top.

That combination is unusual in modular synthesis. Most Eurorack modules are fixed function boxes with a handful of knobs and a switch or two, and the behaviour of the panel is decided by the circuit. A Eurorack module that is a small computer running your own script is a different object, closer to a blank canvas than to an instrument.

The specification gives you the surface you are working with.

Six 0-10V control voltage outputs, each with an indicator LED. Two knobs with 12 bit resolution. Two push buttons. One 0-12V control voltage input with 12 bit resolution. One digital input for external clocking or gate sources. A 128x32 OLED display. And an I2C expansion header on the rear for extra sensors or outputs.

So the module reads control voltages and gates, writes control voltages, and shows you what it is doing on a small screen. Everything else is your code.

The Python in the repository is MicroPython, and the primary language of the repository is listed as Python, which is what the firmware and the user scripts are written in.

## Calibration first, because a Eurorack module reads in volts

The documentation section of the README has an instruction that tells you the order of operations, and it is worth taking seriously.

Before using any of the software, you are told to follow the programming_instructions to set up and calibrate your module. The documentation points at the hardware overview for the source files and documentation including build guides, and the kits can be bought directly from Allen Synthesis.

The reason calibration comes first is a property of the format. Eurorack control voltages are analogue signals, typically 0 to 10V, and a microcontroller reading them through an ADC needs to know what the voltages mean in its own numbers. Get that wrong and every output is scaled wrongly, and the symptom appears as a patch that does not behave like the one you designed. Calibrate once, correctly, and the module's behaviour becomes reproducible across units.

The other documentation pointers are equally specific. There is a list of user contributed scripts with descriptions of their usage in the contrib README, the full list of available functions in the EuroPi API documentation, which also includes examples, and a file called interesting_things.md that explains some of the less obvious but potentially useful functions in more depth.

That last one is a sign of a mature documentation culture. A project where the API reference is complete and there is also a page about the awkward corners is a project people have used hard enough to write down what surprised them.

## The firmware is one file, and the Makefile pushes it over USB

For anyone who wants to extend the firmware itself, the README points at the firmware source code in software/firmware/europi.py and asks you to read the contribution guidelines before making contributions of your own.

One file as the entry point is a good sign for a project that expects people to hack on it. The hardware, the MicroPython API and the user scripts are all in this repository, which means the layer you are most likely to touch, the script you write, sits right next to the layer that defines what the hardware can do.

The Makefile shows the deployment path, and it uses rshell for the transfer.

```make
deploy_firmware: clean
	rshell -f scripts/deploy_firmware.rshell

deploy_configs:
	rshell -f scripts/deploy_configs.rshell
```

So there are two distinct deployment targets. One pushes the firmware, and one pushes the configuration files, and both are done over rshell, which the Makefile comments point at as a requirement. The clean target removes the __pycache__ directories from the tree, and deploy_firmware depends on it, so a stale bytecode directory does not end up in the upload.

Splitting firmware and configuration is a sensible separation for this kind of device. Your own patch script is configuration in that sense, which means you can update the firmware without losing the scripts you wrote, and you can share a script without shipping a firmware version.

## Three free licences, and the hardware is certified open hardware

The licensing is the most deliberately arranged part of the project, and it is worth reading carefully.

The README says the module and any documentation included in the repository are entirely free software and hardware, and that the hardware is certified by the Open Source Hardware Association. Then the three licences are listed separately.

Software is under Apache 2.0, in software/LICENSE. Hardware is under CERN OHL-S v2, in hardware/LICENSE. Documentation is under CC0 1.0, in the root LICENSE file.

That is three different licence families applied to three different artefact types, and it is a well constructed arrangement rather than a single blanket licence. The CERN Open Hardware Licence is the one designed for hardware designs, and the README notes that its section 8.2 is the basis for the one request the author makes of you.

The request is a trademark one. Anyone is welcome to design their own versions of the idea or modify the designs, and the only condition is that you refrain from using the brand name Allen Synthesis on your DIY builds if you have modified the files in any way, to prevent confusion if they end up being resold or distributed. You may use the brand name if you have simply copied the files from the repository to replicate without modification.

The repository licence field records CC0-1.0, which is the documentation licence, so the metadata reflects only one of the three.

## The AI policy is unusually explicit, and it applies to contributions

The README carries an AI Policy section with an explicit image, and it is the most distinctive thing in the documentation. It is worth reading in full because it changes what a contribution to this project looks like.

The reasoning given is that this is a project that is both explicitly aware of, and reliant on, its social context, that the module's licences are deliberately free and open source, and that this is what allowed its community to develop itself and consequently develop the EuroPi module.

It paraphrases Dan McQuillan to make the argument: AI removes the cultural context that underpins our social relations, and a tool which produces an output without regard for social context cannot be used to meaningfully contribute to any project that specifically aims to analyse and engage with that context.

Then the policy itself. The project says it cannot know with certainty that any contribution is AI free, but that pull requests which have clearly relied on AI will be rejected, and it asks people to choose to develop without it, not just to ensure a quick merge but for the benefit of the open source community and society as a whole. It adds that all of the core components, meaning the firmware and the hardware, are entirely AI free.

If you plan to contribute, this is the first thing to read, because it is a stated condition on merging rather than a general sentiment.

## Where EuroPi is the wrong choice

The honest limitations are easy to state, because this is a platform rather than a product.

The first is that it is a lot of work for a module. You are buying a board, or building one from the files, and then writing the code that makes it do the thing you wanted. If you wanted a quantizer or a delay or an envelope generator that works, the commercially made module will do that on a switch press, and the EuroPi will do it after you write it, flash it, and debug it.

The second is the hardware replication risk. The disclaimer is explicit: recreate any of the files found in the repository at your own risk, the author will attempt to solve issues with the designs but cannot guarantee there are not minor bugs in the documents, both hardware and software. If you want a module or kit that you know will work and will have customer support, the README points you at ordering one from Allen Synthesis directly.

The third is that the official kits and the DIY route are not equivalent. The kit comes with a known-good PCB, and the hardware overview includes build guides for the version you make yourself. The README also asks for pictures and documentation with any bug fix or improvement you want to share, so community feedback is part of how the designs get better.

One more note for anyone who arrives at the wrong repository. The README flags that some users may be expecting the EuroPi Prototype, which is now deprecated and lives in a different repository. The main repository is the current module.

## Maintenance, releases, and the state of the community

The repository is not archived and the last push was on 2026-09-08. The recent releases are v0.23.1 and v0.23.0, both on 2026-07-18, and v0.22.0 on 2025-12-07.

That pattern is worth reading. A minor version moving from 0.22 to 0.23 with two patches on the same day, after a gap of about seven months, is a project with a regular but unhurried release rhythm. The zero major version means the project is still signalling that interfaces may change, which is normal and honest for hardware and firmware that people write scripts against.

The community signals are strong and visible. There is a Discord with a member count badge, a subreddit with a subscriber badge, a GitHub release badge tracking the latest semantic version, issue templates for reporting bugs in software, hardware or documentation, and a dedicated frequently_asked_questions.md and troubleshooting.md in the repository root. The README also asks for pictures and documentation alongside any bug fix, which is the right instinct for a hardware project where a photo of the actual board settles more questions than a text description.

The documentation build is Sphinx, driven from the Makefile, and built with warnings treated as errors and nitpicky mode enabled, which means a broken cross-reference fails the build rather than shipping.

The pyproject.toml is minimal, configuring black with a line length of 100, a target version of py38, and an exclusion for the contrib directories so contributed scripts are not reformatted.

## Conclusion

Adopt EuroPi if you build Eurorack patches and want a module you can write your own behaviour for in MicroPython, with hardware files and build guides you can actually replicate. Do not adopt it if you want a finished instrument, because EuroPi is a programmable platform and the effort of writing and deploying a script is on you. Before you buy a kit or build from the files, read the programming instructions, decide between the kit from Allen Synthesis and building the PCB yourself, and note the project's explicit position on machine written contributions before you plan to send a pull request.

## FAQ

### What is the EuroPi?

The EuroPi is a user reprogrammable Eurorack module developed by Allen Synthesis that uses the Raspberry Pi Pico to process and produce modular level signals based on code written in MicroPython. The entire project, hardware, firmware and documentation, is open source.

### What does the EuroPi hardware specification include?

Six 0-10V control voltage outputs each with an indicator LED, two knobs with 12 bit resolution, two push buttons, one 0-12V control voltage input with 12 bit resolution, one digital input for external clocking or gate sources, a 128x32 OLED display, and an I2C expansion header on the rear for extra sensors or outputs.

### How do I deploy my own scripts to a EuroPi?

The Makefile provides deploy_firmware, which cleans the tree and runs rshell with scripts/deploy_firmware.rshell, and deploy_configs, which runs rshell with scripts/deploy_configs.rshell. Both require rshell, and the configuration upload is separate from the firmware upload.

### What licences apply to EuroPi?

Software is under Apache 2.0, hardware under CERN OHL-S v2, and documentation under CC0 1.0, and the hardware is certified by the Open Source Hardware Association. The author asks that you not use the Allen Synthesis brand name on modified DIY builds, in line with section 8.2 of the CERN licence.

### Can I contribute to EuroPi if I use AI tools?

The README's AI policy says the project cannot know with certainty that a contribution is AI free, but that pull requests which have clearly relied on it will be rejected, and it asks contributors to develop without it. The firmware and hardware are stated to be entirely AI free.

## Sources

- [Allen-Synthesis/EuroPi on GitHub](https://github.com/Allen-Synthesis/EuroPi)
- [Issues](https://github.com/Allen-Synthesis/EuroPi/issues)
- [License: CC0-1.0](https://github.com/Allen-Synthesis/EuroPi/blob/main/LICENSE)
- [README](https://github.com/Allen-Synthesis/EuroPi/blob/main/README.md)
- [Releases](https://github.com/Allen-Synthesis/EuroPi/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/allen-synthesis-europi