A gayageum with no audio files
How a small mobile parry game synthesizes every note of its Korean zither soundtrack at runtime, and a demo you can play below.
Boreumdal (FullMoon), solo developer · October 2026
Ink Parry: Seonbi Swordsman is a one-thumb parry game set in Joseon-era Korea. Attacks come at you from the edge of a circle; you swipe toward them at the right moment. I wanted it to sound like Korea, which for me means the gayageum, a twelve-string zither with silk strings that bend and tremble under the left hand.
I didn't have recordings I could license, and the game also had to stay small enough to run inside a mobile webview. So the game ships with zero audio files. The music and the sound effects come from about 1,100 lines of TypeScript on top of the Web Audio API. This post walks through how that works.
Try the string
Tap a string. This is the exact synthesis code from the game, running in your browser. Turn silk excitation off to hear the textbook version.
Listen first
These are recorded straight from the game's synth with an offline audio context. Nothing is edited except a fade at the end.
1. Karplus-Strong, tuned properly
Karplus-Strong is the classic plucked-string trick. Fill a short delay line with noise, then keep feeding its output back through a gentle averaging filter. The loop length sets the pitch, and the averaging slowly eats the high frequencies, which is what a real string does as it rings.
The catch is tuning. A delay line has a whole number of samples, so at 44.1 kHz the higher strings land noticeably sharp or flat. The fix is a first-order allpass filter in the loop that adds the missing fraction of a sample:
const period = sampleRate / freq;
const L = Math.floor(period - 0.5); // whole samples (averaging adds 0.5)
const d = period - 0.5 - L; // the leftover fraction
const C = (1 - d) / (1 + d); // allpass coefficient
// per sample:
const avg = 0.5 * (x + last) * rho; // averaging + decay
const ap = C * avg + apX - C * apY; // fractional delay
Decay is set per string from a T60 time (how long until the note is 60 dB quieter): rho = 10 ** (-3 / (freq * t60)). Low strings get about 3 seconds, high strings under one, so the bass notes bloom and the top notes stay crisp.
2. Making it sound like silk, not steel
Plain Karplus-Strong sounds like a bright steel string or a harpsichord. Gayageum strings are twisted silk: the attack is soft and the tone is hollow. Three small changes got me most of the way, and you can hear the difference with the toggle in the demo.
- Smoother excitation. I run the initial noise burst through the averaging filter twice before it enters the loop. Less high-frequency energy at the start means a rounder attack.
- Pluck position. Plucking a string at 1/7 of its length cancels the harmonics that have a node there. I fake that with a comb: subtract a copy of the excitation shifted by L/7 (scaled to 0.85). This is what makes it sound hollow.
- A wooden body. Every string goes through a peaking EQ at 260 Hz (+4 dB) and a gentle low-pass at 4.2 kHz. That's a very rough stand-in for the paulownia body, but it takes away the synthetic fizz.
Finally, a 4 ms fade-in at the start of each note gives a tiny fingertip-on-silk feel rather than a click.
3. Bake once, play cheaply
Running the loop live for every note would be wasteful on a phone. Instead, the first time a string is needed, the game renders it once into an AudioBuffer (each string has its own fixed noise seed, so it sounds the same every time) and plays it back with an AudioBufferSourceNode. A whole game uses a couple of dozen distinct strings at most, so the cache stays tiny.
4. The left hand: nonghyeon and kkeokgi
What makes a gayageum sound like a gayageum isn't the pluck. It's what the left hand does afterwards. Players press the string behind the bridge to make the pitch tremble (nonghyeon) or to push it up and let it fall back (kkeokgi). Both are just automation on the buffer's playbackRate:
// kkeokgi: push up two semitones and let it fall back
const up = 2 ** (2 / 12);
rate.setValueAtTime(1, t + 0.18);
rate.linearRampToValueAtTime(up, t + 0.34);
rate.setValueAtTime(up, t + 0.50);
rate.linearRampToValueAtTime(1, t + 0.68);
// nonghyeon: 5.2 Hz vibrato that deepens after the attack
curve[i] = 2 ** (depth * Math.min(1, u * 2.5) * Math.sin(u * dur * 2 * Math.PI * 5.2) / 12);
rate.setValueCurveAtTime(curve, t + 0.22, dur);
The delays matter more than the shapes. The vibrato starts about 0.2 seconds after the pluck and grows in, the way a player lets the note speak first.
5. One scale for everything
All pitches come from one function. It uses pyeongjo, a five-note mode (Hwang, Tae, Jung, Im, Nam) that I set at Hwang ≈ E♭4 = 311.13 Hz:
const PYEONGJO = [0, 2, 5, 7, 9]; // semitones above Hwang
function scaleFreq(step) {
const oct = Math.floor(step / 5);
const deg = ((step % 5) + 5) % 5;
return 311.13 * 2 ** (oct + PYEONGJO[deg] / 12);
}
The parry sounds use the same function, so a perfect parry lands on a note of the scale (which note depends on the direction you swiped). In a busy fight the hits and the music never clash, and the hits almost become part of the melody.
6. A composer that doesn't repeat itself
Loops get tiring fast in a game you replay a hundred times. So instead of a track, there is a tiny composer that writes 12-beat phrases as it goes:
- Each note moves one or two steps up or down from the previous one, staying inside two octaves.
- Long notes get vibrato. Short notes that land on Jung sometimes get a bend up toward Im, a gesture that sounds idiomatic to my ear.
- Every phrase comes to rest on Hwang or Im, so phrases feel finished.
- A low string marks every three beats as a drone.
- If a new phrase has the same shape as one played in the last 60 seconds, it is thrown away and rewritten (up to eight tries).
Density and tempo come from the game: the longer you survive, the faster it goes (76 to 102 BPM) and the more short notes it writes. Endless mode moves through day, dusk, night and dawn, which shifts the register down or up and adds more vibrato at night. Boss fights add janggu (hourglass drum) patterns built from filtered noise and pitched sine sweeps.
7. The music runs on the audio clock, not the game clock
Parry games love hit-stop, where time freezes for a few frames on a big hit. If the music followed game time, every hit-stop would hiccup the beat. So the scheduler only looks at AudioContext.currentTime: each frame it schedules whatever beats fall in the next 0.4 seconds, and game time never enters into it.
Mixing is set so the parry is always the hero. The music sits around −17 dBFS during play while hit sounds peak near −6. On each parry the music ducks to 45% in 20 ms and recovers over about a third of a second. When your health is low, the whole music bus slides from a 4.2 kHz to a 700 Hz low-pass, which sounds muffled and slightly underwater without needing any extra sound.
What I'd tell myself at the start
- Get the tuning right first (the allpass). Out-of-tune strings made everything else sound worse than it was.
- The excitation is the instrument. Most of the "silk" came from shaping the first few milliseconds, not the loop.
- Technique beats timbre. Vibrato and bends with the right delays did more for "Korean-ness" than any amount of EQ.
- Render to WAV offline and listen with headphones. I kept a script that renders the title, a full run and each boss to files, and I checked peak and RMS levels every time I changed the mix.
It's not a sampled gayageum, and a real player will hear the difference. But it's small, it never repeats, it's always in tune with the gameplay, and it sounds like the place the game is set in, which was the point.
Ink Parry: Seonbi Swordsman is out on iPhone and Android. It's a one-time purchase, with no ads and no in-app purchases.