Installing Giocoso on openSUSE Tumbleweed

1.0 Introduction

First, there was SUSE Enterprise Linux (SLES), which was expensive but reliable and business-ready. Then there was openSUSE, which was free but equally reliable as it was effectively simply a re-build and a re-packaging of the original SLES. And finally was brought forth openSUSE Tumbleweed, which isn't really built on SLES, but is more of a rolling preview of what SLES might be in the future. Tumbleweed (for that's what I shall call it henceforth) is therefore to SLES what Fedora is to Red Hat Enterprise Linux: racy, daring, cutting (or bleeding!) edge. As a 'rolling release', it gets updates to software all the time, as the updates are released, not once or twice a year when the distro developers are ready for another 'big bang' release of a new version. As such, Tumbleweed is up-to-date and modern... but with a slight tendency to be less reliable than its SLES-based cousin, because new updates can break things.

Anyway, I mention all this history and background because of a crucial difference between openSUSE-based-on-SLES and Tumbleweed: Giocoso can run on Tumbleweed, but cannot on openSUSE 'proper'. The reason is because SLES, and hence openSUSE, ship with Version 4 of the Bash shell... and Giocoso Version 2 demands and requires Bash Version 5. Tumbleweed, happily and as you'd expect from a bang-up-to-date rolling release, ships with the latest version of Bash, and thus has no trouble meeting Giocoso's requirements. (That reliance on Bash 5, by the way, isn't an example of Giocoso itself been too bleeding-edge for its own good, because Bash released that version way back in January 2019. It might be time for SLES to catch up a little!)

That's all prologue to the business of downloading the relevant ISO for the distro from its official website and installing it onto a VirtualBox VM, built with 4GB of vRAM and a 2-thread virtual CPU, plus a 40GB virtual hard disk. As I do for all my documented Giocoso installs on Linux, the first thing I did after installing the operating system was to ensure it was as up-to-date as possible. In Tumbleweed's case, you do that by issuing the command

sudo zypper update

..and I thereby ended up using kernel 5.18.6 and XFCE 4.16, using the x11 graphical server. Though I chose to install the XFCE desktop environment, Tumbleweed ships with all the usual suspects, such as Gnome and KDE, and the specific choice of desktop manager is irrelevant from Giocoso's point of view: it will happily work with any of them.

2.0 Installing Giocoso

Giocoso is installed by a script which is downloaded from this website and then executed. The usual tool for doing that is wget, run within a new terminal session, in which you type the following commands:


The initial 'cd' is to make sure you're sitting in your home folder when the download occurs -but provided you know where you are in your file system, you can download the script to anywhere to which you have read-write access:

You'll note that we are dealing with a download that's only a few kilobytes big. The specific numbers change over time, as new developments are included in the script, but we're talking no more than 5 or 6K at worst.

Once the script is downloaded, you invoke it with the command:

bash abc_installer --giocoso

As soon as the script executes, the screen will clear, the text will turn assorted shades of green and yellow (depending on your terminal's choice of colour scheme) and you'll see something like this:

The Giocoso script is fetched from my servers (and you'll be prompted to supply a sudo password if you haven't already supplied one recently), because we need root privileges to copy the downloaded script to your /usr/bin folder. After that's supplied, the script concludes and you're ready to run Giocoso.

Summing up then:

  • fetch the abc_installer script;
  • run it with the --giocoso argument;
  • supply your sudo password.

It's really that simple.

3.0 Running Giocoso for the First Time

Once Giocoso has been installed, you run it most simply with the bare command giocoso (though you'll see that this soon can become more complicated, with lots of run-time options being passed to the program via runtime parameters). When you launch the program for the very first time, you'll see this happen:

Tumbleweed shares a trait that's pretty unusual amongst Linux distros generally, but is common to anything based on SUSE: it doesn't ship with the bc package by default. Without it, Giocoso can't do a lot of important things, so it insists it is installed before it attempts to do anything very clever. As you can see, some of the error text is in bright blue: that's the command needed to install the missing utility, though it's been broken over two lines and needs to be submitted as a single line command.

You could just copy-and-paste the blue text into a text editor and wrangle it onto a single line... or you could just type the command yourself. That's the option I chose:

As you see, you are asked to continue by typing 'y' (or just pressing [Enter], as that's the default). After a tiny 115KB of software has been downloaded and installed, you can try running Giocoso for a second time (again, with the bare command giocoso):

This is progress: at least Giocoso is actually running, even if it's only to tell you that Tumbleweed by default lacks a number of packages that it depends on. The long commands in bright blue text are everything you need to run to fix this problem up, though again they have been split onto multiple lines and they need to be submitted as a single line command. This one is probably too long to manually type comfortably, so I highlighted the blue text, copied it and then pasted it into a text editor, where I sorted out the line breaks:

Once sorted in the text editor, it's just a select+copy and then a paste back into the terminal session:

As you see, quite a lot then happens on the screen... including this prompt to accept a package signing key from the Packman repository:

The default here is 'r', meaning to 'reject' the key. That won't help get Giocoso working though, so be sure to type the letter 'a', meaning 'trust always' and then press [Enter]. You'll then be asked to continue once more, and the correct response there is 'y' (or just  press Enter, because that is the default).

So now your system finally meets all Giocoso's software requirements, you can try running it for the third time (again, with the command giocoso):

This message only appears the first time Giocoso is run: a persistent configuration file is expected to be found in the $HOME/.local/share/giocoso folder, and when one can't be (as will always be the case on the very first successful run of the program), Giocoso will download a 'default' configuration file from the absolutelybaching servers and store it in that folder. You just press any key at this point in order to proceed. Some downloading magic will happen and your terminal will finally end up displaying something similar to this:

That wall of red error message text doesn't look too promising, does it?! In fact, however, it means Giocoso is running fine. The only thing happening at this point is that you are trying to run Giocoso in its default mode without there being a database to use to find music to play (because you haven't created it yet!), or without telling it explicitly not to use a database. This is described in more detail in the sections of this manual about Direct Play Mode and Database Play Mode. For now, the problem is easily corrected by appending a runtime parameter to the basic 'giocoso' command to formally instruct the program not to use a database for now:

giocoso --dbname=none

But if you type that command into the terminal now, you'll encounter yet another error:

Again, the red error text can look intimidating, but all Giocoso is saying here is: when you run me without a database, I must either be physically in a folder of music files I can play, or you must direct me to where such files can be found. In my case, I know I can find some music within my /sourcedata/music folder, so let me visit a folder there and try again:

This time, I'm sitting in a folder which clearly contains a FLAC file (and it must be a FLAC file: Giocoso won't play MP3s, OGGs, WAVs, ALACs or any other type of audio file). If I once again launch Giocoso (for the fifth time, if you're keeping count) with the giocoso --dbname=none command from before, I now get this result:

...and that's Giocoso happily playing the music, displaying the album art that's been embedded within it whilst it's at it! And it only took five goes to get there!!

  • Let's just sum up all those steps, therefore:
  • When you first run Giocoso, it complains about the absence of the bc utility, so you have to install that before doing anything else
  • When you then run Giocoso for the second time, it notices a lot of required software packages are missing, so you have to install them before doing anything else
  • On the third run of Giocoso, it will download a default persistent configuration file and then immediately error out, saying you've said to use a database that doesn't exist (because that's the default setting in the new configuration file)
  • On the fourth run of Giocoso, you invoke it with the explicit instruction not to try using a database, by adding the --dbname=none runtime parameter to the original giocoso command. But that errors out too, because you are not sitting in a folder containing a FLAC file.
  • So you cd to a folder that does contain at least one FLAC and then run giocoso --dbname=none again... and this time, it finally works.

I think that makes it sound more complicated than it is, to be honest! The real point is that it takes a few goes to make Giocoso happy with its software and musical environment, but once you know about the '--dbname=none' parameter and the need to be in a folder of FLACs, it all works just fine.

4.0 Creating a Database and Music Scanning

Now that you've got Giocoso working and displaying things properly in Direct Play Mode, it's time to consider getting Giocoso to create a database of what music is available to play. That's called running Giocoso in Database Play Mode -and it's where all Giocoso's randomisation features come into play. Instead of playing the particular contents of a specific folder of music, you can ask Giocoso to scan through its database and find anything at all conducted by Karajan that lasts less than 20 minutes ... or pretty much use any other selection filters you can think of!

So, first, we need to get Giocoso to create a database and populate it with details of what music files exist. In a terminal, you do that with a variation on the command:

giocoso --createdb --dbname=my-db-name --musicdir=/somewhere/on/my/filesystem

...replacing 'my-db-name' with an actual name of the database you want to create; and '/somewhere/on/my/filesystem' with the path to the root of your music collection. Database names can be pretty much anything you want them to be -but if they contain spaces, they need to be wrapped inside double quotation marks, which can be a bit of a pain to remember to do every time you subsequently use it. I'd recommend a database name with a short, single-word, name. The default, incidentally, is simply 'music', so if you miss out the --dbname parameter by accident or design, that's the database you'll get created anyway.

The 'root of your music colleciton' folder used for the --musicdir parameter is important to get right. Giocoso will scan any number of folders 'underneath' the one provided, but will not scan upwards or sideways! In other words, supposed you stored your music like this:

  • /music/classical/Britten
  • /music/classical/Beethoven
  • /music/classical/Opera/Puccini

...then --musicdir=/music/classical would fetch all three folders of music (and any sub-folders within them). But a --musicdir=/music/classical/Opera would be blind to the existence of the Britten and Beethoven folders. Giocoso will happily descend within the Opera folder to find any number of sub-folders within it, but cannot go back 'up' a level, and discover the existence of those other two folders. So, point the parameter at a folder that's at the root of your entire music collection, not half-way through it, if you want Giocoso to be able to play everything you have collected. Also note that, as ever, if the path you want to specify contains spaces, wrap the entire path in double quotation marks. For example: "/home/hjr/My Music".

With all that in mind, here's me creating my Giocoso music database:

You'll notice from that, by the way, that the order of the runtime parameters doesn't matter: here, I've got --createdb coming after the --dbname and --musicdir parameters, but it makes no difference to whether the command will work or not! When I submit that command, this happens:

The program tells you that the database has been created almost instantly. That's because creating a database takes almost no time at all: it's the populating it that takes all the time and effort, which is what will happen next, once you press a key. Incidentally, you can confirm the existence of the database file itself by looking in $HOME/.local/share/giocoso: the database will exist as a file called <whatever database name you chose>.db. It will be pretty small, even after it's been populated, because all that's in the database is metadata about your music collection. No music files are ever copied into the database, or moved into it, for example: your music stays exactly where you put it! But the data describing that music is what the database will end up being full of... and that's just text and takes up very little space.

Anyway, here's my new database, before it's been populated with data:

As you can see, it's just 52K big at the moment, and because I've asked for a database called 'main', the database file is called 'main.db'. The filename will match the case of your dbname parameter value exactly. That is, a database called 'Main' is a completely different from one called 'main' or 'MAIN': you always need to supply --dbname in the correct case, in other words.

When you're ready then, press a key on the main Giocoso window, and it will begin to scan for music files:

As the message says, scanning for music files in a large collection can take a lot of time, though Giocoso parallelises the search as much as possible in an effort to speed things up. At this stage, the scan is simply creating a list of what music files exist. That can take a long time, depending on the size of your music collection -and there won't be any obvious indication of progress, apart from a spinning indicator. Just be patient and let the program do it's thing.

Once a complete list of music files has been prepared, Giocoso will then move on to investigating the characteristics of each music file in turn:

Here, progress will be more obvious, since Giocoso scans each discovered music file in turn for all the metadata tags it contains, it's duration and so on. All of that data it's writing into the database. Clearly, this can take a long time too -but at least you can now see progress being made, as the various music folders are visited in alphabetical order. For reference, scanning my 2TB collection of 15,000 or so recordings, over a 1Gbps network link, took just under 2 hours. On my main PC (an actual, physical PC!), it takes more like an hour... so it's not exactly the speed of light, but it's not too bad, either!

At the end of the scanning process, you get a statistical summary of everything that's been found:

At this point, a snapshot of your music collection has been taken and stored in Giocoso's database -which you'll recall was originally 52K big and is now:

...23MB in size. So yes, a populated Giocoso database gets significantly larger than when it's first created, but it remains fairly small, no matter how big your actual music collection happens to be, because nothing of the music itself is stored within it, just the metadata.

6.0 Database Play Mode

Once Giocoso has scanned your music collection and stored the data about it in its database, you can use Giocoso in what is termed Database Play Mode. At its simplest, you simply invoke Giocoso with the --dbname=xxxx runtime parameter, so that it knows what database you're wanting it to use. In my case, typing this command, for example:

giocoso --dbname=main

...caused this to happen:

You'll note from the top of the Giocoso window that we're in 'Database Play Mode' and using database 'MAIN' (Giocoso upper-cases names for display purposes, but the name you supply in the --dbname parameter has to be case-aware). For some reason, Giocoso has decided to play a piece of music by Maurice Ravel: I didn't ask it to do that, but Giocoso simply picked something at random, and this is what it happens to have picked.

This, in fact, is the essence of Database Play Mode: randomisation. Without other filters and 'guidance' you may provide to it, Giocoso simply picks a composer at random (each composer having an equal chance of being selected as any other, no matter how much or how little music they may have contributed to your music collection) and then picks a recording attributed (in the ARTIST tag) to that composer. You end up hearing a completely randomly-selected piece of music.

If you want to 'guide' Giocoso, so that its selections aren't completely random, you can do so by adding one or more selective runtime parameters (which are discussed at length here). Suppose you want to play a piece of randomly-selected music that's by Beethoven? This command will do it:

giocoso --dbname=main --composer=beetho

...resulting in this slightly-modified program display:

Notice how Giocoso displays your filters to you in blue, in the main part of the screen. Again, the parameter value 'beetho' has been upper-cased for display purposes -though, in fact, on this occasion, it makes no difference how you typed in the parameter value. All textual comparisons within the database are done having first forced everything (temporarily!) into upper case. You'll also spot that though I supplied the parameter value 'beetho', Giocoso has correctly found music which it knows was written by 'Ludwig van Beethoven': parameter values such as composer name are always 'wild-carded', meaning that 'bri' could match Frank Bridge as well as Benjamin Britten.

If particular performers, rather than composers, are your thing, then other runtime parameters can be fed to Giocoso. For example:

giocoso --dbname=main --comment=robles

...produces this result:

Why is something by Boieldieu now being played in response to that request? Well, in this case, the album art gives the game away: Marisa Robles is the harpist on the recording. You'll notice back in the main part of the Giocoso display, too, that whilst Iona Brown and the Academy of St. Martin-in-the-Fields are listed as performers, so too is Marisa Robles singled out as 'harp'.

Again, you can wild-card your searches, so 'rob' would have matched Marisa Robles too... though it would also have matched 'Robin Ireland' or 'David Robertson': wild cards can be very helpful, but also result in surprises (which, in the world of making sure you don't listen to the same music over and over again is no bad thing, actually!)

I should perhaps finally mention that these sorts of runtime parameters only achieve their proper effect when you tag your FLAC files in the manner I've documented elsewhere in my 'Axioms of Classical Tagging' articles. Specifically, I used the --comment runtime parameter to find Marisa Robles because she is a performer on a recording and all the performers of a particular recording under my tagging axioms are always typed into the COMMENT tag. There is also a --performer runtime parameter, but that only searches the PERFORMER tag -and, in my system of tagging, that only contains one name, the name of the 'distinguishing artist' that makes a recording unique from any other. That means the PERFORMER tag usually contains the name of the conductor of the piece, not the singer nor the orchestra nor the harpist! If I wanted to listen to something conducted by Karajan, for example, I could certainly invoke Giocoso with the parameter --comment=karajan, but I could also use --performer=karajan, and achieve much the same results. Why duplicate in this way? Well, sometimes you get conductors who perform. Think Benjamin Britten, for example: if I wanted to hear him as a conductor, I'd say --performer=britten. If I wanted to hear him as a pianist, I'd say --comment=britten.

Anyway: this is not the place to discuss the subtleties of tagging strategies! The point to take away from here is that once Giocoso has scanned your music collection, it can play any part of it at random -or you can provide runtime parameters to guide and shape its random choices. In all cases, the program display will tell you what's been selected to play and what filters guided that choice.

7.0 Conclusion

This article was intended to get you started with Giocoso on openSUSE Tumbleweed. To learn how to use the abc_installer script to install Giocoso; to run Giocoso in Direct Play Mode; and finally to run it in Database Play Mode, with and without filters to 'guide' the randomisation process. Hopefully, you've seen how easy it is to install and run Giocoso... after that, everything is simply a matter of becoming familiar with the array of things you can do with it.

For which the rest of this manual should be your guide!

[Back to Front Page]|[Back to Installing on Linux]