DRAFT · SPECULATIVE

Glass Snipler: Device Specification

Version 0.0.1-draft · Status: speculative draft · Updated 2026-11-08

Speculative draft. No Pop Boll hardware has shipped, and nothing on this page has been built or validated on hardware. Dimensions, key maps and protocols will change without notice, and nothing here is an offer, a commitment or a promise of compatibility. We would love to hear about partnership, OEM and dev-kit ideas: use the contact form on this site.

The Glass Snipler is the first device in the PWHAMSS family: a glass-topped slab you play, type and cut on, with the Pop Boll's band listening to everything you do. Where the Boll writes songs by itself, the Glass Snipler is a place where a person and the band work on the same material. This page describes the design for people who want to build software for it, or simulate it, before any hardware exists. The overview page introduces the wider Pop Boll ecosystem.

1. What it is#

The Glass Snipler is a slab about 12 × 8 inches (estimate) with a touch strip called the Workshop across the top, four knobs, a touch pad over a matrix of lights, four mode diamonds, 48 transparent keys over a screen, and six tall side keys. It runs Bollawax, the same song factory that runs inside the Pop Boll, so the sixteen virtual musicians, the seven judges and the licensed corpora are all present. What is new is the person at the keys.

Everything you make on the Glass Snipler is a sniplet: a piece of MIDI with a length in bars, a tempo, a key and a handful of settings. Sniplets come in four musical kinds (a song-length stem, a riff, a loop, a beat) plus a macro kind that records what you did with the keys. You pull sniplets out of songs, cut them on the Workshop, play them with the keys and file them in your library.

The band you jam with is the Boll's band. While you work, the musicians listen to what you cue up, and when a sniplet is finished and public they may steal it into their own riff books, exactly as they trade riffs with each other today, and may gift riffs back. So the Glass Snipler closes a loop that the Boll alone cannot: songs from the corpora become sniplets, sniplets become yours, and your sniplets become the band's. This is the Pop Boll flywheel with a person inside it.

The build order is deliberate. First a web simulator at popboll.com/pwhamss that runs the real engine on real corpus material; then sound in the browser; then audio stems; then the band's trades; then hardware. The simulator and the device share one state machine, so everything on this page is being built now, in software, and the slab is the last renderer of it.

2. Layout#

Layout A is the working layout. An earlier layout B (the Workshop wrapping the pad, knobs on the edges, a 2 × 2 mode cluster) is kept as the alternative and may come back if layout A fails in the hand.

+------------------------------------------------------------------+
|           optional external LCD (attached above the slab)        |
+------------------------------------------------------------------+
+------------------------------------------------------------------+
|                    WORKSHOP   12 x 3.5 in touch                  |
|   popboard lanes . bar ruler . loop window . transport . band    |
+------------------------------------------------------------------+
  (S) (M)     <K> <P>   [ pad over 16 x 26 RGB matrix ]   <S> <A>     (L) (H)
+-----+  +---+---+---+---+---+---+---+---+---+---+---+---+  +-----+
| ESC |  | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | + | = |  |  ?  |
+-----+  +---+---+---+---+---+---+---+---+---+---+---+---+  +-----+
| BKSP|  |MAC| Q | W | E | R | T | Y | U | I | O | P | / |  | ENT |
+-----+  +---+---+---+---+---+---+---+---+---+---+---+---+  +-----+
| UNDO|  |POP| A | S | D | F | G | H | J | K | L | ; | ' |  | TAB |
+-----+  +---+---+---+---+---+---+---+---+---+---+---+---+  +-----+
         |PUT| Z | X | C | V |SPC|SPC| B | N | M | , | . |
         +---+---+---+---+---+---+---+---+---+---+---+---+
              48 transparent pressure keys over an LCD underlay

Key geometry: 1u = 0.66 inch with a 0.10 inch gap (estimate). The side keys are 2u tall. The slab is as thick as its base layer needs to be: battery, Raspberry Pi and Uno Q (see Inside).

3. Modes#

The four diamonds choose a mode. The mode decides what the 48 keys, the knobs and the side keys do, and the LCD underlay redraws every key to match.

Keys are numbered 0 to 47, row-major: key = row × 12 + column, row 0 at the top and column 0 at the left.

3.1 K mode: the keyboard#

Layer 0 in K mode is a QWERTY keyboard with three Pop Boll keys down the left column and two SPACE keys under the thumbs.

SPACE is transport play and stop in every mode. MACRO-REC starts and stops recording a macro sniplet. SNIP POP lifts a sniplet out of whatever is selected; SNIP PUT drops the clipboard onto the popboard. Typing from a real keyboard in the simulator arrives as text events and lands in the same place.

3.2 P mode: play#

Pressure is velocity on note-on and aftertouch while a key is held.

3.3 S mode: the library#

A column is a slot on the current page, twelve per page, and one page index is shared by all four rows. Empty slots show as empty cards. Selecting a card and pressing ENT opens its guts (the note grid) in the Workshop and switches to P mode. Knob L turns pages when nothing is selected.

3.4 A mode: songs and stems#

In v0.0.1 the vocals row shows the song's lead-melody transcription when it has one, otherwise an empty card. You may hold up to four stem keys at once; each is marked held with an order badge. Releasing them together, or pressing SNIP PUT while holding, puts them on the popboard.

3.5 Side keys#

Backfork and forefork are undo and redo seen as a tree: backfork steps back to the previous state of the board, forefork steps forward along the branch you were on. Outside K mode, layer + side 2 and side 5 are previous and next page, and layer + side 1 and side 4 are undo and redo.

4. Layers and keymaps#

The Glass Snipler has a keymap system built in from the start, in the spirit of open keyboard firmware such as QMK.

Layer 0 is the default keymap: the K-mode QWERTY of §3.1 plus its shift level, and the P, S and A maps of §3.2 to §3.4. It is always present and cannot be deleted.

The layer key is both SPACE keys held together, within 150 ms of each other (estimate). It has exactly two gestures:

• Layer + short press of a key (under 600 ms): that key's shift or alternate function, or its shifted character. In K mode that is the second row of the table in §3.1.
• Layer + hold of a key (about 2 seconds): switch to that key's layer. Layer + 1 held goes to layer 1; layer + Q held goes to layer Q; layer + 0 held returns to layer 0.

There are 35 custom layers, one for each letter A to Z and each digit 1 to 9. In every layer each of the 48 keys may hold a command, a character or a macro, and each of the four knobs may be bound to a parameter. A key with no binding in the current layer falls through to layer 0, the way a transparent key does in QMK. Layers apply to every mode, so a layer may remap the P-mode pads or the S-mode rows as well as the typing keys.

Macros are sniplets of kind macro: key presses, side keys and knob moves recorded by MACRO-REC against the transport, replayable on any board. A macro bound to a key in a layer plays when that key is pressed.

Pressure curves are named per layer, so a drum layer can have a hard actuation and a typing layer a soft one. Outside K mode the layer modifier also lives on the side keys (LAYER DN and LAYER UP) because the SPACE keys are busy playing.

5. Sniplets#

A sniplet is the unit of everything on the device. The word also names the longest kind.

Every sniplet carries these fields:

Stamps. Every sniplet derived from a corpus song carries that song's stamp: a 2 × 2 block of four pictograms drawn from a house set of 64, minted deterministically from the song id and the corpus seed. The pictograms are our own monochrome glyphs rather than emoji, so they render identically on the key LCD, the LED matrix and the web. Stems and derived sniplets of one song share its stamp, so you can see at a glance which pieces on the board came from the same place.

Easy mode is on by default. It chops or truncates material on the fly so that everything fits the board: lengths are multiples of 2 bars, with 1-bar loops allowed, and a longer piece is cut at the loop window. With easy mode off, nothing is quantised to even bars; the device must then make sniplet length easy to manage directly, and odd lengths and polyrhythms become possible. Easy mode is a convenience, not a format: a sniplet's bars field is whatever it is, and only the fitting rules change.

Identity. A sniplet's id is a fingerprint of its content: sn_ followed by 12 hex characters derived from its kind, role, bars, beats per bar, tonic, mode and notes. Filing the same notes twice yields one sniplet, and any later library can give back the exact notes a song or a macro referred to. This is the same rule the band's riff books use for riffs.

6. The Workshop#

The Workshop is the touch strip across the top of the slab, visible in every mode. What is on it is the popboard: a set of lanes, each holding one sniplet, under a single bar ruler.

Transport. One bar ruler runs across every lane. A loop window sits on it and you drag either end with a finger. SPACE plays and stops; layer + SPACE records. The board runs at the device tempo; each lane's sniplet is locked (stretched to the board) or unlocked (soloing it pulls the board to its native tempo). Ticks from the renderer advance the playhead; the Snipler never reads a clock of its own.

Fitting rules. Sniplets of different lengths audition together. A shorter sniplet loops if its AGI flag says looping is a good idea, otherwise it plays once at its entry bar. A longer sniplet is cut at the loop window. With easy mode on, lengths are also brought to the nearest multiple of 2 bars. Every lane shows how it was fitted: loop, one-shot or cut, with its repeat count and entry bar.

SNIP POP and SNIP PUT. POP on a selection makes a new sniplet of exactly what is heard inside the loop window: the fitted, stretched, grooved result, not the sources. PUT drops the clipboard onto the board at the playhead, snapped to the grid and transposed to the board's key. Holding SNIP POP opens a chooser so the popped material can be filed as a different kind (a beat from a loop, a riff from a stem).

Cue. A tap on a lane cues it; a long press solos it. The cue stream is what you are working on, as opposed to what the band is playing. A single crossfader-style meter in the transport shows cue against band, and the M knob rides it when M is bound to mix. By default the cue replaces the band on the main output until released. Headphone cue is a setting.

The band listening. The band listens to the cue stream. A musician who likes a finished, public sniplet may steal it: a riff-book trade from your library into that musician's personal library, non-destructive, logged, and shown on the device page the way trades between musicians are shown today. The Workshop's band panel lists who is listening and what they took. In v0.0.1 the library records these events and the frame shows them; the musicians' own trading code is wired in later.

Gifts back. Musicians may also gift riffs into your library. A gift arrives as a new, unfinished sniplet with the musician's name on it, and you decide whether to keep it.

7. Pipeline#

Material enters the Glass Snipler from corpora, from your own playing and from your own recordings.

1. Browse official corpora. Corpora are licensed song collections published through bollawax.org. In A mode you page through the songs of the corpora on the device, twelve at a time.
2. Pull songs. A song's derived MIDI (its morpus) is already split into role stems: drums, bass, chords, lead, pad, arp, fx. A mode's rows 1 to 3 present those stems as drums, bass and music; stem MIDI lands on the popboard as song-length sniplets.
3. Stems minted server side. Audio stem separation and the per-stem MIDI transcription are done once per song, server side, when a corpus is built, and written into the morpus (a stems/ folder) as corpus assets. Devices download them like any other corpus asset. The alternative, separating every song on the device, costs about fifteen CPU-minutes per song on a server (estimate) and far more on a small board.
4. User recordings. Material that never went through the cloud, such as your own recordings or local files, is separated on the device's Raspberry Pi, in the background and more slowly.
5. Cut, play, file. You cut on the Workshop, play in P mode, file in S mode. Finished, public sniplets become stealable.

Nothing in this pipeline creates corpora, and the device plays corpus audio only as the licence of that corpus allows; the corpus terms on bollawax.org are unchanged by the Glass Snipler.

8. Sound#

v0.0.1: one soundfont. Every sniplet plays through one General MIDI soundfont with a per-sniplet program. The intended default is a synth-rock, arcade-pop bank, with a standard GM bank as the known-quantity fallback. On the Raspberry Pi the player is FluidSynth. In the browser the plan is a small SF2 player, or per-program sample banks rendered once by FluidSynth. A later system screen lists soundfonts and makes one active at a time.

The three house synths. Alongside the soundfont the device has three synthesizers of its own:

Each synth is written twice: as AudioWorklet DSP in JavaScript for the simulator, and as a numpy twin for offline renders on the server and the Pi. Both are pinned by the same test vectors, so the same notes produce the same sound to within the tests' tolerance. This is the pattern the Boll's existing FM renderer already follows.

Later: audio sniplets. Audio playback of stems, and stacks that pair an audio stem with its MIDI, are the next increment after sound in the browser. Nothing in the sniplet format forbids them; the frame already carries a per-lane preview that can be either.

9. Inside#

The Pi is a Bolltridge in the sense of the Bolltridge device class: a Linux computer running exactly one signed image, speaking bollardeck Part C to the Boll core. In the slab that link is internal rather than a dock connector, but the software contract is the same, so the Snipler services could in principle run in a separate Bolltridge under an ordinary Boll.

Updates. The bollawax-snipler image is published like the Boll's own image: one release script, one version number, a second image name. The device fetches latest.json, verifies the image's hash and size, boots it, keeps the previous image and rolls back by itself if the new one fails its health check.

Offline first. Everything the device needs runs on the device. Corpora, stems and the soundfont are cached; the library is local SQLite; the band works without a network. When online, the device fetches new corpora and, later, syncs the person's library through HAMS so the same sniplets follow them to any device they use. HAMS sync of the user library is not in v0.0.1.

10. Architecture: one state machine, two renderers#

The architectural bet of the whole build is that the device is one pure state machine with several renderers.

events (keys, side keys, knobs, pad, touch, ticks)        frame (JSON, one per change or tick)
browser / slab  ---------------------------------->  Snipler  ------------------------------>  renderer
                                                     pure Python, no I/O, no clock,
                                                     no randomness outside a seeded rng
                                                        |
                                                        v
                                        user library (SQLite) . board . keymap

• Every input is an event: a JSON object with a type and a t_ms timestamp on the renderer's monotonic clock. Key down, key up and key pressure (0 to 1), side key down and up, mode, knob delta in detents, pad down, move and up (0 to 1 in each axis), Workshop touch, tick, and text. Unknown events are ignored.
• Every output is a frame: one JSON object with the mode, the layer, a status line, 48 key cards, 6 side cards, 4 knob states, the Workshop (view, tempo, key, transport, lanes, guts, picker, text, band), the 16 × 26 matrix as a hex string, the selection, the held keys and an optional toast. A card is a glyph, a sub-legend, a label, a tint, two 0-to-1 field values, a state and optional stamp and marks, and a renderer draws a card from those fields alone.
• Event summary. The frame is the whole display state, so a renderer never needs to remember the previous one. Nothing a renderer shows may be invented locally; if it is not in the frame it is not on the device.
• Determinism. Time enters only through t_ms. Randomness enters only through a random source seeded from the user's seed, the sniplet ids involved and t_ms, and the seed is recorded in whatever it produced. A frame is therefore a pure function of the event history, which is what makes the browser canvas and the slab's screens show the same thing, and what makes the whole device testable from a list of events.

The Boll's LED ring already works this way: the device code and the browser code draw byte-identical frames and are parity-tested. The Glass Snipler extends the pattern to a whole device. The PWHAMSS page carries the developer-facing summary of the contract with examples.

11. Status and open items#

Nothing on this page has been built in hardware. The state of the design on the date above:

Not decided:

• Easy mode off. How sniplet length is edited directly, and how odd lengths and polyrhythms are shown on the Workshop, has not been designed.
• The six side keys' switches. The 48 keys are Hall-effect and pressure sensitive; the side keys are still the earlier default of a clear low-profile linear switch until decided.
• Default knob bindings per mode. The knobs are context dependent; which parameter each one takes in each mode by default is the builder's call for now and will be written down here when it settles.
• Guild (Family) derivation. How a derived family is computed for a sniplet that the user has not labelled.
• Stealing unfinished work. The setting exists in the design; its default is off.
• Headphone cue versus main-out cue as the default on hardware.
• Audio sniplets and audio-plus-MIDI stacks: the sniplet format leaves room for them; nothing is specified.
• Production compute module and carrier, and whether the Snipler services could ship as a stand-alone Bolltridge for an ordinary Boll.

Each later version of this page will carry a change log below this section.

12. Licence#

Proposed, and not yet final, as for the other pages on this site: the specification text under CC BY 4.0, and code under Apache-2.0. These cover the document, not the project's names and logos.