jGLAM manual — the controls, the sound, and why it renders offline

What jGLAM is

jGLAM is a browser-based electronic music sketchpad inspired by the directness and creative constraints of late-’80s Amiga music software. It combines hands-on wavetable sound design, pattern sequencing, and reproducible procedural generation in a compact instrument for exploring sounds and loops before carrying them into a DAW.

In plain terms: a wavetable synthesizer with a sequencer built in, running entirely in your browser — no account, no install, nothing to sign up for. You build a wavetable out of harmonics, draw notes on a piano roll, press Play, and what you hear is a finished audio buffer that your own machine just computed.

The bet the whole project makes: a tool that can't give you perfection sends your creativity somewhere else. The missing half of a DAW is not a gap waiting to be filled. It is what does the work.

So the target feeling is an Amiga 500 in 1989, with more colours: one small, whole machine you noodle on. Five minutes of clicking should produce something that sounds funny — and sounds exactly like it was clicked together in five minutes. That is the aesthetic, not an apology for it.

What comes out is raw material. When a sketch turns out to be worth keeping, it leaves through an export and becomes real somewhere else: a WAV you drop into Ableton, a wavetable you load into Serum. jGLAM is where the idea happens, not where the record gets made.

Why it renders offline

Press Play and the page thinks for a moment before any sound arrives. That pause is the design, not a bug you are waiting out.

Most music software is realtime: it computes audio in tiny slices, a few milliseconds ahead of your ear, and it must never be late. Miss the deadline once and you hear a click. Everything in a realtime engine is shaped by that deadline — approximations get chosen because they are fast, not because they are right.

jGLAM has no deadline. Play renders the entire song into one buffer first, start to finish, and only then hands the finished buffer to your speakers. Nothing streams. There is no audio thread to starve, no dropout to avoid, no budget per sample.

What that buys

Exactness where a live engine would approximate: Every voice is band-limited per pitch. A wavetable frame is one cycle of a harmonic series, so playing it at a given pitch puts its harmonic k at k times that pitch — anything past half the sample rate would fold back down as aliasing, the metallic grit you hear when cheap synths play high notes. jGLAM resynthesizes a variant of the table for each individual pitch, keeping exactly the harmonics that fit underneath. Exact per note rather than per octave. That is affordable only because nothing is racing a clock.
Reproducibility: A song is fully described by its recipe: a flat list of explicit numbers. Same recipe, same seed, same samples — bit for bit, on any machine, today or next year. There is no hidden state and no unseeded randomness anywhere in the synthesis.
An export that is the thing you heard: Because the WAV is the same buffer that just played, there is no "bounce" step that might sound different from the preview. What you exported is what you listened to.

What it costs

The render is synchronous: while it runs, the page is busy. Two signals tell you what is going on, and they answer different questions. The Play and Export buttons spin while they work — that only says something is happening, and it keeps turning even while the page is blocked. A line in the status bar appears only when the render is predicted to take genuinely long, and it says why. Ordinary patterns say nothing at all, because a warning that fires every time is one nobody reads when it matters.

Cost rises with pitches, frames, samples per frame and harmonic count — a song full of high notes with a large harmonic ceiling is the expensive case, because each distinct pitch gets its own resynthesized table.

The short version: jGLAM is not trying to be a DAW. It is trying to be the machine that hands a DAW something to work with. Offline rendering is what makes the second job easy and the first one impossible, and that trade is taken on purpose.

Your first five minutes

Press Play. On a first visit you land on the four-bar sketch; after that the app comes back to whatever you last had, and a shared link beats both. Nothing ever auto-plays — the sketch waits for you.
Double tap the grid to add a note, double tap it again to take it off. Drag a note to move it; drag its right edge to make it longer.
Scroll down. Under the roll the page looks like a synth: Envelope & LFO and Wavetable stand open. Those are the knobs you turn while the song plays.
Open Recipe when you want a different instrument. Change the seed, press Generate, press Play again.
Take it with you. The download arrow exports a WAV; the chain link copies a link that contains the whole song.

Nothing on this page is required reading. The app is meant to be clicked, and this manual exists for the moment you want to know why something behaves the way it does.

The controls

The app is one scrolling page, stacked the way the model nests: the song on top, then the track, then that track's notes, then that track's sound. Anything you change below the track strip belongs to the one track that is currently active.

On a keyboard, Ctrl+K — ⌘K on a Mac — opens a palette that lists every command with the key that reaches it; type to filter, Enter runs one, Esc closes it.

Song

Play: Renders each track into its own buffer and plays them together, so the mixer is live: mute, solo and level move while the song runs. If a recipe changed since the last render, the affected tables are rebuilt on the same click — nothing ever plays stale.
Loop: Turns looping on and off. The region itself is set on the bar ruler above the grid: drag it, or tap it and the region's nearer edge moves to the bar you tapped, so tapping outside grows it and tapping inside shrinks it. Switching Loop off keeps the region parked, so comparing looped against not is two taps. Playback starts at the region rather than running up to it from bar 1.
BPM: Tempo, 40–240. It belongs to the song, so it cannot drift between tracks.
Bars: Song length, 2–32 bars, four by default — because nobody's first idea is sixteen bars long.
Drive: Saturation on the master, after the tracks are summed. At 0 it is a true no-op. It is one continuous control rather than a mode switch: thin material is left alone, dense material sits down, and quiet material keeps its dynamics at any setting. The top of the range is an effect rather than glue — this is a toy that should be able to sound broken.
Export WAV: The song mixdown as a PCM16 WAV, in one tap. Everything else lives in the Export panel at the foot of the page.
Share: Copies a link that restores this song. See Keeping, sharing, undoing.

Under those sits the app's one status line. It is where the render warning, the clipping report, "Link copied" and the Undo button appear.

Clipping is reported, never repaired

The tracks go through a fixed headroom base — a constant scale that reads nothing about the content, because anything content-dependent would make the level faders relative again by the back door. That means clipping is possible, and when the finished mix goes past full scale the app says how far over and how many samples, rather than quietly turning everything down. Lowering a track's level is the only thing that actually removes clipped samples; raising Drive squashes them but cannot clear the report.

Track

A song holds 1 to 8 tracks on one shared timeline. Each carries its own wavetable, its own notes, its own envelopes and LFO, and a level. At one track the whole track row is hidden and the app looks exactly as it did before tracks existed.

+ Track / Duplicate: Adds a track with a fresh default recipe, or a copy of the active one.
The chip strip: Switches which track is active. Exactly one track is active, and the entire Sound section below the roll belongs to it. The other tracks' notes stay visible in the roll, dimmed in their own colour — there for orientation, impossible to grab.
Mute / Solo: Mute silences a track and Solo silences every other one. Both take effect immediately, while the song plays — nothing is re-rendered, so there is no wait and no gap. Solo is a listening aid while you work — it deliberately never travels in a share link.
Level: Volume, live while the song plays. Turning every track down turns the song down, and a track pulled to zero goes quiet. Muted tracks keep their seat in the headroom budget, so muting one track leaves every other track's level exactly where it was.
Scale: Whether this track shows the song's key in the keyboard gutter. Leave it on for anything pitched; turn it off for a drum track, where the rows do not mean notes. It changes nothing you can hear, and it does nothing at all until the song has a key — see Key under the roll.
Delete: Removes the active track. Undo takes it back.

The piano roll

The roll shows the full range C-1 to C7 through a moving viewport. One rule governs every gesture: where you touch decides, not how long you wait. Nothing depends on elapsed time, so there is no half-second in which a hesitation turns a pan into a move.

Double tap (or double click): Toggles a note on the cell you can see. On a cell that already holds one, it takes that note off. A single tap on the grid writes nothing — that is what keeps a scrolling finger from writing notes by accident. With a finger it does nothing at all; with a mouse or a pen it selects, as described under Select below.
Drag a note's body: Moves it in pitch and time at once, keeping its length. Two notes of the same pitch may not overlap: the earlier one ends where the later one begins.
Drag a note's right edge: Sets its length. A note is never shorter than one storage step.
Drag empty grid, or scroll the wheel: With a finger, or with the wheel, pans the view; with a mouse or a pen the drag selects instead, and the middle button pans. Hold a drag at the left or right edge and the song scrolls along under it, so a note can be dragged into a bar that was off screen when the drag started. A wheel pans the roll until it reaches the edge and then scrolls the page on.
Select, with a mouse or a pen: Outside Draw and Chord, click a note to select it, and click empty grid to set the insert marker, the line a paste lands at. Drag across empty grid to select every note the band touches — in Draw that drag paints instead. Shift+click adds or removes a note, or on empty grid moves only the marker, and Shift+drag on empty grid adds a band; in every mode, Draw and Chord too, neither writes a note. Drag a selected note and the whole selection moves, stretches or, in Velocity, changes level with it. The usual copy, cut, paste, delete and select-all keys act on the selection, and the palette (Ctrl+K, ⌘K on a Mac) lists every key. Selecting on touch is not built yet.
The bar ruler: Drag or tap it to set the loop region, as described under Loop above.
Draw: Turns the double tap into a single tap: one tap writes a note, one tap on a note removes it, and with a mouse or a pen a drag across empty grid paints a run of them — one per cell, never over a note it passes, and the whole run is a single Undo. A finger still pans there, because on a phone the empty grid is the only thing left to scroll from. Edit mode stays the default, because a stray tap there writes nothing while in draw mode it deletes what it lands on. The mode lasts for the session only and is in no share link.
Chord: The other single-tap mode — switching either on switches the other off. One tap on a row the key colours stamps that row's triad: root position, upward from where you tapped, major, minor or diminished as the key decides. One tap beside the key writes one ordinary note, and what a stamp writes is ordinary notes too — a tap on one of them removes that one note, and a whole stamp is a single Undo. The colouring is the map: a striped row is exactly a row where a tap gives a chord. A track's Scale switch only hides the colouring — a tap there still stamps. Like Draw, the mode lasts for the session only and is in no share link.
Velocity: The third mode, and the one that takes the notes rather than the tap: drag a note up or down to set how loud it plays, in eight steps from an eighth to full, and the note fills from the bottom to show it — the picture is the readout, and a percentage follows the drag. A double tap on a note puts it back to full. While the mode is on, nothing writes, moves or resizes; empty grid and the ruler do what they do outside it. A note at full carries no value at all, so a song drawn before velocity existed sounds exactly as it did. Velocity is a value on a note; a value over time is automation, which is the next mode along. Like Draw, the mode lasts for the session only.
Automation: The fourth mode: the notes stay on screen but stop being editable, and a row under the roll is where you draw. Its button sits below the roll, so on a phone you leave focus mode to reach it. Tap a knob to pick what a curve moves: in the mode every knob that can carry one wears a dashed ring — Cutoff and Reso, the comb, flanger and delay mixes, the distortion's amount. Turning a knob still turns it; only a tap picks. A point says how far from the knob rather than where, so turning it moves the whole curve, and it stops before the curve leaves its range. Eight points fit in a bar, 512 in a song. A curve on Cutoff overrules that track's filter sweep, whose fields go grey rather than away. Outside the mode a knob with a curve keeps a small mark, and a song with one keeps a thin strip under the roll.
Grid: Which division a tap snaps to: 1/8, 1/16 or 1/32. It is a view setting and only a view setting — notes are always stored on a fixed 1/32 grid, so changing it never moves a note you already wrote. The bar keeps its width at every division; what changes is the size of the cell you tap.
Snap: Turn it off and a note lands where your finger is, down to 1/64 of a storage step. The grid lines stay drawn either way — with nothing snapping to them they are the only thing still saying where the beat is. Percussion is what asked for this.
Key: Pick a key — major or minor on any of the twelve roots — and the keyboard gutter says which rows belong to it: a stripe along its inner edge for every row the key holds, and the root drawn as a tinted key. Every song has one: C major until you pick another. Nothing snaps, nothing is refused, and a note outside the key is exactly as easy to write as it was before you chose one; only chord mode reads the colouring, as the map of where a tap gives a chord. The root is marked because it has to be: C major and A minor hold the same seven notes, so without it half the keys would look identical. A key belongs to the song, not to a track — but each track has a Scale switch that hides the colouring while that track is selected.
Zoom ↔ and Zoom ↕: One control per axis: sideways in three steps (1×, 1.5×, 2×) and vertically in four (0.75× as well). A cell on the default grid is 18 × 16 px, which is why building notes on a phone needs zoom at all.
Clear track: Empties exactly what you see in the roll. The sound, LFO and envelopes survive, so the next note you draw still plays the instrument you built.
Focus: The roll fills the screen. Eleven icons along the edge carry the controls that change how the roll is drawn — Draw, Chord, Snap, Grid and the two zooms — plus Play, Loop, Undo, a Sound/Roll switch and the way out. Esc or Exit leaves, and focus mode is never saved — a reload always leaves it. In focus mode, tapping the chip you are already on opens that track's mute, solo and level as a panel under the strip.

While the song plays, a line in the roll shows where in the buffer you are. It only reads the position — there is no scrubbing and no click-to-seek. It also makes two things visible that used to be only audible: that an edit takes effect at the next loop pass, and where a release tail gets cut off at the loop point.

Sound

This whole section belongs to the active track, and its heading says which one.

Envelope & LFO

Attack, Decay, Sustain, Release: The amplitude envelope, applied to every note on this track. Drag the three handles on the graph — attack time along the top, decay time and sustain level in the middle, release time along the bottom — or turn the four knobs under it. The two are synced in both directions.
Pitch drop, Pitch time, Pitch curve: A second envelope, on pitch. The note starts a number of semitones off its written pitch and falls back onto it. Decay only: on a transient that is the whole mechanism, and sustaining an offset is just a different note. This makes kicks, toms and zaps — the tuned half of percussion; the untuned half is the noise generator below. The curve is the part that matters — linear reads as a cheap effect, exponential reads as something being struck. The time is in milliseconds, not beats, because a 40 ms drop is a property of the drum and must survive a tempo change.
Noise, Tone, Noise decay: A second generator inside the same voice, for the sounds a wavetable cannot make — and quickest learned by what its settings are. Tone near the top is a hat: a thin, fine hiss. About a quarter of the way up, with a short Noise decay, is where a clap starts — a place to push around from in the mix, not a finished sound. A snare is both generators at once: Noise near the middle, a short hard transient from the table in front of a longer noise tail behind it, which works because the tail is triggered by the note rather than held by it and keeps its length however long you drew the note. Noise and Tone run 0–1; the decay is in milliseconds. Tone changes the colour and not the volume — the level is held steady across its whole sweep on purpose — and there is no resonance, because resonance is the knob that would make this wild and it is here to keep it tame.
LFO start / LFO end: Which slice of the wavetable a note sweeps through.
LFO rate: How fast it sweeps, in beat divisions — so it stays in time when the tempo changes. From 8 beats per sweep down to 1/32 of one, which at 120 BPM is about 16 ms: fast enough that the sweep stops being a movement you follow and becomes part of the timbre.
LFO mode: one-shot crosses the range once, ping-pong walks back and forth, fwd-loop starts over at the beginning each time.

Amp, wavetable position and pitch are the three things that can be modulated, and each has exactly one fixed destination.

FX

Each effect is a row of its own, and the rows are the chain: the number on the left is where that effect sits, and the effect above it is heard first. The chevron at the right of a row opens it — one opens as another shuts, so the panel stays the height of a phone however many effects there are — and a shut row shows its current values instead of its knobs.

The handle — six dots on the left of a row — drags it up or down the chain, and the numbers follow. It is the only part of the row that does not scroll the page under your finger, which is deliberate: drag anywhere else and the page moves as usual. With a keyboard, tab to the handle and press the up or down arrow. Order matters — a filter before a distortion is a fuzz built on the frequencies you kept, and the other way round is a distortion smoothed afterwards.

The switch beside it takes an effect out of the chain and leaves everything it holds alone, so you can hear what it is doing without dialling it back afterwards. A switched-off row goes dim with its number struck through, and its head stays readable because that is what you press to bring it back. An effect that is on but doing nothing — a Mix at zero, a filter set to off — is not dimmed at all and says neutral instead: one turn of a knob ends that one.

Two things in the panel are not links in the chain and are drawn that way. Filter sweep is indented inside the Filter, because it is four more settings of that same effect. Duck sits under Beside the chain with no number and no handle, because it listens to another track and there is nowhere in this track's chain for it to move to.

Filter — Cutoff, Reso and Type: A filter on this track, before the track's level and, unless you have dragged it, at the top of the chain. Type picks what survives around the cutoff — low keeps what is below it, high what is above it, band only what is near it, and notch everything but what is near it — and off is a true nothing, so a track with the filter off sounds exactly as it did before there was one. Cutoff is where that corner sits, in hertz. Reso puts a peak right at the corner: at 0 the filter is plain, at the top of the knob it rings loudly enough to be an instrument in its own right, which is what makes a slow cutoff move on a bass line the thing to try first. On notch that same knob does the opposite job — there is no peak to raise, so it narrows the gap instead: turned down it takes out a broad swathe, turned up it removes one thin frequency and leaves the rest alone. The little curve underneath is not a picture of a filter, it is this filter — drawn from the same numbers doing the filtering, so it cannot tell you something other than what you hear. The loudness the filter takes away is put back for you, so the cutoff changes the colour rather than the volume; with Reso up you may notice the whole track getting a little quieter, and that is the same compensation working in the other direction.
Filter sweep — To, Delay, Length and Sweep: The cutoff can travel on its own, in bars of the song. Length is how many bars the trip takes and it is also the on switch: at 0 there is no sweep at all and the filter is exactly the standing one above. Delay is how many bars pass before it starts, so the arc can land on a chorus rather than on bar one. To is where it ends up — the Cutoff knob is where it starts, so a rise is To above Cutoff and a fall is To below it. Sweep chooses what happens at the end: once makes the trip and stays there, loop jumps back to the start and goes again, pong comes back the way it came. The travel is even to the ear rather than even in hertz, which is why the middle of a 300 → 9000 trip is around 1600 and not 4650. What you hear while the song plays is the same smooth arc the exported file has, however fast the trip. The curve drawing above does not move with the sweep; it shows where the arc starts.
Comb — Freq, Feedback and Mix: A resonance you tune in hertz, so it is heard as a pitch. The track is fed back into itself so quickly that the repeats fuse into a ringing note at Freq, 20–2000 Hz — type in the frequency of a note in your key and the track rings in tune with the song. Feedback runs 0–0.9 and decides how long the ring lasts: low is a metallic colour, high is a pitch that sings on after the note has stopped. The loudness the ringing adds is taken back out, so Feedback changes the colour rather than the volume. Mix runs 0–1 and starts at 0, which is off; at 1 you hear only the ringing. While the song loops, a ring still sounding at the end of the loop comes back in at its start; the exported file has no loop, so it gets a tail instead.
Flanger — Sweep, Depth, Feedback and Mix: A comb whose tuning moves, up and back down again, which is the jet-plane whoosh. Sweep is how long one trip takes — 1 bar, 1/2, 1/4 or 1/8 of one — so the whoosh stays locked to the song whatever the tempo. Depth, 0–5 ms, is how far the tuning travels. Feedback, 0–0.9, sharpens the whoosh into a ring, and its loudness is taken back out the way the comb's is. Mix runs 0–1 and starts at 0, which is off.
Distortion — Amount, Shape and Mix: One effect on this track, sitting before the track's level so that the fader stays a fader: turning a track down can never also make it cleaner. Amount runs 0–1 and at 0 it does nothing at all. Shape decides how the sound breaks up — soft is saturation, the one that thickens rather than damages; hard clips the peaks flat; fold turns the wave back on itself once it runs out of room, which is the silly one and the reason to try this on a bass line. Mix runs 0–1 and starts at 1, all distortion; below that the clean track is blended back in under the distorted one, which is what a mixing engineer calls parallel saturation, and at 0 the effect is off. It is the per-track answer to Drive, which does the same kind of thing to the whole song at once — reach for this when one track should be dirty and the others should not. It starts out after the filter, so filtering first and distorting second gives you a fuzz built on the frequencies you kept — drag the two past each other and you get the smoothed version instead.
Delay — Time, Feedback, Damping and Mix: Echoes of the track on a division of the beat, so they stay in time when you change the tempo. Time is the division: 1/16, 1/8T (an eighth triplet), 1/8, 1/8. (a dotted eighth) or 1/4. Feedback, 0–0.55, is how much of each echo comes back as the next one. Damping, 0–1, takes a little of the top off every time round, so the first echo is bright and each later one darker, the way tape echo behaves. Mix runs 0–1 and starts at 0, which is off. It is a crossfade rather than an amount of echo added on top, so at 1 you hear only the echoes, and a sparse part arrives one delay time late. While the song loops, the echoes still sounding at the end of the loop come back in at its start — what a DAW gives you once the stems are laid end to end and their tails overlap. The exported file has no loop, so it gets a tail instead.
Duck — Source, Depth and Recover: Another track's notes dip this one. Pick the kick as the Source on the bass line, and the bass steps aside every time the kick plays, so the two stop fighting without either being turned down. Depth, 0–1, is how far it dips — at 1 the track drops well down but keeps playing, rather than going silent. Recover, 20–1000 ms, is how long it takes to come back up. It follows the source's notes, not its sound, so it is exact and the same on every play. Recover is in milliseconds rather than beats, so after a big tempo change it may want moving. The duck is in the track's stem and in its dry stem.

While the song is playing, what you hear is the file itself. Each track's effects are rendered into that track exactly as the export renders them, so nothing in here is a quicker stand-in for what you will download. Turn an effect's knob and the track is rendered again and swapped in under a short crossfade, so a change arrives a moment after you make it rather than under your finger. Level, mute, solo, the duck and Drive are the exceptions: they act after the effects, and they move the moment you touch them. The curve under the filter's controls follows the drag itself, so you can see where you are going before you hear it.

Wavetable

The two pictures are what your recipe actually produced. The waveform strip shows all frames end to end; the heatmap below shows frame against harmonic, 60 dB of range in the inferno palette — bright means loud.

Preview table: Plays the wavetable itself rather than the song, so you can hear the morph without writing a note. This one is realtime, and it is the one place in the app that is not band-limited: drive its pitch up and it will alias.
Mode: loop, one-shot and ping-pong sweep the frame cursor continuously; step plays a fixed number of cycles per frame with no interpolation between them, which is how you hear each frame as itself.
Pitch, Start, End, Duration: The preview's own pitch in Hz, the frame range it sweeps, and how long it takes. In step mode Duration is replaced by Cycles/frame.

Recipe

This panel starts collapsed on purpose: a first screen of twelve spectral macros is exactly the tutorial this project is supposed to do without. Open it when you want a different instrument.

Generate: Builds the wavetable from the current recipe without playing anything. Play and Export re-render on their own if the recipe moved, so Generate is the explicit "show me" step — it also resets the play and LFO frame ranges to the new table.
Start wave / End wave: The two endpoints of the morph: sine, square, saw, or random — a seeded random spectrum with a natural high-end rolloff.
Seed: Every random choice in the recipe flows from this one number. Same seed, same table, always. Changing it is the cheapest way to get a different instrument out of the same settings.
Morph curve: How the table travels from start to end across the frames: linear, exponential, reverse-exponential or sigmoid. Amplitudes blend linearly; phases take the shortest circular path.
Frames: How many single-cycle waveforms the table holds. More frames, smoother morph.
Samples/frame: The resolution of one cycle. 2048 is the default and what Serum expects.
Harmonics: The ceiling of the harmonic series each frame is built from. This is the single biggest lever on render cost.
Sample rate: 44100 or 48000, for both the render and the export.
Start macros / End macros: Five shaping controls per endpoint, described under How a note becomes sound. Their defaults are true no-ops: at neutral, the macro stage changes nothing at all.
Knobs: The macros, the master drive and the track level are knobs, and they all work the same way: drag up or down anywhere on the knob — where you grab it does not matter, only how far you move. Let go and grab again to keep going, so a small screen costs you no precision. Double tap (or double click) puts a knob back to its default. With a mouse, hold Shift while dragging for fine steps; a knob you have tabbed to also takes the arrow keys.

Export

The last panel on the page, collapsed until you open it. Exactly one export is impulsive — the song, from the download arrow up in the transport — and it stays one tap away. Everything else is something you decide to do, so it may cost a scroll and a click, and in return it gets room to list every track rather than only the active one.

One row per track, plus a row for the song at the top. A button appears when it writes bytes no other button here writes, and goes dim when it has nothing to write; until you have rendered something once, the whole panel is dim.

Song — WAV: The same mixdown the transport's arrow writes, in the same place as everything else.
Song — MIDI: The notes of the whole song as a type 1 MIDI file: a tempo map, then one named channel for every track that has notes. It follows mute and solo exactly as the mixdown does, and it is always the whole song — a loop region is how you are listening, not what you have written.
MIDI: That track's notes as a type 0 MIDI file — the one you drop on a clip slot. It is that track whether it is muted or not, because you asked for this track. No sound comes with it: a MIDI file carries notes, and the wavetable that was going to play them stays here.
Stem: That track alone, over the whole song, as a PCM16 WAV — the file you drop on a track in a DAW. Its effects, its duck and its level are in it; the master stage is not, which is what lets the stems of a song be mixed back together instead of each carrying the master saturation once. It is offered only for a track you can actually hear: mute it, or solo another, and the button goes dim.
Stem dry: The same file without the track's effects, and it appears only on a track whose effects are doing something — otherwise it would be the same bytes twice. The duck and the level stay in either way: a level is one fader drag over there, and an effect burnt into a WAV is not recoverable at all.
Serum: That track's wavetable as a float32 WAV with a clm chunk, which is the layout Serum and other wavetable synths expect. It is the table, not the song — no notes, no envelopes, no effects.
PCM16: The same frames as a plain 16-bit WAV, for anything that just wants audio.
Project — ZIP: All of it in one archive: the mixdown, a stem and a MIDI file for every track that has one, and a reopen.txt holding a link that loads this song straight back into jGLAM. It contains exactly the files the buttons above offer, so a track with distortion brings both its stem and its dry stem. The wavetables are not in it and do not need to be — the link carries every recipe, so the tables are rebuilt when you open it. Unpack it and everything sits in one folder named after the song.

Manual: This page. It opens in a new tab, so your song, your playback and your undo history stay where they are.
Clear song: Starts over completely: one empty track, default sound, nothing stored.
Load showcase — 32 bars: Thirty-two bars, seven tracks, eight four-bar scenes: the one that is here to be listened to rather than edited. Every part of the synth is working somewhere in it.
Load starter — 8 bars: Eight bars of kick, snare, hat, bass and lead — a groove that already runs, with room left to turn it into something else. Start here if you want to build rather than to listen.
Load sketch — 4 bars: Four bars and four tracks, the smallest thing that makes a noise. It is also what the app opens on, so this is the only way back to it once you have a song of your own.

All four of those fire without a confirmation dialog, and all four are one Undo away. That is deliberate: a modal is un-Amiga, and by the third time it gets dismissed blindly anyway.

How a note becomes sound

Two stages, and they run at different times. The table is built when you press Generate (or implicitly, when Play notices the recipe moved). The song is rendered when you press Play.

Building the table

Spectrum construction. The start and end waves become harmonic spectra — amplitude and phase per harmonic. A builtin wave is the textbook series; random is drawn from the seed with a natural rolloff toward the high end.
Spectral macros. Five explicit controls reshape each endpoint. Spectral tilt weights the series toward the low or the high harmonics. Fundamental bias and fundamental rolloff set how much the first harmonic dominates. Even harmonic bias pulls the sound between hollow and full. Harmonic scatter randomizes amplitudes from the seed, and phase jitter does the same to phases — which does not change the spectrum at all, only the shape of the wave and therefore how it behaves under everything downstream.
Morph trajectory. The two spectra are interpolated across the frames along the morph curve.
Frame synthesis. Each frame is rendered additively — every harmonic summed as a sine at its own amplitude and phase — then DC-removed and peak-normalized. That is why this is not sampling: no waveform is drawn or recorded, each one is built out of its partials.

Rendering the song

Every note of every unmuted track becomes a voice at its written pitch, start and length.
Each voice reads a variant of its table resynthesized for its own pitch, containing exactly the harmonics that fit under half the sample rate. Nothing folds back down; nothing aliases. At 48 kHz with 64 harmonics nothing is removed at all below about 375 Hz, so bass renders exactly as it always did.
The frame LFO sweeps the read position through the table while the note sounds, and the amp envelope shapes its level. If the pitch envelope is armed, the note starts off its pitch and falls onto it.
Each track's voices are summed and taken through that track's effects, top row first, and a duck then dips the track wherever its source track plays.
The tracks are scaled by their levels and summed, then taken once through the master stage — a fixed headroom base, then Drive.
The finished buffer is measured. If it went past full scale, the status line says by how much and over how many samples.

There is no reverb anywhere in that chain, and every effect there is works on a whole track, after its voices are summed. Nothing filters a single note: everything in a note's timbre comes out of the harmonics you asked for and the way the table moves while the note is held. If a sound is not in a note, it is because the spectrum does not contain it — which is a much more direct relationship to the sound than a stack of effects, and a much less forgiving one. The noise generator is the one thing in the instrument that is not made of that spectrum, which is exactly why it had to be added rather than dialled in.

Keeping, sharing, undoing

Your song is kept for you: Every edit is written to this browser's local storage, so a reload picks up where you left off. Nothing is uploaded while you work, and there is no account — a cleared browser is a cleared jGLAM.
The link is the data: Share turns every track's recipe, notes, envelopes, LFO, level and mute — plus where in the song it was shared from — into JSON and compresses it. That compressed song is the whole link: nothing else is needed to play it back. Opening the link restores the whole song and renders each table once, without playing.
A link opens at the beginning, not at the sharer's screen: How you are looking at the roll — the two zooms, Grid and Snap — is yours: once jGLAM has seen you once, nothing you open changes it. Where you are in the song is decided by how the song arrived: a reload puts you back where you were, an Undo leaves you where you are, and a shared link starts you at bar one on the first track with the loop off. If the person who shared it was somewhere in particular, a card offers to take you there and a button leaves you where you are. Jumping is not an edit, so Undo has nothing to do with it.
Short links, and what jGLAM keeps: The song alone can run to a thousand characters of gibberish in the address bar, so Share hands it to jglam.org first and copies something like jglam.org/?s=8fk2m0qr7xzt. What gets stored is the song — the recipe, the notes, the settings — with no name attached: not yours, not the song's, not your address. If that ever fails, and it will if you are offline, Share copies the long link instead and the status line tells you which one you got. Both open the same song.
Three ways in, one precedence: A share link beats your stored session, which beats the sketch. Once you change something, the link leaves the address bar — from then on the song is yours.
Old links keep opening: The share format carries a version number with migration code behind it. Controls move between beta releases and things occasionally break; links that have already been shared are the part that does not move.
Undo: Every settled edit is a step — the note you drew, the loop you dragged, the knob you let go of — up to 50 of them, and the button appears in the status line whenever there is something behind you. Redo has no button: Ctrl+Shift+Z, or ⇧⌘Z on a Mac, steps forward again, as Ctrl+Z or ⌘Z steps back. The stack lasts for the session: a reload starts you fresh.

Getting it out

This is the half of the idea that makes the other half affordable. jGLAM is where a sketch happens; the exports are how it leaves.

The download arrow in the transport — the song: A PCM16 WAV of the mixdown, exactly as you just heard it. One tap, no menu: it is the one export nobody wants to think about.
Song — WAV, in the Export panel: The same file, reachable without scrolling back up to the transport.
Serum — the table, per track: The wavetable itself, in the layout Serum and other wavetable synths expect, with a frame-size chunk so the frame boundaries are read correctly.
PCM16 — the table, per track: The same frames as a plain WAV, for anything that just wants audio.
Stem — one track, over the whole song: Audio of a single track, the length of the song's own mixdown, so a set of them lines up at bar 1 without trimming. Summed back together they are the song again — with the master drive turned off, exactly; with it on, close, because a master saturation works on the sum and not on each file.
MIDI — the notes, per track or for the whole song: What you drew, as notes a DAW can edit. Positions survive exactly, including notes placed off the grid with Snap unlocked. A note's velocity goes out as its gain on the 1–127 scale: a note at full is 127, an eighth is 16.

One thing to expect rather than report: jGLAM calls MIDI note 60 C4 and Ableton Live calls it C3. The note numbers in the file are the note numbers you drew — the two programs simply disagree about which octave to print, and have since the 1980s.

Every one of those files is built byte by byte in your browser and handed to your download folder. None of it is fetched from a server — the only thing jGLAM ever asks a server for is a short link.

What it deliberately doesn't do

This list is the feature, not the roadmap. Each of these would make jGLAM more capable and less itself.

No mixer. No pan and no sends. A track has a level, mute and solo, a duck and its insert chain — that is the whole mixer.
No modulation matrix. Three modulators, each with one fixed destination — you can draw a curve on an effect knob, but you cannot wire anything to anything.
No arrangement. One pattern per track on one timeline — no scenes, no clips, no song structure above the bars.
No audio import. Nothing is sampled or analyzed; everything is synthesized from numbers you can see.
No import at all. MIDI goes out and does not come back in. Five minutes to a noise is the promise; opening someone else's arrangement is a different program.
No plugins, no account, no cloud. The page talks to nobody.

There is no finish line here — noise, a chain of per-track effects and a duck have landed, and more offline effects may well follow, because they are experiments in bending waveforms and that is what this project is for. Being a DAW is not on that list, and it is not going to be.