potatoslicer

Music Sequencer.
Multi-Engine Synthesis.

A tracker-style sequencer on an audio engine that ships twice — in Python and in C++. 6 sound engines: Cadenza, Famiwave, SuperGaussKit, NightFM, Meridian, WavSampler. Procedural audio from JSON.

get started listen
Potatoslicer sequencer interface
6
sound engines
36
factory presets
MIDI
import / export / live
2
engines — python + c++

Up and Running

bash + 
$ pip install potatoslicer
$ potatoslicer
python 3.11+ pygame-ce numpy sounddevice json

Everything You Need

synthesis. sequencing. sampling. export.

Multi-Engine Synthesis

Cadenza, Famiwave, SuperGaussKit, NightFM, Meridian, WavSampler — mixable in a single song. Each instrument picks its engine.

more

Dual Sequencers

Tracker pattern grid + FL Studio-style step sequencer. Per-channel solo/mute, swing quantize, crosshair selection synced between both views.

more

Full MIDI

Import MIDI files into the tracker. Export as Standard MIDI. Connect external controllers and synths with real-time I/O.

more

6 Engines, One Song

Each instrument can use a different synthesis engine. Mix Famiwave triangle bass with NightFM leads and SuperGaussKit echo pads in the same track.

  • - Cadenza — pulse, triangle, saw, noise with vibrato and detune
  • - Famiwave — hardware-accurate 4-bit quantization and duty cycles
  • - SuperGaussKit — BRR quantization, gaussian interpolation, echo/delay
  • - NightFM — 4-operator FM with 8 algorithms and feedback
  • - Meridian — band-limited virtual analog, unison stack, real stereo width
  • - WAV sampler — load your own samples with pitch shifting and loop modes
instrument editor

Dual Sequencer Views

Classic tracker grid + step sequencer channel rack. Both views edit the same data with crosshair selection sync.

  • - pattern grid with beat/bar highlighting, sharp and flat note entry
  • - step sequencer — click cells to toggle, horizontal scroll for long patterns
  • - per-channel quantize, fill, clear, and swing (50-75%)
  • - collapsible panels: songs, instruments, piano, chords, step rack
  • - crosshair selection — click in one view, see it in the other
pattern grid

NightFM Synthesis

4-operator FM synthesis with 8 connection algorithms, per-operator ADSR, frequency multipliers, and feedback.

  • - 8 algorithms from serial harmonics to full additive
  • - per-operator frequency multiplier and detune
  • - independent ADSR per operator or shared global envelope
  • - draggable floating editor — open multiple instruments at once
nightfm synthesis

Sampling

Load audio files or record from your microphone. Pitch-shift across the keyboard with repitch or granular timelock modes.

  • - WAV files with automatic pitch detection
  • - loop modes: one-shot, loop, ping-pong
  • - repitch (speed follows pitch) or timelock (granular)
  • - record from microphone with live level metering
wav sampler

Export

Render songs to WAV for sharing or export as Standard MIDI to bring compositions into any DAW.

  • - offline WAV rendering at sample-accurate timing
  • - MIDI export with one track per instrument and GM mapping
  • - MIDI import converts files to tracker patterns automatically
  • - real-time MIDI output to external synths and DAWs
wav and midi export

Hear It

procedural audio from json. no samples.

Chrome
0:00
0:00

more demos →

Two Engines, One Format

the same songs play from python and from c++. 13 reference renders keep them honest.

Client Library

Python

Play songs from a Python program, or render them to audio offline.

  • · Opens an audio device for you, with a threaded ring buffer for glitch-free playback
  • · Renders offline to NumPy arrays when you want the samples rather than the sound
  • · The reference implementation of the song format — it produces the golden renders
  • · Dependencies: numpy and sounddevice
pip install potatoslicer-client

Core Engine

C++

Embed the same engine in a game or a native tool, with no audio backend imposed on you.

  • · Device-agnostic: renders into a buffer you supply and never opens an audio device itself
  • · Render() is real-time safe — a test replaces the global allocator and fails if it stops being true
  • · Built to be called straight from an SDL audio callback
  • · Only dependency is nlohmann/json, header-only
Not yet published

Neither engine is generated from the other. They are held together by the song-format spec and by shared golden renders both must reproduce sample for sample — today to within 5.96e-08 against a 1e-06 tolerance.

Embed Anywhere

load a song, get audio. the api is deliberately small.

python + 
from potatoslicer.player import PotatoslicerPlayer

player = PotatoslicerPlayer()
player.start()
player.load_file("songs/chrome.json")
player.play()
player.set_volume(0.3)
player.stop()
player.shutdown()

The same song, through the C++ engine:

cpp + 
#include <potatoslicer/Engine.hpp>

potatoslicer::Engine engine(48000);
engine.LoadSongFromFile("songs/chrome.json", &error);
engine.Play();

// Real-time safe. out holds 2*numFrames floats,
// interleaved stereo, left then right.
engine.Render(out, numFrames);

Start Making Music

clone the repo and start sequencing. no audio files needed — everything is generated from code.

get started read the docs