Newest first: everything that changed in Freally Unloop, in every language this site speaks.
v0.8.0S: Standalone & web
No DAW at all: drop stems, one loop or a MIDI loop into the standalone or a browser tab, get the chosen style's tempo suggested to adhere to, arrange, preview and export. The web app runs the plugin's own code, compiled to WebAssembly, and nothing you drop leaves your computer.
Added
Stems mode (standalone and web app) — a 280 px drop panel at the left of the window. Drop or choose one to eight audio files, or one MIDI file. Each file shows the part it plays, how sure the reading is and why (its name, or its sound), with your choice over it. The loop's tempo and bars show where they came from, each with a pin. Shorter files repeat in whole cycles under a longer loop. Files arrive as their bytes, in chunks; no path ever crosses the bridge.
Auto-role for files — the name first (F#m 808.wav is the bass; 33 keywords, piano, pluck, bell, arp, guitar, flute, choir and full among the new ones), then the sound: how much of it sits under 150 Hz or above 2 kHz, whether it is short hits or held, and how often it starts a new note.
Tempo and bars from the audio — Freally MIDI Master's grid fit on the files' combined onsets. A loop that could be 70 or 140 is read at the one inside the chosen model's range, and a pin overrides either. The tempo is exact by construction: a whole number of bars fills the file to the sample.
Tempo adhere — where Unloop owns time (never in a plugin, whose host owns tempo), the tempo chip suggests the model's typical tempo, or the nearest in its range when the loop is close, with Adhere, Tape and Keep. Adhere keeps the pitch: WSOLA for drums and whole loops, a phase-locked vocoder for harmonic parts. Tape lets the pitch follow, as a varispeed does. The result is exactly the loop's bars at the new tempo, to the sample, seamless at the wrap, and the same bytes every time. Past ±35 % the chip warns that the sound will change. One undo step; the MIDI song template writes the adhered tempo.
Split drums from music — one whole loop, split offline into its low band, its percussive part and its harmonic part (median-filter HPSS), so a drop-out on the drums reaches mostly the drums. In the standalone and the web app it becomes three real parts; in a plugin it is an export option. Labelled an approximation everywhere; the three parts add back to the loop within −40 dB.
The Loop Doctor — a header sheet of what is wrong with the loop itself: a click at the seam, clipping, a very low level, a tempo read an octave away or not measured at all, a capture at another tempo than the DAW's. Worst first, each with its fix (crossfade the seam, trim, pin the bars or the tempo, capture again), each one undo step.
Export presets and packages — named presets of the whole export dialog. Package writes the mix, the stems, the MIDI song template, the receipt and the arrangement sheet (text and a picture) into a folder of its own or one deterministic zip (two exports, the same bytes). Print a bar range or the selected clips' bars. The Loop extender writes the raw loop repeated to the record's length, tempo-tagged, and the dialog says how many times the loop fills the record.
The web app — the same app in a browser tab: the plugin crate built for WebAssembly without its native half (no host, window, dialogs or OS drag), its bridge in a Worker and its audio core feeding an AudioWorklet. Drop files in, arrange, adhere, preview, export: exports and saves are downloads, and a .unloop opens by being dropped or chosen. A slim bar says nothing is uploaded, a browser that cannot run it says what it lacks, and after one visit it works with the network off. Staged locally under docs/app/ by npm run build:web; not published before 1.0.0.
A .unloop or .unarr dropped on Stems mode opens as Open loop project… or Import arrangement… would.
Feature videos in the manual — ten short, silent videos that loop beside their chapters, filmed in the real app: the themes and the console's controls, motion, the interface sounds, the MIDI view, a MIDI loop, the Velocity Doctor, Stems mode, tempo adhere, the Loop Doctor and export packages. npm run showcase films them from the release standalone, on a profile of its own, with a drawn cursor.
Changed
The plugin crate has a native feature (on by default): the plugin, the standalone and every test build with it; the web app builds without it.
Loop projects (.unloop) are schema 3: they keep the loop as made plus its fix (adhere, seam crossfade, trim, pins), never the derived audio. The host project state is schema 8. Receipts are schema 2.
The standalone owns its transport. Its audio backend's clock always plays, and Unloop read it as a host: the record ran from launch, Unloop's own play and stop were locked out, and the console said Your host is playing. Now, as in the web app, nothing plays until you press play.
A dropped loop's record is made for the loop's own length. Stems mode read the bars but the plan stayed made for 8, and the export dialog said 9 times your 8-bar loop of a 2-bar one.
An export or MIDI drag that carries the MIDI song template reads the parts itself, whatever view is showing — only the MIDI view started the reading, so from the audio view the dialog said still being read for ever. A loop that gives no notes (a sung line) now says so, and the dialog asks again when a reading ends.
Every move's sine, cosine, exponent, logarithm and power is libm's, so a Print is the same samples natively and in the browser.
The Loop Doctor's chip is a pulse, with its word where the header has room; below 900 pixels the header's controls close up.
The web app ships the console's rendered hardware (its build had left it out, so every key, knob and fader drew bare) and holds it in memory before it paints, with every face of its own fonts: switching to Russian, Hindi or Vietnamese after load fetched one. Chinese, Japanese, Korean and Arabic are set in the system's own face, so nothing is fetched after load.
Fixed
A fix no longer dips the sound. Each Loop Doctor fix and each adhere rebuilt every rack part, so all but the first part restarted from silence; now each part plays on, handed its new audio. And a new loop, or an adhered one, reaches the audio after its tempo and length do, never a block before.
The Loop Doctor offers a trim once. Between pressing Trim and the trimmed loop arriving, the same finding offered twice the trim.
What a fix makes is no longer written to the capture cache in the standalone or the web app, where nothing reads it — every adhere and trim wrote a loop's worth of audio. In a DAW it still is: another instance's export reads it there.
The web app lets a finished print go after a minute unused, as the plugin does; it kept the last one for the life of the tab. A request larger than any command is refused before it is written anywhere.
A loop project auditioned in the Loop Library at another rate is resampled as the loop it is, as opening it does — no click each time it comes round. A cut auditions the same way.
An adhere past the longest loop (64 seconds) is refused in words, and a fix that cannot be made is not tried again on every poll.
The export dialog offers Split drums from music before the loop is split, a single file and its receipt download as one zip in the web app, and a receipt names the adhere that plays.
Clear in Stems mode lets go of files still being read, a project opens over a full Stems panel, and a file that could not be made is not asked for again.
Gates
clippy (wasm32) and wasm build in every CI leg; e2e web (Playwright) with the slow gates: zero requests after load (a planted fetch turns it red; it now reads the app in all 18 languages), offline after one visit, four actions from a dropped loop to the record playing, and the web parity gate's browser half.
The web parity gate — plugin/tests/web_parity.rs runs a script natively at 44.1 kHz (a loop dropped, read, arranged from a fixed seed, adhered, its MIDI and its printed WAV exported — nothing resampled) and holds the answers to e2e-web/fixtures/parity.json; e2e-web/parity.spec.ts runs the same script on the real WebAssembly module and must answer the same bytes.
v0.7.0X: MIDI
Flip the view to MIDI and drag the same arranged record out as a multi-track MIDI song. The notes come from your loop, read by Freally MIDI Master's audio-to-MIDI road (no AI anywhere in it), or from a MIDI loop you drop on the instance. Every move, fade and section lands in the file honestly, and each part's velocities are set to the right kind. 0.6.7, the look, ships inside this tag.
Added
The AUDIO/MIDI toggle — the MIDI chip in the header. Pressed, the lanes draw each clip's notes and every drag handle (the mix, a role, a section) carries a Standard MIDI File instead of a WAV. It changes the view and nothing else: no clip, section, fade or marker moves, and undo is untouched.
The MIDI song template — one Type 1 file: a conductor track with the tempo, the time signature and a marker per section, then one track per part, named by part, with drums on channel 10. Each clip's notes follow its slip, repeat and reverse. A mute, drop-out or cut takes notes out, a stutter or roll repeats them with ramped velocities, and half-time stretches them. Filters, volume, pan and sends become controllers. The same seed gives the same bytes, and the MIDI plan is the audio plan, one tiling.
Honest about what MIDI cannot say. A move with no MIDI meaning (a rewind, a reverse, lo-fi) is a marker in the file and a badge on the map. A move MIDI can only approximate (a tape stop, a pitch dive) is a pitch bend plus a marker, flagged in its tooltip. The MIDI panel counts them.
Fades in MIDI — a fade scales the velocities of the notes it covers, along the same curve the audio follows, or, by choice, writes CC11 expression and leaves the velocities alone.
The Velocity Doctor — per part: Measured, Tiered (each drum hit classed as accent, main or ghost, then placed in its band, by default 100–127 / 76–89 / 38–51), Fixed (bass and 808: 127), Flat (chords: 96, top voice +6), Contoured (melody into its band with a phrase arch, counter 12 lower) and Artist feel. The model sets the defaults; each change is one undo step. No ghost in a lane ever plays louder than a main.
The extraction panel — every part and the reason it was routed (on the drum channel, plays like a kit, the lowest voice, split by pitch…). It also states the road's limits: No counter-melody from audio — MIDI Master can write one; Sung line detected — not written as MIDI; Chords spelled plainly; a hit hidden under a louder one is lost. Parts are read on a worker, never on the DAW's editor thread.
MIDI loop input — drop a .mid on the instance (or choose one) and its notes are used for that part, split exactly as Freally MIDI Master splits them. The file is kept with the loop project, never changed on disk, and refused when it is not MIDI or is far larger than a loop.
Changed
Loop projects are schema 7: they keep the MIDI view, the MIDI loop and the velocity choices. A schema 6 project opens in the audio view with the model's velocities. A receipt now says which format was exported, and for a MIDI file, what it held (the song, a part or a section) and how its fades were written.
The contact is freallyproducts@gmail.com everywhere (the licence, the EULA, the security policy, the plugin's details a DAW shows, the crate metadata).
Security
A dropped MIDI loop is bounded: refused over 40 KB, by the page before it is sent and by the plugin before it is decoded, parsed by engine's reader, and kept only in the loop project.
v0.6.7L: The look
Unloop now looks and presses like the rest of the Freally family. Its keys, faders, knob, meters, slider and switches are Freally Flipcopy's, and so are its light and dark themes on Freally green, copied as they are and never redrawn here. Shipped inside 0.7.0; this rung has no tag of its own.
Added
Motion settings — Speed (Normal or Quick: Quick turns the title twice as fast; a popover's or panel's move stays as long as its sound) and Reduced motion (Follow the system or Reduce: Reduce lays the title flat and stills every animation).
Changed
The look is Freally Flipcopy's, copied, never redrawn. The console's faders, knob and meters, its GENERATE, REROLL and PRINT keys, and Settings' slider and switches are Flipcopy's components drawing the Freally playbook's Blender renders, in a light set and a dark set. Every other button stays a plain labeled button, and the preview's play, stop and loop are plain icon buttons. A gate holds every copied file to Flipcopy's, byte for byte.
Two themes, light and dark, on Freally green (#79d920), from the shared Freally UI kit Flipcopy uses: its grounds, glass panels, chassis and glow. The console follows the theme, and its lamps have daylight colours of their own. Every pair passes WCAG 2.1 AA in both themes. No skins (the owner, 2026-10-06).
The faders work like the rest of the family's: −96 to +6 dB, even in dB, 0.1 dB a step, the whole range over 200 pixels (Shift for a quarter of that), a double-click or Alt-click back to 0 dB, Page Up/Page Down a tenth of the travel, Home to the floor and End to the top. The cap shows what you set, and the meter beside it shows what plays.
The meters are Flipcopy's: green below −12 dBFS, yellow to −3, red above, and a clip light at 0 dBFS held until you click it.
The sounds' switch in Settings is an On/Off switch, Flipcopy's, and their level is Flipcopy's slider.
Security
The editor's pages allow inline styles (style-src 'self' 'unsafe-inline'). Flipcopy's hardware set declares each render's address in one stylesheet of the page's own, and that address depends on where the page is served, so a hash cannot pin it. Scripts are still 'self' only, and nothing else loosened.
v0.6.5U: Sounds, the title bar & Report this
Unloop now sounds and stands like the rest of the Freally family, and when it fails, it says so in a way you can report. Opening a popover or a dialog and showing the Loop Library each make the family's own short sound, exactly as long as the move; the standalone's title bar is dark in dark mode, with no title; and an error that is Unloop's own fault offers Report.
Added
Interface sounds — the Freally family's one set, soft glassy, the same files in every Freally app: a popover or dialog opening and closing (Settings and every header and console popover, the Roles & bus panel, the project menu, the export dialog, the shortcut sheet) and the Loop Library shown and hidden. Each lasts exactly as long as its move, both read from one timing table. They play through Unloop's own output — never the PC's speakers behind the DAW's back — and never into the record: not in a Print, a capture, a stem or a drag-out, not in an offline bounce, not while bypassed. On by default; Settings has their switch, their level and Quiet while playing (on). With reduced motion, a short tick plays instead.
Popovers, dialogs and the Loop Library move — they open and close over the family's moves (the Loop Library slides from its edge, the other way in a right-to-left language); with reduced motion they appear at once.
The standalone's title bar is dark in dark mode and follows the theme live, and it carries no title — the turning wordmark is the title. Inside a DAW the plugin window's title stays the DAW's.
Report this. When Unloop itself fails — a file of its own it could not write, an export or a drag it could not make, a loop it failed to read, a call from its own page it could not read, the page crashing — the error offers Report, which opens the report page in your browser with the facts filled in (where it failed, the version, the system), signed so they cannot be altered. Nothing is sent until you press Send there. A crash is offered once the next time Unloop opens. A refusal of what you asked never offers a report, and only release builds can make one.
Changed
Every shared crate from Freally MIDI Master moved to shared-v10 (from shared-v5; freally-report from shared-v7). The roster data is unchanged, but a plan's dataset version names the tag, so every plan hash changed with it — a golden change in the snapshots' header lines only.
The app id is com.freallyproducts.unloop (it was com.mikeweaver.freally-unloop): a DAW project saved with an earlier pre-release looks for the old id and will not find the plugin. Nothing has been released yet.
The road to 1.0 gains a rung: the skins and the hardware set move to v0.6.7, which copies them from Freally Flipcopy once the owner has approved them there.
v0.6.0T: The timeline
The arrangement is yours to edit, every piece of it, and every output hears exactly what you edited. Move, copy, paste, clone, resize, slip and split clips; draw fades with MIDI Master's three handles; ride clip, part and master faders; draw automation; reshape the sections; lock what you like and reroll the rest; place moves by hand — every change one undo step, undone and redone as far as you like. A loop's project now holds a shelf of arrangements you switch between on the next bar, and an arrangement travels on its own as an .unarr file.
Added
The timeline. Every clip on the map is editable: select (click, Shift, a marquee, Ctrl/Cmd+A), move (on the snap; Alt bypasses it; a lane change only between parts that may share one), delete, clone after the selection (Ctrl/Cmd+D), duplicate in place (Shift+D), copy, cut and paste at the edit cursor (an incompatible lane is offered the lanes it may go on, never changed silently), resize from either edge (the loop repeats past its length), slip (Alt-drag), split (S), reverse, rename, colour and Reset to plan — from the context menu too. A moved, slipped or reversed clip is heard from its own place in the captured loop.
Fades exactly like MIDI Master's Song Arrangement: three handles a side — length on the clip's top edge, curvature on the path — that never cross, at any clip length; the shortest clip is a 64th note.
Faders. An on-clip gain handle (−∞ to +6 dB, Shift fine, double-click back to 0 dB), the console's part faders and a master fader — on one fader law — every move heard while it is dragged and one undo step when it ends.
Automation lanes for volume, pan, width, low- and high-pass cutoff, resonance, reverb and delay sends, drive, crush, gate depth and pitch on every part, and master volume and low-pass — drawn, bent, selected and moved; shape stamps (ramps, S-curve, sine, triangle, square, saw, random steps) and copy/paste of a range; a move's own sweep or dive edited on the lane it plays. Read per sample, live and in Print alike.
Sections. Insert, delete, drag to reorder (everything in a section goes with it), resize, re-kind (its activity drawn again for the new kind), rename and lock — from the section's menu or its header.
Lock and reroll. A locked section or an edited clip is never touched by a reroll, and a reroll never moves a neighbour; What changed lists every part and move it changed, section by section.
Moves by hand. A palette of every move (the model's own first), placed, dragged, stretched and deleted on the marker strip; the move inspector edits its parameters and parts and auditions it while previewing — built exactly as the planner builds one.
Unlimited undo and redo of every change in the Song Arrangement view, held by the instance and saved with the project, from the header's Undo and Redo (each naming its step) or Ctrl/Cmd+Z, Ctrl/Cmd+Shift+Z, Ctrl+Y. Crash-safe: every change is written at once to your app-data folder (off your host's own thread), and a host that closed before saving reopens on your last change, and says so — with Keep the saved version for when the change was another copy's (an older project reopened after Save As). A duplicated track keeps an autosave of its own.
A loop the host changes re-fits the arrangement. A new loop length or meter lays your edits onto it as an import does, rather than letting them go; undo starts again from there.
Grid and hygiene. Snap to bar, beat, 1/8, 1/16, their triplets, or off; zoom with a minimap; 4/8/16-bar phrase shading; 3 ms auto-crossfades where clips meet; and, with snapping off, an edge nudged to the loop's nearest zero crossing (within 1 ms). No sequence of edits makes a click.
The arrangement shelf. One loop, many named arrangements, from the header's Arrangement menu: New, Duplicate, Rename, Delete (undoable), Switch — on the next bar line while playing, at once when stopped — and Compare, an A/B toggle between any two; four snapshots (A–D) inside each. Switching never recaptures or decodes the loop, and an arrangement switched away from and back is exactly what it was. Every shelf operation is one undo step, and the .unloop file carries the whole shelf.
.unarr arrangement files.Export arrangement… writes one arrangement without its loop; Import arrangement… lays it over the loop you have open — its sections, clips, moves and lanes found by what they are (the second hook, the drums of the verse), sections laid in whole loops scaled to the new loop's length — and lists anything that had no place.
Keyboard first. One table of shortcuts drives the app and writes the sheet — press ? in Unloop, or see the docs site. Every timeline edit works without a mouse: step through clips, move them by the snap, resize them, change their gain, hold their fade handles, split, reverse, lock, and open their menus. The timeline's keys act when the map (or nothing) has focus, never on a focused button, lane or dialog. The map is named and described for screen readers, clip by clip and handle by handle.
Changed
Project state is schema 6, and a .unloop document schema 2: edits, history, the shelf, and each arrangement's edits and snapshots. Older projects and files open as they were.
The shared Freally crates move to shared-v5 — MIDI Master's shared-v3 to shared-v5, and its nih-plug fork at df472391: the editor's page stays under its window when the window is moved (WebView2 is told the window moved and put back under it), freally-extract and nih-plug's process_mode() are available, and the roster snapshot is re-taken at the new tag (its data is unchanged).
The repository is public — MikesRuthless12/freally-unloop, All Rights Reserved; the shared crates come from the public MikesRuthless12/freally-midi-master, and the macOS release build needs no secret.
Continuous integration runs on GitHub, on Windows, Linux and macOS, for every push and pull request — every gate, clap-validator and pluginval at strictness 10 on every runner (the AU on macOS). No commit carries [skip ci] any more.
v0.5.0C: Capture, preview & print
The MVP is complete. Every instance captures one cycle of its loop and plays the record from memory; the whole arrangement previews inside Unloop while your DAW is stopped; Print renders it — mix, stems, a part or a section — as WAV, AIFF, FLAC or MP3, sample for sample what you heard live; the drag rack drops it straight onto your tracks; a receipt goes beside every file; and a loop saves as a .unloop project you can reopen, or find again in the Loop Library with the rest of your loops.
Added
Capture. After Generate, each instance records exactly one cycle of its loop — loop_bars of music from the next loop boundary, to the sample at 44.1, 48 and 96 kHz — straight from your DAW's input, never Unloop's own output. The LIVE / CAPTURED chip beside the preview keys says where it stands (waiting, capturing, captured, stale) with Recapture and Forget capture. A stop, a seek or a tempo change mid-take throws the partial take away and tries again at the next play; a loop longer than 64 seconds is refused in words. Captures are kept by their content (BLAKE3) in your app-data folder, up to 2 GB, least recently used out first; a host project saves only the hash, and one whose capture is gone asks you to play the loop once.
Loop changed — recapture? When the loop coming in is not the one captured for two cycles running (compared band by band), the chip says so. Nothing is ever replaced while it plays; recapturing is your press.
Played from memory. Once captured, an instance plays the record from its capture, locked to the host's position — no drift on a loop whose cycle is not a whole number of samples, a crossfade when the source changes, and still zero added latency. The memory moves read the capture; before there is one they read the loop's recent past, and the map says so.
Preview inside Unloop. With the host stopped, the play, pause, stop and loop keys in the master section (or the space bar) play the whole record in Unloop — every instance on the channel together, from its own capture, on the same sample inside one DAW and within a block across processes. Click the map's ruler to jump; loop a section. Press play in the host and it takes over at once — the preview pauses where the audio was and says so. Parts your host is not running while stopped (Logic's non-live tracks) and parts with nothing captured yet are named.
Moves II: reverse, half-time (tape and stretch), gate, lo-fi, reverb throw (Unloop's own reverb), delay throw (dotted eighth, ping-pong), pitch dive and rewind — each with its own timing, click and CPU tests. Half-time sections are performed now (from the capture, at full speed until there is one). Four moves at once — any of the new ones among them — cost the whole audio core ≈25–27 µs of a 128-sample block at 48 kHz: about 1 % of one core, inside the 1.5 % budget.
Print. The record rendered offline from the captures through the very code that plays it live — one stem per part, pre-fader and full-length from bar 1 so any DAW lines them up, and the mix as their sum. Live playback and the print are held equal by test for every new move and the half-time clip — bit for bit in the print's own blocks, and the memory moves within −100 dB in the other block sizes a host plays in; printing twice gives the same bytes. A three-minute, eight-stem print takes about 3 seconds, with a progress bar per file and Cancel, which leaves nothing behind.
WAV, AIFF, FLAC and MP3. WAV 16/24-bit or 32-bit float with the acid chunk at every depth, so Ableton, FL and Acid warp it to your tempo; AIFF 16/24 (it has nowhere to carry a tempo, and the dialog says so); FLAC 16/24 with a BPM tag; MP3 128–320 kbps with a TBPM tag (and a note that MP3 adds encoder delay — use WAV or FLAC for stems that must line up). The sample rate as captured or 44.1/48/88.2/96 kHz (MP3 at most 48), converted before the header says so; seeded TPDF dither when the bit depth drops, identical on every print. Every format is read back through Unloop's own decoder in its tests.
The print meter and a safety limiter. Peak (dBFS), 4×-oversampled true peak (dBTP) and integrated loudness (LUFS, ITU-R BS.1770-4) of the mix, shown when the export is done; an optional −1 dBTP limiter on the mix only, which reports how far it pulled the mix down.
The export dialog (PRINT in the master section): what — the mix, the stems, any of the parts, a section or the whole record — the format, quality, rate, dither, the limiter and receipts, and the file names it will write, listed live from your template by the code that names the files. The default template is {genre} - {mode} - {what} - {bpm} BPM - {key}; {model} is there if you want the name in it. No default file name ever carries an artist's or producer's name — a test walks every name on the roster, every mode and every export to hold it.
The drag rack. Drag the mix, the stems, one part or one section onto your tracks (WAV 24-bit by default); the files are rendered before the drag begins, so the drop lands whole.
Receipts, on by default.<name>.unloop-receipt.json beside every export and every drag: the Unloop and dataset versions, the Freally MIDI Master tag, the model, mode and seed, the plan hash, each part's capture hash, the files and what was asked — enough to make the same record again. Turning them off is a preference, never a default.
Loop projects (.unloop).Save loop project… and Open loop project… from the folder button at the start of the header: the loop held once (its parts as 24-bit FLAC) and the arrangement over it. Saving the same project twice gives the same bytes; opening it gives the same plan, to the hash, and the same capture without a play-through. A project from a newer Unloop is refused whole ("Made with a newer Unloop — update to open"); a missing or damaged part opens the rest and names the part to re-supply. Saving never overwrites a file — a taken name gets (2) — and re-saving a project keeps everything in it this instance did not make.
The Loop Library. Add your loop folders: every .unloop and every WAV, AIFF, FLAC, MP3 and MIDI file in them is listed with its bars, BPM (from the file — its acid chunk, tags or name — until detection arrives at v0.7.0), tags, arranged count, last edit and a mini waveform. Search and filter by BPM, key, tag or never arranged; click a row to hear it (↑/↓ walks, Esc stops) — inside Unloop only, never moving your DAW's transport — and Arrange it, when it is exactly one loop. Two thousand files index in a second or two, off the host's thread. It only ever reads your folders. MIDI loops are listed now and arrangeable at v0.7.0.
Recent Projects, newest first, one click to reopen; a project that has moved shows as missing with Remove from list (the row, never the file).
The loop cutter — Make a loop from a longer file…: pick a start bar and a length (1, 2, 4, 8 or 16 bars) at a tempo, hear the cut on repeat, then Arrange it as a new loop project. The cut is exact to the sample, and the source file is never changed.
The bus panel shows which instances hold a capture, and which ones their host is not running while the preview plays.
Changed
Every plan hash moved — the plans did not. A plan names the Freally MIDI Master tag its data was imported at (mm-shared-v2/…, was mm-shared-v1/…); the data is unchanged, so every name, mode and seed arranges exactly as before. The 24 golden plans changed in their header line only.
The shared Freally crates move to shared-v2 — MIDI Master's freally-encode (every byte of every exported file) and freally-drag (the native drag on Windows, macOS and Linux), carved out of MIDI Master for Unloop, beside the engine and the webview adapter at the same tag. The engine now builds on its own, so the Linux CI's full-checkout workaround is gone.
One performer for every output. The schedule and the performer moved into a crate of their own, performance, which live playback, the preview and Print all play through; render holds the Print, the encoders' front door, the decoder, the meter, the limiter and the .unloop container.
The bus file's layout moves to 2 (<letter>.v2.mmap), carrying each instance's capture hash and the channel's preview clock. An Unloop v0.4.0 and this one never share a channel across processes — update every copy together. A host project saved by v0.4.0 opens here (its state moves to schema 4, which references the capture); one saved here is refused whole by v0.4.0.
Level changes glide over 2 ms (were 5 ms), so a fast gate's edges keep their shape; every edge still passes the −60 dB click test.
Search folds letters like Ø, ß and Ł, so "mo" finds MØ.
The console's master section gains the preview keys, the source chip, PRINT and the drag rack; the tape counter says Previewing while the preview plays; the header starts with the loop project's folder button.
THIRD-PARTY-NOTICES.md now lists 437 components (was 381): the decoder (Symphonia, MPL-2.0 — a decoder, which the licence policy allows), the FLAC and MP3 encoders, the resampler and the native file dialogs among them.
Fixed
Unloop's editor keeps a browser profile of its own (%APPDATA%\Freally Unloop\webview, and its macOS and Linux equivalents), no longer the folder of Freally MIDI Master's: the two side by side could leave one editor blank ("The requested resource is in use").
Security
From the phase's code and security review:
Every file is read as hostile — a .unloop, a loop in the library, a cached capture, a preference: size-capped before it is read, every length checked against the bytes present before anything is allocated from it, and refused rather than guessed at. The decoder and the project reader never panic on a file (random-bytes and lying-length tests hold them to it), and a project's parts are decoded one at a time, only when one is used, so a small hostile file cannot make the host hold gigabytes.
Nothing touches the network. A network share (\\server\share) or a device path is refused before anything touches it; a project, a loop, a folder of loops or an export folder on a mapped network drive is refused before any file on it is opened or even looked at (a look is a connection); and an export folder that resolves to a share — a link or a junction into one — is refused before anything is written.
Nothing is overwritten and nothing is left half-written. A taken file name gets (2); files are written beside and moved into place, and a failed or cancelled export takes back what it wrote. File names are plain names on every system (no device names, no separators).
A host that unloads Unloop while one of its threads still runs — an open file dialog, an export in its folder picker — does not crash on Windows: each such thread holds the plugin until its last instruction.
Known limitations
The v0.5.0 host checks — capture, preview, print, formats and drag-out in FL Studio, Ableton Live and Reaper — are written (Live-To-Do.md § 4) and not yet worked by hand; drag-out on macOS and Linux is written but has not been dropped into a real DAW.
The drag shows no picture of what you are dragging yet.
A reverb or delay throw on the last bar is cut at the record's last bar line; the print does not ring on past it.
Part faders are at unity in the mix until the console's faders arrive (v0.6.0); a loop project holds one arrangement until the shelf does.
A loop's key is not known until detection arrives (v0.7.0), so the default file names leave {key} out until then.
On a second monitor at another display scale, the editor sizes itself from the primary display.
On macOS nothing yet holds the plugin while a dialog or an export runs (SECURITY.md, Known limitations).
v0.5.0 ships for Windows and Linux only; no macOS build (AU, CLAP, VST3 or standalone) is made for it.
v0.4.0R: Roles & the Conductor
Put Unloop on each part's track and they perform one record together. The first instance conducts; every other follows its plan to the sample and plays only its own part's moves — the drums drop out on the drum bus, the bass on the bass track — while the console shows a strip for every instance. The editor was redesigned along the way.
Added
Roles. Each instance takes a role — the whole loop, the drums (or one piece of the kit), bass, melody, counter-melody, chords, vocal, FX or the producer tag — from its strip or from the Roles & bus panel, including another instance's role from any window. Two of one kind are numbered ("Melody 2") and share a lane. A part the plan writes for a role nobody took is marked on the map as performed nowhere.
The Conductor. The first instance on a channel conducts: it makes the plan, and every other instance receives its inputs and hash — never audio — rebuilds the same plan and reports back. A plan changed in any window is sent to the Conductor and reaches everyone. When the Conductor goes, the next instance takes the baton within a second and carries the record on.
Sample-aligned. Every instance places every move edge on the same sample, whatever block size its track runs at; a kit move played on a drum bus is split across that bus's bands as the one-instance record would play it.
The bus lamp and the Roles & bus panel. Green: the instances share this DAW's memory. Amber: the host keeps each plugin in a process of its own (Bitwig's sandbox, Reaper's bridging, FL's bridging, macOS's AU host), and the instances meet through a small owner-only file instead — said, not hidden. Red: an instance is not playing the Conductor's plan, with Re-send plan. Four channels, A–D, keep two projects in one DAW apart; a channel already playing another project's plan says so and offers the next one, or following it.
Console v2: a strip per instance, in role order, with its own lamps, filter knob, VU and fader bound to what that instance's audio thread applied; this instance's strip outlined, the Conductor's baton lit.
Changed
A new look. A darker, calmer editor: one height, edge and fill for every header control, a search field with its icon, a drawn mode picker, the clock badge tinted rather than outlined, the empty map drawn as the ghost of a timeline, and a console of three modules — the bus, a sunken rack of strips with name plates, and the master section with a full-width Generate key.
Dark by default. The editor opens dark whatever the operating system's setting; System and Light are still in the settings, and a theme you pick is remembered.
Everything fits, in every language. No label runs out of its box — a long role name wraps on its plate, a long section name on the map is cut with an ellipsis rather than squeezed — and the editor never scrolls sideways, down to windows narrower than any host should give it (a host at 150 % display scaling gave it 930 pixels). The map's ruler spaces its numbers by their measured width, lanes squeeze further on a short map so a whole session still shows, and the lane names get the room they need.
The name, once. Every format reports exactly "Freally Unloop", and nothing beside it repeats it, so a host's title bar never says it twice.
Fixed
A host could crash closing an Unloop it had only just opened — a quick plugin scan, a validator, a project closed while it was still loading. The plugin framework's background worker, shared by every instance, stopped for good when it met work left by an instance already gone, and the next instance closed brought the host down. Unloop no longer gives it any work: each instance does its own on a thread it owns.
v0.3.0M: The magic moment
One Unloop on a looping beat now performs the whole record, live: pick an artist, a producer or a genre, press Generate, press play in your DAW, and your loop becomes an arranged song in time with the host — parts dropping out and coming back, filter sweeps, stutter builds, tape stops — with no clicks and no added latency, while the map and the console move with it.
Added
The live performance (One-Loop mode). One instance splits your loop into three bands — low (below 120 Hz), mid and high (above 4 kHz), a Linkwitz–Riley split that sums back flat — and plays the plan over them: each band comes in and out where the record says, and moves written for the whole loop act on all of it. Nothing about your loop file changes.
The first moves you can hear: mute, unmute, drop-out and cut; the filter sweep (low- or high-pass, the cutoff exact at every tick, bowed by the plan's curve); the stutter build (the beat before, retriggered faster and faster, rising); and the tape stop (the loop slowing to a halt on the boundary). Every edge is an eased ramp (5 ms), held to a click test at −60 dB below the music. The rest of the vocabulary is on the map, marked with the version it arrives in.
In time with the host, whichever way it plays. The song clock lays the record over your timeline from a bar you choose; the loop clock counts the loop going round — FL Studio's pattern mode, a loop brace, Ableton's session view — so 200 loops are exactly 200 loops. Auto picks one per play and says why on the clock badge. A tempo change keeps every move on its bar.
The host owns the tempo. The tempo chip shows the DAW's BPM and whether it suits the name you chose — half and double time counted, the ratio named — and, when it does not, the typical tempo and the nearest one in range to copy and set yourself. Unloop never changes your DAW's tempo.
Search over all 2,413 names, forgiving typos as Freally MIDI Master's search does ("metro bumin" finds Metro Boomin), each row saying what it is and how much of it is its own; recent picks first; "Did you mean" when nothing matches. The model card before any press, with a preview of a mode's form on the empty map. The mode picker (with Any) and the seed chip — copy it, or paste one to get that record again.
The Arrangement Map: sections, the three band lanes with each clip's fades drawn as the audio shapes them, a glyph for every move, the energy curve, a bar ruler with minutes and seconds, and the host's playhead; a move flares on its lanes as it plays. It builds in when a record arrives (a key or a click skips it; at once under reduced motion).
The console: a channel strip whose lamps, fader and filter knob show what the audio thread actually applied, a VU meter with real ballistics, and the master section — Generate, Reroll, the tape counter and the seed. When nothing tells Unloop how long your loop is, it asks once (2, 4, 8 or 16 bars) and never blocks Generate.
Projects remember. The name, mode, seed, loop length and session are saved in your DAW project; reopening it makes the same record again — the same plan, to the hash — and a loop length or time signature that changes (your answer, your DAW's loop brace) makes the plan again for it.
Changed
Every model, genre and mode name is checked against the bundled Noto fonts, as the translations already were, so no name the roster shows can fall back to a system font or a missing-glyph box.
Bypass eases the performance and the Output trim out together, then passes your audio untouched; the meters read what actually leaves the plugin, after the trim.
v0.2.0P: The Planner
Any of the 2,413 names now becomes a deterministic arrangement plan. Nothing plays it yet — the first live performance is v0.3.0 — but every decision a record needs is made here, on the grid, before a sample is played.
Added
The planner. A name, a mode, the session and a seed become a whole record: the song form, each section's length on the 4/8/16-bar phrase grid, which parts play in each section and how (hats only, filtered, faded, half time), every move placed to the tick — drop-outs, cuts, stutter builds, rolls, sweeps, tape stops, beat switches, transition FX, ear candy, the producer's tag — and an energy curve bar by bar. The same inputs give the same plan, byte for byte, sealed by a BLAKE3 plan hash. It plans a three-minute record in under a millisecond.
Every genre is arranged more than one way. Modes — radio cut, mixtape cut, club/DJ cut, switch-up, minimal, stripped, extended, and genre-specific ones (classic, posse cut and beat tape for boom bap; slow jam and interlude for 2000s R&B; the vocal cut for liquid drum & bass). Any picks one by its weight.
The first 12 genre models, authored from the arrangement research: trap, dark trap, plugg, pluggnb, rage, UK drill, NY drill, boom bap, 2000s R&B, 2020s pop, country-pop and liquid drum & bass — 39 modes — plus the default every other name stands on.
The whole roster, imported. 2,413 names — 1,507 artists, 833 producers, 73 genres — from Freally MIDI Master's dataset at the pinned release, with their aliases, eras, genres, inheritance, tempo and song forms. The import is reproducible to the byte, and every field it does not read is excused in words.
An honest badge on every name.Flagship (its own model), standard (performs its own song forms or section lengths — 1,157 names) or inherited (its genre's — 1,244 names), derived from what the planner actually used.
Reroll one thing. A plan can redraw just its ear candy, or one section's parts, and everything else stays exactly as it was.
One-Loop readiness. Every move says what a single instance splitting one loop into three bands will do with it, and when a band has to stand in for a part it cannot isolate, the plan says so.
The model card: modes, forms, section lengths, signature moves, typical energy, tempo, inheritance and provenance — computed from what the planner performs, with the disclaimer.
unloopc, the dataset compiler — validate, stats, coverage, distinct, card, plan, import-roster, schema — and npm run dataset:*. The model schema and the vocabulary file are generated from the Rust types.
Gates: the roster import, the schema and every model (ci:local and ci:linux); every authored key read by the planner — each proved to change a plan when it changes; every authored string parsed by its vocabulary; two or more distinct modes per genre; 24 golden plans; the whole roster planned twice and compared; a planning budget of 50 ms at the 95th percentile; and every unsafe site in the plugin held to the documented list. Every gate was watched failing before it was trusted.
Changed
The note under Generate now says it arrives in the next build — the planner it waited for is here, and the button is wired in v0.3.0 — in all 18 languages.
Fixed
The standalone on a scaled display (Windows). The page sat offset inside the window, cut off at the right and bottom, and slid behind the frame while the window was dragged: the process was DPI-unaware, so Windows stretched the window while the web view drew at true pixels. The standalone now declares per-monitor DPI awareness before any window exists.
The standalone opens at the plugin's size. It passes the display's scale to nih-plug as --dpi-scale (an explicit --dpi-scale still wins), so it opens as big as the same editor does in a host.
v0.1.0F: Foundation
The empty product every later rung builds on: it loads, passes audio through untouched, opens its editor, and every quality gate runs.
Added
The plugin, in every format from one binary. A nih-plug CLAP plugin with VST3 and AUv2 entry points projected by clap-wrapper (licence-clean: no GPL VST3 bindings), plus the standalone application. Stereo or mono, pass-through, zero latency, a versioned saved state that refuses anything it cannot read rather than crashing the host, a host Bypass switch and an Output trim (−24 to +6 dB, smoothed).
The editor shell. The React editor in the shared Freally webview adapter, served from inside the binary under a strict Content Security Policy, with a typed bridge to the plugin (request/response plus polled events) whose TypeScript types are generated from the Rust ones.
The Freally title bar. The product name in 3D, turning backwards on its Y axis, holding, and turning round again — as in Freally MIDI Master and Freally Oscillate, set larger so the turn is easier to see; still under reduced motion.
The licence agreement (EULA.md) and its gate: Unloop asks you to accept it on first open and stays inert until you do. An inert plugin passes your audio through untouched — nothing a host or a saved project sets, the Output trim included, changes it before you agree. Accepting or declining in one instance reaches every open instance at once, and a decline that could not be saved says so rather than letting the next session open as if you had agreed.
THIRD-PARTY-NOTICES.md, generated from what actually ships — every crate in the plugin and the standalone on every OS, the editor's packages and the fonts, with their licences and copyright holders — and carried in every release archive with the fonts' licence (OFL-Noto.txt).
Design tokens and themes — dark, light and system — with WCAG 2.1 AA contrast checked in both; the Noto fonts vendored for all 18 languages.
18 languages in the editor, with a gate that keeps every catalog in step.
Diagnostic tracing (UNLOOP_TRACE=all, written to a log file) for problems that only happen inside a host.
Icons derived from the single icon master for Windows, macOS, Linux and the docs site.
Quality gates, in npm run ci:local (Windows) and npm run ci:linux (Docker Desktop): formatting, lint, type checks, clippy with std::net banned, unit and Playwright tests, an allocation-counting audio-thread test, no-AI/no-network/no-telemetry dependency gate, licence and advisory policy, a generated-notices gate, shared-code and bindings-drift gates, a no-downloads-before-1.0 gate for the docs site, and clap-validator and pluginval (strictness 10). Every gate was watched failing before it was trusted.
Release tooling: npm run release:bundle and a tag-only release workflow that holds no write token or private-repository token while it runs third-party build code, and checks each archive really is a zip or gzip before publishing it.
The docs-site skeleton with the public version ladder.
Security
From the phase's code and security review:
The editor's bridge answers only the editor's own JSON POST: a page that is not Unloop's — a link or file dropped on the window — can neither call it nor read its answers, and a drop no longer navigates the editor at all.
The release plugin opens no DevTools debugging port (Freally MIDI Master's test hook, now behind a feature Unloop builds without), and the bundle check refuses a binary that could, or one not built from the pinned sources.
A diagnostic trace can no longer take the host down if its console is gone.
Fixed
Linux: the editor could not talk to the plugin. The webview delivered every bridge request with an empty body, so the licence agreement could never be accepted. Request bodies now arrive (WebKitGTK 2.40 or later).
The standalone no longer refuses to start when given -p <period>.
Linux: a host that scans plugins by loading and unloading them no longer crashes a few seconds later. The editor's WebKitGTK brings JavaScriptCore threads with it; the plugin library now stays loaded until the host exits (clap-validator's scan tests found it).
Linux: closing the editor quickly no longer ends the host — two fixes in the shared Freally webview adapter (an X error trap on its GTK thread, and a close that waits for the web view to be gone). pluginval at strictness 10 now passes on Linux, editor tests included.
Fixed upstream (in the shared nih-plug fork, consumed through Freally MIDI Master's shared-v1)
A CLAP host is now told its parameter values changed after a project loads (clap-validator state-reproducibility-*).
Opening or closing the editor no longer holds a lock that the editor's own start-up could re-enter — a deadlock of the host's main thread (pluginval Editor Automation).
rtrb moved to 0.3.5, closing RUSTSEC-2026-0274 (a use-after-free) at the source rather than ignoring it.
Known limitations
Hosts: loading in FL Studio, Ableton Live and Reaper is proven by hand, not by CI, and those rows of the host matrix are still to be worked at this rung; the validators prove the plugin well-formed, and the standalone has been run.
AU is built and bundled but unproven: no Mac has loaded it yet. The Linux editor is built and validated in a container but not yet used in a real Linux session.
The shared webview adapter keeps its browser data in a folder named after Freally MIDI Master until the adapter learns to name its own (roadmap).