
Plexamp, standalone music player that can play any music format - vidyesh
https://medium.com/plexlabs/introducing-plexamp-9493a658847a
======
LeoPanthera
> We quickly settled on Electron as a platform to build the app.

Ah yes, because when I want to play music, my first thought is, "doing it
inside an entire web browser engine is the logical choice".

It's especially bad that they're comparing it to WinAmp. WinAmp was in part
popular _because_ it was extremely minimal and resource-light.

I'm so sick of electron apps. My battery hates them. My processor hates them.
I hate them.

Maybe give cmus a try, which is almost the literal opposite of an electron
app: [https://cmus.github.io](https://cmus.github.io)

~~~
hrktb
I felt you had a very good point until I went with all my hopes to the cmus
page. So it’s *nix only (no supported GUI on other platforms)

And that’s why Plexamp is based on electron, as OSX and Windows support comes
basically free.

To be clear I’m not dissing cmus, just that it’s not the same target as
Plexamp and each choices make sense.

~~~
mhd
Because there are no cross-platform options between 70s terminal apps and The
Whole Internet(tm)?

I mean, this basically seems to be a mpd client, so the difficult work has
mostly been done already. But I guess a big draw of the webtechstack is that
it's easier for a lot of people to do fancy animations (like the mentioned
equalizer) and all the blinkenlights.

Which is interesting in the WinAmp context, as amongst the things that drew
people to it were two things: Small size & fancy UI...

~~~
pjc50
_Usable_ cross-platform options? Not really, as we can tell by the dearth of
popular cross-platform apps.

I remember there was a great Cambrian explosion of music players back in the
Napster era, especially on Linux. It seemed to me that the availability of
good non-pirate managed options like iTunes and later Spotify gradually killed
off standalone players. Maybe they're coming back into fashion.

~~~
mhd
I'd say that there's a dearth of _desktop_ apps, creating them in a cross-
platform way is easy enough. Not that the situation got a whole lot better,
but if you're doing web UX i.e. don't give a damn about native UI guidelines
anyway, minor deviations that UI toolkits introduce pale in comparison.

And yeah, I think there were three waves of sound apps on Linux: mp3s becoming
commmon/computers fast enough (mid-90s), Amarok switching UIs and everyone
writing a retro-replacement and recently music moving into the clouds, thus
requiring players that connect to Spotify et al.

------
Hamuko
>We quickly settled on Electron as a platform to build the app.

I guess the "small" only refers to the window size and not to the resource
usage. Even the application bundle size is 160 megabytes. Holy fucking shit.

~~~
Veratyr
Considering that MPD, which is doing the actual music playing, is only 13MB
([https://www.musicpd.org/download/win32/0.20.13/](https://www.musicpd.org/download/win32/0.20.13/)),
yeah, it seems crazy that this bundle is 160MB.

Electron doesn't even have any inclination to fix it:
[https://github.com/electron/electron/issues/2003](https://github.com/electron/electron/issues/2003)

They could even probably use Chromium Embedded Framework, which is usually
~40MB and get a decent improvement. The binary would only be 4x the necessary
size rather than 10x then.

------
peterburkimsher
I'm a heavy user of iTunes 10.6.3. The old interface is beautiful, and it
syncs music/contacts/calendars to my iPhone and iPod over USB without needing
iCloud.

Next year I'm planning to rewrite iTunes as a personal project.

Essential features for me are:

\- Multiple libraries

\- Tags

\- Playlists

\- Playlist folders

\- Sync

\- AppleScript

\- Mini player

I use iTunes as a general database manager, not only for music. I have a
library for Facebook friends, where each person is stored as URL track.
Clicking on the track triggers a PHP script, which opens my browser with their
profile.

I also have other databases for Raspberry Pi projects, universities &
departments, SMS text messages, and Chinese characters (a script on that
library is what became
[https://pingtype.github.io](https://pingtype.github.io) ).

Before I start this huge project, could anyone tell me about alternatives?
I've looked into FileMaker, Access, SQL, MongoDb, etc, but nothing has the
ease of use, nested playlist folders, and scriptability of iTunes.

~~~
shakna
Well of your essential features, the only one lacking in Amarok would be
AppleScript, though you can still write scripts for Amarok in QTScript, which
is fairly similar to JavaScript. [0] (Amarok runs on Linux, Windows and
macOS).

For what you're using it for, I'd probably using SQLite, and a mix of DB
Browser for SQLite [1], which is kinda like Excel for SQL.

DB Browser can also export records to file. So if you had something like watch
running on a folder, you can trigger a script as soon as that happens.

My vague thought process:

DB Browser entry:

    
    
        kind    entry             play?
        music   KickassSongILike
    

You click KickASSSongILike, and type y in the play box.

A Python script, called by watch watching the db, sees the change and uses
something like mp123 to play the file. When it's done, or rather when the
process for mp123 stops, so you can stop a song playing, it changes play? back
to 'n'.

But honestly, you'd do a lot better just building it as a GUI app from
scratch.

Easiest would be Python, which comes with Tk for graphics, and SQLite for
database. Probably a weekend to get you 3/4, and then... Well it depends on
the hard parts.

The hard parts are:

* Sync. Sync with what? And how does that thing officially support extensions? Or what workarounds are currently used instead?

* AppleScript. AS doesn't get much love anymore, even from Apple. Integrating it isn't an easy thing.

As a way to explain how simple most of this is, I'll explain it in terms of
SQL:

* Multiple libraries = Multiple tables.

* Tags = A second table, filled with tags, that you query via JOIN.

* Playlists = A second table that references primary keys of individual song records.

* Sync = Compare last-updated fields between backup db and current db, then using developer API to update your sync service.

[0] [https://amarok.kde.org/en](https://amarok.kde.org/en)

[1] [http://sqlitebrowser.org/](http://sqlitebrowser.org/)

~~~
peterburkimsher
Thanks for replying! I agree that the easiest way is probably to rewrite from
scratch.

DB Browser is like Excel. That's like seeing a single library playlist with
lots of rows with songs on.

I need playlist folders, which is a kind of nested data structure. I can drag-
and-drop playlists between playlist folders, and also make Smart Playlists.

Smart Playlists are basically SQL queries. But SQL databases are flat - I
can't have tables inside tables.

~~~
zdkl
I'm approaching the nested datastructure playlist problem by having playlists
be nothing more than a special tag in the existing sqlite table. But then you
have to reckon with explosive growth when dealing with that table, especially
with (potentially ephemeral) machine generated tags.

Anecdotaly, tagging attributes and relationships on a large library is a good
way to DIY big-ish data, as my HD learned.

~~~
peterburkimsher
What size is the big-ish data that you're talking about? iTunes slows down
noticeably over 30k songs.

My Facebook friends database is small by comparison (under 6000), but if I
want to include all their Liked Pages, the database size increases to 223,783.

The nested structure is really important to me. For example, my friend David
is in the lists: Taiwan, Christians, Health & Medicine, KGCC Church, KTL
Christian student group.

The KGCC and KTL playlists are inside the Taiwan folder.

I can use Smart Playlists to sort by the year when I added friends, but I want
to manually manage some playlists as well. For example, if I go on holiday to
New Zealand and add a new friend, then they belong in the New Zealand list,
not the Taiwan list, even though the date added is during my time living in
Taiwan.

Some playlists are not in any country folder e.g. male/female, Limited
Profile.

The highly nested nature of the database means Excel isn't suitable, and my
brief look at SQL tells me that it would quickly become a mess of tables.
There must be some kind of database program that supports nested structure,
but I haven't found it yet, and that's why I'm asking here.

~~~
dragonwriter
> The highly nested nature of the database means Excel isn't suitable, and my
> brief look at SQL tells me that it would quickly become a mess of tables.
> There must be some kind of database program that supports nested structure,
> but I haven't found it yet, and that's why I'm asking here.

Nested structure is easy to represent in SQL, and doesn't take a lot of
tables. It can be a little bit awkward to query, and it tends to be
inefficient to query, but with a smallish DB of on the order of hundreds of
thousands of records with a not really deeply nested structure, that's
probably not a big concern in practice.

Graph Databases may be a better solution; they should handle the nesting more
simply.

~~~
peterburkimsher
ArangoDB looks like the most popular Graph Database program.

The internal data structure model looks fine, and probably quite efficient,
but I can't find a GUI that shows playlist folders.

------
solarkraft
> Literally the only requirement we had was “small”

...

...

...

...

...

...

> We quickly settled on Electron

The reason Plexamp "can play any format" is that it's a client for mpd. While
it's insanely bloated for what it does (Winamp became popular for exactly the
opposite), it does look like a very good implementation of the concept
visually. Especially satisfying when you always see very good music player
concepts on dribbble, but none of them are actually implemented.

------
gregman1
Electron for a music player? It's like using matlab as a text editor.

Absolutely stupid.

~~~
pmlnr
Spotify is also electron :/

~~~
la_oveja
Spotify is a website, that uses web services. If I want to listen to my local
music, I don't need a browser.

It's just plain stupid.

~~~
magicalhippo
PlexAmp is meant to play music from your Plex library, which may indeed not be
local. The Plex server API is HTTP based (something REST-like IIRC).

And they wanted the player to work on multiple platforms, unlike say
Foobar2000.

Not saying it's the best technical choice, but given that it started as a
personal side project it's a hardly fair to call it "plain stupid" to use
Electron for this.

~~~
pmlnr
> And they wanted the player to work on multiple platforms, unlike say
> Foobar2000.

You mean something like VLC, mplayer, clementine, Quod Libet, [insert another
massive amount of players based on gtk, python, qt, etc.]? Something tells me
Electron is not the only choice.

~~~
magicalhippo
I suspect it's easier to go the route they did than try to integrate Plex
playback into the clients you mentioned. Though of course it's not the only
choice...

------
ferongr
Those people really want to appear on that n-gate dude's website.

------
sbashwin
Just used this and I personally felt it's simple and great! Very easy to
search for a track and play them.

------
SnazzZG
Looks pretty, but I don't need yet another app with it's hooks into my social
media/email etc.

------
_ZeD_
Sooo... they build an mpd client?

cool, it's ages I toyed with ncmpc and QMPDClient

