Fauste Player

Radio playout for the desktop: several players, a cartwall and sample-accurate mixes.

Download · Website · User guide

Fauste Player is a desktop radio playout application for Linux, Windows and macOS, written in Rust. It runs any number of independent players side by side, each with its own playlists, transport and outputs, with sample-accurate overlapping mixes, a separate pre-listen (CUE) output, and an audio engine that the interface can never block.

The user guide is in English, with AI translations into Català, Deutsch, Español, Euskara, Français, Galego, Italiano, Nederlands, Polski and Português.

Built with AI assistance, provided as is. Fauste Player, its documentation and its translations were developed with substantial help from AI tools. It comes without any warranty and you use it at your own risk: see the Disclaimer.

Contents

Features · Platform support · Install · Build from source · Develop · How it is built · Versioning and releases · Roadmap · Documentation · Working with AI agents · Contributing · Security · Disclaimer · Licence

Features

• Independent players: four by default, any number configurable. Each has Play/Next, Stop, Fade stop, Pause and Stop-after-current, SINGLE and CONT modes, a countdown with tenths, a stereo meter, a mixing-desk volume fader (fine near 0 dB, with fine adjust and a scale) and its own playlist tabs (they shrink, cut long names and scroll). Times keep a fixed width as they count.
• Resizable layout: drag the gaps to resize the players and the cartwall, put the cartwall under the players or on their left or right, hide the panels a shift does not use (a hidden panel that is on air keeps playing; every tile shows a red dot while its player plays and pause bars while it is paused), maximize one for a moment, and lock the layout against stray drags. The layout is saved with the session.
• About window: the window's title bar shows "Fauste Player "; the info button next to Settings opens the author, the copyright, the licence, a short disclaimer and the licence notices of the bundled components.
• Restore defaults: Players, Meters, Analysis, Loudness and Shortcuts can each be reset to their defaults.
• Live settings: every setting applies while the application runs. A change to the outputs waits until nothing plays on what it affects (a Settings pending pill says what waits and on what), or applies at once with Apply now, after a confirmation when it would briefly interrupt the audio.
• Close guard: closing the window while audio is on air asks first, lists what is sounding, and offers Stop and close or Cancel.
• Standard level meters: digital peak (IEC 60268-18), EBU and DIN PPM (IEC 60268-10), VU (IEC 60268-17) and K-System (K-20, K-14, K-12), each with its own ballistics and scale. Optional true peak and EBU R128 loudness, and a maximum readout.
• Loudness normalization: on by default. Every track and cart plays at the same integrated loudness (ITU-R BS.1770, EBU R128) with one fixed gain per track, measured in the background, limited by a true-peak ceiling and a maximum boost. A badge in each player header shows the gain on air; any track can be excluded or trimmed. A bit-perfect output is never normalized.
• Sample-accurate mixing: in continuous mode the next track starts exactly at the MIX point and overlaps the fading end of the current one. How far below the track's own level the MIX point sits, and the maximum overlap, are configurable.
• Automatic markers: background analysis finds cue-in, cue-out, the MIX point and the outro. It also reads tags and cover art, and draws the waveform. Markers set by hand are never overwritten.
• CUE pre-listen on a separate device or channel pair (or, with one sound card, on the on-air output, asking first while something plays), with a window per CUE to seek, zoom, edit markers, pause, stop and load the track as next.
• Cartwall: pages of instant carts (jingles, effects, spots), each with a configurable grid. Carts overlap by default; they can loop gaplessly or stop the others, and a Stop all button stops every playing cart. They have their own Main and Cue outputs. Each cart can take one of eight colours and shows its waveform faintly behind its name. It sits under the players or beside them: under them the configured rows always fit the window (the buttons shrink to a minimum before the area scrolls), and resized or beside them the buttons grow to fill it. Pages can be imported and exported.
• Tag editor and track tooltip: hover a track for its tags, format and path; edit the common tag fields (title, artist, album, date, track and disc numbers, genre, BPM, key, lyrics and more) and the front cover (view, change, remove) of MP3, FLAC, MP4, WAV and other files, written safely into the file.
• Configurable track tables: choose and order the columns (title, artist, album, date, genre, intro, file name and more) from Settings, the header menu or by dragging a header; columns resize live; tables open at the next track; Reset played clears a playlist's played marks.
• Marker editing on the waveform: cue in and out, intro, outro and MIX, set from a menu or with Alt-drag. An INTRO tag can also set the intro. A setting makes players ignore cue-in and cue-out and play whole files.
• Remappable keyboard shortcuts for players and carts.
• MIDI control surfaces: every player's transport buttons and volume fader can be learned onto a MIDI controller, with soft takeover for faders, LED feedback and hot-plug.
• Remote control: an HTTP/JSON API with live events (Server-Sent Events) and OSC, off by default and set up in Settings → Remote. A web page, a phone app, automation or a control surface can follow the players, playlists and cartwall, operate them, and edit playlists, cart pages, markers and a track's loudness settings. A token, origin checks and source allow-lists protect it when it listens on the network.
• M3U / M3U8 / PLS import and M3U8 export.
• Bit-perfect output: a special mode for audiophile playback, off by default. A device is played with exclusive access and follows each track's sample rate, with a short silence between two tracks when it changes; the players on it never crossfade (each track plays to its end, then the next starts) and their volume is held at 100 %. With no fade and nothing else on the outputs the samples reach it unchanged, and a BP badge says so (ALSA hw: devices, WASAPI exclusive mode, Core Audio hog mode).
• DSD output: on a bit-perfect device, a DSD track can reach the converter unchanged, as DoP (every system) or as native DSD (Linux, ALSA hw: devices whose driver reports a DSD format), with a DSD badge. DoP and native DSD are checked on simulated devices only; a check on a real converter is still to do.
• Per-device outputs: Settings → Audio outputs has a Basic and an Advanced view; in Advanced each device can have its own sample rate and buffer size, and shows its bit-perfect switch and DSD mode with why a mode is not offered.
• Routing per player: Main and Cue outputs on any device and channel pair. Multichannel interfaces carry several players at once.
• Resilient:
  • if an output device is lost, the timeline keeps running on a virtual clock and the device reconnects on its own;
  • decoder, analysis, services and interface panics are contained;
  • saves are transactions in a SQLite database, with rotating backups;
  • after a crash, players come back paused at their positions, and nothing goes on air by itself.
• Fast, dense interface (egui). Virtualised track tables handle thousands of entries, with drag and drop within and across players and onto tabs, drops from the file manager, a context menu and keyboard shortcuts.
• Eleven-language interface (Fluent): English, Spanish, Catalan, Dutch, French, Galician, German, Italian, Basque, Polish and Portuguese. It follows the OS language or the language chosen in Settings. The interface in every language, English and Spanish included, was produced with AI and may contain errors. Corrections are welcome as issues or pull requests.

Platform support

OS	Audio systems	Bit-perfect
Linux (x86-64, ARM64)	PulseAudio (also on PipeWire desktops), JACK, ALSA; native PipeWire in builds with the pipewire feature	ALSA hw: devices
Windows 10/11 (x86-64)	WASAPI, JACK, ASIO (when built with the SDK)	WASAPI exclusive mode
macOS (Intel, Apple silicon)	Core Audio, JACK	Core Audio hog mode
Android 10+ (ARM64, x86-64): in development; the signed APK ships with each release from the next one, and Google Play follows (guide)	AAudio	—

With nothing configured, the first available system is used, in this order:

• Linux: PipeWire, PulseAudio, JACK, ALSA;
• Windows: WASAPI, ASIO, JACK;
• macOS: Core Audio, JACK.

Systems that are missing on a machine show as unavailable in Settings; the application still starts.

Formats: WAV, AIFF, CAF, FLAC, MP3 (and MP1/MP2), AAC/M4A, ALAC, Ogg Vorbis, Opus, WavPack, Monkey's Audio (APE), DSD (DSF and DFF) and Matroska audio (MKA). DSD plays converted to PCM, or unchanged on bit-perfect devices as DoP or native DSD. Whole programme recordings play like songs: a 4-hour file is analysed in under a minute, with memory that does not grow with its length, and seeks at once.

Install

On Windows, install it from the Microsoft Store (x86-64, updated automatically). On Linux, install it from the Snap Store with sudo snap install fauste-player (amd64 and arm64; see the guide for bit-perfect ALSA output, MIDI and music on other disks). Or download a package for your platform from Releases. Each file has a .sha256 next to it.

Platform	Packages
Debian, Ubuntu	fauste-player_<version>_amd64.deb / _arm64.deb: sudo apt install ./fauste-player_*.deb
Fedora, openSUSE	fauste-player-<version>-1.x86_64.rpm / .aarch64.rpm: sudo dnf install ./fauste-player-*.rpm
Any Linux	fauste-player-<version>-x86_64.AppImage / -aarch64.AppImage, or the Flatpak bundle fauste-player-<version>-x86_64.flatpak
Windows	fauste-player-<version>-x86_64-pc-windows-msvc.msi
macOS	fauste-player-<version>-macos-universal.dmg (Apple silicon and Intel)
All	Portable archives (.tar.gz, .zip) per target

See the getting started guide for installing, updating and removing each one, and for first starts of unsigned builds on macOS and Windows. The Windows release is a GUI program: it opens no console window.

Build from source

The toolchain is pinned in rust-toolchain.toml (Rust 1.98.1, edition 2024). Install rustup; it picks the right version by itself.

Linux

Distribution	Packages
Debian, Ubuntu	sudo apt install build-essential pkg-config libasound2-dev libdbus-1-dev
Fedora	sudo dnf install gcc pkgconf-pkg-config alsa-lib-devel dbus-devel
Arch	sudo pacman -S base-devel pkgconf alsa-lib dbus

PulseAudio support needs no extra package. To build with the optional audio systems:

sudo apt install libpipewire-0.3-dev libspa-0.2-dev libjack-jackd2-dev clang   # Debian, Ubuntu
cargo build --release -p fp-app --features pipewire,jack

JACK is loaded at run time on every OS, so a jack build still starts where JACK is not installed; on Windows and macOS it needs no SDK to build. pipewire links libpipewire, so that build needs PipeWire installed to start. ASIO needs the Steinberg ASIO SDK: set CPAL_ASIO_DIR to it and build with --features asio.

The release archives are built with jack only. PipeWire desktops are served through PulseAudio (pipewire-pulse), and the archives start on any Linux with ALSA and D-Bus.

The window system libraries (X11 or Wayland, libxkbcommon, OpenGL) are loaded at run time. Any desktop has them. Minimal systems may need libxkbcommon-x11-0 and libgl1 (or their equivalents).

Windows

Install the Visual Studio Build Tools with the Desktop development with C++ workload (MSVC and the Windows SDK), then rustup. Use the default x86_64-pc-windows-msvc toolchain.

macOS

xcode-select --install

Build and run

git clone https://github.com/sanchezfauste/fauste-player.git
cd fauste-player
cargo run --release -p fp-app          # builds and starts target/release/fauste-player

To try it with a ready-made state (four players and three playlists built from a folder of audio files):

FAUSTE_HOME=/tmp/fp-demo cargo run -p fp-app --example demo_session -- ~/Music
FAUSTE_HOME=/tmp/fp-demo cargo run --release -p fp-app

FAUSTE_HOME keeps every file of the application in one folder (portable mode). Without it, the OS locations are used; see Data and backups.

Develop

Workspace

Crate	Role
fp-model	Pure domain state and player rules: commands in, engine actions out
fp-store	SQLite persistence, backups, migrations, config
fp-decode	File decoding (symphonia) to stereo f32
fp-dsp	Signal processing shared by the meters and the analysis: K-weighting, true peak, BS.1770 loudness
fp-backends	Audio backends: system through cpal, Null, Offline for tests
fp-engine	Real-time mixer, buses, decode workers, the conductor thread
fp-analysis	Tags, covers, peaks, automatic markers, cache, background pool
fp-app	The egui application and the fauste-player binary

Everyday commands

cargo fmt --all                                        # format
cargo clippy --workspace --all-targets -- -D warnings  # lint (CI fails on any warning)
cargo test --workspace                                 # all tests: no sound card or display needed
cargo test -p fp-engine --test it conductor::          # one test file
cargo test --release -p fp-engine --test it -- --ignored conductor::six_simulated_hours   # soak
cargo deny check                                       # licences, advisories, sources
RUST_LOG=debug cargo run -p fp-app                     # verbose logs
git config core.hooksPath .githooks                    # enable the Conventional Commits hook

Rules the code follows

• No unsafe (forbid workspace-wide), and no unwrap, expect or panic outside tests. The audio and analysis crates deny clippy::indexing_slicing.
• The real-time thread never allocates, frees, locks, logs or panics. assert_no_alloc tests enforce it. See Threading and real time.
• Behaviour lives in the pure fp-model reducer and is tested rule by rule, without audio.
• No hardcoded product limits: everything tunable is in Config, with defaults, ranges and lenient loading.
• TDD: write the failing test first. UI interactions are tested headlessly with egui_kittest.
• English for all code, identifiers, comments, commits and docs. Every UI string goes through Fluent, in en-US and in every other locale file.

How it is built

The design started as an interactive prototype (the "v3" main screen with the Nocturne design system). It became a binding design spec: normative player rules, engine, backends, analysis, persistence, UI, security, testing and phases. Each phase is split into implementation plans in docs/superpowers/plans. Each plan was executed task by task with test-driven development, then reviewed by a fresh reviewer, and reaches master through a pull request once CI is green on every OS. Deviations and decisions are recorded as rulings in the plans.

In short:

• the UI sends commands to a conductor thread;
• the conductor applies them through the pure model reducer and turns the resulting actions into sample-accurate commands for one real-time mixer per output device;
• per-player worker threads decode and resample into lock-free rings, above normal priority but never real time;
• analysis runs on a low-priority pool, and saving on its own thread;
• the UI reads immutable snapshots and never waits for the audio path.

Details are in the technical documentation.

Versioning and releases

• Semantic Versioning and Conventional Commits (feat(engine): …, fix(ui): …, docs: …).
• release-please keeps a release PR that bumps the version and writes the changelog.
• Merging the release PR tags vX.Y.Z, publishes the GitHub release, and attaches binaries for Linux (x86-64, ARM64), Windows (x86-64) and macOS (Intel, Apple silicon), with checksums and third-party licence notices.

See Release process.

Roadmap

Phase	Content	Status
1. Usable core	Players, mixing, CUE, analysis, persistence, main screen, Settings subset, CI and releases	done
2. Cartwall and full Settings	Cart pages, remappable shortcuts, language selector, M3U/M3U8/PLS import and export, manual marker editing	done
3. Native backends	PipeWire, PulseAudio, JACK, ASIO	done
4. Bit-perfect	Output at the file's rate and format with no processing, BP badge; ALSA hw:, WASAPI exclusive mode, Core Audio hog mode	done (Windows and macOS need an on-device loopback check)
5. Packaging	deb, rpm, Flatpak, AppImage, MSI, universal dmg; signing and notarisation when certificates are configured	done
6. Audio path	Audio path audit and its fixes (no clicks at starts, joins and cue-outs; clipped integer conversion; xrun reporting), DSD output as DoP or native DSD on bit-perfect devices, "No output (silent)" device	done (DoP and native DSD need a check on real hardware)
7. Website and guide	Project website on GitHub Pages with per-platform downloads, the landing page, privacy policy and user guide online (mdBook) in every interface language with AI translations and a shared language menu, screenshots of every screen from a scripted scene	done
8. Stores	Publishing every release to the Microsoft Store, the Snap Store, Google Play, Flathub, WinGet and the AUR from CI	in progress (the Microsoft Store and the Snap Store since 0.11.0; Google Play ready, with its listing and screenshots in every interface language, for the first release with the Android app; Flathub, WinGet and the AUR not yet submitted)
9. Mobile	An Android app on the same Rust core: one or more players and the cartwall with music on the device, a foreground service so playout survives the screen and the app switcher, a touch layout; iOS later (mobile spec)	in progress (the app, its touch layout, output choice and music browser are built, and releases are signed; the first Google Play release and checks on real phones are next)

Documentation

• Website and the user guide online
• User guide (the source of the online guide, which is also available in ten other languages, translated with AI)
• Technical documentation
• Design spec and implementation plans
• Changelog

Working with AI agents

The project is developed with Claude Code and the superpowers skills. CLAUDE.md is the canonical guide for agents (rules, commands, invariants, workflow). AGENTS.md points other agents to it.

Install the skills from the official plugin marketplace inside Claude Code (/plugin → superpowers). Use them as follows:

Situation	Skill	How
A new feature or phase	superpowers:brainstorming	Explore the idea, agree the design, update the spec
A spec is agreed	superpowers:writing-plans	Write docs/superpowers/plans/<date>-<phase>-<plan>.md with tasks, interfaces and a review focus
Implementing a plan	superpowers:executing-plans (inline) or superpowers:subagent-driven-development	Task by task, with a ledger in .superpowers/sdd/
Writing any code	superpowers:test-driven-development	Red, green, refactor; never skip the failing run
A bug or a failing test	superpowers:systematic-debugging	Find the cause before changing code
Before claiming done	superpowers:verification-before-completion	Run the checks and read the output
After a plan	superpowers:requesting-code-review	A fresh reviewer on the most capable model reviews the whole branch
Handling review findings	superpowers:receiving-code-review	Verify each finding, then fix it test-first
Finishing	superpowers:finishing-a-development-branch	Green suite, then merge or PR
Isolated work	superpowers:using-git-worktrees	One worktree per branch

The UI design lives in a Claude Design project, which agents can read through the claude_design MCP server (see CLAUDE.md).

Contributing

See CONTRIBUTING.md.

Security

See SECURITY.md. The application makes no network connections and sends no telemetry; the privacy policy (site/privacy.html, with its texts in site/locales) says so for the stores.

Disclaimer

Fauste Player, its documentation and all its interface texts and translations (English and Spanish included) were developed with substantial help from AI tools and may contain errors.

The program is provided "AS IS", without warranty of any kind, express or implied, including the warranties of merchantability, fitness for a particular purpose and non-infringement. You use it entirely at your own risk. To the maximum extent permitted by applicable law, the author and the contributors are not liable for any damages of any kind, whether direct, indirect, incidental or consequential, including dead air, interrupted or wrong broadcasts, loss of data, loss of revenue or audience, regulatory fines or sanctions, and damage to equipment or hearing caused by audio levels.

The operator is solely responsible for checking that the program is fit for their use, for supervising their broadcast, and for holding the rights and licences for the content they play.

This notice summarises, and does not replace, sections 15 and 16 of the GNU General Public License (disclaimer of warranty and limitation of liability).

Licence

Fauste Player is free software, released under the GNU General Public License version 3 or (at your option) any later version (GPL-3.0-or-later). Copyright (C) 2026 Marc Sánchez Fauste.

NOTICE adds one term, under section 7(b) of the licence: anyone who conveys the program, modified or not, must keep this attribution, with its link, in the program's About window (or the equivalent screen that shows credits to users):

Fauste Player by Marc Sánchez Fauste

A modified version may present it as "Based on Fauste Player by Marc Sánchez Fauste".

The name and the logo may be used freely.

Bundled third-party components keep their own licences:

• the Inter font: SIL Open Font License 1.1, OFL.txt;
• the Phosphor icons: MIT, Phosphor-MIT.txt;
• every Rust dependency: listed in licenses/THIRD-PARTY.html inside each release archive.

The About window (the info button in the top bar) shows the version, the author attribution with the project link, the copyright, the licence, the disclaimer, both bundled notices and a button that opens the installed THIRD-PARTY.html.