SoloMod Synth: A Battery-Powered, Modular Digital Synthesizer for the Solo Performer

SoloMod is an ambitious personal project to create a portable, battery-powered digital synthesizer that combines the flexibility of modular synthesis with the convenience of a standalone instrument. The core idea is to replicate the experience of a Eurorack system in a self-contained unit, using a Raspberry Pi as the brain and a custom PCB for audio I/O, CV/gate generation, and power management. All sound generation and signal routing happen in software, controlled through a 7-inch touchscreen that displays a virtual patch bay. Physical knobs and sliders provide tactile control over parameters, with real-time feedback on the screen. The entire system is designed to be built by one person over several months, with open-source documentation and a focus on hackability. The synth will be battery-powered (Li-ion, 4+ hours), and the 3D-printed case will include a built-in speaker and headphone output. It aims to be a live performance tool and a learning platform for digital audio programming.

Modular synthesizers are powerful but expensive, bulky, and require multiple modules to get started. Software synthesizers on laptops lack tactile immediacy and are not designed for live, knob-driven performance. There's a gap for an affordable, portable, hands-on digital synth that one person can build and customize. SoloMod scratches that itch: it offers the patching freedom of a modular system without the rack, the portability of a groovebox, and the deep hackability of open-source hardware and software.

• Build a fully functional prototype with 4-voice polyphony and 8 virtual modules (oscillator, filter, envelope, LFO, VCA, mixer, delay, reverb).
• Achieve sub-10ms audio latency on a Raspberry Pi 4.
• Design a custom PCB that integrates audio codec (PCM5102), CV DACs (MCP4725), ADC for control inputs (MCP3008), and battery management.
• Develop a touchscreen patching interface where you drag virtual cables to connect modules.
• Ensure battery life of at least 4 hours under typical use.
• Release complete build instructions, KiCad files, and source code as open-source.

• Not striving for audiophile-grade audio quality (addressing noise floor but not obsessing over THD).
• No physical module swapping; all modules are software-defined and selected via screen.
• No polyphony beyond 4 voices to keep CPU manageable.
• No built-in effects beyond a basic delay and reverb (can be expanded later).
• No mass production; this is a one-off build for personal use and learning.

Hardware:

• Raspberry Pi 4 (2GB) with 7-inch official touchscreen
• Custom PCB (KiCad) with audio codec PCM5102, DAC MCP4725 (x2 for CV), ADC MCP3008 (for knob/slider inputs)
• 20x 10kΩ potentiometers, 10x sliders, 8x push buttons
• 4x 18650 Li-ion cells with BMS and 5V boost converter
• 3D printed case (PLA) with ventilation
• Built-in 3W speaker and 3.5mm headphone jack

Software:

• Raspberry Pi OS Lite (headless)
• Audio engine: Pure Data (or custom C++ using JUCE) for real-time synthesis
• Touchscreen UI: Python with Pygame or Kivy for patching interface
• Control: GPIO with I2C for ADC/DAC communication

The system is structured around a Raspberry Pi 4 running a real-time audio engine. The touchscreen provides the user interface for patching and module selection. Physical controls (potentiometers, sliders) are read via I2C ADC (MCP3008) and their values are mapped to parameters in the audio engine. CV output is generated via I2C DACs (MCP4725) for controlling external gear. The audio codec (PCM5102) outputs stereo audio to a built-in speaker or headphone jack. Power is provided by a 4-cell Li-ion battery pack regulated to 5V. The software architecture layers: (1) a low-level audio driver (via ALSA) with a custom real-time loop; (2) a module graph that processes samples in blocks; (3) a patch parser that connects modules based on the touchscreen state; (4) a GUI running on a separate thread to handle touch events. Patching is done by selecting a module's output jack and dragging to an input jack on the screen; the connection is stored as a pair of node IDs. Parameters are modulated by the physical controls or by LFOs and envelopes within the module graph. The entire system is designed to be modular in software, allowing new modules to be added as code without hardware changes.

• Real-time audio latency on Raspberry Pi may exceed acceptable limits; need to optimize code and possibly use a real-time kernel.
• Battery management: ensuring stable 5V under peak CPU load; risk of brownouts.
• Touchscreen usability in bright light (outdoor performances) may be poor; need to consider matte screen protector or alternative.
• Custom PCB manufacturing errors could waste time and money; careful design and multiple revisions expected.
• Solo development: scope creep and burnout; must prioritize core functionality.

• Which audio engine is best? Pure Data is easier to prototype, but a custom C++ engine (using JUCE or PortAudio) offers lower latency and more control. Should I start with PD and later rewrite?
• Should the synth include MIDI over USB? It would make it more useful with external controllers, but adds complexity.
• How to store and recall patches? Simple JSON file with module settings and connections.
• Should the battery be removable? For safety and convenience, but adds mechanical complexity.

Life got busy with a full-time job, and the cost of materials (Pi, screen, custom PCB) was higher than anticipated. The plan is still on the shelf, waiting for a stretch of free time and budget.

This project is as much about learning embedded Linux, audio programming, and PCB design as it is about the synth itself. It's intentionally scoped for a single person to complete, with each milestone achievable in a weekend or evening. The open-source aspect means others could benefit even if I never finish.