UX first impressions

Welcome screen

This is the first screen you see. Like that there is a proper Dock. Like the wallpaper. Don’t like the baby blue color. The radius of the Dock is way, way too large. Destroys the first impression.

The cosmic installer window barely fits on a 1366x768 screen. Wonder what happens on 800x600.

Dark mode by default, shudder

First thing I will change is disable the dark mode. We are not in the early 80s anymore. WYSIWYG gave us black type on white backgrounds.

At least it is simple enough to switch to Light Mode, which should be the default.

Proper typeface, yay!

I like that unlike many Linux distributions, #Cosmic uses a proper typeface throughout the system (Fira), designed by Erik Spiekermann et al.

Fix for the ridiculous radii

With “Slightly round” the radii look correct. It definitely should be the default. Looks way more polished like this.

Performance?

It has been claimed that thanks to its exclusive use of Wayland, Cosmic would be “snappy”. However, Cosmic doesn’t feel very responsive on my lowly Acer TravelMate B117-M. For comparison, XFCE on Xorg definitely feels way snappier on the same hardware. In addition to that, there is a lack of immediate feedback: For example, when you launch an application via the Dock there is no visual feedback until the launched application is fully loaded and shows its first window.

Proper menus, good!

I like that there are proper menus (not just those dreaded hamburger icons) in Cosmic. And most (though not all) windows have icons to minimize and maximize.

Buttons in dialog boxes, light and shadows

Good use of colors in dialog boxes. Buttons mostly positioned in sensible places. But that “Cancel” needs to be a button, not just a clickable word.

Keyboard settings do not get applied to Live system

The keyboard setting I made as part of the Welcome dialog doesn’t seem to have affected the keyboard setting of the running Live system. Why is the user even asked if the choice is then discarded when you choose to run Live mode?

File manager does not have a spatial mode (yet?)

It would be nice if icons could be freely positioned at arbitrary coordinate locations in Cosmic (think spatial file manager).

Strange window close controls

I like how Cosmic shows the git commit in the About screen, but why “Close >” instead of the usual close button provided by window decorations? Consistency rules. (And it needs to be “x”, not “>” anyway.)

Wasteful use of screen real estate

The application launcher screen takes up way too much space. Especially when there is not much in it.

Desktop metaphor 101

The Trash is not a “folder”. And if something is empty, there is no need to put an icon in there. Just show an empty window. In fact, icons in file managers represent objects. But if there is no object, then showing a folder icon there nonetheless is outright misleading!

Minor UX hiccups

The navigation bar feels misplaced on the right-hand side of the window. It should span the entire width of the window, directly under the menu bar. In other words, it should also be over the sidebar.

Search box could be even better

When you press the Meta (a.k.a. “Windows”) key, a nifty search box comes up at the top of the screen. It would be neat if you could search for commands from the menu of the frontmost application there, too. Would be a true productivity booster!

Dock

It’s great to see a proper Dock right out of the box, without having to press any keys or install any plugins (that tend to break all the time) first. Yay for giving us a proper dock as the default.

The third button from the left in the Dock (looking like a mosaic) in Cosmic seems to do the exact same thing as clicking on “Applications” in the global menu bar. It can be removed.

Menus

Oopsie Cosmic!

This is not how menus are supposed to work. They need to extend in length further than the window if needed. Conceptually, opened drop-down menus are not part of but float above the window. They should not adhere to the size of the window, but of the screen.

On/off controls

“Checked” icons would be so much better than these weird controls in Cosmic. With these, I never know whether something is off or on. Please give us proper checkboxes (and in menus, proper “checked” icons).

Especially if you are already using them in some other menus. Just use them consistently…

How to minimize windows?

Also, there is no obvious way to minimize windows via the Dock, effectively not giving me ANY way to minimize Firefox in Cosmic.

It seems to be totally random. Where is the minimize button here?

Apparently this is what you get when you allow client-side decorations. No consistency.

Cosmic should enforce server-side decorations on all windows, so that we would at least have the same set of buttons on all windows. How do you minimize the Fonts window?

Workspaces

Is there a way to get rid of the “Workspaces” menu entry in the upper-left corner of the Cosmic screen? I never use this feature.

Tiled windows

Trying “Tiled” for a second. Ah, I guess this is how Windows 1.0 must have felt before it was allowed to have overlapping windows! I prefer “Floating” (a.k.a. overlapping) windows a lot, be it in Cosmic or elsewhere.

Summary

With that, I’ll end my “first impressions”.

There is a lot to like here:

No Gnome. That’s already a big improvement.

Design better than Gnome. But still some Gnome-isms, like date and time at the center of the screen. That space could be so much better used by a gloabal menu bar for “File, Edit,…”. Like it used to be since the early 1980s.

A Dock right out of the box, not relying on fragile extensions.

Proper typeface by default.

Proper window decorations, at least on some windows.

And then, some missing “desktop-y” features such as persisting window locations, sizes, and icon positions. Maybe a “spatial mode” will come later?

And some features I personally won’t use: Workspaces and tiled, a.k.a. non-overlapping windows.

Going forward, I hope the developers will orient their design even less around Gnome and more around the successful desktop metaphors that were developed in the 1980s. Especially I hope the developers will have a deep look at the Macintosh human interface guidelines: | Guide books | ACM Digital Library and adopt the “feel” of a true desktop system. Using Haiku for a while would also definitely not hurt, to see how a truly “desktop-y” system works (especially under the hood) and feels.

I think that Cosmic is important. If executed properly, it can finally give us a proper desktop for Linux again, after all that mobile-UX that made Gnome after version 2 un-desktop-y and, in my opinion, unusable.

The Simplicity of Early Graphical Desktop Computers

In the early days of personal computing, launching applications was simple. Operating systems on the Apple Lisa and the classic Macintosh allowed users to double-click application icons directly in the file manager. This method was intuitive and required no additional steps — users could see all available applications in one place and launch them with a simple click. This directness fostered a sense of control and familiarity, making it easy for users to find and run the software they needed.

Direct Manipulation

“Direct Manipulation” in computing, pioneered by Ben Shneiderman, refers to a user interface design paradigm that allows users to interact with digital objects in a way that resembles physical manipulation. This approach emphasizes intuitive interaction, where users can directly manipulate graphical representations of objects on the screen.

Direct Manipulation engages users and makes them feel in control of their environment. Being able to click on an application and drag it around on the desktop (or to another disk, or to the Trash) is more efficient than using a package manager application, and is, well, satisfying.

Spatial Orientation

Spatial file managers, like the Spatial Finder described by John Siracusa, offer a “natural” approach to navigating the file system by emulating physical spaces in the digital realm. Unlike navigational file managers that use a single window to represent multiple directories, spatial file managers open a new window for each folder, maintaining the size, position, and view settings for each window and for each object in it. This creates a strong sense of location and orientation, making it easier for users to remember where files are and how to get to them. By preserving the state of each window and its contents, spatial file managers provide a consistent and intuitive experience that closely mimics handling physical files and folders, enhancing user control and reducing cognitive load.

Unfortunately, there is not one single spatial file manager for Windows or Linux that is in widespread use, and the modern Finder on the Mac comes configured in a way that makes it act more like a browser than a spatial file manager by default. File managers on Linux are worst; they don’t even show the application icon on application binaries, unlike Windows or Classic Mac OS. They don’t persist window locations nor the position of the icons inside windows. As a result, working with the filesystem becomes monotonous, unnatural, and cumbersome quickly.

The Rise of Complexity through Layers of Abstraction

With the introduction of taskbars, start menus, and launchers, for example in Microsoft Windows, the user experience took a turn for the worse. These features offered some organization but introduced layers of abstraction that complicated the user experience. Modern operating systems, particularly various Linux desktop environments based on XDG Specifications, have taken this trend to an absurd level. Dedicated application launchers, such as the “Activities Overview” in GNOME, provide a centralized location for accessing applications, but at what cost? Users don’t know where applications live, where they are coming from, or how to copy them to a backup medium.

Mobile Devices

The rise of mobile devices has revolutionized the way we interact with technology, but it has also led to a significant departure from traditional computing paradigms. Mobile operating systems, such as Android and iOS, handle file systems in a way that abstracts away the file system hierarchy, making it difficult for users to directly manipulate files and folders. This lack of Direct Manipulation has significant implications for user control, transparency, and overall productivity. Users may not know where their files are being saved or how they are organized, leading to confusion and disorganization.

This shift has especially impacted younger users, particularly those who have grown on smartphones rather than desktop computers. Increasingly, the concept of navigating the filesystem is utterly foreign to such users. They are accustomed to app grids and touch interfaces where applications are abstracted away from the underlying file structure, keeping them uninformed and disengaged from their devices. The simplicity of launching applications by double-clicking an icon has been replaced by a paradigm that obscures where applications reside and how they function.

Mobile operating systems often make offline use harder than necessary due to their lack of Direct Manipulation, as users are not always aware of where their files and applications are stored and how to access them without an internet connection. How do you keep multiple versions of the same application in parallel? How do you back up applications for eternity? Heck, how do you even quit an application completely?

Loss of Flexibility in Modern Application Management

The “modern” approach to application management has led to a loss of flexibility. In the past, it was simple to have multiple versions of the same application and run them from different filesystem locations. Users could experiment, test, and switch between different versions of software without the constraints imposed by installation processes. Now, the “modern” paradigm requires everything to be “installed,” which is inflexible and stifling. Users are forced into predefined directories, losing the freedom to organize their software in a way that makes sense to them. And many users have grown entirely dependent on centralistic app stores, managed by big tech companies acting as gatekeepers to their devices.

Flatpak and OSTree: The Opposite of Direct Manipulation

The trend of abstraction and complexity in application launching has been further exacerbated by the rise of Flatpak, a package management system designed to centralize the deployment of applications across different Linux distributions. While Flatpak’s goals may be noble, its implementation has had a negative impact on user control and Direct Manipulation. It is not integrated into the file manager, but is essentially a package manager with a GUI application bolted on top of it.

One of the most egregious aspects of Flatpak is its use of OSTree, which creates a layer of abstraction between the user and the file system, making it difficult for users to understand and interact with the underlying system. OSTree’s complicated storage model, characterized by cryptic paths and a complex directory structure, makes Direct Manipulation in the file manager nearly impossible.

AppImage: One app = one file

Contrast this with AppImage (conceived by the author), a format for distributing applications on Linux (and on other operating systems that can run Linux applications, such as FreeBSD and Windows with WSL). Essentially a self-mounting disk image that runs the application contained in it, it is optimized for Direct Manipulation, allowing users to interact with applications in a straightforward and intuitive way. Unlike traditional installation methods that require complex package management systems, AppImages encapsulate all necessary resources an application needs within a single file. This means that users can download an AppImage, make it executable, and run it without navigating through intricate installation processes or dependency resolutions.

The self-contained nature of AppImage files facilitates easy Direct Manipulation; users can move, copy, or delete these files just like any other file on their system. This flexibility allows for quick testing of different application versions or configurations without the risk of affecting the underlying system or other installed software.

Outlook

It is time to rethink the modern approach to application management and demand desktop environments that prioritize Direct Manipulation. The way we get and launch applications has taken a wrong turn and removed control from the user. While app stores and launchers may offer some superficial convenience, they come at the cost of lessened user empowerment and reduced direct access. We need systems that allow users to interact with their applications and files in a straightforward, intuitive manner. This is a call to learn from the past and incorporate its simplicity and flexibility into modern design.

With projects like helloSystem (and its helloDesktop desktop environment), AppImage for Linux, and experiments like the conceptual file manager tentatively called “Spatial” shown above, I am trying to preserve the best concepts from early graphical desktop computing to today’s personal computers.

References

Shneiderman, B. 1983. Direct Manipulation: A Step Beyond Programming Languages. Computer 16 (8), pp. 57–69.

First impressions count, something many vividly remember from the KDE 4 days. How is the K Desktop Environment performing out of the box this time?

A bit about my background: Been using Macs, Windows, Linux, BSD, and KDE during various periods of time, most of the time concurrently. Passionate in all things user interface design, my gold standard against which I measure desktop user interfaces are the Apple Human Interface Guidelines (HIG) from the 1990s , which I still consider unmatched by any other desktop operating system (some details below). I wish every desktop user interface designer would use System 7 for a month.

Reality is that probably most Linux power users don’t live in a Linux world 100% of the time, at least when they also work in a (large) company, have family and friends, etc. For this reason, I think we should think desktop environments in a “cross platform” way for users. So that users who are constantly moving back and forth between Windows, the Mac, and Linux don’t have to constantly apply different mental concepts. For example if all other systems use double-click, then double-click it is.

From the outside

Saw that a new “KDE” version is out. Yes, I know — KDE is actually the name of the community, not the product. But everyone I know calls KDE, well, KDE. Speaking of the community, my impression is that it is a very friendly and welcoming community in which user voices are actually heard, even if they are different from the opinions of the core developers. I find this a very welcome change from some other open source desktop projects. Point in case: Double-click is the default again, just like users (myself included) want. When they say “KDE is not a big company; it’s an international volunteer community, and its software is made by people like you donating their time and passion” that’s not just empty marketing speak. It really shows, and it does make a difference!

Live ISO

Immediately headed over to https://neon.kde.org/download. I really like that they provide an official Live ISO with a reference distribution that contains the KDE software in exactly the way the KDE team wants it to be delivered. This way, I can be sure to see the original configuration as intended by the designers and developers.

Why the ISO doesn’t have the name “6” in it puzzles me, though. I keep lots and lots of Live ISOs over the time, how am I supposed to know a few years down the road that neon-user-20240229–0716.iso is the one with “KDE 6.0"?

Size

KDE neon User Edition comes in at 2.7 GB. I still fondly remember the times when Kubuntu fit on a 800 MB CD-ROM. Since then, size has more than tripled — why? It may be feature creep and the sheer size of KDE, it might be a large dependency trees, or a bloated base operating system. Most likely, a combination of all three. This is not a KDE specific issue, though. All Ubuntu flavors were shipping on CD-ROM once. I think that was a good forcing mechanism for developers to think harder about what is actually needed, and how to do it efficiently.

First boot experience

You can’t replicate first impressions, they say. For me, the total end user experience is what counts. That’s why I like to write down my first impressions whenever I switch something on for the first time. So here we go with “KDE 6” a.k.a. neon-user-20240229–0716.iso.

Plasma

Maybe it’s just me, but every time I read “Plasma” I am reminded of the dreadful switch from the excellent KDE 3 to the strange KDE 4, where the desktop was replaced with strange desktop widgets called “Plasmoids”, the assumption was that users would be using projection tables rather than a screen and mouse, and would be interested in rotating everything in strange angles. No one I know is using their computer this way. From that time onward, I keep thinking “KDE would be really great without this Plasma thing”. Nowadays they are using “KDE Plasma” as the name fo the desktop environment as a whole, the thing most people used to call just “KDE”. Maybe “KDE Desktop Environment” would be the most fitting name. Oh well, the “DE” in “KDE” already stands for “Desktop Environment”.

Simple by default

The welcome center claims that “Plasma is designed to be simple and usable out of the box. Things are where you’d expect, and there is generally no need to configure anything before you can be comfortable and productive”. I applaud this philosophy very much! This is really welcome, especially when compared to other desktop environments that seem to take pride in putting things into unexpected places (e.g., hiding the Dock behind an icon, etc.).

However, the statement is pretty much true for switchers coming from Windows: Menus are inside windows (rather than at the top of the screen where switchers from the Mac would expect them), windows are closed with Alt-F4 (rather than with Command-W), you need to use the Ctrl key (rather than Command), the default button in windows is on the left hand side (rather on the right), to continue searching you have to press F5 (rather than Command-G), the buttons in the window title bar are on the right hand side (rather than on the left), and so on. So if you are coming from the Mac, then this doesn’t equal mean that “Things are where you’d expect”. It would be super awesome if the “Simple by Default” screen in Welcome Center would ask whether the user is coming from Windows or from the Mac, and configuring things in line with user expectations.

Welcome Center could ask whether the user is coming from Windows or the Mac, in order to make sure that “Things are where you’d expect”. I think this would be in line with the KDE philosophy and would increase usability for switchers a lot.

Powerful when needed

Welcome Center points to Vaults, where you can “store sensitive files securely”; Activities, to “separate work, school, or home tasks”, KDE Connect to “connect your phone and your computer”, KRunner to “search for anything”, and Get New Stuff to extend the system with add-ons.

I am one of those users who are typically impatient and don’t read introduction texts in assistants like the Welcome Center. We are missing out, as this one really contains some gems, like being able to launch KRunner by pressing Alt-Space. Sounds very cool! If it actually worked. Instead I get an error message. Oh well. (As a switcher coming from the Mac, I’d look for some kind of “magnifying glass” icon in the menu bar to find this kind of feature.)

As part of the Welcome Center, various applications are showcased. The selection of example applications is a testament to the fact that the KDE community puts the user above politics: It showcases powerful, cross-platform, real-world applications, no matter where they are coming from or which toolkit they are written in. Contrast this with some other desktop environments which seem to pretend that every application should be written specifically for a certain desktop environment.

The Welcome Center asks users to share anonymous data to improve KDE software. They give reasons, show their privacy policy, and let users opt-into the data collection, describing exactly what is being shared. This is how you do it!

It’s improving

KDE developers are listening to their audience, and are willing to correct design decisions when they prove to be unpopular with users. This is a big factor why I think KDE is way ahead of some other desktop environments.

Finally, clicking on an item on the desktop or in the file manager selects the item, as on every other desktop operating system. This is a “proper desktop” and not a phone or tablet, after all, so great to see that finally we have double-click to open again, just like we expect from a desktop. Great!

Alt-Tab works as expected and the annoying Command-Tab (something about workspaces, a concept I never started to embrace) is gone by default (who wants it can get it back easily). Good!

Icons on the desktop work more in line with expectations than in the past. No more confusing plus and minus buttons on icons (I still haven’t figured out what these are for, on a mouse-operated system). Unfortunately, the file manager behaves inconsistently vs. the desktop. In the file manager, we still have those extraneous icons:

I can only suspect that this is a leftover from the time when you couldn’t select an icon by just clicking on it.

Cosmetic idiosyncrasies

In some areas KDE has been defaulting to strange defaults I find quite annoying but could be fixed very easily:

• Shape of the cursor. This shape just doesn’t look right. It looks like a christmas tree about to fall over, not like an arrow as it should. Compare it to the shape of cursor in virtually every other operating system.
• Jumping icon in the cursor when an application is launched. Personally I find this very annoying and distracting. The dock icon should be animated by default, not the cursor.
• Inconsistent, too large text in some places, e.g., the time in the dock should be the same size as the rest of the user interface, especially the same size as the date. Headlines in Kirigami (a KDE GUI framework on top of Qml) should not be larger than the rest of the user interface, and should especially not be larger than the text in the window title bar.

Some dialogs are unnecessary and too busy

When I insert a storage device, I’d expect its icon(s) to show up on the desktop. After all, this is how the desktop has been working since at least 1984. Instead, when I plug in a USB stick, KDE shows a “Disks & Devices” popup with no less than 11 clickable icons in it:

1. A “<” (back) icon
2. A “hamburger” icon (my least favorite of all icons because it feels like “random unsorted mess” is in there)
3. An arrow icon next to it (as if the hamburger icon alone wasn’t enough — but the two confusingly do the same thing)
4. A settings icon
5. A pin icon
6. A CD-ROM icon (for the Live ISO I am running) — I have not inserted that one right now
7. An Eject icon for the CD-ROM (I just attached a USB stick, why should I want to eject the CD-ROM now?)
8. An arrow icon with some random applications inside it
9. A USB stick icon for the USB stick that I just attached
10. A folder icon
11. Another arrow icon

Eleven icons. And an entirely unnecessary popup.

I point this out because this is actually a big thing. KDE feels unnecessarily overcomplicated in places. Its developers probably want to make things easy, but just adding more and more stuff actually achieves the opposite. “Simple by default, powerful when needed” — make the simple thing the default. Let power users change it if so desired.

It could just “do the right thing” and show the icon for the device on the desktop, like this:

No popups. One icon for each storage volume. On the desktop. Simple by default!

One application menu is enough

Note that as a switcher from the Mac, I have configured my desktop to show the global menu bar at the top of the screen. Why does the file manager have a “hamburger” icon which yet another menu then? And even worse, why does the “hamburger” menu have another (dotted) “hamburger” which seems to duplicate the exact same menu that we already have in the menu bar at the top of the screen?

It’s stuff like this that may seem like unimportant details, but actually determines how polished the product appears overall. Could be more simple by default.

Form over function?

In some areas, a lot of complexity has been introduced presumably to make things look “nice” (which of course is subjective), resulting in unnecessary amounts of code and visual inconsistency. Check the menu bar at the top of the screen, and the Dock at the bottom of the screen:

As soon as you maximize a window, things become normal again:

This is not only causing unnecessary code complexity (probably took the developers a lot of tie), but unfortunately also creates the perception of “wasted space” and visual inconsistency. Can we please have a consistent user experience where Menu bar and Dock are aligned with the edge of the screen all the way, where users expect them, all the time?

When showing just the desktop (without an application open other than the desktop itself), the global menu is empty. It should be populated with roughly the same menus as when a file manager window is open, since the desktop has the same functionality as the file manager but for ~/Desktop.

Key “desktop-y” features still missing

There are some aspects in which most open source desktop environments are still trailing beyond commercial desktops from the 80s. I’ve been wondering for a long time why this is. To me these omissions are really puzzling. These are not unimportant details in my opinion; having them would really make a big difference for open source desktops.

Some prominent examples:

• Persistent icon position in file manager windows: While Dolphin remembers window size, position, and most properties, it doesn’t let us freely position icons in the window, and persist their location (also between different machines). Some Mac users meticulously arrange icons in icon view in a way that makes sense (e.g., README file centered on top, application icon below it, everything else down below).
• Icons on binaries: Opening /usr/local/bin, all executables are missing their icons. On systems like Windows and Classic Mac (and on Haiku OS), icons are resources built into the application executables themselves (rather than separate files that must be moved around and associated with clumsy XDG .desktop files), and hence can always be shown in the file manager (instead of generic application icons).
• Custom icons on items in the file manager: A super simple way to paste custom icons into the file manager for documents and folders (without having to edit any text files).
• Support for application bundles: Application bundles (such as .app or .AppDir) are really useful, because they allow applications to be used just like documents, without the need to install them first. It would be nice if they were embraced more universally, e.g., in the Dolphin file manager.
• File creator codes: If I create one .txt file in VSCode and another one in Kate, chances are that I always want to open the one file in VSCode and the other one in Kate. On the classic Mac, the default is that the application that has created a file gets to open it when it is double-clicked. In KDE, whatever happens to be the default for a certain file type will be launched, no matter which application actually created any particular file. Worse, it seems not even possible to manually define which application is going to open a specific file (only all files of the same type, which doesn’t really cut it).

Open source desktops have largely ignored the need for features like these, making them (in my opinion) still not on par with what commercial systems already had 40 years ago.

How hard can it be?

Will the open source desktop ever catch up?

Configurability

A strong point of KDE is that you can configure almost everything to your liking. It can become a weak point if it gets overwhelming. There are some changes I always make immediately when launching KDE, and I wish could either be made the default or could at least be set in “I am a switcher from the Mac” mode.

• Right-click on the Start icon, Show Alternatives…, Application Menu. A big “thank you” to the KDE developers for providing a relatively easy way to get a global menu bar working at the top of the screen!
• Right-click on the desktop, Enter Edit Mode, Add Panel, Application Menu Bar.
• Right-click on the desktop, Icons, Align, Right.
• Right-click on the desktop, Icons, Arrange, Top to Bottom.
• Right-click on the desktop, Configure Desktop and Wallpaper…, Plain Color, some unobtrusive solid color like a muted blue. (What is important on a desktop are the icons of the items on the desktop, not the background picture.)
• Right-click on the global menu bar, Edit Mode, Add Spacer. Then move tray icons to right-hand side of the global menu bar.
• Start, Settings, System Settings. Unfortunately it does nothing at all, except show the ugly jumping icon cursor for a while. I would like to change: No icons in menus, no icons on buttons, default buttons blue and in the right-hand corner. Window close/minimize/maximize buttons at the left hand side of windows. Alt-W to close windows instead of Alt-F4 (and similar).

Under the hood

There are quite many changes under the hood of “KDE 6”,

Qt 6

Qt, the framework KDE software is built with, recently moved from Qt 5 to Qt 6. While this is a pain for all developers involved (and I hope that Qt won’t do major version jumps anymore anytime soon), it is only logical for KDE to eventually switch over to it. The timing seems right and Qt being Qt, I don’t expect mayor issues resulting from it, apart from the time it took the KDE developers to make it happen.

Wayland

This is the controversial one. Wayland is an incompatible alternative to the widely used X11 windowing system that we have been using since, well, basically forever. It breaks a lot of stuff by design, due to its nature of not being designed as an API compatible nor feature compatible drop-in replacement. Its developers are known for discussing even the most basic features (that have been working on X11, Windows, and the Mac forever) for an eternity (e.g., the ability for applications to set icons on windows, or the ability for applications to freely position their windows at pixel-precise locations on the screen — the list goes on and on).

Unfortunately, KDE is hopping into that bandwagon big time now, making Wayland the default. This means that a lot of existing software will be broken to various degrees. At least, users largely don’t notice major interruptions from the move to Wayland as long as they stay within the KDE ecosystem. Quite an achievement which must have cost KDE developers a lot of time and effort.

Does performance on Nvidia, screen sharing and screen capturing (with sound) work reliably though? Will have to test this on another day. In case it doesn’t, I’ll blame it on Wayland (the concept), not KDE (the software). After all, getting things to work at all under Wayland must have been a giant undertaking for the KDE project, just to get things (roughly) into a state no worse than before the switch. Imagine if all that developer time could have been spent on the missing "desktop-y" features...

Summary

Overall, I am optimistic about the future of KDE. The “dark times” of KDE 4 are really over, and some “controversial” decisions (like single-click to open) have been reversed. This shows that the project is driven by a community that actually cares about its users.

If I share some criticisms of “KDE 6”, it is not because I think that it is bad software. Quite to the contrary, it is in the hope that this kind of feedback is taken as constructive input by the developers, helping them to turn the K Desktop Environment into an even better place to be.

Pros

• Made by a welcoming and friendly volunteer community, not dominated by a big company
• Live ISO available for download from https://neon.kde.org/download
• KDE community listens to its users — double-click is the (sane) default again
• “Simple by default, powerful when needed” philosophy “designed to be simple and usable out of the box. Things are where you’d expect”
• Relatively easy to get a global menu bar working at the top of the screen
• Users largely don’t notice major interruptions from the move to Qt 6
• Users largely don’t notice major interruptions from the move to Wayland as long as they stay within the KDE ecosystem (even though Wayland breaks many things in incompatible ways) — with occasional exceptions (e.g., applications don’t show proper icons on all windows)

Cons

• KDE neon size: 2.7 GB for the (compressed!) neon-user-20240229–0716.iso Live ISO
• No 64-bit ARM version of the Live ISO yet
• Made the immature Wayland the default rather than the proven X11, causing breakage in existing software
• “Things are where you’d expect” not entirely true for Mac users
• Some dialogs are unnecessary and too busy (e.g., what happens when you attach a USB stick)
• Sometimes seems to put “form over function” (e.g., Menu bar and Dock not always aligned at the edge of the screen), causing unnecessary code complexity and visual inconsistency“
• Fra still missing, e.g., persistent icon positions in window manager windows, icons embedded into binaries, custom icons in the file manager, application bundles, file creator codes, allowing to open certain files always with certain applications)

Ideas for (quick?) fixes

• Put “KDE 6.0” in the name of the ISO
• Welcome Center could ask whether the user is coming from Windows or the Mac, in order to make sure that “Things are where you’d expect”
• Fix Alt-Command to show KRunner on the Live ISO. t shows an error
• Fix System Settings on the Live ISO. It does not open
• Fix cosmetic idiosyncrasies that could easily be fixed (e.g., shape of the cursor, jumping icon next to the cursor when launching applications, inconsistent, too large text in some places)
• Remove “hamburger” menus from applications when global menu bar is present

probono is passionate about desktop usability (see his series on #LinuxUsability (part 1, part 2,part 3, part 4, part 5, part 6), has introduced the AppImage format for distributing portable applications on Linux, has started the helloSystem desktop operating system, and is a casual contributor to hundreds of open source projects.

In a world in which computing is increasingly omnipresent, we are running the risk of losing control and privacy. If we like to stay in control, we should resist using App Stores, always-on computers, Apple/Microsoft/Google/Facebook/whatever IDs, two-way authentication using phone numbers, digital signatures, entitlements, notarizations and all the other crap coming under the disguise of “security” today.

Looking back at the state of computing 25 years ago and comparing it to today, it is easy to see that not everything has improved.

Extrapolating from the past into the future it is not all that hard to see that things have the potential to go downhill rapidly, and that we have to do something against it.

25 years ago

You installed a piece of software like this:

• Turn on the computer
• The computer does not know who you are. There are no usernames nor accounts
• Insert floppy disk containing the application
• Copy from floppy to hard disk with drag-and-drop — easy! No personal data, no sign-ups, no cookies, no phone home, no spying
• What happens on your computer, stays on your computer
• Switch off at any time
• Secure by default (by not being connected to anything other than power)

You were in full control. Could install older versions of anything at your discretion.

Today

It looks more like this:

• Wake the computer from sleep
• It connects to the Internet before you are even seeing anything
• You give it your fingerprint to unlock
• It phones home to the operating system vendor
• Enter your Apple ID to access the App Store — or else you can’t even download iMovie (which came with every Mac)
• Purchase the application. It is automatically downloaded and installed, making sure the operating system vendor (and who knows who else) exactly knows who downloaded what to which machine
• The computer checks signatures, entitlements, notarizations, and other stuff you don’t understand to make sure that someone (not you) controls what does and doesn’t run on your machine
• Put the computer to sleep

You are no longer in full control. Operating systems and applications are digitally signed, and the signatures have expiry dates. You cannot downgrade at your discretion. Vendors force you on a never-ending upgrade rat race. Who guarantees that you will be able to install today’s software 10 years from now?

In 25 years?

Maybe it will look like this much more quickly, actually:

• The computer is always spying on everything you do
• You allowed the computer to spy on you 24/7 a long time ago, and to use everything collected against you
• You do not get to install an application, nor to decide which version to use
• You just do stuff, and the computer is watching you do it
• You will be billed for the usage the computer has seen
• You own nothing
• Everything can be taken away from you at someone else’s discretion at any time for whatever reason
• The computer knows everything about you because it watches you 24/7
• And shares information about you with whatever entities it deems appropriate
• Everything you do is biometrically tied to you and saved redundantly on the Blockchain so that you cannot delete your traces or rewrite history, which are all more or less public (at least to tech companies, the NSA, and other advanced persistent threats and adversaries)
• Everything is encrypted and pseudo-“secured” by “Trusted Hardware” that you totally can’t understand because it is entirely proprietary and undocumented

You will not even remember how it felt to be in full control. You are at the mercy of “service providers” billing you for every move you do, and spying on every step you do.

Do we want such a future? No!

So resist using App Stores, always-on computers, Apple/Microsoft/Google/Facebook/whatever IDs, two-way authentication using phone numbers, digital signatures, entitlements, notarizations and all the other crap coming under the disguise of “security” today! These things can work against you. They can take away your freedoms and can make you the subject of surveillance.

What can we do?

• Use Open Source
• Build systems that do not require logins nor IDs
• Build systems that let you use a multitude of different, partly temporary pseudonyms
• Never use “supercookies” (such as mobile phone numbers — most people only have very few and don’t change them all too often)
• Do not restrict software by enforcing the use of digital signatures with built-in “time bombs” (=expiry dates)

More ideas?

Applications don’t always have to be something you download from some store somewhere, and that might happen to spy on you. Applications can also be delightful small programs you write yourself to do one job, and do it exactly how you like it to be done for you.

Let’s bring Home Automation on the desktop

Suppose you would like to be able to trigger different Home Automation scenes like “Reading”, “Work”, “Leisure”, “Bedtime”, etc. — right from your desktop. In your home automation setup you are using a MQTT broker running on a tiny embedded server, and several lights running the Tasmota firmware.

Create a minimal application

Now, you would like to have a super simple way to switch between the scenes.

Let’s create a helloSystem application that does just that with minimal fuzz. Thanks to the concept of Application Bundles this is not complicated:

1. Create an Applications folder inside the home folder
2. Create a folder named Scenes inside the Applications folder
3. Create a folder named Work.app inside the home folder
4. Create a file named Work inside the Work.app folder
5. Paste the program code from below (adjust to your own environment) — I am not going to explain the code in detail here but Tasmota MQTT users will instantly recognize it
6. Click on Work and press ⌘-I, then click “Make File executable”
7. Move Work.app into the Scenes folder created earlier. This will make it show up in the menu automatically

Program code:

#!/usr/bin/env python3

import os
import paho.mqtt.client as mqtt

client = mqtt.Client()
client.connect("mqtt.local") # Replace with address of your broker

# Set screen color temperature
os.system("redshift -P -O 5700")

# Set light bulb colors
client.publish("cmnd/tasmota_aaaaaa/Color",'030100FF00', retain=True) # large bulb
client.publish("cmnd/tasmota_bbbbbb/Color",'030100FF00', retain=True) # small bulb

There you have it. A fully functional helloSystem application that does one job, and does one job well.

Whenever you want to run the scene “Work”, you can now just select System -> home -> user -> Applications -> Scenes -> Work.

Or press ⌘-Spacebar, type “work”, and press Enter.

Adding some polish

Let’s make this application use a nice application icon. To do that, right-click on Work.app, select “Show Contents”, create a new folder called Resources and copy a 128x128 pixel png there with the name Work.png. Done!

Let’s also make this application accessible via a shortcut on the keyboard. For this, open System -> Applications -> Preferences -> Shortcut Keys and add a new shortcut. Choose a key combination (e.g., Meta-F3), click “Activated”, Click “Command” and enter launch Work.

Now, you can launch the “Work” scene by pressing the key combination.

Easy, huh?

Copy&Paste

Now, having just one scene is kinda boring, right? Copy and paste your application, rename it, and let it call a different scene. Let’s say “Bedtime”.

#!/usr/bin/env python3

import os
import paho.mqtt.client as mqtt

client = mqtt.Client()
client.connect("mqtt.local") # Replace with address of your broker

# Set screen color temperature
os.system("redshift -P -O 4000")

# Set light bulb colors
client.publish("cmnd/tasmota_aaaaaa/Color",'80621C004A', retain=True) # large bulb
client.publish("cmnd/tasmota_bbbbbb/Color",'80621C004A', retain=True) # small bulb

And once you are happy with everything, copy that Scenes folder to other machines on your network as well.

Simplicity that Empowers You

Now try this with another operating system.

Sure, you could probably use a proprietary system like Philips Hue along with proprietary apps that may or may not collect your personal data and get it to work sooner or later. But I challenge you to get to the same result as fast and efficiently.

Or you could go the Linux way and fiddle around with desktop files and whatnot. But again, I challenge you to get to the same result as fast and efficiently.

This is the kind of simplicity we are striving for. Not hiding away how things work, but making them as accessible and non-frightening as possible for slightly more advanced users.

You are in full control. Simple as that!

helloSystem is in pre-release status. Please see https://hellosystem.github.io/docs/developer/contributing for how to contribute.

Making technology “simple” is not about making “flat designs”. It is about making things “accessible”. For me, it pretty much involves making simple tasks simple. And most desktop environments are terribly bad at it, as I have pointed out in my six-part series about #LinuxUsability (part 1, part 2 , part 3, part 4, part 5, part 6).

Example: Formatting a disk

Here is a prime example: Formatting a disk.

Simple, eh? Most people (at least those used to Windows and the Mac) will take a dialog like this for granted:

Nothing fancy here, nothing special. That’s what I thought too, until I went about implementing it. Turns out that most open source desktop environments make this type of task way too complicated, because they are approaching the problem like an engineer rather than like a person who wants to “just format that disk”. Windows and the Mac do this much better!

Step 0: Think like a user, not like an engineer

Making things simple requires a developer to think like a user. And then work hard to make all the tech stuff happen.

Let’s look at that “Format Disk” example in detail.

Step 1: Put the verbs where the object is

It begins with the desktop, where disks (“volumes” to be precise) are shown to the user.

This is where a user naturally goes to access disks, it is where disks “are” for a user. So naturally this is where a user would go to format a disk. Windows users can right-click a disk and select “Format…”. Yet in most open source desktop environments you can’t do that. You need to open another application with a cryptic name like “GParted”. Scary stuff!

Disks are objects. They should have a place in the user interface. Ideally one place (in helloSystem, that place is on the desktop). Not multiple places (e.g., on the desktop and in GParted). You should be able to manipulate the objects by clicking on them and by selecting a verb (usually by selecting something from the menu).

Step 2: Ask the user only relevant questions

In the “Format Disk” dialog, the questions that are relevant for the user are asked: Name, format, and partitioning scheme.

And we are referring to things in terms users can relate to. A user might know that a disk is for “Linux”, but not necessarily know what “ext2” is.

We are only asking the user for a partitioning scheme the whole disk to be formatted, rather than an individual partition. Many users will never even have to know the difference, we are just doing the right thing.

All questions can be answered in one step. Try doing the same in GParted and count the number of steps needed! This dialog contains all mere mortals will need in >95% of cases. For the remaining cases, there are still command line tools and more specialized utilities.

Step 3: Do the legwork

“Formatting the disk” can mean different things in different situations. Most “mere mortals” can’t remember to do those things in the correct sequence manually, and even if they can, they will find it cumbersome.

In this example, the user wants to format /media/AIRYX, which happens to be on /dev/da0 (no partition!) while /media/bootdisk is on /dev/da0p1. So we do:

umount /media/AIRYX # (1)
umount /media/bootdisk # (2)
dd if=/dev/zero of=/dev/da0 bs=1M count=1 # (3)
/sbin/gpart create -s MBR da0 # (4)
/sbin/gpart add -t fat32 da0 # (5)
newfs_msdos -F 32 -L Untitled /dev/da0 # (6)
/usr/local/sbin/automount da0 attach # (7)

1. Unmount the disk the user requested to format
2. Unmount all partitions that are on the same disk
3. Blank out the partition table — without this the next step would fail
4. Create a partition table using the selected partitioning scheme
5. Add a partition with a type that matches the selected filesystem
6. Format the partition with the selected filesystem (not sure this step is correct — would it need to be /dev/da0p0?)
7. Mount the newly formatted partition

What is essentially the “same” operation for the user — format a disk — can look very different technically in another case:

In the next example, the user wants to format a disk that was previously formatted in ExFAT. Shouldn’t make a big difference, should it? Well, it does, because ExFAT is mounted using FUSE (again something “mere mortals” will not need to know even exists):

umount /media/exfat # (1)
dd if=/dev/zero of=/dev/da0 bs=1M count=1 # (2)
/sbin/gpart create -s MBR da0 # (3)
/sbin/gpart add -t fat32 da0 # (4)
newfs_msdos -F 32 -L Untitled /dev/da0 # (5)
/usr/local/sbin/automount da0 attach # (6)

1. Unmount the disk the user requested to format (as above)
2. Blank out the partition table. For this we need to know the device node /dev/da0. Turns out that mount tells us: /dev/fuse on /media/exfat (fusefs). But umount /dev/fuse is not going to work. So we need to do a series of rather convoluted steps to find out the actual device that is mounted at /media/exfat. (I will spare you the details here but it is not straightforward.)

Rest of the steps as above.

By thinking about what users want to do rather than by thinking about what the computer needs we put “user first”. Sounds trivial, but it isn’t.

Here is another example.

Renaming a disk

Renaming a disk. Simple enough, right? Just click on the disk icon on the desktop and rename it — just like you would rename any file or folder. Piece of cake. Right?

No. To my knowledge, none of the existing open source desktop environments can do this! Go try it out for yourself. You will be surprised.

Making it work isn’t trivial either. Turns out that depending on which file system is used on the disk, a different command line tool (with different syntax) is needed to do the job.

Tasks like this should be simple. They are way too complicated!

Let’s make simple tasks simple

Grown out of my frustration with #LinuxUsability (part 1, part 2 , part 3, part 4, part 5, part 6) and with the ongoing crippling of the desktop metaphor, I set out to build a desktop system for “mere mortals” that is simple yet powerful.

So the examples above are set to be solved in the upcoming pre-release of helloSystem, 0.7.0, expected to arrive later this year.

helloSystem is in pre-release status. Please see https://hellosystem.github.io/docs/developer/contributing for how to contribute.

Recently there was a challenge on Twitter to “Describe FreeBSD in three words only”. An operating system. Right? Berkeley Software Distribution, literally. Dating back to early UNIX, and powers macOS and the iPhone, that’s what I always mentally filed FreeBSD under. But also as something that still requires you to use a cryptic command line and to configure stuff — like if the graphical desktop, Plug&Play, and Live ISOs that “just work” never had happened. Maybe I was wrong all along.

When I think of an “operating system”, I think of Windows, macOS, or Ubuntu-style “Linux”. And naturally, that was the standard I kept measuring FreeBSD against. In comparison, FreeBSD felt so much more cryptic and complicated. I always wondered why that was.

So “Community nongraphical UNIX” is what I wrote.

When I read through the answers to the “FreeBSD in three words” question it finally dawned upon me:

Patrick M. Hausen on Twitter: "Infrastructure, not product. / Twitter"

Infrastructure, not product.

Infrastructure, not product. Interesting way to look at it. In the Linux world, many distributions are based on Debian, including the arguably most popular one on the desktop, Ubuntu. So in a way, FreeBSD is like Debian if it was simply a building kit for other distributions. It is not the Ubuntu Desktop Live ISO that made Ubuntu so popular and the experience I am after — pop it into a computer and be able to use it as a desktop machine.

Infrastructure, not product. Is that a good thing? My initial reaction would be “no”. For many years I looked at FreeBSD and always decided to test it “once they have a Desktop Live ISO like Ubuntu I will try it out”. Which never happened.

Yes, variants of it like TrueOS, DesktopBSD, FuryBSD came and went and some are still around like GhostBSD and NomadBSD, and new ones like my own helloSystem are coming up , but are they really FreeBSD? Places like https://forums.freebsd.org/ say no, and don’t want to support them.

Infrastructure, not product. Is that really a bad thing? After all, wouldn’t it be a good thing to have an official FreeBSD Desktop Live ISO?

Turns out the issue goes deeper than that. Unlike Linux distributions, FreeBSD draws a strict line between the core operating system (base.txz) and what is thought of as “packaged third-party software” (Ports and Packages that live in /usr/local). The the core operating system is BSD licensed and developed as a fully integrated operating system by the FreeBSD team, whereas the rest happens to run on FreeBSD but is essentially mostly third-party software which may or may not agree with the FreeBSD objectives.

So, wouldn’t it be nice to have at least a very spartan, minimal graphical environment as part of the FreeBSD core operating system ? Operating systems like Haiku and SerenityOS see graphics as an integral part of the core operating system. FreeBSD doesn’t.

And then it dawned upon me again:

Michael Dexter on Twitter: "Own the stack / Twitter"

Own the stack

Own the stack. That is certainly a good thing and an aspect I really like. No one is following some hidden agenda to force certain stack elements (“unwelcome technology”) upon users, such as SELinux, systemd, Gtk, Gnome, Wayland, Pipewire, Flatpak and so on. And I like FreeBSD for that. So, maybe we should really come to embrace that FreeBSD wants to be more like a toolkit that enables third parties (you and me!) to build the end-user experiences we like rather than a readimade operating system like Windows, macOS, or Ubuntu-style “Linux”.

And in fact, it is very good at that. It allows us to build a helloSystem user experience exactly to our liking.

Maybe FreeBSD should position itself as a “toolkit for building operating systems” rather than an “operating system”. I think it would have helped me understand it better.

But… somehow I think it is still sad that graphics is completely absent from the FreeBSD core operating system. At least the window server and graphics drivers….

What do you think?

Imagine you want to set the keyboard language to German. Does it really need to be any more complicated than that?

How hard can it be? I think it should be only one click in a preferences application. Yet most existing open source desktops (developed by geeks for geeks) screw this up so badly that it can actually make me angry.

Can we do better than that? Sure we can.

Here is what I call the “three-layer design philosophy”:

• For mere mortals, remove everything that is confusing
• For advanced users, give raw access to the underlying components
• For developers, show’em the code

Layer 1: Remove everything that is confusing

This layer is for “mere mortals”. It is what grandma sees when she is using the computer. In this layer, expose only what is needed to get 80% of the users to get their job done 80% of the time. Remove everything that is not essential or requires much explanation. In most cases, Layer 1 will be a graphical application (with an uppercase name, such as “Keyboard”).

Compare the left-hand side dialog (from KDE) with the right-hand side dialog (from helloSystem). Which one would you want to use if all you wanted to do was switch the keyboard language?

Layer 2: Give raw access to the underlying components

This layer is for advanced users. Mac OS X used to be great at this, but with Apple’s continued focus on iOS, Memoji and watchfaces, and with locking down everything, their current systems increasingly fall flat in this aspect. This layer is all about explaining advanced users how things work under the hood, and give them raw access to tweak things. In most cases, Layer 2 will be a command line tool (with a lowercase and often cryptic name for historic reasons, such as setxkbmap).

In helloSystem, we give access to the raw power of the underlying core operating system, FreeBSD.

Can we go even further with this concept?

For users who want to tweak settings more than what the GUI offers at first sight, we make it as easy as possible to access the right information. In this example, by linking the man page for the setxkbmap command line tool which is being used by the GUI under the hood. Arguably, using that command line tool will be more satisfying for advanced users than trying to figure out from the convoluted KDE user interfaces what things could possibly mean.

Layer 3: Show’em the code

This layer is for developers, including first-time developers. Here the beauty of an open source operating system such as helloSystem can really shine.

From my own experience, it is good to know that the source code for the applications one is using is available somewhere, in case one would ever need it.

But then, wouldn’t it be much cooler if the source code was always right there, available at your fingertips all the time?

In helloSystem, many applications can be right-clicked to reveal their source code. This is because they are written in Python, an interpreted language that effectively results in the source code to be always present.

We could extend this concept by providing a “Show Source Code” menu entry that would open a web browser pointing to the GitHub repository of compiled applications, so that, just like in the Python example, you could have a glance at the code very quickly.

Can we embrace the open source nature of helloSystem even more?

Consider this:

Would you be more likely to peek into the source code if it was presented to you in this simple way?

So here you have it. My “three-layer design philosophy”:

• For mere mortals, remove everything that is confusing
• For advanced users, give raw access to the underlying components
• For developers, show’em the code

But wait. There is one more thing.

Layer 0: Zero configuration

Now that we have looked at three layers of user interface to set the keyboard language, wouldn’t it even be much, much cooler if the user wouldn’t have to set the keyboard language at all, because when you attach a German keyboard the system just knows that it is a German keyboard and configures the system accordingly, at least for the vast majority of users? At least 80% of people with a German keyboard will want the keyboard layout to be German. So why not just do it? Using English is wrong for at least 80% of people with a German keyboard. Using German will be right for at least 80% of people. Yet most operating systems just default the keyboard language to English all the time.

Turns out that even in the days of USB, most keyboard manufacturers decided to save 2 cents in production by not having the firmware communicate the keyboard language to the system. What a pity! Luckily, some genius at the Raspberry Pi foundation finally produced a keyboard that can do the job — with the result that I have equipped all my computers with their keyboards. (Unfortunately that genius did not make any attempt to get any of this standardized, what a shame.)

helloSystem will detect the keyboard language and make intelligent guesses regarding not only the keyboard layout, but also the system language, and timezone based on this information. helloSystem will also read language information from NVRAM (also known as “Parameter RAM” or PRAM) on Apple devices, and use that information. Possibly we can also find other sources of information to make even more intelligent guesses.

The point: Zero configuration is what gives the user those pleasant “it just works” experiences without having to fiddle around.

A true master in this area is Stuart Cheshire, the mastermind behind Zeroconf networking (also known as Bonjour). Apple was kind enough to not only introduce this technology, but to also make the specifications and even code publicly available. Yet it surprises me all the time how neglected this building block for “it just works” is by many open source systems. But that will be the topic for another day.

So here we go:

• Level 0: Out of the box, make it just work without fiddling around. For example, pre-select the correct keyboard language based on hints the hardware may be giving
• Level 1: For mere mortals, remove everything that is confusing. For example, just show the most common keyboard languages in their own language and make them selectable by just one click
• Level 2: For advanced users, give raw access to the underlying components. For example, actively point power users toward the underlying command line tool and its documentation
• Level 3: For developers, show’em the code. For example, have a “Show Source Code” menu item in the Help menu.

By combining the simplicity of the original Macintosh with the power of UNIX, the original designers of Mac OS X did a great job in making something that was both easy to use for “mere mortals” yet powerful under the hood.

Can we take this design objective to new heights in helloSystem? Please leave your comments.

helloSystem is in pre-release status. Please see https://hellosystem.github.io/docs/developer/contributing for how to contribute.

Why I set out to build a desktop system operating system true to the desktop metaphor’s roots. One that removes the distractions, clutter, complexities, privacy issues, and encumbrances that have kept piling up.

Desktop user experience needs to be restored because it has been crippled over the years.

We risk forgetting the power of the Desktop

They build user interfaces for touch. They bring in user experience elements made to be used with the finger on tiny mobile devices, no matter that we have a precise mouse pointer and 27" screens.

Already three years ago when I wrote my series on #LinuxUsability (part 1, part 2, part 3, part 4, part 5, part 6) I had the impression that there was some super secret, evil plan to kill the desktop as we know it. A general-purpose computing productivity powerhouse. Replace it with inferior user experiences that make our lives harder.

Today I stumbled across this article:

The desktop metaphor must die

It proves my worst fears.

Sometimes it seems that even desktop operating systems these days are made by people who don’t get, or worse, hate the desktop.

The desktop metaphor is still unmatched when it comes to productivity

When I observe people in a company, I can immediately tell those who actually do the work from those who just glance over other people’s work. The former have real desktop computers or powerful notebooks, usually plugged into power and a wired network. The latter have tablet-wannabe-computer “convertibles” with cardboard keyboards held together by magnets, and their battery is always empty.

No TV studio will cut a feature-length movie on those mobile toys.

The mouse is your friend

It allows for pixel-perfect navigation and object manipulation. It allows you to select even parts of a word on the first try. It makes it easy to do drag-and-drop.

Touch is an inferior substitute, as far as productive work is concerned. No serious graphic designer will be happy with the precision of manipulating objects with the fingers on a slippery glass surface. Heck, even selecting text within a word is almost impossible on those mobile touch devices. And no, voice is not a good substitute at all. I don’t want to tell my computer how to draw a picture.

So let’s use a real mouse. Not those pesky touchscreens. Not those touchpads. A mouse with an optical sensor and buttons, you know.

Applications and documents are our friends

You could call them “verbs” and “objects”. Being able to exactly choose which version of which application to use to operate on which document is crucial.

Centering the workflow around lofty other ideas has been tried before, and went nowhere.

The file system is your friend

It allows you to understand where stuff goes. It gives you full power over where stuff goes. It allows you to access, move, copy, remove, backup, archive stuff. It puts you in control. By using “Save As…” and saving a file under a different name, you can make a new version. And so on.

On mobile devices, stuff goes “somewhere”, in places you don’t know. You never know what gets saved when and where. Maybe stuff goes somewhere on the local device, and worse, those days maybe it goes somewhere in the cloud. Anyone who as ever tried to get an MP3 file off an iPhone knows what I mean. You don’t even know where the files are stored, and you need complicated 3rd party software to actually access them. Complicated!

So let’s embrace the file system. Not a file system hidden away from view. And let’s work in the file manager. Let’s do everything by drag-and-drop in the file manager. Let’s do away with control panels, application installers, app stores, backup software, and the like. It can all be done with drag-and-drop in the file manager.

The global menu is your friend

It allows you to see all commands that are available to you quickly. Today, it even lets you search those commands.

So let’s use a real menu. Not those pesky hamburger or ribbon things that only make everything slow and inefficient.

Let’s get rid of the bloat, less is better!

There is just way too much stuff. And it’s all way too configurable. As a result, it’s a giant mess. Hence, let’s remove everything that had been bolted onto the desktop metaphor lately, and let’s go back to the basics.

Get rid of notifications

The computer is supposed to execute the instructions the user gives it, not the other way around. Notifications are a big distraction, most often designed for the computer to make the user do something. They are a never ending stream of unwanted interruptions, taking the focus away from your work. Your virus scanner wants to phone home. There is a new version of this and that. 7 new messages on Twitter. Please reboot. Activate your windows. Special promo offer ends today.

Get rid of notifications entirely! The original Mac did not need them, and nor do we today.

Get rid of ads

Some desktop operating systems look like an ad-financed newspaper.

Get rid of all ads entirely! Not just in the web browser. The original Mac did not need them, and nor do we today.

Get rid of app launchers

A Start menu with tiles? A Launchpad? Who needs those extra things to launch apps when we have the file system. I want to launch an app, I double-click it in the file system. Easy as that! As an added benefit, I can organize the apps in folders to my own liking, and can move, copy, delete, archive, backup them exactly like I want.

Get rid of tiles, launchpads, and other launchers. The original Mac did not need them, and nor do we today.

Get rid of app stores, DRM, signed everything

App stores require you to give their operators your personal information. They allow the app store operator to know which apps you have. They enforce “DRM” against you. They use signing to keep you from doing with your computer what you want.

Get rid of app stores. Drag-and-drop the apps into the file system at your own liking. Get rid of all the app store accounts and the phone home that comes with them. The original Mac did not need them, and nor do we today.

Get rid of everything that messes with your privacy

Once Apple positioned themselves as the savior that rescued mankind from an omnipresent Big Brother. Today they are phoning home which developers’ apps you use, and are making it hard to firewall internet traffic originating from the operating system. It’s outright evil.

Get rid of everything that messes with your privacy.

Get rid of everything that is “always on”

What if you don’t want an “always on” processor, let alone an “always online” one? Don’t use battery-operated devices.

Get something that has an off switch. Something that is really off when it is not in active use.

Get rid of everything you cannot understand

Good things can be understood. Not just how to operate them at their surface, but how they work.

Get rid of anything you cannot figure out how it works on the inside, if you like to.

I you are like me, you want to get tasks done with high efficiency, speed, and control. The desktop metaphor is ideal for this.

The mouse is your friend. The file system is your friend. The global menu is your friend. They can make your life easy! Don’t treat them as your enemies but embrace them. Let’s bring back the original simplicity of the desktop.

Un-bloat the desktop. Throw everything out that makes it cluttered, distractive, and encumbered. Notifications, ads, launchers, app stores, DRM , “always on” stuff — all that cruft that has no place on the desktop.

Less, but better!

Check out helloSystem. It is a desktop system for creators with focus on simplicity, elegance, and usability. Its design follows the “Less, but better” philosophy. It is intended as a system for “mere mortals”, welcoming to switchers from the Mac. FreeBSD is used as the core operating system.

Right now, it is beginning to materialize from the idea stage.

Want to collaborate? This is a small, purely volunteer-driven project, so your contributions are highly welcome. Check out https://hellosystem.github.io/docs/developer/contributing to get started.

Say hello!

probono is the founder and lead developer of helloSystem, the AppImage project, and a contributor to various open source projects. Screenshots were made on helloSystem booted from USB.

Design is how it works, not how it looks

Don’t get me wrong here: With “welcoming to switchers from the Mac” I don’t mean a Mac theme nor a Mac clone. There is an abundance of themes and even so-called “Linux distributions” that are basically just themed versions of Ubuntu. This is not what I want to create.

Also, the last thing I want to have on an open source system is the lock-down and spyware that Apple has been adding to its systems as of late.

I mean something that is inspired by some core Mac principles, while using Libre (“free as in freedom, not as in beer”) ingredients, and simplifying things as much as possible.

Some examples:

• A Live medium that you can boot e.g., from USB to try out the system without the need to install
• Automatically set the correct keyboard, language, and timezone
• A proper global menu bar that works like you expect it to work
• Every application comes in its own directory that can easily be “managed” using the file manager, no need for package managers
• Automatically discover network services using Zeroconf (no more looking for IP addresses on the local network)
• Easy and straightforward installer that doesn’t ask you cryptic questions
• A straightforward backup system that “just works”

Less, but better

When I think about it, most desktop environments have many things that I find utterly annoying and do not want nor need:

• Annoying notifications
• Lots of configurability which makes everything complicated, makes no 2 systems the same, and, as a result, makes everything unsupportable
• Everything tightly coupled with everything
• Lock-down (it’s my computer, not the manufacturer’s, and it’s not the manufacturer’s business to decide what I can and cannot run on my machine)
• Spyware (no, I don’t want to send the manufacturer and the secret service a list of the authors of all applications I am using)
• GNOME, KDE Plasma (too much of everything)
• App Stores where you have to log in using personal information

Makes me realize that I want basically the things I have written about in my series on #LinuxUsability (part 1, part 2, part 3, part 4, part 5, part 6), and not much more. I don’t need feature creep on the desktop, but I need the basics to work. I don’t want to configure 1,001 knobs just to get something to work. I want to switch on the machine and be in familiar territory, but I don’t need most things that make everything complex. FreeBSD greatly simplifies things because there is only one FreeBSD and hence doesn’t suffer from the Desktop Linux Platform Issues.

Unix philosophy is about small tools that do one job, but do one job well. Mac philosophy is about using the mouse to achieve everything. Let’s combine the two. Small tools that do one job, but do it well. As simple as possible.

Live medium

If you are somewhat like me, you want to try out a new operating system before you commit to installing to disk. This is what Live systems are for. Of course, hello comes as a Live system.

The Create Live Media tool makes it really convenient to fetch the lastest build and write it to a USB device in one go. No more messing around with dangerous dd if=... of=... commands!

Automatic keyboard, language, and timezone

As someone who is using Live systems for everything, I can tell you: It’s annoying to set keyboard, language, and timezone each time you boot into a new system.

So hello does it for you, automatically, without asking questions.

If you boot on a Mac, then the information stored in EFI NVRAM is used. If you have a keyboard attached that tells the system its language (like the official Raspberry Pi keyboards do), then this information is used. (If you know other ways to automatically figure this stuff out, let me know.)

A proper global menu

File, Edit,… you name it. Easy, eh? You would think. Yet so many systems get it wrong.

And this menu has superpowers: You can search its content, allowing for very quick navigation through applications with large menus like GIMP, Scribus, Krita, and the like.

Every application is a directory

Applications on Unix traditionally are scattererd around the whole file system, with the main executable in /usr/local/bin, metadata in /usr/local/share/applications, icons in /usr/local/share/icons,… you get the idea. As a result, it is very hard to drag-and-drop an application (and everything that belongs to it) in the file manager. The hello system simplifies this by taking a GNUstep-like approach using .app bundles. That Boot Environments application shown above? Open it in a new tab, and you see that it is actually a directory that contains the applications and additional resources it needs to run.

This system can be extended to produce fully self-standing application bundles that have no dependencies other than the base system.Which means that you can have multiple versions of applications in parallel, and can update each application without impacting anything else.

Using Zeroconf to connect to devices on the network

For example, imagine that instead of having to find out and type IP addresses you could just use this:

This is just one example of what I mean by “small tools that do one job, but do one job well”.

Preferences are managed with small apps

Preferences are just regular applications, many written in Python, which allows one to inspect and change the source code with ease.

Easy and straightforward installer

If you have ever installed the operating system on a Mac, you should feel instantly at home. Example: just enter your name, the installer figures out a name for your computer (hostname) on its own. Want to log in over the network? It’s just one checkbox away.

When you use this installer, you end up with FreeBSD proper plus an easy-to-use graphical interface.

A straightforward backup system

FreeBSD uses OpenZFS, a file system with true superpowers. Yet features like Boot Environments and Snapshots need to be understood and actively managed by the user. Well, let hello do that for you.

Say hello!

Would you like to try it for yourself? Grab a pre-release Live ISO.

What do you expect from a desktop FreeBSD for “mere mortals” that “just works” and is “welcoming to switchers from the Mac”? We would be happy to hear from you.

At this point, this project is still very much in the idea strage, with some proof-of-concept (ok, I’ve been using it as my daily driver lately). Do you have FreeBSD experience, Qt skills, or other ideas how to help the project? Check out the contributing page. This project lives from contributions of interested people like you! There is no company behind it, just users like you and me.

probono is the founder and lead developer of the AppImage project, the founder of the PureDarwin project, and a contributor to various open source projects. Screenshots were made on a hello Live system.