Instrument tables (wave / pulse / filter)

On the sid — and on the game-boy in lsdj — an "instrument" is not a sample but a small program: a set of tables that the player steps through frame by frame to change waveform, pitch, pulse width and filter while a note plays. sid-wizard gives each instrument its own three tables (source: s-sid-wizard-manual); goattracker uses the same idea with four shared tables that instruments and pattern commands point into (source: s-goattracker-readme); sid-factory-ii has wave, pulse and filter tables addressed by index (source: s-chordian-sf2-instruments).

The C64 community's word for what the wave table does is "wavetable": "a synthesis method, where the waveform and frequency of a SID voice is modulated so fast, that the resulting output sounds like a new waveform … The parameter changes are stored in a table"; the rows are 20 ms frames because the players are called from the 50 Hz raster interrupt — so a synthesizer that wants to copy a SID drum has to slow its own sequencer down to one step per 20 ms (source: s-ucapps-wavetable-sounds-tutorial-1). furnace implements the same idea as per-tick macros in the instrument — arpeggio, duty, waveform, pitch, cutoff, filter mode, resonance, a "special" macro for ring/sync/gate/test, and one per ADSR nybble — with the twist that its volume macro is global, because it writes the chip's single volume register (source: s-furnace-c64-docs).

SID-Wizard's three tables#

Waveform-Arpeggio-Detune table (Shift+W) — three columns per row:

The 1.6 charts sharpen three entries: WF $00–$0F repeats "only arpeggio/detune-columns for 1..16 frames (no Waveform-change)"; a $FE jump whose target is ≥ $40 "jumps to itself"; and on the $7F chord-jump row the WF column ($00–$0F) overrides the chord speed — "if you do this, you should leave the default chord speed setting to $00" (source: s-sid-wizard-charts-and-tables). The beginners' tutorial adds the timing rule and a loop idiom: "each row of the tables in a C64 tracker lasts for a 50th of a second (or a 60th in NTSC-land)", and FE xx loops a table, even to itself (source: s-chipmusic-c64-music-for-dummies). "Arp overrides/cancels slide/vibrato" — an arp entry with a pitch shift cancels any running slide or vibrato. Used for wavetable-programming, chord-arpeggio and detune.

Pulse-width table (Shift+P):

The third column is a keyboard-tracking curve ($00 off; $01 upward = more dependence on note pitch, $FF downward = less). See pulse-width-modulation.

Filter-program table (also C=+F toggles filter reset):

Third column: $00–$7F / $FF–$90 keyboard tracking, $8x filter-switch override. Filters switch on automatically for channels using filtered instruments; the leftmost channel has priority when several tracks want the filter; an empty first row makes the instrument filtered without controlling the filter. See filter-programming.

Note-off rows and reset behaviour (SID-Wizard)#

Shift+SPACE marks a row of any of the three tables as the row to jump to on note-off — "more control on the release phase of the instrument … reverb-like effects by changing the waveform (or pulse and filter programs)"; the default program can be separated from the note-off part with a $FE self-jump. C=+P / C=+F set whether the pulse / filter program restarts on every note (bright header) or only when an instrument is selected (dark header); selecting the same instrument again in a pattern restarts them. The WF-ARP table needs at least one row, and $FF (END) is shown, not typed (source: s-witchmaster-creating-chiptunes-with-sid-wizard).

Exact execution semantics (SW 1.97 player.asm, m64's DUET research)#

What the tables above cost and when they run, from the player source (sources: s-duet-research-sidwizard, s-duet-research-sidwizard-deep):

• Tick units: the WF-arp table steps once per instrument-tick (a row is held speed+1 player calls; in multispeed tunes the unit is player calls, not video frames). The pulse and filter tables run every call that reaches them: a set row costs exactly 1 tick; a sweep row [N,xx] performs N additions over N+1 ticks (the last tick advances without adding). $00 as a sweep command is a valid 1-tick NOP that still loads the third column.
• No table row executes on the note-start tick — tables begin the call after; on ticks 0/1 before a new note only the WF table runs (Normal player). PW/filter sweep counters survive note start (a residue can shorten a first-row sweep).
• Terminators: $FF ends a table but the state holds — the output stage keeps writing the last pulse/cutoff every tick, and after a WF-table end the accumulated slide/vibrato owns the pitch. A $FE self-jump in the PW/filter tables means "hold forever".
• All jump targets and the gate-off pointers are instrument-base-relative — SWM-spec.src's "relative to table" comments are wrong; the player (NGATEOF 3117–3175) is ground truth.
• The WF $FE rule at player level: the manual's "target ≥ $40 = jump to itself" is SWMconvert's GoatTracker-conversion heuristic — the player halts only on targets ≥ $80 (player.asm 2422), a target < $80 jumps and executes the target row in the same step, and there is no self-jump guard at all (the editor prevents degenerate data).
• Reset rule (TABLRST 1826): the PW/filter table position resets iff the instrument's reset-disable bit (ctrl 6/7) is clear OR an instrument number appears in the row — so C=+P/C=+F "no reset" is overridden every time you re-type the instrument.
• Gate-off ($7E) redirects all three tables to the instrument's gate-off pointers rather than merely clearing the gate — and if the WF gate-off pointer is set, the gate bit is NOT cleared by the FX; the pointed rows must carry gate-0 waveforms.

GoatTracker's shared tables#

Four tables shared by all instruments — wavetable, pulsetable, filtertable and a speedtable for vibrato/portamento/funktempo — each row a left and a right byte; an instrument holds start rows for the first three ($00 = not used), a pattern command (8XY, 9XY, AXY) can point anywhere, and FF xx rows jump (00 = stop). Rules: never jump onto a jump row; the wavetable's first row of an instrument must set a waveform; the wavetable can even execute pattern commands (F0–FE). SHIFT+O removes unused rows, SHIFT+INS inserts without moving pointers. Value schemes are on goattracker; the speedtable makes a vibrato of speed 03 depth 40 read 03 40 and a slow bass vibrato 05 04 (source: s-goattracker-readme).

Table speed and multispeed#

The instrument's "WF-Arp table execution speed" runs the wave table slower than once per frame; values above $40 run the pulse table at multispeed rate, above $80 the filter table too.

Other per-instrument settings#

ADSR and ADHR (adsr-envelope, hard-restart), frame-1 waveform, hard-restart timer and type, vibrato amplitude/rate/delay and type, default chord, octave shift, and PW/filter reset (re-initialise the tables when the instrument is selected; toggled with C=+P / C=+F). Gate-off entries can be placed in the tables (Shift+SPACE sets the note-off table position).

LSDj tables#

LSDj has one table type with six columns: envelope (amplitude digit + number of ticks; loop by putting the target step in the first digit and H in the second), transpose (semitones from the played note), and two command + value pairs that accept any phrase command (P, L, V, E, W, S, F, O, G, A, H, B…). Speed is one tick per step unless a G groove says otherwise; H builds nested loops (H21 = hop twice to step 1, H04 = forever), B makes probabilistic hops. A table starts with every note when set in the instrument (TICK mode) or advances one row per trigger (STEP mode), or is started/stopped from a phrase with Axx / A20. Uses: arpeggios (transpose column), custom envelopes, drum pitch drops, rhythmic gates (source: s-lsdj-manual).

defense-mechanism's table lesson adds the details the manual leaves out (source: s-intense-tech-09-lets-table-this-discussion): the volume column's second digit is the number of ticks to hold the level (36 = volume 3 for six ticks); after the last filled line the instrument keeps that level until the note is killed — unless all 16 rows are filled, in which case the column loops; the wave channel's range is 0–3. D cannot be used in a table; L follows the transpose column (first command column only) and L00 resets the pitch. "Automate" — renamed STEP in version 8, with PLAY for the usual one line per tick (source: s-intense-tech-14-lets-appreciate-version-8) — applies one line per note. A inside a table extends it into another table, or — with Automate — nests a second table so that four commands run at once (one in the phrase, one in table 01, two in table 02 called by A02); A20 or higher stops the table without a K, since no table beyond 1F exists. When two channels play the same Automate instrument at the same time, the first channel gets the even-numbered rows and the second the odd-numbered ones — a stereo effect from one table, one instrument and one phrase (stereo-panning). Attack tricks: a high instrument volume then a drastic E cut (noise snare — the mixing article credits the trick to Pain Perdu: instrument volume around 90, the table's E pulling it down after the first tick, an E beside the note in the phrase to scale the burst; source: s-intense-tech-15-lets-mix-it-up-and-down), 0C in the transpose column on the first tick, a pulse waveform change on ticks one and two, or a fast V on tick one cancelled by V00 on tick two.

Later versions changed the table machinery (sources: s-intense-tech-12-scoping-out-new-features, s-intense-tech-14-lets-appreciate-version-8, s-intense-tech-19-new-noise-and-910-news): FX/SPEED, introduced in 7.7.4 and renamed CMD/RATE in version 8, slows C, P, R and V (P and V on pulse and wave only in TICK pitch); B in a table is a probabilistic hop — B05 never hops to row 5, B85 about half the time, BF5 about 15 times in 16; version 8 lets xF in the volume column hop to row x, makes R on the wave channel restart the synth from its first frame, replaces the wave instrument's REPEAT with LOOP POS (the loop point; 0 repeats every frame within LENGTH), and CLEAN SONG DATA / CLEAN INSTRUMENT DATA remove duplicate tables; since 9.1.0 the noise channel's P sweeps the ordered noise notes (P01 = S01 every 4 ticks, P04 every tick), so noise kicks, hi-hats and crashes no longer need a hand-made S table.

How players learn tables (sources: s-chipmusic-tables-and-chords-threads, s-infu-getting-started-with-lsdj): count in ticks — "each step is 6 ticks" (Dire Hit), so a table row is a sixth of a phrase step; use H loops to give a command time to act, "like a ADSR works on a synth" (herr_prof: a3 up to c3 over four steps and back down); embed the table in the instrument so the phrase's command column stays free; end with A20 ("no table") so running effects continue; and dissect other people's .sav files. Infu's snare table is the beginner template: alternating O pans, a raised transpose on the first rows, a slow upward V against a downward P, then A20.

Three more things the tables do, from the later sources:

• The instrument number restarts the table; the note does not. Leaving it off is legato and skips whatever the table's first rows do — which is what Victory Road's flute is built on: a synth whose first frame is much louder than the rest, PLAY set to MANUAL and an F01 on the first table tick, so every note that carries the instrument number gets an attack and "you can imitate tonguing and slurring in the phrases by removing the instrument number from notes that you want slurred". Flutter tonguing then alternates two frames from a second table, F01 to step forward and FFF to step back (FFF is −1 in F's relative arithmetic) (source: s-chipmusic-lsdj-wav-instrument-tutorials; lead-articulation).
• S adds, it does not set. "The S command adds to the shape parameter, it does not set the shape … it's relative, so it adds on top." Adding F0 on a looping table row wraps the noise shape around and lands one step lower each time, walking a sweep down slowly instead of jumping, and the H hop's timing decides how often the addition happens — i.e. how fast the sweep moves (source: s-painperdu-03-isometric-sav-walkthrough).
• Tables are the scarce resource. There are 32 of them ($00–$1F) and far more phrases, so the economies are real: one instrument with several tables instead of one instrument per chord — "if you optimise carefully and choose your root notes well, you can just slap the same instrument with a different table on top" (table 0C being the same shape with a minor third instead of a major); an arpeggio written out in a phrase when the tables are needed elsewhere; a swell written as two phrases rather than two instruments, "since you have way more phrases than tables"; and two channels running the same table three ticks apart at different duties, which "your brain just kind of glues … together" (source: s-painperdu-03-isometric-sav-walkthrough; chord-arpeggio, fake-echo).

A drum table shows all six columns at once. Mrwimmer's noise kick is 00 --00 / 00 -SF0 / 00 -SF0 / 00 -SE0 / 00 --00 / 00 -H05 against an envelope of decay 1 and shape FC — "the noise sweeps down in pitch pretty quick"; metatronaut's snare puts the pan flick in the table instead (F0 OL- / F0 O-R / -- OLR, with H03 on row 8). The rest of the noise-drum recipes are on instrument-design and wavetable-programming (source: s-chipmusic-noise-drum-threads; stereo-panning).

The 1980s ancestors: 24, 8 + 8 and 8 bytes#

• soundmonitor's sound is 24 hex bytes edited on a "page": waveform at key-on and at key-off, ADSR, pulse width plus a pulse EG (count-up time, count-down time, step), portamento speed and mode, vibrato depth/speed/delay, fine detune, and a filter block with its own filter EG (type nibble, resonance/voice mask, cutoff, up/down times, step lo/hi, mode and trigger voice) — modulation as timed counters rather than stepped tables (source: s-64er-soundmonitor-article).
• matt-gray-player (1987): two 8-byte rows per instrument — pulse nibbles, control register, AD, SR, pulse step, arpeggio (count + table index), end-of-note control register, effect bits; then vibrato step and length, a 2-frame start control register, portamento value and mode, effect length — with arpeggio lists shared between instruments (source: s-sidin02-matt-gray-driller); V4.2 adds a drum table of (waveform, pitch) frame pairs and PLEX chord tables (source: s-matt-gray-dominator-source).
• musicfile (1988): one 8-byte row (pulsehi, waveform, attdec, susrel, filcount, fx1, fx2, fx3) per instrument plus shared pulsetabel, filterbytes, arp lists, drumtabel (waveform list + pitch list) and per-instrument start waveform/length tables (source: s-realdmx-sid-players).
• tfmx (1988) is the step to programmable instruments: "a script language in addition to the typical rigid instrument table" (source: s-vgmpf-soundmonitor-tfmx).
• JCH's NewPlayer (from July 1988) dates the moment a private driver acquires one. His OldPlayer of 1987 had done waveform swapping "programmatically instead of using a flexible table"; NewPlayer went "from a prototype version with mere bleeps to one with pulsating, arpeggio and drums using a table of waveforms, all within a sensible use of CPU time" — the table arriving together with the CPU budget that made it worth having. His surviving paper includes a notebook of "chord counts" he "referred to … when constructing arpeggio chords in my old SID tunes" (sources: s-chordian-my-computer-chronicles, s-chordian-player-editor-notes; chord-arpeggio).

More 1980s layouts: 8, 29, 5, 16 bytes — and none#

The realdmx drivers read from source on 2026-08-30 (cheat sheets on the tool pages):

The recurring 1988–91 idea is the gate time inside the instrument (Ocean, FAME, Scoop, Audial Arts, Galway's $1b), which trackers later expressed as gate-off or hard-restart timers (hard-restart).

An instrument the music pokes while it plays (Galway's Arkanoid, 1986). The 29-byte definition is copied into a 34-byte running copy per voice, and the byte stream can write to either: SETNI loads the first n bytes of a definition, INSTR the five register parameters, SETCI and SET2CI a single byte of the running copy — so an "instrument" here is memory the music edits mid-note. Two of its bytes are pure timing: $1B "Duration before apply release ($FF means not apply release)" and $1C "Duration before an hard restart" (hard-restart). The sound-effect variant is "a perfect copy of the instrument table, but with two extra bytes at the end: the low/high value of the frequency to use", with no note and no duration of its own (sound-effects). Tognon, after reverse-engineering all of it, still writes: "not all the meaning of this flags I was able to understand … try to found by yourself the answers :(" (source: s-sidin04-galway-arkanoid).

Two more layouts from SIDin: a 2004 tracker and a 1988 Italian driver#

• asterion-sid-tracker (2004): an instrument is one sound table row of 13 fields — A/D, S/R, WAV and ARP (start positions in two independent macro tables with their own speed WAS), VDE/VDS vibrato delay and depth/speed, PWM/PLM pulse speed and limits, SCP/MCP cutoff-and-pulse speeds, FCT/FLM filter start and limits, R/T resonance, filter type and a hard-restart bit; the macro tables use $FE to end and $FF n to loop, and the ARP column mixes relative ($00–$7F), absolute ($80–$DF) and "skydrive" ($E0) entries — the SID-Wizard/GoatTracker table idea on a native one-screen editor (source: s-sidin06-asterion-sid-tracker).
• The modules driver (Ivan Del Duca, 1988): the opposite extreme — nine tables of 16 entries (tbAD, tbSR, tbWLo, tbWHi, tbCntOn, tbCntOff, filtCutFH, filterResCtr, filterMode), i.e. ADSR, a fixed pulse width, the control byte for note-on and for release, and a filter preset (cutoff high byte, resonance/routing, mode); every modulation is a pattern command instead, so "al the effects that the player can reproduce are not associated with the instrument, with one exception: the filter" (source: s-sidin07-inside-modules).

Instruments under a size limit (Tiny SID, 2005)#

The 2005 tiny-sid-compo is the useful stress test: what survives when the whole player and the song must fit in 512 or 256 bytes turns out to be the table itself (source: s-sidin08-tiny-sid-512b, s-sidin09-tiny-sid-256b).

• Two parallel wave tables — laxity's Twone Five (512 b, second place): wavetab1 holds control bytes and wavetab2 the pitch, where a positive entry is semitones added to the note, a negative one an absolute note, and $00 ends the row. Bass = $81,$81,$41,$00 / $c0,$c0,$00,$00 ("2 ticks with noise and E5 note, follow by rectangular waveform and relative note 0"); Snare = $81,$81,$11,$40,$80,$00 / $d0,$d0,$b2,$ac,$ca,$00; Kick = $09,$81,$11,$10,$10,$10,$10,$00 / $d2,$d2,$ae,$a6,$a2,$9e,$96,$00. Laxity's own summary — "extreemly simple but still handles wave tables for instrument. AD is fixed for all channels, SR is set per channel. Hard restart is always enabled. No vibrato, no slide, no tie notes" — and Tognon's verdict: "if you had composed with some real editor around, you are familiar with this kind of instrument implementation."
• Five bytes and one counter — 4mat's Empty (512 b, winner): instadsr (SR only), instadd (added to the pulse low byte every frame), instpuls (low nibble = pulse high byte, high nibble = the loop position 1–3), and three-entry instdata/instwave rows in which instdata ≤ $ef is a pitch high byte and $f0–$ff an arpeggio offset ($f0 = the pattern's own note). The saving has a price he states himself: "I only have one counter for both data & waveform to save memory, so any instrument that loops can't use release value" — two columns, one pointer.
• Three bytes, with the duration inside (256 b): AD, the control byte, and the note duration. "This trick of use duration inside the instruments is very interesting, as with one instruction you set the duration of note and the instrument to use … one instruments cost you only 3 bytes" — and a silent instrument carrying the longest duration is then an entire empty pattern written as one byte.

What does not survive is the separation: at these sizes an instrument stops being a set of tables plus an ADSR and becomes one or two columns stepped a row per frame — the same shape a full tracker's wave table has, with everything optional removed.

Three more layouts: a register stream, 2 bytes, and driver-defined rows (2006–2007)#

• A control byte plus the registers it names (Frantic's BLOCK ACID DUB, 256 bytes): each row begins with a byte whose bits $80 SR, $40 AD, $20 control, $10 pulse high, $08 pulse low, $04 frequency high say which SID registers follow, plus $02 JUMP (next byte = new row pointer) and $01 STAY (hold here); an empty byte waits a frame. A note is $05 / $06 (frequency high + stay), a drum five such rows, an arpeggio two rows jumping to each other — "Not using different code structures for 'notes' and 'instruments'. It's all just SID data" (source: s-sidin11-tiny-sid-2-part-2).
• Two bytes: RM's nine instruments are a control byte and one byte holding AD in the low nibble and SR in the high nibble ($4A = AD $0A, SR $40), split with AND #$0F / AND #$F0 on the way to $D405/$D406 (source: s-sidin10-tiny-sid-2-part-1).
• Rows whose meaning the driver defines — laxity's SID Factory (2007): the v5.0x driver's instrument is 8 bytes (AD, SR, two flag bytes for restart / arpeggio mode / oscillator reset / HR-table pointer / pulse-filter settings / arpeggio delay, resonance, filter, pulse and wave pointers), the "fast" v6.0x driver's is 6 (AD, SR, flags $80/$40/$20/$10, filter, pulse, wave pointers); the editor shows whatever table set the loaded driver declares. ninjatracker's "command" is 4 bytes: ADSR and three table pointers (00 = keep the running table) (source: s-sidin11-sid-factory-vs-ninjatracker; details on sid-factory-ii and ninjatracker).

defMON: the whole instrument system is one table (2008)#

frantic's defMON collapses the idea to its limit: one table, the sidTAB, whose columns map almost 1:1 onto SID registers (JP DL WG WG AD SR TR AF PW PS RE FV CP ACID — jump, delay, waveform, gate, envelope, transpose, finetune/bend, pulse, filter), and no distinction between instruments and effects at all — iLKke: "the only true tracker for the C64 … No tables with pointers to tables", and the no-distinction idea is "similar to NinjaTracker". The table is subdivided into chunks (every 8th row highlighted by default), and each sequence step can call two chunks at once, the second overriding shared columns — so a "vibrato" or "slide" is just a second chunk laid over the instrument, defMON's replacement for effect commands. JP builds loops for vibratos and arpeggios; frantic refused loop-with-counter commands on principle ("The limit has to be drawn somewhere") (sources: s-defmon-wiki-manual, s-defmon-wiki-defmoning-101, s-chipmusic-defmon-thread).

CheeseCutter: the JCH tables on the PC (2011)#

cheesecutter's instrument is 8 bytes — ADSR, a restart-type + wave-delay byte, a hard-restart waveform, filter and pulse program pointers (00 = "keeps playing any … program set by another instrument"), and a wave-table pointer — over wave/pulse/filter/chord tables that keep the JCH byte meanings ("works like byte C/B/A/D in JCH's players") with upgrades: 10-bit filter sweeps, an indexed chord table that doubles as the swing program, and a 3-byte command table whose first row holds the HR ADSR (source: s-cheesecutter-guide).

JITT64: unshared tables with a delay/repeat field (2010)#

jitt64 takes the opposite road from GoatTracker's shared tables: each instrument owns eight command columns — AD, SR, Wave, Frequency, Pulse, Filter cut-off, Resonance, Filter type — in a 127-row table, plus its own Table of Values holding the numbers the columns refer to (absolute notes for 8 octaves in four tunings, relative notes ±31, relative frequencies up to 32768, absolute frequencies, fixed and relative pulse values, cut-off values), "up to 2KB of data for its definition"; only the packer removes what a tune does not use. Every entry carries a D/N field — delay ticks and repeat count: 0|0 one tick, 2|0 next entry after 3 ticks, 2|3 = (2+1)×(3+1) = 12 ticks — and a column can loop from a "step" row a set number of times or forever. In the player each column is a small block — length, allowed repeats, loop position, then (value, delay/repeat index) pairs — stepped by one macro for all eight columns, with frequency, pulse and filter values routed through helper routines into shadow registers (sources: s-sidin13-jitt64-tracker, s-sidin13-inside-jitt64).

• matt-gray-player V4.2, as Tognon documents it in 2015 (16 bytes = two 8-byte rows, up to 32 instruments): 0 pulse start (swapped nibbles) · 1 control register · 2 AD · 3 SR · 4 pulse step · 5 unused (the Driller arpeggio byte — the plex became a pattern command) · 6 second control register, written gate-off on instrument change and before the main one at each note · 7 effect bits (1 drum table, 2 pulse modulation, 4 implex waveform switch, 16 hat) · 8 vibrato step · 9 vibrato length · 10 implex control register · 11 slide value · 12 slide flag (1 down, 2 up, 3 down on the high byte, 4 up on the high byte) · 13 drum-table index · 14 pulse limits $LH · 15 unused (source: s-sidin14-dominator-player).

Two things a table's speed depends on#

A table advances one step per tick by default, and a Gxx inside it sets its own groove instead — the cheap way to slow an arpeggio without doubling its rows, or to pack more commands into a percussion table (credited by pain-perdu to Joe Toye of Chiptune Belgium; source: s-painperdu-06-grooves, and see shuffle-funktempo).

With TABLE set to AUTOMATE the clock changes entirely: the table steps once per instrument value played, not per tick. A stock L/R panning table therefore reads L R L R when every note carries the instrument number, and L L R R when only every second note does — the table becomes a phrase-level rhythm, and leaving the instrument number off keeps it running rather than restarting it (source: s-painperdu-01-instrument-retriggering; retrigger).

Related#

wavetable-programming · pulse-width-modulation · filter-programming · instrument-design · sid-wizard · furnace · defmon

Sources#

s-sid-wizard-manual · s-lsdj-manual · s-goattracker-readme · s-witchmaster-creating-chiptunes-with-sid-wizard · s-chordian-sf2-instruments · s-intense-tech-09-lets-table-this-discussion · s-chipmusic-tables-and-chords-threads · s-infu-getting-started-with-lsdj · s-sid-wizard-charts-and-tables · s-chipmusic-c64-music-for-dummies · s-intense-tech-12-scoping-out-new-features · s-intense-tech-14-lets-appreciate-version-8 · s-intense-tech-15-lets-mix-it-up-and-down · s-intense-tech-19-new-noise-and-910-news · s-ucapps-wavetable-sounds-tutorial-1 · s-furnace-c64-docs · s-64er-soundmonitor-article · s-sidin02-matt-gray-driller · s-matt-gray-dominator-source · s-realdmx-sid-players · s-vgmpf-soundmonitor-tfmx · s-realdmx-hubbard-player · s-realdmx-galway-rambo-player · s-realdmx-galway-arkanoid-player · s-realdmx-ocean-dunn-hughes-driver · s-realdmx-bjerregaard-player · s-realdmx-fredgray-kimmel-whittaker · s-realdmx-audial-arts-fame-players · s-realdmx-deenen-test-tunes · s-realdmx-ouwehand-mon-tunes · s-sidin06-asterion-sid-tracker · s-sidin07-inside-modules · s-sidin11-tiny-sid-2-part-2 · s-sidin10-tiny-sid-2-part-1 · s-sidin11-sid-factory-vs-ninjatracker · s-sidin13-jitt64-tracker · s-sidin13-inside-jitt64 · s-sidin14-dominator-player · s-defmon-wiki-manual · s-defmon-wiki-defmoning-101 · s-chipmusic-defmon-thread · s-cheesecutter-guide · s-duet-research-sidwizard · s-duet-research-sidwizard-deep · s-chipmusic-lsdj-wav-instrument-tutorials · s-chipmusic-noise-drum-threads · s-painperdu-03-isometric-sav-walkthrough · s-chordian-my-computer-chronicles · s-chordian-player-editor-notes · s-sidin04-galway-arkanoid · s-sidin08-tiny-sid-512b · s-sidin09-tiny-sid-256b · s-painperdu-06-grooves · s-painperdu-01-instrument-retriggering