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.
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 APK ships with a release once its signing key is set up (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 | Atomic JSON persistence, backups, migrations |
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, Flathub, WinGet and the AUR from CI | in progress (the Microsoft Store and the Snap Store since 0.11.0; 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; the release key and checks on real phones are next) |
Documentation
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.
