MixApp

MixApp is a desktop application for preparing timeline-based DJ mixes. The primary desktop UI is Tauri 2, Svelte, TypeScript, and PixiJS. Python owns project, analysis, and audio behavior through the versioned stdio engine bridge.

Run from source

Install Python 3.12+, Node.js, Rust, and the platform prerequisites for Tauri. Then run:

python -m pip install -r requirements.txt
cd ui-v2
pnpm install --frozen-lockfile
pnpm run tauri dev

Build the desktop application with:

cd ui-v2
pnpm run tauri build

The Tauri bridge uses the system Python only in development. Production builds launch a packaged mixapp-engine sidecar from Tauri's resources/engine/ directory. Build the engine with Python 3.12 and the reviewed Windows dependency lock, then stage the pinned FFmpeg and Rubber Band binaries alongside it:

./tools/build_engine.ps1 -FfmpegPath C:/path/to/ffmpeg.exe -RubberBandPath C:/path/to/rubberband-3.dll -NonCommercialDistribution

Then build the desktop app from ui-v2/ with pnpm run tauri build. The packaged engine is platform-specific; build it separately on each target OS. The Windows Rubber Band runtime can be built with tools/build_rubberband.ps1 (Git, Meson, and Visual Studio C++ Build Tools required). For development, pnpm run tauri dev continues to use Python from PATH or MIXAPP_PYTHON_EXECUTABLE. Madmom track analysis uses up to four process workers on larger machines for tracks at least three minutes long. The process count (1, 2, 4 or 8) is selected in Application settings and saved for later sessions; an existing MIXAPP_MADMOM_WORKERS environment value is still honored when no app preference has been saved.

The current packager uses PyInstaller one-folder mode: it avoids unpacking the complete scientific stack at every engine launch and keeps native dependencies inspectable. Nuitka standalone is a viable later comparison, but adds C compiler/toolchain requirements; one-file modes for either tool trade simpler delivery for extraction/startup behavior and are not the current target.

Audio-only Windows FFmpeg

tools/build_ffmpeg_audio.sh cross-compiles a standalone Windows x64 FFmpeg from the same pinned source commit as the current full build. It retains audio decoding for existing Library imports, MP3/WAV encoding and canonical float PCM output; video codecs, network access and capture devices are disabled. Runtime CPU detection and x86 SIMD remain enabled. LAME is statically linked.

Run on an x86_64 Linux/WSL host with Bash, curl, tar/xz, GNU make, GCC, Perl and sha256sum. The script downloads hash-pinned LLVM-MinGW, NASM, FFmpeg and LAME archives into its work directory; it does not install system packages. Prefer a Linux filesystem for the work directory when using WSL:

bash /path/to/mix-app/tools/build_ffmpeg_audio.sh /path/to/linux-build-directory

The binary is written to <work-directory>/dist/ffmpeg.exe, with licenses and the exact configuration. Copy the entire dist directory to Windows before verification. In the Windows checkout:

python tools/verify_ffmpeg_audio.py --reference ui-v2/src-tauri/resources/engine/ffmpeg.exe --candidate build/ffmpeg-audio/candidate/ffmpeg.exe --output build/ffmpeg-audio/validation

This checks generated fixtures through MixApp's actual decode/encode service, including MP3 artwork, AAC audio inside an MP4 video, mono/multichannel input, all export variants and 120-second decode comparisons. It writes report.json. The native Windows lock now pins this audio-only build. Copy the verified binary to app/native/ffmpeg.exe for source development; FFmpegService prefers it over the system FFmpeg. Frozen engines prefer the binary beside the sidecar. Explicit executable arguments still take precedence, and PATH remains a fallback if the local binary is absent. Rebuild the engine with the verified dist/ffmpeg.exe and its sibling licenses/ directory using tools/build_engine.ps1. The build and verification tools do not modify an installed app or publish releases.

Signed Windows releases

Python engine packaging uses tools/mixapp_engine.spec. It retains the audio analysis paths and runtime data, excluding unused librosa decomposition, segmentation, effects and display modules and their scikit-learn dependency. The development lock still installs scikit-learn as a librosa dependency. Foreign PortAudio binaries are excluded on Windows x64. Both x64 PortAudio variants (normal and ASIO) remain. Each build writes its exclusion inventory to build/pyinstaller/mixapp_engine/engine-package-report.json.

Synchronized offline export uses the bundled Rubber Band R3 CLI, separate from the realtime preview library. tools/build_engine.ps1 prepares its hash-pinned official Windows archive automatically. For source runs, execute tools/prepare_rubberband_cli.ps1 once. The resolver honors explicit paths and RUBBERBAND_PATH, then checks the bundle before system/user tools. The CLI and its libsndfile dependency live together under rubberband-cli/.

Create the Tauri updater signing key once with pnpm exec tauri signer generate --ci --write-keys "$HOME/.tauri/mixapp-updater.key" from ui-v2/; keep the private key outside Git and back it up securely. For a noncommercial release using the bundled madmom weights, prepare version 0.1.0 with tools/release.ps1 -Version 0.1.0 -NonCommercialDistribution. It verifies the staged engine against the reviewed source and resource manifest (or rebuilds it when both native binary paths are supplied), builds the signed NSIS installer, and writes the installer, .sig, checksums, and updates/latest.json to the ignored release/ directory. Add release-notes/v0.1.0.md first, then commit/push the generated public metadata and publish the prepared assets under the matching Forgejo tag. Commercial distribution requires separate permission for the model weights.

Checks

python -m unittest discover -s tests -q
cd ui-v2
pnpm run check
pnpm run test:ui
pnpm run build
cd src-tauri
cargo test

License

MixApp source is licensed under GPL-3.0-or-later. Bundled third-party software and model weights retain their separate licenses; see THIRD-PARTY-NOTICES.md and the licenses/ folder in the installed application.

Project layout

• ui-v2/ — Tauri/Svelte/PixiJS desktop application
• app/ — Python application, domain, project persistence, analysis, and audio engine
• native/rubberband/ — Rubber Band source and license
• tests/ — Python and UI tests
• tools/ — native build and audio verification scripts

Runtime architecture

The Svelte/PixiJS UI is a presentation client. Tauri's Rust bridge exchanges versioned JSON envelopes with the Python engine, which owns the project model, analysis, transport, timing, and audio rules. UI views refresh bounded snapshots when their domain revisions advance; waveform IPC contains reduced display peaks only, never PCM.

Realtime preview uses Rubber Band's realtime path by default. A Tempo Map or sync edit publishes a completed immutable render snapshot for the next audio block, so a currently rendering block remains internally consistent. Set MIXAPP_PREVIEW_SYNC_MODE=prepared only when deliberately selecting the prepared clip-local compatibility path.

Export captures that same completed render snapshot at the start of the job and creates its own renderer, source resolver, readers, and DSP state. Edits made after export begins cannot alter the rendered audio. PCM and prepared media caches may be reused as immutable resources. Export readiness still checks required media and tempo assets before it writes a temporary file and atomically replaces the destination on success.