🎛️ CrossPad S3

An ultra-compact, open-source, hackable sampler — a platform for building your own beat machine.

Build it yourself. Play it anywhere. Modify anytime.

ESP32-S3 · 16 velocity-sensitive pads · Touch screen · WiFi + BLE · 2000 mAh battery · SD card · Stereo line out · No soldering

_{The same code runs on real hardware, in a full desktop simulator, and in your browser.}

No hardware yet? No problem. Open play.crosspad.app in your browser and play CrossPad right away. The web app runs the same UI and app logic as the real device — pads, launcher, synth engine, and all.

_{▶ play.crosspad.app — CrossPad in your browser}

CrossPad isn't another closed box with a logo on it. It's an open platform for programming your own beat machine — designed for two crowds that usually have to choose sides:

• 🎧 Producers & beatmakers who want a portable, expressive sampler they can take anywhere and actually perform with.
• 🔧 Tinkerers & makers who want hardware they can open, program, modify, and extend — firmware, schematics, everything.

CrossPad ships as a ready-to-play instrument and as a hackable dev platform. Same device, your choice.

• 🎒 Take it anywhere. Built-in 2000 mAh battery, compact body, stereo line out — your studio fits in your pocket.
• 🎹 Play it. 16 velocity-sensitive RGB pads, rotary encoder, and a touchscreen color LCD with an animated LVGL UI.
• 🔊 Hear it. Built-in sampler plus FM synth, mixer, and effects chain. SD card for your sounds, stereo line out with independent mixing.
• 🔌 Connect it everywhere. Class-compliant MIDI over USB, BLE, and UART — plus WiFi for network features. No drivers, no dongles.
• 🧩 Extend it. Modular app system — drop in a new app (sequencer, sampler, piano…) without touching the core. Write apps in C++ and they run on both real hardware and the simulator.
• 🔨 Build it yourself. Engineered for DIY assembly — no soldering required. Components chosen to stay accessible and swappable.
• 💻 Develop anywhere. A full PC simulator with feature parity — build and test apps in seconds, no hardware needed.
• 🤖 Build it with Claude. A dedicated MCP server gives Claude Code 17 tools to build, test, screenshot, inject input, search code, tweak settings, and inspect runtime state.
• 🌍 Fully open. PCB to pixel. Schematics, firmware, GUI, tooling — all public, all hackable. The components were picked so you can actually rework and remix the design.

 

                   ┌─────────────────┐     ┌──────────────────┐
                   │  crosspad-gui   │     │  crosspad-core   │
                   │   (LVGL UI)     │     │  (business logic)│
                   └────────┬────────┘     └────────┬─────────┘
                            │                       │
      ┌─────────────────────┼───────────┬───────────┴─────────┐
      │                     │           │                     │
┌─────▼─────────┐  ┌────────▼────────────────┐  ┌─────────────▼─────┐
│  crosspad-pc  │  │ ESP32-S3 / platform-idf │  │  CrossPad_STM32   │
│ (SDL2 + MSVC) │  │  (Arduino / ESP-IDF)    │  │  (pad scanning,   │
│  PC simulator │  │     main firmware       │  │  LED + encoder)   │
└───────────────┘  └─────────────────────────┘  └───────────────────┘

Write once, run everywhere. Apps implement IApp. Platform repos provide thin implementations of hardware interfaces (IClock, IMidiOutput, ILedStrip, IAudioOutput, ISynthEngine). Business logic never knows what chip it's running on.

CrossPad lives across several repos, each with a single clear responsibility.

The simulator runs the exact same GUI and app code as the real device. No hardware needed.

Requirements: Git, CMake, Ninja, vcpkg, SDL2, Visual Studio 2022 (Windows) or clang/gcc (macOS/Linux)

# Clone with submodules
git clone --recursive https://github.com/CrossPad/crosspad-pc.git
cd crosspad-pc

# Install SDL2 via vcpkg
vcpkg install sdl2:x64-windows   # Windows
# or: brew install sdl2          # macOS
# or: apt install libsdl2-dev    # Linux

# Build
cmake -B build -G Ninja \
  -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake \
  -DCMAKE_BUILD_TYPE=Debug
cmake --build build

# Run
bin/main.exe   # Windows
bin/main       # macOS / Linux

The simulator window shows the full device: LCD, 4×4 pad grid, rotary encoder, and audio device selection.

git clone --recursive https://github.com/CrossPad/ESP32-S3.git
cd ESP32-S3
pio run              # build
pio run -t upload    # flash via USB

There's also a native ESP-IDF variant in platform-idf for those who prefer the ESP-IDF component system directly.

Give Claude Code full control over the build/test/run cycle:

git clone https://github.com/CrossPad/crosspad-mcp.git
cd crosspad-mcp
npm install && npm run build

Add to .claude/settings.local.json:

{
  "mcpServers": {
    "crosspad": {
      "command": "node",
      "args": ["/path/to/crosspad-mcp/dist/index.js"]
    }
  }
}

Then just ask Claude: "Build and run the simulator, take a screenshot, press pad 5" — it just works. Scaffold a new app, run UI tests, inspect live state, iterate on pixel-level details — all from a single conversation.

• PadManager is the single source of truth for pad state, note mapping, and LED coordination. All pad events flow through PadManager, never directly to apps.
• Platform capabilities are runtime bitflags (hasCapability(Capability::Midi)), not compile-time #ifdef. Apps query what's available instead of null-checking pointers.
• Settings use IKeyValueStore abstraction (NVS on ESP32, filesystem on PC). The settings UI is 100% shared in crosspad-gui.
• App lifecycle follows start / pause / resume / destroy. Apps register via static AppRegistrar constructors — no central list to maintain.
• Event-driven architecture via IEventBus. Pad presses, MIDI, encoder events are dispatched to subscribers. PC uses synchronous dispatch; ESP32 uses FreeRTOS queues.

CrossPad is designed so you can contribute without reading the entire codebase:

• Add an app → use crosspad_scaffold_app (MCP) or copy src/apps/ml_piano/ as a template
• Add a platform → implement the interfaces in crosspad-core/include/crosspad/platform/
• Add UI components → drop widgets into crosspad-gui, they'll work on every platform

See crosspad-pc/CLAUDE.md for detailed architecture documentation.

CrossPad was born from inside the scene it serves: built by musicians and engineers who wanted a controller designed around how finger drummers actually perform, practice, and share. Every layer of the device — from pad response to app structure — is shaped by players and builders, not spec sheets.

Steve Nash Fingerdrummer / Performer / Program Founder World Champion fingerdrummer and creative technologist. Founder of the CrossPad project, combining music, design, and open technology to empower creators around the world.

Marcel Licence Programmer / Audio Systems Developer Software engineer specializing in embedded audio and real-time DSP. Brings CrossPad's sound engine to life with precision, efficiency, and an open-source mindset.

Mateusz Czarnecki Hardware Designer Electronics designer and prototyping expert responsible for CrossPad's hardware architecture. Focused on compact design, intuitive layout, and seamless integration between music and technology.

Got ideas, feedback, or something you built with CrossPad? Reach out on Instagram or open an issue on any repo — the community is the reason this project exists.

Open source. Schematics, firmware, PC tools, documentation — all in the open.

A music controller you can't modify isn't yours.