Changelog

VERSION HISTORY

What shipped in each version, and why. Newest first.

4.0

MAJOR RELEASE

Now on iPad.

Three things, and the first one is the release: the app is on iPad, laid out for the tablet rather than stretched onto it.

On iPad. The rack becomes a grid of cards you page through, three across on a 13 inch and three on an 11 inch as well. Menus come in from the right and leave the instrument where it is, so nothing you are looking at jumps while you reach for a setting. Open a module and it steps into the middle of the screen with its settings beside it, so you are looking at the thing you are changing. The library, the scenes and the export are rooms of their own, and renaming happens in front of you. A screen too short for the grid is laid out as a phone instead. Landscape, for a stand and two hands. Everything the phone does, in the same build: one app, both devices, one purchase.

Your projects, on both. Turn iCloud on and your work follows you. Start a track on the phone in the morning and open it on the tablet in the evening, with the presets, the samples and the covers already there. Four folders travel, Projects, Presets, Samples and Covers, in a Sequentia folder in iCloud Drive that is visible in Files, so a project is a file you can copy, send and keep like any other. There is no server of ours and no account of ours in the middle.

It is off until you switch it on, and the first time you do, with work already on both sides, the app asks what should happen to the two libraries instead of deciding for you: merge them, use the cloud, or replace the cloud. Nothing is deleted without being asked, nothing moves until you answer, and the answer that deletes sits behind a second question that names the count.

The whole project out in one step. One door for the project instead of one module at a time. Take the rack out as MIDI, or every scene as its own folder, named so the session opens in your DAW already making sense. If there are samples in the rack, one tick brings the audio along, as you hear it or as the original files.

Fixed. A sample dropped into a rack that was already playing now starts on the beat instead of a sixteenth late. A modulation lane keeps the name of what it is aimed at when you close the project and open it again.

Free and Pro. Sequentia is free, and so is the built in sound, Live Performer and CC Control. Sequentia Pro adds pattern slots, scenes, several racks, every drum style, your own libraries, unlimited projects and MIDI export.

3.1

FEATURE RELEASE

Balls, patches and a rack that keeps its own time.

A new module where physics writes the notes, twenty eight sounds, scenes that set up your synths before the first note, and a tempo and key per rack.

Bounce, a new module. Balls travel a box, and every wall they touch plays a note in your key. It looks like chaos and runs on the grid, so it grooves. Set how many are flying and how fast. Hold a whole field as a pattern slot, save the ones worth keeping as presets, and let it follow your chords. Like Rain, it never repeats itself, so the export asks for a length and writes that many unique bars rather than one loop.

Twenty eight new sounds. They land where a rack usually thins out: eight pads, six keys, six basses, four modular voices, a lead, a bowed string and two more acid patches. Every one is loudness matched to the rest, so a new sound changes the character and never the volume. The app now holds 174.

Scenes set up your synths. A scene can send a program change the moment it starts, so the right patch is already waiting for the first note. It can send CC as well, picked straight from your instrument’s own control map, and CC can fire again as the scene leaves, to put the filter back where it was. A message aimed at a machine that is not connected is not sent, and the row says so, rather than landing on whatever else happens to be plugged in.

Every rack keeps its own tempo and key. A rack is a section now, not just a set of parts. Give the breakdown its own tempo, put the last one in another key, and switching racks live carries both across on the bar line. A new rack starts from the one you were standing on, so nothing changes until you want it to.

The sampler says what it does. Stretch fits your sample to the tempo, and Repeat plays a trimmed piece at its own speed with the tile showing the repeat.

The hardware library nearly doubled. A hundred and thirty two instruments from twenty two makers now load their real control map, each one read out of its own manual rather than guessed at. The chart also walks you through getting a controller talking to the app, step by step.

Fixed. Saved projects show up again after updating. Nothing was ever lost, the shelf just would not draw. And a shelf that cannot be read now comes back on its own instead of being saved over empty. A crash that could happen while one rack played and you looked at another. Custom kit samples no longer click, and a long hit like a ride keeps ringing when the next one lands. Stabs patterns open in the editor exactly as they sound. And, on the last day before submission, chords that died at a transition when two parts happened to hold the same note.

3.0

MAJOR RELEASE

Play the arrangement.

Until now the app made a rack that looped. This release gives you the rest of the track: slots to keep the patterns you like, scenes to put sections in order, and racks you swap live. Everything still happens while the music runs.

Pattern slots on every module. Roll a pattern you like and keep it. Roll another. Every module holds its own slots, and you switch between them on the bar, the way you would fire clips. A slot gives back exactly what you put in it, note for note. Hold a slot to move it in the row. Leave the strip to advance on its own and the module plays through its slots while you work somewhere else.

Scenes. A scene is a section of your track, saved: what every module is playing, right now. Put the scenes in order and the timeline plays your arrangement. Tap one and the set goes there, even mid flight. The editor is a table, so you see every module against every section at once. The last bar of a scene can be a fill, and you decide what happens at the end of the list: loop, stop, or hand over to the next rack. Three ways to move: in order, by hand, or at random.

Several racks in one project. A rack is a whole set of modules. A project holds up to eight of them. Change the rack live and it lands where you asked: instantly, on the next bar, or on the next two, four, eight or sixteen. Ask for a fill and the drums announce the change before it happens. While one rack is playing you can open the next one and build it. The music does not stop, and nothing you touch there is heard until you take it.

Your own samples in Drums. Load your WAV one shots onto the eight lanes and the kit is yours. Each lane gets tune, decay, tone and reverb, live while the kit plays. Point a lane at a folder and it becomes a pool: every hit pulls a different file out of it. Imports are levelled on the way in, kits you build are saved to your own shelf, and a kit can leave the app the way it sounds.

Your controller turns the app. CC coming in now moves Sequentia’s own controls. Random, Mutate and its depth, mutes, note length, octave, single drum lanes, fills and the transport are all reachable. The CC channel picks the rack slot rather than the module’s own output channel, so one controller reaches the whole rack. Inside the app there is a searchable chart of every CC it answers, next to the switch that turns it on, and a line that shows the last message that arrived.

Going out, the hardware library passed sixty machines, from twelve makers, every map still read out of the machine’s own manual rather than guessed at.

Vinyl. A record that turns while the rack plays, with the light and the grooves of a real one. It makes no notes. It is there because a rack of numbers had nothing in it to look at.

Sampler. Play your own audio from the rack. Load a sample, place it in key and in time, and it runs with everything else, on the same tempo as the rest of the modules.

The Add menu sorts the modules into four families, so the list answers one question: do you write the notes, does the module write them, or does it work on the rest of the rack.

Projects that keep themselves. The library is a shelf of covers now, and every project has a page of its own: a name, a cover you can shoot yourself, and a play button that opens straight into the track. A project saves itself. Undo goes back a hundred steps, survives closing the app, and every step in the history says when it happened.

Seven tracks in the box. Night Shift, First Light, Redline, Slow Motion, Voltage, Invaders, and Live Jam, which runs fifteen minutes in four movements. Each one is a finished project with its own sleeve. Open one, take it apart, keep what you like.

Sound. Fourteen drum kits, drawn from scratch as separate instruments rather than shades of one. Every hat has its own metal, the third percussion lane finally speaks, and Roll hands you a kit nobody has heard before. The built in synth grew a new voice: unison, FM, noise, drift, and velocity that opens the filter. Slides glide and accents land on it. The reverb and the delay were rebuilt so you can hear what they do. The mixer gained one fader for the whole drum kit.

The app itself. Eleven themes, three of them not built on black. One type face and one scale across every screen, with nothing left too small to read. Every hold gesture opens the same menu, the icons speak one language, and there is not a single system alert left in the app. The intro was rebuilt and you can watch it again whenever you like. About now tells where Sequentia came from, in the words of the person who made it.

Fixed. The last chord of a progression cut off at the loop instead of ringing. Chords disappeared after a key change. Random answered with silence. The acid drive crackled. Scrolling broke on iOS 26. Typing a name could stall the app. The drum playhead drifted behind the audio. A loaded project could arrive silent while Play said it was running.

2.1

AUGUST 2026

Three new modules. All three are free.

CC Control: your synth’s own knobs, on the phone. Pick your machine from the built-in library and its real control map loads, ready to turn. No MIDI learn, no hunting CC numbers on a forum. Every map was read out of the manufacturer’s own manual and then checked a second time against it, row by row.

51 machines at launch, 3,487 individual controls, across Elektron, Moog, Arturia, Waldorf, Korg, Sequential, Novation, Erica Synths, UDO, Torso and Gamechanger.

Arm the red R, turn a knob while the pattern is playing, and that movement becomes a loop, locked to the bar along with everything else. Your hand always outranks the loop, so the moment you touch a knob the recording steps aside and gives it back when you let go. Every control picks its own MIDI channel, so a single module can address a whole multitimbral groovebox.

Live Performer: one pad that plays the whole rack. Move your finger and every module answers at once. More density, new variations, a fill, a break, a return home. Two axes, material and motion, and the whole rack responds together instead of you editing one part at a time.

Turn on RIDE and it plays itself, walking its own path through the performance while you do something else. BREAK is a momentary button: the drop lasts exactly as long as you hold it.

Euclid: three rings that drift apart and land together. Each ring carries its own length, its own number of hits, its own rotation, and its own note in the project key. A 12-step ring running against a 16-step ring separates and comes back bars later.

The rings can follow a Chords module, taking its root, third and fifth. Each one can address its own MIDI channel, so three rings can be three different synths.

Bigger libraries. Chords ships a library of 417 authored progressions, in your project key. Piano gained 240 authored techno phrases, with new choices for how a melody you drew follows project key changes. Changing key and changing back no longer damages what you wrote.

Drums grew Hip Hop from 48 to 98 grooves and added a Glitch style, for 1,112 grooves across 19 styles, each with the swing that genre actually has. Acid’s pattern bank went from 62 lines to 268. Bass gained a 16th genre, Groovy.

The menu was rebuilt. Projects, help, settings and the subscription each have their own place instead of one long list. Undo and redo now cover the whole rack, and a shake undoes the last step. A knob drag counts as one step, not fifty.

The Stabs plate was rebuilt to read like the Bass plate: round dots, the whole loop visible at once, and a column lighting several rows at a time because a stab is a chord. It no longer pages itself bar by bar while you watch.

Fixed. A module could display one sound and play another. The Live Performer’s ride would not switch back to manual. Typing a name could stall the app. Menus could be clipped at the bottom of the screen. Euclid’s Wander control moved notes so little that it read as broken.

2.0

JULY 2026

The app makes sound on its own.

Built-in sound engine. 87 sounds: 12 acid voices on a real 303-style emulation, 67 polyphonic presets and 8 drum kits. Free, not behind the paywall.

Sound picker in every module. Pick a family, pick a preset, and it switches live while the pattern plays so you choose by ear. Every module opens on a sound that suits it.

New module: Stabs. Chord hits from skank to rave. 12 styles plus Random, with a preset library and a chord-slab visual that shows every voice at its own pitch.

Drums grew to 984 grooves across 18 genres. Techno, house, trance, psy, disco, dub, synthwave, pop, rock, lo-fi, funk, hip hop, reggaeton, R&B, UK garage and trip-hop. Each genre carries its own swing.

Piano writes in a genre. Pick the genre and the phrasing follows it.

Acid slides actually glide. They never did. The app wrote slides and the gates went legato, but the pitch never moved, on hardware or in the export. Now a slide bends pitch on your 303-style gear, in the exported MIDI and in the built-in sound.

Background playback. The pattern keeps running when you leave the app, with controls on the Lock Screen and in the Dynamic Island.

Better starting points. Every styled module lands on something usable the moment you add it, and Arp follows a Chords module by default.

Fixes. Bass Mutate did nothing on 8 of its 15 styles and now works on all 15. Rain drops trigger exactly the note you see hit. Onboarding and the in-app Manual were rewritten around the built-in sound.

1.0.3

JULY 2026

The Bass module.

New module: Bass. A generative bassline that speaks in genres. 15 styles, from house, trance and disco through techno, acid and psy to funk, dub, DnB, upright and EBM. It writes the line in the idiom of the style you pick, from a one-note groove to a full melody.

Range, Humanize and Follow Chords. Set how far the line roams from the root, loosen the timing so it breathes, and lock it to a Chords module.

Preset library. Save a bassline you like and recall it in any key.

1.0.2

JULY 2026

Rain, the Manual, and Pro.

New module: Rain. A generative texture of note drops, drizzle to downpour, always in key. It never loops: every bar falls differently.

Generative export. Rain exports as many unique bars as you ask for rather than one repeated loop, so what you bounce is what you heard.

In-app Manual. A page per module in Settings, with every control described.

Sequentia Pro. Drum styles, pattern and preset libraries, unlimited projects, send to DAW and MIDI export.

DEV LOG · 3.1 AND 4.0

What the tablet and the cloud cost

Notes from building them. Mostly about the things that were wrong.

The shelf that would not draw

After an update, people opened the app and their projects were gone. Nothing had been lost. Reading the library was all or nothing: one field the parser did not recognise and the whole file was thrown away, so the shelf drew empty. Worse, an empty shelf is a state the app is happy to save.

Reading is partial now. A library reads as far as it reads and keeps what it could not parse instead of discarding it, so an unfamiliar field costs you that field and not the shelf. And a shelf that cannot be read recovers itself rather than being written over.

The lesson is about the pairing rather than the parser: strict reading and automatic saving must never be neighbours. One of them has to give, and it should be the reader.

A start that reported success

iOS can stop the audio session under you, for a call or another app. The app could not stand back up afterwards, and the reason it looked fine is that starting returned success whether or not anything had started.

The session can be restarted now, and a start that did nothing says so. There is a test that fails if it lies, which is the part worth keeping: a function that always answers yes is not a function, it is a decoration.

A wall, not a ratchet

Sequentia does not write with long dashes. That was a rule kept by hand, which means it was a rule kept until somebody was tired.

It is a check in the build now: no long dash can reach a user through a piece of text in the app. A convention that only lives in review is a convention with a slow leak. Either the build enforces it or it is a preference.

The gate that read 895 per cent

Bounce came out of the Lab with a tile that proudly displayed 895 per cent. Nothing was broken in the physics. Two halves of the module were using the same word for two different numbers, and the label was reading one of them through the other’s scale.

A second thing came out of the same pass. The arena was quietly correcting about a quarter of its own jitter, which is why the balls looked like they were cheating: they arrived a little too neatly on the grid.

Nine behaviours that had only ever been described in comments were turned into code with tests behind them. A promotion out of the Lab is mostly this: everything the module was assumed to do has to become something it is measured doing.

Projects became files

Everything you had made lived in one settings blob. That is convenient until you want it on two devices, because a blob cannot travel and a file can.

Projects and presets are files now, one for each, and that is the ground iCloud stands on. The old blob is still written on every save as a way back, and it is never deleted; it simply stops being read once the files check out. A migration you cannot reverse is a migration you have to be right about the first time, and nobody is.

Five passes and one question

Sync is the first feature in this app that can destroy work rather than annoy you. So it was traced against the source five times: sixteen scenarios, then the repairs reviewed, then traced again, then the repairs of the repairs reviewed.

The fifth pass asked a question none of the first four had asked: whose bytes are these. It found a save path where the phone writing one project could land on the tablet’s edit of a different one. Four passes of asking whether the logic was right had missed it, because the logic was right about the project it was thinking about.

An earlier version had also adopted the cloud container silently on update, which showed at least one person an empty shelf. Sync is opt in now, the first enable asks what should happen to the two libraries, and the answer that deletes sits behind a second question that names the count.

Four hundred points that were a drawing

The tablet layout was designed for weeks against a card width of four hundred points, treated as a floor nobody questioned. It turned out to be the width of a drawing, not a requirement. Once that went, three cards fitted across the small tablet as well as the large one.

The tablet also got one lattice for the whole screen, so a card, a section and a row all measure the same way instead of each carrying its own arithmetic. Then a seam audit went across the layer: thirty nine places read the same geometry, two disagreed with the rest, and both were corrected.

The paywall was deliberately left on the phone layout. It works, and redesigning it in the same release would have mixed its bugs into the two riskiest surfaces this app has shipped.

1.0

JUNE 2026

First release.

A generative MIDI sequencer that streams to hardware over USB-C, Bluetooth MIDI and Wi-Fi.

Modules on one shared tempo, key and transport: Acid, Drums, Chords, Arp, Mod, Mixer and Piano.

Local and deterministic. The same seed gives the same pattern, every time, with no internet and no cloud.

DEV LOG · 2.1

What 2.1 actually cost

Notes from building it. Mostly about the things that were wrong.

A knob that did nothing

Euclid has a control called Wander: how far each ring strays from its note, up and down the key. A user reported that it did not seem to work.

It was wired correctly and it did move notes, which is the annoying kind of bug. So we replicated the algorithm outside the app and ran it over 4,000 random seeds to see what it actually produced. Two things came out.

The knob’s value was not part of the random seed. That meant every position of the knob read the same stream of random numbers and the knob only shifted the thresholds those numbers were compared against. With only a handful of decisions per loop, most of those shifts flipped nothing at all: moving the knob from 50% to 77% produced bit-identical notes in 30% of projects. The control was, a third of the time, literally inert.

Worse, the walk only took a step when a ring played a hit. A four-hit ring therefore got three decisions per loop, and it restarted from home on every pass. A random walk that is pulled back toward home cannot travel anywhere in three steps. Measured: the average stray at maximum wander was two thirds of one scale degree, against the algorithm’s own limit of five.

The fix was structural in both halves. The walk now advances on every step of the ring and the hits sample it, and the knob is folded into the seed. Dead knob positions went from 30% to zero, and the peak finally reaches the range the design always allowed.

The general lesson is worth writing down: if a knob shapes a seeded, repeatable figure, the knob belongs inside the seed. Otherwise it can only move thresholds against a fixed stream, and with few decisions per pass it will read as a dead control.

Solo was gagging the controllers

Late in the release we removed the Solo button from controller modules. Solo means “hear only this”, and a controller makes no sound of its own, so soloing one could only silence everything else for nothing.

That was right, and it created a trap. The rules that decide what solo silences still treated controllers like any other module. Since a controller could no longer be soloed, soloing anything else silenced CC Control and every Mod LFO completely, with no indication of why and no way back except releasing the solo. You would solo a part to work on it and your filter sweeps would quietly stop.

The cause was not the rule, it was that the rule existed in seven different places, each spelling out “is it one of these six module types” by hand. One copy got updated and the others did not. Two of them had already drifted apart on which types they listed.

There is now one predicate and every site asks it. Then we ran an adversarial review pass over that fix, and it found a seventh copy we had missed: the mixer’s Mod strip, which derived the same rule from the solo set without naming a single type, and so survived every search we did by type name. It would have shown the LFO as silenced while it kept transmitting.

The lesson: a rule written as a list of types will be written more than once and the copies will drift. Name the concept.

The stop that ate your sound

A user reported a module showing “Kalimba” in its label while an acid bass came out of it.

Patches are not set directly on the audio engine, they are queued, and the queue is only drained by the render callback. Stopping the preview queued an “all off” message and then stopped the graph on the very next line, so that message sat at the head of the queue while the engine was down. Every patch chosen in the meantime queued up behind it. On the next start the “all off” fired and cleared the entire rest of the queue, so the slot kept whatever it had, which for a slot the engine had never been told about is patch zero: the first acid patch.

A memo on the sending side then made it permanent. It recorded what each slot had been told at the moment of queueing, so nothing was ever re-sent.

The fix is that a stop now cancels only what was already scheduled when it arrived, and leaves alone whatever was queued after it. Positional, not “empty the list”. Anything pushed into an audio queue is a promise, and a promise is only kept while the renderer is running.

The plate that paged itself

The Stabs plate used to show a 16-step window of the pattern and flip to the next bar on its own while playing. It answered the wrong question. A plate exists to say how long the loop is and where the hits sit inside it, and a page that swaps under your eye says neither.

It now draws the whole loop, in the same language the Bass plate uses: same dot, same spacing, same greys, same playhead. A longer loop gets smaller dots rather than a slideshow. The one difference that stays is the one the module actually has, which is that a column lights several rows at once, because a stab is a chord and the shape of that column is the voicing.

Reading 51 manuals

The CC library was the largest single piece of work in the release, and almost none of it was code.

Every machine’s control map was extracted from its manufacturer’s manual, then independently re-read and compared row by row against the first pass. That second pass is where the value is. It caught a vendor typo in one manual where two envelope parameters carried the same printed name, a control that the manual documented on a page belonging to a different MIDI channel, and several tables where the printed numbers simply did not match the text beside them.

We also turned machines away. If a synth has no real control map in its documentation, a couple of stray CC numbers is not an instrument, and shipping a guess is worse than shipping nothing. Several well-known machines are absent for exactly that reason, including a few whose entire control scheme is assigned by the user rather than fixed by the factory.

One finding changed the app itself. Two Moog synths document every switch as “0 = off, 64 = on”, and nothing above 64 is defined. Our buttons had been sending 127 to everything, because that is the obvious value. It is not always the right one. A switch now carries the value its own manual prints for “on”.