Chord arpeggio (the 0 3 7 trick) › CheeseCutter #

An indexed chord table, activated per note with 80–9F in the sequence's command column (the value points to an index that holds each chord program's start): entries 00–3F = semitones up ("the familiar major chord would be 0-4-7"), 40–7F = semitones down (7F = −1, 7E = −2 — the Guide's SID cheat sheet includes a full up/down transpose table), 80–FF = wrap. Chords are read in tandem with the wave table, so the wave-delay value also paces the chord; they work over any wave program except absolute notes (80–DF). Chord program 0 is reserved as the swing-tempo program (shuffle-funktempo) (cheesecutter; source: s-cheesecutter-guide).

Detune › CheeseCutter #

Detune is command 3 of the command table (the descendant of JCH's "Super Table"), and it is 16-bit — two parameter bytes, so the offset is a full frequency value rather than a low-byte nudge. Being a command rather than a table column, it can be attached to a single note or left running (source: s-cheesecutter-guide).

Filter programming on the SID › CheeseCutter #

"All filter settings can only be controlled from the filter table" — there are no filter commands, only the per-note filter-pointer range 60–7F in the sequence command column (cheesecutter). A table row with byte A ≥ $80 is a filter init: type, resonance + voice bitmask, initial cutoff (90 F1 10 7F = low-pass $10, resonance $F on voice 1, cutoff $10, stop; C0 07 FF 04 = type $40, all voices, keep the cutoff, jump to row 4). Sweep rows are (duration, add) pairs where the add is two's-complement ("add value of FF actually subtracts by one"), and the sweeps have 10-bit accuracy — "4 times as fine as those on JCH players". An instrument's filter byte 00 means the voice keeps playing whatever filter program another instrument set — the shared-filter idiom again (source: s-cheesecutter-guide).

Hard restart › CheeseCutter #

The restart is a per-instrument type nibble (byte C's high nibble, "works mostly as in NP21.G5"), a menu of four flavours (cheesecutter; source: s-cheesecutter-guide):

"Restart types 0x and 8x are the ones to use for most of the time." The HR ADSR value lives in the Command Table's first row (default 0F 00 — the GoatTracker default again); byte D (the HR waveform) is "usually values 0 & 8", the gate bit added automatically.

Multispeed (framespeed) › CheeseCutter #

CheeseCutter 2 supports multispeed, with the guide's own caveat that it "doesn't work well past 4x" (source: s-cheesecutter-guide) — the practical ceiling for an editor whose player is written for "features/comfort over speed". The 2024–25 arch0N fork lists a multispeed buffer overrun among its fixes (credited to Isildur), so tunes written above 1× in older builds are worth re-checking there (source: s-cheesecutter-repo-and-releases).

Pitch slides and tone portamento › CheeseCutter #

Slides live in the command table, not in the note column: entry 0 slides up, 1 slides down, 7 is tone portamento and 8 stops either. Two rules matter — portamento must be activated before the target notes and "works only on tied notes", and it resets an ongoing slide. The guide's known-quirks list adds that a slide or vibrato placed on a tied-note row is not executed at all (source: s-cheesecutter-guide).

Pulse width modulation (PWM) › CheeseCutter #

Four-byte pulse-table rows in the JCH mould ("works like byte C/B/A/D in JCH's players"): duration with the sweep direction in bit 7 (00–7F up, 80–FF down; the Guide's cheat sheet tabulates durations in frames and ms — $10 = 16 frames = 320 ms), add value, init value (FF = keep the previous width), jump (00 = next row, 7F = stop — implemented as a jump to row 0's 00 00 FF 7F self-wrap). Change the running note's pulse program with 40–5F in the sequence command column (cheesecutter; source: s-cheesecutter-guide).

Ring modulation and oscillator sync › CheeseCutter #

The same two nibbles, read off the editor's own SID cheat sheet: the waveform high nybble (with LOCK flagged on $9–$F, the noise combinations that silence the generator until a test bit) and the gate / sync / ring / test low nybble, entered in the wave program. Its note beside them is the one that decides whether a sound survives the wrong machine: "Waveforms $3, $6 and $7 are audible only on new SID (8580)" — the combined waveforms, not the ring and sync bits, are what varies between chips (source: s-cheesecutter-guide; sid).

Shuffle, swing and FunkTempo › CheeseCutter #

Swing hides in the chord table: chord program 0 doubles as the swing-tempo program (a list of tick lengths), enabled by setting the song speed to 0 or 1 — from the editor or with sequence command F0/F1 (cheesecutter). Caveat from the site's own bug list: "Changing between swing tempo and regular tempo mid-song can mess the timing" (source: s-cheesecutter-guide).

Vibrato and delayed vibrato › CheeseCutter #

Vibrato is a command-table entry, not an instrument setting: in the command table (JCH called it "the Super Table") 2 is vibrato — "the usual delta vibrato as found in JCH's players from 20.G4 upwards; try $21 $05" — and 5 is a second vibrato taking speed and depth. One player quirk to know: a slide or vibrato on a tied-note row is not executed, and a portamento resets an ongoing slide (source: s-cheesecutter-guide; pitch-slide-and-portamento).

Wavetable programming (waveform / arp tables) › CheeseCutter #

The wave table is two columns, transpose and waveform, read one row per frame (source: s-cheesecutter-guide):

The 01–0F delay applying backwards to the row above is the unusual part — it lets one row hold for several frames without a second table entry. Pulse, filter and chord live in separate tables, each with its own jump/stop convention, and chord program 0 doubles as the swing-tempo program when song speed is 0/1 (shuffle-funktempo).

Chord arpeggio (the 0 3 7 trick) › defMON #

There is no chord command: a sidTAB row's arpeggio is the note-transpose (TR, $00–$7F semitones added to the sequence note) stepped by the table itself, with JP (Step Jump) looping it — the manual names arpeggios and vibratos as the two things those loops exist "for". Because a sequence step can execute two sidTAB chunks at once, an arpeggio can run under a second program doing something else entirely (source: s-defmon-wiki-manual).

Detune › defMON #

The AF column (Finetune/Bend) is one byte doing three jobs, and the split is what to remember: $00–$19 is finetune, with $19 = one whole semitone up — so a single step is 1/25 of a semitone, about 4 cents, and a fat-lead offset is $01–$03. Above that, $21–$7F continues as pitch up (wrapping), $80–$BF is bend-up speed and $C0–$FF bend-down speed (pitch-slide-and-portamento). Detune and portamento therefore live in the same column and cannot both be active on a row; transpose is a separate column (TR), so a detuned copy of a part is TR unchanged and AF $01–$02 (sources: s-defmon-wiki-manual, s-defmon-wiki-defmoning-101).

Filter programming on the SID › defMON #

Four sidTAB columns instead of a filter table (defmon): RE = resonance nibble + voice-mask nibble, with the defMON-only mask value 8 = "activates the filter for the Voice the Sound Program is called from" — so one filter chunk works from any voice (F8 = resonance $F, filter on, this voice); FV = filter type (first digit, combinable low/band/high); CP = a relative cutoff offset added or subtracted from the base value; ACID = a four-digit absolute cutoff that doubles as a slide command — $0000–$7FFF set, $8000–$BFFF slide up, $C000–$FFFF slide down — with the minimum locked at 200 "Acids" "so you don't blow your speakers/eardrums". Two cutoff controls means a filter envelope can be offset without rewriting it. Two internals worth knowing: defMON never writes $D415, so the two rightmost digits of a set value do nothing (anarkiwi's register dump, 2018-12-22), and on a detected 8580 the player floors the cutoff at $0200 ($0000 on a 6581) to make the chips behave more alike (sources: s-defmon-wiki-manual, s-defmon-wiki-defmoning-101, s-chipmusic-defmon-thread).

Hard restart › defMON #

The only editor that automates nothing — frantic (2018-02-22): "You can do any kind of hardrestart in defMON, whereas most other editors only feature one type of built in hardrestart and no reasonable way to do it manually." Automated HR would need look-ahead sequence parsing, which costs rastertime; instead every sequence has a −1 step before line 0 (reach it with CTRL+G twice) where the restart rows go, ~2 frames before the note (source: s-chipmusic-defmon-thread). The field guide new users are pointed at says the same thing as a boast: "Most flexible hard restart ever, period. Because you do it all yourself." (source: s-defmon-wiki-defmoning-101).

• The common idiom (used by goto80 and Amelinium): on the restart line waveform/gate 00 00 with ADSR $0F00, wait 2 ticks (DL), then gate 09 (test + gate) with the instrument's real ADSR, then the waveform — the GoatTracker recipe, typed by hand in the sidTAB (source: s-chipmusic-defmon-thread).
• iLKke's compendium (2015-08-03) names four HR shapes — old school (one frame gate-off, ADSR $0000), new school (gate-off with ADHR, then $09 + real ADSR, then waveform+gate+note), hybrid, "heatbeat" — and the known ADHR values: $0000 "hardest", $0F00 "most common", $0F18 Drax, $0F20 GRG, $0FF0 Randall/Jammer, $F000 Linus, $FF00 Jeff. Sustain $F "is especially buggy (try E then?)"; a soft restart wants release ≥ $8 (sources: s-chipmusic-defmon-thread, s-defmon-wiki-defmoning-102).
• How much HR you need: F7sus4 — the full test-bit restart is "obligatory only with drums and snares"; leads, bass and arps are fine soft-restarted. 4mat's minimal recipe: "$08 on the first frame before you set the gate … ($08,$41,$41,$40)". Bonus trick: vary the AD nibble on the HR line ($01–$0F) to scale a drum's volume per hit (source: s-chipmusic-defmon-thread).

Multispeed (framespeed) › defMON #

defMON does 1x/2x/4x/8x, but the multiplication lives in the editor, not the player: F2/F4/F6/F8 set a CIA timer ($4CC7+1 cycles = one PAL frame; $2663 = 2x, $1331 = 4x), and C=+F-keys nudge or halve/double the timer — which doubles as defMON's free-form BPM control. Because of that design a per-pattern multispeed command is impossible without breaking packed tunes. Odd rates work by typing the timer by hand: $1997 gives 3x — frantic's favourite, "Just enough to be enough" — and a CSDb compo tune ran at 25 Hz, the player called every second frame. A host program plays a multispeed defMON tune by calling $1003 once per frame and the sound-only entry $1006 the remaining 1/3/7 times (sid-player-routine). Switching 1x↔8x live works as a performance effect, though frantic warns it can "also sound crappy in some cases" (sources: s-defmon-wiki-defmoning-102, s-defmon-wiki-calling-the-player, s-chipmusic-defmon-thread). The full preset set is $4CC7/$2663/$1331/$0998 for 1×/2×/4×/8× (source: s-defmon-wiki-sync-and-stereo), and the 2014-06-15 release fixed multispeed toggling so that switching while playing no longer drifts out of sync — which is what makes it usable live (source: s-defmon-wiki-releases). The wiki's field guide states the payoff plainly: "Up to 8x multispeed means nearly any SID tune except sample playback can be covered in defMON" (source: s-defmon-wiki-defmoning-101) — a claim that only holds because the player is cheap enough to call eight times, "relatively low CPU usage… DefMON tunes can be, and have been, used in various demos and games" (source: s-defmon-wiki-manual).

Pitch slides and tone portamento › defMON #

defMON has no slide command, by design: you write the bend as a sidTAB chunk and call it in a step's second sound-program column, beside the instrument in the first (instrument-tables). The pitch columns are TR and AF. AF packs finetune and bend into one byte — $00–$19 finetunes up with $19 equal to one semitone, $21–$7F continues upward (wrapping), $80–$BF sets the speed of a bend up and $C0–$FF the speed of a bend down — while TR is $00–$7F relative semitones (for arpeggios) and $80–$FF absolute pitches, so a slide's destination can be written either way (sources: s-defmon-wiki-manual, s-defmon-wiki-defmoning-101; detune).

Pulse width modulation (PWM) › defMON #

Two sidTAB columns (defmon): PW sets the width, PS sweeps it — $00–$7F "slide left (to 0%, lowering PW value in time)", $80–$FF "slide right (to 100%)". The two digits XY typed into PW expand to the 12-bit value $YXY (e.g. 83 → $383), so the closest squares are $08 → $808 ≈ 50 %, $0C → $C0C ≈ 75 %, $04 → $404 ≈ 25 % (or $F7/$FB/$F3 from the other side); "If pulSEWIDTH is set near to 0% or 100%, the pulse waveform is inaudible" (sources: s-defmon-wiki-defmoning-101, s-defmon-wiki-defmoning-102). The manual states the same landmark more simply — "PW (Pulse Width) — $08 equals the 50% pulse" — and the sweep direction as $00–$7F left, $80–$FF right (source: s-defmon-wiki-manual).

Ring modulation and oscillator sync › defMON #

Ring and sync live in the gate nibble of the sidTAB's second WG column: +1 gate, +2 sync, +4 ring mod, +8 test bit — additive, so 07 = ring + sync + gate and 05 = ring + gate. defMONing 102 states the pairing: "1+2, 2+3, 3+1 … e.g. used in channel 1 means channel 3 modifies channel 1". Because the two WG columns are ORA'd together before the register write, $55 can be entered as 5401 or 5005 — so you can hold the ring-mod bit in one column while switching waveforms per line in the other, a per-line ring-mod switch (Amelinium's technique, 2018-12) (sources: s-defmon-wiki-defmoning-102, s-defmon-wiki-defmoning-101, s-chipmusic-defmon-thread). The manual states the column split that makes this work: of the two WG columns, the yellow one is the waveform and you "use only the first digit" (1x triangle, 2x saw, 4x pulse, 8x noise), while the green one is gate plus hardsync and ring modulation and you "use only the second digit" (source: s-defmon-wiki-manual).

Shuffle, swing and FunkTempo › defMON #

defMON has no groove list and no funktempo: every sequence step carries its own speed value, per channel, and the value is ticks − 1 (a 2 in the column means 3 ticks). Swing is therefore written by hand into the column — and because the columns are per channel, the drums can run 5 3 5 3 against a straight melody, with everything re-aligning at each sequence break (source: s-chipmusic-defmon-thread).

Under hardware sync that freedom narrows to one choice. The user-port adapter sends six pulses per two sequence steps, so a synced tune has to spend exactly 6 ticks on every two steps: 3+3 straight or 4+2 swung, and nothing else; tempo changes then have to come from the player-call rate rather than from the speed columns (source: s-defmon-wiki-sync-and-stereo).

Vibrato and delayed vibrato › defMON: no vibrato at all #

defMON has no vibrato command, on purpose. The sidTAB is the whole effect language — "you would create a vibrato the way you like it, rather than calling a pre-programmed vibrato" — so a vibrato is a few sidTAB rows that step the pitch up and down, and a step can run two sidTAB chunks at once, one holding the note and one running the wobble. The design argument is the same one frantic makes about hard-restart: fewer built-ins, more flexibility, and no CPU spent on a routine a given tune may not want (source: s-defmon-wiki-manual; sid-player-routine).

Multisampling and drum-kit instruments › C64: Digi-Organizer #

The 1980s C64 equivalent, from the other direction: sample definitions are (start page, end page, rate) triples into one block of memory, so a single "instrument" can chain several raw blocks — a poor man's multisample of drum hits, with the map living in the sample table rather than in a note column (source: s-sidin06-digiorganizer).

Hard restart › DUST (DUET) #

• duet's DUST synth makes hard restart a patch parameter: RESTART OFF / SOFT (gate down for the window) / FULL (gate down and the envelope slammed to zero) over a 1–200 ms window spent before the note; the engine peeks at the next row so the attack, not the restart, lands on the beat (source: s-duet-docs-dust-dusk).

Sound effects and game audio › DUET #

duet takes the same road explicitly: duet_engine_note_on fires an instrument by family — a PCM instrument, or a SID-Wizard instrument from the project's pool routed through a chip — with jam = 1 building a chip on demand, no pattern needed. The docs call it "a game's instruments-as-sound-effects road" (source: s-duet-docs-libduet).

Wavetable programming (waveform / arp tables) › DUSK (DUET) #

• duet's DUSK plays a P## sample as a row of equal single-cycle frames (frames = sample length / FRAME; "2048 is the Polyend standard") and morphs between the two nearest frames; a slow LFO routed to morph "is the classic wavetable sweep"; ALIAS raw keeps the aliasing on purpose (source: s-duet-docs-dust-dusk).

Multisampling and drum-kit instruments › FastTracker 2 #

An instrument holds 1–16 samples with a key split "drawn" on the piano keyboard; each sample has its own volume, pan, finetune and relative tone; the FAQ warns that the instrument, not the sample, is what carries envelopes (source: s-ft2-manual).

Chord arpeggio (the 0 3 7 trick) › Furnace #

The instrument's Arpeggio macro is a per-tick "pitch sequence" in semitones — the same table idea, with the waveform and duty in parallel macros (furnace; source: s-furnace-c64-docs).

Filter programming on the SID › Furnace #

furnace sets the filter from the pattern with 4xxx (cutoff 000–7FF), 13xx (resonance 00–0F), 14xx (mode: 00 off, 01 low, 02 band, 03 low+band, 04 high, 05 notch, 06 high+band, 07 all), 24xx/25xx (cutoff slide up/down at speed xx, 00 stops) and 1Bxy (reset the cutoff on the next note / now); 11xx is a discouraged coarse cutoff 00–64. Per instrument: Enable filter routes the voice, Initialize filter sets cutoff 0–2047, resonance 0–15 and the mode (low, high, band, ch3off — "selecting both 'low' and 'high' results in a bandstop (notch) filter"), and Absolute Cutoff Macro makes the cutoff macro write 0–2047 directly instead of relative steps. Because the filter is global, the chip configuration decides whose macros win: Left to right (channels 1→3, the last wins) or Last used channel (the latest note-on wins) — a third policy beside SID-Wizard's leftmost-channel rule and its "latest instrument takes over" (source: s-furnace-c64-docs).

Hard restart › Furnace #

furnace calls it envelope reset: in the chip configuration, Hard reset envelope is the ADSR "used during the short reset before a note" and Envelope reset time the number of ticks — "0 disables reset, which prevents notes from triggering. 1 is short, but may exhibit SID envelope bugs. 2 is a good value." From the pattern, 15xx sets the reset time (00, or more than the song speed, = no reset) and 1Axx disables it for the channel; per instrument, Don't test before new note "disables the one-tick hard reset and test bit before a new note" — so Furnace, like GoatTracker's $09, sets the test bit during the reset (source: s-furnace-c64-docs).

Pulse width modulation (PWM) › Furnace #

furnace: instrument Duty 0–4095 (2048 = square) and a duty macro per tick, Absolute Duty Macro to write widths directly instead of relative steps, Reset duty on new note to reload the instrument's width; from the pattern 3xxx sets the width 000–FFF, 22xx/23xx slide it up/down at speed xx (00 stops), 1Cxy resets it on the next note / now, and 12xx is a discouraged coarse setting 00–64 (source: s-furnace-c64-docs).

Ring modulation and oscillator sync › Furnace #

Instrument checkboxes Ring Modulation ("the channel's output will be multiplied with the previous channel's") and Oscillator Sync ("as the previous channel's oscillator finishes a cycle, it resets the period of the channel's oscillator"), a Special macro that switches ring, sync, the gate bit and the test bit per tick, and the compatibility effects 1E4y (ring) and 1E5y (sync). Its test-bit semantics: set = "immediately mute channel", and "if the channel is a source of ring mod and/or hard sync, those stop working until the bit is reset" — a test bit on the modulator silences the modulated voice's effect too (source: s-furnace-c64-docs).

Wavetable programming (waveform / arp tables) › Furnace #

furnace does the same with a per-tick waveform macro in the instrument (plus arpeggio and pitch macros for the note column) and, from the pattern, 10xx — 01 triangle, 02 saw, 04 pulse, 08 noise, sums for combinations (source: s-furnace-c64-docs).

Chord arpeggio (the 0 3 7 trick) › GoatTracker #

GoatTracker 2 removed v1's arpeggio command: "Everything that this command does can also be done with wavetables". A looping arp is a wavetable whose right bytes are the semitone offsets and whose left bytes keep the waveform: 41 00 / 00 04 / 00 07 / 00 0C / 00 00 / FF 02 (4-note pulse arpeggio, waveform unchanged in the loop); with delays in the left byte the arp slows — 21 00 / 02 03 / 02 07 / 02 00 / FF 02 is "a delayed minor chord arpeggio with sawtooth waveform. Each step takes 3 ticks". Because the wavetable "is never skipped", arps keep time at any tempo (source: s-goattracker-readme).

Filter programming on the SID › GoatTracker #

The filtertable: 00 xx set cutoff, 01–7F xx modulate for that many ticks at signed speed, 80–F0 xx set passband (left high nibble 9 low-pass, A band-pass, C high-pass) with the right byte = resonance nibble + channel bitmask (as in command BXY), FF xx jump. A set-parameters row directly followed by a set-cutoff row executes in the same frame. Examples: 90 F1 / 00 40 / FF 00 — low-pass, resonance F, channel 1 only, cutoff $40; A0 87 / 00 00 / 7F 01 / 7F 01 / 7F FF / 7F FF / FF 03 — band-pass on all channels sweeping up 254 ticks and back; C0 F2 / 00 F0 / 90 F2 / 00 50 — high-pass then low-pass on the next frame. From the pattern: AXY sets the filtertable pointer, BXY filter control (X resonance, Y bitmask; B00 = off and stop), CXY cutoff. "In most cases it makes sense to have a filter-controlling instrument only on one channel at a time"; the filtertable runs on every tick, and the test note plays filtered only on a channel selected in the filter parameters (source: s-goattracker-readme).

Hard restart › GoatTracker #

• Per instrument: HR/Gate timer = how many ticks before the next note the note fetch, gate-off and hard restart happen (at most tempo−1; with tempo 6 and timer 2 they happen on tick 4, "2 ticks before first frame"); bit $80 disables hard restart, $40 disables gate-off. 1stFrame Wave is "usually $09 (gate + testbit)".
• Global: the HR ADSR value (-Axx, SHIFT+F7), default 0F00 — "0000 is probably too hard to be useful, except perhaps with gateoff timer value 1. 0F00 (default) is a lot softer, and 0F01 adds also a little bit of release to the gateoff phase for even softer sound. 000F makes the note start very pronounced." Attack F enables an alternative playroutine that writes the waveform before ADSR, "more reliable note triggering, especially for very fast releases 0 & 1".
• Legato without restart: timer bit $40 and 1stFrame $00 (tables and ADSR still re-initialise).
• Multispeed: multiply the timer with the speed (2 → 4 at 2×). If a packed tune still bugs: make note-init take more cycles (nonzero pulse start position, 1stFrame $09 → $0B), use buffered writes, or attack F; since v2.68 notes with attack 0 and release 1 are the sensitive case.

(source: s-goattracker-readme)

Instrument design beats note count › GoatTracker #

Nine parameters per instrument (ADSR, three table pointers, vibrato + delay, HR/gate timer, 1st-frame waveform) and everything else lives in the tables (goattracker). The readme's own recipes (source: s-goattracker-readme): ADSR 09/00 self-fading pluck, 00/8A organ-like sustain, CC/AF slow pad; wavetable "flute" 41 00 / 11 00, "koto" 41 01 / 40 00, a snare 81 D0 / 41 AA / 41 A4 / 80 D4 / 80 D1 ("use pulsewidth 800"), hi-hat-then-pulse 81 DF / 41 00; pulse sweep 80 10 / 20 40 / 40 E0 / 40 20 / FF 03; speedtable vibrato 05 04 "slow shallow vibrato, suitable for bass notes"; low-pass bass filter 90 F1 / 00 40. Stop an unused pulse program (80 00 / FF 00) under sawtooth instruments to save rastertime.

Multispeed (framespeed) › GoatTracker #

The speed multiplier is -Sxx on the command line or SHIFT+F5/F6 (0 = 25 Hz, 1 = 1×, 2 = 2× …). Because the whole player runs faster: multiply tempos and gate-off timers (timer 2 → 4 at 2×, also when importing v1 multispeed songs); to keep a vibrato the same, multiply its speed and divide its depth by the multiplier; divide portamento and pulse/filter modulation speeds; funktempo 24 18 is 09 06 at 4×. With attack 0 "the very silent first row of the wavetable" may vanish — raise the attack or add E9 00 (test + gate) rows at the start (source: s-goattracker-readme).

Octave bass › GoatTracker #

Type it, or put it in the instrument: a wavetable whose right byte alternates 00 and 0C (+12 semitones) with the waveform kept (00 left byte) and an FF jump back — the readme's 4-note arpeggio example (41 00 / 00 04 / 00 07 / 00 0C / 00 00 / FF 02) shrunk to two rows; add left-byte delays (01–0F) to slow it to 8ths (derived from the documented table semantics, source: s-goattracker-readme).

Pitch slides and tone portamento › GoatTracker #

1XY / 2XY slide up / down and 3XY tone portamento all take a speedtable index holding a 16-bit pitch step per tick; 300 is a tie note (instant pitch change, no retrigger). Speedtable examples: 00 20 (old parameter $08), 01 00 (old $40), 4F FF "loops the pitch highbyte very fast so that a SEUCK-like 'space' effect is heard"; a high bit in the left byte (80 01) makes the speed note-independent (divisor 1 = half). SHIFT+H on a command precalculates a note-independent speed from the frequency difference of adjacent notes (00110 = double the C-3→C#3 difference). Portamento is a realtime command: it continues under one-shot commands and stops at 0XY (source: s-goattracker-readme).

Pulse width modulation (PWM) › GoatTracker #

The pulsetable: 01–7F xx = modulate for that many ticks at signed speed xx (right byte), 8X xx = set width $Xxx, FF xx = jump (00 stops). Readme examples: 88 00 / FF 00 sets $800 and stops; 80 10 (very thin), 20 40 (32 ticks up at speed 64), 40 E0 (64 ticks down at −32), 40 20 (64 ticks up at 32), FF 03 (loop from row 3) — "a nice loop". Enter sweeps as limit-based steps (84 00, C0 10 modulate to $C00, 40 10 back to $400) and convert them with SHIFT+L; the player only understands time-based steps. Speeds doubled in v2.4. Pulse execution is skipped on note-init ticks unless -O0; 900 or a 80 00 / FF 00 program stops an unused pulse program under non-pulse instruments (source: s-goattracker-readme).

Ring modulation and oscillator sync › GoatTracker #

Set the bits in the wavetable byte: $02 sync, $04 ring ("most effective with the triangle waveform"), $08 test — e.g. 15 = triangle + ring + gate. The inaudible values $00–$0F are typed as E0–EF, so test + gate is E9; the instrument's 1stFrame Wave is normally $09 (gate + test) (source: s-goattracker-readme).

Shuffle, swing and FunkTempo › GoatTracker #

EXY = funktempo from a speedtable entry whose two bytes are the alternating tempos (09 06 corresponds to the old parameter $96; 24 18 is the same feel at 4× multispeed); it applies to all channels, and FXY with $83–$FF overrides the tempo on one channel (F00/F01 recall the funktempo values). Tempo 3 is normally the fastest, but a funktempo entry 02 02 with gate-off timer 1 in every instrument and pulse skipping disabled gives tempo 2 (source: s-goattracker-readme).

Vibrato and delayed vibrato › GoatTracker #

4XY and the instrument's vibrato parameter both index the speedtable: left byte = how many ticks until the direction changes (speed), right byte = pitch added each tick (depth). 03 40 equals the old one-byte parameter $34; 05 04 is "slow shallow vibrato, suitable for bass notes. Not possible to achieve with old parameters"; 83 04 (high bit set) makes the depth note-independent with a divisor of 4 right-shifts. The instrument's vibrato delay is the tick count before it starts (00 = off) — a delayed vibrato without any pattern command, which also packs smaller. Realtime commands are skipped on tick 0 of each row unless -R0; a one-shot command (5XY–FXY) between vibrato rows leaves the vibrato running, but 0XY stops it; SHIFT+H precalculates "hifi" note-independent depths from the frequency difference of adjacent notes (source: s-goattracker-readme).

Wavetable programming (waveform / arp tables) › GoatTracker #

Wavetable rows are left right bytes: left 00 keep waveform, 01–0F delay 1–15 frames, 10–DF waveform/control, E0–EF the inaudible values $00–$0F (E9 = test + gate), F0–FE execute pattern command 0–E (right = parameter; not 0, 8, E), FF xx jump (00 = stop); right 00–5F semitones up, 60–7F down, 80 keep frequency, 81–DF absolute C#0–B-7. A delay or "no change" must not be the instrument's first row. Rows with a delay or 80 let vibrato and realtime commands run underneath (rastertime!). Examples from the readme (from table row 1):

Instrument pointers select the start row; 8XY in a pattern jumps into a table mid-way; "Wavetable is never skipped" at any tempo (source: s-goattracker-readme).

Chip samples — tiny looped waveforms › Impulse Tracker's sample tools #

Alt-E/Alt-F resize with/without interpolation (Graham the Happy Scum: +1 then −1 sample as a crude low-pass "smoothing"), Alt-G reverse, Alt-A/Alt-Q signed and 8/16-bit conversion, Alt-B/Alt-L cut before/after the loop — Onix4MAN loops the first 50–100 bytes and pre-loop-cuts to remove start clicks; a crude noise gate is Alt-A, Alt-M at 103–104 %, Alt-A; quarter-tone scales come from loading a sample twice with one copy's rate × 1.0293 (2^(1/24)). IT can render new samples of itself: put a break in one pattern, restart with the WAV-writer driver, play, reload the WAV as a sample. One channel of a stereo WAV: Ctrl-F halves the sample keeping every second byte (cut the first and last byte first for the right channel), then double the frequency (sources: s-tw086-wrecking-samples-with-impulse-tracker, s-it-hints, s-it-manual).

Chip samples — tiny looped waveforms › One composer's digi voice, and why it stayed private (1991) #

JCH added samples to his own editor in June 1991 by the $D418 volume-click trick driven from an NMI — the same route as the 1986–88 drivers above — and sampled Korg M1 sounds with an SFX Sound Sampler cartridge. His first digi tune was "Better Late than Never" (1991-06-23) and he made only four in total, because the jch-editor was merely "hacked" for the digi voice and was "too hairy to be used by anyone else but me". It is a useful counterweight to the 1986–88 firsts: by 1991 the technique was reachable by a bedroom composer, but productising it — making it survive in an editor other people use — was still the hard part (source: s-chordian-my-computer-chronicles; multispeed).

Chord arpeggio (the 0 3 7 trick) › Impulse Tracker / Scream Tracker 3 #

Jxy cycles base, +x, +y once per tick — the IT manual calls it "an effect similar to old C-64 chords" (source: s-it-manual): the Modsquad's chip lead has a chord channel of J47 (major) and J37 (minor) at volume 64 with J00 to stop, and their rules are "chords in one channel — never two — and no percussion inside them" (source: s-tw077-chip-off-the-block). Pinion admits that for "really neato chords" Jxx is "a bit… shitty sounding" in a sample tracker — but on a looped noise sample with a long falling pitch envelope a column of Jxx makes analog-style sweeps (instrument-envelopes; source: s-tw081-it-tip-of-the-week). Trixter's reminder that "a chord isn't a thing, it's any combination of notes" applies: an arp is a chord spread in time (source: s-tw039-chord-theory-debate).

MOD and XM use 0xy for the same command: ProTracker's help calls it "used to simulate chords … noisy and grainy on most samples, but ok on monotone ones" — C-3 00047 C major, 037 C minor — and FT2 plays the note on tick 1, +x on tick 2, +y on tick 3 (sources: s-protracker-23d-help, s-ft2-manual). ST3's manual says the same in its own letters: Jxy changes the pitch "50 times per second … best to use it with clear or tight-looped (chip) instruments. Old users of the Commodore 64 remember this effect which was used to make chords" (J37 = C minor) (source: s-st3-manual). Two quirks players emulate: Fasttracker 2's arpeggio runs backwards (the second parameter's note comes first), and in ProTracker mode arpeggios that leave the Amiga range wrap around an octave (sources: s-openmpt-manual-compatible-playback, s-openmpt-manual-song-properties).

One command-memory trap when porting a part between formats: in S3M the effect memory is mostly global to the column, so a bare J00 recalls the last non-zero parameter of any command in that column, not just the last arpeggio — where MOD's 0xy has no memory at all and IT keeps per-command memory. Only vibrato and tone portamento have their own memory in S3M (source: s-openmpt-manual-effect-reference; effect-command-crosswalk).

Chord arpeggio (the 0 3 7 trick) › Who invented it, and the PWM trick #

• SIDwave credits martin-galway: "In the process, Martin invented the chord, aka arpeggio — to play 3 or more notes in the same voice, very fast, one after another, so that it sounds like a chord. People from the UK called it the arpeggio, it was also known as wibble, or wibbles" (1984–85; source: s-recollection-brief-history-of-sid). de.wikipedia describes Soundmonitor's arpeggios the same way — "sehr oft zu hören" in C64 games (source: s-soundmonitor-lineage-wikis).
• matt-gray: "the note or chord plex where you go very quickly between 2,3 or even 4 notes to give the impression of a full chord being played. That sound became unique almost to the SID and everyone is using it as a retro sound now … And if you put a pulse width mod on it such as a sweep, the bubbling chord took on a life of it's own" (pulse-width-modulation; source: s-rvg-matt-gray-interview).

Fake echo / delay › Impulse Tracker #

Pulse's own hint: copy the column and set a channel volume M20 at the top of the echo channel — "you won't have to modify the echoing channel from the original", the Dxx slides stay right. StereoMan's reverb-like version: copy the sequence one or two rows later, zero its volumes (Alt-V, Alt-W) and fade every echo note in with Dx0 slides; pan the pair apart (X22/XDD or X80 + S91) for "stunning" results (sources: s-it-manual, s-it-hints).

Filter programming on the SID › Impulse Tracker / OpenMPT (resonant filter) #

The PC-tracker equivalent of the SID filter table is a column of Zxx macros (source: s-openmpt-manual-zxx-macros): by default Z00–Z7F set the cutoff (00 lowest … 7F highest; the top is about 5 kHz, or 10 kHz with Extended Filter Range) and Z80–Z8F the resonance; the underlying messages are F0F000xx cutoff, F0F001xx resonance, F0F00200 lowpass and F0F00210 highpass (mutually exclusive), so a fixed macro can switch filter type. Instruments carry default cutoff, resonance and (MPTM) filter mode; cutoff at maximum with resonance at minimum turns the filter off; the pitch envelope can act as a filter envelope (S7D/S7E force one or the other in MPTM); S9C makes filters stay until switched off (Impulse Tracker behaviour), S9D resets them on every note; MPTM adds cutoff and resonance swing per instrument; the filter never touches plugins (sources: s-openmpt-manual-instruments, s-openmpt-manual-effect-reference). On OPL instruments the cutoff macro scales the modulator — "effectively … a lowpass filter" (opl-fm-instruments; source: s-openmpt-manual-samples). The Amiga's only filter is the LED low-pass toggled by E0x — "connects filter (turns power LED on)" — which OpenMPT calls "muffled" and emulates only with the Amiga resampler (sources: s-protracker-23d-help, s-openmpt-manual-effect-reference).

Lead articulation (velocity, legato, late vibrato, drop-off) › Scream Tracker 3 / Impulse Tracker #

Necros's worked example (E minor run; ST3 letters, identical in IT/OpenMPT; source: s-tw012-advanced-tracking-tips):

1. Velocity in the volume column — ramp a run up to its held peak and back: E-4 40 · G-4 40 · A-4 50 · B-4 60 · E-5 64 … G-5 60 · F#5 50 · B-4 40 · C-5 40 → 50 → 64 · A-4 50. Multiples of 10 are quick to type; the volume column, not D20, so the effect column stays free.
2. Legato with tone portamento so the sample is not restarted: GF0 for any jump over three semitones ("practically instant"), G20/G06 for a slow slide over a small step, and a GF0 on the row after a slow slide to guarantee it lands, "since some players tend to play Gxx/3xx effects too slowly" (pitch-slide-and-portamento).
3. Late vibrato on the held notes only: HA1 a row or two after the note, then HA2, never the main event except in hard up-tempo tunes; fade it back or fade the note (vibrato).
4. Echo track: copy the lead column, ALT-J its volumes down to a third at most (22 from 64), shift it 2–3 rows at speed 6 (4–6 at speed 3), pan it the same distance on the other side of the lead (fake-echo, stereo-panning).
5. Drop-off ("made infamous by Purple Motion and other siner junkies"): slide up into the top note, sustain it with vibrato, and at the very end fall away with an accelerating down-slide and falling volume:

Catspaw's version of the same shape mixes volume-column values with K/H/E commands (C#6 02 33 UC3 → K20 → 44 H82 → K01 → 32 H71 → 20 E0E; source: s-tw058-the-finishing-touches; see volume-slides). The cheapest cousin of the drop-off is vegas's release tip of 1996: "Dont use a ^^^ to kill a note in the lead, just drop the volume to 10, 15, or 20 and volume slide the rest away. It leaves a reverb-ish effect thats really good on flutes, piano's and violins" — no pitch fall, just a volume-column 10–20 on the release row and a D0x slide to silence (source: s-tw062-interview-vegas).

Staccato and grace notes (Dan Hartrell's funk sax run, source: s-tw021-tracking-tips): D0F on a note and the row after it for "4 staccato" notes, G90 on each note of a phrase for a "wavey" pipe-or-reed sound, SD1 (note delay) to turn a note into a grace note that slips into the next, and alternating A05/A08 speeds so the run swings (shuffle-funktempo). Greg Heo's definition: a note cut SCx after x ticks is staccato, the absence of it legato (source: s-tw074-intro-to-musical-theory).

MIDI output from trackers (Impulse Tracker macros) › Impulse Tracker #

From Airon's 1997 guide (source: s-tw098-impulse-tracker-midi); all values hex, c = MIDI channel, z = the macro's data byte (00–7F):

• Static macros Z80–ZFF hold fixed messages; parametered macros SF0–SFF select one of sixteen templates whose z byte comes from Z00–Z7F — the mechanism OpenMPT documents in full (source: s-openmpt-manual-zxx-macros).
• Velocity: the volume column is sent as NOTE ON velocity (timbre, "how hard you hit"); MIDI volume (controller 07) is a separate level, "the distance to the listener".
• Note-off timing and legato: NOTE OFF is sent when the note's tracker volume reaches zero. A sample-style instrument with NNA note fade and a fade-out around 120 therefore sends NOTE OFF late; use NNA note cut and fade-out 0 for tight playing, or NNA note fade with a small fade-out on purpose — "the greater the VOLUME FADE, the less LEGATO" (new-note-actions). ^^^ (note cut) sends NOTE OFF at once; most synths retrigger a repeated note without killing the previous one.

Multisampling and drum-kit instruments › Impulse Tracker #

The instrument's note translation table maps every note to a (note, sample) pair, so C-5 01 can play sample 1 while D-5 01 plays sample 3 at D-4. Two uses: a drum kit in one instrument (each note a different drum, one NNA/envelope/fadeout for all; "Update Pattern Data" converts old sample-per-drum patterns), and a high-quality multisampled piano — "if you don't run out of memory first. Or patience." Saving an instrument saves its samples with it (source: s-it-manual).

The kit case is where IT's NNAs pay off: with NNA continue, "put a bass drum in the very next row after [a snare] — the snare will still complete playing" from one instrument on one channel (source: s-it-manual).

New Note Actions (NNA) › Impulse Tracker #

• Set the default NNA in the instrument (with a sensible fade-out so virtual channels are freed).
• Override per note with S73 cut · S74 continue · S75 note off · S76 note fade — the setting applies to the note following the command. Correction from IT's author: a note left with S74 keeps ringing until an S70 past-note cut; ^^^ only affects the latest note; check the info page's Tot column to see how many virtual channels you are burning (source: s-tw081-it-tip-of-the-week).
• Instruments cost almost nothing in file size, so keep several per sample with different NNAs and fades.
• MIDI instruments: IT sends NOTE OFF when the note's tracker volume reaches zero, so NNA note fade with a fade-out (Airon's was 120) delays every note-off; use note cut and fade-out 0 for tight timing, or keep note fade with a small fade-out as a deliberate legato — "the greater the VOLUME FADE, the less LEGATO"; ^^^ sends NOTE OFF at once (midi-in-trackers; source: s-tw098-impulse-tracker-midi).
• Continue is for drums and short unlooped samples; a looped sample with continue and no cut "will annoy the listener into deleting your song" and can crash the player. Zinc: use NNAs, but "don't cram your instruments into one or two channels" (source: s-tw075-it-percussion-tips).
• The 1996 objection: kal-zakath relayed the view that NNAs "encourage inefficient tracking, and reduce GUS sound quality"; vegas did not use them but called them "definitely not useless", citing FutureAssassin's NAID '96 entry as the good example (source: s-tw062-interview-vegas). The manual supports the second half of the complaint mechanically — on a gravis-ultrasound the playback rate falls as active channels rise (source: s-it-manual) — and Pulse's own hope (below) that NNAs would not kill four-channel craft answers the first.

The Modsquad's drum-sampling comparison (1997): a kick-plus-snare combination sample versus playing the two with NNA continue — "almost the same" result, minus the interaction of the two waveforms, the "subharmonics and resounding frequencies" that a single recording keeps (source: s-tw087-music-theory-a-modern-approach; see instrument-design).

New Note Actions (NNA) › How IT allocates channels (from the manual and format doc) #

• Cut stops the old note "like in all other trackers"; continue lets it play on (a snare keeps ringing under the kick placed on the very next row); note off releases it (sustain loops, envelope sustain); note fade fades it with the instrument's fadeout. S70/S71/S72 apply cut/off/fade to all notes the channel left in the background.
• Duplicate checks: DCT (off / note / sample / instrument) with DCA (cut / off / fade) stop a repeated note from piling up — the manual's guitar example: NNA continue, DCT sample, DCA fade, one sample per string, so replaying a string fades its previous note like a finger landing on it.
• Allocation: when a channel already plays, its note is flagged background and its NNA fires; the new note takes the first free virtual channel, else the quietest background channel, else it is dropped (IT 2.03+ chooses more cleverly). Background channels die when the sample ends, the envelope ends at 0, the fadeout is silent, or their volume is 0 — so always give fading notes a real fadeout; NNA fade with fadeout 0 or continue on looped samples "can easily hang a slow computer".
• Pulse: "I sincerely hope that these options do not cause the death of brilliant 4 channel music … There is truly an art in making a decent sound in as few channels as possible!"

(sources: s-it-manual, s-ittech)

Octave bass › Impulse Tracker / OpenMPT #

Jxy is an arpeggio over three notes — "the note playing, a note x halftones above, and a note y halftones above", an effect the manual itself compares to "old C-64 chords". So there is no single command for a strict 0 12 alternation: JCC gives 0 12 12 and J0C gives 0 0 12. For an exact 8th-note octave, type the two rows (source: s-it-manual). See effect-command-crosswalk for the same effect's number in MOD/XM (0xy).

Pitch slides and tone portamento › Impulse Tracker details #

Exx/Fxx slide down/up (values up to DF); EFx/FFx are fine slides and EEx/FEx extra-fine (a quarter of fine); Gxx may target a different sample, which then starts from its beginning; E, F and G share one effect memory. Linear slides (F12) make a value mean the same interval at any pitch — F08 at speed 5 raises a whole tone whether from C-4 or C-5 — because the frequency is multiplied by 2^(value/768): 64 units per semitone, Exx steps 4 units per frame, EEx 1 unit. With Amiga slides you must experiment per octave (sources: s-it-manual, s-ittech).

Randomization and probability (MayBe, RandomiZe) › Impulse Tracker #

Instruments have volume swing and panning swing — a random variation applied to every note. Zinc uses a small volume swing on hi-hats ("even if you've already changed your hi hat volumes to go 64-24-32-20") and panning swing for barely noticeable movement (source: s-tw075-it-percussion-tips); Pinion turns volume swing up to 100 % on a channel full of scale notes with NNA note-fade and "lets the laws of chaos do the composing" — a novelty, but a real generative tool (source: s-tw081-it-tip-of-the-week).

More IT randomness: the instrument's random volume variation is the volume swing Zinc and Pinion use, but the format doc marks random panning variation "not implemented yet" (so panning swing may not have worked in the versions of the time); S33/S43/S53 set the vibrato/tremolo/panbrello waveform to random — with random panbrello the speed digit becomes a delay in frames between new positions (Y14 fast, Y44 slower) (sources: s-ittech, s-it-manual).

In openmpt the instrument's Random Variation section has volume swing and pan swing (a random percentage of the global volume, a random pan offset) for every format with instruments, and MPTM adds cutoff swing and resonance swing on the resonant filter; the IT-compatible rule is that volume variation is a percentage of the instrument's global volume, not of the note volume (sources: s-openmpt-manual-instruments, s-openmpt-manual-compatible-playback). The random LFO waveform (S33/S43/S53 in IT, E43/E73 in MOD/XM) "is not supported by ProTracker and FastTracker" and should be avoided in those formats (source: s-openmpt-manual-effect-reference).

Retrigger and resync › Impulse Tracker / Scream Tracker 3 #

Qxy replays the sample every y frames with a volume change x per hit: 0 none · 1–5 = −1, −2, −4, −8, −16 · 6 = ×⅔ · 7 = ×½ · 8 none · 9–D = +1, +2, +4, +8, +16 · E = ×1½ · F = ×2 (source: s-it-manual). Catspaw's frame arithmetic: at speed 6, Q03 hits again exactly halfway through the row, Q02 gives three hits, Q04 a lopsided pair; avoid odd speeds (5, 7, 9) because no retrig can land on the half-row — get the feel with tempo instead. vegas's tip of 1996 is the same arithmetic from the other side: "Use EVEN speed values like 2, 4, or 6, to make your retrigs sound smoother" — Qxy intervals that divide a speed-6 row evenly (source: s-tw062-interview-vegas). Recipes: ride cymbal Q43 (32 → 24), a snare roll Q53 then Q43 on consecutive rows, and the tom "thwump" QC2 from volume 04 rising by 8 per hit (source: s-tw058-the-finishing-touches). Q00 reuses the last value (volume-slides). ST3's manual gives the same table (with 8 marked "?") and the worked examples Q72 at speed 8 = 64, 32, 16, 8 and QC2 at speed 6 = 12, 20, 28 (source: s-st3-manual). ProTracker's E9x retrigs every x ticks — "If you retrig with 1 in speed 6 that note will be trigged 6 times in one note slot. Retrig on hi-hats!" — and FT2 keeps E9x and adds Rxy with the volume table, which OpenMPT calls "very buggy" (a volume command in the same cell skips ticks) (sources: s-protracker-23d-help, s-ft2-manual, s-openmpt-manual-compatible-playback). IT-compatible players refuse to retrigger a channel that has already stopped, so a very short hi-hat sample needs a silent loop at its end (source: s-openmpt-manual-compatible-playback).

Sample offset tricks › Impulse Tracker semantics #

Oxx starts at the xx00-th sample (so byte xx00h × 2 for 16-bit samples); SAy supplies the high digit for offsets beyond FF00; an offset past the end is ignored unless Old Effects is on, in which case the sample plays from its end; the manual's own uses are skipping a loud attack or starting speech mid-way (sources: s-it-manual, s-ittech).

Sidechain pump › Impulse Tracker / OpenMPT #

Three levers, in increasing order of tidiness (source: s-it-manual):

• Dxy volume slides typed per row, the crude version (volume-slides).
• Mxx channel volume (0–40h) with Nxy channel volume slide — one command per channel per beat, no per-note volumes to edit, and it survives copy-paste of the notes. This is the closest thing a tracker has to a sidechain bus: put M20 on the beat row and N0x after it on every channel that should duck. S3M players only support M/N as an extension, so a song that needs them should stay .it.
• Vxx global volume with Wxy global volume slide ducks everything including the kick, so it is a mastering lever rather than a pump — and IT's Vxx affects notes already playing, unlike ST3's.

Or bake it into the instrument: a volume envelope that starts low and rises, retriggered every beat, pumps without a single command in the pattern (instrument-envelopes; source: s-037-lab). Keep the global volume high while doing any of this — at V05–V08 a volume-column fade jumps instead of sliding (source: s-it-hints).

Song initialisation and looping › ST3 / Impulse Tracker #

Put a silent dummy pattern first in the order list:

 1 | ^^^ .. .. X3C | ^^^ .. .. X40 | ^^^ .. .. T7D | ^^^ .. .. A06 |
 2 | ... .. .. C00 | ... .. .. .00 | ... .. .. X44 | ... .. .. X40 |

^^^ cuts anything still ringing from the previous loop, Xxx sets each channel's pan (works in S3M too), T7D/A06 set tempo 125 and speed 6, C00 breaks to the real first pattern after a fraction of a second. If you fade the global volume out at the end, reset it here too (volume-slides). At the end, put C00 on the same row as the final AFF so the pause lasts one slow row and the song restarts; give the Cubic player a row or two of AFF before the break because it stops on C00 immediately.

Jumps and breaks by format (sources: s-protracker-23d-help, s-ft2-manual, s-st3-manual, s-openmpt-manual-effect-reference, s-openmpt-manual-compatible-playback): ProTracker Bxx jumps to a hex position and "also perform[s] a pattern-break" — "you can use this command instead of restart as on Noisetracker"; Dxx breaks to a decimal line; F00 stops the song. FT2 Dxx takes a hex row (D16), and its E60 loop start has a bug: the next pattern begins on the loop row unless the pattern ends with D00. ST3 Bxx is hex, Cxx decimal, SB0/SBx loops never cross patterns. IT/OpenMPT: Bxx + Cxx on one row jump into the named pattern at the named row; a Bxx right of a terminating SBx cancels the loop. Song length in MOD is "one more than the last position" and NoiseTracker's restart byte is unused by ProTracker.

Song initialisation and looping › Chip trackers: the loop is in the orderlist, and it does not reset state #

On the C64 there is no song header to fall back on — the tune is code with an init entry point that runs once (init at the load address with the subtune number in A, then play every frame) and an orderlist that jumps back on itself (source: s-sid-wizard-manual; sid-player-routine). Everything the init call does not set is whatever the last pass through the song left behind. Three documented cases, and they agree:

• goattracker: the orderlist ends with an RST endmark carrying a restart position, and its TRANSPOSE entries are "reset only at song start" — so a transpose written near the end of the list is still in force on the next lap unless the list re-states it. Two editor rules go with it: TRANSPOSE must precede REPEAT, and the entry before RST must be a pattern or the editor halts playback (source: s-goattracker-readme).
• sid-wizard: orderlist values are $01–$7F pattern, $80–$8F/$90–$9F transpose down/up ($90 = original), $A0–$AF main volume, $B0–$EF track tempo, $FE end (the track halts) and $FF xx jump to position xx — and each track has its own list and advances independently, so each has its own loop point and they need not be the same length (sources: s-sid-wizard-manual, s-duet-research-sidwizard). Transpose, volume and tempo are orderlist entries, which is the cure: re-state them at the jump target rather than trying to undo them at the end.
• The drivers do it the same way, bugs included. In Charles Deenen's Maniacs of Noise player $ff restarts the sequence without resetting the transpose (source: s-realdmx-deenen-test-tunes); in Johannes Bjerregaard's, $FF restarts all three voices at once, so one voice's loop point is the song's (source: s-realdmx-bjerregaard-player). The Dominator player separates the two endings outright: $FF repeats the track, $FE ends the music — and $FE triggers an automatic fade, storing $5F in FADE and decrementing $D418 every $5F frames until the tune-number flag clears (source: s-sidin14-dominator-player).

The rule that follows is the same one catspaw gives for modules, stated in registers: anything sticky — transpose, main volume, tempo, filter state — must be re-stated at the loop target, not merely avoided at the end.

Stereo panning › Impulse Tracker internals and hints #

• Separation (F12): 128 for speakers close together, 80 far apart, about 40 for headphones — the listener's control, so compose at full width (s-tw075-it-percussion-tips agrees). Pan chain: channel pan, overridden by the instrument's default pan, offset by pitch-pan separation (higher notes drift right, lower left, around a centre note) — Pulse: "a very convenient way to achieve a nice pan", and avoid having too many samples at centre. S91 = surround (centre on hardware mixers), Pxy slides the pan, Yxy panbrello with S53 random waveform jumps to a new random position every x frames; the GUS only has 16 pan positions (sources: s-it-manual, s-ittech, s-it-hints).
• Two-channel width (Onix4MAN): the same note on two channels panned 00/64 — either offset the second by a row, or delay it with SDx (finer, x < speed), or duplicate the instrument and give one copy a pitch envelope that dips for a tick (leaves volume and effect columns free; bad for pianos). StereoMan's flanging pair at X00/XFF ("a smooth three dimensional sound") and echo pairs at X22/XDD (source: s-it-hints).

Vibrato and delayed vibrato › Impulse Tracker details #

Hxy speed x depth y; Uxy is four times finer; S3x picks the waveform (0 sine, 1 square, 2 ramp down, 3 random); Kxy adds a volume slide; H00/U00 reuse the last vibrato of either kind. IT's vibrato is updated every tick and is "two times finer" than ST3's — with Old Effects on it reverts to ST3 depth and timing. Samples also carry their own vibrato (speed 0–64, best 24–48; depth; rate = how quickly it sets in — a built-in delayed vibrato) (sources: s-it-manual, s-ittech).

Volume slides, fades and effect memory › More from the IT manual #

D0F/DF0 slide by 15 on every frame for S3M compatibility — in openmpt that behaviour is a per-song switch rather than a command trick: Fast Volume Slides applies slides on every tick "as Scream Tracker 3.0 did", so an imported S3M keeps its original slide rates (source: s-openmpt-manual-song-properties); Alt-K slides the volume column linearly between the block's ends (twice removes all volumes), Alt-X does the same for effect values (pan, offsets, global volume), Alt-J amplifies a block's volumes 0–200 %; the global volume Vxx (0–80h) affects notes already playing, unlike ST3. Keep the global volume high: at 5–8 a volume-column fade jumps instead of sliding (Nacho) (sources: s-it-manual, s-it-hints).

Vibrato and delayed vibrato › Iseq (2002): vibrato as an additive list #

Steve Judd's iseq has no vibrato command; an instrument's frq+ list is added to the current frequency on every player call, so a vibrato is frq+ 0100 0200 0100 0000 ff00 fe00 ff00 0000 looped — Judd's own example, with the caveat that it is "not 'proportional' — you wouldn't use the same modulations at low and high frequencies" and the upside that one list can also carry a rising frequency, an ornament or an "asymmetric" vibrato. His Commando lead uses frq+=0000 0040 0080 00c0 00c0 0080 (source: s-sidin01-iseq).

• Why Galway's middle phase is twice as long: Tognon's figure for the Arkanoid vibrato (+$14 × 3, −$14 × 6, +$14 × 3 after $1E cycles) shows the first phase climbing from the note's pitch to the top, the double-length second phase crossing to the bottom, the third returning to the centre — "necessary for having the correct up/down sequence" — before flag $05 restarts the phases from the current frequency (source: s-sidin04-galway-arkanoid).

Wavetable programming (waveform / arp tables) › Iseq (2002): the three-call drum #

Judd's description of a drum in his register-level editor iseq is the recipe every table player encodes: "1st player call: waveform=$81 freq=$a000 (or whatever); 2nd player call: waveform=$11 freq=$a000; 3rd player call: waveform=$41 freq=original value" — the instrument's fixf "restores the frequency, that's all". His Commando crash is two calls of noise at $0F82 then $1F04 with control $81, $80; crish-v1 runs creg=15 81 81 15 — triangle + ring modulation, noise, noise, back (source: s-sidin01-iseq).

Chord arpeggio (the 0 3 7 trick) › JITT64 (2010) #

Pattern command 05: the parameter byte packs a speed in bits 7–6 (0–3 ticks between steps), a first offset in bits 5–3 and a second offset in bits 2–0 that is added to the first arpeggio note, not to the root — so $23 (offsets 4 and 3) gives root, +4, +7, a major triad; the player cycles root → note 1 → note 2, a new note in the pattern clears the command, and 00 with bit 0 stops it. Chords of more than three notes, or offsets above 7 semitones, need the instrument's relative-note column instead (sources: s-sidin13-inside-jitt64, s-sidin13-jitt64-tracker).

• matt-gray-player, the 2015 readings: in V4.2 the plex is a pattern command, $FD ci — c notes from table i, so $FD,$36 plays table 6 as a three-note chord and $FD,$40 the first four entries of table 0 — and it persists until the next instrument or slide; Tognon's empty template offers 16 tables (nine of three notes, four of four, three of two: "95% of arpeggio are based into 3 values") (source: s-sidin14-dominator-player). The earlier Serpent Demo build keeps the arpeggio in instrument byte 5 and lists eight four-note chords with the octave on top — $00,$03,$07,$0C, $00,$04,$07,$0C, $00,$05,$07,$0C, $00,$04,$09,$0C, $00,$03,$08,$0C, $00,$05,$09,$0C, $00,$07,$0A,$0C — and one running downward, $13,$0C,$07,$00 (source: s-sidin15-serpent-demo-player).

Filter programming on the SID › JITT64 (2010), two tiny players, and an 8580 trick #

• jitt64: three pattern commands — 0D filter type (high/band/low pass and the voices to filter), 0E resonance (0–15), 0F cut-off — and three instrument columns: cut-off relative or absolute (values from the instrument's own table), resonance fixed / add / subtract, and a type entry of six checkboxes (HP, BP, LP, voice 1, 2, 3), each with the D/N delay/repeat field; the player keeps them in shadow registers (shadow_FCH, shadow_RES, shadow_TYPE) written after the three voices. The example "filtered bass drum" moves the cut-off per tick (sources: s-sidin13-jitt64-tracker, s-sidin13-inside-jitt64).
• 512 and 256 bytes: Plaster sweeps the cut-off high byte between $3F and $FF one step per frame with $D417 = $F1 and $D418 = $3F; Back To Basics writes the same counter to $D416 that it uses for pulse width, with $D417 = $F4 and $D418 = $1F (source: s-sidin12-tiny-sid-2-part-3).
• freedom's reason to prefer the 8580: "when you change filter type you don't get an unwanted noise as noticeable as the one you hear in 6581. This makes it possible to change filter type on an instrument while a note is being played and you get more sophisticated sounds" — but "way too open filters"; tsm adds that every 8580 sounds the same, unlike the 6581 (source: s-sidin13-tsm-freedom-interview). hermit in 2008: the 6581 "has good bass-filter behavior for older compositions", the 8580 "is more accurate" (source: s-sidin12-hermit-interview).

• Two 1980s filter policies from the SIDin interviews: matt-gray wrote no filter code until after Dominator — "I only started using them post Dominator on Vendetta … I was well aware of the filter inconsistencies and wanted to avoid using them, but eventually I needed the extra palette of sounds" (source: s-sidin15-matt-gray-interview), and elsewhere: "Initially, like others I didn't use the filters because they often sounded very different on another machine, but eventually I simply had to just to move the sound on" (source: s-vandalism63-matt-gray-interview); scarzix's 6581 had "a very light filter", so when the programmer could not hear CombatZone's leads the game got a filter on/off option in its menu (1989/90) (source: s-sidin14-scarzix-interview).

Hard restart › JITT64 (2010): hard restart as five instrument fields #

Tognon's jitt64 makes every part of the restart an explicit per-instrument setting (sources: s-sidin13-jitt64-tracker, s-sidin13-inside-jitt64):

• Three choices: no action ("all is left to you for preventing ADSR bugs"), Gate off N ticks before the end of the note, or Hard Restart — N ticks before the end the player writes Attack/Decay HR, Sustain/Release HR and First Control HR, and on the last tick before the new note Second Control HR. N is capped by the pattern tempo (timing 3, ticks 4 → 3 effective).
• A per-instrument write order, Wave–ADSR or ADSR–Wave, "for letting you obtain good hardrestart (some one need accurate write timing to be achieved)" — the choice GoatTracker makes globally with its attack-F playroutine.
• Two test-bit recipes: (a) HR AD/SR set, first control with the gate released, second control $09 (test + gate), at least 2 ticks, order ADSR–Wave; (b) both HR controls gate-off, one tick, and the instrument table's first row sets ADSR and wave $09 before the real waveform, order ADSR–Wave.
• In the player the instrument record starts with an HR byte (low nibble = ticks, bit 7 = full HR rather than gate off) and AD, SR, CTRL1, CTRL2; the hard-restart block runs last in the interrupt so that it overrides every other command, and the SID is written from shadow registers at the start of the next interrupt so that all voices — and the HR frame — land together; Tognon restructured the routine because variable block timing "can cause some hard-restart of note problem too". A hard-restart pattern command was still on the to-do list.

And a hard restart in 512 bytes: GRG's Tiny Sid Compo II winner Plaster writes SR $01 and AD $0F when a note's remaining duration reaches 1 — the 0F01 value — and starts every control sequence with $09 then $81 (source: s-sidin12-tiny-sid-2-part-3); the same GRG is credited above with the "soft restart".

Pitch slides and tone portamento › JITT64 (2010) #

06 xx / 07 xx add or subtract xx twice per tick ("the amount (*2)") to the 16-bit frequency until 00 (bits 1–2) stops them; 08 xx is a tone portamento entered on the same row as the target note: the player takes the new note's frequency as the target, restores the previous frequency as the start, chooses the direction by a 16-bit compare, moves xx × 2 per tick and snaps to the target when it is passed, then clears the command. Portamento at instrument level uses the frequency column's relative-frequency entries; a note-independent "hifi portamento" was planned (sources: s-sidin13-inside-jitt64, s-sidin13-jitt64-tracker).

Pulse width modulation (PWM) › JITT64 (2010) and the 512/256-byte players #

• jitt64: pattern commands 0A xx / 0B xx add or subtract xx per tick to the 12-bit pulse value (carry into the high byte, no bounds) until 00 with bits 5–6 stops them; in the instrument table the Pulse column takes fixed values (0–2048, from the instrument's own value table) or relative steps, the D/N field setting how many ticks each step holds and repeats — that is how the example instruments do "a 'vibrato' to the pulse" (Emil's string, a Dane lead, Matt Gray's bass) and "a 'portamento' onto the pulse" (the filtered bass drum, the other Dane lead) (sources: s-sidin13-jitt64-tracker, s-sidin13-inside-jitt64).
• The 2005 512-byte entries are three variations on a free-running counter (source: s-sidin08-tiny-sid-512b): Crue Gurl steps the pulse high byte for voices 1 and 3 from pwmMin = 3 to pwmMax = 6 every four frames, wrapping — with the source's own warning that the step counter pwmSpeed = 3 ; must be (n^2)-1!!!! because the code masks rather than compares; laxity's Twone Five gives each voice a start high byte (pulsehi $08,$01,$04) and adds a per-voice constant (pulseadd $00,$10,$3d) to the low byte at every SID write, so voice 3 sweeps fast and voice 1 not at all; 4mat's Empty makes it an instrument parameter — one instadd byte per instrument ($1c,$0c,$00,$15,$00,$74,$a5) added to the pulse low byte each frame, with the pulse high byte packed into the low nibble of instpuls.
• In GRG's 512-byte Plaster the pulse low byte of each voice is simply incremented by $18 every frame from high bytes $08, $08, $04 — a free-running sweep with no bounds; in Jaymz Julian's 256-byte Back To Basics one counter, incremented every four loops, is written as the pulse high byte of all three voices with the voice offset added, and as the filter cut-off at the same time (source: s-sidin12-tiny-sid-2-part-3).

• matt-gray-player V4.2: the bounce limits became part of the instrument — byte 14 holds them as nibbles $LH, i.e. between $0Lxx and $0Hxx ($8E = the Driller $08–$0E; $33 keeps the width "around" $03xx; $35 = $0300–$0500); byte 0 is the start width as swapped nibbles ($23 → $0320), byte 4 the per-frame step. Tognon's worked example: start $0320, step $A0, limits $18 → 800, 960, 1120 … 2080, then down to $01xx and back (source: s-sidin14-dominator-player).

Vibrato and delayed vibrato › JITT64 (2010) #

Command 09 xy: y + 1 ticks per leg, and each tick adds or subtracts (x + 1) × 16 to the raw 16-bit frequency; the first leg lasts one speed count and the following ones two (plus the reload tick), so it starts with a half period — a triangle on the register value, deeper in cents at low pitch like the matt-gray-player's and unlike Bjerregaard's semitone-proportional one; 00 with bit 4 stops it, and a "hifi vibrato … independent from octave/note" was planned. Instrument-level vibrato goes in the frequency column as relative-frequency entries timed by the D/N delay field (sources: s-sidin13-inside-jitt64, s-sidin13-jitt64-tracker).

• matt-gray-player V4.2 adds a per-note vibrato delay: pattern byte $F9 nn counts down before the instrument's vibrato (step in row byte 8, length in byte 9, the same down / up / up / down / down triangle as Driller) starts (source: s-sidin14-dominator-player). Gray in 2015: "My vibrato routine was very different to his [Hubbard's] and Martin Galway's" (source: s-sidin15-matt-gray-interview).

Wavetable programming (waveform / arp tables) › Two more starts: Plaster's $09,$81 and JITT64's noise drums #

• GRG's 512-byte Plaster keeps its "wavetables" as three control-register sequences shared by five instruments — $09,$81,$41,$00, $09,$81,$11,$11,$11,$11,$11,$00, $09,$81,$41,$40,$40,$80 — every sound opening with a test-bit frame and a noise frame, and a parallel list supplying fixed high-frequency bytes ($8B,$89,$86,$84, $8E,$8C,$8A) for the drum steps (source: s-sidin12-tiny-sid-2-part-3).
• jitt64's wave column is one of eight per-instrument columns with a delay/repeat field per row (0 = keep the waveform); its example bank builds bass drums and Matt Gray's snares from "fixed notes" in the frequency column and noise in the wave column, a second bass drum with "more low pitch notes and less noise", and a sea effect from noise with a very long attack/decay and no sustain (source: s-sidin13-jitt64-tracker).

Channel interleaving (one channel, two jobs) › LSDj #

The Game Boy scene's rule, from the LSDJ Advanced Tricks thread (source: s-chipmusic-lsdj-advanced-tricks): never dedicate a channel to one job. "You can have kicks, snares, toms, lead, bass and chords all in one channel and in one pattern if you mix it up and alternate" (SketchMan3); the wave channel carries kick, bass and snare (Saskrotch, Zef); arps and echoes go between pulse kicks (roboctopus); envelopes (E) let a note ring through an instrument switch (defiantsystems); "you'd be surprised at how many gaps in the music the listener's brain fills in on its own" (Victory Road); and "Dont be afraid of silence" (herr_prof). The noise-drum threads add the percussion side: one drum at a time per channel, so introduce instruments one by one and let the ear keep them (Vegasdiamond, borrowed from beatboxing), fit hi-hats on the step before with D02/D05, use the noise channel to accent a pulse bass instead of spending a channel on it (herr_prof), and layer three-channel kicks and snares (Analog) (source: s-chipmusic-noise-drum-threads).

sabrepulse's beginner tutorial teaches the trick in the very first song (source: s-sabrepulse-getting-started-with-lsdj): because the wave-channel kit kicks are "really weak and not very loud", a PULSE kick instrument (envelope F1, duty 50 %, a table with PF1 and a K00 near its end) goes on rows 0, 4, 8, C of PU1 and the bass C3 on rows 2, 6, A, E — "Kick, Bass, Kick, Bass" — leaving PU2 for the lead and NOI for snare and hats; the K00 clears the channel before each bass note (instrument-design).

Chord arpeggio (the 0 3 7 trick) › LSDj #

• Cxy chord command: runs an arpeggio of base, +x, +y semitones once per tick: C37 plays 0, 3, 7, 0, 3, 7… (minor), C47 major, C0C = 0, 0, C (octave on every third step), CC0 = 0, C alternating, CCC = 0, C, C; C00 resets. The instrument's CMD/RATE slows it down (0 fastest, F slowest).
• Table arpeggios for anything longer than three notes or with its own rhythm: put semitone offsets in the table's transpose column (the manual's example forms a major chord) and loop with H; the table speed follows the groove selected with G (instrument-tables).
• Chains carry a transpose per phrase, so the same arp phrase serves every chord of a progression (orderlist).

(source: s-lsdj-manual)

Before 9.1.0, C on noise instruments alternates between the base shape and base + value on every tick (C01 on shape FF gives FF, F0, FF …) rather than a pitch interval; the table transpose column is 01–7F up, 80–FF down (sources: s-intense-tech-17-the-joys-of-noise, s-intense-tech-09-lets-table-this-discussion). From 9.1.0, with the noise channel reorganised into ordered notes, C on noise arpeggiates like on pulse and wave, limited to the notes the channel has: F 5 with C12 gives F, G# and C — an F minor triad — and larger values span octaves (source: s-intense-tech-19-new-noise-and-910-news).

Two more intense-tech details: the speed setting began as FX/SPEED in version 7 (7.7.4), renamed CMD/RATE in version 8 (sources: s-intense-tech-12-scoping-out-new-features, s-intense-tech-14-lets-appreciate-version-8); and C37 followed by Z10 on later steps plays the chord randomly as minor or major, possible since version 6 made the Z digits independent (randomization-and-probability; source: s-intense-tech-03-dont-sleep-on-z). sabrepulse's tutorial introduces the command with C07 on the first note of the lead — "magically transformed into a chord" — and suggests trying it on a couple more notes (source: s-sabrepulse-getting-started-with-lsdj).

Community practice (sources: s-chipmusic-tables-and-chords-threads, s-infu-getting-started-with-lsdj, s-intense-tech-06-groove-and-tick-tricks-part-1): LazierGunz's cheat sheet writes chords as hex transposes — the values are interval positions counted from 0, so a major-seventh table is 00 04 07 0B 0C 07 04 00 (C E G B C B G E); slow it with G01 on the table's first line and groove 01 = 2/2 rather than doubling rows; 00 04 00 07 00 0B 00 0C is a texture. The C command's speed is fixed, which is why tables win for anything expressive; danimal cannon: go down, out of order, add octave notes, use five-note patterns over more than an octave — "just don't go up the chord every time the same way". Arpeggios can also be phrases: a 3-tick groove and H71/H5A loops turn one phrase into a long arp. Infu's beginner pair: C47 major, C37 minor.

Grooves are the table's speed control (source: s-painperdu-06-grooves, credited to Joe Toye of Chiptune Belgium). "By default tables run at one tick per step", but a G command inside a table sets that table's speed — which halves what a slow arpeggio costs: "if I wanted to make a long arp that actually took two tables to make, that was a bit of a hassle; thanks to that trick I can now use half the space and control exactly how fast my tables go". A faster groove does the reverse, packing more commands into the same time for a percussion table. The workflow consequence is worth stating: with per-channel grooves, arps can live in phrases instead of tables — "if you're like me and you overuse tables for arps, using grooves and phrases might be a better idea". defense-mechanism makes the same point from the timing side: a table groove of 2, 3 or more ticks slows a table down for arpeggios and duty changes, and groove plus H combine "to create complex timing changes in both phrases and tables" (source: s-intense-tech-07-groove-and-tick-tricks-part-2; shuffle-funktempo).

Why the arpeggio exists at all, on this machine. Asked why C alternates instead of sounding a chord, the chipmusic-org answer is flat: "each channel is really just one channel"; slower table arpeggios come closest; "that's how the medium works, boss" (source: s-chipmusic-lsdj-faq). Hackaday's framing of the same constraint names the two classical escapes side by side — "clever composers evoke the feeling of multiple notes by quickly switching between pitches to make arpeggios that sound convincingly like chords, or switch between very different sound parameters to allow two different 'instruments' to share the same channel" — arpeggio and channel-interleaving, with the ghost-channel as the third (source: s-hackaday-gameboy-channelhacking).

Four notes, then five, then two channels (pain-perdu, source: s-painperdu-03-isometric-sav-walkthrough). C gives three notes at one tick each; writing the arp into a table at two ticks per note (00 44 77 CC — root, major third, fifth, octave) buys a fourth note and enough time to hear each one: "faster arps, you can just hear the click noise between each note and not really the note itself". Put the bass on the relative minor third instead of the root and the same table sounds a five-note chord. Then run both pulse channels on that table, one at 25 % duty and the other at 50 %, with the second offset by three ticks — at two ticks per note there are five usable offsets — and the pair reads as one wide sustained chord: "your brain just kind of glues them all together … you don't even hear the note switch in the arp, you just hear chords." Keeping the same instrument and swapping only the table (the same shape with a minor third for the minor chord) avoids one instrument per chord.

On the wave channel there is a way to get a second note without arpeggiating at all: draw it into the wave. The ghost-channel sounds base + harmonic simultaneously, which no C command can do — at the cost of being limited to the octave and the octave + fifth (source: s-chipmusic-lsdj-ghost-channel).

Detune › LSDj #

The pulse instrument's FINETUNE detunes PU1 downwards and PU2 upwards, and PU2 TSP. transposes pulse 2 — the manual notes these "create interesting phase effects when the same phrase is played on both pulse channels", which is the standard fat-lead recipe: one chain in both pulse columns. Fxy on a pulse instrument sets PU2 TSP (x) and finetune (y, 1/32 semitone per step) from a phrase or table; WAVE instruments have their own FINETUNE (source: s-lsdj-manual).

Version notes: the wave instrument got its own FINETUNE (-F…+F) in lsdj 7.7.4, and from 9.1.0 instrument FINETUNE has two digits — an old value of 01 equals the new 10 (sources: s-intense-tech-12-scoping-out-new-features, s-intense-tech-19-new-noise-and-910-news).

Fake echo / delay › LSDj #

Two native shortcuts: Rxy retrig with a decreasing volume digit — the manual's RF4 "retrig the sound every fourth tick, decreasing amplitude (echo effect)" — gives a same-channel echo without extra rows (retrigger); and a second pulse channel playing the same chain a few steps later with a lower E amplitude or a quieter instrument, panned to the other side with O (stereo-panning). Dxx delays a note by ticks for finer offsets than a step (source: s-lsdj-manual).

Hypnogram's groove delay: give the echoing pulse channel a groove whose first line lasts 0A ticks, so every note after it arrives 4 ticks late; the next phrase returns to groove 0 and keeps the offset; a second groove whose last line lasts 2 ticks cancels it — finetune the two pulses apart to thicken (source: s-intense-tech-07-groove-and-tick-tricks-part-2). danimal cannon's rule for a spare channel: double, echo, octave or detune what is already there, "compensate volume to taste" (source: s-chipmusic-lsdj-advanced-tricks).

A delay inside one channel (source: s-painperdu-03-isometric-sav-walkthrough): two instruments that differ only in panning — one L, one R — alternating in a single channel, playing the same phrase offset by three notes. "It's like a delay of this, offset by three, all in one channel." The alternative he names is an AUTOMATE table with L/R and an H (stereo-panning); he used two instruments because those instruments' tables were already busy with pulse-width modulation and a slight vibrato.

Typed echoes, and the two-position lag (source: s-lsdj-and-you-echo-chamber). Write the echo as notes in the gaps, played by a second instrument with the same sound at a lower volume and a shorter envelope — and pitch each echo to the note before last, not to the note it follows: in a C – B – G – E run, the echo after B is the C, the echo after G is the B. Carry the previous phrase's last note in as the first echo of the next so the loop stays continuous. From there: pan the echo instrument to one side ("panned echoes are often used in professionally produced tracks, and the trick works well in LSDJ"), or run an automated table that pans it left and right on alternate notes. Spending a second channel buys a chorus rather than an echo — copy the phrases into pulse 2, shift them one tick later, lower the volume and set PU FINE TUNE to 2, which "will create a sort of chorus effect when the notes play in unison with pulse channel one" (detune). roboctopus's habit is to leave the echoes to the end: "in the final stages of working on a track, I often look for every bit of free space in the patterns and see if I can add an echo here and there."

Filter programming on the SID › LSDj (the wave synth's filter) #

Not a filter on the output like the sid's, but a filter applied when the synth generates its 16 waves, so what it shapes is the wavetable itself. FILTER is Lowp / Highp / Bandp / Allp, with CUTOFF 00–FF and Q; both interpolate from the synth's first wave to its last (source: s-lsdj-manual).

These are not filters in the sid sense at all — nothing is filtered on the way out: "this is a wavetable synthesizer, it's not a subtractive synthesizer, so the filters that you see here are actually just kind of emulated … it will just generate what you might expect to see from these kinds of filters" (source: s-defensemech-wave-channel-ramble). What they shape is the 16 waves the synth writes.

Two things make it unusually literal. First, CUTOFF is calibrated in harmonics: every multiple of 10 is one partial, so bandpass at 20 sounds the octave, 30 the octave + fifth, 40 two octaves — the filter selects an interval (harmonic-series). Second, lowpass at CUTOFF 10 with Q 3 and VOLUME 08 leaves the fundamental alone, which is how you get a sine out of a channel that has no sine setting (source: s-intense-tech-01-wave-synth-deep-dive-part-1).

Walked up by ear on a bandpass with high Q, the whole series is audible: 10 fundamental, 20 octave, 30 fifth, 40 octave, 50 major third, 60 fifth, 70 an out-of-tune seventh, 80 octave, then 90 a major second, A0 a major third, B0 a sharp fourth, C0 a fifth, D0 a flattened sixth-to-seventh, and nothing much above that — "it probably only generates up to here really". On a square signal the even harmonics are simply absent: CUTOFF 20 changes the volume and nothing else, and the first thing that speaks is the fifth at 30 (source: s-defensemech-wave-channel-ramble). A sweep that must outlast one synth's sixteen waves is built as a chain of synths, one CUTOFF slice each, played in sequence (wavetable-programming; source: s-defensemech-learning-lab-shorts). A sweeping CUTOFF with a high Q is the channel's wah — start high, end low, PLAY ONCE, SPEED 3, LENGTH F.

Q is what makes a sweep audible rather than merely dark: "if you're just going to have a standard lowpass you're just gonna hear more and more bass and less and less treble; with the resonance you're gonna actually have some kind of a sonic cursor" (source: s-painperdu-02-wav-channel-walkthrough).

Because the synth screen is editable while the song runs, Q is also a performance control and not only an instrument setting: "altering Q in wave instruments while a song is playing is a lot of fun for sweepy type stuff" — and Lazerbeat notes it works in song mode, not just live mode (live-tracking; source: s-chipmusic-lsdj-live-performance).

Allpass is the odd one and the useful one for two-note sounds: it passes everything and shifts phase around the cutoff, so a high Q promotes one partial to near-melodic prominence while "no matter how much you boost this Q you really never lose the root note" — defense-mechanism's route to a power chord on one channel, with Q around 8–9 for the fifth. Lowpass gives a cleaner but thinner version of the same, with the harmonics above the fifth rolled away (source: s-defensemech-ghost-channel-allpass; the technique is ghost-channel). Whether the filter overdrives is decided by DIST and LIMIT rather than by the filter itself (wavetable-programming).

Ghost channel (two notes in one wave) › LSDj — drawn by hand (the original method) #

1. Draw the base. A sine (Lowp, CUTOFF 10, Q 3, VOLUME 08 is the cleanest sine the channel makes — source: s-intense-tech-01-wave-synth-deep-dive-part-1, collected on wavetable-programming) or any smooth wave, at every volume you want the base to take: "starting from silence all the way to the maximum volume".
2. Add the rider. On a copy of each base wave, push runs of samples up by a uniform amount — the same operation that turns silence into a square, applied to the sine as a baseline. Tyler Barnes counts "1 2 3, 1 2 3" for a rider three units high; the run length is the 16/x above. Repeat for each rider octave.
3. Add rider volumes. From each superimposed wave, "decrease those Peaks by one pixel every time until you get back to that original sine wave". A three-pixel rider gives three ghost volumes — the rider's dynamic range is its height.
4. Play it. The wave instrument's PLAY is MANUAL; the note in the phrase sets the base's pitch, the wave frame sets the ghost. "If I want to change the Octave of that square wave I'm going to be changing the frame … the sine wave stays the same octave but only the square wave moves." To move the base under a fixed ghost, do it in reverse: raise the note an octave and step the frame back by the compensating amount. Fxx steps frames relatively, F10 jumps a whole synth (source: s-lsdj-manual).

Labour savers from the thread (source: s-chipmusic-lsdj-ghost-channel): SELECT+B starts a selection, the cursor extends it and UP/DOWN offsets the whole run — this also copies, and SELECT+A pastes; holding A with LEFT/RIGHT or UP/DOWN mirrors the selection. "By using these tricks and abusing symmetries in the waveforms, you can speed up the manual labor a lot." A saw rider works too (steps of 1, 2, 3, 4), but a square rider was found to give "more octaves and a louder sine".

Ghost channel (two notes in one wave) › LSDj — with the filter (the cheap route) #

Boost the wanted overtone instead of drawing it. In the synth screen, Allp with a low CUTOFF and a high Q lifts one partial into audibility: "the idea that you can have extra notes in the wave channel — it's really talking about this overtone emphasis that sounds like almost two notes … you've got the low note but then also that octave, or three if you use allpass with Q boosting that fifth: the power chord" (source: s-defensemech-ghost-channel-allpass). Allpass over lowpass, because "no matter how much you boost this Q you really never lose the root note"; lowpass when you want the fifth alone and the top rolled off, which is cleaner but thinner. A Q around 8–9 is where the fifth sat for defense-mechanism — lower is "kind of subtle", higher "too much".

CUTOFF is calibrated in overtones, so the interval is choosable rather than hunted: every multiple of 10 is one harmonic — 20 the octave, 30 the octave + fifth, 40 two octaves (source: s-intense-tech-01-wave-synth-deep-dive-part-1). That also makes bandpass at CUTOFF 30 with a high Q a third route to the same power chord (inference from the same source — untested here).

Ghost channel (two notes in one wave) › LSDj — crunched from audio #

Render the two-note chord you want in any synth or DAW, then let lsdj-wave-cruncher reduce it to a 16-frame synth and liblsdj's lsdj-wavetable-import patch it into the song. This is exactly what the 2013 thread asked for and did not have — "i wonder if there's a tool that can autogenerate these waves and spit out an lsdsng" (source: s-chipmusic-lsdj-ghost-channel); the tooling arrived later (sources: s-intense-tech-05-wave-cruncher-instrument-library, s-intense-tech-08-dotcnts-wave-cruncher). The harmonic constraint still applies: a crunched interval that is not a harmonic of the played note will beat against it.

Instrument design beats note count › LSDj #

The manual's synthetic drum recipes (chapter 3.6) — they free the wave channel's kits for other duties:

Envelopes are ENV. triples of amplitude + speed (32/AD/10: attack from 3 to A at speed 2, slow decay to 1, hold); E and the table envelope column override per note. Kit instruments give real drum-machine samples (TR-808/909/606/707/727, CR-78, LinnDrum, DMX…) with OFFSET/LOOP/CLIP and the S loop-point and F offset commands for timbral tricks. Dxx delays and Rxy retrigs help flams and rolls (retrigger) (source: s-lsdj-manual).

What the chip adds to these recipes (sources: s-pandocs-audio-registers, s-pandocs-audio-details): the noise channel is a 15-bit LFSR clocked at 262144 ÷ (divider × 2^shift) Hz — a lower clock sounds "harder", a higher one "softer" — and its 7-bit mode gives "more regular output; some frequencies sound more like pulse than noise", LSDj's pitched noise. Switching from 15- to 7-bit mode can lock the generator into silence until it is retriggered: the hardware reason for PITCH = SAFE. The PU1 bass drum's SWEEP is register NR10; an upward sweep that overflows switches the channel off, a downward one stops at period 0 (pitch-slide-and-portamento). K clicks because switching a channel's DAC off pops, while volume 0 with the DAC alive is silent — presumably what the click-free E00/E11 do (inference).

Defense Mechanism's recipes (intense-tech, LSDj 6–9; sources: s-intense-tech-10-kicks-part-1, s-intense-tech-11-kicks-part-2, s-intense-tech-17-the-joys-of-noise, s-intense-tech-18-adsr-makes-life-easier, s-intense-tech-12-scoping-out-new-features, s-intense-tech-15-lets-mix-it-up-and-down):

The noise shape chart (first digit octave, second digit divisor, 0–7 short-loop, 8–F long-loop) is on lsdj. Heard in: .exe's NOIZE JAMS and a demo by they/them use the noise channel alone (source: s-intense-tech-17-the-joys-of-noise).

Noise drums since 9.1.0 (sources: s-intense-tech-19-new-noise-and-910-news, s-intense-tech-21-whats-new-in-lsdj-92): the shape bytes became ordered notes — long-loop noise as 00–3B from low to high, short-loop noise as the note names C, D, F and G# in octaves −9 to 8 — and P now sweeps them smoothly (P01 applies S01 every 4 ticks, P04 every tick), so a kick, a hi-hat and a crash can come from one instrument with P in the phrase instead of a hand-made S table. Old songs convert their noise notes but not their transposes or S values; read from the article's converter, the noise-kick recipe above becomes C 0 for the base 95, C 1 for the tick-one A5, then C-1, F-2, D-2, D-3, D-4, D-5 — a plain descending line. S MODE FREE/STABLE was removed in 9.1.0 and, after random mutes turned out to happen inside one loop mode as well, replaced in 9.1.3 by PITCH FREE (the old STABLE: restart only when going from long-loop to short-loop) and PITCH SAFE (restart on every value change — rougher, but "guaranteed never to mute"); noise instruments also gained TRANSP, C arpeggios limited to the available notes (F 5 with C12 = F, G#, C) and a tick-based V. Emulators (BGB, SameBoy) and most Game Boy Advance models never mute; many Game Boy models still can.

A beginner's set from sabrepulse's tutorial (undated, pre-8.1 ENVELOPE field; source: s-sabrepulse-getting-started-with-lsdj):

Community recipes (sources: s-infu-getting-started-with-lsdj, s-chipmusic-noise-drum-threads, s-chipmusic-tables-and-chords-threads, s-chipmusic-kotlinski-interviews):

Layering advice from the same threads: a high-toned wave kick under a noise snare "gives a really full and thick tone"; a wave-bass table with a short attack layered under the snare; noise + pulse snares "à la C64"; a loud hi-hat-like first row before a kick's sweep makes hi-hat + kick in one instrument; and "a noise kick is never going to blow out your subwoofer".

Where the wave-channel instrument material lives. Designing a WAV instrument is mostly designing its synth, so that whole body — the synth's SIGNAL/FILTER/DIST/PHASE chain read as harmonic content, LIMIT as the volume control the hardware lacks, the LENGTH interpolation chart, hand-drawn banks, and the sixteen-hand-narrowed-waves PWM instrument — sits on wavetable-programming (sources: s-intense-tech-01-wave-synth-deep-dive-part-1, s-intense-tech-02-wave-synth-deep-dive-part-2, s-lsdj-and-you-pwm). Two design decisions worth restating here: an instrument's envelope can be its own sidechain — on the wave channel E02 is 50 % and E03 100 %, so 02 then 03 on the steps after the kick is an audible pump locked to the 16th, and on the pulse and noise channels a per-beat envelope "that starts from zero and rises at the speed of A" makes hats and pads pump even where no kick plays (sidechain-pump; source: s-painperdu-04-sidechaining) — and the kick and bass sharing WAV is already a sidechain, so what you actually design is the recovery.

The noise channel after 9.1.0 (source: s-defensemech-noise-channel-92l). The channel was rebuilt, so older tutorials no longer apply: shapes now run ordered low to high (00–~$3B are the long-loop, noisy ones; past either end you cross into short-loop pitched noise, labelled with the nearest note name), and C chords, P pitch bends, V vibrato and S all work on it. Design consequences:

• Set the envelope instead of chaining E commands — "a much faster and easier way … and then I can just work on setting transpose commands". A snare is that envelope plus a couple of rising transposes, stopped with A20 or K.
• R is the dynamics tool the hardware envelope cannot be. Hardware envelopes are one smooth slope, so a decaying repeat cannot be written with E; R with a volume digit "will reduce this by one level and keep these numbers" — ghost snares, quieter repeats, and triplet fills at a four-tick retrig (retrigger).
• Hardware LENGTH still has one job: it overrides an E command, "so it kind of puts a cap on how long this envelope can actually be" — useful under a rising envelope.
• Why PITCH SAFE exists, in hardware terms: the LFSR "sometimes … creates zeros, and that results in silence", so on real hardware (DMG, old CGB, some GBA units, the GameCube Game Boy Player) a pitch slide can simply cut out with no K. SAFE re-initialises the channel on every pitch change so it never cuts out, at the cost of a harsher texture — recoverable in part by slowing COMMAND RATE. Current SameBoy and BGB emulate the cutout; older builds do not, so a patch that works in an old emulator can die on hardware.

The SPEECH instrument, from people who have used it (source: s-chipmusic-lsdj-speech-synthesis). Jotie, who has shipped several: "It's slow, difficult and in my opinion, flawed. You can't delete wrong letters." The workflow that makes it tractable is to compose the allophones outside LSDj — "download an Atari ST emulator and write your lines in STSPEECH — it will show you how to do what you just wrote in allophones" (Steem SSE) — and transcribe the result into the word screen. Two craft notes: speech sits in the centre with everything else panned away from it, because "mixing is the only thing that is going to make your speech stand out" (stereo-panning); and phrase it musically — "don't put them on every downbeat tick, try and give them space and change the syllable when it's natural to do so". Scale the ambition to the tool: a hook, not a monologue.

An echo is an instrument, not an effect (source: s-lsdj-and-you-echo-chamber): a second instrument on the same channel, same sound, lower volume and a shorter envelope, with the echo notes typed into the gaps. The pitch rule is what makes it read as an echo — "the echoed note corresponds to not the note it immediately follows but the one before that" — a two-position lag, and the echo of the previous phrase's last note opens the next phrase so a loop stays continuous. Pan the echo instrument to one side, or table-pan it side to side for ping-pong. The expensive version is a chorus: copy the phrases into PU2 shifted one tick, drop the volume and set PU FINE TUNE to 2, "which will create a sort of chorus effect when the notes play in unison with pulse channel one" (fake-echo, detune).

Designing instruments that have to share a channel (source: s-chipmusic-lsdj-advanced-tricks). The thread's consensus is "definitely don't use one channel for just kick drums" (Saskrotch) — the wave channel does kick, bass and snare — which puts requirements on the instruments themselves: E commands so a ringing note survives an instrument switch, tables that end in "wild pitch commands … to add subtle little bleeps and bloops" (defiantsystems), and drums layered across channels rather than owned by one. danimal cannon's use for a free channel is entirely instrument design: double, echo, octave or detune what is already there, volume-compensated. Victory Road's caveat is the reason it works at all — "you'd be surprised at how many gaps in the music the listener's brain fills in on its own" (channel-interleaving).

Lead articulation (velocity, legato, late vibrato, drop-off) › LSDj (wave channel) #

The wave instrument's table does the articulating, and the trick is that a note without an instrument number does not restart the table (source: s-chipmusic-lsdj-wav-instrument-tutorials):

• Attack / tonguing. Make the synth's first frame noticeably louder than the rest, set PLAY to MANUAL and put F01 on the first tick of the instrument's table. Every note that carries the instrument number gets the loud frame as its attack; notes typed without it are slurred into the previous one.
• Flutter tonguing. Give a third frame a slightly different volume and shape and alternate between two frames from a second table — F01 forward, FFF back (FFF is −1 in F's relative arithmetic) — started from the phrase with an A command.
• Breath. A frame or two of near-noise at the start "simulate[s] the attack phase of a musician blowing into the flute" (tyler-barnes); a very quiet noise-channel layer with a slow decay underneath does the same job from outside.
• Vibrato with varied Vxx speeds rather than one fixed setting (vibrato). Victory Road's verdict: "it's all about articulation, really. LSDJ is really good for flutey articulation."

Worth reading against the counter-argument in the same thread: chasing an orchestral instrument on the Game Boy mostly disappoints, and "other people will only hear '8bit' anyway" (an0va) — the articulation is worth more than the timbre.

Multisampling and drum-kit instruments › LSDj kits #

The Game Boy's version of a drum-kit instrument, and it is a real map, not a metaphor. A kit instrument names two kits: "the first kit will be used in the left note column in the phrase screen; the second kit will be used in the right note column" — so one instrument addresses two banks of samples, selected by which column the note is typed in (source: s-lsdj-manual). Each kit holds 15 sample slots inside 3FA0 bytes — "just over two seconds worth of audio per kit, so whatever you put in has to count!" — at 11.468 kHz (source: s-little-scale-lsdj-kits; preparation is on chip-samples, patching on lsdpatch).

What that budget forces is the opposite of the IT piano: a themed set is split across slots, not crammed into one. little-scale's own releases show the convention — Mario Paint, "29 samples from the SNES program spread across two kits"; Street Fighter 2, "17 samples in 6 kits"; Street Fighter Alpha, "34 samples in 4 kits with one kit per character". Budget two to six kit slots for a voice or sample set and split by character or function (source: s-little-scale-lsdj-kit-releases).

Octave bass › LSDj #

Two rows of C-2 C-3 work as anywhere else, but the chord command does it in one column: CC0 "plays 0, C, 0, C, 0, C, …" — a true octave alternation at tick rate, slowed with CMD/RATE in the instrument screen. Neighbouring values give the variants: C0C = 0, 0, C (octave every third tick), CCC = 0, C, C, and C00 resets the chord (source: s-lsdj-manual).

The wave channel can also play the octave inside the note: a ghost-channel wave carries a rider at 2× the fundamental, so bass and octave sound together and the octave can be faded or stepped away without touching the bassline (source: s-chipmusic-lsdj-ghost-channel).

A related use of the same interval is the kick that turns into a bass note — start two octaves above and slide down with a P/L pair, or split the two with a groove; the recipes are on wavetable-programming and instrument-design (sources: s-intense-tech-10-kicks-part-1, s-defensemech-every-lsdj-kick).

Pitch slides and tone portamento › LSDj #

• Lxx slide: slides to the note in the row over a duration xx — in ticks if the instrument's PITCH is TICK, otherwise in xx/360 seconds. Manual example: C-4, then F-4 L40, then C-4 L10 bends up to F and snaps back. In a table, L in the left command column uses the transpose column as target relative to the base note; transposes and slides add independently.
• Pxx pitch bend: continuous bend at the given speed (P02 up 2, PFE down 2). Behaviour follows PITCH: DRUM = logarithmic at 360 Hz (kicks), FAST = linear at 360 Hz, TICK = per tick, STEP = instant pitch change without bend. On noise instruments P applies S every tick.
• Legato: cut the instrument column with B+A to change the note without retriggering.
• Fxy on pulse instruments sets PU2 transpose and finetune in 1/32-semitone steps — micro-detune rather than a slide (detune).

(source: s-lsdj-manual)

Hardware limits (source: s-pandocs-audio-registers): pitch is an 11-bit "period value" 0–$7FF; pulse frequency = 131072 ÷ (2048 − value) Hz, wave = 65536 ÷ (2048 − value) Hz (one octave lower at the same value). The scale is not linear in pitch: one step at value $500 changes the pitch by about 2 cents, at $7D0 by about a third of a semitone, and near the top by whole semitones (computed from the formula) — high slides step audibly, low ones are smooth. Period writes only take effect when the current sample ends. PU1's hardware sweep (NR10, LSDj's SWEEP and S on pulse): every 1–7 ticks of 1/128 s the period value changes by ± value ÷ 2^step; in the upward direction a result past $7FF switches the channel off (even with the pace at 0), and a downward sweep can never underflow — a rising sweep that goes too far ends in silence rather than at the top.

PITCH modes and their history (sources: s-intense-tech-10-kicks-part-1, s-intense-tech-11-kicks-part-2, s-intense-tech-13-kotlinski-interview): the pitch engine changed in 5.1.0 (johan-kotlinski: "actually a total disaster" at first — "it took way too long until it was on par with what was there before in terms of kick crafting"), losing the old logarithmic slides until version 6 added the instrument setting P/L/V — renamed PITCH in 7.0 — which governs P, L and V: FAST (formerly "HF") at the fastest rate, TICK much slower and tempo-dependent, STEP makes P a pitch offset (fun on kit snares), DRUM emulates the pre-5.1.0 logarithmic slides through a separate frequency lookup table and is not affected by tempo. In version 6 DRUM broke transposes in phrases and tables (turn the instrument's TRANSPOSE off); 7.0 (7.0.6 in November 2019) made transpose work with DRUM. L with transpose 80 in a table slides to the lowest note and stops there without wrapping. On noise instruments the commands act on the shape instead: S adds per digit (S01 on 4F gives 40, SFF gives 3E) and accumulates, whereas a phrase or table transpose changes the whole byte (4F + 01 = 50, + FF = 4E) and reverts when its row ends; P keeps adding every tick (FF, F0, F1, F2 …), C alternates base and added shape per tick (C01: FF/F0); CMD/RATE slows both. Smooth noise sweeps therefore need hand-made S tables (source: s-intense-tech-17-the-joys-of-noise) — that description holds up to 9.0.x; see the next paragraph for 9.1.0.

Later versions (intense-tech): version 7 (7.7.4, January 2020) added the FX/SPEED setting — renamed CMD/RATE in version 8 — which stretches each step of P (in TICK pitch only, like V), a wave-instrument FINETUNE of -F…+F, and the R8x super-fast retrig that restores the old wave-channel pitch wrap: on wave the pitch becomes tunable instead of relying on P, and a pulse kick reaches "about 3 whole tones lower than the pulse channel is normally capable of" (retrigger; sources: s-intense-tech-12-scoping-out-new-features, s-intense-tech-14-lets-appreciate-version-8). In 9.1.0 the noise channel became an ordered scale (long-loop values 00–3B, then short-loop notes by octave), so P on noise now sweeps smoothly through it without a table, with a new speed scale — P01 applies S01 every 4 ticks, P04 every tick — enough for kicks, hi-hats and crashes from one instrument; the instrument FINETUNE also gained a second digit (old 01 = new 10) (source: s-intense-tech-19-new-noise-and-910-news). Contradiction: the 9.2.6 manual as read above says P on noise "applies S every tick", whereas article 19 gives P04 as the every-tick speed from 9.1.0 on (sources: s-lsdj-manual, s-intense-tech-19-new-noise-and-910-news). A beginner's pulse kick from sabrepulse: PF1 in the first command row of the instrument's table, K00 near its end (instrument-design; source: s-sabrepulse-getting-started-with-lsdj).

Forum practice for L (source: s-chipmusic-lsdj-faq): the command goes on the target note — "it bends the previous note to the new one" (A#6 … C 6 L02 down, C 5 … A#5 L02 up); L on an empty step bends the note "down to nil"; in the 2010 versions only L01/L02 sounded musical, and slides ignore the vibrato waveform (only the HF/non-HF setting matters). Without PITCH = DRUM a kick slide played on a low note wraps back to the highest octave (source: s-infu-getting-started-with-lsdj).

Slides as drum design (defense-mechanism, 2024–25; sources: s-defensemech-every-lsdj-kick, s-defensemech-noise-channel-92l):

• P alone slides down and wraps if pushed too far, while L with transpose 80 always lands on the lowest note, C1 — so the two together separate the transient's speed from the body's slope, and the note written in the phrase only sets where the slide starts. That is the tuning control: "that allows me to actually tune the transient of the kick using the starting pitch in the note column", with higher octaves adding high end and the difference growing as the slide slows.
• Stutters used to need an L 00 00 on the tick where the kick restarts, because R did not reset the pitch; in 9.4.0 R retriggers the pitch too, so a plain R in the table is enough (retrigger). (The version is read off screen in an auto-transcribed video; the wiki's LSDj version history otherwise stops at 9.2.6 — (unverified).)
• Why PITCH SAFE exists, in hardware terms: the noise channel is a linear-feedback shift register that "sometimes … creates zeros, and that results in silence", so on real hardware — "especially like the original brick DMG", old CGBs and some Game Boy Advance units — a pitch slide on noise can simply cut out with no K. SAFE re-initialises the channel at every pitch change so it never drops out, at the price of texture: "it creates a harsher sound, it's just a totally different texture". Slowing the rate of change, or lowering COMMAND RATE with PITCH set to TICK, buys some smoothness back — and on a kick the restart is the sound, giving "almost a tonal aspect" where FREE "just completely loses its impact" (game-boy-apu, instrument-design).
• P on noise keeps running after the note ends, so stop it deliberately.

Pulse width modulation (PWM) › LSDj #

The pulse instrument's WAVE parameter selects the duty ("typically 50-50 high/low", other waves for a more distorted sound); the Wxy command changes it from a phrase or table — with the hardware oddity that the instrument's LENGTH timer is reset, possibly extending the sound. A duty sweep is therefore a table with W on successive rows, looped with H (source for the commands: s-lsdj-manual).

What the hardware allows (sources: s-pandocs-audio-registers, s-pandocs-audio-overview): bits 7–6 of NR11/NR21 select one of exactly four duties — 00 12.5 %, 01 25 %, 10 50 %, 11 75 % — and Pan Docs notes that "there is no audible difference between the 25 % and 75 % duty cycle settings", so a W sweep has three timbres to step through; it is a stepped effect, never the continuous sweep of the sid. The W-resets-LENGTH oddity follows from the duty and the initial length timer sharing that register (inference). A pulse channel's phase is "only ever reset by turning the APU off" and the duty setting shifts the phase, which is "usually not noticeable unless changing the duty cycle mid-note" — a duty step can land anywhere in the cycle, so listen to the transition rows.

The W values count 00 = 12.5 %, 01 = 25 %, 02 = 50 %, 03 = 75 %, which is what makes a random duty possible: W on the note and Z03 on its repeats picks any of the four, and Z02 (12.5 / 25 / 50 %) is the better choice because 25 % and 75 % "effectively sound identical"; an added value past the range wraps to the remainder after dividing by 4 (randomization-and-probability; source: s-intense-tech-03-dont-sleep-on-z). A beginner's defaults from sabrepulse's tutorial: 50 % ("a good low bassy sound") for the bass, 25 % for the lead (source: s-sabrepulse-getting-started-with-lsdj).

Three more sources: the wave channel does the sweep the pulse channels cannot — Square with PHASE Normal from 00 to 1F is "a smoothly modulated pulse lead (commonly associated with the C64 SID)" (source: s-intense-tech-02-wave-synth-deep-dive-part-2); johan-kotlinski's own bass duty "depends on the octave. For the base, I go for 15 or 25 first tick, then switch to 50" — a W on the first tick of a table (source: s-chipmusic-kotlinski-interviews); and Dire Hit's reading of Trey Frey's "Dreaming": at the fade-out an H loop over two table steps flips the pulse width while an E release runs (source: s-chipmusic-tables-and-chords-threads).

On the pulse channels themselves the duty is also a drum parameter: for a pulse kick, 50 % is "the beefiest", and the channel's floor of C2 is what makes the wave channel the better home for a kick with real low end (source: s-defensemech-every-lsdj-kick).

A cheaper approximation of the same motion: VSHIFT combined with FOLD or WRAP, where the shifted part of the wave folds or wraps back in — "that's almost like a pulse-width modulation thing happening" (source: s-defensemech-learning-lab-shorts; wavetable-programming).

Hand-drawn PWM on the wave channel#

Before the synth screen could sweep PHASE, the wave channel got its PWM by hand, one wave at a time (source: s-lsdj-and-you-pwm): draw a square in wave 0 at VOLUME 10, then narrow the pulse a little more in each of the synth's remaining fifteen waves — copy a whole wave with SELECT+B twice and paste it into the next frame with SELECT+A, then edit, rather than redrawing. Play it with PLAY PINGPONG, REPEAT F, LENGTH F and a slow SPEED, and the pulse narrows and widens continuously: "PWM will allow your game boy to sound a bit more like a C64, though nowhere near as smooth and classy." The steps are audible — "you can hear the synth stepping through each frame" — but "less noticeable on leads/basses in a full mix … and barely discernible when used in a fast arpeggio". roboctopus's verdict: "It's great for giving a lead line a more organic feel, and it makes a pretty massive bass."

The article predates LSDj 7's silky wave, which removed the click from frame changes (wavetable-programming), so on a current version the stepping should be gentler than he describes (inference).

Randomization and probability (MayBe, RandomiZe) › LSDj #

• Bxy MayBe in a phrase: probability that the note (or kit sample) to its left plays — first digit for the left kit, second for notes and the right kit. B00 never, B0F always, B08 about half the time.
• Bxy in a table: a hop to row y that only happens with probability x (BF5 15 times out of 16, B84 about 50 %) — a table that sometimes takes a different path.
• Zxy RandomiZe: repeats the last command that is not Z or H, adding a random 0..x to its first digit and 0..y to its second (Z02 adds 0, 1 or 2; Z22 any of 0,1,2,10,11,12,20,21,22). Put it after a V, P, E or F command for humanised vibrato, pitch, volume or sample offset.

(source: s-lsdj-manual)

• Worked Z examples from hypnogram's 2016 post as rewritten by defense-mechanism for intense-tech (source: s-intense-tech-03-dont-sleep-on-z): random vibrato — V00 on the note, Z03 on every repeat of the note, each acting as V00…V03; random duty — W values count 00 = 12.5 %, 01 = 25 %, 02 = 50 %, 03 = 75 %, and Z02 beats Z03 because 25 % and 75 % "effectively sound identical"; random panning — O values count OLR = 00, O__ = 01, OL_ = 02, O_R = 03, so OL_ followed by Z02 chooses among left, right and both while a start from OLR would include the mute; for these four-valued commands an added value wraps to the remainder after dividing by 4 (Z11 = 17 acts as 01); since version 6 Z also works in tables, and alternating OLR/O__ in an Automate table gives a random gate; random melody — Fxy's first digit is PU2's transpose in semitones, so ZF0 after an F re-pitches pulse 2 anywhere up to an octave plus a major third above the note; random chords — C37 with Z10 yields minor or major, possible since version 6 made the digits independent (in version 4 they were not); random sweep — Hypnogram's signature lead (Phantasm Dragon, at 1:30) randomises a sweep, which only pulse 1 can do. A Z never randomises another Z.
• Version notes: B arrived with version 7 (toured at 7.7.4 in January 2020) with the values B05 never hops, B85 about half the time, BF5 about 15 times in 16, and on notes B04 25 %, B08 50 %; on kit instruments the digits are the left and right samples separately — B48 = left 25 %, right 50 % (source: s-intense-tech-12-scoping-out-new-features). Since version 8 Z works with every command except H (and Z), which makes randomised straight-or-swung grooves possible (source: s-intense-tech-14-lets-appreciate-version-8). Contradiction: the version-6 manual said Z does not work with Hop, Groove and Delay; article 03's later footnote claims it does "as of version 8.1.9" including Hop, while article 14 and the 9.2.6 manual (s-lsdj-manual, above) exclude H (sources: s-intense-tech-03-dont-sleep-on-z, s-intense-tech-14-lets-appreciate-version-8).
• Z on noise shapes for random crash cymbals (a trick defense-mechanism credits to an Exploring Chip Tunes video): because Z randomises each digit independently, the variation can be confined to one loop mode and octave — first digit +0…4 at most so it never wraps past F to 0 (silence), some rows with a first digit of 0, second digit F for a completely random divisor (source: s-intense-tech-17-the-joys-of-noise). "Probability sequencing" is one of the features johan-kotlinski lists for the stable LSDj 8 (source: s-intense-tech-13-kotlinski-interview).

Retrigger and resync › LSDj #

Rxy: x changes pulse/noise volume per retrig (0 none, 1–7 increase, 9–F decrease), y sets the rate (1 fastest, F slowest, 0 = retrig once). R8x is resync: R80 resyncs at 360 Hz, R8F stops it. Examples from the manual: R01 retrig every tick, RF4 retrig every fourth tick with decreasing amplitude (echo effect). CMD/RATE in the instrument slows R down. Dxx delays a note by ticks, which combines with retrigs for flams (source: s-lsdj-manual).

What a hardware trigger does (bit 7 of NRx4; sources: s-pandocs-audio-registers, s-pandocs-audio-details): the channel is switched on (unless its DAC is off), an expired length timer is reset, the period divider is reloaded, the envelope timer is reset and the volume set from NRx2; on CH1 the sweep restarts, on CH4 the LFSR is reset to 0, on CH3 the wave read index restarts while the last sample stays in the output buffer. A pulse channel's duty step is not reset — only its timer is — so "retriggering a pulse channel often enough will cause its 'duty step' to never advance": very fast retrigs freeze the waveform, which is presumably the mechanism behind the resync pitch drop (inference). Because a trigger zeroes the noise LFSR, retriggering CH4 at a steady rate repeats the same noise burst and turns it into a pitched, pulse-like tone (inference from the LFSR reset); a retrigger is also the cure for a noise generator locked up by a 15→7-bit switch (game-boy-apu).

From Intense Tech (sources: s-intense-tech-17-the-joys-of-noise, s-intense-tech-18-adsr-makes-life-easier): depending on the version R00 retrigs once or every tick — in 8.9.3 R01 retrigs every tick. On the noise channel a fast retrig chops the noise into a pulse wave: the pitch follows the R rate, the tempo (tick length) and the noise shape; a shorter LENGTH or ADSR controls the loudness; R80–R8F, "the super-fast retrig", ignores tempo and LENGTH. With the 8.1.0 ADSR, R's per-retrig volume change gives a tremolo. Infu's hi-hat is a noise instrument with R02 on its notes (source: s-infu-getting-started-with-lsdj); Dire Hit's late discovery: "the first number of an R command is an envelope" (source: s-chipmusic-tables-and-chords-threads).

Version history of R (sources: s-intense-tech-12-scoping-out-new-features, s-intense-tech-14-lets-appreciate-version-8): the "super-fast retrig" R8x arrived in the 7.7.4 development version as the much-requested return of the old wave-channel pitch wrap — the sound generator restarting at a very fast rate; on the wave channel the resulting pitch can be tuned by the R value rather than left to P, and on a pulse kick it reaches "about 3 whole tones lower than the pulse channel is normally capable of" (three whole tones = the manual's half octave). FX/SPEED, the 7.7.4 setting that slows C, P, R and V, became CMD/RATE in version 8; version 8 also made R on the wave channel restart the synth from its first wave frame, and with the version-8 ADSR RFx behaves like a tremolo.

R as the noise channel's dynamics control (source: s-defensemech-noise-channel-92l): the hardware envelope is a single smooth slope, so a decaying repeat cannot be written with E at all. R with a volume digit "will reduce this by one level and keep these numbers" — ghost snares, quieter repeats, and triplet fills from a four-tick retrig; leaving the instrument untriggered and changing only the shape is the variant. On kicks, R did not reset the pitch before LSDj 9.4.0, so a stutter needed an L 00 00 on the restarting tick; since 9.4.0 a plain R retriggers the pitch and the workaround is gone (source: s-defensemech-every-lsdj-kick).

The instrument number is itself a retrigger (source: s-painperdu-01-instrument-retriggering). A note plays without one; what the instrument number does is restart everything the instrument owns — the envelope, its table, and on the wave channel the synth's wave cycle. "It's really important to know that instrument and note are actually independent." Leave it off and a rising envelope keeps rising across the following notes, so triggering once per beat turns a run into a swell that resets on the beat, and a long PINGPONG wave instrument (LENGTH F, slow SPEED) finally gets to complete its cycle instead of restarting every note. With a table set to AUTOMATE the table advances per instrument value rather than per tick, so the stock L/R panning table gives L R L R when every note carries the number and L L R R when only every second one does (stereo-panning). It also costs less: fewer instrument numbers means fewer blocks and less CPU. The trap is drums — a kick on the wave channel is another instrument, so it re-triggers the lead that follows; the fix is to fit the synth's cycle between the hits (LENGTH 3 at SPEED 6 steps a frame every 16th note).

ROM retuning — patching a tracker's pitch table › LSDj — by hand #

Offsets verified on 3.8.9 only (source: s-little-scale-lsdj-tuning-tables):

1. Open the ROM in a hex editor in overwrite mode (little-scale uses Hex Fiend on OS X). Do not insert — the ROM must stay 1,048,576 bytes.
2. Find the table: "starts just after location $6D30 with the bytes 2C 00 9C 00 06 01. Select 216 bytes starting with 2C and 00" (source: s-little-scale-underclocking-and-retuning).
3. Paste your 108 little-endian values over it.
4. Patch the second block too. KiGB reads only the SGB table "regardless of emulator settings", so a ROM patched in one place will test wrong there and play wrong under a Super Game Boy (source: s-little-scale-lsdj-tuning-tables).
5. Save, flash, play.

ROM retuning — patching a tracker's pitch table › LSDj — with lsdj_tune #

abrasive's Perl script does all of the above from the command line and, uniquely, rewrites the note names as well, so the display matches the tuning. Built for LSDJ 3.9.9 (source: s-little-scale-abrasive-lsdj-tune):

lsdj_tune --et 24 --base A5 440 --rom lsdj.gb --out lsdj_et24.gb
lsdj_tune --cstep 78 --base 0 70 --rom lsdj.gb --out lsdj_alpha.gb      # Wendy Carlos alpha
lsdj_tune --ratio 1,256/243,9/8,32/27,81/64,4/3,729/512,1024/729,3/2,128/81,27/16,16/9,243/128,2 \
          --names D,Eb,E,F,F#,G,G#,Ab,A,Bb,B,C,C# --base 0 73.42 --rom lsdj.gb --out lsdj_pyth.gb

Modes: --et n, --cents, --cstep, --ratio; all 108 notes may also be given explicitly. Its stated limitation is that the base-frequency option "won't take custom note names, and sequences always start on the base note".

Sample looping (perfect loops, sustain loops, long loops) › LSDj: the loop points are a pattern command #

The Game Boy's kit samples loop too, and LSDj is unusual in letting the pattern move the loop while the sample plays (source: s-lsdj-manual).

• The kit instrument's LOOP is three-way: OFF does not loop, ON loops and starts playing from OFFSET, ATK loops the sample but starts playing from the beginning — so ATK keeps the attack and repeats the body, the shape a sustaining instrument needs. OFFSET is the loop start (or, with LOOP off, a plain sample-offset) and LEN the length.
• Sxy on a kit instrument "changes the loop points. The first digit modulates the offset value; the second digit modulates the loop length. (1–7 = increase, 9–F = decrease.)" — the manual's own note is that "used creatively, this command can be very useful for creating a wide range of percussive and timbral effects". Walking the loop length down over a few rows turns any sampled tail into a pitched buzz; walking the offset along it granulates (retrigger, wavetable-programming).

The budget behind all of it: 3FA0 bytes per kit at 11,468 Hz, so a loop measured in time is measured in tens of milliseconds, and the sample must be lowpassed at 5,734 Hz and faded at both ends before it ever gets there (source: s-little-scale-lsdj-kits; chip-samples).

Sample offset tricks › LSDj #

The Game Boy has sample memory after all — the kit ROM — and LSDj offsets into it two ways (source: s-lsdj-manual).

• Fxx on a kit instrument "modifies the sample position. 00–7F steps forward, 80–FF steps back". Unlike 9xx/Oxx it is relative and it goes backwards, so a column of small F values walks a sample forwards and back — stutter and grain rather than a jump to a fixed point. (The same command means PU2 transpose + finetune on a pulse instrument and a wave-frame step on a wave instrument, so it only reads as an offset in a kit.)
• The instrument's OFFSET parameter sets a static start point: with LOOP OFF it "can be used for skipping the initial part of a sound", the classic snare-tail-becomes-a-hi-hat trick that ST3's manual also documents; with LOOP ON it is the loop start. LEN cuts the other end (chip-samples, instrument-design).

Shuffle, swing and FunkTempo › LSDj #

Grooves are the native mechanism: each groove lists how many ticks every phrase (or table) step lasts. Groove 0 defaults to 6/6; 8/5 makes even steps last 8 ticks and odd steps 5 — swing; other lists give triplets and complex rhythms. In the groove screen A+UP/DOWN changes the swing percentage while keeping the total ticks, so the song speed stays constant (6/6 = 50 % → 7/5 = 58 %). Gxx selects a groove in a phrase or a table (SELECT+DOWN on it edits the groove); tables can run their own groove for rhythmic envelopes. The T tempo command is exact only for 6-tick grooves — otherwise use bpm = desired × ticks/step ÷ 6 — and sync modes expect 6-tick grooves (source: s-lsdj-manual).

Grooves also solve arrangement problems: to shorten the gap between a kick and the bass note that follows it, give the row pair its own groove — in defense-mechanism's example the first tick count of groove 10 is how long the kick lasts and the second how long the bass lasts, "No fancy kick transposition needed!" (source: s-intense-tech-10-kicks-part-1).

Defense Mechanism's groove practice (sources: s-intense-tech-06-groove-and-tick-tricks-part-1, s-intense-tech-07-groove-and-tick-tricks-part-2): a tick is the smallest time unit, its length set by the tempo; a G on a line makes that line last the groove's first value and the following lines the next values. Hypnogram's convention — grooves 01–0C set to 1…12 ticks so G03 reads "three ticks per line", 10–1F for custom feels (G10 = 7/5) — keeps commands legible. Swing lives per channel: 7/5 on the wave channel (kick and bass) against 6/6 elsewhere sits "in-between swung and straight"; 8/4 and 9/3 swing harder; 8/5/7/4 mixes two feels in 24 ticks for a human lead; 3/9 (or 3/9/6/6) makes room for note bends or a three-tick kick before a bass note. LSDj 6 restarts a groove on a repeated G, older versions do not. A 3-tick groove doubles phrase resolution at half the phrase length — H gives it back (H71 = hop to line 1 seven times). Triplets: G08 (8 ticks = 24 ÷ 3) for the three notes, then H00 to skip the last 6-tick line so the next phrase lands on the beat; 3/4 time can be a groove alone (a trick from Zef). Tables take grooves too (2 or 3 ticks for arps and duty changes), and Hop + Groove inside a table gives Hypnogram's dramatic "Zenarchy" sound. Mrwimmer's version of the same idea: G01 on a table's first line with groove 01 = 2/2 halves an arpeggio's speed without doubling rows (source: s-chipmusic-tables-and-chords-threads); aphasia's live tip: with a MIDI keyboard, the lowest possible groove and a high tempo minimise quantisation (source: s-chipmusic-lsdj-faq).

Tempo is not BPM (source: s-painperdu-06-grooves). The TEMPO field sets the tick rate; the groove decides how many ticks a step lasts, so the groove is what sets the musical speed and the feel. Picture the song as an hourglass: "tempo says how fast they will fall, but grooves say how many of them will be in each note" — hold TEMPO at 255 and the music still speeds up, slows down and changes feel as the grooves change. Consequences worth keeping:

• A 16-step phrase is a bar only at groove 6; at groove C (12 ticks) it is half a bar, at groove 3 two bars. A ternary bar is 12 steps, not 16, so end it with an H hop.
• A groove needs only one value if the speed is constant — the list wraps. A longer list is a per-step tempo map: 12 6 12 6 6 6 2 3 is two long notes, two short, two long, and so on, and nothing stops you writing 1 6 3 4 F A for experimental work.
• Grooves are per channel, so pulse 1 can run at groove 3 while the wave channel runs at 6 — as long as the tick totals match (eight phrases at 3 = four phrases at 6), "at the end of the day they still sing together".
• Triplets by arithmetic: double the tempo and the groove together to keep the BPM (groove C = 12 ticks), then run the triplet channel at groove 8 — 12 ÷ 3 × 2.
• Tables take grooves too, and that is the space saver: "by default tables run at one tick per step", so a G in a table halves what a slow arpeggio costs and lets a percussion table pack more commands into the same time. Pain Perdu credits the trick to Joe Toye of Chiptune Belgium; Mrwimmer describes the same thing above.

Three more things pain-perdu does with grooves, from the walkthroughs:

• The groove reaches into the instruments. A wave-synth instrument's SPEED is ticks per wave frame, so it should be set to the groove's tick count: at groove 6/6, SPEED 6 puts exactly one wave frame on every step — "this is relevant to the groove, so if you're in groove 5 5 this is going to be 5, for groove 7 7 this is going to be 7" (source: s-painperdu-02-wav-channel-walkthrough; wavetable-programming).
• The groove is a resolution knob, not only a feel. For a sidechain recovery, halving the groove to 3 makes each step a 32nd, so the same two E commands recover twice as fast — "it's almost as if you hear the bass being triggered at the same time as the kick, but this is an illusion being made possible by the fast groove" (source: s-painperdu-04-sidechaining).
• Two grooves at once, with the hop that keeps them honest. A chord section at groove C C (12 ticks per step) against another channel at groove 2 "time together perfectly, you just have to be a bit of math" — six to one — but the fast channel needs an H hop at the end of its phrase or the two do not land together. In the same song the tempo itself is written as a curve, a new T value per phrase from 100 up through 142 and 150 to 180 and back down to 80: "each phrase I'll have a new tempo that goes slightly up very organically … this was really painstaking … [but it] really pays off". T affects the whole song from whichever channel carries it, so it goes on the second tick of a phrase when a G has taken the first (source: s-painperdu-03-isometric-sav-walkthrough; arrangement).

defense-mechanism's 2024 version of the kick-into-bass groove is two instruments and two grooves: a wave kick and a separate 808 bass, with a groove of 3 9 — "I want this kick to play for three ticks and then the bass for the next nine" — and a second groove 3 9 6 so the following bar's timing works, returning to groove 0 after. It costs two groove slots and buys independent control of both sounds, plus the W command for how fast the bass decays (source: s-defensemech-every-lsdj-kick; the values are spoken over an auto-transcribed video and are (unverified); instrument-design).

Since version 8 the Z command also randomises a preceding G, so a phrase can switch between a straight and a swung groove by chance — Defense Mechanism expected "very interesting rhythmic consequences" (source: s-intense-tech-14-lets-appreciate-version-8); see randomization-and-probability.

Sidechain pump › LSDj #

The table envelope column is a custom amplitude envelope (amplitude digit + duration in ticks, loop with H in the second digit — the manual's tremolo example); a table that starts low and rises over a beat, run with a groove of the beat length, pumps any instrument that uses it. Exy on pulse/noise sets amplitude x with release y per row for hand-drawn ducks (source for the mechanics: s-lsdj-manual).

In a full arrangement it comes out as an envelope on every chord instrument: each arp note triggers a rising envelope so the chords give way on the beat — "kind of your poor man's sidechain compression emulation in LSDj, with just volume" — timed so the kick lands in the dip (source: s-painperdu-03-isometric-sav-walkthrough).

pain-perdu builds the whole effect out of those pieces (source: s-painperdu-04-sidechaining). Half of it is free: kick and bass share the wave channel anyway, so they cannot sound together — what has to be written is the recovery. Put E02 (50 %) and then E03 (100 %) on the steps after the kick and the bass swells back in on the 16th-note grid. Then halve the groove: at groove 3 each step is a 32nd, the same two commands recover twice as fast, and the pump stops announcing itself — "it's almost as if you hear the bass being triggered at the same time as the kick, but this is an illusion being made possible by the fast groove" (shuffle-funktempo). Duck the channels the kick never touches as well: an envelope command rising from 0 at speed A once per beat on the pulse channel "gives a little bit more of a four-to-the-floor groove … and it helps the kick stand out", and it carries the feel through bars with no kick at all — "even if you have no kick playing you still have the feel of the song". The same command on the noise channel gives the house-record hat that pumps instead of hitting. Two kick patches with different kill points and pitch-drop speeds (his verse kills at 4, his chorus at 6 with more low end) turn the same trick into a section contrast.

On the wave channel E is too coarse to pump with — E01/E02/E03 are 25 / 50 / 100 %, and "there's nothing between fifty and a hundred percent … sometimes 2 is too soft for an instrument and 3 is too loud in the context of your mix". Ramp LIMIT instead: 0 on the synth's first wave, F on its last, PLAY LOOP with the loop point at the end so the instrument sustains once it has recovered — "now we can have this going from zero to F and have this kind of naturally do its own sidechaining". SPEED and LENGTH set how fast the duck recovers, and a start value above 0 keeps it from ducking to silence; VOLUME and Q can ride the same ramp for a filter-and-volume pump (source: s-defensemech-wave-channel-ramble). Before LSDj 7's silky wave this was impractical — every frame change clicked (wavetable-programming).

Song initialisation and looping › LSDj #

Playback only stays in sync if every channel has something to play from the top: Infu keeps silent chains — chain 7F holding the empty phrase FE, used as 7E (a short bridge) and 7D (a full-length chain) — in every gap of the song screen, with the same number of phrases as the neighbouring chains, so START works from any row (source: s-infu-getting-started-with-lsdj). Grooves added at the end of a phrase must be taken back (H00, or a G back to the default) so the next phrase starts on beat 1 (source: s-intense-tech-07-groove-and-tick-tricks-part-2).

H is both the loop and the ending: in a phrase H00–H0F hop to the next phrase at the given step (H00 on step C is how you compose in 3/4), H10–HFE hop back within the phrase — first digit how many times, second digit the destination step — and HFF stops the song, or just that channel in live mode (source: s-lsdj-manual). Without an HFF the song screen simply plays its chain lists top-down and comes round again, so the sticky-state rule above applies to LSDj too: a T, M or G set late in the song is still set on the next lap.

Stereo panning › LSDj #

Instrument OUTPUT parameter (L/R/both/none); Oxx command to pan a channel from a phrase or table; B+LEFT/RIGHT in the song screen pans a channel live; Mxy sets or nudges the master volume per side (source: s-lsdj-manual). Classic use: the same chain on PU1 and PU2, one left, one right, slightly detuned (detune).

The hardware: NR51 ($FF25) has one left bit and one right bit per channel — a channel is hard left, hard right, centre (both) or absent, nothing in between — and NR50 scales each side in eight steps (0 = 1/8, 7 = full) without ever muting, which is what Mxy writes. Changing NR51 for a channel whose DAC is on causes a pop, so make panning moves on silent rows; the built-in speaker merges both sides to mono (sources: s-pandocs-audio-registers, s-pandocs-audio-details, s-pandocs-audio-overview).

One table for both pulses: when PU1 and PU2 play the same instrument with its table set to Automate at the same time, channel 1 receives the even-numbered table rows and channel 2 the odd-numbered ones, so alternating O values pan the two channels apart from a single table, instrument and phrase (source: s-intense-tech-09-lets-table-this-discussion).

Clicks and tricks from the forum: on pre-8.8.0 versions an O change clicks, so "fade the instrument off before doing the panning" (herr_prof; source: s-chipmusic-lsdj-faq); the stereo snare trick is the opposite use — a very quick left-to-right flick at the top of the snare table, then centre (Victory Road; source: s-chipmusic-noise-drum-threads); Infu's snare table opens with alternating O rows to make the snare "wide on the speakers" (source: s-infu-getting-started-with-lsdj); "Use O command to create stereo space" (SketchMan3; source: s-chipmusic-lsdj-advanced-tricks).

Random and alternating panning (intense-tech): the O values count OLR = 00, O__ = 01, OL_ = 02, O_R = 03, so OL_ followed by Z02 on later steps chooses among left, right and both — starting from OLR would include the mute — and a value added past the range wraps to the remainder after dividing by 4; since version 6 Z works in tables too, and alternating OLR/O__ in an Automate table gives a random gate (randomization-and-probability; source: s-intense-tech-03-dont-sleep-on-z). defense-mechanism counts stereo placement as one of three mixing levers beside volume and register: alternating left/right on pulse notes or noise hi-hats creates "a sense of space and ambience" even with only left, right or both available (source: s-intense-tech-15-lets-mix-it-up-and-down). sabrepulse's beginner pattern puts the O commands on the empty rows between the lead's notes — OL_ on rows 1, 5, 9 and D, O_R on rows 3, 7, B and F, notes on the even rows — which "gives a better stereo effect" than panning on the note rows and leaves those rows free for other commands such as C (source: s-sabrepulse-getting-started-with-lsdj).

Vibrato and delayed vibrato › LSDj #

Vxy: x = speed, y = depth in semitones — 0 0.125, 1 0.25, 2 0.375, 3 0.5, 4 0.75, 5 1, 6 1.5, 7 2, 8 2.5, 9 3, A 3.5, B 4, C 5, D 6, E 7, F 8; V00 resets. Shape and speed depend on the instrument's PITCH setting: with PITCH = TICK the vibrato is synced to the music (assuming 6 ticks/step) and CMD/RATE slows it; A+LEFT/RIGHT on PITCH chooses the shape (triangle, saw or square, upward or downward). Delayed vibrato: put V a few steps after the note, or in the instrument's table on a later row so every note gets it automatically. The manual also suggests V (and P) on noise snares to liven them up (source: s-lsdj-manual).

Dire Hit's account of the digits: the first is the modulation speed (0 slow … F "so fast it almost becomes audible as a tone"), the second the depth; VFF is FM in all but name — Monodeer's pulse-channel cymbals are a single V command, "if you ever need noise percussion out of a pulse channel" (source: s-chipmusic-tables-and-chords-threads). SketchMan3: "High frequency V effects can give you a more complex raspy sound" (source: s-chipmusic-lsdj-advanced-tricks); a fast V on a table's first tick, cancelled by V00 on the second, sharpens an attack (source: s-intense-tech-09-lets-table-this-discussion).

More from intense-tech: random vibrato is V00 on the note and Z03 on each repeat of it, so every repeat acts as V00…V03 (randomization-and-probability; source: s-intense-tech-03-dont-sleep-on-z). The slowing setting was introduced as FX/SPEED in version 7 (7.7.4) — it lengthens each step of C, P, R and V, the V only when PITCH is TICK — and renamed CMD/RATE in version 8 (sources: s-intense-tech-12-scoping-out-new-features, s-intense-tech-14-lets-appreciate-version-8). Since 9.1.0 the TICK vibrato rates are rhythmic at the default groove — one cycle per V0x 16 steps, V1x 12, V2x 32/3, V3x 8, V4x 6, V5x 16/3 … VFx 1/2 step — and V also works on noise instruments, always tick-based (source: s-intense-tech-19-new-noise-and-910-news).

Pushed far enough, a V on the wave channel stops being vibrato: with the right combination of speed and depth a bass note "kind of self-resonates with itself", a sound defense-mechanism rates highly and uses rarely — "I honestly don't use enough V commands on the wave channel". It belongs to one note, so a different pitch needs the values retuned, and silky wave may have softened it (source: s-defensemech-learning-lab-shorts).

Two wave-channel notes from pain-perdu (source: s-painperdu-02-wav-channel-walkthrough): in the instrument screen, LEFT/RIGHT cycles the vibrato type while A+UP/DOWN inverts the vibrato's phase; and a fast V on a wave instrument — normally a pulse-channel trick, since wave instruments are raspy already — turns a raspy hand-drawn wave into "a kind of flanger filtery modulation effect" with no synth movement at all. It costs CPU, and because the modulation interacts with the note's pitch the value that works on one note will not work on the next, so it belongs on the note rather than in the table. A slow vibrato does the opposite job: it detunes a held pulse note enough to "fight off the really robotic feel" (source: s-painperdu-03-isometric-sav-walkthrough).

Two more places V earns its keep. On the noise channel it has worked since 9.1.0, alongside C and P, and combines with P — a bend and a wobble on the same hit; the pitched (short-loop) noise shapes make that read as a tonal snare rather than as noise (source: s-defensemech-noise-channel-92l). And on a wave instrument imitating an acoustic one, V is most of the imitation: "using a variety of vibrato speeds (Vxx commands) will also help make a flutey tone sound more convincing. It's all about articulation, really. LSDJ is really good for flutey articulation though!" — varied speeds across a phrase, not one setting held (Victory Road, source: s-chipmusic-lsdj-wav-instrument-tutorials; lead-articulation).

Volume slides, fades and effect memory › LSDj #

No slide command: volume is shaped per note by Exy (x = level 0–F; y = 1–7 decrease from fastest to slowest, 9–F increase from slowest to fastest, 0/8 hold), by the instrument ENV/ADSR and by the table volume column (level + ticks, looping when all 16 rows are used). Until 8.8.0 every pulse or noise volume change reset the hardware envelope with a click; since 8.8.0 a software volume makes E, the table column and K click-free, with speeds from 1 (shorter than any hardware speed) to F. Mxy moves the master volume per side (9–B up, D–F down). Global fades and ducks are therefore tables and M, not slides — and the four wave-channel steps are enough for a rhythmic one: because E02 is 50 % and E03 100 %, an 02 followed by an 03 on the next step is an audible pump locked to the 16th note, which is how pain-perdu writes the recovery half of a sidechain. On the pulse and noise channels he instead runs an envelope that starts from zero and rises once per beat, so the pump is there even in bars where the kick is not (sidechain-pump; source: s-painperdu-04-sidechaining). (adsr-envelope, sidechain-pump; sources: s-intense-tech-18-adsr-makes-life-easier, s-intense-tech-09-lets-table-this-discussion, s-lsdj-manual).

Mixing levers beyond E (source: s-intense-tech-15-lets-mix-it-up-and-down; the headroom argument behind them is on levels-and-headroom): when E03 (100 %) is too loud and E02 (50 %) too soft on the wave channel, cap the synth's LIMIT instead — at instrument VOLUME 3, LIMIT 8 gives about 50 %, 9 ≈ 56 %, E ≈ 94 % — and different LIMIT values on the synth's first and last wave, run with W (speed, length), make a wave-channel volume envelope (wavetable-programming). On pulse and noise the version-8 ADSR chains E-like stages and can fade in to a chosen lower maximum, where a rising E climbs to F or the next E; E commands and the table volume column override the ADSR (source: s-intense-tech-14-lets-appreciate-version-8). A transient beats a louder level: instrument volume around 90 with the table's E pulling it down after the first tick lets a snare cut through "without overpowering the other channels" (Pain Perdu's trick; instrument-design).

Before software volume the clicks were the topic of the LSDJ FAQ thread (source: s-chipmusic-lsdj-faq): a table fade-in 01 21 41 61 81 A1 clicks on every step because "to change the volume, the phase of the waveform needs to be restarted" (nitro2k01 — the hardware behaviour Pan Docs describes, adsr-envelope); fixes of the time were chained E commands that continue where the previous one stops, aphasia's stepped fade (a short loud 0F, then a sustain at the wanted level, repeated), or spacing the steps to the groove's ticks so the clicks fall on the beat. Infu's reading of ENV: each box is a level and the speed to the next box's level, 0 holds, lower speeds are shorter — a fade-in starts at 0: 07/88/-- (source: s-infu-getting-started-with-lsdj).

LIMIT is the wave channel's volume fader, and VOLUME is not. The two do different jobs and only one of them is safe to move: VOLUME scales the signal before CUTOFF, Q, PHASE and DIST, so turning it down also destroys the clipping or wrapping that made the sound — "what if you want to keep the same wave shape … I really like this sound, but it's too loud, and this was the bane of my existence in the early versions of LSDj, because you're just stuck — you can't get it to wrap if the volume isn't high". LIMIT (added in synth version 6) constrains the samples after all of that: F allows the full 0–F, 5 allows only 5–A, and whatever exceeds the window is handled by the DIST type. It exists precisely because the hardware's four steps leave the channel "often being too loud at 100% volume but too quiet at 25% or 50%". defense-mechanism's verdict: "LIMIT, I think, is almost more useful than anything else on this entire thing." Because the synth interpolates across its 16 waves, different start and end LIMIT values (say F → 4) are a fade — "a nice gradual fade without having to use the E commands, which only give you 100, 50, 25 or zero" (sources: s-defensemech-learning-lab-shorts, s-intense-tech-02-wave-synth-deep-dive-part-2; wavetable-programming, levels-and-headroom).

The wave channel is the exception (sources: s-chipmusic-lsdj-wav-channel-release, s-defensemech-wave-channel-ramble): E gives four steps only (0 / 25 / 50 / 100 %), and they are a bit shift, so the quiet settings also lose resolution. Three ways around it, in the order they were found — draw the fade into the waves themselves and step frames with F01 from a table (16 steps per synth, 32 across two); pan the channel alone to one side and use M, which has 8 steps and does move it; or, from LSDj 8, ramp LIMIT across the synth's waves, which is the smoothest of the three and doubles as a sidechain-pump.

Wavetable programming (waveform / arp tables) › LSDj #

Two different things are "wavetables" on the Game Boy:

• Instrument tables — six columns (amplitude envelope, transpose, two command/value pairs), one tick per step by default, started by the instrument's TABLE setting or Axx, looped with H, with probabilistic hops via B. They do what the SID-Wizard wave/arp table does: pitch drops for drums (transpose column + L/P), noise-then-tone attacks (switch instruments/E per row), custom envelopes (tremolo example in the manual). With TABLE set to STEP the table advances one row per note trigger — a per-note sequence.
• The wave channel's synth: 16 synth sounds × 16 four-bit waves. The synth screen generates them from a SIGNAL (square, saw, triangle, custom), FILTER (low/high/band/all-pass), DIST (CLIP/FOLD/WRAP), PHASE (PINCH/WARP/RESYNC), fading VOLUME, CUTOFF, Q, VSHIFT, LIMIT and PHASE from the first wave to the last. WAVE instruments play them ONCE, LOOP, PINGPONG or MANUAL; Fxx steps through frames by hand (F10 = next synth sound), Wxy changes synth speed/length. The wave screen edits single waves.

(source: s-lsdj-manual)

LIMIT is not a volume control, and that is the point (source: s-defensemech-learning-lab-shorts): VOLUME scales the signal before the rest of the chain, so turning it down destroys the clipping or wrapping that made the sound — "you can't get it to wrap if the volume isn't high" — while LIMIT constrains the dynamic range afterwards and keeps the shape. Ramped across a synth's 16 waves it is also the fade the E command cannot give (E steps 0 / 25 / 50 / 100 %). There is no LIMIT command for the phrase screen, so different levels mean different synths. VSHIFT finally has a rule from the same clip: it is to DIST what Q is to the filter — with CLIP it merely squashes the wave against the ceiling ("a sound-bad button", "just a way to make it quieter"), but with FOLD or WRAP the shifted part folds or wraps back in and "that's almost like a pulse-width modulation thing happening" (pulse-width-modulation). 10 lifts the wave about one step; FF is silence. In older versions VSHIFT wrapped regardless of the DIST setting.

Sweeps longer than one synth (same source, credited to hypnogram): slice the CUTOFF range across consecutive synths — synth 1 1→2, synth 2 20→30, synth 3 30→40, Q around 5–7 — and play the matching instruments in sequence, each PLAY ONCE at a slow SPEED. The sweep then continues past the sixteen-frame limit, at the cost of a synth per slice.

The instrument side of the synth (source: s-painperdu-02-wav-channel-walkthrough): LENGTH is how many of the 16 waves the cycle uses, REPEAT is how many frames at the end of that cycle repeat afterwards — "if you play with this cleverly you can have really interesting rhythmic wave cycles" — and SPEED is ticks per frame, which belongs to the groove rather than to taste: SPEED 6 under groove 6/6 advances one wave per step, SPEED 5 under groove 5/5, and so on. SPEED 1 "is more clipping than actual modulation". MANUAL is the quiet mode because only one wave is ever read, so no frame change occurs. Two corrections from the same source: hand-drawn waves are not restricted to MANUAL — "one of the most common misconceptions is that the hand-drawn waves in LSDj are only accessible when you set this to MANUAL … [they] are available even when you're in PINGPONG and LOOP and ONCE" — and F offsets that run past a synth's sixteen waves bleed into the next synth's waves, which is a way to make one note evolve out of its own timbre.

Hand-drawn banks and their hazards (source: s-chipmusic-lsdj-wav-channel-release): the synth screen is a generator, the wave screen an editor, and re-entering the synth screen overwrites all 16 of that synth's waves — later versions warn first ("are you sure you want to override hand-drawn waveforms?"), older ones do it silently. F is relative and accumulates, so F05 F05 lands on frame 0A; a wave — a section of one or a whole one — can be copied and pasted between waves in the WAVE screen (SELECT+B, highlight, B, then SELECT+A on the target), which is what makes a 16-wave hand-drawn bank affordable at all (source: s-painperdu-05-shortcuts-and-workflow); F10 steps into the next synth, which is also how two synths are chained into a 32-frame animation. Frame changes clicked on hardware until LSDj 7's silky wave; the standing advice was to set the frame rate so the clicks fall on 16ths, where percussion masks them.

A wave can also hold two notes at once: draw a second waveform at 2× or 3× the fundamental on top of the first and the channel sounds a bass note plus an independently steerable higher one — the ghost-channel (sources: s-chipmusic-lsdj-ghost-channel, s-tylerbarnes-ghost-channel-tutorial). The 2020 answer needs no drawing at all: an allpass filter with a low CUTOFF and a high Q (around 8–9) lifts one overtone into audibility while passing everything else — "the nice thing about the allpass is that no matter how much you boost this Q you really never lose the root note", where lowpass isolates the fifth but throws away the edge. Both give "this overtone emphasis that sounds like almost two notes … the power chord" (source: s-defensemech-ghost-channel-allpass).

The hardware under the wave channel (sources: s-pandocs-audio-registers, s-pandocs-audio-details): wave RAM ($FF30–$FF3F) holds 16 bytes = 32 four-bit samples, played upper nibble first at 32 × the tone frequency (65536 ÷ (2048 − period value) Hz — one octave below a pulse channel at the same value, which is why WAV is the bass channel). There is no envelope, only the NR32 output level 100 / 50 / 25 % (a right shift of the samples) or mute — LSDj's VOLUME setting and E00–E03. Wave RAM can only be rewritten while the channel is inactive (on the DMG only in step with the channel's own reads; on the Color a write lands on the byte being played), so every wave or synth-frame change means stopping and retriggering the channel; a retrigger resets the read index but keeps the last sample in the output buffer, and on monochrome consoles retriggering while a byte is being read corrupts the first bytes of wave RAM. Pan Docs names the two classic uses: "shortening" the wave by repeating a pattern or doubling samples and read rate, and "lengthening" it by reloading wave RAM as soon as it has been read once — "sometimes used for full-on sample playback", which is presumably how LSDj's kits and speech play on this channel (inference).

Drum tables from Intense Tech (sources: s-intense-tech-10-kicks-part-1, s-intense-tech-11-kicks-part-2): the wave kick table is a fast P on the first line (how quickly the pitch falls from the played note) and on the second an L with transpose 80 — the slide stops at the lowest note instead of wrapping to the top, survives tempo changes (DRUM-mode P/L ignore tempo) and leaves the attack tunable by the note (C5–C7) and the P speed. The "Kyoto kick" (popularised by Toriena) puts a noisy, gritty wave in slot 00 and the clean kick in 01–0F, switching with F01 on the second table line — or without any command by setting PLAY LOOP, LENGTH 1, REPEAT 0, SPEED 01, which plays wave 00 for one tick and then jumps to 0F. A kick that becomes a bass note: in LSDj 7 with DRUM pitch, start two octaves up and let the L line carry transpose E8 (−24); in LSDj 6 it needs FAST pitch and instrument TRANSPOSE ON — line 1 transpose 0C with a two-tick P down, line 3 transpose F4 with an L. A wave snare is the same shape, P then L to the note the snare is tuned to, E commands trimming the decay, layered with a noise snare.

The wave synth in depth (sources: s-intense-tech-01-wave-synth-deep-dive-part-1, s-intense-tech-02-wave-synth-deep-dive-part-2, s-infu-getting-started-with-lsdj): a wave is 32 four-bit samples, and the number of cycles inside the frame is the harmonic that sounds, so the synth's CUTOFF reads as harmonic numbers — every multiple of 10 is one overtone (20 the octave, 30 octave + fifth, 40 two octaves). SIGNAL saw = all harmonics, square = odd harmonics (the pulse channels' 50 % sound), triangle = odd harmonics falling off faster (the deep NES-style bass); there is no sine, but Lowp with CUTOFF 10, Q 3 and VOLUME 08 extracts one — the lowest, cleanest bass and kick wave the channel can make. PHASE Normal compresses the wave and pads it with silence, so Square with Phase 00 → 1F is a pulse-width sweep ("SID lead"; Triangle gives a vocal-like lead); Resync repeats the compressed wave to fill the frame (new overtones), Resync2 repeats without compressing (quieter). DIST governs overflow when VOLUME or Q exceed 0–F: Clip squares the wave off, Fold (version 6) mirrors the excess for resonant highs, Wrap throws it to the opposite edge for buzz; VSHIFT follows the DIST type in version 6 (FF with Fold inverts the wave). LIMIT (version 6) clamps the samples afterwards (5 = 5–A) — the fine volume control the hardware's four levels lack, and with different start and end values a volume fade. Infu's rules of thumb: Q does little until CUTOFF moves, VOLUME above 20 triggers DIST, LIMIT above 0F rarely helps, instrument LENGTH skips waves, and W sets SPEED and LENGTH from a phrase. A synth's parameters interpolate from the first to the last of its 16 waves, so a kick and a bass can share one synth: the kick plays the first wave, the bass loops the rest.