Release Auris Studio v0.3.0 · uthree/auris-studio

Downloads

File	What it holds
`…-macos-universal.tar.gz`	`Auris Studio.app` and the `auris` command line tool — Apple Silicon and Intel in one binary
`…-windows-x86_64.zip`	`auris-studio.exe` and `auris.exe`
`…-linux-x86_64.tar.gz`	the `auris` command line tool only

Every archive carries MuseScore General, a General MIDI SoundFont under the MIT
licence, in a SoundFonts directory — which is most of the download size and all of the
instruments beyond the four built in. On macOS it lives inside the bundle, so dragging
Auris Studio.app to /Applications takes it along.

None of it is code-signed. macOS will refuse the first launch and say the developer
cannot be verified: open it from the right-click menu once, or run
xattr -dr com.apple.quarantine "Auris Studio.app". Windows SmartScreen wants
More info → Run anyway.

Auris Studio is at 0.x, where nothing is stable: the project format, the configuration
files and every public API may change in any release, with no migration.

Plugins somebody else wrote

Auris hosts CLAP plugins, instruments and effects alike. They are found in the platform's own
search paths, listed in the browser under the built-ins as one branch per file, and placed on a
track or into a chain the way anything else is. The graph cannot tell a hosted plugin from a
biquad, so automation, presets and the parameter panel work on one exactly as they do on ours.
A file's branch is shut until you open it, and that is not about size: opening one loads it,
and loading a plugin means running somebody else's code in this process. That has to be something
a person did, rather than something a panel did on their behalf while they were looking for a
reverb.
A plugin opens its own window, floating above the application and told which window to stay
above. Plugins that draw into a window rather than making one — anything built on JUCE, which is
most of them — are lent a plain native window to draw into, because a host with nothing to give
them shows nothing at all.
The parameters are asked of the plugin, not guessed from the document. A preset loaded
inside it, a knob turned in its own window, its own MIDI mapping: all of them move parameters
the session never hears about. The document is asked first and the plugin second, so the panel
beside a plugin's window agrees with the window.
A plugin is sent the note dialect it declares — CLAP's own or MIDI, and the better half of
each from one that speaks both. One that speaks neither gets no notes, rather than events sent
into a void.
Where else to look is in the browser, at the foot of the plugin list: point at a .clap or
at a folder holding a hundred of them, and it is remembered. A plugin built in a working tree or
kept on an external disk was previously unreachable however plainly it could be pointed at.

The computer keyboard is an instrument

a to ; is a piano — Logic and GarageBand's layout key for key, including the keys that
look arbitrary, because a layout a hand already knows is the whole point and one that is nearly
the same is worse than one that is plainly different. 1 and 2 bend, 3 to 8 are the
modulation wheel, z and x move the octave, c and v the velocity, and Tab sustains.
⌘K switches it on, and has to carry a modifier: a bare letter could not switch off a keyboard
that plays nearly every bare letter.
The keyboard is drawn while it is on, so which octave the hands are in, how hard they are
striking and where the wheel was left are on screen instead of in your head. Every control lights
while it is in force, and the bar across the top says where those seventeen semitones sit on the
whole of MIDI.

Audio follows the tempo

A recording can be stretched to the piece instead of being left behind by it. Playing a file
faster is a resampling away and takes the pitch with it; this is WSOLA, which lays overlapping
windows down at a new spacing so every period inside one keeps its length and only the number of
them per second changes.
Per clip, from its menu. A clip knows what tempo it was recorded at and whether it should
follow the piece's, and everything that asks how long it is asks what it plays as rather than
what was stored — so the arrangement and the renderer come from one number.
A following clip says so on its face: a pill at the end of its name bar reading the stretch
as a percentage of the recording. The number rather than a mark, because 100 % is a clip being
played untouched and 150 % is one being pushed half again as long, and only the second is a
reason to go and listen closely.
Cutting one does not change how it sounds. A split or a front trim writes down the tempo the
clip was anchored to, so two halves of a take the far side of a tempo change still play as one
thing.

A curve on any parameter, and a lane on any controller

Right-clicking a control offers automation on it — a mixer fader, a send level, a plugin's
row in the inspector. The document has always held those lanes and the engine has always played
them; the track menu could only ever name a track's own fader and pan, so a lane on anything else
could be written by hand and never edited.
A lane slides or steps, and either can be changed afterwards. The shape used to be guessed
from the parameter when the lane was made, and the guess was final — a fader meant to drop on the
bar line rather than slide into it had no way to say so.
A clip carries any of the hundred and twenty-eight controllers, not the wheel alone. The
piano roll opens a strip for whichever ones you ask for, stacked in number order and remembered
in the layout — an expression pedal, a breath controller or a sustain pedal now has somewhere to
be written down.

The export can be shaped, and called off

Depth, rate and dither are settings rather than 24-bit at the project's rate every time.
auris export has had the flags since the exporter was written and the window passed defaults;
delivering a 16-bit master meant leaving the application.
A bounce can be stopped. Export is the longest thing this application does and the overlay
over it had one button, which appeared only once the render was over. A cancelled export is a
third outcome rather than a failure: the bar stops where it got to and the line says what was
written.

The window opens where you left it

Its place and size are remembered across launches. A DAW is arranged around a screen — pushed
to one side of a second monitor, sized so the arrangement and the browser both fit — and doing
that again every session is a tax on the thing the application is opened for. A remembered
rectangle that no longer overlaps any display is ignored rather than restored somewhere no
pointer can reach.
The projects opened lately are on the File menu, ten deep, written the moment one is opened
or saved under a name rather than on the way out: a recent list is worth most exactly when the
last session ended badly.
auris-studio Song/Song.auris opens that song, and so does double-clicking a .auris file
with the application registered against it. The window used to ignore its argument.
Help → About says which build this is.

A meter says what already happened

Clipping latches. A meter falls at 20 dB per second, so a single block over full scale is
most of a decibel down by the next repaint and a clip nobody saw is a clip that was not reported.
The latch is kept where every block is seen — the audio thread — and stays lit until it is
cleared by clicking the master's meter.
The input meter moves whenever the device is open, not only during a take. Setting a level is
what somebody does before pressing Record, and a meter that appeared once the take began
arrived too late to be used for it.
A take has a clock on it, and says while it is going wrong that it is. How long it has run,
frames the disk could not keep up with, a device that has disappeared — all three used to be
visible only in the report after Stop, which is the wrong moment for every one of them.

Finding things, and typing into them

The browser has a search field. It holds every built-in instrument and effect, every .clap
on the machine and every sound in every imported font — a General MIDI bank is a hundred and
twenty-eight of them — and the only way to a name was to open the right branch and scroll.
Every panel that scrolls says where you are in it. A bar appears along the edge of the
browser, the inspector, the log, the lane column and the mixer's strips the moment there is more
than fits, and takes no room at all while everything does. Pressing its track jumps there.
Shift makes a drag five times finer, and a value can simply be typed. A full sweep of a
slider is 220 pixels, which on a cutoff running 20 Hz to 20 kHz is about a hundred hertz a pixel
at the bottom — fine enough to find a filter by ear and far too coarse to land on a number.
Double-clicking a track's name renames it, on the header and on the mixer strip both. It was
a menu row and nothing else, which is how a project ends up with eight tracks called Audio 1.
The arrow keys move the selection, both keys labelled Delete delete, menus show which way their
switches are set and which rows can do nothing, and the unlabelled buttons say what they are and
which key also works them.
Text fields answer the same editing keys everywhere — backspace, the caret keys, Select All, the
clipboard — because there is now one table for them rather than four that had drifted apart. An
IME composes into all of them.

Effects can be dragged into order

Take hold of an effect's name and move it. The chain rearranges as the pointer travels, in
the inspector and on the mixer alike, and the whole drag is one undo step. Reordering used to be
a chevron clicked once per position, or a menu row chosen again and again.
Every strip ends in an empty slot that adds an effect. A track's strip in the mixer had no
way to add one at all — the answer was a right-click on empty space — while the master's had a
button above its chain instead of a slot at the end of it.

Importing does not stop the window

A file is read on a worker thread. A two-hundred-megabyte SoundFont, or an audio file being
decoded and resampled, used to be read on the thread that draws: the status line said which file
it was and then nothing answered until it was done, which is a freeze with a caption. Playback
and everything else now carry on while it happens.
Files dropped together are read one at a time, so a folder of takes does not arrive in memory all
at once.

Fixes worth naming

A held note released while the pointer was over another window stops sounding. A release nobody
was listening for used to leave it on.
Playing the same pitch again cuts the first one, and a voice stolen for a new note is the one
that has been sounding longest rather than the newest.
Unison no longer stacks the chiptune past full scale, and a narrow pulse stays audible at the top
of the keyboard.
A cut no longer changes how a clip sounds, and quitting during a take no longer loses it.
Changing the audio device while a take is running is refused rather than attempted.
Undo steps through a gesture only once the gesture has finished.
A project folder is recognised through a difference of case, and Save As points an asset back
outside the folder when it cannot copy it in.

One bad bar no longer costs the whole take

Punch recording. Mark a stretch from the ruler's menu — or take the cycle region wholesale
with Punch Over Cycle Region — switch it on with the transport's punch button or ⌘P, and a
take keeps only what falls inside it. The region is washed over the timeline in red while it is
on, beside the cycle's own wash and distinguished from it by colour, because they answer two
questions about the same bars: what is played again, and what is written down.
The transport rolls out of the take by itself at the punch-out — the one part of punching
nobody can do by hand with an instrument in both. It watches for the playhead leaving the
region rather than passing the punch-out, because under a cycle it never passes it.
A punched take removes what it lands on, on its own track and only where the new clip
covers, in the same Undo step. A clip spanning the region comes back as two. Recording without
punch cannot do this and does not: nothing knows where an ordinary take will end until it ends.
Record is still pressed by hand. Punch decides what a take keeps, not when one begins.
The file holds the whole take, not the trim, so a punch set to the wrong bar has not thrown
away what was played. A take that missed the region entirely says so — a different sentence from
an empty take, which would send somebody to check a cable that is fine.

You can hear yourself now

The I button on an audio track plays the live input through it — or U, or Transport → Input
Monitoring. It joins the mix where the track's own material does: through the effects, the fader,
the pan and wherever the track is routed. A singer hears themselves through the reverb they are
about to be recorded into, and a muted track stays silent.
It works with the transport stopped and without a take running, because setting a level is
what somebody does before pressing Record. Recording and monitoring are independent switches on
one device.
What it costs is on the status line every time it is switched on, not once in a dialog:
software monitoring adds latency and an interface's own direct monitoring does not. Roughly 32 ms
at a 512-frame block, on top of what the hardware costs. Use one or the other — both at once is
hearing yourself twice, a few milliseconds apart.
A monitor that breaks up says how many times. The input and output clocks drift, and once the
gap stops being usable the monitor jumps to the live edge rather than replaying what you have
already heard. A handful over a session is the clocks; a stream of them is a block size that is
too small, and Settings → Audio is where that lives.
The input meter now moves whenever the device is open rather than only during a take — a meter
that appeared after the take began arrived too late to set a level with.
Track headers are twenty pixels wider by default, for the fourth button. A column you have
already dragged keeps the width you gave it.

The project saves itself

A project with a folder is written back over itself about every thirty seconds, when
something has changed and no drag is part way through. Nothing is announced — the unsaved mark in
the title bar going out is the feedback, and a status line that says "saved" twice a minute is
one that never holds anything else. A save that fails is reported every time.
It never invents a place to save. A document that has never been saved has no folder, and
choosing one on somebody's behalf puts their song where they did not put it. That first save is
still a question — but pressing Record on an unsaved project now asks it, rather than
refusing with "recording needs a project folder". The answer to a dead end is a dialog.
What it costs is written down rather than glossed over: this writes the real file, not a recovery
copy, so closing without saving stops being a way to undo an afternoon. Undo still is, while
the window is open. Settings → General → Autosave turns it off.

Audio tracks can be recorded onto

TrackKind::Audio has said "Recorded or imported audio" since the beginning, and only half of
it was true. Nothing in the workspace had ever opened an input device. Now: click an audio
track, press Record in the transport (or R), play, and stop. The take lands as a clip where
the playhead was.
The take goes where you are looking. The selected audio track is the target, and its R
button is outlined to say so before anything is pressed — arming first was a button press that
said what the selection already said. Filling that button in overrides the selection, which is
the one thing selecting cannot say: record the vocal while you read the drum part. Clicking it
off hands the aim back.
A take is written as it happens, straight into the project folder's Audio/, by a thread of
its own — not on the UI thread, where a dialog that blocked for a second would cost the take a
second of audio. Takes are 32-bit float, and that is not a setting: every integer depth is a
decision about how much of a performance to throw away before anybody has heard it, and float
cannot clip.
Recording needs a saved project, and says so rather than inventing a temporary directory.
Every other asset can sit outside the folder until a save picks it up; a take has to be written
the moment it starts, and somewhere the machine tidies up is not that place.
Where the take lands is stamped by the audio callback, not by the button. The first block to
arrive reads the playhead, so a take begins at the frame it actually began at rather than one
callback earlier. The input and output run on separate clocks and nothing here corrects for the
drift between them: a take a few frames long by the end of an hour can be seen and nudged, and
one that has been quietly resampled cannot.
Frames lost to a slow disk are counted and reported. A hole moves everything after it
earlier, which is a thing to be told about now rather than to find in a mix next week.
The take is named after its track and numbered from the first gap — Vocals 3.wav, not a
timestamp — because the folder is something people read a year later.
The input device is chosen in Settings → Audio, and choosing one does not stop playback:
it is opened per take, so it was never the output stream's business.
Not in this pass: monitoring. You hear the song you are playing along to, not yourself
through Auris. An interface's own direct monitoring covers it in the meantime.

A SoundFont has an envelope now

The sampler carries the same four controls the built-in instruments do — attack, decay,
sustain, release — and the same draggable graph above them. They shape the font rather than
replace it: a piano's hammer is still a hammer, and now you can fade it in, hold it under its own
decay, or let it ring long after the key has gone.
It is off until you switch it on, with an Envelope toggle and nothing else. While it is off
the four sliders do nothing at all — the mechanism is not neutral, it is skipped, and the font
plays exactly as it is written.
Switching it on costs something, and the window says so. A shaped note needs a MIDI channel
to itself, because channel expression is the only per-note gain the library exposes: polyphony
drops to fifteen notes, and a drum kit's choke groups stop working — an open hi-hat is no longer
cut off by a closed one. A caution strip sits under the graph for as long as the switch is on,
because missing polyphony shows up as "the top note of my chord dropped out", which is a symptom
that gets blamed on anything but the switch that caused it. Turning it back off restores
everything at once, mid-note if need be.
Once it is on, the envelope owns the note. A release of zero means the note stops when the key
does, and the graph draws exactly that — a vertical drop with no tail. The default is a fifth of
a second, which is close to what a General MIDI patch already does.
A shaped note at full level is exactly as loud as an unshaped one, and the envelope is
square-rooted on its way into the channel because the format squares it again — the same
correction the sampler already made for velocity, and for the same reason. A release stated as
half a second is half a second.
The envelope generator moved from auris-synth to auris-dsp, so both instrument crates fade a
note with the same code. Two definitions of what an attack of five milliseconds sounds like would
have agreed right up until one of them was corrected.
The envelope graph now counts towards the window's height the way the equalizer's curve does, so
a plugin that has one does not lose sliders to it.

The equalizer has a curve you can grab

The window drew the spectrum going in and left you to aim at it with twenty-four sliders. It now
draws the response the equalizer is making, over that spectrum, with a node on each band that
is switched in. Drag a node: sideways is the frequency, up and down is the gain, and both at once
is the pair you were thinking about when you reached for it.
The wheel over a node narrows the band. Q is the third number a band has and there is nowhere
on a two-axis graph to put it; the wheel is where every equalizer with a curve has put it, and it
costs no screen — the graph sits outside the scrolling list, so the wheel over it meant nothing
before.
A high-pass or low-pass node moves sideways only, and its node sits on the centre line: those
shapes have a corner, not a level, and the gain a slider would let you set is a number the audio
never reads.
A band that is switched off has no node and is not on the curve. The toggle in the list below
is what switches it in — a handle floating over a shape it has no part in is a control that lies.
The curve is drawn by the same crate that makes the audio, from the same band table, at the rate
the engine is running at. A frontend that drew it itself would be a second implementation of the
cookbook filters, and the two would agree until the day one of them was corrected.
The sliders stay underneath. A graph is how a shape is found and a number is how it is said —
6 dB is a value you type, not a pixel you aim at — and neither answers for the other.
The equalizer's window is drawn wider, and the graph does not count against the height at which
the slider list starts scrolling: the picture would otherwise have cost a third of the controls.

A plugin window is as tall as what is in it

The last control was cut through the middle — a compressor showed six and a half rows. The
window's height was worked out by counting the rows and multiplying, which left out the four
pixels between each pair and the padding around them, and it came out twenty-seven pixels short.
That number is now a ceiling rather than a size. The body sizes itself to the rows it holds and
stops at the ceiling, so a figure that is too small can only nudge where the window opens instead
of cutting a control in half.

The plugin window no longer lets the pointer through

A press over a plugin's controls was reaching whatever was behind the window as well. gpui's
hit test walks every box under the pointer until one blocks, and the floating editor blocked
nothing — so dragging a slider over the mixer moved the slider and the fader underneath it.
Dismissing a right-click menu had the same fault: the click that shut the menu also landed on the
arrangement behind it and moved the playhead to wherever the pointer happened to be.

A composed song is re-takeable one clip at a time

Every clip Compose a Song writes now carries the recipe that describes it, so the commands a
clip from Write a Part Here… has always answered to — Another Take, Write It Again, the dial
panel, Keep This One — work on a whole composed piece. Right-click the chorus bass, ask for
another take, and the chorus bass changes while the verse bass and the chorus drums stay where
they are.
That one field is the entire feature. Nothing downstream had to learn what a composed song is:
the menu, the inspector panel and the painter's "this was written" mark all read
Session::clip_recipe and nothing else, so they all started working at once.
The recipe is read off the part as that section played it, not off the roster — a chorus that
patched the bass an octave up produces a clip whose recipe says so.
Each clip gets a seed of its own, a stream of the song's named by the part and the stretch: it is
reproducible from the specification, different for every clip, and six digits, because a seed is a
number a person reads off a panel and types back in.
A recipe describes a clip; it does not reproduce it. A whole song is planned with things one
clip has no room for — how far a repeated section departs from its first playing, what leads into
what, the arch of intensity across the form — so writing a composed clip again hands it to the
one-clip writer, which knows the document's chords and not the plan. The part, the register, the
density, the chords and the feel all hold; the phrase moves. The same is true of dragging its
edge, which is the same request. Keep This One is how a take stops being at the mercy of either.
The alternative was making the composer write its clips through the one-clip writer so the two
agreed exactly. That trades the composer's output — section variation, the joins between
sections, the intensity arch — for a button's arithmetic, and the output is the product.

A clip can be looped

Drag the right edge of a clip's name bar, or Loop Clip on its right-click menu, on the Edit
menu, or L. The clip goes on saying itself for as long as the edge is pulled, in faded
repeats divided by a hairline. Dragging back over the clip's own end stops it — the same gesture
run the other way, rather than a second thing to know about.
The name bar's edge, and only it. The edge below still resizes, so how long the phrase is and
how many times it is played stay two separate things you can change. On a clip nobody has looped
yet the two sit on the same pixel, which is what makes the gesture findable at all.
A loop is a length rather than a count, so the last repeat is cut off wherever the edge was
let go. That is what makes the drag continuous, and it means a loop can stop half way through a
bar because that is where the next clip starts.
Both kinds of clip. On audio the fades stay on the clip's own two edges and the joins between
repeats run flat: a fade-out at the end of every pass would pump once a bar.
The repeats are flattened when the graph is built, so the audio thread never learns that a
clip repeats — it plays a list it cannot tell from a song somebody duplicated by hand. Exports
carry the repeats too, WAV and MIDI both, since a MIDI file has no notion of a region that
repeats and the notes are the only honest way to write one down.
Splitting a looped clip leaves neither half looping, because the repeats were of a block that no
longer exists. Duplicating one puts the copy past the repeats rather than on top of them.
FORMAT_VERSION is 10. The field carries backwards on a default, which normally does not move
the number — but a version 9 build would open a song whose drum loop runs thirty-two bars, play
the one bar, and write that back on the next save with the other thirty-one gone. Refusing at the
door is the only honest answer.

Notes can be quantised

Quantise Starts (Q), Quantise Lengths, and Quantise Both, on the piano roll's right-click menu
and on the Edit menu. Nothing could put a played part back on the grid after the fact; snapping
applied while something was being dragged and not one moment later.
Three commands rather than one with a setting, because the two numbers a note has are separately
wrong. A part played a shade ahead of the beat wants its ragged lengths evened out and its feel
left alone, and doing both to a take that needed one is how it stops sounding like anybody played
it.
They snap to the division the grid button is showing, which is on screen above the notes being
moved: quantising to a value nobody can see is a jump with no explanation.
A length never rounds down to nothing. On a sixteenth grid a clipped grace note becomes a
sixteenth rather than silence — a note vanishing because it was played crisply is not a
tidying-up.
The status line says how many notes actually moved, which is the one thing worth knowing
afterwards: four out of twenty means the other sixteen were already where they should be.

There is a metronome

The button beside the cycle button, Transport → Metronome, or K. A click on every beat while
the transport rolls, an octave higher on the bar line. The application has had a tempo map, a
meter map and a bar ruler since it was written, and no way at all to hear any of them.
It clicks the beat you feel rather than the one the meter is written in: a bar of 6/8 gets
two clicks, not six. Meter and tempo changes are both followed, so a piece that moves into 7/8
at bar nine has its accents move with it.
The click is laid over the mix — past the master fader, past the master mute, past the meters
— so it cannot be turned down by accident, it is audible with every strip muted, and switching it
on does not move a level meter. It never reaches an export: playback and an offline render
take the same code path in every other respect, and this is the one line that differs.
Stored with the project, like the cycle region, because whether a piece wants counting in is a
fact about the piece. Not an undo step, for the reason cycling is not: a practice pass is a run
of toggles, and those would push the edits the pass was checking off the end of the stack.

Cut, copy and paste

⌘X, ⌘C and ⌘V, meaning notes in the piano roll and clips in the arrangement — the same three
keys scoped to wherever the keyboard is, exactly as ⌘A and ⌘D already were. On the Edit menu in
pairs, and on the right-click menus of both surfaces. Duplicate has existed since the beginning
and only ever laid a copy down next to the original; there was no way to move material
anywhere else at all.
What is on the clipboard is a shape rather than a place. Notes keep the gaps between them; a
block of clips copied off four tracks lands on four consecutive tracks wherever you aim it, and
goes on doing so after the tracks it came from have been reordered or deleted, because it was
never holding those tracks' ids.
A paste lands at the playhead; Paste Here on an empty lane lands it under the pointer, which is
the one place a paste has a position of its own. What arrives becomes the selection. A paste that
fits nowhere — the wrong kind of track, or rows running off the bottom of the list — lands what
it can rather than failing whole.
Its own clipboard, not the system's. Nothing here reaches another application and nothing copied
in one arrives here.

A melody can be given an accompaniment

Right-click a clip holding a tune → Accompany This Melody, or Compose → Accompany the Melody.
Its key is worked out and written into the harmony lane, one chord per bar is written under it,
and bass, chords and drums are added as tracks beside it. The melody is not touched. One undo
step for the lot.
The composer could write a whole song from a specification and could write one part from chords
that were already there. What it could not do is the thing a person actually has in front of
them: sixteen bars they played, and no idea what goes underneath.
The key comes from correlating what the melody plays — weighted by note length and by how hard
each is struck — against Krumhansl and Kessler's probe-tone profiles. Each bar takes whichever of
the key's seven triads accounts for most of it, with a thumb on the scale for what the bar
arrives on and a little inertia so the progression does not change on every coin toss. Nothing
draws a random number, so changing one note and pressing it again says what that note was doing.
It will be wrong sometimes, and it is built to be argued with. A melody is one voice: a tune
in A minor and a tune in C major play the same notes, and a bar of passing notes reads as the
chord it passes through. So everything it guessed goes into the harmony lane where it can be seen
and retyped, and every part it writes carries a recipe — correct a chord, press Write It Again,
and the band follows.
Each part gets a fitting General MIDI sound where the shipped font is installed, and the built-in
oscillators where it is not, which the status line says.

The library list is readable

Every row carries a colour mark, and the marks line up into a column down the panel. A plugin
wears its category's colour and so does the heading above it. A font's sounds are banded eight at
a time — General MIDI's own sixteen families, Piano, Organ, Guitar, Bass — which is what turns a
hundred and twenty-eight rows of small grey text into something an eye can find a place in. The
percussion bank is one band rather than sixteen: its patches are kits, not programs.
Nothing depends on the colour. Every coloured row still has its name and its number beside the
mark, the mark is never the text, and the hues are spread as far apart as their count allows and
then walked outwards until each clears 3:1 against the surface it sits on — in all four schemes,
which is checked rather than eyeballed. A fixed lightness put one group in ten at 2.7:1 on
Midnight, because lightness is not luminance and the gap between them is widest across the hues.

A note can be placed without holding anything

Create can be a plain click. ⌘-click is Logic's, and it is still the default, but holding a
modifier to write a note is a thing you have to be told — and the first person to try this
without being told said so. The Pointer section of Settings now offers the bare click alongside
the three modifier gestures.
Choosing it moves the rubber band to ⇧-drag, and a click on empty arrangement then makes a clip
rather than moving the playhead. The settings page says both at the moment you choose it, and
they are why the modifier is still the default. ⇧ already means extend the selection on every
other press, so the gesture was there to be used rather than invented for the occasion.
Deleting cannot be a plain click, and is not offered. Creating on a bare click leaves
something you can see and undo; deleting on one would remove every note you reached for, and
would leave no gesture anywhere meaning "just this one".

Sixteen more commands you can put a key on

Mute, solo and duplicate for a track; duplicate, split-at-playhead and mute for a clip; select
all, duplicate, and transposition by a semitone or an octave for notes; add a bus. Every one of
them was already in a right-click menu and reachable from nowhere else, which meant that
working from the keyboard stopped at the point of actually editing anything.
A command can now ship with no key at all and still be in the list. Mute wants M, solo wants
S, and the mixer and the structure lane hold both; inventing ⌥⇧K so the row had something
would take that chord from whoever wanted it and bury the commands that earned their key. The
row is there with a dash on it, and one press puts your key on it.
⌘A and ⌘D mean the notes in the piano roll and the clips in the arrangement — the same key,
scoped to where the keyboard is, which is what the panel outline has been telling you all along.
⌥↑ and ⌥↓ transpose by a semitone, ⇧⌥↑ and ⇧⌥↓ by an octave, ⌥X splits a clip, ⌘B adds a bus.
The settings page groups them as Notes and Clip rather than as a second Edit
section, which is what a second run of the same group would have printed.

Composing has a menu

A Compose menu, holding the song sheet and the specification file. It was one row in the
middle of File, between Open Project and Save — and that row carried the label of the
specification file route while dispatching the song sheet, so the way in that needs no file
was announced as "Compose from Specification…" and the file route was in no menu at all.

The tune is a line rather than a walk

A third of every melodic interval the composer wrote used to be a fourth or wider. That is an
arpeggio's interval distribution, not a tune's, and it is why a composed melody sounded unnatural
while the accompaniment underneath it — which is a function of the chord and so is right or wrong
locally — sounded like players. It is now one in seven, against the one in five a corpus of real
melodies gives for leaps of any size.
The measurement, the literature it is read against, what each of the five rules is for and what
is still wrong are in auris_compose::melodic, which is a page of documentation and no code.
The constants in the melody writer are what it argues for; neither makes sense without the other.
What changed: the restated figure is joined to where the last bar left off instead of restarting
from its structural pitch — the single worst fault, and one nothing had chosen; the interval table
is the corpus distribution and has an entry for a repeated note, which it did not; the walk has a
memory, so a leap is filled in and a step tends to carry on; a dissonance left by a leap resolves;
and a phrase ends on a chord tone with a beat of air after it.
No chord and no note count moved in any of the four fingerprint fixtures, which is the report on
the change: the pieces are the same pieces with a singable line in them. Existing projects are
untouched — this writes new material and does not migrate old.

Compatibility

Project::FORMAT_VERSION is 14, from 4. Every document written by 0.2.0 opens with everything
in it; nothing written by this release opens in 0.2.0, which is what the number is for. Ten of
the bumps happened one at a time and each one's reason is written down beside the constant — the
short version is that automation, buses and sends, drum recipes, clip loops, per-controller
curves and tempo-following audio are all things an older build would have ignored on the way in
and written away on the next save.
A clip's modulation curve is now an entry under controller 1 in a map of controllers, and an
automation lane records the stable key of the parameter it drives beside the id that addresses
it. Both changed shape rather than gaining a sibling.
Session::import_audio and Session::import_soundfont still do the whole job, and each is now
also available in halves: decode_audio and read_soundfont read a file from any thread, and
Session::place_audio and Session::install_soundfont put what they read into the document from
the thread that owns it.
settings.json has grown the window's last rectangle, the projects opened lately, the extra
places to look for plugins, and the export's depth, rate and dither. layout.json has grown the
set of controller lanes the piano roll has open. Both are read with defaults, so an older file
opens and is written back complete.

Auris Studio v0.3.0