Spotifast: a Rust Spotify client built on egui and librespot

What Spotifast replaces, and for whom

Spotify's own desktop app ships a browser engine to draw a music library. Spotifast does not. The README states the project is a Spotify client written in Rust with egui that plays music through librespot, and that it typically uses 100-250 MB of RAM while Spotify's desktop app often uses 600 MB to over 1 GB. That single number is the pitch: the app is a native window, not a web view.

The intended user is someone with Spotify Premium on Linux, macOS, or Windows who wants the library and the playback in one process, and who may also want to control playback on other devices. The README says playback needs Spotify Premium, and that Free accounts can browse and search but cannot play music through Spotifast on this computer or another device. That is not a soft limitation. If you do not pay for Premium, the app is a browser for your library and nothing more.

The secondary audience is people running librespot or spotifyd on a home network. Spotifast finds librespot, spotifyd, and supported hardware receivers over mDNS, and once connected they appear as Spotify Connect devices. So the app is both a client and a discovery tool for a self-hosted audio setup.

egui for drawing, librespot for audio, keyring for credentials

The architecture is visible in Cargo.toml. eframe with the glow backend and egui 0.36 draw the interface; the comment in the manifest says glow keeps the binary and the dependency tree small, and that wgpu is not needed for a 2D music client. AccessKit is enabled, which connects egui's control names, states, and actions to native screen readers. Audio comes from librespot, which the README names as the playback engine.

Credentials are handled through keyring-core, with the manifest comment stating that one protected-store API is used with each target's native provider, and that durable Spotify grants must not be copied into ordinary state JSON. That is a deliberate split: tokens live in the platform keyring, while ordinary settings stay in JSON. The dependency list also includes directories for platform config paths and a small translation crate generated from PO files at build time, with no system libintl or runtime catalog parsing.

There are two binaries. `spotifast` is the main command, and `fastpotify` remains available for existing scripts. The Cargo package is still named `fastpotify` so existing cargo-install users keep working. The crate targets edition 2024 and rust-version 1.95, so a current toolchain is required.

The Home view pulls Made for you, Recently played, top artists and songs, and recommendations. Library covers playlists, Liked Songs, saved albums, followed artists, podcasts, and saved episodes, with filtering, pinning, and sidebar reordering. Liked Songs reopens from an account-specific metadata cache, and older rows refresh in the background while Like and Unlike take effect immediately. Search spans songs, artists, albums, playlists, podcasts, and episodes, and since 0.8.0 a personal app searches the catalogue while shared access finds playlists, with each part appearing independently even if the other fails.

Installing Spotifast and playing the first track

The README does not inline install commands. It says to see spotifast.rocks for installation, setup, everyday use, and connection details, and it notes that AUR and Homebrew packages now use the Spotifast name. The repository also carries a flake.nix, a packaging directory, and a PACKAGING.md, so source and Nix builds are clearly part of the project's surface, but the README defers to the website for the actual steps. Do not guess a package name or a flag from this page; read the site.

What the README does document is the command surface. The main command is `spotifast`:

spotifast

Running it opens the app window. The README says it starts in well under a second and has no browser engine. On first launch you sign in, and the credential is stored through the platform keyring rather than in plain state files.

Once signed in, the shortest path to audio is the device picker. The README describes Spotifast as appearing as a Spotify Connect device, so you can select it from your phone or play music in the app. To play locally, open a playlist and use Play. Since 0.8.0, double-clicking a playlist in Library starts playback, while a single click opens it.

If you have librespot or spotifyd running on the same network, Spotifast finds them over mDNS and lists them as Connect devices:

spotifast

The picker uses responding receivers' names and combines entries with the same device ID. Long device lists scroll. From there, play, pause, skip, seek, shuffle, repeat, and volume all apply to the selected device.

For scripts that already call the old binary name, the compatibility command still exists:

fastpotify

The README says settings and credential stores keep their established paths, so an upgrade should not require re-authentication.

Playback limits: Premium, connection timeouts, and seek behaviour

The first hard boundary is the account tier. Free accounts can browse and search, but cannot play music through Spotifast on this computer or another device. If your use case is casual listening on a free account, this app cannot serve it, and no configuration will change that.

The second is network behaviour. The README states that stalled Spotify connections time out after five seconds per attempt so playback can try another endpoint. That is a reasonable default for a home network, but it means a flaky or slow endpoint produces retries rather than a long patient wait. On a congested link, expect the client to move on rather than hold the stream.

Seeking has its own caveat. Since 0.8.0, a confirmed local seek discards audio queued from the old position, but the README adds that decoder, download, and device-buffer delays can still apply. In other words, the queue is corrected, not the pipeline. If you are testing seek accuracy against a local cache, measure the audible result rather than trusting the state change.

There is also a metadata dependency. Artist names in the player bar open their pages, including during local playback before Web API metadata arrives, which the README lists as available since 0.8.0. That phrasing implies metadata can lag behind audio, and the app is designed to stay usable while it does. If you need every label correct the instant a track starts, that gap is a real one.

Finally, the README says the app registers for `spotify:` links and that `open.spotify.com` addresses go through the browser, which hands them to the same handler. That means link handling depends on the desktop's registered handler being intact, not only on Spotifast being installed.

ncspot and the terminal player comparison

The obvious alternative for a lightweight Spotify client is ncspot, a terminal player. The difference is not cosmetic. ncspot draws in a terminal and fits into tmux, SSH sessions, and keyboard-driven workflows. Spotifast draws a native egui window with AccessKit, right-click menus, drag-and-drop playlist editing, and a device picker, and it registers as a Spotify Connect target that other devices can select.

If your environment is a headless server or a terminal multiplexer, ncspot is the closer fit; Spotifast expects a graphical session. If your environment is a desktop where you also want to move playback to a speaker or a phone, Spotifast's Connect device role and mDNS discovery of librespot, spotifyd, and hardware receivers are the parts ncspot does not cover in the same way.

The other comparison worth making is against Spotify's own desktop client. The README's memory figures, 100-250 MB against 600 MB to over 1 GB, and the absence of a browser engine, are the stated reasons to switch. What you give up is everything Spotify's client does that the README does not mention. Podcasts and saved episodes are listed, but video podcasts, social features, and the full non-music surface are not described. Treat Spotifast as a music and audio library client, not a drop-in replacement for every Spotify screen.

Maintenance, the 0.8.0 rename, and the MIT licence

The repository is not archived, and the last push was on 2026-09-16. Releases are close together: v0.8.0 on 2026-09-14, v0.7.1 on 2026-09-09, and v0.7.0 on 2026-09-06. That cadence is the strongest signal in the repository that the project is being worked on, and it also sets the upgrade cost. A client shipping point releases days apart means you should expect to update often if you want the listed fixes, such as the 0.8.0 seek behaviour, sorted-view playback, and the search field layout fix in narrow windows.

The rename is the upgrade risk. The project was previously Fastpotify, and the new name starts with version 0.8.0. The README says settings and sign-ins carry over, except when switching the Flatpak installation, and points to docs/_reference/renaming.md for the details. The `fastpotify` binary remains for existing scripts, and the Cargo package name is unchanged, so cargo-install users are insulated. AUR and Homebrew packages now use the Spotifast name, which means anyone pinned to the old package name needs to move.

The licence is MIT, stated in Cargo.toml and present as a LICENSE file at the repository root. MIT is permissive: it allows reuse and redistribution with the licence and copyright notice retained. That is a general description of the licence text, not advice about your situation. If you plan to redistribute a build, read the LICENSE file and the packaging notes yourself. Spotifast is a client for a proprietary service, so the licence on this code says nothing about your rights to Spotify's catalogue or your account terms. Those are separate questions the repository does not answer.

Editorial conclusion

Spotifast suits Linux, macOS and Windows users with Spotify Premium who want a native client that uses roughly 100-250 MB of RAM, starts in well under a second, and doubles as a Spotify Connect device on the local network. It is the wrong choice for Free accounts that need playback, and for anyone who wants Spotify's full non-music surface such as video podcasts or its social features, which the README does not describe. Before adopting it, verify that the v0.8.0 rename did not break your install path: the README points to docs/_reference/renaming.md, and says settings and sign-ins carry over except when switching the Flatpak installation. Check that your distribution or Homebrew package now uses the Spotifast name, and confirm your audio stack works with the glow renderer before you migrate a working setup.

Frequently asked questions

Official sources

1. crmne/spotifast on GitHub
2. License: MIT
3. Project website
4. README
5. Releases