Convert Figma logo to code with AI

audacious-media-player logoaudacious

A lightweight and versatile audio player

1,224
149
1,224
169
View on GitHub

Top Related Projects

clementine-player's avatar

Clementine

4,228

:tangerine: Clementine Music Player

cmus's avatar

cmus

6,180

Small, fast and powerful console music player for Unix-like operating systems.

DeaDBeeF-Player's avatar

deadbeef

1,943

DeaDBeeF Player

quodlibet's avatar

quodlibet

1,742

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

Quick Overview

Audacious is a free and open-source audio player. It is designed to be lightweight and efficient, with a focus on high audio quality and support for a wide range of audio formats. Audacious offers a customizable interface and extensive plugin support, making it a versatile choice for music enthusiasts.

Pros

  • Lightweight and efficient, with low system resource usage
  • Supports a wide range of audio formats
  • Highly customizable interface and extensive plugin system
  • Cross-platform compatibility (Linux, Windows, and BSD)

Cons

  • Less intuitive interface compared to some modern audio players
  • Limited integration with online music services
  • Some users report occasional stability issues on certain systems
  • Development pace can be slow at times

Getting Started

To get started with Audacious, follow these steps:

  1. Download Audacious from the official website: https://audacious-media-player.org/download
  2. Install the application following the instructions for your operating system
  3. Launch Audacious
  4. Add music to your library by clicking "File" > "Add Files" or "Add Folder"
  5. Customize the interface and settings by navigating to "Settings" > "Preferences"
  6. Explore available plugins in "Settings" > "Plugins"

Audacious is primarily a desktop application and not a code library, so there are no code examples or quick start instructions for developers. However, if you're interested in contributing to the project or building plugins, you can find the source code and development resources on the official GitHub repository: https://github.com/audacious-media-player/audacious

Competitor Comparisons

clementine-player logo

Clementine

4,228

:tangerine: Clementine Music Player

Pros of Clementine

  • More feature-rich, including internet radio, podcast support, and cloud services integration
  • Cross-platform compatibility (Windows, macOS, Linux)
  • Active development with regular updates and new features

Cons of Clementine

  • Heavier resource usage due to more features
  • Steeper learning curve for new users
  • Larger installation size

Code Comparison

Clementine (C++):

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

Audacious (C):

void playlist_play (int playlist, int entry)
{
    if (entry < 0)
        return;
    playlist_set_position (playlist, entry);
    drct_play ();
}

Both examples show similar functionality for playing a selected track, but Clementine uses C++ with object-oriented design, while Audacious uses C with a more procedural approach.

Clementine offers a more comprehensive media player experience with additional features, while Audacious focuses on being lightweight and efficient. The choice between them depends on user preferences for features versus simplicity and resource usage.

cmus logo

cmus

6,180

Small, fast and powerful console music player for Unix-like operating systems.

Pros of cmus

  • Lightweight and resource-efficient, ideal for older or low-spec systems
  • Highly customizable with extensive keybindings and color schemes
  • Faster startup time and lower memory usage

Cons of cmus

  • Less user-friendly interface, steeper learning curve for new users
  • Limited visualization options compared to Audacious
  • Fewer plugins and extensions available

Code Comparison

cmus (C-based):

static int cmus_play(struct track_info *ti)
{
    player_set_file(ti->filename);
    if (player_status == PLAYER_STATUS_PLAYING)
        player_pause();
    player_play();
    return 0;
}

Audacious (C++-based):

bool PlaybackPlugin::play(const char * filename, VFSFile & file)
{
    if (! open_audio(FMT_FLOAT, 44100, 2))
        return false;
    
    return true;
}

Both projects use C-based languages, with cmus using pure C and Audacious using C++. cmus focuses on simplicity and efficiency, while Audacious offers more features and a graphical interface. The code snippets demonstrate the different approaches to implementing playback functionality in each project.

DeaDBeeF-Player logo

deadbeef

1,943

DeaDBeeF Player

Pros of DeaDBeeF

  • More extensive plugin system, allowing for greater customization
  • Better support for high-resolution audio formats
  • More active development and frequent updates

Cons of DeaDBeeF

  • Less user-friendly interface, steeper learning curve
  • Smaller community and fewer resources for troubleshooting
  • Limited cross-platform support (primarily Linux-focused)

Code Comparison

Both Audacious and DeaDBeeF are written in C, but their code structures differ slightly. Here's a brief comparison of how they handle playlist management:

Audacious:

void aud_playlist_entry_insert (int playlist, int at, const char * filename, Tuple * tuple, bool play)
{
    playlist_entry_insert (playlist, at, filename, tuple, play);
}

DeaDBeeF:

int
plt_add_file (ddb_playlist_t *plt, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data) {
    return plt_add_file2 (plt, NULL, fname, pabort, cb, user_data);
}

Both implementations provide similar functionality, but DeaDBeeF's approach allows for more flexibility with callback functions and user data.

quodlibet logo

quodlibet

1,742

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

Pros of Quodlibet

  • More extensive tagging and metadata support
  • Advanced search and filtering capabilities
  • Better handling of large music libraries

Cons of Quodlibet

  • Steeper learning curve due to more complex features
  • Slower startup time, especially with large libraries
  • Less intuitive interface for casual users

Code Comparison

Audacious (C):

static void
playlist_add_url_string(const gchar * url)
{
    gchar * uri = audacious_url_string_to_uri(url);
    if (uri)
        playlist_entry_insert(playlist_get_active(), -1, uri, NULL);
    g_free(uri);
}

Quodlibet (Python):

def add_filename(self, filename, library=None):
    if library is None:
        library = self.library
    song = library.add_filename(filename)
    if song:
        self.add([song])
    return song

Both code snippets demonstrate adding a file to the playlist, but Quodlibet's implementation is more high-level and Pythonic, while Audacious uses lower-level C functions.

Convert Figma logo designs to code with AI

Visual Copilot

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

Try Visual Copilot

README

Audacious

Overview

Audacious is a lightweight, open-source audio player focused on high audio quality and low resource usage. It supports a wide range of audio formats and provides a flexible plugin system for extending functionality.

Features

  • Fast and lightweight with low system resource usage
  • Runs on Linux, BSD derivatives, macOS and Windows
  • Wide support for audio formats
  • Plugin-based architecture
  • Multiple user interfaces:
    • GTK interface
    • Qt interface
    • Winamp interface, including support for Winamp 2 skins
  • Advanced playlist management
  • Built-in equalizer, audio effects and visualizations
  • Support for ReplayGain and gapless playback
  • Controllable also via MPRIS and with audtool

Installation

Prebuilt Packages

Most Linux distributions provide Audacious in their respective package repositories. For Windows we offer an installer. On macOS, Audacious can be installed using Homebrew.

There are also Flatpak and Snap packages of Audacious, however we do neither provide nor support them. So if you have an issue with these packages, make sure it also affects ordinary installation methods before reporting it to us.

See also the download instructions on our website.

Building from Source

Requirements

  • Meson
  • GCC or Clang
  • pkg-config
  • Required development libraries (GTK/Qt, GLib, audio backends, codecs, etc.)

Reading our build pipeline installation script may help with the package names when using Ubuntu or macOS.

Build Steps

After downloading the source code, you need to create a build directory (e.g. meson setup build). To view a list of all supported build options, you can use the command meson configure build. Alternatively inspect the file meson_options.txt. Logs can be found in meson-logs within your build directory.

Example:

meson setup build      # pass custom build options with -D option=value
meson compile -C build # start building
meson install -C build # install the built software

Consult the official Meson documentation for more details, e.g. Running Meson and Configuring a build directory.

Plugins

Audacious uses a modular plugin system to provide most of its functionality. Many plugins are included in the audacious-plugins package, officially provided and supported by the Audacious developers. But there are also third-party plugins available, install and use them at your own risk though.

Plugins can be enabled or disabled at runtime within the Audacious settings window. When using the GTK or Qt interface, several plugins (e.g. album cover, lyrics, file browser, visualizations) can be docked into the main window.

Plugin Types

  • General plugins – provide additional features (e.g. lyrics viewer, last.fm, playlist manager)
  • Effect plugins – apply audio processing (e.g. echo, equalizer, speed and pitch)
  • Visualization plugins – display visual effects (e.g. spectrum analyzer, VU meter)
  • Input plugins – decode audio formats (e.g. MP3, FLAC, Ogg Vorbis, Opus)
  • Output plugins – handle audio playback devices (e.g. ALSA, PipeWire, PulseAudio)
  • Playlist plugins – offer support for various playlist formats (e.g. M3U, ASX, Cuesheets)
  • Transport plugins – allow reading from streams or file shares (e.g. HTTPS, FTP, SMB)

Supported Formats

Supported audio formats depend on enabled plugins but typically include:

  • MP3
  • FLAC
  • Ogg Vorbis
  • Opus
  • AAC / M4A
  • WAV
  • WavPack
  • Ad-lib chiptunes
  • Audio CD
  • MIDI
  • Nintendo DS (2SF)
  • PlayStation Audio (PSF)
  • Tracker formats (MOD, XM, etc.)
  • … and many more (through FFmpeg)

Troubleshooting

  • Read Common Problems on our website
  • Make sure to use the latest Audacious version
  • Enable verbose output (with audacious -V on the command line)
  • Check our issue tracker and forum for similar reports (also closed ones)

Contributing

Contributions are welcome!

How to Contribute

  • Submit pull requests for fixes or feature requests
  • Support and help others in our forum
  • Report issues in our bug tracker
  • Translate Audacious into your native language
  • Recommend and advertise Audacious to your friends

Before submitting large changes, consider opening a forum thread first to discuss your ideas. Also remember that the developers of Audacious are volunteers and can only spend a limited amount of their free time on the project.

License

Audacious is licensed under the BSD-2-Clause license. Please note that many of the plugins distributed with Audacious are under different licenses. See the COPYING file and the respective plugin source code for more details.

Links