Auris Studio v0.9.0

Downloads

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

Every archive includes a Dictionary directory with the NAIST Japanese dictionary
(BSD-3-Clause, jpreprocess's build), used to read kanji lyrics and their pitch accent.
On macOS it lives inside the application bundle.

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.

---

Instruments and arrangements

• Play built-in physical instruments without downloading samples. Piano, acoustic and
  electric guitar, bass, bell, mallet, violin, clarinet, hammered dulcimer and tin whistle provide
  instrument-specific controls. Physical Choir adds wordless ensemble vowels, and the drum kit
  uses modeled percussion voices. Instrument visualizers show the relevant controls and motion.
• Compose with instrument-aware presets. Arrangements use physical instrument themes,
  developed sections, dedicated drum patterns and preset effect chains. The grand piano and
  other physical models gain calibrated responses and improved performance controls.
• Keep your own sounds. Save instrument settings as named user presets, organize them in
  the sound library and reuse them on other tracks.

Editing and desktop

• Switch between the timeline and a track grid. Monitor physical-instrument motion and
  stereo waveforms in a responsive grid, with track selection, mute and solo controls.
• Control piano-roll snapping more precisely. Smart and fixed grids, relative or absolute
  snapping, and temporary snap overrides support both aligned notes and intentional offsets.
  Toolbar customization and note preview controls make common editing actions easier to reach.
• Keep the selected object visible in the inspector. Track and clip context stays above
  scrollable settings, with collapsible sections, clearer hierarchy and corrected label
  truncation. macOS window behavior and collapsed picker labels are also improved.

Singing, files and rendering

• Use DiffSinger and LeapSinger voicebanks. DiffSinger runs acoustic and vocoder ONNX
  models, including supported variance predictors. LeapSinger setup exposes model paths and
  frame settings, with validation before rendering.
• Preserve imported MIDI expression. Controller and pitch-bend state before the first
  note carries into the imported clip, and sustain changes keep their authored timing.
• Protect files and cancel background work reliably. Saving over the current project
  detects external edits, and drum analysis workers honor cancellation. Mix normalization
  and encoded WAV checks improve rendered-audio handling.

Compatibility

• Projects continue to use format 31. Optional voice models are configured separately from
  the application download.
• Source builds require Rust 1.95 or newer. Workspace dependencies have been refreshed;
  Windows release builds continue to include ASIO support.

Auris Studio v0.8.0

Downloads

File	What it holds
…-macos-universal.tar.gz	Auris Studio.app, auris, and auris-mcp — Apple Silicon and Intel universal binaries
…-windows-x86_64.zip	auris-studio.exe, auris.exe, and auris-mcp.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. Beside it, a Dictionary directory holds the
NAIST Japanese dictionary (BSD-3-Clause, jpreprocess's build): what reads kanji
lyrics, and what gives a melody composed from lyrics the words' pitch accent to follow.
On macOS both live inside the bundle, so dragging Auris Studio.app to /Applications
takes them 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.

---

Composition and editing

• Build larger arrangements with clearer musical controls. The composer adds B and C
  sections, phrase-aware development, instrument participation controls and responsive progress.
  Mood, tonality and pace provide a simpler starting point, while bounded composition search can
  preview and adopt exact chord progressions before writing the song.
• Enter and shape richer harmony. Chord input accepts absolute names, Roman numerals, added
  tones, 6/9, eleventh and thirteenth qualities. Key-aware completions are coloured by scale
  degree, and accompaniment presets now share one density model across composition workflows.
• Edit notes and rhythms directly. Piano-roll selections can be moved, resized and edited as
  a group, with clearer drag readouts and Alt-drag duplication. Melodic and drum generators gain
  manual rhythm grids in resizable utility windows.

Agent workflow

• Work with an agent inside the desktop application. The embedded worker streams progress,
  supports cancellation and permission modes, compacts long conversations and keeps editable
  session history. It can compose through explicit track and note edits, inspect rendered audio
  and use the instruments that are currently available in the session.
• Use smaller, safer tool contracts. Live editing and MCP schemas provide bounded paging,
  compact responses, atomic track setup and note replacement, file-backed score input and
  actionable validation errors. Large reports and searches remain usable without unbounded model
  context or partial project edits.
• Use the agent panel comfortably at different sizes. Responsive controls, clearer status,
  corrected Markdown lists, improved focus handling and settings integration make conversations
  easier to manage in both narrow and wide layouts.

Audio and desktop

• Inspect audio in stereo and in time. The visualizer adds stereo spectrum monitoring, a
  time-domain oscilloscope and clearer monitoring controls. The piano roll can overlay performed
  notes while keeping source and performance views distinct and editable.
• Export through a dedicated dialog. WAV, FLAC and MP3 share one export workflow with saved
  settings. Track-list density is resizable, detachable panels use native utility windows, and
  dropdowns, theme colours and platform font fallbacks are more consistent.
• Configure singing voices from Settings. Voice connections and setup live with the other
  application preferences. VOICEVOX lyrics, short rests and tempo changes preserve note timing
  more reliably and report invalid notes in the editor.
• Map drum instruments manually. The drum workflow can analyze, audition and assign named
  lanes, retain ordered manual mappings and remap generated parts without rewriting unrelated
  notes.

Compatibility

• Projects use format 31, and this release opens format 31 only. Projects saved by v0.7.0
  use format 26 and cannot be opened here; projects saved by v0.8.0 cannot be opened in v0.7.0.
  No automatic migration is provided.
• Local Windows builds enable ASIO explicitly when required. Release builds continue to package
  their supported audio backends and the standard project resources.

Auris Studio v0.7.0

Downloads

File	What it holds
…-macos-universal.tar.gz	Auris Studio.app, auris, auris-mcp, and auris-agent — Apple Silicon and Intel universal binaries
…-windows-x86_64.zip	auris-studio.exe, auris.exe, auris-mcp.exe, and auris-agent.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. Beside it, a Dictionary directory holds the
NAIST Japanese dictionary (BSD-3-Clause, jpreprocess's build): what reads kanji
lyrics, and what gives a melody composed from lyrics the words' pitch accent to follow.
On macOS both live inside the bundle, so dragging Auris Studio.app to /Applications
takes them 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.

---

Composition and performance

• Shape the performance while keeping the written notes. New articulation, ghost-note,
  strumming, expression and groove controls change playback and MIDI export. Source and
  Performance tabs compare the editable score with its performed result. Keep the
  Performance makes that result editable in one undoable step.
• Add automatic pitch gestures. Scoops, falls, vibrato and melodic connections follow
  eligible solo notes while preserving hand-drawn bends. MIDI export carries the generated
  curves and their bend sensitivity, including tracks that share a MIDI channel. Song presets
  supply performance settings suited to their instruments, adjustable after generation.
• Compose looping background music. The new game-loop preset creates a sixteen-bar
  chiptune cycle. Loop endings work across styles, and Export Cycle warms instruments and
  effects before writing exactly one repetition.
• Compose songs with clearer lyric controls. Basic and detailed views separate everyday
  controls from the full arrangement. Voice and speaker selection, lyric-capacity feedback,
  repeated-verse matching and fixed-length vocal rhythms help lyrics fit the chosen form.
  Generated chord progressions follow section lengths and can connect half-bar changes.

Analysis and sound selection

• Review music analysis before applying it. The Analysis menu and results panel collect
  written-chord estimation, audio tempo/chord analysis and isolated-melody transcription.
  Accepted drafts become editable chords or notes; the original audio remains intact.
  Optional local ONNX models add instrument tagging and mixture transcription. These model
  weights are separate downloads; see docs/music-analysis-models.md for their requirements,
  including MuScriptor's noncommercial terms and per-use acknowledgement.
• Find related sounds on the Timbre Map. Browse, audition and compare built-in instruments
  and loaded SoundFont presets by their measured acoustic features, then adopt a sound on
  the selected track with Undo. The map requires no pretrained model or network service.
• Render tracks to audio and inspect the mix. Instrument, drum and singer tracks can be
  converted to audio in one undoable operation. Spectrograms now include rendered instrument,
  drum and singer tracks and a project-wide mix overview.

Singing and the desktop

• Keep VOICEVOX articulation when editing expression. Relative pitch and energy changes
  preserve the Engine's contour, unvoiced frames and phoneme balance. Japanese prolonged
  vowels, small-tsu closures and short timing edge cases are handled more consistently.
  The piano roll can show backend pitch alongside the host contour, restricted to written
  note spans.
• Find settings and customize the workspace. Search settings in Japanese or English,
  choose panel positions, and edit theme palettes for tracks, library categories, chord
  degrees, transport indicators and note-velocity gradients.
• Overlapping SoundFont notes release correctly. Releasing one occurrence of a pitch
  no longer prematurely cuts another held occurrence.

Compatibility

• Projects use format 26, and this release opens format 26 only. Projects saved by
  v0.6.0 use format 21 and cannot be opened here; projects saved by v0.7.0 cannot be opened
  in v0.6.0. No automatic migration is provided.
• Model tools consolidate regeneration in regenerate_clips, with an explicit take
  policy, and send-level edits in routing. set_effect requires a slot.

Auris Studio v0.6.0

Downloads

File	What it holds
…-macos-universal.tar.gz	Auris Studio.app, auris, auris-mcp, and auris-agent — Apple Silicon and Intel universal binaries
…-windows-x86_64.zip	auris-studio.exe, auris.exe, auris-mcp.exe, and auris-agent.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. Beside it, a Dictionary directory holds the
NAIST Japanese dictionary (BSD-3-Clause, jpreprocess's build): what reads kanji
lyrics, and what gives a melody composed from lyrics the words' pitch accent to follow.
On macOS both live inside the bundle, so dragging Auris Studio.app to /Applications
takes them 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.

---

Drums and generated parts

• Drums have their own track and editor. Dedicated percussion tracks use named drum rows
  and editable MIDI assignments. The built-in polyphonic kit supplies kicks, snares, hats,
  cymbals and toms, with shared hat choking. Composed percussion and MIDI channel 10 imports
  use drum tracks; drum tracks export on channel 10 without consuming melodic channels.
• Measure and assign drum sounds. Background analysis measures built-in, SoundFont and
  hosted instruments and proposes musical roles from their rendered audio. Apply a map for
  future generation, or retarget generated clips with an undoable command. Manual assignments
  remain available, and analysis alone changes no notes.
• Shape generated parts in the inspector. Drummer and the melodic Session Player offer
  complexity/intensity pads, phrasing controls and take selection. Each pad gesture is one undo
  step and preserves the seed. Shared drum kits retain independent settings for individual
  voices. Newly generated parts start on bar lines.

The desktop

• Audio tracks can show spectrograms. Switch from the waveform to a frequency display
  calculated in the background. It follows clip trimming, stretching and looping while
  describing the source recording.
• The window follows your appearance settings. Themed title bars bring playback and panel
  controls together. Clearer icons and panel indicators, an interface font picker, custom
  colour themes and keyboard-friendly settings selectors improve navigation. The library has
  clearer grouping and search results, and macOS panel controls align with the window edge.
• Singer controls show who is singing and what is happening. Named voice and speaker
  selection, portraits and persistent render feedback make failures and stale takes visible.
  VOICEVOX speaker discovery runs asynchronously, and leading-consonant handling fixes
  first-beat synthesis failures.
• LeapSinger joins the singing backends. Exported acoustic models and NHVSing vocoders
  render locally through ONNX, selected through a .leapsinger.json entry. Model preparation
  is documented in docs/singing-backends.md.
• Windows supports ASIO. Choose the audio backend and inspect the buffer size actually
  reported by the device. Source builds can download a missing standard SoundFont in the
  background; release archives continue to include the standard sounds and Japanese dictionary.

Files, Agent and MCP

• Autosave preserves the last manual save. Unsaved changes go to a private session
  snapshot, including before the first save. Save and Save As write the permanent document;
  closing without saving keeps the last manually saved document.
• Model tools can revise an existing project. Expanded clip, harmony, routing, effect,
  automation and file operations support local edits, with checkpoints and protection against
  conflicting disk changes. Shared schemas and tool_help expose exact arguments. Invalid
  calls receive corrective feedback, while repeated failures stop the tool loop.
• Preview and compare actual audio. Short previews are available as local WAV files and
  MCP resources. The listen tool sends excerpts to a separately configured audio-capable
  critic. The optional Python reviewer is in tools/audio-review in the source checkout;
  release binaries include the tool interface, not that service or its model weights.
  Reviews remain experimental and depend on the chosen model.

Compatibility

• Project format advances from 19 to 21. Older percussion tracks migrate from explicit
  source or drum metadata while preserving their stored notes and performance. Every project
  saved by this release uses format 21 and cannot reopen in v0.5.0, including projects without
  drums.
• Native Auris voice metadata remains version 2; existing v0.5.0-compatible voices need no
  re-export. LeapSinger rerenders can differ with the same seed; saved audio takes preserve
  the performance.
• Model calls now require add_track.kind and add_clip.name. The set_effect schema requires
  an explicit slot.

Auris Studio v0.5.0

Downloads

File	What it holds
…-macos-universal.tar.gz	Auris Studio.app, auris, auris-mcp, and auris-agent — Apple Silicon and Intel universal binaries
…-windows-x86_64.zip	auris-studio.exe, auris.exe, auris-mcp.exe, and auris-agent.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. Beside it, a Dictionary directory holds the
NAIST Japanese dictionary (BSD-3-Clause, jpreprocess's build): what reads kanji
lyrics, and what gives a melody composed from lyrics the words' pitch accent to follow.
On macOS both live inside the bundle, so dragging Auris Studio.app to /Applications
takes them 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.

---

The voice trainer moved in

• training/ is now part of this repository. The Python project that trains the singing
  voices — PyTorch and Lightning, its own uv environment, its own documentation — was a
  repository of its own (uthree/auris-singer) and is now a directory here, history and all. It
  is not part of the Rust workspace, cargo never sees it, and no release archive carries it.
• The voice file format is checked across both languages. An exported .onnx is a contract
  between the trainer that writes it and auris-singer that reads it, and several halves of that
  contract were written down twice — the metadata key, the format version, the reserved symbols,
  the phoneme table down to which symbols are voiceless. Nothing could compare them while the two
  lived apart, to the point where a comment in auris-vocal asserted that its voiceless list
  matched the trainer's symbol for symbol: true when written and unverified ever after.
  training/tests/test_host_contract.py is that comment executable, and CI runs it on every
  change to either side.
• PyTorch is no longer pinned to a CUDA index. The trainer named the CUDA 12.8 wheels
  outright, which is right on a machine with a card and wrong on every other;
  uv pip install --torch-backend=auto reads the driver and chooses.
• A voice is measured through the host, not only through PyTorch. Training's validation
  sings in PyTorch and export's verification compares one runtime against another on random
  inputs; neither sees what auris-singer does with the file — the chunking of a long
  timeline, the arrangement of frames into tokens, the energy scale, its own noise, its own
  copy of the runtime — or what auris-vocal decided before it. training/scripts/evaluate_host.py
  sings the validation set's own curves through the application and reports the trainer's
  own metrics beside a PyTorch reference and beside the same utterances sung as one song, so
  a seam or an arrangement bug shows as a number; --score composes from lyrics and sings
  through auris sing, the path a person walks. Two CLI commands are the doors: auris frames writes what a singer track will be sung as, and auris sing-frames sings such a
  file through a voice into a WAV, with --report writing the session's account of the render
  — chunks, load and render time, which processor sang.
• The words are measured, not only the tune. The corpus run splits its spectral distance
  by the manner class of the phoneme on each frame — vowels, consonants, the sibilants on
  their own — and measures the sibilant tilt, the energy above 4 kHz against below on /s/
  frames, render against recording. It is the consonant-width study's measurement made a
  permanent column: a voice that tracks its pitch to the cent and hums through every /s/ now
  shows it as a number.
• A rest is a seam. The singer cut a timeline into inferences only where twenty seconds
  of frames forced it, so a four-line verse with two seconds of rest between the lines was
  one inference — and a voice is trained on phrases cut at their pauses, so a rest longer
  than a breath inside one inference is a place it has never been. Measured, the lines after
  the rests came out with phoneme error rates of 0.47 and 0.67 sung whole, 0.10 and 0.23 sung
  each in its own inference. Chunks now break at every rest longer than half a second as
  well, which costs nothing audible since the cut was in silence anyway.
• A voice says how loud its consonants are, and the frames listen. The energy a singer
  track's frames carried was the note's velocity on every phoneme, a plateau — and measured
  on JSUT-song a voiceless plosive or fricative sings twenty-odd decibels under the vowel
  after it, a voiced consonant six to nine, an approximant three. A /k/ at the vowel's level
  is a /k/ the model has never heard, and on the labelled corpus that plateau alone cost the
  phoneme error rate 0.25 → 0.56, more than the consonant widths and the note-flat pitch
  together. An export now carries phoneme_levels, measured by
  training/scripts/measure_phoneme_levels.py from a labelled dataset the way the widths are
  measured from labels; choosing the voice copies the table into the document beside the
  widths, and auris-vocal turns each consonant down by its measured decibels.
• The pitch travels between notes that touch. The frames a voice was fed held each
  note's pitch to its last frame and jumped on the first frame of the next, and no singer
  does that: measured on JSUT-song, across 1,568 note changes of a semitone or more, the pitch
  takes a median 60 ms to cross from one note to the next, starting some 20 ms before the
  next note's first phoneme and ending 50 ms after it. A model trained on that has never
  seen a step. auris-vocal now draws an 80 ms straight line centred on every boundary where
  one note ends exactly as the next begins, each half capped at a quarter of its note. It is
  a note change, not a portamento: a rest between the notes leaves each on its own pitch, and
  a fall or a scoop written on either note replaces it, since those are the slides somebody
  meant. The roll's sung pitch curve draws the same line. Through the host over ten takes the
  words came out at a phoneme error rate of 0.29 against the step's 0.30, inside the spread
  between takes; the line is there because every voice was trained on one, not for that
  number.
• A voice can start from another run's weights. training/scripts/train.py --init-from
  takes the generator and discriminator out of a checkpoint and nothing else — no optimizer
  state, no step count — so a voice can be pre-trained on a speaker's read speech and finished
  on their songs. configs/preprocess/jsut.yml prepares JSUT, the JSUT-song singer's 6.6 hours
  of prose, through the song's own preparation script; the consonants a 21-minute singing
  corpus holds a few hundred of, the speech holds thousands. Measured on the base voice,
  speech first and then the song took the corpus phoneme error rate from 0.20 to 0.12 against
  the recording's own 0.09, and a composed verse's from 0.31 to 0.23 — the stops and the
  flap, which the tally had named, most of all.
• The Namine Ritsu preparation writes its labels too. The database's hand-corrected mono
  labels were read for the phrase boundaries alone; prepare_namine_ritsu.py now writes them
  out as seconds per phoneme beside each phrase, and the preprocessing config names the
  folder, so the voice trains on the labels the way JSUT-song does.
• A batch is all-labelled or all-searched. Training takes the labelled durations only
  when every utterance in a batch has them, so a corpus mixing a labelled source with an
  unlabelled one — JSUT-song beside VocalSet — quietly sent most of the song's batches back
  to alignment search. The bucket sampler now keeps the two apart. VocalSet's clips carry
  labels of their own besides: a clip is silence, one vowel, silence, and the silence
  detection that cut it is its alignment.
• The consonant tables are the speaker's. A voice's consonant widths and levels were one
  table for the whole model; a model trained on several corpora now carries one of each per
  speaker, and choosing a speaker copies that speaker's into the document. The metadata format
  is 2 for it — a version-1 table has no speakers and would read as no table at all, so
  the host refuses a version-1 voice with a line saying to re-export it, and the exporter
  refuses a version-1 table. measure_phoneme_durations.py --data measures every speaker of
  a labelled dataset at once, as the level script always did.
• A voice's speakers can be chosen. A voice trained on several corpora carries one
  speaker per source, and the host always sang the first. A singer track now names the
  speaker who sings, saved with the document and part of what pins a take; Track → Next
  Speaker moves round the voice's list, auris sing --speaker and auris sing-frames --speaker take the name, the sing tool has a speaker argument, and
  evaluate_host.py --speaker measures one. A name the voice does not have is refused with
  the ones it does, at the command and never mid-render. train.py --init-from lets the
  speaker tensors start afresh, so a multi-speaker base can finish as a single voice.
• A consonant releases into its vowel. The level table turns each consonant down by
  its measured decibels, and the frames held that level to the consonant's last frame — a
  stop at its closure's level to the end, which is a stop that never bursts. Measured...

Auris Studio v0.4.0

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.

---

The singer gets a real voice

• Singing-voice synthesis works end to end. A singer track can now be pointed at a trained
  auris-singer voice model — one self-contained
  .onnx file, chosen the way a SoundFont is and left where it lies — and asked to sing:
  notes and lyrics become frames, the frames become a waveform, and the waveform lands in
  Audio/ as the track's take, an ordinary audio source that plays, exports and reopens
  with everything else. Track → Choose Voice… and Track → Sing in the window (the render runs
  off the main thread behind the export overlay, with the same stop button), and
  auris sing <project> [--track <name>] [--voice <model.onnx>] [--seed <n>] at the command
  line.
• A take is kept, never silently rewritten. Every random choice is pinned by a seed the
  document stores, so the same document, seed and voice render the same audio on any machine.
  Editing notes after a render leaves the take playing — a voice someone chose does not fall
  back to the formant preview over one edited word — and the track header says
  behind the notes until Sing is pressed again. Clicked notes still audition through the
  preview instrument while a take plays.
• The take keeps up with the score by itself. Once a track has a voice, editing the notes
  is the ask: shortly after an edit settles, the window re-renders the take in the
  background — no overlay, no button, just the header badge reading … ♪ voice while the
  CPU is spent, which is the standing rule that a cost switched on without a click must say
  so on screen. A burst of edits coalesces into one render; an edit landing mid-render
  cancels the stale work between chunks; a manual Sing or an export takes the stage and the
  background render steps off it. Refusals worth acting on — an unsaved project, a voice
  that stopped loading — are said once in the status bar rather than once per frame, and an
  empty or voiceless track is simply left alone.
• The model doors sing too. Three additions to the toolbox, identical over MCP and in the
  agent panel: add_track accepts kind singer, write_lyrics lays a phrase across a clip's
  notes one syllable each (notes reads the words back beside the pitches), and sing
  renders the track through its voice model into the project's take — so a model can write a
  song and make it sing without a window open. Twenty-nine tools in all.
• A dragged note previews in the real voice. Grabbing or dragging a note on a voiced
  singer track no longer strikes the formant instrument: the model sings that one note — its
  own syllable, half a second at the grabbed pitch — in the background, and the engine plays
  the render at once, transport rolling or not. Renders are cached by voice, seed, pitch and
  syllable, so a drag is instant everywhere it has already been; short sequences sit well
  inside what a desktop CPU renders faster than real time. Tracks with no voice keep the
  formant preview, and chords stay on the instrument path. Under the hood the engine grew
  one-shot playback: a pre-rendered buffer crosses the command channel whole, is mixed in by
  the callback without ever being freed there, and travels back up the retired-data channel
  when replaced — the SetGraph discipline in miniature.
• The piano roll draws the sung pitch curve. Editing a singer clip overlays the contour
  the voice will actually sing — the note's pitch plus its bend curve, in fractional
  semitones, with consonants riding their vowel and rests leaving a gap in the line — over
  the notes, the way vocal editors draw it. It is computed from the same frames the model is
  fed, cached against the document revision like the take badge, so what is drawn and what
  is sung cannot drift apart.
• And the phoneme segmentation beside it. The same frames say where each phoneme's time
  actually falls — the sixty milliseconds a consonant takes at a note's edge, the vowel
  stretched over the rest — and the roll now draws it: a faint divider inside the note at
  each cut, the symbol above the note at the position its frames begin. The old untimed
  phoneme list above a note yields to this wherever frames exist; zoomed far out the symbols
  step aside and the dividers stay.
• The cuts are draggable. Take hold of a divider and the phoneme to its left is pinned
  to that many seconds — stored on the note beside its phonemes (Note::phoneme_seconds),
  so the adjustment travels, saves and re-renders with the word. The timing rule lays the
  unpinned phonemes out around the pins, squeezing proportionally where pins outgrow the
  note; retyping a lyric clears its pins, the note's menu offers Reset Phoneme Timing while
  any stand, and one drag is one undo step.
• A note can wear pitch ornaments: scoop, fall, vibrato. しゃくり rises into the note
  from below, a fall drops away at its end, a vibrato sways around it once settled — each a
  handful of numbers stored on the note (Note::scoop / fall / vibrato), shaped by one
  public function (auris_vocal::ornament_offset) that the frames, the painter and the
  editor's grab test all read, so drawn, heard and grabbed can never disagree. The note's
  menu toggles each ornament on with defaults taken from singer measurements, and every
  ornament then carries a handle on the drawn pitch curve: the scoop's and fall's at the
  corner of the gesture (drag for span and depth at once), the vibrato's at the crest of its
  first sway (onset and depth). Scoop and fall cap at half the note so they cannot collide;
  ornaments are pitch, not phonemes, so they survive the lyric being retyped; one drag is
  one undo step, and the take re-renders itself afterwards like after any other edit.
• Under the hood: the new auris-singer crate runs the model on the CPU via onnxruntime,
  cutting the timeline at silences into chunks of at most twenty seconds — the model's
  attention grows with the square of the frame count, and a whole song in one inference has
  taken a machine down — and deciding each frame's voicing from the phoneme class
  (auris_vocal::is_voiceless), never from f0 > 0, which would hum through every /k/.

The conversation moves into the window

• The Agent panel — View → Agent, docked on the right beside the inspector the way an
  editor's chat sidebar sits. Ask for a piece, watch each tool call land in the transcript,
  read the answer; provider, model, URL and API-key variable are set in the panel and saved
  to the shared settings, which auris-agent on the command line now reads as its flag
  defaults. The window spawns auris-agent --json beside its own binary and speaks JSON
  lines over its pipes, so the frontend boundary holds: the window never learns what an LLM
  client is.
• The two ends of one file, settled: the window saves before every message, so the model
  always reads the document as it stands; when a tool call writes the project back, the agent
  reports it (changed events, from the new auris_toolbox::WRITES_PROJECTS list) and the
  window reloads — automatically while it holds nothing unsaved, by an offered button when it
  does. The whole policy is a plain function with tests; the window only obeys it.
• auris-agent --json: newline-delimited JSON for a host program — {"say": …} in;
  ready, call, result, changed, answer, error out. A provider failure is an
  error event rather than an exit, because the host's window is still open.
• From the first live sitting: provider and model are both picked, not typed — the panel
  runs the new auris-agent models (Ollama asked in its own words, context windows included;
  OpenAI-compatible via /models) and fills a dropdown, refetching when the provider or URL
  changes. A context gauge in picocode's image sits over the input — ↑ prompt ↓ written,
  a bar filling the chosen model's window, yellow from 60% and red from 85% — fed by token
  counts that now ride every answer event. Tool rows open on a click to the whole answer
  the model saw, which makes the transcript the loop's log. And a send with no model
  configured now says so in the transcript instead of silently doing nothing, which is what
  the first Enter ever pressed in the panel ran into. From the sittings after it: picking a
  model applies it on the spot — the choice writes through to the settings as the menu
  closes, and Enter in the chat treats a completed settings form as applied, so the Apply
  button now only serves the typed fields.
• The model can edit the arrangement in place. Six tools at both model doors, so one more
  part is an edit rather than a recomposition: add_track (a new track in an existing
  project, voiced by a built-in id or any General MIDI sound by name or number — the shipped
  font is adopted into the project in the same step), add_part (a...

Auris Studio v0.3.0

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 travel...

Auris Studio v0.2.0

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.

---

What an adversarial read of the composer's harmony found

The music theory, gone through looking for chords the composer plays that nobody wrote. Every one
of these was silent: the wrong chord sounded, the document recorded the numeral that was asked for,
and nothing anywhere said the two had stopped agreeing.

• A numeral means the same chord wherever it is typed. Colouring built its chords by hand
  instead of asking the numeral, so a borrowed chord and a seventh took different paths to the same
  question and answered differently. The whole of it now goes through chord_in, which is the one
  place that knows what a numeral means.
• A seventh comes from the key rather than from the triad it lands on. vii7 in a harmonic
  minor key came out half-diminished where the key builds it fully diminished — a distinction the
  triad alone cannot make, and the leading-tone chord is where it matters most.
• A lead-in is a fifth above the tonic it arrives at, in every mode. It was built from the
  scale's fifth degree, which in phrygian and locrian is not a fifth above anything: a
  modulation into a locrian section was prepared by a chord a tritone from where it was going.
• ii/V is the supertonic of V. Everything in front of the slash was thrown away and every
  applied chord came out as the dominant seventh of its target — ii/V, vii/V and IV/V all
  parsed happily and all sounded as V7-of-V. An applied chord is now read in the key its target
  would be the tonic of, which is what the notation has always meant. V/x still takes its
  seventh: the tritone pulling into the target is the whole point of writing one.
• A sixth leaves the fifth under it alone. Major6 and Minor6 both hold a perfect fifth
  and the sixth was handed out on the strength of the third, so vii6 came out with a perfect
  fifth and was no longer diminished.
• A section ends where its progression ends. A four-bar progression under a six-bar section
  played bars 1–4 and then 1–2, stopping in the middle of the loop; it now plays the whole thing
  and fills from the end, so the section lands on the chord the progression resolves to.
• The octave figure moves an octave. The bass folded root + OCTAVE back into its range, and
  the range is two octaves wide with the roots in the upper one — so for four of the seven degrees,
  the subdominant and the dominant among them, the leap was subtracted straight back and the bass
  restruck the note it was already on.
• The bass is the bottom of the arrangement. The pad ran from C2 and the bass from E1, sharing
  sixteen semitones, so a pad voicing could put a chord tone under the bass note — an inversion
  nobody wrote, decided by whichever tone happened to fold lowest. The pad now runs C3 to C5, and a
  test holds every pitched role above the bass's floor. No part may read another's notes, so the
  ranges are where this has to be settled.
• A tie between two scale degrees now rounds down rather than off the top of the scale.

Compound time is counted in dotted beats

• 6/8 is two beats, not six. The grid divided the note the denominator names, which made a
  "sixteenth" in 6/8 a thirty-second — the grid came out twice as fine as everything placing notes
  on it believed. A step is now a fixed note value in every meter, and the felt beat is derived:
  six sixteenths to a dotted quarter. Every part that asks "am I on a beat" gets the answer the
  meter actually has.
• The metric hierarchy no longer offers a compound beat a halfway point. A dotted quarter
  divides in three and in nothing else; its midpoint is a syncopation against the meter rather
  than a position the meter offers, and weighting it as a beat handed real weight to the one step
  in 6/8 that most needs to be heard as a departure. Swing is off in compound time for the same
  reason: the shuffle is already there.
• A groove is mapped onto the bar rather than wrapped round it. The built-in grooves are one
  bar of 4/4, and under a 6/8 bar the pattern restarted partway through, putting a second downbeat
  where the bar has no beat at all; under 3/4 the turnaround simply never played. The bar's first
  beat now takes the groove's first and its last takes the groove's last, which is what a drummer
  does with a pattern in a meter it was not written for.
• six-eight and slow-blues are grooves written in compound time — in eighths of a dotted
  beat rather than sixteenths of a plain one — so a song in 6/8 or 12/8 has a two-beat and a
  four-beat idea to reach for instead of borrowing a four-beat one. A groove now carries how many
  steps make one of its own beats. Nothing picks them automatically; a song names them the way it
  names any other groove.
• The bass reads the kick the same way the drummer does. It was reading the raw step index, which
  wrapped a groove shorter than the bar and truncated a longer one — so in every meter the groove
  was not written for, the bass followed a kick the kit was not striking.
• A rhythm somebody writes by hand is still a repeating cell, because that is what writing four
  steps under a 4/4 bar means.

The panels answer the pointer

• The song sheet's dials follow the mouse again. The sheet is drawn on an occluding overlay,
  and gpui's hit test stops at the first hitbox that blocks — so the root's pointer handlers, which
  every drag in the application is tracked by, never saw a move over the sheet. A dial could be
  pressed and would not turn.
• The piano roll draws the rest of the track. The bars either side of the clip being edited
  were empty grid, so there was no way to see what the phrase before it ended on or what the next
  one starts from without closing the roll. The neighbours are now drawn behind it, flat and faint
  — no velocity in the fill and no selection outline, because a ghost that read like a note would
  be an invitation to edit something the roll will not edit.
• The mixer scrolls, and says so. A flex item's min-width is auto, which is the width of
  its content — so a panel holding fifteen channel strips asked the dock for the width of fifteen
  channel strips and got it. Nothing overflowed, because nothing was ever too small; the strips ran
  off the side of the window where no scroll could reach them. There is now a scrollbar under the
  strips, drawn only when there is something to scroll, with the thumb draggable and the track
  clickable to jump.
• One picker row and one way to open a menu. The song sheet, the inspector and a plugin's choice
  parameters were three copies of the same control, and twenty-eight call sites each wrote out the
  same eight lines to open a context menu.

A section can change how a part plays

• [section.chorus.part.lead] octave = 6. A part was one setting for the whole song: whatever
  density, octave, gate and subdivision the roster gave it, it played that way from the first bar
  to the last. A section can now patch any of those, plus rhythm and note — the lead an octave
  up in the last chorus, the hat on sixteenths in the bridge.
• A patch, not a second declaration: what it does not name it does not touch, so a busier
  chorus is one line and adding a field to a part does not silently reset it in every section that
  tweaks one.
• The resolution happens once per part per section, and every pass reads it. That is the whole of
  the change and the only part of it with a trap: shorten and humanise run over the finished
  part after every section has been written, so a gate or a subdivision read off the roster there
  would be the one kind of per-section field that silently does nothing — a chorus cut to the
  verse's note lengths, or a section on triplets having its swing measured against sixteenths.
  Both are pinned by tests that fail when the resolution is taken away.
• Not patchable, by construction: the name, the role, the instrument, the program, the level and
  the pan. Those are not how a part plays, they are what its track is — one row, one instrument,
  one fader for the whole song. A chorus on strings where the verse was on a piano is two parts and
  the section roster is what brings each of them in. The line is not waiting to be lifted: a track
  that changed instrument half way through would have to be two tracks, and then it was two parts
  all along.

A key change is arrived at rather than stumbled into

• The last chord before a modulation becomes the dominant of the key being arrived at. A
  transposed section used to begin and that was all: the piece stepped sideways and a listener
  heard the join as an edit. A V7 names its tonic before that tonic has sounded, which is why
  every arranger reaches for it first and why nothing else does the job.
• One event, replaced in place — the section keeps its bars and its clips keep their lengths — and
  only where the key a...

Auris Studio v0.1.0

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

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.

---

The first release. What is here works end to end: write notes, play them through a built-in
instrument, shape them with effects, and render the result to a WAV file.

The window

• An arrangement of instrument and audio tracks, with a bar ruler, a cycle region and a playhead
  that scrolls itself into view while the transport rolls.
• A piano roll with two tools — pointer and velocity — a mixer with per-track strips and a
  master bus, an inspector, and a library that browses instruments, effects and SoundFonts as a
  tree.
• Every panel is docked to the left, the right or the bottom, and can be moved between them from
  its icon in the status bar. Where you leave them is where they are next launch.
• A command palette, a right-click menu on every component, and a menu bar — drawn by the
  application on Windows and Linux, the system's own on macOS. Both answer to the keyboard.
• Colour schemes, chosen in the settings window and checked for contrast by a test.
• English and Japanese throughout, following the system locale unless told otherwise.

Sound

• Chiptune, two-operator FM and noise-drum instruments, all band-limited where it matters.
• Effects: gain, pan, delay, reverb, chorus, distortion, compressor, limiter and a parametric
  equalizer with a spectrum analyser.
• SoundFont playback: .sf2 files are imported once and referenced by font, bank and patch, so a
  project stays small and opens playing the same sound.
• A realtime engine on cpal with a bounded command channel, plugin latency compensation, effect
  tails summed along the chain, and pre-built graphs handed over so nothing is dropped on the
  audio thread.
• Audio import through Symphonia, resampled when the device disagrees with the project.

Writing music

• A harmony lane holding a key and a chord progression, editable on the timeline and audible by
  pressing or sweeping it.
• A structure lane naming the song's sections.
• Clips that write themselves from a preset and the harmony under them, and remember the recipe
  so they can be written again after the chords change.
• Whole-song composition from a text specification, from the desktop application or the command
  line.

Files

• A project is a folder holding <name>.auris and an Audio/ directory. Imported audio is
  copied in; assets are found again by name and size when they move, and a missing one costs that
  track's sound rather than the whole document.
• Configuration lives in ~/.config/auris-studio/ on every platform, in four small JSON files a
  dotfiles repository can carry.
• WAV export at 16-bit, 24-bit or 32-bit float, for the whole project or for the cycle region.

Frontends

• auris-studio, the desktop application, on macOS and Windows.
• auris, the command line tool, on macOS, Windows and Linux.