# rmpc: a configurable terminal MPD client with album art > rmpc is a Rust TUI client for Music Player Daemon that renders album cover art through Kitty, Sixel, Iterm2 or ueberzugpp, and configures nearly every part of its interface. It is stable for daily use, but the README says breaking changes are sometimes unavoidable. **mierak/rmpc** — A modern, configurable, terminal based MPD Client with album art support via various terminal image protocols - Repository: https://github.com/mierak/rmpc - Website: https://rmpc.mierak.dev - Stars: 3,390 · Forks: 123 - Language: Rust - License: BSD-3-Clause - Published: 2026-09-23 · Updated: 2026-09-23 · Language: en - Canonical page: https://hysenlabs.com/projects/mierak-rmpc ## What rmpc solves for MPD users Music Player Daemon is a server. It holds the library, the queue and the playback state, and it exposes all of that over a socket. What it does not ship is a client you would want to look at for hours, so the choice of client is a separate decision from the choice of server. rmpc is one of those clients, written in Rust and drawn with ratatui. The README describes it as heavily inspired by ncmpcpp and by the ranger and lf file managers. That inheritance shows up in two places. From ncmpcpp comes the idea of a terminal music client with a configurable header, a queue view and a now-playing display. From ranger and lf comes the three-column browser through the music library, where the left column is a directory tree, the middle column is its contents and the right column previews what is selected. If you have used either file manager, the navigation model is already in your fingers. The audience is narrow and specific: people who run MPD, live in a terminal, and care about what the client looks like. If you stream from a service rather than a local library, rmpc is the wrong layer of the stack. The README does list the ability to play music from YouTube, but that sits on top of an MPD setup, not instead of one. ## How the client, the daemon and the image protocols fit together rmpc is a workspace rather than a single crate. Cargo.toml lists four members: rmpc, rmpc-mpd, rmpc-shared and rmpcd, with rmpc as the default member. That split is the clearest signal about the architecture. rmpc-mpd is the protocol layer that talks to the daemon, rmpc-shared holds code the other crates use, and rmpc is the terminal application. rmpcd is a separate binary in the same workspace. The TUI itself is built on ratatui and crossterm, with crossterm compiled with the osc52 feature, which is how the terminal clipboard escape sequence is available. Album art is the part that constrains your setup. The README states cover art is displayed if your terminal supports the Kitty, Sixel or Iterm2 protocols, or via ueberzugpp. Those are four different mechanisms with four different failure modes, and the client cannot invent one your terminal lacks. The dependency list includes image, color_quant and base64, which is consistent with decoding a cover, reducing it to the palette the protocol expects and encoding it for the escape sequence. Other pieces visible in the workspace dependencies tell you what the client does at runtime: mlua with Lua 5.5 vendored, which backs the scripting hooks and CLI mode; reqwest, which is what a YouTube lookup would need; notify-debouncer-full, which watches files; and flate2, for compression. The README's feature list matches this: synchronized lyrics, Cava integration for visualisation, playlist management and script hooks. ## Installing rmpc and getting a first queue on screen The README does not contain install commands. It says that description, configuration and installation methods can be found on the rmpc website at rmpc.mierak.dev, and it links a Repology packaging status badge, so distribution packages exist and are tracked there. Start at the website rather than guessing at a build command, and check Repology for whether your distribution already carries rmpc. What the repository does tell you is the toolchain floor. Cargo.toml sets the workspace edition to 2024 and rust-version to 1.97.1, so a source build needs a Rust toolchain at least that new. The workspace also declares a flake.nix and a nix directory, which means a Nix flake is part of the repository for people who build that way. Once rmpc is installed, it needs an MPD server to connect to. The website's configuration page is where the connection details and the keybind and theme options live; the README states every keybind can be changed and that the defaults are vim-like. A first session is then: start MPD, start rmpc, and use the three-column browser to reach a directory, add tracks to the queue, and play. The README describes that browser as ranger and lf-like, so the navigation keys follow that model rather than a menu. The repository also ships a basic CLI mode and script hooks, which the README lists as the scripting surface. If you want to drive rmpc from a shell script or a window manager keybind, that is the entry point to look up on the website, because the README does not spell out the flags. ## Where rmpc gets in your way The README's status section is unusually direct: rmpc is still maturing, it is stable for daily use, and breaking changes, while rare, are sometimes unavoidable. Treat that as a real cost. A configuration file that works on one release may need editing on the next, and the project does not promise otherwise. The CHANGELOG.md at the repository root is where those changes would be recorded, and it is the file to read before upgrading rather than after something stops working. Album art is the second constraint, and it is a hard one. The four supported paths are Kitty, Sixel, Iterm2 and ueberzugpp. If your terminal implements none of them and you cannot run ueberzugpp, the feature the project leads with is simply unavailable. That is not a bug to file; it is the boundary of what escape sequences can do. The third limitation is the shape of the tool. rmpc is an MPD client, so it has no library of its own, no server, and no scanning. Point it at nothing and it shows nothing. Anyone who wants a self-contained player with its own index should be looking elsewhere, not at a client that assumes a daemon is already running. ## rmpc against ncmpcpp The README names ncmpcpp as the inspiration, so the honest comparison is with it. Both are terminal MPD clients. The difference is in where each puts its weight. ncmpcpp is the long-established client in this space, with a screen-based model where you switch between named views such as the playlist editor, the browser and the visualiser. rmpc instead borrows its navigation from ranger and lf: a persistent three-column layout where you move through the library in place, with the preview column showing what you are about to act on. If you have used those file managers, rmpc's model will feel familiar immediately; if you have used ncmpcpp for years, rmpc's will feel like a different program that happens to speak the same protocol. The second difference is configuration surface. The README claims you can configure what information, if any, appears in the header, which columns appear on the queue screen, the colour theme, and every keybind. That is a wider claim than most MPD clients make, and it is also why the breaking-change warning matters more here: the more of the interface you are allowed to redefine, the more there is to migrate when a default changes. A third difference is packaging language. rmpc is Rust with a workspace of four crates and a declared minimum toolchain, which matters if you build from source on a distribution that lags. ncmpcpp's build requirements are a separate question and outside what this repository states. ## Maintenance, licensing and upgrade cost The repository is not archived, and the last push was on 2026-09-13. The most recent release listed is v0.11.0 on 2026-02-01, preceded by v0.10.0 on 2025-11-11 and v0.9.0 on 2025-06-23. So commits continue between releases, and the release cadence over the last year has been roughly every few months rather than continuous. Upgrade cost is dominated by configuration drift, not by the binary. Because header contents, queue columns, colours and keybinds are all user-configurable, an upgrade can change a default that your config was written against. The README's own warning about occasional breaking changes is the reason to read CHANGELOG.md before moving to a new version, and the reason to keep your rmpc config in version control alongside it. The licence is BSD-3-Clause, declared both in the LICENSE file and in the workspace package metadata in Cargo.toml. That is a permissive licence, which generally means you can use, modify and redistribute the code including in closed products, subject to the usual conditions about retaining the copyright notice and the disclaimer. This is a description of what the licence identifier means, not legal advice; read the LICENSE file itself if the distinction matters to you. ## Conclusion rmpc suits people who already run Music Player Daemon and want a keyboard-driven client whose header, queue columns, colours and keybinds they can rewrite, plus cover art in a terminal that speaks Kitty, Sixel or Iterm2. Skip it if you have no MPD server, if your terminal cannot draw images and ueberzugpp is not an option, or if you need a client that never changes configuration format: the README states breaking changes are sometimes unavoidable. Before adopting, read the configuration and install pages on rmpc.mierak.dev and check the CHANGELOG for the v0.11.0 entry, because that is where a config migration would be documented. ## FAQ ### What is rmpc? rmpc is a terminal based Music Player Daemon client written in Rust. The README describes it as configurable, with a ranger and lf-like three-column browser, album cover art through the Kitty, Sixel, Iterm2 or ueberzugpp protocols, and synchronized lyrics support. ### How do I install rmpc? The README does not list install commands. It states that installation methods are on the rmpc website at rmpc.mierak.dev, and it links a Repology packaging status badge, which tracks distribution packages. A source build needs Rust 1.97.1 or newer, per the workspace metadata in Cargo.toml. ### Does rmpc show album art in any terminal? No. The README states cover art is displayed if your terminal supports the Kitty, Sixel or Iterm2 protocols, or via ueberzugpp. If your terminal implements none of those and you cannot run ueberzugpp, the cover art feature is unavailable. ### Can I change rmpc's keybinds and theme? Yes. The README says every keybind can be changed and that the defaults are vim-like, and that you can configure what appears in the header, which columns appear on the queue screen, and the colour theme. ### Is rmpc stable enough for daily use? The README's status section says rmpc is still maturing, is stable for daily use, and that breaking changes, while rare, are sometimes unavoidable. The CHANGELOG.md at the repository root is where those changes would be recorded. ## Sources - [License: BSD-3-Clause](https://github.com/mierak/rmpc/blob/master/LICENSE) - [mierak/rmpc on GitHub](https://github.com/mierak/rmpc) - [Project website](https://rmpc.mierak.dev) - [README](https://github.com/mierak/rmpc/blob/master/README.md) - [Releases](https://github.com/mierak/rmpc/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mierak-rmpc