The "Year of the Desktop" has been a perennial call to arms that's sunken into a joke that's way past its expiration date. We frequently talk about the "Year of the Desktop", but we don't really talk about how we would achieve that goal. What does the "Year of the Desktop" even look like?

What it comes down to is applications—rather, a market for applications. There is no market for applications because of a number of cultural artifacts that began when the Free Software was just getting up on wobbly legs.

Today, what we have is a distribution-centric model. Software is distributed by an OSV (operating system vendor), and users get their software directly from there via whatever packaging mechanism that OSV supports. This model evolved, because in the early-to-mid 1990s, those OSVs existed to compile the kernel and userspace into a cohesive product. Packaging of applications was the next step as a convenience factor to save users from having to compile their own applications, which always was a hit-or-miss endeavor as developers had different development environment from the users. Ultimately, OSVs enjoyed being gatekeepers as part of keeping developers honest and fixing issues that were unique to their operating system. OSVs saw themselves as agents representing users to provide high-quality software, and there was a feeling that developers were not to be trusted, as of course, nobody knows the state of their operating system better than they would.

However, this model represented a number of challenges to both commercial and open-source developers. For commercial developers, the problem became how to maximize their audience as the "Linux" market consisted of a number of major OSVs and an uncountable number of smaller niche distributions. Commercial application developers would have to develop multiple versions of their own application targeted at various major distributions for fear of missing out on a subset of users. Over time, commercial application developers would settle on using Ubuntu or a compressed tar file hosted on their website. Various distributions would pick up these tar balls and re-package them for their users. If you were an open-source developer, you had the side benefit of distributions picking up your work automatically for you and packaging them if you successfully enjoyed a large following. But they faced the same dilemma.

For open-source developers, the problem is further exacerbated by the fact that OSVs would take their code and modify it in order to integrate it properly into their operating system. Modifications could be the result of bugs that are unique to a given operating system due to library versioning choices or possibly be due to reverting changes made to the application by an upstream developer. Every application in an operating system will have a series of bugs that are exhibited only in that particular operating system. These bug databases are replicated for each OSV. And, many fixes don't make it back to the upstream project. Even the way in which the packages are built can be different—different compiler options can create different behaviors from one OSV to another. Upstream developers are stuck with trying to replicate issues that they themselves cannot see, forcing them to install various distributions in order to test them.

This distro-centric model also makes it difficult for developers to have relationships with their users. There is no way to build a community around an application if users get their software from their distributions without any thought. In order to monetize the relationship, developers need to depend on capturing eyeballs in order to make the pitch. Firefox, for example, is able to distribute every version of its browser except for Linux. Downloading the macOS and Windows versions allows the Mozilla Foundation to ask for a donation. Consequently, the Linux version lags in donations by its users compared with the other two. Mozilla, by consequence, listens to users on the other platforms more than its Linux users.

This model, I believe, has reached the end of its usefulness. In order to further scale the market for Linux applications, we need to move to a new model. Although we never can eliminate the distribution-centric model (nor should we), to reach the scalability we need, we need to remove the OSV as the gatekeeper for application distribution and allow developers to control how they distribute their applications. With the rise of ubiquitous application bundling and sandboxing technologies like Flatpak, we can address those problems. Applications that can run anywhere and behave exactly how developers intended them to be run, and then centralizing them in application stores, will be the way of the future. Furthermore, we will leapfrog over Windows and macOS by being safer by having the sandboxing built in.

The next obstacle is that compared to Windows and macOS, Linux development toolchains are antiquated in relation to the highly sophisticated IDE tools that are available on non-free operating systems. This causes developers who switch to Linux to have to deal with software that came from the 1990s, which leads to longer lead times when developing applications in Linux. Although there is some relief with development hosting sites like GitLab and GitHub, it's still quite a problem. One example is embedded device developers—they frequently code in Windows and then switch to Linux to flash their device. Those developers complain that they don't have the tools they are used to using. We need to focus on modernizing our toolchain and be able to meet the expectations of developers from all technology sectors. We are making some in-roads with GNOME Builder, which makes it easy not only to build applications, but also to create immediately distributable software.

Finally, developing open-source software has been an opaque process. With a dizzying set of licenses to choose from, it's quite daunting to decide which is the best license from the very beginning in order to exploit the highly scalable nature of open-source development. In addition, culturally, libre desktop users generally expect to have little to zero monetary cost for their software. Conflating libre with free has been a cultural issue in the community. Finding new ways to allow developers to make money from open-source software is something we need to investigate and move forward with in order to allow for free and open-source software to spread at the consumer level. A successful migration will establish the last sector that Linux has not yet dominated.

Forces are in place to make this switch happen. Conferences like the Libre Application Summit—being held in Denver, Colorado, September 6–9, 2018—puts us on a more aggressive footing in creating a market for Linux applications and being able to create monetary incentives for people to create applications. The more apps we have, the greater the attraction to the Linux platform. Although the "Year of the Desktop" will not happen this year or the next, we slowly are moving toward our goals with cooperation from distributions, developers and userspace architects.