⏱️ Lectura: 11 min
Fastpotify starts in under a second and uses between 100 and 250 MB of RAM: that’s how the native Rust alternative to the official Spotify client presents itself, available for Linux, macOS, and Windows.
📑 En este artículo
The project is open source under the MIT license and replaces Electron’s embedded browser engine with an interface built using egui, Rust’s immediate-mode graphics library, and librespot, the open implementation of the Spotify Connect protocol.
TL;DR
- Fastpotify is a native Spotify client written in Rust, with no embedded browser engine.
- It starts in under a second and uses between 100 and 250 MB of RAM according to the official site.
- It plays locally in gapless mode and up to 320 kbps using librespot.
- It supports Spotify Connect: control speakers, phones, or TVs from the same window.
- It includes a Winamp-style mini player (Ctrl+M) compatible with classic Winamp 2 skins.
- It adds a MilkDrop visualizer based on projectM, with fullscreen mode and preset packs.
- It’s open source under the MIT license, built with the egui and librespot frameworks.
- Available for Linux, macOS, and Windows, with MPRIS integration and system tray support on Linux.
Introduction
Spotify’s official desktop client uses an embedded browser engine, the same approach taken by Slack, Discord, or Visual Studio Code with Electron. That architecture makes it easier to share code with the web version, but it comes at a cost in memory usage and startup time. Fastpotify tackles that problem head-on: it’s a native binary with no browser engine, written entirely in Rust.
The idea isn’t new in the ecosystem: projects like spotifyd, ncspot, or spotify-tui have offered lightweight Spotify clients for years. What sets Fastpotify apart is that it aims for a complete graphical interface, with a library, search, visual themes, and even a retro mode inspired by Winamp, without giving up the low resource usage typical of terminal clients.
What happened with Fastpotify
The project’s official site, fastpotify.rocks, presents Fastpotify as a desktop app with local playback, library access, and Spotify Connect controls. The app lets you play music locally in gapless mode at up to 320 kbps, or use the same window to control playback on a speaker, phone, or TV connected to the user’s Spotify account.
Among the announced features are browsing playlists, Liked Songs, albums, artists, and podcasts, plus search across the full catalog and editing of your own playlists. It also includes light, dark, and automatic themes based on the operating system, with the option for both pages and the player bar to pull their color palette from the cover art of the track currently playing.
Two features stand out for being unusual in a modern streaming client: a Winamp-style mini player, activated with the Ctrl+M shortcut, compatible with classic Winamp 2 skins and featuring its own spectrum analyzer, equalizer, and playlist; and a MilkDrop visualizer based on the projectM engine, which runs in its own window with fullscreen mode, preset packs, and keyboard controls.
Background and history
Fastpotify relies on two pieces of free software with their own track record. The first is librespot, a Rust reimplementation of Spotify Connect’s closed protocol that started as a community project more than a decade ago and today powers dozens of alternative clients, including spotifyd (for running as a daemon on Raspberry Pi and embedded systems) and librespot-java. The second is egui, the immediate-mode graphical interface library for Rust, designed to draw the UI directly on the GPU without relying on a browser engine or the operating system’s native widgets.
The combination isn’t accidental: egui allows the same codebase to be compiled for Windows, macOS, and Linux with very few changes, while librespot solves the trickiest part, authenticating and streaming audio as if it were a legitimate Spotify Connect device, without exposing the user’s credentials to a third-party server.
The trend of lightweight native clients versus Electron-based apps isn’t exclusive to Spotify. Editors and terminals written in Rust have competed with the same weapons: GPU rendering, no Chromium engine, and startup times measured in milliseconds instead of seconds.
Technical details and Fastpotify’s performance
The project itself places Fastpotify’s memory usage between 100 and 250 MB of RAM in typical use, well below the several hundred megabytes usually reported by users of desktop clients built on a full browser engine. Startup, according to the same source, completes in well under a second.
For local playback, Fastpotify supports gapless audio (no silence between tracks) and streaming at up to 320 kbps, the maximum quality Spotify Premium offers. When used as a Spotify Connect controller instead of a local player, the audio doesn’t pass through the machine running Fastpotify: the app only sends playback commands to the output device, whether that’s a smart speaker, a compatible Chromecast, a phone, or a smart TV.
On Linux, integration includes support for MPRIS (Media Player Remote Interfacing Specification), the D-Bus standard that lets you control playback from desktop environment widgets, keyboard media keys, or GNOME and KDE applets. It also offers a system tray option to keep music playing after closing the main window.
| Client | When to use it | Advantage | Limitation |
|---|---|---|---|
| Fastpotify | Linux, macOS, or Windows desktop with graphical interface | Native in Rust, low RAM usage, Winamp and MilkDrop | Requires a Premium account for full playback via Spotify Connect |
| Official Spotify | General use without worrying about configuration | Official support and all social features | Higher memory usage from the embedded browser engine |
| spotifyd | Headless servers, Raspberry Pi, DIY speakers | No graphical interface, minimal resource usage | No GUI or built-in library browsing |
| ncspot / spotify-tui | Terminal, remote use over SSH | Lightweight, keyboard-controllable | No visualizations or graphical themes |
For anyone wanting to understand what an app like Fastpotify does under the hood, here’s roughly what authenticating a session with librespot from Rust looks like:
use librespot::core::session::Session;
use librespot::core::config::SessionConfig;
use librespot::discovery::Credentials;
#[tokio::main]
async fn main() {
let session_config = SessionConfig::default();
let credentials = Credentials::with_password("spotify_username", "secret_password");
let session = Session::connect(session_config, credentials, None, false)
.await
.expect("failed to authenticate with Spotify Connect");
println!("Session established: {:?}", session.session_id());
}
This snippet doesn’t reproduce Fastpotify’s actual source code, it just illustrates in a generic way how any client built on librespot handles authentication: it creates a session, provides credentials, and gets an active session identifier before it starts streaming.
How to get started
Fastpotify is distributed as a downloadable native binary from the project’s official site, with separate builds for Linux, macOS, and Windows. Since it’s an MIT-licensed project, the alternative for anyone who prefers to build from source is to clone the repository linked in the “Read the source” link on the official site and compile it with the Rust toolchain:
# Linux and macOS: install the Rust toolchain (one time only)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# clone the repository (exact URL on fastpotify.rocks, "Read the source" section)
git clone URL_DEL_REPOSITORIO_OFICIAL
cd fastpotify
cargo build --release
# Linux / macOS: run the compiled binary
./target/release/fastpotify
# Windows (PowerShell, with rustup already installed)
cargo build --release
.\target\release\fastpotify.exe
The Ctrl+M shortcut opens the Winamp-style mini player once Fastpotify is already running and authenticated against a Spotify account. To confirm the Spotify Connect session is active, just open the official Spotify app on another device and check that Fastpotify appears listed as an available audio output in the Connect device selector.
💡 Tip: if you only need to control another device (a speaker or a TV) and don’t want to play audio on the same machine, Fastpotify works the same way without the local machine processing the audio stream.
⚠️ Heads up: like any client based on librespot, Fastpotify requires a Spotify Premium account for full playback via Spotify Connect; this is a restriction of Spotify’s protocol, not of the application.
Impact and analysis
The interest in native, lightweight clients isn’t an aesthetic whim. A full browser engine gets duplicated by every application that uses it, which multiplies RAM usage when several apps of that kind run at once. A user with several of these apps open can easily rack up several gigabytes of RAM just in graphical interfaces, even on machines with limited resources.
Fastpotify isn’t the first response to this problem and won’t be the last: the Rust community keeps accumulating native alternatives to tools traditionally built on browser engines, from editors to terminals. What sets this project apart is targeting Spotify specifically, a service whose official client rarely gets criticized for its interface but often does for its resource footprint and the lack of deep visual customization options.
The Winamp component deserves its own paragraph for reasons beyond nostalgia. Winamp 2 maintains an active community of skin creators that keeps producing new designs decades after the player’s original release. Fastpotify’s compatibility with those classic skins gives practical use once again to that archive of designs, mostly abandoned since streaming took over.
flowchart TD
A["egui interface (Fastpotify)"] --> B["librespot session"]
B --> C["Spotify Connect protocol"]
C --> D[("Spotify servers")]
C --> E["Speaker, TV, or phone"]
subgraph Local client
A
B
endWhat’s next
The research available on Fastpotify doesn’t include a public roadmap or download figures that would allow measuring its actual adoption. There’s also no confirmation of plans to add social features, like comments or friend activity feeds, which the official client does have: given that it targets a technical user profile, it’s reasonable to expect that performance will remain the priority over feature parity with Spotify.
As with any client built on librespot, the main medium-term threat doesn’t depend on the project itself but on Spotify: the company doesn’t publish an official API for Spotify Connect, and the protocol librespot uses is the result of reverse engineering. A change to that protocol by Spotify could break compatibility overnight, something that has already affected other librespot-based clients before.
📖 Summary on Telegram: View summary
Try it yourself: download the binary for your operating system from fastpotify.rocks or build it with cargo build –release, then hit Ctrl+M to see Winamp mode in action today.
Frequently Asked Questions
What is Fastpotify?
It’s a native desktop client for Spotify, written in Rust with the egui and librespot libraries, with no embedded browser engine, available for Linux, macOS, and Windows.
Do I need a Spotify Premium account to use it?
Yes. As with any client based on librespot, full playback via Spotify Connect requires a Premium account; this is a restriction of Spotify’s protocol, not of the application.
Does Fastpotify replace the device where I’m listening to music?
Not necessarily. Fastpotify can play audio on the machine it runs on, or simply send playback commands to another Spotify Connect device, like a speaker, a TV, or a phone, without processing the audio itself.
What is Fastpotify’s Winamp mode?
It’s a mini player that opens with the Ctrl+M shortcut, compatible with classic Winamp 2 skins, featuring its own spectrum analyzer, equalizer, and playlist.
Is Fastpotify free and open source?
Yes, it’s distributed under the MIT license, which allows using, modifying, and redistributing the code freely, as long as the original license notice is kept.
Does it work on Raspberry Pi or other embedded systems?
The project is designed for desktop use (Linux, macOS, and Windows) with a full graphical interface; for embedded systems without a screen, projects like spotifyd, also based on librespot, are the more common option.
References
- Fastpotify: the project’s official site, with the feature list and download links.
- librespot: the open Rust implementation of the Spotify Connect protocol used by Fastpotify.
- egui: the immediate-mode graphical interface library for Rust used to build the app.
- Winamp: history of the player and its skin format, which Fastpotify supports in its mini player mode.
📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day. @programacion
Imagen destacada: Foto de Kevin Canlas en Unsplash
0 Comments