🍊 SONIX STUDIO - Professional Native Linux DAW

Languages / Språk: 🇬🇧 English | 🇸🇪 Svenska

A modern, lightning-fast graphical Digital Audio Workstation (DAW) built with Rust and egui, featuring FL Studio-style direct timeline audio editing, magnetic loop snapping, FL Studio/VST3/CLAP plugin scanning & cataloguing, Soundtrap-style creative panels, an integrated modular synthesizer, 16-step Channel Rack, Piano Roll, Vocal Studio with live microphone recording, a multichannel Effects Mixer, and Touch Instruments for Linux. Audio runs through the system's realtime backend via cpal/ALSA (PipeWire works through its ALSA layer). See Features & Implementation Status for exactly what is real today and what is still to come. Full development plan: ROADMAP.md.

---

🚀 Installation (Linux / Omarchy)

Sonix is a native Linux DAW written in Rust and egui. You run it by building from source with Cargo. The built-in mode that captures the 29 screenshots is only used by maintainers (see the note under the gallery below) and is not part of installing or running the app.

📦 Prebuilt binary (no Rust needed): Grab the latest sonix-<version>-x86_64-unknown-linux-gnu.tar.gz from the Releases page, unpack it and run ./sonix. The archive ships the binary, both READMEs, the manual, the changelog and the licenses, plus a .sha256 checksum. It is built with --features plugin-host for x86-64 (glibc ≥ 2.35).

⚡ Fastest way (guided installer): Download and run install.sh – it confirms every step for you (dependencies, compilation, binary + start-menu entry) with no other terminal commands needed:

bash <(curl -fsSL https://raw.githubusercontent.com/alexwest1981/sonix/master/install.sh)

If you already have a clone, just run bash install.sh from inside the folder. After a code change you can refresh the binary + start-menu entry with bash install.sh --refresh.

The installer asks which interface language you want (English, Svenska, Dansk, Norsk, Deutsch, Español, Français). You can always switch languages live from the 🌐 menu in the app's top toolbar — the choice is remembered between sessions.

Prerequisites

• 64-bit Linux with a running audio server — PipeWire (recommended), JACK or ALSA.
• Rust (stable, edition 2024) plus a C toolchain.
• One runtime helper used by a specific feature: unzip (Suno ZIP import). Optional. File dialogs have come from the desktop's own portal since Fas 7.1 (xdg-desktop-portal, installed with most desktop environments) — zenity is no longer needed.
• Optional, for Windows VSTs: yabridge + Wine.

Install the prerequisites:

Omarchy / Arch Linux:

sudo pacman -S --needed base-devel alsa-lib unzip rustup
rustup default stable

Debian / Ubuntu:

sudo apt install build-essential libasound2-dev unzip curl
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Fedora:

sudo dnf install gcc-c++ alsa-lib-devel unzip curl
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

1. Clone and build

git clone https://github.com/alexwest1981/sonix.git
cd sonix
cargo build --release
./target/release/sonix

During development you can skip the manual build step and use cargo run --release instead.

2. Install the binary (optional but recommended)

Installs sonix into ~/.cargo/bin so you can launch it from anywhere or from an application menu:

cargo install --path .
sonix

3. Application menu entry (Omarchy / Linux desktop)

After cargo install, create a launcher (adjust the paths if your clone lives elsewhere):

mkdir -p ~/.local/share/applications
cat > ~/.local/share/applications/sonix.desktop <<EOF
[Desktop Entry]
Name=Sonix Studio
Comment=Native Linux DAW
Exec=$HOME/.cargo/bin/sonix
Icon=$HOME/Projects/sonix/assets/sonix.png
Terminal=false
Type=Application
Categories=Audio;AudioVideo;Music;
StartupWMClass=sonix-daw
EOF

Then log out/in once, or refresh the menu immediately with:

update-desktop-database ~/.local/share/applications

Troubleshooting

• No sound / no audio device: make sure PipeWire (or JACK/ALSA) is running and your microphone/interface is connected. Open the audio settings in-app with Ctrl + P to pick a device and buffer size.
• Window fails to open: you need a working Wayland or X11 session with Mesa/OpenGL drivers.

---

🎧 Samples, stems and your own music

The repository contains no audio files at all — deliberately, in both directions:

• No third-party sample packs are shipped. Their licences don't allow redistribution.
• No stems or recordings of your own music are ever committed — imported_stems/, *.wav, *.mp3, *.flac and *.ogg are in .gitignore.
• A guard rejects any staged file over 5 MB (git config core.hooksPath .githooks once per clone — that is why the 416 MB of audio that once ended up in this repo's history cannot happen again by accident).

The app is fully playable without any of it. The drum voices (kick, snare, clap, hats, crash) are synthesised, so the Channel Rack, the sequencer and the demo song work out of the box. Samples are an upgrade, not a requirement.

Where sounds go

What	Where
Sample packs — the library the Sound Browser scans	~/Music/Sonix/Sample_Packs/
Factory sounds	~/Music/Sonix/Factory_Samples/
Your own samples	~/Music/Sonix/Samples/
Imported stems and recordings (gitignored)	imported_stems/ in the project folder
Templates	~/Music/Sonix/Templates/

Every path can be moved. Run sonix --paths to see the map your machine actually uses — it also prints which directories exist and which would be created.

Where to get packs

Free, licensed starting points: Freesound (CC — check each file), 99Sounds, Bedroom Producers Blog and Cymatics' free packs. Paid subscriptions such as Splice or Loopcloud drop straight into Sample_Packs/ as well. Check a pack's licence before releasing music made with it.

Naming — how the drum rack finds your samples

When the library is scanned, the six built-in drum channels fill themselves from the first file whose name contains one of these words:

Channel	Matches on
Kick	kick, bass drum, bd0, bd-
Snare	snare
Clap	clap, handclap
Closed hi-hat	closed hat, chh, hat closed
Open hi-hat	open hat, ohh, hat open
Crash	crash, cymbal, cy

Name files accordingly (909 kick.wav, snare_tight.wav) and they land in the right channel on the next start. Everything else still appears in the Sound Browser.

🎨 Features & Implementation Status

Legend: ✅ Real & wired · 🟡 Partial / approximation · 🔜 Not yet implemented

Everything marked ✅ is genuinely functional in the audio engine or project state — not a mock-up. The 🟡 items work but are deliberately labelled so nothing is over-sold.

1. 🎼 Timeline & Multitrack Arranger — ✅ Real

• Direct Clip Edge Dragging (Paint & Select Tools): Grab the right edge to extend and loop clips across bars, or drag left to shorten. Grab the left edge to trim/crop the start without destructive edits.
• Continuous Waveform Phase Tracking: Trimming the start shifts the waveform without squishing or distorting loop cycles.
• Magnetic Loop-Snap (🧲): Locks onto exact whole-loop multiples (1x, 2x, 3x, 4x, 8x) and grid divisions (1/16, Beat, Bar). Hold Alt for free precision.
• Bottom Region Inspector: Coarse/fine nudge (±1 bar, ±0.1s), start-trim offset, gain, fade in/out, reverse playback, and loop multiplication.
• Tool Palette: Select (⇱), Paint (✎), Slice (✂), Erase (🗑), Mute (🔇); quick-cut at playhead (Ctrl+B).
• Live In-Track Microphone Recording: Arm buttons (⏺), real zero-latency direct monitoring and real-time waveforms on audio tracks.
• Automation Curves (📈): Draw per-track curves for volume, pan, reverb and delay sends. Left-click to add points, drag to move (snaps to the grid), right-click to delete. Curves play back in real time and are saved with the project.

2. 🥁 Sonix Channel Rack (16-Step Sequencer) — ✅ Real

• Channel Strips: Kick, Snare, Closed/Open Hat, Synth Lead, Sub Bass and custom user channels.
• 4-Beat Step Buttons with glowing center LEDs.
• Per-Channel Knobs: Volume, pan, pitch (semitones + cents) and a sample chopper (start/end fractions + transient detection).

3. 🎹 Piano Roll & Interactive Touch Keyboard — ✅ Real

• Polyphonic Note Editor: Note lengths, velocity editing, scale snapping and brush tools.
• Playable Virtual Keyboard: Neon feedback with computer-keyboard typing (A–K).
• Real MIDI Keyboard Input (ALSA Seq): Open a real MIDI-in port ("Sonix MIDI In"), connect a hardware keyboard with aconnect, play it live, and arm ⏺ MIDI-REC to write held notes straight into the Piano Roll grid during playback.

4. 🎚 Mixer Console & Per-Track Effects — ✅ Real

• Channel Strips: Faders, real peak VU meters, solo, mute, pan and stereo width.
• Per-Track 3-Band Parametric EQ: Draggable visual curve + quick presets.
• Per-Track Dynamics & Sends: Compressor, reverb/delay sends and pitch — all sent to the audio engine.
• Master FX Rack: Gate → 4-band EQ → compressor → de-esser → filter/drive → doubler → limiter, plus reverb & delay, with a real gain-reduction meter and a visual EQ editor.
• Remix FX (live): Kaoss-style XY pad with beat-repeat/stutter/reverse and a real tape-stop varispeed effect.
• VCA Groups & Sub-Mix Buses: 4 sub-mix buses (Vocal, Drums, Synth, FX) and 4 VCA groups, each with fader + mute/solo; per-track bus/VCA routing. Group gain is applied post-fader just before the master, and the state is saved in the project and honoured by offline export.

5. 🎛 Analog Alchemy Synth — ✅ Real

• 4 waveforms (sine, saw, square, triangle), ADSR, resonant filter, drive and an 8-snapshot morph vector pad.
• ✅ Per-voice: Each note has its own filter state and filter envelope (the ENV ±oct knob sweeps the cutoff per note); envelope parameters are patch-global so knobs are heard live.
• 🟡 Note: The filter is a 2-pole (12 dB) state-variable low-pass — not a 24 dB Moog ladder.

6. 🎙 Vocal Studio & Harmonizer — ✅ Real

• Take Lanes: Multiple takes with non-destructive comping; waveform crop/slice/normalize.
• Pitch Editor: Draggable note blobs (Melodyne-style) and scale-aware correction.
• Autotune & 4-Part Harmonizer with per-voice level and formant controls; harmony voices use real formant preservation (STFT + cepstral envelope correction) so pitch shifts no longer sound "chipmunk".
• Real-time Auto-Tune & direct monitoring: The 🎙️ Real-time Auto-Tune checkbox corrects the microphone in the audio thread (rolling pitch detection + WSOLA streaming shifter) and is heard through true zero-latency direct monitoring (ring buffer → master bus). Strength = the AUTO-TUNE knob. Recording stays dry.
• Custom Sampler: Record acoustic one-shots via microphone and map them to instruments/drums.
• Hardware Mic Panel: Input device selector, hardware gain boost (+0 to +24 dB), noise gate, feedback suppression and vocal character presets.
• 🟡 Note: The graphical pitch editor and the harmony voices still run offline on the recorded buffer; the real-time auto-tune and direct monitoring are genuine. Pitch detection is autocorrelation-based.

7. 🎛 Creative Generators — ✅ Real

• Smart Chord & Harmony Matrix: 12 scales, Roman-numeral progressions, voicings, strum humanizer, arpeggiator → Piano Roll.
• Beat & Melody Dice Generator: 5 categories, genre presets, live preview → pattern.
• Session Drummer: XY complexity/energy pad with 6 genre presets.
• Song Section Arranger: Intro/Verse/Chorus/Bridge/Drop/Outro → timeline.
• Add Track Studio: 19 templates across 6 categories.
• Hardware Strobe Tuner: Real pitch detection, ±cents readout, 7 tuning presets and a reference tone.

8. 🧩 Modular Patcher — 🟡 Real DSP, order-sensitive

• Visual node grid with patch cables: MidiIn, Oscillator (sine/saw/square/triangle + sync/PWM), Filter (LP/HP/BP), ADSR Envelope, LFO, Delay, Reverb, Distortion, AudioOut.
• 🟡 Note: Nodes are evaluated in creation order (no topological sort), so cables must follow signal order. A few node labels describe more than the DSP does.

9. 🤖 AI Music Assistant & Generation — ✅ Real (with honest limits)

• Real HTTP integration: OpenAI, Anthropic, OpenRouter and local Ollama for text→patterns; audio generation via OpenAI TTS and Stability Stable Audio. Project context (key/BPM/selection) is injected into prompts.
• Local fallback: a deterministic, rule-based composer (scale/key aware) when no API is configured.
• Suno/AI Stem Importer: Unzip and decode real audio, detect BPM and map stems onto the timeline.
• 🟡 Note: There is no Suno API integration. "Suno" here means importing Suno-exported stem packs and using the local generator — not calling Suno.

10. 🧠 Stem Separator — ✅ Real (DSP + optional neural HTDemucs)

• Splits a mix into vocals/drums/bass/instruments. The default is a real spectral DSP separator (band-splitting, center-channel extraction, transient gating) with a real onset-autocorrelation BPM estimator.
• Optional neural backend: build with --features neural and place an HTDemucs-family .onnx model in ~/.config/sonix/models/ (or set SONIX_DEMUCS_ONNX) to run genuine Demucs separation through ONNX Runtime — background thread, live progress, 44.1 kHz resampling and overlap-add crossfading. Without a model it falls back to the DSP path and the UI states which backend ran.
• 🟡 Note: Sonix does not ship model weights; the neural path needs a user-provided, appropriately licensed model. The default build stays dependency-free and offline.

11. 🔌 Plugin Manager — 🟡 Catalogue + opt-in CLAP/VST3/VST2 host

• Real recursive scanning of VST3/CLAP/LV2/VST2/.fst folders, ELF/PE binary verification, Wine & yabridge detection, and a one-click yabridgectl sync.
• Opt-in CLAP host: build with --features plugin-host and Sonix can dlopen a .clap plugin, validate its clap_entry, instantiate it, read its descriptor and parameters (the "🔎 Load & inspect" button shows them), run audio through it on a stem track with plug-in delay compensation (the "▶ Load" button inserts it), save/restore its state with the project and read/drive its clap.gui lifecycle.
• Plugin GUI in its own window: an active insert opens the plugin's own UI with "🪟 Open GUI" — the host creates a real X11 window and embeds the editor via clap.gui (set_parent/show), and the audio and the GUI share the same plugin instance. The window is polled every UI frame and torn down cleanly (hide → destroy) when closed.
• Crash isolation in a separate process: "🧪 Sandbox inspect" runs the plugin in its own process (the same binary re-executed with --plugin-sandbox-worker) over a length-prefixed JSON protocol and reads its info + parameters there; a supervisor automatically restarts it on a crash (up to three attempts) so Sonix does not go down. "🧪 Load into sandbox" goes further: the plugin's audio processing itself runs in that separate process, streaming stereo blocks over a shared-memory ring buffer (memfd_create + mmap), with the transport's one-block latency compensated by PDC and automatic re-sync after a restart.
• 🔜 Note: VST3 and VST2 modules can now be loaded, inspected and played (opt-in --features plugin-host), just like CLAP. LV2 is still catalogue-only. Plugin GUIs need a real X display (cannot be shown headless). See Plugin Support — Current Reality.

12. 💿 Export & Project I/O — ✅ Real

• Offline render of the full project (real samples, timeline audio, FX) to WAV (16/24-bit & 32-bit float) and FLAC (in-app encoders); MP3/OGG/AAC via ffmpeg when installed.
• Clean metadata tagging (Sonix Studio only), master mix or per-track stems.
• Loudness normalization (EBU R128): Real ITU-R BS.1770 gated loudness (K-weighting) and true-peak ceiling via 4× oversampling. One-click export presets (Streaming −14, Apple Music −16, Broadcast −23, Club/Loud −9 LUFS).
• Project save/load and template projects.

13. 🎛 Hardware Control — ✅ Real

• Real ALSA MIDI (MCU-style) input and a real UDP OSC server; live device list and bound port are shown in-app.

14. 🌐 Localisation & System — ✅ Real

• 7 interface languages (English, Svenska, Dansk, Norsk, Deutsch, Español, Français), switchable live and remembered between sessions.
• cpal/ALSA realtime engine with a lock-free command ring and a crash-safe audio callback.
• Audio Settings (Ctrl+P) apply the chosen sample rate and buffer size by rebuilding the output stream live; the choice is persisted to ~/.config/sonix/audio.json and restored on launch. The current host/device and the real active stream config are shown.

---

📁 File Locations & Autosave

Every path is built in one place (src/paths.rs) and follows XDG. Run sonix --paths to print the map for your machine (✓ = exists, · = created on demand).

Location	Contents
~/Music/Sonix/	The library (XDG_MUSIC_DIR is honoured, including via ~/.config/user-dirs.dirs)
~/Music/Sonix/Projects/	<name>.sonix + <name>/ with the project's own media (Recordings, Stems, Samples, Renders)
~/Music/Sonix/Samples/ · Factory_Samples/ · Templates/	Your samples, factory sounds, project templates
~/.config/sonix/	config.json (language), audio.json (stream), ai.json (keys, chmod 0600)
~/.local/share/sonix/	models/ (ONNX), plugins/
~/.local/state/sonix/	recent.json (recent projects), window.json, logs/ (audio-thread crash log), autosave/
~/.cache/sonix/	waveforms/, library_cache.tsv

Override with environment variables: SONIX_PROJECTS_DIR, SONIX_SAMPLES_DIR, SONIX_CONFIG_DIR, SONIX_DATA_DIR, SONIX_STATE_DIR, SONIX_CACHE_DIR (otherwise XDG_* applies).

Autosave & crash recovery

• The project is autosaved every 60 seconds if anything changed, and immediately after structural edits (cuts, tracks, mute, paste …) — rate-limited to one write per ten seconds.
• The 5 most recent versions per project are kept in ~/.local/state/sonix/autosave/; older ones are rotated out.
• Everything is written atomically (temp file + rename), so an interrupted write can never replace a whole project file with half of one.
• If Sonix starts and finds an autosave newer than the project file on disk, a recovery dialog is shown. A restored copy is retired (renamed to *.restored) rather than deleted.
• The project menu has 🕘 Recent projects (reads recent.json) and 📂 Show project folder in file manager.

Undo currently covers the timeline; undo for mixer/FX/automation is planned as item 6.2 in ROADMAP.md.

---

🧭 What's Left & How Far From "Real"

A candid status of the remaining gaps. The audio engine, timeline, mixer, generators and I/O are real; the items below are the honest exceptions.

Area	Status	Remaining work
Audio engine (synth, drums, samples, FX, render)	✅ Real	—
Timeline, Piano Roll, Channel Rack, Mixer	✅ Real	—
Vocal Studio (record, comp, pitch edit, harmony)	✅ Real	—
Generators (Chord, Dice, Drummer, Sections, Tuner)	✅ Real	—
AI (LLM + audio APIs)	✅ Real	Local fallback is rule-based, not a neural model
Hardware MIDI / OSC	✅ Real	—
Export (WAV/FLAC in-app, MP3/OGG/AAC via ffmpeg)	✅ Real	—
Modular Patcher	✅ Real	Topological sort + labels match the DSP
Stem separation	✅ Real	Optional neural HTDemucs via --features neural + user model; DSP fallback otherwise
Vocal tuning	✅ Real	Real-time autotune in the audio thread + direct monitoring; harmonies/formant preservation run offline
Time-stretch	✅ Real	WSOLA (pitch-preserving) in the Vocal Studio audition and the Stem Separator SPEED control
Audio Settings	✅ Real	Live stream rebuild + persisted; shows real host/device/stream
Legacy "AI Settings" modal	✅ Real	Now edits the same AiConfig and saves to disk
.fst "Apply Preset" button	✅ Honest	Disabled with a tooltip — FL Studio's closed .fst preset data cannot be decoded; CLAP/VST2/VST3 plugins can be loaded from the plugin panel instead
Plugin hosting (VST3/CLAP/LV2/VST2)	🟡 Partial	CLAP, VST3 and VST2 load + parameter inspection + per-track audio processing with PDC + state save-load + CLAP GUI in its own X11 window + separate-process sandbox with crash restart and shared-memory audio transport (opt-in --features plugin-host); LV2, MIDI instrument routing & a real Wine/yabridge bridge still missing

Overall: roughly 90–95 % of the features advertised in the UI are genuinely implemented and wired to the audio engine. The largest outstanding piece is plugin hosting (CLAP, VST3 and VST2 load + parameter inspection + per-track audio processing with PDC + state save-load + CLAP GUI in its own X11 window + separate-process sandbox with crash restart and shared-memory audio transport work opt-in; LV2, MIDI instrument routing and verifying a real Wine/yabridge bridge remain); neural stem separation is implemented (opt-in --features neural + a user-supplied HTDemucs ONNX).

The full, prioritised development plan with check-off phases lives in ROADMAP.md. A complete catalogue of every built-in effect, channel processor and instrument — with what each one does and its controls — lives in PLUGINS.md.

---

🔌 Plugin Support — Current Reality

Short answer: catalogue + opt-in CLAP, VST3 and VST2 loading, inspection, per-track audio processing, project state persistence, a plugin GUI in its own X11 window and an out-of-process sandbox with crash restart and shared-memory audio transport. Sonix can find and catalogue every format, and — when built with --features plugin-host — load a native CLAP, VST3 or VST2 plugin, read its parameters, run audio through it on a stem track with plug-in delay compensation, save/restore its state with the project, load the plugin's own presets (CLAP), open the plugin's own UI in an X11 window that shares the same instance that processes audio (CLAP), run the plugin's audio processing in a separate process over shared memory and restart it automatically on a crash. LV2, MIDI instrument hosting and verifying a real Wine/yabridge bridge remain.

What works today (✅)

• Recursive scanning of standard VST3 / CLAP / LV2 / VST2 folders and FL Studio .fst locations (Linux + Wine paths).
• Binary verification (ELF/PE), file size and a "verified" badge.
• Wine and yabridgectl detection, plus a one-click yabridgectl sync.
• CLAP host (opt-in, --features plugin-host): dlopen of a .clap bundle, clap_entry validation, instantiation via the plugin-factory, and descriptor + parameter inspection shown in the UI.
• Real audio processing + PDC: a loaded CLAP effect can be set as a per-track insert (the "▶ Load" button in the Plugin Manager) and processes the stem audio in real time. The host block-buffers (128 frames) and the engine compensates the latency so tracks stay phase-aligned.
• State + preset persistence: the host implements clap.state (opaque save/load blob) and clap.preset-load/2 (the plugin's own presets). Plugin inserts are stored in the project (plugin_slots, path + state) and re-instantiated with their state restored on load; the UI lists active inserts with a remove button and offers a "load with preset" field.
• GUI ABI + lifecycle: the host reads clap.gui and drives the whole lifecycle on the main thread (is_api_supported, get_preferred_api, create, get_size, can_resize, set_size, set_parent, show, hide, destroy). Inspection reports the plugin's GUI capability (e.g. "x11 320×240, resizable").
• Plugin GUI in its own X11 window: an active insert opens with "🪟 Open GUI"; the host creates an X11 window via libX11 and embeds the editor with set_parent, and the GUI shares the same ClapCore instance as the audio thread (via Arc + PluginHandle). Window events are polled every UI frame and closing tears the editor down cleanly (hide → destroy). Requires a real X display.
• Out-of-process sandbox (crash restart + shared-memory audio): "🧪 Sandbox inspect" runs the plugin in a separate process (the same binary re-executed with --plugin-sandbox-worker) over a length-prefixed JSON protocol and reads its info + parameters there. A supervisor monitors the process and automatically restarts it on a crash (up to three attempts) before giving up, so a crashing plugin does not take Sonix down. "🧪 Load into sandbox" additionally moves the audio processing itself into that process: host and worker map the same anonymous region (memfd_create + mmap(MAP_SHARED)) and exchange stereo blocks through SPSC ring buffers, with the transport's one-block latency compensated by PDC and the ring re-synchronised after a restart.
• VST3 loading, inspection, audio, state & PDC (opt-in, --features plugin-host): a hand-rolled minimal VST3 ABI (no SDK) loads a .vst3 module (ELF or bundle), creates the component via the factory and reads its parameters (name, units, steps, flags). A live VstProcessor then runs IAudioProcessor::process on real stereo blocks, reports getLatencySamples to the engine's PDC, drives parameters through IEditController + IParameterChanges, and saves/loads state via a host-owned IBStream (IComponent::getState/setState + IEditController::setComponentState). This is especially relevant because yabridge produces VST3/VST2, not CLAP.
• VST2 loading, inspection, audio, state & PDC (opt-in, --features plugin-host): a hand-rolled minimal VST 2.4 ABI (no SDK) dlopens a .so bridge (e.g. yabridge's ~/.vst/yabridge/*.so), calls VSTPluginMain, validates the AEffect magic and answers the plugin's audioMaster callback. A live Vst2Processor then runs processReplacing on real stereo blocks, reads parameters via getParameter/effGetParamName/effGetParameterProperties, reports initialDelay to the engine's PDC, resets through effMainsChanged, and saves/loads state as a program chunk (effGetChunk/effSetChunk). .so paths (without .vst3/.clap) are routed to this backend automatically.

What is still missing to fully host plugins (🔜)

1. Full engine-wide MIDI routing into instruments (note-port discovery and plumbing are in place, but no instrument hosting yet).
2. The Wine/yabridge path for FL Studio & Windows VSTs (Fas 4.6): VST3 module/ABI/loading/inspection (4.6a), VST3 audio/state/PDC (4.6b) and the VST2 ABI/audio/state/PDC (4.6c) are done; running a real yabridge bridge (needs Wine + a display) remains.
3. LV2 loading — CLAP, VST3 and VST2 can play audio so far.
4. For FL Studio's own instruments (Sytrus, Harmor, Gross Beat, …) and FL Studio VSTi, the only viable route is their VST/VST3 builds run through Wine + yabridge — the native FL .dll formats are not a standard plugin API.

Therefore: a CLAP, VST3 or VST2 effect is now usable for sound in Sonix when built with --features plugin-host — load it, insert it on a stem track with "▶ Load", open its GUI with "🪟 Open GUI" (CLAP), and its state survives project save/load. Crash isolation in a separate process with shared-memory audio now exists (with automatic restart); LV2, instrument hosting and verifying a real Wine/yabridge bridge are still to come.

---

⌨️ Keyboard & Shortcut Reference

Key / Shortcut	Function	Description
Space	Play / Pause	Toggle playback in Song or Pattern mode.
R	Record Arm	Arm active microphone track for live recording.
Alt (Hold)	Free Slip / Trim	Bypass magnetic loop and grid snapping for free editing.
F1	User Manual / Help	Open built-in interactive manual and help center.
F3	Timeline / Arranger	Switch to the linear multitrack audio playlist.
F4	Channel Rack	Switch to the 16-step sequencer and drum machine.
F5	Piano Roll	Switch to the graphical note editor and keyboard.
F6	Mixer Console	Switch to the multichannel mixer and effects rack.
F7	Analog Synthesizer	Switch to the synth editor with ADSR, Filter, and Morph Pad.
F8	Vocal Studio	Switch to the vocal recording console and harmonizer.
Ctrl + I	Import Stems	Open dialog to import Suno ZIP archives or audio files.
Ctrl + E	Export Master / Stems	Offline-render the full project (real samples, timeline audio & FX) to WAV, FLAC, MP3, OGG or AAC with clean Sonix-only metadata.
Ctrl + S	Save Project	Save the current project to disk.
Ctrl + O	Open Project	Open a saved project from disk.
Ctrl + P	Audio Settings	Open PipeWire, ALSA, and buffer size configuration.

---

📸 Screenshots & UI Gallery (1920 × 1080 Fullscreen)

ℹ️ These previews are generated by maintainers with cargo run --release -- --capture-screenshots screenshots (opens a fullscreen instance and captures each view). Not needed for installing or running Sonix.

1. 🎼 Main Workspaces & Production

1. 🎼 Timeline & Multitrack Arranger (Playlist)

Linear multitrack editor with FL Studio-style clip dragging, magnetic loop snapping, continuous waveforms, tool palette, and live microphone track.

2. 🥁 16-Step Channel Rack & Drum Sequencer

Tactile step buttons with glowing center LEDs, mute/solo status, dedicated volume/pan rotary knobs, and sample quick-select.

3. 🎹 Piano Roll & Interactive Touch Keyboard

Polyphonic note editor with note lengths, velocity, scale snapping, and playable keyboard with neon visual feedback.

4. 🎙 Vocal Studio & Microphone Recording (Take Lanes)

Professional recording console for vocals and acoustic instruments with pitch detection, offline autotune, formant-preserving pitch shift, and a 4-part harmonizer.

5. 🎤 Vocal Studio: Custom Sound & Sampler Recording

Record acoustic instruments or custom samples directly from microphone and map them into synths and drum tracks.

6. 🎚 Master & Multitrack Effects Mixer

Full mixing console with individual channel strips, VU meters, per-track 3-band parametric EQ, and reverb/delay sends.

---

2. 🎛️ Synthesizers, AI Engines & Signal Processing

7. 🤖 AI Music Assistant & Prompt Engine

Generate chord progressions, melodies, basslines, and song ideas via natural language text prompts (OpenAI, Anthropic/Claude, OpenRouter, or local Ollama), with a built-in rule-based generator as fallback.

8. ✨ Sonix Alchemy Synthesizer

Advanced hybrid synth with 4 oscillator waveforms (Sine, Sawtooth, Square, Triangle), a resonant state-variable filter, ADSR envelope, and an 8-point morph vector pad.

9. 🥁 Dynamic Session Drummer

Interactive XY control pad for groove complexity and energy dynamics, with humanize engine, style variations, and fill-ins.

10. 🧩 Modular Patcher & The Grid

Visual modular node environment for connecting audio signals, filters, envelopes, LFOs, and distortion with virtual patch cables.

11. 🧠 Stem Separator (DSP + optional Neural ONNX)

Source separation to isolate vocals, drums, bass, and instruments from mixed tracks. Runs a lightweight spectral DSP separator by default, or a real HTDemucs ONNX model when built with --features neural and a model is installed.

12. 🔌 Plugin & VST/CLAP Bridge Manager

Cataloguing of FL Studio .fst presets and CLAP, VST3, VST2, LV2, and Wine/Yabridge plugin locations (scanning & verification — CLAP, VST3 and VST2 processing opt-in, LV2 hosting not yet implemented).

13. 🎛 Remix FX (Live Performance Pad)

Live DJ performance effects with Kaoss-style XY matrix, stutter repeater, vinyl tape stop, and reverse.

---

3. 🎙 Creative Studio Panels & Vocal Modules (Soundtrap-Inspired)

14. 🎤 Microphone & Hardware Vocal Panel

Input device selector, hardware gain boost (+0dB to +24dB), noise gate, acoustic feedback suppression, and vocal character presets.

15. 🎹 Smart Chord & Harmony Matrix

Scale-aware Roman numeral chord matrix, strum spread humanizer, block/arpeggiated styles, and one-click Piano Roll stamping.

16. 🎯 Hardware Strobe Tuner

Ultra-high precision chromatic strobe tuner with real-time frequency analysis, ±cents deviation, and 440Hz calibration.

17. 🎲 Beat & Melody Dice Generator

Algorithmic generator for drum rhythms and melodic hooks with musical scale locks and syncopation controls.

18. 🎛 Modular FX Pedalboard & Vocal Rack

Multi-effect chain with Vocal Doubler, Analog Tube Compressor, Dynamic De-Esser, Noise Gate, and Resonant Filter.

19. 🎼 Song Section Arranger

Define and arrange Intro, Verse, Chorus, Bridge, Drop, and Outro sections on the timeline.

20. ➕ Add Track Studio Creator

Modal for quickly instantiating Vocals/Mic, Sample Audio, 808 Drums, Synth Lead, Bassline, or FX Bus tracks.

---

4. ⚙️ Dialogs, Modals & System Configuration

21. ⚙ Audio & Driver Settings

Shows the real cpal host and output device, the active stream (sample rate · buffer · channels), and lets you apply a new sample rate/buffer by rebuilding the stream live (persisted to ~/.config/sonix/audio.json).

22. 🤖 AI Configuration & API Keys

Setup credentials and connections for OpenAI, Anthropic/Claude, Stability Stable Audio, and local Ollama servers.

23. 💾 Project Manager & Templates

Create new projects from music templates (Synthwave, Trap, House, Ambient), save, and load projects.

24. 💿 Render & Master Export Queue

Offline full-project rendering (real channel WAV samples + timeline audio stems + FX) to WAV (16/24-bit & float), FLAC (24-bit lossless), MP3 (320 kbps), OGG Vorbis and AAC/M4A. Choose master mix or per-track dry/wet stems, sample rate and clean metadata (title/artist/album/genre/year/comment) tagged only with Sonix Studio – never AI/provider info. WAV/FLAC are encoded in-app; MP3/OGG/AAC use ffmpeg when installed. Includes EBU R128 loudness normalization (BS.1770 K-weighted gated measurement + true-peak ceiling via 4× oversampling) with one-click delivery presets (Streaming/Apple Music/Broadcast/Club).

25. 📥 Suno AI Stem Importer

Automated loading and unzipping of Suno AI stems directly from zip archives or folders.

26. 🎛 Hardware Controllers & MCU/OSC

Hardware controller support for Behringer X-Touch, Novation Launchpad, ALSA MIDI, and OSC network control.

27. 🔍 Focused Stem & Region Editor

Detailed audio region editor with volume envelopes, fade in/out curves, reverse, and sample slicing.

28. 📖 Interactive Help Guide & Manual

Built-in comprehensive manual with shortcut lists, signal flow diagrams, and workflow guides.

29. ℹ About Sonix Studio

Version information, audio engine details, system architecture, and license.

📜 License

Sonix Studio is dual-licensed under either of

• MIT License (LICENSE-MIT)
• Apache License, Version 2.0 (LICENSE-APACHE)

at your option. Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project by you, as defined in the Apache-2.0 license, shall be dual-licensed as above, without any additional terms or conditions.