Speaker amp

BPI AMP Platform

The BPI AMP Platform is an autonomous, agentic platform for audio streaming, loudspeaker tuning and digital signal processing (DSP). It is an open hardware and software stack for building and tuning custom active loudspeakers, and its software is developed, tested and deployed by a team of AI agents working under the direction of a person.

Each loudspeaker contains a BananaPi BPI-CM4 compute module on two purpose-built boards. The speaker receives music over the network, applies its own tuning in real time, and drives a woofer and a tweeter through two MAX98397 class-D amplifiers. Two speakers form a stereo pair, tuned together from a single desktop application.

Autonomous development

The platform is built by specialised AI agents, each responsible for one part of the stack: the audio plugins, the speaker's audio engine, the controller application, the board software, and the pictures of the project. A person sets the goal and approves the result. An orchestrator agent plans the work, runs the specialists in parallel, merges their changes and has a reviewer agent read them; a failed test or a review comment goes back to the agent that made the change. Every change is tested on two virtual speakers running on one computer before it is published, and again by continuous integration. A board operations agent installs the result on the real speakers and checks them. Safeguards apply throughout: no private data enters the repository, nothing reaches the main branch without review, and a lab lock keeps the agents away from the boards while they are on the bench. The agents, their rules and their tools are described in CLAUDE.md and docs/autonomous-development.md.

Overview

Music is played as usual, from a computer or a phone; the speakers take care of the rest.

• Network streaming. Snapcast streams the music to both speakers in sync. AirPlay is also supported, through shairport-sync.
• Processing in each speaker. Each speaker processes its own channel. Its audio engine, speakerd, runs a chain of plugins: a correction filter, a crossover that divides the signal between the woofer and the tweeter, and a loudness contour. A speaker keeps playing from the settings stored on it, with no network or controller connected.
• Tuning from a computer. The controller application works like a familiar plugin host: plugins are added, connected and adjusted in their own editors, and both speakers follow within milliseconds. The settings are kept on the speakers, not in the application. The ampd service on the left speaker acts as the hub that keeps the pair in step; the right speaker applies what the hub sends. Level meters are read directly from each speaker.
• Filters from measurements. A set of Python tools measures each driver and designs the crossover and correction filters, which are then built into the plugins.

Inside a speaker

Each speaker runs a layered stack: the platform's applications and PipeWire in user space, the Linux audio drivers in the kernel, and the hardware beneath them.

The diagrams on this page are generated from docs/diagrams/.

Software modules

The controller, ampd and speakerd communicate through the protocol described in docs/protocol.md. The overall design is described in docs/remote-plugin-host.md.

Tuning tool: driver responses, the crossover sum and the corrected output, with every filter parameter adjustable live.	The loudness plugin in the controller: the plugin's own editor, acting as a remote control for both speakers.

Project status

The first three steps of the roadmap are complete and tested: the plugins in their three variants, the speakerd audio engine, and the controller with the hub. Every test run checks them against a pair of virtual speakers. On 1 November 2026 the platform was first installed on a real board, which now starts speakerd at boot and plays the music Snapcast streams to it. Running ampd and the controller on real boards is the next stage of that installation. Step 4 of the roadmap (oscilloscope data, a catalogue of the plugins on each speaker, and several controllers at once) is next. tools/roadmap.py reports the current state.

Hardware

The platform uses two boards joined by a board-to-board connector: a base board that carries the BPI-CM4 module, with a USB-C port and a debug serial port, and a speaker amp board with the two MAX98397 amplifiers, a boost converter for their supply and a 5 V regulator for the rest of the system. The KiCad projects and their details are in hardware/.

The picture alternates between a render of the KiCad projects (hardware/render/) and a photograph of the boards as built (all.jpeg).

Firmware

The board runs Armbian Linux with this repository's device tree, kernel configuration and amplifier drivers, and PipeWire as its audio server. firmware/setup.sh installs the audio software of a speaker, either from the development computer or on the board itself. The bring-up procedure and the installers are described in firmware/.

Development

All development and testing, apart from work on the boards themselves, takes place on a Linux x86_64 computer with no board attached. Only Podman and git are required: the builds and the tests run in a development container with the same PipeWire version as the boards.

git clone --recurse-submodules https://github.com/AMuszkat/bpi_amp_platform
cd bpi_amp_platform
tools/test.sh all          # the complete test suite
tools/test.sh changed      # while working: the checks that cover the files changed
tools/build.sh loudness    # build one plugin or application into build/
tools/container.sh         # open a shell in the development container

The first run builds the container image and the JUCE framework, which takes a few minutes. A focused check then takes between a few seconds and two minutes, and the complete suite about two minutes. For a board, tools/build.sh speakerd aarch64 cross-compiles into build/aarch64/, and firmware/setup.sh --mode target-remote installs the result. Run tools/test.sh all before installing on a board: nothing enforces it.

The Python measurement and tuning tools have their own quick start in dsp/README.md. The development process, including the test levels, the development agents and continuous integration, is described in CLAUDE.md and docs/autonomous-development.md.

Repository layout

License

The software under dsp/ is free software, licensed under the GNU Affero General Public License v3.0; see dsp/LICENSE.