Pros of librespot

• Written in Rust, offering better performance and memory safety
• More actively maintained with frequent updates
• Supports a wider range of Spotify features, including Connect API

Cons of librespot

• More complex to set up and configure
• Larger resource footprint, potentially less suitable for low-power devices
• Less focus on being a standalone daemon, often used as a library

Code Comparison

spotifyd:

let (mut spotify, credentials) = get_spotify_object(args.clone()).await?;
let (player_event_channel, player_event_sender) = channel::<PlayerEvent>();
let player_event_program = args.onevent.as_ref().map(|path| path.to_owned());

librespot:

let session = Session::connect(config, credentials, cache, handle).await?;
let (player, mut player_events) = Player::new(config, session, audio_setup, move |_| {});
tokio::spawn(async move {
    while let Some(event) = player_events.next().await {
        // Handle player events
    }
});

Both projects use Rust and implement Spotify playback, but librespot offers more flexibility as a library, while spotifyd is designed as a standalone daemon. librespot's codebase is generally more extensive, reflecting its broader feature set and active development.

Pros of spotify-tui

• Provides a feature-rich, interactive terminal user interface for Spotify
• Offers extensive playback control and playlist management capabilities
• Supports searching and browsing Spotify's library directly from the terminal

Cons of spotify-tui

• Requires a separate Spotify client (like Spotifyd) to handle audio playback
• May have a steeper learning curve due to its more complex interface
• Depends on the Spotify Web API, which may have rate limits and require authentication

Code Comparison

spotify-tui (Rust):

pub fn run() -> Result<()> {
    let mut app = App::new()?;
    let mut terminal = Terminal::new(CrosstermBackend::new(io::stdout()))?;
    terminal.clear()?;
    loop {
        terminal.draw(|f| ui::draw(f, &mut app))?;
        if let Event::Key(key) = event::read()? {
            if !app.handle_key(key) {
                break;
            }
        }
    }
    Ok(())
}

Spotifyd (Rust):

fn main() {
    let config = Config::load_or_default();
    let (ctrl_c_tx, ctrl_c_rx) = mpsc::channel();
    let (shutdown_tx, shutdown_rx) = mpsc::channel();
    ctrlc::set_handler(move || {
        ctrl_c_tx.send(()).unwrap();
    }).expect("Error setting Ctrl-C handler");
    run(config, shutdown_rx);
}

Both projects are written in Rust, but spotify-tui focuses on providing a user interface, while Spotifyd handles the core functionality of playing audio and interacting with the Spotify service.

Pros of ncspot

• Full-featured TUI client with playlist management and search functionality
• Written in Rust, offering better performance and memory safety
• Supports offline mode and local cache for faster playback

Cons of ncspot

• Requires more system resources due to its full-featured nature
• May have a steeper learning curve for users unfamiliar with TUI interfaces
• Limited to terminal environments, lacking GUI support

Code Comparison

ncspot (Rust):

pub fn play(&mut self, track_id: &str) -> Result<(), Box<dyn Error>> {
    self.player.load(track_id, true, 0)?;
    self.player.play()?;
    Ok(())
}

spotifyd (Rust):

pub fn play(&mut self) -> Result<()> {
    self.player.play()?;
    self.update_state(PlaybackState::Playing);
    Ok(())
}

Key Differences

• ncspot is a full Spotify client with a rich TUI interface, while spotifyd is a lightweight daemon that acts as a Spotify Connect target
• ncspot offers more features and control within the application, whereas spotifyd relies on external Spotify clients for control
• spotifyd is designed to run in the background, while ncspot is an interactive application meant for active use
• ncspot provides a more comprehensive Spotify experience, but spotifyd is more resource-efficient and better suited for headless setups

Pros of spotify-adblock

• Focuses specifically on blocking ads in the Spotify desktop application
• Lightweight solution that doesn't require running a separate daemon
• Can be used alongside the official Spotify client

Cons of spotify-adblock

• Limited to ad-blocking functionality only
• Requires manual installation and potential recompilation for updates
• May break with Spotify client updates, requiring frequent maintenance

Code Comparison

spotify-adblock:

static const char *whitelist[] = {
    "https://spclient.wg.spotify.com/color-lyrics/v2/track/",
    "https://api-partner.spotify.com/pathfinder/v1/query",
    "https://spclient.wg.spotify.com/metadata/4/track/",
    "https://spclient.wg.spotify.com/audio/",
};

spotifyd:

pub struct SpotifyId(pub [u8; 16]);

impl SpotifyId {
    pub fn from_raw(raw: &[u8]) -> SpotifyId {
        SpotifyId(raw.try_into().unwrap())
    }
}

The spotify-adblock code shows a whitelist of URLs allowed to pass through the ad-blocking filter, while the spotifyd code demonstrates the implementation of a Spotify ID structure. This highlights the different focus areas of the two projects: ad-blocking versus full client functionality.