Clementine

:tangerine: Clementine Music Player

3,740

675

3,740

2,384

View on GitHub

Top Related Projects

mopidy

8,034

Mopidy is an extensible music server written in Python

quodlibet

1,426

Music player and music library manager for Linux, Windows, and macOS

tomahawk

2,966

Tomahawk, the multi-source music player

Quick Overview

Clementine is an open-source, cross-platform music player and library organizer. It offers a clean and user-friendly interface for managing and playing music collections, with support for various audio formats and streaming services.

Pros

Cross-platform compatibility (Windows, macOS, Linux)
Extensive feature set, including internet radio, podcast support, and lyrics fetching
Customizable interface with multiple themes and layouts
Integration with cloud storage services and streaming platforms

Cons

Development pace has slowed down in recent years
Some users report occasional stability issues on certain platforms
Limited mobile support compared to other modern music players
Learning curve for advanced features may be steep for some users

Getting Started

To get started with Clementine:

Download the appropriate installer for your operating system from the official website.
Install the application following the on-screen instructions.
Launch Clementine and add your music library by going to Tools > Add Music.
Explore the various features and customize the interface to your liking through the preferences menu.

For developers interested in contributing:

Fork the GitHub repository.
Clone your fork: git clone https://github.com/your-username/Clementine.git
Follow the build instructions in the repository's README for your specific platform.
Make changes, commit them, and create a pull request to contribute back to the project.

Competitor Comparisons

mopidy

8,034

Mopidy is an extensible music server written in Python

Pros of Mopidy

Extensible architecture with a plugin system, allowing for easy integration of new features and services
Supports a wide range of audio sources, including local files, streaming services, and radio stations
Headless design allows for flexible front-end options and remote control capabilities

Cons of Mopidy

Requires more technical knowledge to set up and configure compared to Clementine
Limited built-in GUI options, often requiring additional front-end clients for a user-friendly interface

Code Comparison

Mopidy (Python):

from mopidy import core

class MyFrontend(pykka.ThreadingActor, core.CoreListener):
    def track_playback_started(self, tl_track):
        print(f"Now playing: {tl_track.track.name}")

Clementine (C++):

void MainWindow::PlaylistItemDoubleClicked(int index) {
  if (index < 0) return;
  app_->player()->PlayAt(index, Engine::Manual, true);
}

Mopidy's code demonstrates its event-driven architecture and extensibility, while Clementine's code shows its direct integration with the GUI and playback control.

MPD

2,169

Music Player Daemon

Pros of MPD

Lightweight and efficient, ideal for low-resource systems
Client-server architecture allows remote control and multiple interfaces
Supports a wide range of audio formats and protocols

Cons of MPD

Lacks a built-in graphical user interface, requiring separate clients
Setup and configuration can be more complex for beginners
Limited metadata management compared to full-featured music players

Code Comparison

MPD (server configuration):

music_directory    "/path/to/music"
playlist_directory "/path/to/playlists"
db_file            "/path/to/database"
log_file           "/path/to/log"
pid_file           "/path/to/pid"

Clementine (C++ code snippet):

void MainWindow::AddFiles() {
  QStringList filenames = QFileDialog::getOpenFileNames(
      this, tr("Add files"), last_add_dir_,
      QString("%1 (%2);;%3").arg(tr("Music"), FileView::kFileFilter,
                                 tr("All files (*.*)")));
  if (filenames.isEmpty()) return;
  MoveToNewPlaylist();
  app_->library()->AddOrOpenFiles(filenames);
}

MPD focuses on server-side configuration and efficient audio playback, while Clementine provides a rich user interface and integrated library management. MPD's lightweight nature makes it suitable for headless setups, while Clementine offers a more user-friendly experience for desktop environments.

quodlibet

1,426

Music player and music library manager for Linux, Windows, and macOS

Pros of Quod Libet

More extensive tagging and metadata support
Better handling of large music libraries
More customizable and extensible through plugins

Cons of Quod Libet

Less intuitive user interface for beginners
Slower startup time with large libraries
Limited support for streaming services

Code Comparison

Clementine (C++):

void Library::AddDirectory(const QString& path) {
  QDir dir(path);
  QStringList entries = dir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
  for (const QString& entry : entries) {
    QString full_path = dir.filePath(entry);
    // Process files and subdirectories
  }
}

Quod Libet (Python):

def scan_directory(path):
    for root, dirs, files in os.walk(path):
        for name in files:
            yield os.path.join(root, name)
        for name in dirs:
            yield from scan_directory(os.path.join(root, name))

Both projects are open-source music players, but they differ in their approach and target audience. Clementine focuses on a user-friendly interface and broad platform support, while Quod Libet emphasizes advanced features for music enthusiasts and collectors. The code comparison shows different approaches to directory scanning, with Clementine using Qt's file system functions and Quod Libet utilizing Python's os module for recursive scanning.

tomahawk

2,966

Tomahawk, the multi-source music player

Pros of Tomahawk

Advanced social features, including collaborative playlists and friend activity
Unified music library across multiple streaming services and local files
More modern and visually appealing user interface

Cons of Tomahawk

Less actively maintained, with fewer recent updates
Heavier resource usage, especially for larger music libraries
More complex setup process compared to Clementine's straightforward installation

Code Comparison

Tomahawk (C++):

void AudioEngine::setVolume( float volume )
{
    m_volume = volume;
    applyVolume();
}

Clementine (C++):

void Engine::SetVolume(int value) {
  volume_ = value;
  if (current_backend_)
    current_backend_->SetVolume(value);
}

Both projects use C++ for their core functionality. Tomahawk's code tends to be more modular and object-oriented, while Clementine's is often more straightforward and procedural. Tomahawk's codebase is generally larger and more complex, reflecting its broader feature set and multi-service integration. Clementine's code is typically more focused on traditional music player functionality, resulting in a leaner and more maintainable codebase.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Clementine

Clementine is a modern music player and library organizer for Windows, Linux and macOS.

Latest Release
Latest Pre-Releases
Website: http://www.clementine-player.org/
Github: https://github.com/clementine-player/Clementine

Opening an issue

Ask for a new feature

Please:

Check if the new feature is not already implemented (Changelog)
Check if another person didn't already open an issue
If there is already an opened issue there is no need to comment "+1", it won't help. Instead, you can subscribe to the issue to be notified of anything new about it

Report a bug

Please:

Try the latest build (https://github.com/clementine-player/Clementine/releases) to see if any bug is still present. If it works fine even though you see an open issue, please comment on it and explain that the issue has been fixed.
Check if another person has already opened the same issue to avoid duplicates
If there already is an open issue you could comment on it to add detail about the problem or confirm it
In case there isn't, you can open a new issue with an explicit title and as much information as possible (OS, Clementine version, how to reproduce the problem...)
Please use https://pastebin.com/ for logs/debug.

If there are no answers, it doesn't mean we don't care about your feature request/bug. It just means we can't reproduce the bug or haven't had time to implement it :o)

Compiling from source

Get the code (if you haven't already):

git clone https://github.com/clementine-player/Clementine.git && cd Clementine

Compile and install:

cd bin
cmake ..
make -j$(nproc)
sudo make install

See the Wiki for more instructions and a list of dependencies: https://github.com/clementine-player/Clementine/wiki#compiling-and-installing-clementine

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot