KN-90T Toneline

Projected MSRP (1990): $179.95 (acknowledged internally as likely too high) Prototypes produced: Unknown; fewer than the Statline. No surviving unit publicly confirmed. Source: Notion — KN-90T Toneline Imported: 2026-04-26 Related: future-concepts.md, kn90s-statline.md, kn92-gridline.md, Kinoshita Electronics Consortium

The Toneline was a portable music composition and performance device targeting bedroom musicians, particularly teenagers and young adults already spending $200–400 on basic four-track cassette recorders.

Form Factor

Clamshell form factor returned but in landscape orientation — wider than the Deckline to accommodate a horizontal sequencer timeline on the display. The same Sharp 240×128 LCD panel was mounted sideways. All sixteen function keys retained, remapped to musical operations: loop definition, phrase placement, playback, note selection, voice assignment, tempo control. The numpad served double duty for pitch input (digits mapped across a selectable scale — chromatic, pentatonic, or major) and tempo/BPM entry.

Audio Subsystem

The most ambitious change: the Deckline’s Yamaha YM2149 PSG was replaced with a Yamaha YM2612 FM synthesis chip — the same chip that powered the Sega Genesis. Six FM voices plus a PCM channel. The difference in fidelity was substantial: rich, layered FM tones — electric pianos, synthetic brass, punchy bass, metallic percussion.

Internal speaker upgraded to a 40 mm driver with a small passive radiator for improved low-frequency response.
3.5 mm line-out jack added alongside the headphone output for direct connection to an external tape recorder, boombox, or amplifier.

Interaction Model

The list-processing paradigm mapped naturally to music composition:

A song is a list of patterns
A pattern is a list of sequences
A sequence is a list of notes
LAMBDA defines reusable musical phrases (a bassline, a drum pattern, a melody) insertable at any position in an arrangement
The LINK port enables two Tonelines to sync and play together over a serial cable — a portable 1988 jam session

Development Status (in fiction)

Less advanced than the Statline. The YM2612 integration was working and reportedly impressive — Edgeware’s audio programmer produced several demonstration compositions that circulated internally on cassette. However, the upgraded audio hardware, larger speaker, and landscape clamshell tooling pushed projected BOM cost beyond what the consortium could sustain at a viable consumer price point without new investment. Loop quantization and multi-deck LINK synchronization were still in development when the project was suspended.

Surviving Units (in fiction)

No Toneline prototype has been publicly confirmed to survive. The device is referenced in internal Kinoshita memos and product briefs recovered from the Edgeware founder’s papers when his estate was settled in 2011. The demonstration cassette tape of YM2612 compositions was reportedly among those papers, though its current whereabouts are unknown. Whether a working Toneline unit exists in a box in someone’s garage in Houston — where PacRim Display Technologies was headquartered — remains a matter of speculation among Deckline collectors.

Buildable feature set — Batch 8 audio research

Scope: engineering, not fiction. This section captures the concrete, buildable feature set for a modern Toneline reconstruction synthesized from the Batch 8 audio TUI research (docs/influences/inspiration/{line,cmus,upiano,waves,asak,valvefm}.md, docs/influences/effect/cava.md). The Toneline shares the KN-86 platform: Pi Zero 2 W primary processor, a 1024×600 RGB565 native framebuffer rendered via the KN-86 native renderer per ADR-0036 (per-region cell density via integer-scaled 8×8 glyphs; 128×75 = 1× cell ceiling; HALF-BLOCK 128×150 sub-pixel canvas preserved from ADR-0027; rows 1–73 cart-usable at 1× scale, Row 0 = status chrome, Row 74 = action chrome), the KEC Lisp VM (ADR-0001, ADR-0004), the Ferris Sweep split keyboard (ADR-0031), and the Pico 2 realtime-audio coprocessor (ADR-0017). It runs the music payload where the Deckline runs gameplay carts. See the parent-repo CLAUDE.md Canonical Hardware Specification for the authoritative grid/processor values.

1. The sequencer language IS KEC Lisp (headline)

The Toneline does not ship a bespoke sequencer DSL alongside a separate scripting language. There is one language: KEC Lisp, the same VM the Deckline already runs. The fiction’s framing — a song is a list of patterns, a pattern is a list of sequences, a sequence is a list of notes, LAMBDA defines a reusable phrase — is the literal runtime data model:

A phrase is a list.
A song is a list of lists.
LAMBDA (already on the Sweep left-half keymap and in the Toneline fiction) defines a reusable phrase exactly as it defines any other function.
The transform verbs are the standard list library — reverse, rotate, shuffle, append, repeat — operating on the phrase-as-data.

The reference is line (pd3v): a CLI live-coding MIDI sequencer that parses a terse text grammar into a nested note tree (phrase → parts → notes) and schedules it. line already proves the boundary KN-86 committed to in ADR-0001/0004 — an embedded language VM owns parsing and structure; the host C runtime owns scheduling and I/O. KN-86 takes the further step line stops short of: the intermediate tree is not hidden behind a private grammar — it is exposed directly as an s-expression, because the deck already ships a KEC Lisp REPL on the TERM key (ADR-0002, ADR-0016, repl.md).

Grammar to adopt for the terse text-entry mode (every token types cleanly on the Sweep’s right-half digit + punctuation cluster — . ( ) ~ - are already on the keymap):

Element	Syntax	Meaning
Note	`45` / `a3 as3 b3 c4`	space-separated note tokens (MIDI number or `a/as/b/c`+octave), quarter-note default
Subdivision	leading `.` — `45 .34 35.`	a leading `.` halves a note’s duration (subdivides it)
Chord	`(c3 e3 g3)`	parenthesized note group plays simultaneously
Arpeggio	`(c3 e3 g3) g5 e6`	bare notes after a chord = arpeggio
Velocity	`d3~.5`	`~amp` suffix sets per-note/per-chord velocity 0.0–1.0
Rest	`-`	a silent note

The line → KEC Lisp mapping (the crux):

`line` (terse)	KEC Lisp (structural)
`(c3 e3 g3) g5 e6`	`(seq (chord c3 e3 g3) g5 e6)`
`45 .34 35.`	`(seq 45 (div 34) (div 35))` — `.x` = subdivide
`d3~.5`	`(amp 0.5 d3)`
`r` (reverse)	`(reverse phrase)`
`*4` (concat 4×)	`(repeat 4 phrase)`
`s` (shuffle)	`(shuffle phrase)`
`rl` / `rr` (rotate)	`(rotate ±n phrase)`

Two front-ends, one representation. A performer types the terse line-style phrase at the prompt for speed, or opens the same phrase in nEmacs (ADR-0008) as an s-expression for structural editing. The compact grammar and the structural editor are two views over one phrase data structure — so a performer who learns the music grammar has, without noticing, learned to program the deck.

Notes-vs-control mode: line’s n/cc toggle maps to the Toneline distinguishing note phrases (drive the YM2612 FM voices) from control phrases (sweep an FM operator’s envelope, modulate tempo, automate a parameter) — same phrase engine, two phrase semantics.

2. Single-color audio visualization (cava)

Reference: cava — the canonical terminal spectrum visualizer.

Eighth-block ramp ▁▂▃▄▅▆▇█ (U+2581–2588) gives 8× sub-cell vertical resolution: a bar’s top cell is drawn with the partial eighth-block matching its fractional height, so an N-row spectrum reads as if it had 8N levels. Color is fully separable — the information channel is height + density only. Encode the eight ramp glyphs as guaranteed entries in the KN-86 Code Page bitmap font (pixel-exact on the single-phosphor grid — AMBER default per ADR-0036, WHITE / GREEN selectable; no Unicode-terminal dependency — cava’s own cava.psf precedent).
cavacore DSP/render split: build the visualizer as a pure DSP core (audio samples → bar magnitudes) cleanly separated from the grid renderer (magnitudes → glyph rows). One core feeds two thin renderers: the main-grid spectrum (rows 1–73) and a compact CIPHER-LINE level meter.
Expose the band array as a NoshAPI primitive (cava’s “raw mode” seam — the visualizer’s output is just an array of bar heights). A NoshAPI builtin returns the current spectrum band array so a Toneline cart draws its own visualizer in KEC Lisp without touching the DSP.
Input is the YM PSG/FM mix from the Pico 2 coprocessor (Toneline: YM2612 FM; Deckline: YM2149 PSG), not a system-audio loopback. The DSP and magnitude→glyph mapping are identical either way.
Animation profile: peak-hold with gravity fall-off + light temporal smoothing + auto-sensitivity (cava’s gravity-decay model, so bars decay naturally instead of snapping).

3. UI component kit (single-color)

Four reusable single-color widgets, drawn in the cart-usable rows:

Piano strip (upiano) — a horizontal keyboard band showing which notes are in the active scale and which is currently sounding. White keys = phosphor-outlined cells on black; black keys = filled phosphor blocks (██) above; the sounding note inverts (solid phosphor field); in-scale vs out-of-scale differ by fill density, not hue. The Sweep delivers real press/release events (it is a hardware keyboard, not a terminal), so live polyphony is viable on-device — the Toneline avoids the terminal-no-key-release limitation that caps upiano’s keyboard play.
Linear slider (upiano) — VOL ├────●───────┤, position-only, carried entirely by character + position. The continuous-control widget for FM parameters (operator levels, envelope rates, feedback, volume/reverb/chorus).
Rotary dial (valveFM) — ◄ ──────●──── ► or a radial box-drawing sweep, value = marker position. For parameters best dialed than typed: tempo (BPM), FM operator frequency ratio, filter cutoff, parameter sweep, arrangement scrub. Slider (linear) + dial (rotary) = both continuous-control idioms the kit needs.
Waveform-with-playhead (asak) — a centered band of block characters (▁▂▃▄▅▆▇█ above/below a center line) whose height tracks amplitude over time, with the playhead a single inverted column sweeping across. This is the time-domain view (amplitude vs time, for take review/editing) and complements cava’s frequency-domain spectrum (bars vs frequency, for live monitoring). A complete Toneline audio UI uses both.

4. Recording workflow (asak)

Reference: asak. The Toneline captures and plays back audio (its fiction adds a 3.5 mm line-out and a larger speaker for exactly this), so it needs a record path the sequencer/synth references don’t cover:

Mode-selector splash as the front door: boot into a clean Sequencer / Record / Voices / Settings menu (a rows-1–73 menu over the firmware status/action chrome), with Esc/BACK always returning home — a branded, legible entry point rather than dropping the operator into a dense sequencer cold.
Record loop: name the take → arm → live-monitor waveform during capture (real-time input level/shape + elapsed take timeline) → save → the take lands in the phrase/voice library, immediately available to drop into a sequence.

5. Shell scaffolding (cmus + waves)

The UX discipline wrapped around the phrase engine, from cmus and waves:

Numeric view-switching (1–7) — one digit, one whole working surface (sequencer/arrangement, phrase library, voice/patch editor, browser, settings). Bind to the Sweep’s right-half digit cluster (preferred over F-keys — the digits are already there). cmus’s “one key, one surface” discipline.
One-line compact transport bar — tempo (BPM), current bar/beat, play/stop state, current phrase/pattern, mute — packed into the firmware-owned Row 0 by position + fixed-width formatting (120BPM 03:12 ▶ PHR:bass-A), mirrored to the CIPHER-LINE status strip on device.
Library-vs-queue separation — the durable phrase/patch library lives on the cartridge SD; the transient performance queue (what plays next) is built and drained live. The catalog is not the playlist.
Persistent toggle-able queue panel (waves p) + undo/redo on list edits (Ctrl+Z) — keep the performance queue docked beside the sequencer (toggle on/off, don’t navigate away) so the operator builds the live set without losing the phrase being edited; undo/redo is first-class because an arrangement IS a list and every reorder/drop/swap is a list edit.
Song → Pattern → Phrase → Sequence drill-down — waves’s Artist→Album→Track browser tree, re-pointed at the Toneline’s music nesting: drill into a song to see its patterns, into a pattern to see its phrases. (Indexed/fuzzy phrase+patch search is the natural scaling layer once a cartridge holds many phrases.)

6. LINK port

line’s reason-for-existence demo is multiple instances locked to one shared clock via an Ableton-Link-style shared-beat model (derive all phrase timing from a shared beat/quantum so instances stay phase-locked, loop updates landing on bar boundaries). This is the implementation blueprint for the fiction-specified LINK port — two Tonelines syncing to jam together. Adopt the Link-style shared-beat protocol (or literally speak Ableton Link if a host-DAW bridge is ever wanted).

Scope: v0.1 vs deferred

v0.1	Deferred
KEC Lisp phrase representation (phrase = list; song = list-of-lists; `LAMBDA` phrases; `reverse`/`rotate`/`shuffle`/`append`/`repeat` transforms)	Indexed/fuzzy phrase + patch search (FTS-style) at cartridge scale
Terse `line`-style text-entry prompt over the phrase representation	nEmacs structural-edit front-end for the same phrase (ADR-0008 dependency)
cava-style eighth-block spectrum (main grid) + cavacore DSP/render split	Cart-facing NoshAPI spectrum-band primitive for cart-drawn visualizers
Numeric view-switching, Row 0 transport bar, library/queue separation	Persistent toggle-able queue panel + undo/redo on arrangement edits
Mode-selector splash; piano strip, slider, dial, waveform-with-playhead widgets	Record→monitor→save sampling loop (line-in capture into the voice library)
Notes-vs-control phrase mode toggle	LINK-port shared-beat sync (multi-instance jam) — fiction calls it still-in-development

Hardware deltas vs the existing fiction

The buildable platform is the modern KN-86 reconstruction stack, which differs from the in-fiction 1990 Toneline; flagging the deltas rather than forking the spec:

Display: the fiction specifies a sideways-mounted Sharp 240×128 LCD with a horizontal sequencer timeline. The buildable platform is the canonical 1024×600 RGB565 native framebuffer with per-region cell density via integer-scaled 8×8 glyphs (128×75 = 1× cell ceiling) per ADR-0036. The horizontal-timeline intent survives — 128 columns at 1× scale is wide enough for a legible arrangement timeline; the half-block 128×150 canvas covers pixel-flavored waveforms/spectra; mixed-size text per region (e.g., large-scale BPM headline over 8-px pattern grid) is available per ADR-0036.
Input: the fiction specifies 16 function keys + numpad on a landscape clamshell. The buildable platform is the Ferris Sweep 34-key split (ADR-0031) — numeric view-switching and digit-to-pitch land on the right-half digit cluster; LAMBDA and the Lisp primitives are on the left half; the ./(/)/~/- phrase-grammar punctuation is already on the keymap.
Audio path: the fiction’s YM2612 FM chip is realized as software emulation on the Pico 2 coprocessor (ADR-0017), matching how the Deckline emulates the YM2149 PSG. The spectrum visualizer’s input is this PSG/FM mix, not a host-audio loopback. On the desktop emulator, FluidSynth/SoundFont (upiano) and cpal device I/O (asak) are the development-time synthesis/capture references; on-device the path is the YM2612 + DAC chain.
LINK: the fiction’s serial-cable LINK port is realized with an Ableton-Link-style shared-beat protocol.

Source inspiration

This feature set is synthesized from the seven Batch 8 audio TUI entries:

line — CLI live-coding MIDI sequencer; the primary sequencer-language reference (phrase grammar → KEC Lisp s-expression mapping; phrase queue + persistence; multi-instance LINK sync; notes-vs-CC mode).
cava — terminal spectrum visualizer; the single-color audio-visualization reference (eighth-block ramp, cavacore DSP/render split, band-array FFI seam).
cmus — console music player; numeric view-switching, one-line transport bar, library-vs-queue separation.
upiano — playable terminal piano; the piano-strip and linear-slider widgets (and the real-press/release polyphony note for hardware keyboards).
waves — TUI music player; persistent toggle-able queue panel, undo/redo on list edits, Song→Pattern→Phrase→Sequence drill-down.
asak — audio recorder/player TUI; mode-selector splash, waveform-with-playhead, record→monitor→save workflow.
valveFM — vintage FM tuner TUI; the rotary dial control idiom (the rotary complement to upiano’s linear slider).