Polaris is a music streaming application, designed to let you enjoy your music collection from any computer or mobile device.

Overview

Actions Status codecov.io License: MIT

Polaris is a music streaming application, designed to let you enjoy your music collection from any computer or mobile device. Polaris works by streaming your music directly from your own computer, without uploading it to a third-party. It is free and open-source software, without any kind of premium version. The only requirement is that your computer stays on while it streams music!

Features

  • Optimized for large music collections
  • Can run on Windows, Linux, BSD, or through Docker
  • Listen to your music on the web or using the Polaris Android app
  • Easy to setup and configure via the built-in web UI
  • Support for flac, mp3, mp4, mpc, ogg and opus files
  • Support for album art images
  • Last.fm scrobbling
  • Color themes
  • Restrict access to your music collection with user accounts

Tutorials

Screenshots

Polaris Web UI Polaris Web UI Dark Mode

Documentation

API Documentation

The Polaris server API is documented via Swagger. Please note that this Swagger page does not point to a live Polaris server so the Try it out buttons are not expected to work. Every installation of Polaris also distributes this documentation, with the ability to use the Try it out buttons. To access it, simply open http://localhost:5050/swagger/ in your browser on the machine running Polaris.

Feel free to open Github issues or Pull Requests if clarifications are needed.

Comments
  • Scan speed in 0.12.4 terribly slow

    Scan speed in 0.12.4 terribly slow

    Since upgrading, scans have become unbearably slow to the point that the app is unusable on my system when not much else is happening.

    Debian sid on linux kernel 5.7.6 running polaris 0.12.4 in docker, scans have 4 threads capping out at about 20MB/s. Watching the logs shows no obvious errors or anything, but I can see very obvious hitching in the scan where all logging stops for a solid 20-30 seconds. The entire library is frozen up during a scan, and at these speeds, scans are taking longer than 30 minutes to finish.

    Rolled back to 0.12.3, one thread is floating between 140-180MB/s with no issues using the app during the scan. I intended to look into this to see what I can do, but I really haven't had the time to put into this.

    I'll try to investigate a bit in the next few days and report back.

    performance 
    opened by vosscodes 36
  • Add opus format support

    Add opus format support

    Rust already has binding for libopus https://docs.rs/opus/0.2.1/opus/
    I don't know if this would help anyhow, but opus support for polaris would be very nice :)

    enhancement 
    opened by vvrein 18
  • add support for opus files

    add support for opus files

    This adds support for opus files.

    It seems to work fine on my limited set of test files. One thing I noticed is that sometimes a tag is written in uppercase "TITLE" (when set with kid3) and sometimes in lowercase "title" (when converted from mp3 with ffmpeg). To be case insensitive I used to_uppercase().

    Another thing I noticed is that the duration is not displayed. However it seems like it is not supposed to be part of the header but should rather be determined from the last ogg page of the stream.

    opened by zaethan 14
  • Linux system-wide install guidance

    Linux system-wide install guidance

    I tried to do a system-wide install on Linux and it's a bit of a mess. I ended up with this:

    /var/lib/polaris
    /var/lib/polaris/.local
    /var/lib/polaris/.local/share
    /var/lib/polaris/.local/share/polaris
    /var/lib/polaris/.local/share/polaris/polaris.log
    /var/lib/polaris/.local/share/polaris/polaris.pid
    /var/lib/polaris/.local/share/polaris/thumbnails
    /var/lib/polaris/.local/share/polaris/thumbnails/12698004523255186174.jpg
    /var/lib/polaris/.local/share/polaris/thumbnails/11339598049783905663.jpg
    /var/lib/polaris/.local/share/polaris/thumbnails/17518483773397318633.jpg
    /var/lib/polaris/.local/share/polaris/db.sqlite
    

    The .local/share part shouldn't be there, the log file should be under /var/log, and the PID file should be under /var/run.

    This one isn't great, but it would be nice to include a systemd unit in the package. This can be used as a starting point.

    [Unit]
    Description=Polaris
    After=network.target
    
    [Service]
    User=polaris
    ExecStart=/usr/bin/polaris -f -w /usr/share/polaris/web -s /usr/share/polaris/swagger
    WorkingDirectory=/var/lib/polaris
    
    [Install]
    WantedBy=default.target
    
    opened by lnicola 13
  • Indexing performance improvements

    Indexing performance improvements

    What the title says. I'd like to test Polaris, but it's a bit slow at scanning my media library. Being able to share the library with mpd would be really nice.

    performance 
    opened by lnicola 13
  • Index optimizations

    Index optimizations

    Savings were:

    • Moving all database insertions away from the thread doing directory traversal
    • Avoiding bail!() macro on critical path
    • Parallelizing the work to detect DB entries that should be removed

    Net result is about 50% faster on warm cache, running on i7-8086k CPU and HDS722020ALA330 drive on Windows.

    opened by agersant 12
  • Tutorial: Set up on Linux server

    Tutorial: Set up on Linux server

    Tested with Ubuntu 21.04

    1: Get nightly rust from rustup.rs

    2: Get dependencies and build

    sudo apt install -y libarchive-tools
    cd ~
    git clone https://github.com/agersant/polaris
    cd polaris
    cargo build --release
    cd ~
    
    

    3: Install

    echo "Creating config dir"
    sudo mkdir -p /etc/polaris
    sudo cp ~/polaris/test-data/config.toml /etc/polaris/polaris.toml
    
    echo "Creating swagger and web directories"
    sudo mkdir -p /usr/share/polaris
    sudo cp ~/polaris/docs/swagger /usr/share/polaris/
    
    echo "Getting web files"
    cd /usr/share/polaris
    wget -qO- https://github.com/agersant/polaris-web/releases/download/build-50/web.zip | sudo bsdtar -xvf-
    cd ~
    
    echo "Copying binary to cargo default"
    mkdir -p ~/.cargo/bin
    cp -f ~/polaris/target/release/polaris ~/.cargo/bin
    
    echo "Cleaning up polaris build files"
    rm -rf ~/polaris
    
    echo "Adding polaris user"
    sudo useradd polaris
    
    echo "Setting permissions for polaris"
    sudo chown -R polaris:polaris /usr/share/polaris
    sudo mkdir -p /var/lib/polaris
    sudo chown -R polaris:polaris /var/lib/polaris
    sudo mkdir -p /var/log/polaris
    sudo chown -R polaris:polaris /var/log/polaris
    
    echo "Copying binary to default bin PATH"
    sudo cp -f ~/.cargo/bin/polaris /usr/bin/polaris
    
    

    4: Configure

    sudo ufw allow 5050
    sudo nano /etc/polaris/polaris.toml
    
    

    5: Enable and start the service (paste the entire thing into the terminal)

    cat << SERVICE_CMD | sudo tee /etc/systemd/system/polaris.service
    [Unit]
    Description=Polaris
    After=network.target
    
    [Service]
    User=polaris
    ExecStart=/usr/bin/polaris -f -w /usr/share/polaris/web -s /usr/share/polaris/swagger -c /etc/polaris/polaris.toml -d /var/lib/polaris/polaris.db --log /var/log/polaris/polaris.log
    WorkingDirectory=/var/lib/polaris
    
    [Install]
    WantedBy=default.target
    
    SERVICE_CMD
    sudo systemctl daemon-reload
    sudo systemctl enable --now polaris
    
    

    6: Navigate to <your-ip>:5050

    image

    opened by Lyamc 11
  • could not compile rocket_http

    could not compile rocket_http

    Hello,

    I wanted to try out this under Debian Buster (in an LXC container, but that doesn't really matter I suppose...), and got the following fail message:

    error: proc macro panicked --> /root/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket_http-0.4.5/src/parse/uri/parser.rs:119:34 | 119 | let path_and_query = pear_try!(path_and_query(is_pchar)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = help: message: called Option::unwrap() on a None value = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

    error: aborting due to previous error

    error: could not compile rocket_http.

    To learn more, run the command again with --verbose. warning: build failed, waiting for other jobs to finish... error: build failed make: *** [Makefile:7: build] Error 101

    Rust is nightly (installed as per your recommended command):

    curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly

    Thank You!

    opened by eisengrau 11
  • Builds take too long

    Builds take too long

    Polaris takes quite some time to build. It's not terrible, but I feel we could do better.

    Some low-hanging fruit is:

    • [x] using profile overrides to build proc macros in debug mode
    • [ ] avoiding some of the dependency duplication (e.g. right now we're building two versions of syn, each taking around 37 seconds to build
    • [ ] removing some of the less important proc macro dependencies (function_name) comes to mind
    • [ ] making the TLS support optional (for people that use a reverse proxy)
    • [ ] making the Last.fm support optional
    • [ ] maybe something related to the testing code?
    internal 
    opened by lnicola 10
  • Handling of authentication errors

    Handling of authentication errors

    19:40:24 [INFO] rocket::rocket: [~/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.4.2/src/rocket.rs:205] GET /api/browse/:
    19:40:24 [INFO] _: [~/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.4.2/src/rocket.rs:289] Matched: GET /api/browse (browse_root)
    19:40:24 [INFO] _: [~/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.4.2/src/rocket.rs:297] Outcome: Failure
    19:40:24 [WARN] _: [~/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.4.2/src/rocket.rs:318] Responding with 401 Unauthorized catcher.
    19:40:24 [INFO] _: [~/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.4.2/src/rocket.rs:120] Response succeeded.
    

    I haven't checked, but it might be some sort of CSRF protection. I couldn't find a log out link, so I had to clear my cookies to be able to log in again.

    Update: it was Rocket's encrypted cookies.


    After #41, this no longer happens, but it would be nice if:

    • the web UI could detect that it's not authenticating properly and prompt the user to log in again
    • there was a way to log out
    bug 
    opened by lnicola 10
  • song duration

    song duration

    is there a reason for songs not having them? if not I can submit a PR in the next couple days adding them to the formats that support them (from what i see both id3and metaflac have support= cheers :)

    opened by jxs 10
  • Multi value fields

    Multi value fields

    This is a POC to store multiple values per field. Starting with artists and album artists. If this was to be merged, we should probably do the same for lyricists and composers. It also paves the way for semantic browsing, as we now have a table of artists (and possibly composers and lyricists). And something similar can be done for albums.

    One thing to be cautious about is that ids of songs, and artists will have to be stable, we could also make the join table work on paths and artists names. But to be honest I prefer using numeric ids.

    Let me know what you think.

    opened by Saecki 3
  • Add the ability to run Polaris on some HTTP root path

    Add the ability to run Polaris on some HTTP root path

    Would it be possible to optionally define a root path component so http://192.168.0.2:5050/#/browse becomes http://192.168.0.2:5050/<DEFINED_PATH>/#/browse

    This means it is easier to host this service on a shared URL with other services.

    Vaultwarden for example calls this alternate base dir - https://github.com/dani-garcia/vaultwarden/wiki/Using-an-alternate-base-dir

    opened by johnflan 2
  • Feature request: ability to Love a track on last.fm, and see if current playing track is loved.

    Feature request: ability to Love a track on last.fm, and see if current playing track is loved.

    Leaving this here in case someone wants to do a PR.

    Last.fm does not only track what you've listened to, it may also track what songs you mark as loved. Traditionally, marking a track as loved is done either through the last.fm web portal, or by using the official last.fm scrobbler. My request is to add the REST endpoints and webui button to (un)mark the current playing song as loved.

    • https://www.last.fm/api/show/user.getLovedTracks
    • https://www.last.fm/api/show/track.love
    • https://www.last.fm/api/show/track.unlove

    In both the last.fm web portal and their scrobbler, they use an outlined heart to indicate unloved, and a filled heart to indicate loved.

    enhancement 
    opened by pbsds 0
  • add simplified browse functionality for single collection

    add simplified browse functionality for single collection

    Greetings,

    Thanks for Polaris!

    I've got a single collection of hundreds of directories. There is an extra (unnecessary) click of going from "All Music" -> "Collection Root" -> [hundreds of directories]

    Both "All Music" and "Collection Root" are single directories/containers. It would be great for Polaris to notice that there is only one collection configured and then skip the "All Music" container. That is, when you click the Browse link in the upper left hand corner you go directly to the hundreds of directories.

    Thanks for considering this feature request!

    enhancement 
    opened by mzagrabe 0
Releases(0.14.0)
  • 0.13.5(Apr 25, 2021)

    Server

    • Added support for AIFF and WAVE files (thanks @gahag)

    Web Client

    • Improved performance when scrolling large playlists
    • Fixed display and playback issues when a song was used multiple times in a playlist
    • Playlist duration can now display number of days
    • Fixed a bug where the playlist panel could have blank space in very tall browser windows
    • Major dependencies updates
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.13.5.msi(27.19 MB)
    Polaris_0.13.5.tar.gz(3.69 MB)
  • 0.13.4(Jan 5, 2021)

    Server

    Adjustments to logging behavior.

    On Linux:

    • Running without -f emits a log file
    • Running with -f and no --log option does not emit a log file
    • Running with -f and --log option emits a log file

    On Windows:

    • Running with UI feature (polaris.exe in releases) emits a log file
    • Running without UI feature (polaris-cli.exe in releases) and no --log option does not emit a log file
    • Running without UI feature (polaris-cli.exe in releases) and --log option emits a log file
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.13.4.msi(26.86 MB)
    Polaris_0.13.4.tar.gz(3.11 MB)
  • 0.13.3(Dec 31, 2020)

  • 0.13.2(Dec 29, 2020)

  • 0.13.1(Dec 27, 2020)

  • 0.13.0(Dec 21, 2020)

    API changes

    • Bumped API version number to 6.0.
    • Added new endpoints to manage users, mount points and settings more granularly.
    • Added support for authenticating via bearer tokens generated by the /auth endpoint. These token can be submitted via Bearer HTTP Authorization headers, or as a URL parameters (auth_token).
    • Authentication using cookies or Basic HTTP Authorization headers is deprecated and will be removed in a future revision.
    • Authentication cookies no longer expire after 24 hours. The newly added bearer tokens also have no expiration data.
    • Last.fm account linking now requires a short-lived auth token obtain from the newly added `lastfm/link_token' endpoint.

    Server

    • ⚠️Breaking change⚠️ If you use a config file, please put the reindex_every_n_seconds and album_art_pattern in a [settings] section.
    • ⚠️Breaking change⚠️ The installation process on Linux has changed a lot. See the README for updated installation instructions. A summary of the changes is available here.
    • Embedded album art is now supported for mp3, flac and m4a files (thanks @Saecki).
    • OPUS files can now be indexed and streamed (thanks @zaethan).
    • APE files can now be indexed and streamed.
    • The collection indexer has been rewritten for better performance. This also fixed an issue where on some machines, the web client would be unusable while indexing (thanks @Inicola for the code reviews).
    • Thumbnail generation is now slightly faster, and works with more pixel formats (notably RGBA16).
    • Polaris now uses actix-web instead or rocket. This change fixes numerous performance and stability issues.
    • Sqlite is now bundled by default when building Polaris and was removed from the list of prerequisites. This can be controlled with the bundle-sqlite feature flag when compiling Polaris.
    • The default album art pattern now includes the jpeg extension in addition to jpg.
    • Album art patterns are now case insensitive.

    Web client

    • ⚠️Breaking change⚠️ Your current playlist will appear broken after this update. Please clear the current playlist using the trash can icon. Saved playlists are not affected.
    • Added a logout button.
    • Reworked interface for managing user accounts.
    • Added a shuffle button to randomly re-order the content of the current playlist.
    • The total duration of the current playlist is now displayed.
    • Audio output can now be toggled on/off by clicking the volume icon.
    • Individual discs from multi-disc albums can now be dragged into the playlist.
    • When browsing to album, songs are now displayed and queued in filepath order.
    • Fixed a bug where albums could not be dragged from the random or recent views.
    • Fixed a bug where directories with a # sign in their name could not be browsed to.
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.13.0.msi(26.89 MB)
    Polaris_0.13.0.tar.gz(3.12 MB)
  • 0.12.4(Aug 5, 2020)

  • 0.12.3(Jun 1, 2020)

    Server

    • Fixed a bug where the /flatten endpoint (used by the Queue All function) could return songs from directories with similar names (https://github.com/agersant/polaris-web/issues/53)
    • Fixed a bug where it was possible for users to remove their own admin permissions (https://github.com/agersant/polaris-web/issues/54)

    Web client

    • The web client no longer needs access to Google CDN to display the intended fonts (https://github.com/agersant/polaris/issues/78)
    • Minor font changes (most noticeable in the "recent" and "random" pages)
    • Fixed a bug where pressing some buttons within the settings page would cause the page to reload (https://github.com/agersant/polaris-web/issues/52)
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.12.3.msi(18.77 MB)
    Polaris_0.12.3.tar.gz(2.81 MB)
  • 0.12.2(May 30, 2020)

  • 0.12.1(Apr 17, 2020)

  • 0.12.0(Apr 17, 2020)

    Server

    • Library indexing speed is now significantly faster
    • When indexing files that have malformed ID3 tags, information preceding the error will no longer be discarded
    • Deleted users can no longer make requests using an existing session
    • When using a config file, existing users, mounts points and DDNS settings are no longer removed before applying the configuration
    • When using a config file to create users, blank usernames are now ignored
    • Improved architecture and added more unit tests

    API Changes

    • API version number bumped to 4.0
    • The auth endpoint now returns HTTP cookies instead of a JSON response
    • Client requests to update Last.fm status no longer return an error if no Last.fm account is associated with the user
    • The thumbnail endpoint now supports an option to disable padding to a square image

    Web client

    • The web client now uses Vue instead of Riot as its UI framework
    • Added support for theming
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.12.0.msi(18.94 MB)
    Polaris_0.12.0.tar.gz(2.57 MB)
  • v0.11.0(Jan 1, 2020)

    Server

    • Compatible with current versions of the Rust nightly compiler
    • Fixed a rare crash when indexing corrupted mp3 files
    • On Linux, Polaris now notifies systemd after starting up
    • Release tarball for Linux version now includes a top-level directory
    • User sessions no longer break across server restarts (more improvements still to do on this: https://github.com/agersant/polaris/issues/36)
    • ⚠️Breaking change: due to improvements in Polaris credentials management, you will have to re-create your users and playlists after upgrading to this version. If you want to preserve your playlists, you can use a program like DB Browser for SQLite to back up your playlists (from db.sqlite within your Polaris installation directory) and restore them after you re-create users with the same names.

    Web client

    • Song durations are now listed when available
    • Fixed a bug where clicking on breadcrumbs did not always work when the Polaris server is hosted on Windows
    • Current track info now shows in browser tab title
    • Fixed a semi-rare bug where indexing would not start during initial setup flow
    • Improved handling of untagged songs
    • Fixed a bug where playlist had padding in Chrome
    • Fixed a bug where folder icons did not render on some systems

    Thank you to @lnicola for working on most of the server changes!

    Source code(tar.gz)
    Source code(zip)
    polaris-0.11.0.tar.gz(2.36 MB)
    Polaris_0.11.0.msi(18.90 MB)
  • v0.10.0(Apr 10, 2019)

    Server

    • Polaris servers now ship with an interactive API documentation, available at http://localhost:5050/swagger
    • When using a prefix URL in Polaris config files, a / will no longer be added automatically at the end of the prefix

    Web client

    • Automatically bring up player panel when songs are queued
    • Fixed a bug where songs were not always correctly sorted by track number in browser panel
    • Fixed a bug where some button hitboxes didn't match their visuals
    Source code(tar.gz)
    Source code(zip)
    polaris-0.10.0.tar.gz(2.36 MB)
    Polaris_0.10.0.msi(18.10 MB)
  • v0.9.0(Feb 28, 2019)

    Server

    • Rewrote all endpoints and server setup using Rocket instead of Iron
    • Fixed a bug where special characters in URL to collection folders were not handled correctly (bumped API version number)
    • Server API is now unit tested
    • Fixed a bug where lastFM integration endpoints did not work
    • ⚠️ Compiling Polaris now requires the nightly version of the Rust compiler

    Web client

    • Encode special characters in URL to collection folders
    Source code(tar.gz)
    Source code(zip)
    polaris-0.9.0.tar.gz(142.50 KB)
    Polaris_0.9.0.msi(15.81 MB)
  • v0.8.0(Oct 24, 2018)

    Server

    • Added new API endpoints for search
    • Added new API endpoints for Last.fm integration
    • Thumbnails are now stored as .jpg images instead of .png
    • Duration of some audio files is now being indexed
    • On Linux when running as a forking process, a .pid file will be written
    • Fixed a bug where usernames were inserted in session even after failed authentication

    Web client

    • Added search panel
    • Added settings tab to link Last.fm account
    Source code(tar.gz)
    Source code(zip)
    polaris-0.8.0.tar.gz(144.18 KB)
    Polaris_0.8.0.msi(17.53 MB)
  • v0.7.1(Oct 9, 2017)

  • v0.7.0(Sep 27, 2017)

    Server

    • Added support for the Partial-Content HTTP header when serving music, this fixes several streaming/seeking issues when using the web client (especially in Chrome)
    • New API endpoints for playlist management
    • New command line argument (-p) to run on a custom port (contribution from @jxs)
    • New command line argument (-f) to run in foreground on Linux (contribution from @jxs)
    • Fixed a bug where tracks were queued out of order
    • Updated program icon on Windows

    Web client

    • Added support for playlists
    • Added a button to to queue the current directory (thanks @jxs)
    Source code(tar.gz)
    Source code(zip)
    polaris-0.7.0.tar.gz(130.80 KB)
    Polaris_0.7.0.msi(11.58 MB)
  • v0.6.0(Jul 9, 2017)

    Server

    • Internal improvements to database management (now using Diesel)
    • Configuration settings are now stored in the database, polaris.toml config files are no longer loaded by default
    • Added API endpoints to read and write configuration
    • User passwords are now encrypted in storage
    • Fixed a bug where results of api/browse were not sorted correctly

    Web client

    • Settings can now be edited from the web UI
    • Collection re-index can now be triggered from the web UI
    • Added initial setup configuration flow to help set up first user and mount point
    • Visual changes
    Source code(tar.gz)
    Source code(zip)
    polaris-0.6.0.tar.gz(124.04 KB)
    Polaris_0.6.0.msi(11.60 MB)
  • v0.5.1(Jun 12, 2017)

  • v0.5.0(Jun 4, 2017)

    This releases adds Linux support and a variety of improvements to the web client.

    Server

    • Added Linux support
    • Moved location of configuration file on Windows to %appdata%\Permafrost\Polaris\polaris.toml

    Web client

    • Performance improvements from upgrading RiotJS to 3.4.4 (from 2.6.2)
    • Added support for browsing random and recently added albums
    • Minor visual changes (colors, whitespace, etc.)
    • Updated favicon
    • Fixed a bug where songs containing special characters in their title would not play
    • Persist playlist and player state across sessions
    Source code(tar.gz)
    Source code(zip)
    polaris-0.5.0.tar.gz(85.86 KB)
    Polaris_0.5.0.msi(10.12 MB)
  • v0.4.0(May 8, 2017)

    This release adds new features supporting the development of polaris-android.

    General

    • No changes

    Server

    • Added API endpoint to pull recently added albums
    • Added support for the Authorization HTTP header (in addition to the existing /auth API endpoint)

    Web client

    • No changes
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.4.0.msi(9.90 MB)
  • v0.3.0(Apr 12, 2017)

    This release is an intermediate release addressing issues with the installation process and updating internals.

    General

    • Fixed missing OpenSSL DLL in Windows installer (fixes Issue #3)
    • Split every file into an individual installer component

    Server

    • Added API endpoint to pull random albums
    • Upgraded dependencies
    • Added unit tests to indexing and metadata decoding

    Web client

    • Web interface playlist now displays more tracks (enough to fill a 4k monitor at normal font size)
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.3.0.msi(9.98 MB)
  • v0.2.0(Nov 29, 2016)

    This release is focused on polish and performance, solidifying the basics that were put together in version 0.1.0. Here are the major changes:

    General

    • Polaris now has a project logo
    • ~~Windows installer now supports upgrading an existing install (from 0.2.0 to higher versions)~~
    • Added support for multi-disc albums

    Server

    • Major performance improvements to /browse and /flatten API requests (up to 1000x faster for large requests)
    • Added API endpoint for version number
    • Album covers are now served as thumbnails rather than at source size
    • Moved configuration file outside of /Program Files
    • Added support for Ogg Vorbis, FLAC and APE metadata
    • Fixed a bug where most albums didn't show an artist name
    • Fixed a bug where uppercase extensions were not recognized
    • Upgraded compiler to Rust 1.13

    Web client

    • Complete visual overhaul of the Polaris web client
    • Performance improvements for handling large playlist in Polaris web client
    • Added error messages when playing songs in unsupported formats
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.2.0.msi(9.62 MB)
  • v0.1.0(Sep 26, 2016)

    This is the very first Polaris release, celebrating the minimum viable product!

    Features in this release:

    • Server application with Windows Installer
    • Support for multiple users
    • Support for serving custom music directories
    • Support for custom album art pattern matching
    • Support for broadcasting IP to YDNS
    • Web UI to browse collection, manage playlist and listen to music
    Source code(tar.gz)
    Source code(zip)
    Polaris_0.1.0.msi(5.41 MB)
Owner
Antoine Gersant
Antoine Gersant
A simple GUI rust application that keeps track of how much time you spend on each application.

TimeSpent A simple GUI rust application that keeps track of how much time you spend on each application. Installation Click here to download the Setup

Slacked Lime 4 Sep 23, 2022
A small program to feed the audio from your QRP-Labs QDX digital transceiver through to your computer's speakers

A small program to feed the audio from your QRP-Labs QDX digital transceiver through to your computer's speakers. Also gives you a small user interface in which you can see a signal-strength meter, control the output volume coming from your speakers, and to tune the QDX to a particular frequency (receive SSB and other signals!).

Matt Gumbley 3 Jul 24, 2023
A library and application for lossless, format-preserving, two-pass optimization and repair of Vorbis data, reducing its size without altering any audio information.

OptiVorbis A library and application for lossless, format-preserving, two-pass optimization and repair of Vorbis data, reducing its size without alter

OptiVorbis 27 Jan 3, 2023
A tool that switch default audio playback device on windows.

AudioSwitch A tool built by Rust that can switch default audio playback device on windows. How to use specify which device you want to use Execute it

null 2 Aug 28, 2022
Your musical pokedex, Plex for music

Musidex Your musical pokedex, Plex for music. Add songs from youtube videos or youtube playlist to your library, or import them from your local files.

Pâris DOUADY 35 Oct 5, 2022
Midnote is a terminal application that reads a MIDI file and displays you its notes bar-by-bar, while playing it.

MIDNOTE Midnote is a terminal application that reads a MIDI file and displays you its notes bar-by-bar, while playing it. Goals As a blind musician my

null 4 Oct 30, 2022
🎥 Turn any playlist into a Podcast feed

Playcaster Turn any playlist1 into a Podcast feed Installation Playcaster can be installed from Cargo: cargo install playcaster You will additionally

Jessica Stokes 3 Nov 6, 2022
A music theory guide written in Rust.

Rust Music Theory A library and executable that provides programmatic implementation of the basis of the music theory. Table of Contents Overview Usag

Ozan Kaşıkçı 551 Dec 21, 2022
The open source musician's digital music stand

DiNoScore* A digital music stand written with GTK in Rust using WoAB. Includes an editor to import your sheet. Touch-friendly thanks to Libhandy. Ever

null 13 Dec 5, 2022
🎧 a self-hosted Spotify → Discord music bot

Aoede is a Discord music bot that directly streams from Spotify to Discord. The only interface is Spotify itself. Note: a Spotify Premium account is c

Max Isom 159 Dec 29, 2022
A next-generation music player and manager

ouverture A next-generation music player and manager Very much at Work-In-Planning stage now Planned features GUI (localizable) Backend (something lik

Michael B 9 Nov 17, 2022
A music bot build in Serenity/Rust.

Sunny Flowers is a Discord bot to play media in voice channels. It uses Serenity and Songbird to accomplish this.

Sophie 11 Nov 5, 2022
musify is a simple discord bot to play music within a voice channel, written in the rust programming language.

musify-rs musify is a simple discord bot to play music within a voice channel, written in the rust programming language. Features A simple song queue

NV6 5 Aug 14, 2022
MRVN is a Discord music player bot.

MRVN is a Discord music player bot. It has a few neat features: Supports a wide array of sites, including Youtube, Soundcloud, Twitch and many mo

Tom Barham 17 Jan 1, 2023
Terminal Music Player written in Rust

Terminal Music Player written in Rust Listen to music freely as both in freedom and free of charge! Freedom: As time goes by, online service providers

null 376 Jan 3, 2023
Random music in Annil and stream as a radio station.

anni-radio anni-radio is an audio streaming client for Project Anni. Installation cargo install --git https://github.com/project-anni/radio Dependency

Project Anni 2 Dec 16, 2021
Small music theory library with MIDI capabilities written in Rust

mumuse Small music theory library with MIDI capabilities written in Rust (wip). Examples Creating notes and transpositions // Declare Note from &str l

Alexis LOUIS 4 Jul 27, 2022
A terminal music player written in the Rust language.

A terminal music player written in the Rust language. (Windows) Requirements Configuration file path: C:\Users\xxx\.config\music_player\config.yml # P

xiao hui 162 Nov 12, 2022
Tool for solving music harmonics written in rust.

Harmonized Tool for solving harmonics tasks Installation steps Requirements Make shure you have installed rust cargo If not: Download and run rust ins

Dmitry Miasnenko 0 Jan 28, 2022