Tulip CC: a portable Python computer with a 120 voice synthesizer

A computer that boots straight into a Python prompt

Tulip CC is a low power, self contained portable computer with a touchscreen display and sound, and its defining property is what happens when you turn it on. The README says Tulip boots instantaneously into a Python prompt, with built in support for music synthesis, fast graphics and text, hardware MIDI, network access and external sensors.

That is the whole interaction model. There is no desktop, no window manager and no application switcher. You write Python in the built in editor and execute it, or you type at the REPL and watch the result happen in real time on the display and the speakers.

The system is described as dedicated to your code, the display and sound, running in real time on specialized hardware, with the hardware and software fully open source. The framing is a programmable instrument rather than a general purpose machine. The intended user is someone making music, games, art or writing with code, and equally someone who wants to work on the system itself.

You can also buy one, or build one, or skip the hardware entirely. The README lists three ways to use Tulip: the off the shelf or DIY hardware project, Tulip running on the web with almost all the same features, and Tulip Desktop, which runs as a native app for Mac or Linux, or under WSL on Windows.

ESP32-S3, MicroPython, AMY and LVGL

The hardware is an ESP32-S3 chip running under the ESP-IDF, and the software on top of it is MicroPython. The sound comes from AMY, the project's own synthesis engine, and the interface layer is LVGL.

The repository layout makes the division of labour visible. There is an amy directory for the synthesis engine, a micropython directory, lv_binding_micropython_tulip for the bindings that expose the graphics library to Python, tulip for the device firmware, and tinycc, which points at the C runtime used to compile those bindings. tools and assets hold the supporting pieces, and docs holds the documentation the README links to, including the Tulip API reference and the music tutorial.

Two of those directories are submodules, and there are also AGENTS.md, AMY_AGENTS.md and CLAUDE.md files at the root, which says something about how the project expects itself to be worked on.

The repository also carries a requirements.txt at the top level, listing the Python packages for the parts that run off the device:

fastapi
uvicorn[standard]
python-multipart
requests
anthropic
model2vec
numpy

The fastapi and uvicorn entries point at a server component, which is consistent with Tulip running on the web and with a desktop build that talks to a local service rather than emulating a device.

8.5MB of RAM, 32MB of flash and a 128 by 50 text layer

The hardware budget is documented in enough detail to plan a project against, which is rare for a consumer device.

Memory comes first. The Tulip CC has 8.5MB of RAM, of which 2MB is available to MicroPython and 1.5MB is available for OS memory. The rest is used for the graphics framebuffers, which you can also use as storage, and for the firmware cache. Storage is 32MB of flash exposed as a filesystem accessible from Python, with 24MB left over after the OS in ROM.

So a Python program on Tulip has 2MB of heap and a filesystem to work with. That number is the design constraint behind everything else, and it is worth checking against what your own program needs before you commit to the platform.

The text layer is 128 by 50 with ANSI support for 256 colors, inverse, bold, underline and background color. The graphics side allows up to 32 sprites on screen drawn per scanline with collision detection, out of a total of 32KB of bitmap memory at one byte per pixel. Behind them sits a background framebuffer of 1024 plus 128 overscan by 600 plus 100 overscan, which can be drawn to arbitrarily or used as RAM, and which scrolls horizontally and vertically.

The display defaults to 30 FPS at 1024x600, with the clock and resolution adjustable, and the palette is 256 colors. PNGs can be loaded from disk to set sprites or the background, or the bitmap data can be generated from code.

AMY, 120 voices, and the Alles mesh

Sound is the part that makes Tulip different from a small terminal, and the AMY engine is where the detail sits. It is described as a stereo 120 voice synthesizer engine running locally, or as a wireless controller for an Alles mesh.

The synthesis palette is wide. AMY supports additive and subtractive oscillators, an FM synthesis engine, samplers, karplus strong, high quality analog style filters and a sequencer. On top of that, Tulip ships with a drum machine, a voices and patch app, and a Juno-6 editor, so the device can make sounds on its own without a computer attached.

Running locally versus acting as a controller for an Alles mesh is a real fork in the design. A local 120 voice engine means the instrument keeps playing when the network is gone, while the mesh option means the synthesis can be spread across networked devices. Which one you get depends on the hardware and the software, and the README documents both paths without pretending they are the same thing.

The AMYboard is the headless variant of the same codebase. It has no screen, more audio capability, and the specific additions are audio input, modular 10hp and 10vpp audio, S/PDIF digital audio, CV jacks and an SD card. It is built on the Tulip code but focused on music synthesis, and it is priced separately at $29.90 through amyboard.com, with the Tulip itself at US$59 through tulip.computer, both sold by Makerfabs.

Inputs, outputs and the TULIP ~ WORLD chat room

Everything else the device can do is listed in the README as hardware support, and the list is specific about connectors.

There is USB keyboard, MIDI and mouse support, including hubs, plus capacitive multi touch, where the mouse stands in on Tulip Desktop and Tulip Web. MIDI input and output are both present, and there is an I2C, Grove or Mabee connector that the README says is compatible with many I2C devices such as joysticks, keyboards, GPIO, DACs, ADCs and hubs.

Networking is WiFi, and the README says you can access HTTP from Python using requests or through TCP and UDP sockets. So a Tulip is a network host as well as an instrument.

There is also a built in code and text editor, which is where the write your own program path starts, and a built in BBS chat room and file transfer area called TULIP ~ WORLD. A BBS on a device from this era of hobby computing is not a nostalgia gimmick so much as a way to share programs with other people on the same network without any server account of your own.

Power draw is stated as 575mA at 5V including the display at medium brightness, which the README says means it can last for hours on LiPo, 18650s or a USB battery pack. That figure is the difference between a desk device and something you can carry.

Rolling release tags and a licence GitHub cannot classify

The release scheme is unusual and worth noting before you pin anything. Among the recent releases are tags called tulip for a rolling release of the Tulip firmware dated 2026-06-19, amyboard for a rolling release of the AMYboard dated 2026-06-18, and a dated tag v-jun-2026 from 2026-06-04. Rolling tags mean the same tag name can point at different commits over time, so a build script that references tulip is not reproducible without also pinning a commit.

The last push was on 2026-10-14, and the repository is not archived, so work on the system continues. The project also documents a troubleshooting guide, a build guide for making your own hardware, and a roadmap board hosted on the shorepine organisation page for what is being worked on next.

The licence needs care. GitHub cannot classify the licence on this repository as one of the standard ones and points to the LICENSE file, and the README itself does not restate the terms. Anyone planning to reuse the hardware design or the firmware commercially should read that file rather than assume a familiar open source grant. The project's open source claim about the hardware and software is stated in the README, but the licence text is the authoritative source.

One more practical detail: the README points to a T-Deck option, a small T-Deck device on which Tulip CC can be installed directly, with details on the T-Deck page of the repository.

Editorial conclusion

Tulip CC fits people who want to write Python that makes sound or pictures on a device with no operating system between them and the hardware, and it does not fit people who need general purpose compute, since 2MB of RAM is available to MicroPython on an 8.5MB part. Verify first that you can obtain a device or use the web version at tulip.computer/run, that the AMY engine and LVGL bindings build for your target, and that you read the LICENSE file, since the licence on this repository is a custom one that GitHub cannot classify.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. shorepine/tulipcc on GitHub