posted by Thom Holwerda on Thu 30th Jan 2014 17:44 UTC

Sailfish, part I

As nice and interesting as Jolla's hardware is, I think the bigger deal here is the software. Sailfish, while reusing open source code from MeeGo, is essentially a new operating system, but with clear influences from its past.

The core of the Sailfish operating system consists of the Linux kernel (3.4.0 to be exact) and Mer Core. Mer is quite the important aspect of the operating system, and is not necessarily Sailfish-specific, as other operating systems can use it as well. Its origins go all the way back to Maemo and Moblin, and currently, Tizen also plays a role in its development - but in order to retain my sanity, I have no intention of diving into the complicated relationships between all these mobile efforts.

In any case, Mer Core sits between the kernel and the user interface of the operating system it powers, and uses Wayland for graphics instead of X, making the Jolla one of the first devices to use this relatively new technology. Jolla's Carsten Munk has made it possible to run Wayland atop Android GPU drivers (Hybris), using glibc instead of Android's Bionic. This is a big deal, as it solves the problem of mobile GPU makers not concerning themselves with producing drivers for anything but Android. The code in question is open source, and has already been adopted by Open webOS and Ubuntu Touch, and is a major low-level contribution to the open source mobile world.

Mer Core also provides several other key aspects of a mobile operating system, like multimedia, software management, personal information management, and more. Unlike its predecessor Meamo (which uses Gtk+), but like Harmattan, Mer and thus Sailfish use Qt (version 5.0), so that the user interface is built with QML and Qt Quick.

So, lots of open source stuff in there, which brings us to an important note. If you go to Jolla.com, you're greeted by a flowery statement ejecting sparkling unicorn dust: "Jolla is powered by Sailfish OS, a truly open and distinct mobile operating system". Put a mental asterisk next to the 'truly open' part, since while the kernel and Mer Core are open source, an important part of Sailfish is, currently, not open source: the user interface. However, Jolla has promised that the entire operating system - including the UI - will be open source, and since they've kept every promise they've made so far, I have no doubt that they'll keep this promise.

Setting up the infrastructure to support open source and inclusive development is not easy, especially not when you're also trying to ship a real product consisting of both hardware and software, so it should be no surprise that this takes some time. I do believe, however, that this is an important note to make, since I know a considerable number of OSNews readers find open source to be an essential aspect of their choice of product.


Performance and battery life

The very first thing I want to focus on is performance. There's a reason for that. Anyone who has ever used any of the Maemo devices or the N9 knows that their Achilles heel was performance - which, depending on device, was anywhere between sub-par and downright dreadful. While this was in large part due to low-end specifications and low-quality hardware (as already mentioned), another prime reason was unoptimised software and ageing software stacks. This was my biggest concern when sending the €400 to Finland.

But there's only good news here. Sailfish does away with all the prejudices concerning performance that have become part of the Maemo/N9 story. And all this on hardware that is, compared to its contemporaries, middle-to-low end.

Applications on Sailfish open instantly, without any delay. Everything is responsive, without any input lag. Animations are super-smooth, without any hiccups. This in and of itself isn't all that impressive, but if you take into account that Sailfish has real multitasking, things do become impressive. Even if I have more than ten applications running simultaneously, there's still no lag or degraded performance. It's a huge leap forward from the N9 and Maemo devices that came before it, and a hugely important leap too. With a user interface built entirely around gestures, input lag would be a disaster. Sailfish on the Jolla has certainly exceeded my expectations in this regard.

This extends to something that other phone manufacturers have pretty given up on: battery life. Where my 5S or Find 5 hit the 30-40% battery life at the end of a day's use, my Jolla barely drops below 70-75%. Considering I usually have about nine applications multitasking the entire day (no reason to close any of them), that is hugely impressive. Operating systems like Windows Phone, iOS, and Android need to perform all sorts of complicated tricks to give the illusion of multitasking and still have one-day battery life, while Sailfish with true multitasking runs circles around them.

There is a hugely important asterisk here, though. Sailfish as it currently stands ships with a battery draining bug. The Other Half, the backplate, ships with an NFC chip to instruct the phone to download some special wallpapers and such, and software that controls the NFC receiver in the phone itself had a bug in it that drained the battery more than it should. An upcoming official patch will fix this, but in the meantime, you can easily fix it yourself. There's a chance that once this review is published, the official fix might have already been released.

Just to put all this in perspective, the Jolla phone has a 2100mAh battery, the Galaxy S4 has 2600mAh, and the iPhone 5S has a 1558mAh battery. It could be that the iPhone could achieve similar battery life as the Jolla if it had a 2100mAh battery, but that's something I'll leave to the experts. For now, all you need to know is that the Jolla has amazing battery life, and that its true multitasking does not seem to affect it all that much.


Gestures

One of the most defining features of the N9 was its Swipe UI, and Sailfish builds upon this unique interface and takes it to the next level. This biggest difference between 80/20's Swipe UI and Sailfish is that Jolla has tried to make even more functionality available through swipes than was possible on the N9. This is both a good and a bad thing, because while it makes virtually the entire phone controllable with just a single thumb swiping around, it also makes the set of gestures more convoluted than on the N9.

For instance, while applications on the N9 had a toolbar at the bottom of the display for various functions such as opening settings or going back, Sailfish has a new menu that's hidden 'above' the application. You access this menu, called the pulley menu, by pulling the application down to reveal the menu. As you pull down, you can select an option in the menu by releasing when the desired option is highlighted. Thanks to auditory and tactile feedback, you will soon be able to do this without having to look at your display. The pulley menu is indicated by a glow atop the screen; dragging it all the way down will make the menu permanently visible so you can tap on an option. However, this is really not needed, as it's much easier to select by gesturing.

The pulley menu, while indeed controllable with a single thumb and without having to look at the device, does have one annoying weakness: if the view atop which the pulley menu sits is a scrollable list (say, a Twitter feed), and you've scrolled down a bit, the pulley menu will be unavailable until you've scrolled all the way back up. This can be quite annoying as you frantically swipe back up to open the pulley menu. This could be addressed by adding a 'back-to-top' button - but without a toolbar, where are you going to put it? The nature of the pulley menu means that developers need to consider the contents of it very carefully; if the applications consists of a long, scrollable list, don't put oft-used items in the pulley menu.

The pulley menu is also one of the instances where the gestures can be a bit conflicting. Just like on the N9, swiping down from above the display closes an application. Consequently, the only difference between opening the pulley menu and closing an application is the starting point of the gesture: on the display, or above it. This sometimes leads to unintentional results. But it gets more convoluted than that.

Virtually every gesture can be 'cancelled'. To stick with the example of closing an application, you can swipe down from above the screen, and then hold; this allows you to peek at your homescreen (with running applications and the time and such). If you release while your finger is still on the display, the application is closed and you're returned to the homescreen. If, however, you move your finger back up to above the display and then release, nothing happens. This allows you to peak at your homescreen, and works with most gestures.

If this sounds complicated, that's because it is - at first. When you first pick up your Jolla, all these gestures are a bit daunting, and getting used to them certainly takes a little bit longer than with, say, a toolbar and a home button. The initial learning curve is higher, but - and this is a big deal - it pays off later on. Unlike iOS or Android, where applications tend to do whatever they want with completely arbitrary placement of buttons and toolbars, the gestures in Sailfish are always the same. Every gesture works in every application. Every application has a pulley menu.

So yes, it takes a little longer initially to get used to the gestures, but once you're used to them - we're talking an hour, tops, here - you really don't want to go back. Whenever I pick up my Find 5 or iPhone 5S now, I'm frustrated by how arbitrary every application appears to be, and I quickly long for the consistency that Sailfish brings to the table. Sailfish feels like the logical move forward for a touchscreen-based user interface.

I'm not going to detail all the gestures, since the Sailfish website does that just fine. To help you get to grips with the gestures, the initial setup as you boot your Jolla for the first time integrates the gestures into this setup process - forcing the user to move through all of them at least once. Very clever.

In general, the gestures work well, and I have few complains about them. I think the pulley menu needs a bit of tweaking, though; it seems you need a lot of travel to access all the options (so sometimes you run out of space on the display), and the jump from one item to the next seems a bit too sensitive to me, causing you to select the wrong item every now and then - although this might just be me.


Screens

Sailfish resembles Harmattan the most when it comes to the homescreen setup, and any N9 user will quickly feel at home. There are differences, but they're mostly cosmetic (and, perhaps, arbitrary). Sailfish has three homescreens: the application switcher, the application launcher, and a notification screen. You switch between the application switcher and application launcher by swiping up and down. The notification screen, however, is accessed by swiping up from below the display.

Running applications are represented as 'covers' on the application switcher, and it will display the covers of the nine most recent running applications. You can think of covers as a combination between regular icons and widgets, and application developers can customise them. They can be a miniature view of the application, contain some custom information, an icon, a background graphic, or anything else you can think of. For instance, the contacts application shows a shifting mosaic of contact pictures.

On top of customising the appearance, developers can also add up to two buttons to each cover, which you push and swipe to activate. The mail application, for instance, contains a refresh and new mail button, so you can access this functionality without having to go into the application itself. Since covers all work the same and have the same general appearance, you don't have the Android situation where I pretty much gave up on most widgets since they all look and work differently, which I found increasingly frustrating and confusing.

If you tap and hold a cover, a close button appears over every cover, allowing you to close them. While there is a maximum of nine visible covers, this limit is not imposed on the maximum number of applications you can multitask; the tenth application (and beyond) will also run, you just can't see its cover anymore. However, if you tap and hold to close applications, you'll see the covers of all running applications - even if there are more than nine.

There are problems with the application switcher. First and foremost, due to the relatively low resolution of the display, text on the tiny covers is often fuzzy and hard to read, which just doesn't look very good (this should eventually solve itself on newer devices with better displays). I also dislike how when you only have four applications running, the four covers resize to cover the entire homescreen. I find the transition from four large covers to five or more small ones a bit jarring; on top of that, it also means developers have one more size to test and potentially develop for. I would prefer to have them all always be the same size.

Swipe down from the application switcher, and the application launcher appears. There's not a whole lot to tell here - it's a 4×6 grid of icons (you can scroll down to access more pages), a concept that has not fundamentally changed from the PalmOS days. It does have a number of limitations, though; there's currently no support for folders and it doesn't have any sorting options (other than manually). That's it, really.

Wherever you currently may be in the operating system - application, lockscreen, whatever - a swipe up from below the display opens the notification screen. It's essentially the same screen we know from Harmattan, but given a Sailfish makeover, of course. Currently, functionality of this screen is rather limited, because accounts support has some issues, and because application developers are not yet tapping into its functionality.

Here, you will find notification from applications and from the accounts you've configured in the accounts settings pane (another holdover from Harmattan - I'll get to this later). Tapping the notification will open the associated application, and the pulley menu has an option to mass-dismiss all notifications at once, and an update option to mass-update all sources.

Like in Harmattan, these three screens combined constitute the main user interface of the Sailfish operating system, and together with the gestures and ability to peek, you get an initially relatively complex user interface that, over time, as you learn the gestures by heart, becomes incredibly powerful. Most of all, though, it becomes natural. The N9 and Harmattan had that same feeling (although without the learning curve) that's kind of hard to describe. Using consistent gestures to navigate around the user interface and applications on a smartphone just feels more natural than using buttons and toolbars that are often different for each application.

Aside form the aforementioned three main screens, there's one more screen you can swipe to: the Ambiance screen. If you swipe the application switcher to the left or right, you get a screen which contains a graphical list of the Ambiances you've favourited. Ambiances are essentially themes that the operating system generates from a wallpaper that you've set, changing all the colours of the user interface to match. This is a nice segway into my next topic, but I do want to state that this Ambiance screen is superfluous (since you can set Ambiances in the photo application), and giving this functionality so much prominence makes little sense to me. It's easily avoided though: just don't favourite any Ambiances, and the screen disappears.

Table of contents
  1. Introduction
  2. Hardware
  3. Sailfish, part I
  4. Sailfish, part II
  5. Miscellaneous & conclusion
e p (18)    28 Comment(s)

Technology White Papers

See More