███████╗██╗ ██╗ ██████╗ ██╗ ██╗ ██╗███████╗██████╗ ██╔════╝██║ ██║██╔═══██╗██║ ██║ ██║██╔════╝██╔══██╗ █████╗ ██║ ██║██║ ██║██║ ██║ ██║█████╗ ██████╔╝ ██╔══╝ ╚██╗ ██╔╝██║ ██║██║ ╚██╗ ██╔╝██╔══╝ ██╔══██╗ ███████╗ ╚████╔╝ ╚██████╔╝███████╗╚████╔╝ ███████╗██║ ██║ ╚══════╝ ╚═══╝ ╚═════╝ ╚══════╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝ EVOLVER

01What is EVOLVER?

EVOLVER is a bare metal, pattern-based MIDI sequencer inspired by a classic tracker workflow, but without the hex codes. It is entirely keyboard-driven and does not use GEM.

It features 8 tracks with 8 lanes each — 64 independent lanes, every one of them freely assignable to any of the 16 MIDI channels - or 32 with MIDI OUT B turned on - with its own note, gate, timing, patch and automation on every step. There are 32 patterns per track — 256 in a project — and an arranger that can chain them into a full composition.

How many voices is that? A lane set to MONO plays one note; a lane set to POLY expands a chord macro into up to 8. Each track can hold 24 voices — so one track can sound 24 notes at once and the machine 192 in total. Most experienced Atari musicians will know that MIDI carries 3,125 bytes a second, so 24 notes struck at once take about 23 ms just to leave the port. The cable fills up long before the voices run out.

This software is subject to changes of features and optimization. Please check the news section or the Discord channel for any updates.

As of 25/10/2026 the manual is still currently a work-in-progress and does not necessarily represent the final product.

02Before you start

Pre-requisties:

• An Atari ST, STE or Mega with 4 MB of RAM. EVOLVER reserves 3.05 MB.
• A monitor that can run in ST-High: 640×400 monochrome.
• TOS 1.00+ / EmuTOS. EVOLVER was mainly developed for and measured on TOS 2.06, and verified on EmuTOS 1.2.1 on both STE and Hatari.
• A MIDI cable and a device on the other end of it.

TT and Falcon are untested. They would need ST-High compatibility mode, since the screen is addressed directly as 640×400 mono at 80 bytes a scanline.

Files, all in the same folder:

Double-click EVOLVER.PRG from the desktop, or drop it in AUTO\ to boot straight into it.

03Sixty seconds to your first sound

You land in the SESSION view. It is empty. Here is the fastest possible path to hearing something.

1.  ENTER            The T1 cell on row S01 opens for editing.
2.  ENTER            Commits pattern 01 to track 1.
3.  TAB              Drops you into the pattern editor for that pattern.
4.  SPACE            Puts a note on step 1.
5.  ↓ ↓ ↓ ↓  SPACE   Another on step 5.
6.  NUMPAD ENTER     Play.

You should be hearing two notes on MIDI channel 1, looping every 16 steps.

If you hear nothing, jump to section 20 — but the first thing to check is that the track's CH matches what your synth is listening on.

To stop: NUMPAD ENTER again. To get back to SESSION: ESC.

04The transport header

The top three lines are always there in every view.

════════════════════════════════════════════════════════════════════════════════
 [>] PLAYING [R]*+2            [BAR 003.2.14]                        [BPM:132]
════════════════════════════════════════════════════════════════════════════════

Setting the tempo:

• F10 opens BPM for editing. Type digits, or ↑/↓. ENTER locks it.
• F9 reminds you where swing is set: per track, in the editor's header.

The metronome. CTRL+M switches it on and off. On, the * flashes on each beat while the transport runs and the ST's sound chip clicks with it, with a higher click on the first beat of the bar.

Swing above 50 % delays every odd-numbered step. At 50 % it is straight. It scales with the pattern's SCL setting, so a slowed-down pattern swings by the same proportion of a step, not the same number of ticks.

Swing is set per track: the SWG cell on the editor's header row (section 07). There is no global value; every track starts at 50, and a SWG sequence action sets several tracks at once.

05The two workspaces

EVOLVER has two views you work in, and six pop-up pages that float over them.

SESSION view — the arrangement: which pattern plays on which track, and when.

                   |  T1   T2   T3   T4   T5   T6   T7   T8  |
 ARRANGE       SEQ |  [ ]  [ ]  [ ]  [ ]  [ ]  [ ]  [ ]  [ ] | LENGTH  ACTION
-------------------+-----------------------------------------+-----------------
 INTRO    [>]  S01 |  01   01   --   04   --   --   --   --  | 4 BARS  FADE IN
 VERSE         S02 |  02   01   03   04   --   --   --   --  | 4 BARS  NEXT

EDITOR view — the pattern editor consisting of a grid with 8 lanes and two sidebars.

 [T1] [TRACK 01] [PT:01] [CH:01] [LEN:16] [SCL:  1x] [SWG:50]
 ST | CH01 CH02 CH03 CH04 CH05 CH06 CH07 CH08 | STEP 01:CH01   | AUTOMATION
----+-----------------------------------------+----------------+-------------
 01 | C-1  ---  ---  ---  ---  ---  ---  ---  | MIDI CH : 01   | PRG     ---
 02 | ---  ---  ---  ---  ---  ---  ---  ---  | VOICING : MONO | BANK    ---
 03 | C-1  ---  ---  ---  ---  ---  ---  ---  | VELOCITY: 100  |    CC# VAL

The one rule that makes navigation click: TAB goes in, ESC comes out, one level at a time.

• In SESSION view, TAB opens the pattern under the cursor in the editor.
• In the editor grid, TAB moves the cursor into the STEP sidebar. TAB again toggles to the AUTO sidebar, and TAB toggles back. It bounces between the two panels; it does not cycle out.
• ESC steps back: cancel an edit → leave the sidebar → leave the editor.

Arrow keys stay inside whatever zone you are in. You cannot wander into the sidebar by holding →.

While your cursor is off in a sidebar, the grid cell you are editing stays lit and blinking, so you're never in doubt which step and lane you're editing.

06SESSION view

This is the top level where you arrange your composition. It can hold 128 sequence rows, S01 to S128, each one programmed with patterns on the eight tracks. You can also set how long a sequence should last and define which actions a row should follow.

                   |  T1   T2   T3   T4   T5   T6   T7   T8  |
 ARRANGE       SEQ |  [ ]  [M]  [ ]  [S]  [ ]  [ ]  [ ]  [ ] | LENGTH  ACTION
-------------------+-----------------------------------------+-----------------
 INTRO    [>]  S01 |  01   01   --   04   --   --   --   --  | 4 BARS  FADE IN
 VERSE         S02 |  02   01   03   04   --   --   --   --  | 4 BARS  NEXT
 CHORUS        S03 |  05   06   03   07   --   --   --   --  | 8 BARS  -> S02

• [>] marks the sequence row that is playing. [Q] marks one that is queued.
• [M] / [S] on a track column is mute / solo.
• -- means that track is silent on this row.

Moving and editing

SPACE is how you build a sequence. On an empty cell it drops pattern 01 in; press it again and you are on 02, 03, and so on.

SHIFT+SPACE walks back down. When you do want a specific pattern, ENTER opens the cell for typing - confirm by hitting ENTER again.

The cursor can also move to the left of the track columns, on the sequence's name — ENTER lets you type an 8-character name like CHORUS.

To build a variation of a pattern without touching the original, clone it: SHIFT+C on the pattern, SHIFT+V on an empty cell. See Copy, paste, undo.

LENGTH and ACTIONS

LENGTH is how many bars the sequence lasts before it ends. A bar is sixteen steps of the master clock - the same bar the [BAR 001.1.00] readout counts - so 4 BARS is 64 master steps, whatever the patterns on the sequence happen to be doing.

INF means loop forever, which is the default and what you probably want while you are writing. SPACE steps it, SHIFT+SPACE steps it back. ENTER opens it for typing.

ACT says what happens when either the sequence starts or ends:

STOP, -> Snn and RANDOM happen when the sequence's length has run out — they say where to go next. FADE IN, FADE OUT, BPM, SWG and RPM take effect when the sequence starts: a fade or a ramp needs the sequence's length to run across, and a tempo change wants to be in force for the bar you can hear. Those five then fall through to the next sequence when the length runs out, the same as NEXT.

RPM on an INF sequence has no length to ramp across, so it sets the tempo at once like BPM. Editing the tempo by hand with F10, or stopping the transport, ends a ramp where it is.

The three that carry a number each remember their own, so cycling past one never costs you another. ENTER opens the number for typing; SPACE cycles which action it is.

Fades send CC#7. If you are also automating controller 7 on a CC lane of the same channel, the two will fight. A STOP sequence after a FADE OUT keeps the level where the fade left it: it runs its length in silence and then stops, so the ending is not undone at the last moment. Pressing play puts the level back to FADE LEVEL if a fade left it somewhere else, so a FADE OUT that ended a song never makes the next take silent — and a FADE OUT you start from a later sequence falls from where the music actually sits rather than jumping to full first. A project with no fades in it never sends a CC#7 at all.

A FADE IN sends its zero a little ahead of the sequence, so the synth has settled before the first note instead of catching it on the way down: 16 ticks before the sequence changes, or at the play key with a 60 ms hold when the fade is on the first sequence. The hold delays everything together — the music, the clock, START — so nothing moves against anything else. Set the fade on a sequence reached by RANDOM and the zero can only go out when the sequence starts, since there is no knowing it is coming.

How high a fade rises is FADE LEVEL on the F4 page, 1–127, default 100. 127 is CC#7 flat out; sitting a little under it leaves headroom to push into. It applies to FADE IN; a FADE OUT always ends at zero.

Which tracks a fade or a SWG action touches is set per sequence. With the cursor on a FADE IN, FADE OUT or SWG action cell, press TAB — the cursor drops into that row's track cells, which stop showing pattern numbers and start showing who is in the action:

 VERSE      S02 |  I    I    .    .    I    --   --   --  | 4 BARS  FADE IN

I is in a fade in, O in a fade out, S takes the swing, . is a track left alone. LEFT/ RIGHT move, SPACE toggles, ESC applies and hands the cursor back to the ACTION cell. The pattern numbers come straight back. This belongs to that one row — two rows can fade different tracks, and every row starts with all eight selected. A fade with no tracks selected does nothing.

A SWG action sets the swing of the tracks selected in its row, all eight by default.

SPACE on the ACTION cell cycles it, SHIFT+SPACE cycles back. ENTER opens the number — the jump row, the BPM, the swing — for typing.

Launching rows live

CTRL+↑/↓ nudges the playhead one row at a time without moving your cursor, which is the quick way to audition the sequence above or below what you are editing.

With the transport stopped, Q on a sequence jumps straight to it.

With the transport running, Q queues it — the sequence is marked [Q] and switches at the next downbeat, so you can line up a chorus and hit it in time. Q again cancels the queue.

Good to know: the sequence length is bars, not pattern repeats. If track 1 plays a 16-step pattern and track 3 plays a 64-step one, 4 BARS is 64 master steps: track 1 loops four times inside it and track 3 plays exactly once. A pattern that does not divide into the bar - a 12-step pattern, or anything on 2/3x - is cut wherever the last bar ends. If you want whole passes, set a length that is a whole number of them, or use INF and switch sequence by hand. SCL changes how much pattern fits in a bar — see section 11.

07EDITOR view

TAB from SESSION opens the pattern under the cursor and takes you into the pattern editor.

 [T1] [TRACK 01] [PT:01] [CH:01] [LEN:16] [SCL:  1x] [SWG:50]

 ST | CH01 CH02 CH03 CH04 CH05 CH06 CH07 CH08 | STEP 01:CH01   |    CC# VAL MOD
 01 | C-3  ---  ---  ---  ---  ---  ---  ---  | MIDI CH : 01   | 01 074 --- ---
 02 | ---  ---  ---  ---  ---  ---  ---  ---  | VOICING : MONO | 02 071 --- ---
 03 | ---  C-1  ---  ---  ---  ---  ---  ---  | VELOCITY: 100  | 03 007 --- ---
 ...                                          | ...            | ...

There are three zones, left to right:

• The GRID — 16 visible steps down, 8 lanes across.
• The STEP panel — every parameter of the one cell your cursor is on.
• The AUTO panel — the eight CC automation lanes, plus the lane's LFO.

The header row

[T1] [TRACK 01] [PT:01] [CH:01] [LEN:16] [SCL:  1x] [SWG:50]

Press ↑ from the top of the grid to reach it.

SPACE steps the cell under the cursor up, SHIFT+SPACE steps it down. When you want an exact number instead, ENTER opens the cell, ↑/↓ or digits change it, ENTER commits and ESC discards.

Moving in the grid

SHIFT + ↑/↓ snaps to the boundaries your eye already reads the grid by — it is not a flat +4.

Placing notes

SPACE is the fast way. It stamps the lane's latched note onto the step — the last pitch you used on that lane. So set the pitch once, then walk down the grid tapping SPACE, and you are writing a part at speed.

ENTER is the precise way. Type a note name — C3, F#2, Bb4 — and ENTER. Or use ↑/↓ to nudge, SHIFT+↑/↓ for octaves.

Middle C is C3 (MIDI 60), matching Roland, Akai and Waldorf standards.

Renaming lanes

Press ↑ from step 1 to land on the lane-name row, then ENTER and type up to 4 characters. KICK, SNRE, HAT, BASS, LEAD — whatever the row actually is.

Parameter steps

A step can carry settings without sounding a note of its own. It shows as -P- in the grid, and what it does is re-shape whatever its lane is already sustaining.

SHIFT+SPACE on an empty cell puts one there. So does simply changing any step parameter on an empty step — move to it, turn TIE off, and the step now exists as a modifier — and so does setting an automation value on it. The other way round too: SHIFT+SPACE on a -P- takes the step away together with its automation, and clearing a note clears the note's automation with it. A cell that shows nothing holds nothing.

That third row is the interesting one. Hold a MIN 7 chord from step 1 with TIE on, put a parameter step on step 9 with CHORD:MIN, and the seventh lifts out — one Note-Off, and the three notes that stay are never re-attacked. It is a chord progression written as one held note and a few modifiers.

The above is merely an example - it's up to your creativity on how to use a parameter step, whether you want to adjust a MIDI CC value, an ARP division, or something completely different.

MIDI CH, VOICING and NOTE never create a parameter step: those belong to the lane rather than the step, so changing a lane's channel will not litter the pattern with -P- wherever your cursor happened to be.

Editing many notes at once

You can select notes — in one lane or across several, or the whole pattern — and then change them all from the STEP or AUTOMATION panel, copy them as a block, or clear them.

1. Put the cursor on the first note.
2. Set how far each press moves with ALT+1 … ALT+8 — the same step-input advance used for recording. At 2, every other step; at 4, one per beat.
3. Press CTRL+↓. The note you started on and every note you land on are marked with * in the grid. Empty steps are passed over, not selected. The cursor wraps at the end of the pattern like step entry does. CTRL+→ and CTRL+← move one lane across and mark the note there, so a selection can cover several lanes; they stop at the first and last lane.
4. TAB. The panel header shows the count — STEP 01:KICK*04 — and the panel edits the first selected note as usual.
5. Change whatever you like, then ESC. Every value you changed is copied to the other selected notes, and the log says what was applied.

The copy is absolute: set VELOCITY to 90 and all of them are 90. Values you did not touch stay as each note had them. MIDI CH, VOICING and NOTE belong to the lane, not the step, so they are never copied. One UNDO takes the whole apply back.

The AUTOMATION panel works the same way. A CC value or mode you change on the first note is set on the same CC row of every other selected note, each on its own lane. The CC numbers stay as each lane has them, and the LFO rows are lane settings, so they are not copied.

Select the whole pattern with CTRL+A. Every cell inside the pattern length is marked, empty ones included. TAB edits the notes in it as above. CTRL+C copies the whole pattern, and DEL empties it.

Emptying the whole pattern also clears its PRG and BANK, and resets each lane's other automation settings — the CC# numbers and the LFO — so nothing is left set to send. The CC# numbers and the LFO belong to the lane across all 32 patterns of the track, so a lane that another pattern of the same track still uses keeps them, and the log says how many were kept. One UNDO brings back the notes and the settings together.

Clearing a selection. DEL or BACKSPACE empties every selected cell: the note, its step values and its automation all go back to how a new pattern has them. One UNDO brings them all back. Without a selection, DEL clears the cell under the cursor as before.

Any other key in the grid — a plain arrow, SPACE, ESC — drops the selection. After CTRL+A, CTRL+arrows start a new selection.

SHIFT+ALT+arrow is the intended binding, but TOS may keep ALT+arrow combinations for moving the mouse pointer, and on EmuTOS it never reaches EVOLVER. CTRL+arrow always works. All of them can be rebound in the F1 keyboard map.

Switching tracks

Changing between [TRK 1] … [TRK 8] in the header jumps straight to that track, staying on the sequence row you came in from. If the track has no pattern on that row, nothing changes and the log says so — EVOLVER will not invent one for you.

08Lanes and voicings

Every track has 8 lanes. A lane is an independent voice: its own MIDI channel, its own note on every step, its own gate, its own everything.

That is the whole architecture. A "drum track" is eight lanes each hitting one drum. A "multitimbral track" is eight lanes on eight different MIDI channels. A bass part is one lane and seven empty ones. They are the same thing.

Each lane has a VOICING, set on the VOICING row of the STEP panel:

The lane's latched NOTE

Every lane carries a latched pitch, shown as the NOTE row in the panel, and SPACE on an empty step stamps it.

Because voicing is per lane, one track can be both. Lane 1 a kick, lane 2 a bassline, lane 3 a poly pad — same track, same pattern, same 16 rows.

MIDI channel per lane

The MIDI CH row at the top of the STEP panel is the lane's channel.

• 01–16 — this lane goes out on that channel.
• Leave it at the track default and it follows the track's CH.

This is how you drive a multitimbral module: one track, eight lanes, eight channels, one pattern to write them all in.

09Every step parameter

Press TAB from the grid to get into the STEP panel. ↑/↓ picks a row.

SPACE steps the value up, SHIFT+SPACE steps it down. That is the fast way. ENTER opens the row for typing an exact number, and BACKSPACE or DELETE resets it to its default.

Rows marked ● appear on all lanes; ◆ only on POLY.

The ones worth dwelling on

GATE vs LEN. GATE is a percentage of one step — 50 % is a staccato stab, 100 % fills the step. LEN is how many whole steps the note occupies, so a pad that should ring for four steps is GATE:100 + LEN:04. It counts the note's own step, so LEN:01 is the default and LEN:64 is the longest pattern there is, held from its first step to its last. LEN is measured in the lane's own scaled steps, so LEN:04 on a 2x pattern is four fast steps, not four bars' worth.

TIE. Where LEN re-states the note, TIE sustains without re-triggering. Put a note on step 1 with TIE on, and steps 2, 3 and 4 will not re-fire it — the note simply keeps ringing. It is the difference between a bass line that pulses and one that holds.

TIE also changes what ARP does: with TIE on, the arpeggio runs continuously instead of stopping after LEN steps. That is your infinite arp — and a parameter step with TIE off is how you end it.

SHIFT. Ticks, not steps. There are 48 ticks in a step, so SHIFT:-12 is a quarter-step early — a snare that drags, a hat that pushes. Negative values fire the note before its own step, which the engine handles by scheduling it a step ahead.

RETRIG. Repeats the note across the step. 4x on a snare with a short gate is a drum roll; on a synth stab it is a stutter. 4x means four hits in the step, 8x means eight, and the last one's gate is what you hear ring on. The F3 page has three switches that change how it behaves — see section 17.

HUMANIZE. Randomizes velocity around what you set.

10Conditions and probability

Two independent ways to make a step not always play.

PROB is a straight dice roll: PROB:60 fires six times in ten.

COND is a rule about which pass through the pattern you are on. This is where patterns stop repeating and start evolving.

PRE and !PR are the interesting pair. Chain them and you get branching: a step with PROB:50, then a following step on PRE, and the second only happens when the first did. Put !PR on a third and you have an either/or fill.

A worked example. A 16-step hat pattern. Every step PROB:100, except step 16, which gets COND:4:4 and a RETRIG:4x. Now three bars are plain and the fourth ends with a roll — one parameter, and the loop stops being a loop.

11SCL — scaling a pattern's clock

SCL on the header row makes one pattern run at a different speed from the rest of the machine, without changing BPM.

SCL states how long each step lasts. 2x means each step is twice as long, so your 16-step pattern spans twice the bars. 1/2x means half as long — twice as fast.

ENTER on the SCL cell, then ↑/↓ to cycle. It wraps at both ends.

SCL also changes how hard the machine is working

This is worth knowing before you reach for it on a busy song.

SCL sets how long a step lasts, so it also sets how often steps happen — and steps are the work. 1/2x means the steps come twice as fast, which is the same amount of work as playing the song at double the tempo. 2x means they come half as often, which is half the work.

Two practical consequences:

Going fast? Reach for 2x. Eight busy tracks at 240 BPM on 1x will drop the odd tick. The same material on 2x patterns — twice as many steps, each lasting twice as long, so it sounds the same — runs perfectly. If you are writing at high tempo and the TK counter on F7 is climbing, this is the first thing to try.

1/2x on a busy song is asking a lot. On eight tracks of plain notes it is fine. On eight tracks that are also running arps and automation it is the setting most likely to push you over. Nothing breaks — the tempo holds and notes thin instead — but it is where you will notice it first.

None of this matters on an ordinary song. It matters when you are already near the edge, and then it is the biggest single lever you have.

3x was removed: everything else here is either a power of two or a triplet relation, and three-against-one on a 16th grid was not a figure anyone was reaching for. An old project that used it still opens and still plays at the same speed — the setting just cannot be selected again once changed.

Every ratio is exact. A step is 48 ticks and 48 divides by both 2 and 3, so 2/3x is precisely 32 ticks — there is no rounding and nothing drifts, however long you leave it running.

Why 4x is the interesting one. A pattern is at most 64 steps. At 4x those 64 steps cover 256 steps of timeline — sixteen bars — so you can write a long evolving pad or a whole chord progression in a single pattern instead of chaining four. Elektron users will recognise this immediately.

Changing SCL while playing is safe. The new value is latched at the pattern's next boundary, never mid-pass, so it will never cut a phrase in half.

One thing to know about row length: the row ends after the number of BARS you set, and a triplet scale does not line back up with the grid until three passes have gone by. So on 2/3x and 4/3x, a row of 1 BAR cuts the pattern part way through a pass. Give a triplet row 3 BARS - or a multiple of three - and it lands where it should.

12Automation — CC, JMP, INT and LFO

TAB from the STEP panel puts you in the AUTO panel.

| AUTOMATION
| PRG        012
| BANK       ---
|    CC# VAL MOD
| 01 074 100 JMP
| 02 071 --- ---
| 03 007  64 INT
| ...
| LFO CLK  SYNC
| LFO SPD  1/16
| LFO SHP  SINE

Everything on this panel belongs to the LANE your grid cursor is on, not to the track. Move between lanes and the whole panel changes with you. Eight CC lanes, a patch and an LFO on each of the eight note lanes — 64 CC lanes per track, and each one goes out on that lane's own MIDI channel.

• PRG / BANK — the patch this lane plays in this pattern. Each pattern has its own, so PT 01 can play one sound on a lane and PT 03 another. --- means "say nothing" and keeps whatever the lane last sent, which is the default: EVOLVER will not reprogram a rack nobody asked it to. See Patch changes below.
• CC# — what this row sends: a controller number 0–127, or PRG for program changes (see below). Per lane, not per step. 000 is Bank Select; --- is no controller. The 01–08 down the left are just the eight rows, not controller numbers.
• VAL — the value on this step, 0–127, or --- for "this step says nothing, leave whatever is running alone".
• MOD — what the value means on this step.

←/→ moves between the three fields, ENTER edits, ↑/↓ or digits change. The CC# VAL MOD line is a heading, so the cursor steps over it.

SPACE steps any field up and SHIFT+SPACE steps it down, wrapping round at the ends; DEL or BACKSPACE puts it back to its default. PRG and BANK step one at a time through --- and 0–127 and send the patch each time, so you can tap through sounds. CC# steps through ---, 000–127 and PRG; when typing, use DEL for ---. VAL starts at 64 from --- and moves in tens. MOD goes JMP → INT → LFO, and back with SHIFT. The LFO rows step through their settings the same way; their defaults are SYNC, 1/4 and SINE.

Patch changes

A pattern's PRG and BANK go out when the pattern starts: when you press play, when the arrangement moves to its row, and every time it loops. Bank Select goes first, then Program Change, on the lane's own MIDI channel. Each is sent only if it differs from what that lane last sent, so a pattern looping on the patch that is already loaded sends nothing. Editing the value sends it at once, so you hear the sound you picked.

To change the sound inside a pattern, set one of the lane's eight rows to CC# PRG and give a step a VAL: that is the program it switches to on that step. A -P- on an empty step is the usual way. The same "only if it differs" rule applies, and the step obeys its COND, so a -P- with PRG 20 and COND 4:4 switches the sound on every fourth pass. On a PRG row VAL steps by one and MOD is always JMP. For a bank change on a step, put a CC# 000 row on the same step; it goes out before the program.

A pattern with PRG --- sends nothing at its start, so its first steps play on whatever the lane last had. Set the pattern's PRG, or a PRG step on step 1, if those steps should always have a particular sound.

When you press play on a row whose pattern has no PRG on a lane, EVOLVER looks up the arrangement for the nearest row above whose pattern does, and sends that first — so a row played on its own sounds the way it does in the song. It reads the patterns' own PRG/BANK, not PRG steps inside them.

Give the synth a moment. Many synths take a few milliseconds to load a patch, and a note on the same step can start with the old sound or be cut. Put a PRG step one step before the note that needs the new sound.

The three modes

JMP — jump. Send this value, once, right now. This is an Elektron parameter lock: step 5 slams the cutoff to 100, step 9 drops it to 20. Nothing in between, no ramp, just the value at the moment the step fires.

INT — interpolate. Sweep smoothly from this value to whatever the next step on this lane sets, over the time between them. Set INT 0 on step 1 and INT 127 on step 16 and you get a filter sweep across the whole bar that is perfectly smooth — the engine walks it with a Bresenham line, so it never stutters and never overshoots.

LFO — modulate. Hand this CC to the lane's LFO. The value you set is the depth, not the level.

The LFO

Three rows at the bottom of the panel. Like everything else here the LFO is per lane, so each of the eight can run its own shape at its own rate:

RAMP rises through the cycle and snaps back; SAW is its mirror and falls. RND is sample and hold — one new random level per cycle, held until the next. Each lane's RND draws independently, so eight of them do not step to the same number.

In SYNC the LFO is locked to the bar and starts from phase zero when you press play, so it is in the same place every time round. Two takes will sound the same.

An LFO keeps running until another step on the same CC row sends a JMP or INT value, or until you stop and start the transport. Deleting or clearing the step that started it stops it, if no other step of the playing pattern sets that row. Setting the row's CC# to --- stops it at once.

Try this. CC# 074, MOD LFO, VAL 60, CLK SYNC, SPD 1/4, SHP SINE. A quarter-note filter wobble locked to the grid. Now change SHP to RAMP and it becomes a sawtooth pump.

13Live recording

Plug a keyboard into MIDI IN.

Stopped: step entry from the keyboard

A note you play lands on the step your cursor is on, and the cursor moves on. This is the fastest way to get a part in — no arrowing, no typing note names.

ALT+1 … ALT+8 sets how far the cursor moves. At 1 you fill every step. At 2 you fill every other one, so a 16-step off-beat hat pattern is eight keypresses and nothing else. At 4 you are placing one note per beat.

The setting shows in the transport row as +n — blank at 1, so you can always see why the cursor is jumping. It resets to 1 when you relaunch. It also sets how far each press moves when you select notes to edit together.

Chords work the same way: play one on a POLY lane and the whole chord lands on the step, then the cursor advances by the same amount.

Running: notes land where they fall

Count-in. With RECORD or OVERDUB armed and a count-in set, pressing play does not start the song at once: EVOLVER counts 1 to 4 bars first, clicking on each beat, and the transport then starts from step 1. The header shows [-] COUNTIN and the bar counter runs down — -02.1, -01.4 — until it does. Set the length with COUNT-IN on the F4 page; NUMPAD - switches it off and back on without losing the length. Pressing play again during the count cancels it. With nothing armed there is no count-in.

With REC QUANTIZE off (the default), your micro-timing is kept — stored in the step's SHIFT down to the tick, so the feel of what you played survives. Quantise afterwards with Q if you decide you want it tidy; that way round you can always change your mind. Turn it on and notes snap to the step as they land.

Knobs, too

Control changes are recorded as well. Move a knob with the transport armed and the value lands on the step that is playing, as a JMP on the matching CC lane.

The catch — and it is deliberate — is that the lane must already be listening for that controller. Set CC# on one of the automation rows of the lane you are playing into, and your knob movement is captured; a controller no lane is watching is ignored. That way you decide what gets recorded instead of a stray knob writing itself into your pattern.

A sweep sends far more messages than there are steps, so later values simply overwrite earlier ones on the step being played. One value per step is exactly what a lane holds.

Play into it feel-first with quantize off, then use Q afterwards if you decide you want it tidy. That way round you can always change your mind.

14Quantize

Set the grid on F2 → QUANTIZE: 1/4, 1/8, 1/16, 1/32 or 1/64.

Then, in the editor:

1/4 and 1/8 move notes onto the nearest beat or eighth. 1/16 puts each note exactly on its nearest step. 1/32 and 1/64 round the note's SHIFT to the nearest half or quarter step, so it stays close to where you played it.

The pattern is treated as a loop: a note played just before the end can move to step 1, and one played early on step 1 can move to the last step.

Each lane is quantized separately, using its own SHIFT.

One UNDO takes back a whole SHIFT+Q. The console shows how many notes moved.

15Copy, paste, undo

In the editor:

The block is one clipboard with two ways to fill it: select notes with CTRL+arrows, or the whole pattern with CTRL+A, then press CTRL+C. It stays on the clipboard when you move, so you can paste it into another pattern or onto another track (1 … 8 switches track).

A block of selected notes lands with its top-left corner on the cursor. Each note travels with its step values and that step's automation. Pasting writes only the notes: an empty cell inside the block leaves whatever is underneath alone.

A whole pattern lands on the cursor's step with its lanes where they were, and it brings everything with it, empty cells included, so the steps it covers end up the same as the source. It does not change the pattern's LEN or SCL.

Either kind stops at the end of the pattern rather than wrapping round. One UNDO takes a paste back.

In SESSION:

Pattern IDs will not paste across track columns. Track 3's pattern 05 is not track 5's pattern 05, and silently pasting the wrong one would be a very annoying bug to chase.

Cloning a pattern (SESSION):

C/V copy a pattern's number — both cells then play the same pattern, and editing one edits both. A clone copies the contents into a new pattern, so you can change it freely.

SHIFT+V picks the lowest free pattern on the target track: one that is empty and not placed in any row. Clone pattern 00 into the next row and you get 01. Press SHIFT+V on further empty cells and you get 02, 03 and so on. The notes, automation, LEN and SCL all come across.

Cloning never overwrites anything:

• SHIFT+V on a cell that already holds a pattern is refused.
• A pattern already in use is never chosen as the target.
• If all 32 patterns on the track are in use, it says so and does nothing.

A pattern can be cloned onto another track too; its notes then play through that track's lanes and channels.

UNDO after a clone empties the new pattern again, but the cell keeps the pattern number. Clear it with BACKSPACE — SESSION cell edits are not in the undo history.

UNDO (the Atari UNDO key) goes back 256 levels, and SHIFT+UNDO goes forward again.

An operation that changed many steps comes back in one press — a whole SHIFT+Q quantize of a 64-step pattern is a single undo, not sixty-four. Everything is covered: typing values, SPACE cycling, laying notes in the grid, paste, and quantize.

16Saving and loading

Both open a file browser. Arrows to move, ENTER to choose, ESC to cancel. On save you type a filename; .EVO is added for you.

A .EVO file holds everything: all 8 tracks, all their patterns, the whole arrangement, tempo, swing, MIDI OUT B, and your notepad. Your preferences on the F3 and F4 pages are not in it — they are yours, and live in EVOLVER.SET.

A save writes the project to NAME.TMP in the same folder first and only replaces NAME.EVO once every byte is on the disk. If the disk fills up or the write fails, the old file is untouched and the console says so — which does mean the disk needs room for the old and the new file at the same time. Opening works the other way round: a damaged or truncated file is refused before anything is loaded, and the project you had stays as it was. The browser will not go deeper than the 127-character path it can hold, and says so.

The step-input advance and the record mode are not saved — they describe how you are working right now, and both reset on launch.

17The function pages

There are six menu pages: F1–F4,F7,F8.

F1 — Keyboard map

Every command key in EVOLVER, and the place to change them if you prefer to customize your own workflow.

The map is split into pages:

The title shows where you are, e.g. KEYBOARD MAP: SEQ VIEW 2/3 and 05/11.

Every command has two slots, KEY 1 and KEY 2, and either key triggers it.

Modifiers must match exactly. C, SHIFT+C and ALT+C are three different keys, which is how copy, clone and copy-row live side by side.

If the key is already taken, the log line says which command has it. ENTER swaps the two keys between the commands; ESC leaves both alone. Keys only clash within the same page group. A SEQ VIEW key can also be an EDITOR key, because only one of those views is ever active. A GLOBAL key works in every view, so it clashes with keys in all of them.

Some keys are off limits:

• ESC and F1 cannot be bound to anything, so a bad map can always be fixed.
• A GLOBAL command needs ALT or CTRL, an F-key, UNDO/HELP or a keypad key. A plain letter or arrow there would be taken away from every text field and cursor in the program.
• The keys inside an open field are fixed: digits, letters, ↑ ↓ on a value, ENTER to confirm. So are the popups' own arrows, the notepad and the quit Y/N. These are the FIXED KEYS pages.

Your map is saved when you close the page, to EVOLVER.SET in the folder EVOLVER started from, and it is loaded every launch. It belongs to you, not to a project, so loading a .EVO does not change it. Delete the file, or press SHIFT+DEL in the map, to go back to the defaults.

Keys are matched by position on the keyboard, not by the letter printed on it. On a German or French ST, rebind any key whose position feels wrong. The defaults use US positions (Q for queue sits where A is on AZERTY).

F2 — MIDI settings

MIDI OUT B — the serial port as a second MIDI output

Off by default. Turn it on and channels 17–32 leave through the ST's RS-232 port instead of the MIDI socket, so a heavy project can be split across two cables. Set a lane's MIDI CH to 17–32 and that is where it goes; 17 is channel 1 on the second cable, 32 is channel 16.

You need a lead from the 9-pin serial port to a MIDI DIN socket: TxD to DIN pin 5, ground to DIN pin 2, through the usual 220Ω resistor on pin 4 fed from +5V. Any "Atari serial to MIDI" lead does this.

The rate is 30720 baud, not 31250. The ST's serial clock cannot be divided to exactly the MIDI rate; this is the closest it gets, 1.7% slow. That is well inside what a MIDI input tolerates, because a receiver re-synchronises on the start bit of every byte. Gear that is fussy about its input may disagree, which is the honest caveat: try it with what you own.

It is saved with the project, so a song that needs it comes up with it on. Turning it off hands the port back to TOS exactly as it was found.

What it buys. On an eight-track test that saturates one cable, splitting the tracks across both cut the queue waiting for the wire from 344 bytes to 96 - about 110 ms of latency down to 30. It costs a little CPU, so use it when the wire is the problem, not the processor.

The typing keyboard — ALT+K

Off by default. Turn it on and the letter rows play notes, laid out the way a piano sits under your fingers:

A note played this way is treated exactly as one arriving on MIDI IN — it goes out through soft-thru, it records when the transport is armed, and the chord catch sees it. Nothing behaves differently because it came from the computer keyboard.

A note lasts as long as you hold the key. The ST's keyboard reports two keys at once at most — that is a limit of the keyboard itself, not of EVOLVER — so two notes can be held together and a third will not sound. Chords come from chord mode instead. While the typing keyboard is on, EVOLVER reads the keyboard itself rather than through TOS — that is the only place a key release can be seen — and hands it back the moment you switch it off.

Chord mode. Press M and each note key plays a whole chord from one root: the fifteen chords of the CHORD list in order, A to L for MAJOR, MINOR, DIM, AUG, SUS 2, SUS 4, MAJ 7, MIN 7 and DOM 7, then W E T Y U O for MIN7b5, DIM 7, MAJ 9, MIN 9, POWER and OCTAVES. The root starts at the octave's C; SHIFT+Z and SHIFT+X move it a semitone at a time, and Z / X still move the octave. The chord sounds for as long as the key is held and is released as a whole, with the root it was struck with, so you can move the root under a chord without cutting it. A chord played this way records like one played on a MIDI keyboard. M again goes back to single notes.

While it is on, those letters are no longer commands. S is a note, not SOLO. Anything with a modifier still works — ALT+S still saves — and ALT+K gives the letters back. It is always off when EVOLVER starts.

Quick fill — CTRL+1…8 then SPACE

In the editor grid, hold CTRL and a digit to arm a spacing, then press SPACE. A note goes down every n steps along the lane, starting at the cursor and wrapping round the end of the pattern. CTRL+4 SPACE on step 1 of a 16-step pattern gives you four on the floor; the same on step 3 gives the same pulse shifted. Steps that already hold a note are left alone, and one UNDO takes the whole fill back. ESC or any other edit key cancels the arm.

Queue length — SHIFT+Q then 1…8

Q queues a sequence row to take over while the transport runs. SHIFT+Q followed by a digit says how long to wait: 1 switches on the next downbeat, 4 on the next four-bar line. It is a launch quantise — a grid the switch lands on, not a countdown — so queueing halfway through bar 3 with a setting of 4 still lands on bar 5. It starts at 1 every time EVOLVER is launched.

F3 — Global configuration

These are yours, not the project's. They live in EVOLVER.SET, written next to the program the first time EVOLVER runs, so opening someone else's .EVO can no longer turn your console off or flip your screen to dark. Older projects still carry the old fields; they are ignored.

DARK MODE inverts the whole screen at once, highlights included, with no redraw. Quitting always gives the desktop back in its own colours.

AUTO-SAVE does nothing until you have saved the project once — it needs somewhere to write. Until then the row shows an asterisk, as in 10 MIN *. It also never fires while the transport is moving: writing two megabytes through GEMDOS stops the screen and the keyboard for long enough to feel like a dropout, so if the timer comes due mid-take it waits and saves when you stop.

TEMPLATE stores your rig, not your music — the eight tracks with their names, MIDI channels, lane voicings, CC assignments and LFOs, plus tempo and swing. No patterns, no notes. Press → on the row to capture whatever is loaded now; from then on EVOLVER starts with that setup instead of an empty one, and ALT+N gives you a fresh project on the same rig. Press ← to clear it. If LOAD LAST is on it wins, because reopening what you were working on is the more specific intent.

DEBUG LOG is for finding out what happened when something went wrong — a note that would not stop, above all. On by default. Every launch starts a new file, LOGS\EVO_0001.LOG, EVO_0002.LOG and so on, in a LOGS folder next to the program; the newest three are kept and older ones are deleted. The date and time are on the first line of the file.

It records every note and controller that came in, everything soft-thru sent on, the keys you pressed, play and stop, and the error counters from the F7 page. Notes the sequencer plays itself are not in it. ALT+P adds a summary of which notes were never released, so if a note hangs: press ALT+P, stop, and wait a few seconds.

Nothing is written while you play. A disk write would stall the program for long enough to lose incoming MIDI, so events are held in memory and written when the transport is stopped and you have touched nothing for three seconds, and when you quit. If the row shows NO DISK, the folder could not be written and nothing is being logged.

F4 — Playback behaviour

FOLLOW PLAY matters once a pattern is longer than the sixteen rows the editor shows. With it on, the window jumps a whole block at a time as the playhead crosses 16, 32 and 48, and back to the first block when the pattern loops — the rows stay where they are and only the block changes, which is far easier to read at speed than a grid that creeps. On by default.

METRO SOUND decides when the click is heard. ON clicks during a count-in and on every beat while the metronome (CTRL+M) is on. COUNT-IN clicks during the count-in only. OFF is silent, and the * in the header still flashes. The first beat of a bar is a higher click. Changing the row plays one click so you can hear it. While EVOLVER runs, the ST's own key click is switched off so it cannot be mistaken for the metronome; it comes back when you quit.

The three retrig switches. They apply to every retrig you play.

RETRIG VEL: DECAY is worth turning on early — flat retrigs sound like a machine stuttering, decaying ones sound like a drummer. DECAY fades the roll down to roughly a quarter of the velocity you set, spread evenly over however many repeats there are, so a 2x and an 8x both end up somewhere useful. The first hit always goes out at the step's own VELOCITY; the fade starts after it.

RETRIG SWING: OBEY makes the repeats groove with the pattern instead of running straight through it — the odd-numbered hits sit late by the same proportion your SWING displaces the off-beats. At SWING:50 there is nothing to obey and the two settings sound identical, so this only matters on a swung pattern. Very high swing values are held back a little inside a roll: pushing a repeat a whole interval late would just stack it on the next one.

RETRIG MODE decides what happens on a pattern whose SCL is not 1x. SUB-TICK divides the step you can see, so 4x is four hits per step whether the step is long or short — this is what you almost always want and it is the default. EXACT holds the speed fixed instead: 4x stays at the speed it would run at 1x and simply fits more of them into a longer step, so a 4x pattern gets a machine-gun and a 1/2x pattern gets fewer hits. On a 1x pattern the two settings are identical, which is why projects made before this setting worked sound exactly as they did.

F7 — MIDI bus / debug

Where you look when something is wrong. It is a tool for chasing problems rather than for making music, so it is off until you turn on DEBUG MIDI in F3; until then F7 just says so on the console line.

RUN STATUS      ON
MIDI CLOCK      ON PLAY
BUS  TX0    RX0    ER0    TK0    OB0
LATE TICKS      0
TEMPO LOCK      ON
NOTES THINNED   0
IKBD TRACE      OFF
LOAD WK 35   PK 99   AV 13   WA 23   WB 0

All zeros is what you want. SPACE clears them.

LOAD, and the percentage in the bottom-right corner. How much of the machine the arrangement is asking for, counted while it plays. WK is the work of the busiest step in the last beat — every note voice, chord voice, arp hit and retrig hit the step asks for, plus the automation lanes running — against what the engine can do in one step at this tempo. The scale is set so that 100 is where notes start to be thinned: an empty project reads 0, eight dense tracks at 120 BPM read about 30, and the number rises as you add. WA and WB are the share of what each MIDI cable can carry, which automation fills long before notes do, and a cable past 100 drops notes late just as surely as a full engine does. PK and AV are the engine's measured time, the longest tick and the average share of the beat, for when something is wrong rather than merely busy. The corner shows the highest of WK, WA and WB, is blank while the transport is stopped, and turns inverse past 100 — the zone where notes start to thin or the cable starts dropping controller changes. Below 100 you are safe; the number tells you how much room is left before you are not.

IKBD TRACE is for one question: when the typing keyboard (ALT+K) misses a key, did the keyboard send it at all? With it on, every byte the keyboard sends while ALT+K holds the keyboard is written to the debug log as an IKBD line, tagged with what EVOLVER took it for: a note, a key, a modifier, a release, or a mouse packet. It is off at startup and never saved. The !KOVR line next to it counts keyboard bytes the ST's own serial chip lost before EVOLVER could read them.

TEMPO LOCK — the tempo is not allowed to be wrong

Ask for more than 8 MHz and one MIDI cable can carry and something has to give. Without tempo lock what gives is time: the engine falls behind, ticks are discarded, and each discarded tick takes a step advance and a clock byte with it. Eight dense tracks asking for 240 BPM played 155, and — this is the part that matters — every drum machine and delay slaved to EVOLVER's clock slowed down too. The whole timeline was wrong, not just crowded.

With tempo lock on, what gives is density. The clock keeps its exact rate and the sequencer declines to schedule some of the notes it cannot deliver. The same eight tracks now play 179.9 BPM at a 180 setting, and 239.5 at 240.

What this means in practice:

• Sparse and ordinary projects never notice. Tempo lock only engages when the engine is genuinely not repaying its backlog, not merely when a step is briefly busy. Every project that kept time before still plays note for note identically.
• Notes disappear before the tempo does. On a step too dense to play you lose individual notes — typically from the crowded downbeats where every track lands at once.
• Your low-numbered tracks survive. The budget is spent in track then lane order, so put the parts that matter on tracks 1 and 2 and they will be the last to go.
• Nothing is ever left hanging. A thinned note is refused before a voice is allocated, so there is no Note-On on the wire and no Note-Off is owed.
• Watch NOTES THINNED. If it is climbing, your pattern is asking for more than the machine can play. That is useful information: thin it yourself, move half the tracks to MIDI OUT B, or drop the tempo.

Turn it off and you get the old behaviour — the tempo sags instead. That is occasionally what you want, if you would rather hear every note and fix the speed later.

TK climbing with tempo lock off means you have asked for more than 8 MHz can deliver on one tick — usually a lot of simultaneous arps and retrigs.

You also get told once. The first time tempo lock drops a note after you press play, the log line says so. Once per run — it will not nag.

How many arps can I actually run?

Arps are the one feature dense enough to reach the limit, because they do not just cost time, they make notes — and notes are what runs out.

The table is the most arp lanes that keep the tempo exact, measured with a deliberately brutal backing: eight tracks with every remaining lane playing sixteenths. Real music is far thinner than that, so treat these as the floor you are guaranteed, not the most you will get.

In one sentence: eight arp lanes is safe anywhere from 40 to 180 BPM at any division except 1/32, where it becomes four once you are past about 140. Below 120 the question effectively does not arise.

Two things that are not obvious:

Spread arps across tracks rather than stacking them. Eight 1/32 lanes spread one-per-track hold better than the same eight crowded onto four tracks. Each track has its own pool of voices, and piling two fast arps onto one track makes that pool start stealing from itself.

At high tempo, reach for 2x. Eight busy tracks at 240 BPM on 1x drop the odd tick; the same material written on 2x patterns runs perfectly. See the SCL section — it is the biggest single lever you have when you are near the edge.

F8 — Notepad

64 lines of 38 columns, scrolling, saved inside the project. Arrow keys move, typing types, BACKSPACE deletes, and running past the end of a line wraps you onto the next one.

Set lists, patch numbers, what channel the JV is on, the thing you will definitely remember tomorrow and will not.

18The key commands

These are the defaults. Anything except ESC, F1 and the keys inside an open field can be rebound in the F1 keyboard map.

Everywhere

The F pages open from the editor too. ESC takes you back to the editor, even if you switched between pages in the meantime.

SESSION view

EDITOR view - grid

On the header row (↑ past the lane names): ← → move between cells (SHIFT to the first / last), SPACE steps the cell up, SHIFT+SPACE steps it down, ENTER opens it for typing, ↓ or TAB goes back down.

EDITOR view — STEP and AUTO sidebars

While editing a note in the grid

19Specifications

Capacity

Timing

On tempo accuracy. The MFP's counter is 8 bits, so most tempos are not exactly reachable: 150 BPM wants 480 Hz and the nearest integer divider gives 481.88, which is 150.59 BPM. A permanent 0.4 % error is nothing on its own and everything when a delay is synced to it — the phase walks all the way round in a couple of bars. So the divider alternates between two values in exactly the ratio that makes the average period correct, carrying the remainder as a fraction rather than rounding it away. Every tempo from 20 to 240 BPM is held to better than 0.002 BPM.

The sequencer runs on MFP Timer A at 192 PPQN. A separate Timer B interrupt at 3200 Hz drains the MIDI transmit queue, and the sequencer interrupt deliberately drops its priority so the transmitter can pre-empt it. That is why timing stays tight when a lot of notes land on one tick. 3200 Hz is one tick per MIDI byte time plus a little slack - the drain used to run half as fast again, and every spare tick cost the price of an interrupt to discover it had nothing to send.

A tick that arrives while the previous one is still running is banked, not dropped, because a dropped tick takes a step advance and a clock byte with it and never gives them back - that is tempo lost, not jitter. The engine will carry up to two steps' worth of debt and pay it back in the idle ticks that follow, which is what lets eight dense tracks hold their exact tempo across the burst of work every step boundary causes.

MIDI clock is emitted at the top of the tick, before any scheduling work, so clock jitter is bounded by interrupt latency rather than by however much music that particular tick happened to contain.

Sent MIDI

Note On, Note Off, Control Change, Program Change, Bank Select, Clock (0xF8), Start (0xFA), Stop (0xFC). Clock, Start, Continue and Stop are also received, for external sync. Running status is used on the wire and reset whenever the transport changes, so a receiver never has to guess.

20When something is wrong

No sound at all. Check CH on the track header against what your synth is listening on. Then check the lane's own MIDI CH — a lane can be routed away from the track. Then check the track is not muted ([M] in SESSION) and that nothing else is soloed.

Notes hang. Stop and start the transport — that sends an all-notes-off. If it keeps happening, look at F7: TX climbing means the bus is saturated. The debug log in the LOGS folder shows whether the Note-Off ever arrived — see F3.

The note names do not match what my synth calls them. EVOLVER names middle C (MIDI 60) C3, matching Roland, Akai and Waldorf. Gear that calls it C4 or C5 is playing the same pitch under a different name — the MIDI note numbers going down the wire are identical. To change the name, set MIDDLE C on the F2 page.

The tempo drifts against another machine. Decide who is master. F2 → SYNC CLOCK. If EVOLVER is INTERNAL it sends clock; if it is EXTERNAL it follows. Two masters will always fight.

TK on F7 keeps going up. Late ticks. The sequencer could not finish a tick's work before the next one arrived. Almost always too many simultaneous arps or retrigs. Thin out the densest step; check whether a RETRIG:8x is doing anything you would miss.

A note is ringing and will not stop. ALT+P — MIDI panic. It stops the transport, sends a Note-Off for every voice EVOLVER started, and then sweeps Sustain-Off and All-Notes-Off across every channel it has used, which also catches notes it never knew about (soft thru, a synth left latched, a cable pulled mid-note). It works even while a field is open for editing, because that is exactly when you need it.

A pattern only plays half of itself. Check the sequence row's LENGTH. It is counted in bars, so if the row is shorter than the pattern the row wins and cuts it off — a 32-step pattern needs 2 BARS to play out. That is what INF is for while you are writing.

A 2/3x or 4/3x pattern behaves oddly at a row boundary. A triplet scale needs three passes to line back up with the grid, and the row ends on a bar whether or not the pattern has got there. Give the row 3 BARS, or a multiple of three, and the two agree.

I quantized and hated it. Press UNDO — one press takes the whole SHIFT+Q back. To hear what a setting does before committing the pattern, quantize one step with Q first.

A key does nothing, or does the wrong thing. It may have been rebound. F1 shows what every key does right now. SHIFT+DEL in that map puts every key back to its default, and so does deleting EVOLVER.SET.

SHIFT+ALT+↓ does not select notes. Your TOS keeps that combination for the mouse pointer and EVOLVER never sees it. Use CTRL+↓, or bind something else in F1.

Saving fails. Check the disk is not write-protected and that you are not out of space. The loader will never half-apply a file: if a load fails, nothing in memory is touched.