A tour of elementary OS, perhaps the Linux world’s best hope for the mainstream

By Scott Gilbertson

The default look of ElementaryOS Juno
Enlarge / The default look of ElementaryOS Juno.

Everyone is a Linux user, but almost no one knows it. The operating system is a strange beast. You'd be hard pressed to come up with another tool so widely used, so widely deployed, and so absolutely necessary to the functioning of the modern world that is simultaneously so utterly unknown outside the tech community.

From ATMs, to phones, to in flight displays, to the Web server your browser got this page from, we are all using Linux every day even if we don't all realize it. Yet even with that ubiquity, there's one place Linux has never really succeeded: the desktop. Despite passionate communities of users (as seen in place like Ars comment threads), Windows and macOS dominate the desktop and that's unlikely to change in the near term. Though if it ever does, it will likely be because of projects like elementary OS—an operating system that seeks to bring the polish of commercial desktops to the world of Linux.

elementary OS began life over a decade ago as a set of icons. (Yes, seriously.) If ever there was a group of developers who started at the bottom and worked their way up to the top, it's Daniel Foré and the rest of today's elementary OS team. From a set of icons designed to improve the look of Ubuntu's then GNOME 2 desktop, the elementary project expanded to include some custom apps, including a fork of the default GNOME files app, Nautilus, called nautilus-elementary. As with most open source projects, the borrowing went both ways: Ubuntu's Humanity theme was a fork of elementary OS's icon set.

Over the years, the elementary project continued to grow and encompassed ever more apps and ever more customizations for the desktop. Eventually, things got to the point where it became more and more cumbersome for users to install everything. But there was enough momentum behind the project that Foré decided the logical thing to do was for the group to create their own distribution. The project took Ubuntu as a base and began layering in their custom apps, and the highly refined look and feel of elementary OS was born.

elementary OS (codename version Luna) launched in 2012 with considerable fanfare thanks to its revolutionary idea of asking users to pay for it. Unfortunately for elementary OS, a blog post about the pay-what-you-want model initially rubbed a lot of people in the Linux community the wrong way. Most of the kerfuffle was not about the money, but rather the wording of the post, which essentially called non-paying users thieves.

When I spoke with Foré, he was quick to point out how little experience the team had with PR at the time (he clearly regretted the post). It was poorly worded, but as with all things in Linux, it was something of a tempest in a teapot even at the time and it's well behind the project at this point. I bring it up not to revisit the controversy, but because the funding model elementary OS established early on has succeeded.

Today, elementary OS is a bootstrapped business with quite a few full time employees. It's not Canonical by any means, but it is self-sustaining and it has a model for how to continue sustaining itself, which is more than a lot of open source projects can say. If I were an open source project heavily dependent on contributions from Red Hat employees, I might right about now have a closer look at how elementary OS's funding model works. (Of course, the elementary OS model doesn't necessarily work at the scale of Red Hat, but it doesn't have to in order to sustain elementary OS.)

In fact, elementary OS' funding model works so well that the project has extended it to developers in its app store as the latest elementary OS iteration—version 5, code-named Juno—has rolled out. For interested users, there are currently quite a few apps specifically targeting the elementary OS desktop. And within the elementary app store, every developer can set a price that they feel is fair as users still ultimately decide what they want to pay, down to and including nothing. Juno may represent the easiest and most sustainable way for the uninitiated to finally wade into the Linux waters.

elementary OS 5 Juno

For a bit of logistics, elementary OS Juno should be version .5, following the previous release, .4 or Loki. However, since .5 implies incomplete and elementary OS is more or less complete (in terms of stability certainly) ,the project is calling this release elementary OS 5.

The default look of elementary OS Juno.
Enlarge / The default look of elementary OS Juno.

Whatever the version number may be, one thing is for sure: there's ton of new stuff in Juno. Enough features, in fact, that the release notes, written by elementary OS's Cassidy James Blaede, are an impressive John Sircusa-style essay of some 8,000 words. If you want to know everything that's new, Blaede's notes are worth a read. If you want to know what it's like to actually use all that stuff, read on.

Before getting started, Linux users wanting to try elementary OS should be forewarned: it doesn't work very well in a virtual machine. I installed it, but it was very slow. According to Foré, it's an upstream problem. GTK requires hardware acceleration for animations, which does not currently work in Virtualbox. That may change soon, though. One of the big lessons Canonical has learned from collecting hardware metrics is that Ubuntu ends up in virtual machines a lot, so improvements are apparently in the works. That will help downstream distros like elementary OS, as well as others like Linux Mint Cinnamon edition (which also runs poorly in a virtual machine).

In the mean time, to get an accurate sense of performance, you'll need to install elementary OS. The Juno installer is a thinly skinned version of Ubuntu's Ubiquity Installer, which means you can easily install elementary OS alongside your existing OS just as you would Ubuntu. The installer is perfectly functional, but it doesn't really convey elementary OS's unique look and feel, which is why there's a new installer in the works. That's a collaboration between elementary OS and System76 (creators of PopOS), and it will be, I assume, what you'll see installing future versions of PopOS as well. The new installer isn't ready for Juno though, so for now you'll have to make do with the Ubiquity installer.

Composite screenshot of some of the top bar menus in elementary OS Juno.
Enlarge / Composite screenshot of some of the top bar menus in elementary OS Juno.

elementary OS was plenty snappy on my Lenovo x240 (i5 with 8GB of RAM), but I also installed it on a brand new Dell XPS 13 where it really shined. elementary OS's theme, typography, and icons all looked really nice on the XPS's HiDPI screen. My only gripe is that elementary OS's scaling is either 1X or 2X, and there's no in-between. My preference on the XPS would be more like 1.5X, but as far as I know only the KDE and Cinnamon desktops support incremental scaling without command line fiddling.

Once you've got elementary OS installed and you reboot, you'll be greeted by the Pantheon desktop. While Pantheon is based on GNOME, it's very much its own thing. Like GNOME, Pantheon has a top menu bar, but it functions very differently in that it's never used for application menus (something GNOME is getting rid of as well). Instead the top bar in elementary OS is a global bar—it never changes. The top bar shows the date and time in the middle, status notifications, a power menu, settings for audio, power, and wireless to the right and an application launcher to the left.

elementary OS also sports a dock-style app launcher along the bottom of the screen that is, well, somewhat macOS-ish. elementary OS has taken some flack over the years for being heavily macOS-inspired and it does have some element of macOS—the dock, a column view in Files (which KDE used to offer as well), and, perhaps more than anything else an obsession with details. elementary OS clearly sweats the small stuff, paying careful attention to typography, icon design, color use, shading, and so on, which ends up creating a kind of feel that's perhaps reminiscent of macOS. Having played with elementary OS since version .2, I would say the macOS influence has been declining with every new release and I really don't see it at all in Juno, beyond the use of the dock.

Another possible reason some users find elementary OS to be macOS-like is that it lacks the level of customization many Linux desktops offer. There's really no way to change the look and feel of elementary OS, and little way to customize the behavior of its default apps. It's a take it or leave it operating system—you either like it or you don't, and if you don't you're better off using something else than trying to tweak elementary OS to suit your whims.

So, elementary OS is not a Linux desktop in the traditional sense. Rather it's an operating system in the same sense that Windows and macOS are.

That said, you can make certain customizations without too much trouble. For example, elementary OS puts the windows close button on the left, which, for me, messes with 25 years of muscle memory. There's no setting to change this in elementary OS, but since GNOME is under the hood you can use gsettings to change the button layout. In other words, little adjustments are possible, but I'd suggest staying away from the tweak apps.

Juno ships with the ability to remap the Super key. By default it brings up a list keyboard shortcuts (mostly inherited from GNOME), but you can set it to open the main menu. Combined with the ability to immediately search by typing, this turns the main menu into an application launcher as well.

Juno doesn't make any sweeping changes to the basic look and feel that elementary OS has been working with for some time. It's made some refinements and given third-party developers some much-improved guidelines and a new color palette, but most of the work in Juno has come into the complement of tightly integrated applications that ship with elementary OS.

Unlike most GNOME-based distros, elementary OS does not ship with the usual slew of GNOME applications. Instead, you'll get elementary OS's own versions of the same. In this release that means Files, a terminal app, Photos, Noise (music player), Code (previously known as Scratch), and then a few outside apps like the Epiphany Web browser and the Geary mail client.

For the most part, elementary OS's homegrown apps are quite capable, though again, there's a notable lack of customization available. The Terminal app, for instance, offers three color schemes and not much else in way of preferences. It also, by default, uses ctrl-v for paste and ctrl-c for copy, which is annoying if you're used to ctrl-c killing a process. Since there's no preferences for Terminal, there's no way to fix this beyond installing a more powerful terminal like rxvt-unicode.


Page 2

The Terminal app showing memory use with nothing open (596MB).
Enlarge / The Terminal app showing memory use with nothing open (596MB).

elementary OS has often been seen as a good option for new users (which is to say, an option for users not entirely comfortable with Linux). I'd say this it true to a point, but elementary OS has appeal beyond that, or at least it would like to. Juno has seen a lot of work geared toward developers, especially the changes to AppCenter.  These tweaks make it easier than ever for developers to get paid for their work, but it's also an upgrade in terms of the tools available for developers. As mentioned above there are quite a few new toolkits under the hood, but there's also completely revamped code editor known, appropriately enough, as Code.

Code is quite nice, reminiscent of GNOME's Gedit but without the abandonware feel. As with most of elementary OS, Code doesn't have a ton of customization options, but it does have the important ones—control over tab/space settings, code folding, automatic syntax highlighting, and a quick toggle comments feature. Unlike the Terminal, Code manages to allow for complexity through a plugin system that can add extra features. You can actually add a terminal to Code and run your tests without leaving your editor, and you can install a plugin to give you "Vim style" shortcuts (which is, well, not Vim, but does allow some Vim-like features).

The Code app in elementary OS.
Enlarge / The Code app in elementary OS.

Code is a very pretty editor—it has nice anti-aliased text and a lot of attention has been paid to the visual details—but if you're coming from an IDE like Eclipse or powerful text editors Vim or Emacs, to be frank, Code isn't going to cut it. It may be that the gray is showing in my beard here, but I feel like the effort put into Code might have been better spent elsewhere given that IDEs and text editors seem like a problem that's already been solved several hundred times.

The other homegrown elementary OS apps take a similar approach, reinventing the wheel a little. For the most part, the results are always very nice and fit well with the rest of elementary OS. For instance, Files is a good, if simple, file manager. And that simplicity is by design. As Blaede puts it in the release notes, elementary OS encourages "a workflow where users access content from the related apps instead of worrying about the intricacies of moving files around their device's storage." Files even has one feature I wish more file managers offered: a column view.

The Code app in elementary OS
Enlarge / The Code app in elementary OS

The Photos and Noise apps are photo and music managers respectively. Photos is very close to GNOME's Photos app, allowing for basic organization and editing of photos (including RAW files). Noise integrates well with system, allowing you to control your music from the menu bar. The default Web browser is Epiphany, which, like many default web browsers, is best used to download and install a real Web browser (just kidding... in elementary OS you should use AppCenter to install a real Web browser).

One thing you won't find in elementary OS is an office suite. LibreOffice and more lightweight alternatives like Abiword and Gnumeric are all available via the AppCenter, but they are not part of the initial installation.

The default software suite for elementary OS does a good job of balancing simplicity and ease-of-use against powerful features. It only falls down in two places really: Code, while nice, probably isn't going to cut it for most programmers, and Epiphany is pretty simplistic if you're used to Firefox or Chrome.

One of the more interesting and innovative new features in this release is a picture-in-picture video feature that allows you to watch a video while doing something else.

The easiest way to use picture-in-picture is to hit the keyboard shortcut super-F, which will change your cursor into a crosshairs. Just drag the cursor over the video to clip it, and elementary OS will pull the portion of the page out and display it in its own window. The only catch is that for Web video at least, you'll need to leave the browser window open (I just sent it to another desktop). It's a pretty cool feature, but unfortunately I found it a little buggy. During testing, playback stopped twice for no apparent reason, and resizing the window sometimes caused the "clipped" video window to disappear entirely.

The new picture-in-picture in elementary OS. When it works, it's awesome.
Enlarge / The new picture-in-picture in elementary OS. When it works, it's awesome.

The AppCenter

Still, the biggest news in elementary OS Juno is the new and improved AppCenter, which offers some improvements to AppCenter's pay-what-you-want model. For users, the biggest improvement is likely the option to try an app before you buy.

The AppCenter in elementary OS.
Enlarge / The AppCenter in elementary OS.

Previously you could, as you would now, put in $0 to download an app for free. Now, however, you'll be prompted to pay for that app after you've tried it, not with some nagging reminder, but with a lack of updates. If you opt not to pay for a paid app, you won't get automatic updates. The exception is security updates, which will be automatically applied regardless of whether you paid or not. As Foré said in an announcement earlier this year, "We will never withhold security updates based on payment status."

That means you can continue to get updates for paid apps for free, you just have to re-download each one individually. It is, as Foré puts it, "a convenience tax." If you pay, you get the convenience of automatic updates; if you don't pay, you don't.

Paying for an app in the elementary OS AppCenter.
Enlarge / Paying for an app in the elementary OS AppCenter.

This will, no doubt, rub some people the wrong way. Elementary OS is in uncharted waters here and is trying to build a sustainable development model in a world where most things are free. That's no easy task and there will inevitably be some pushback. It also may not work. So far, developing for elementary OS is not exactly lucrative. The project released some numbers earlier this year, reporting that it had processed $1,700 worth of payments from about 750 charges. That puts the average price of an app at $2.26. Divide that among the paid apps in the app center, and unfortunately it becomes rather obvious that not only is building apps for elementary OS not going to pay the bills, it's probably not even going to buy you coffee.

Will the new model change that? It certainly makes it easier to pay for an app after you've been using it for a while, something that was impossible before. There's also a new button to send money to a developer any time you like, just look up the app in the AppCenter and scroll to the bottom and you'll find a button to send money.

Conclusion

elementary OS has a reputation of being a good distro for Linux newcomers. Juno adds to that legacy, and it's one of the easiest ways I know of to dip a toe in the Linux waters without needing to learn a whole new way of working. It's especially familiar for macOS users which makes it a good choice to install on your Apple hardware (elementary OS ships with most of the drivers you'll need for Apple hardware, making it easy to install). The exception would be that shiny new the Apple hardware with the T2 chip which (as of November 2018) currently blocks Linux bootloaders.

What about for developers though? Clearly with the improvements to Code, elementary OS is aiming to provide a usable desktop that's also a good platform for development. I suspect most developers will probably want more familiar tools, but elementary OS does make a good development platform.

One thing elementary OS does well that so many desktops these days refuse to do is get out of the way. The month I spent using Juno was not spectacularly different for me than using my usual i3, or LXQT on my wife's machine. Like the simpler, lightweight i3 and LXQT, elementary OS does a good job of giving you the tools you need, but also, and often more importantly, it gets out of the way and lets you focus on what you need to get done.