What is Modal?

We live in uncertain times. Over the past years we've seen long-established institutions erode, and new threats appear at an alarming rate. Former worst-case, nightmare scenarios like people being prosecuted for abortions based on their Facebook chats (or worse) have lost their shock value next to things like the new bone-chilling surveillance apparatus being built by ICE in the US. You can literally scroll the 404media homepage on any given day to see what fresh horrors the modern technology ecosystem has in store.

The decisions made by those who built today's digital systems were based on an underlying assumption that the current status quo would never meaningfully change. But it is now changing, at an alarming rate. The era of relative stability of the past few decades, during which most of our technology was designed seems well and truly over. In a recent publication on the threats of digital identity systems, New Design Congress has called the current moment the "end of the end of history".

Over the last year we've seen the US Big Tech companies whose services are the backbone for infrastructure world-wide explicitly aligning themselves with the Trump administration. Apple and Google are nakedly abusing their control over app stores as the only channel to distribute software to phones at the behest of the US government, such as in the recent ICEBlock case. In a similar instance, Microsoft blocked the email account of a prosecutor for the International Criminal Court, due to "fear of being targeted by US authorities". We've seen DOGE wreaking havoc in the US nonprofit sector, endangering programs like Open Technology Fund, which funds important privacy technologies like TOR. Meanwhile, Google keeps locking down Android further and further, including trying to introduce mandatory developer verification for sideloaded apps, and slowly making the OS proprietary. The Google-free Android ecosystem (F-Droid, GrapheneOS, et al) is in a more precarious position than ever.

All of this comes at the same time that more and more of society is being digitized in countries across the globe. One particularly stark example is that the EU's proposed new digital ID system entirely relies on Apple and Google for device attestation. This would create a brand-new dependency on US Big Tech companies at the precise moment that they're starting to openly abuse their power.

Told You So

People have been warning about threats like these for a long time, from the early days of the software freedom movement all the way up to the present day. Notable examples include the mid-2010s movement to frame personal data as part of the self, as well as work on weaponized design (2018) and the vulnerability of current approaches to decentralization (2020).

A decade ago these concerns were exclusive to a paranoid niche of privacy activists and free software advocates. Even in tech-savvy circles, the common wisdom was "if you want privacy, just get an iPhone". Today, with "De-Appling" having become a topic of discussion even on Hacker News, everything the free software movement has worked towards for the past decades suddenly makes perfect sense. Data ownership, sovereignty, resilience, and supply chain security are now buzzwords used even by the likes of Microsoft.

Unfortunately, while the writing was on the wall for a long time, these communities have, by and large, not been able to produce solutions that can meet the moment. Now would be the time to get people to switch over en masse. Instead, in many cases the best we can do is say "told you so".

The 80% Problem

The free software community is impressive in its capacity to explore new ideas and paradigms. However, its chaotic, volunteer-led nature means it's hard to maintain a common agenda and bring projects to completion. This makes it difficult to build competitive solutions that actually meet the needs of the wider public. The space is full of examples where the free software solution gets you about 80% of the way there. Some examples:

• The Linux desktop is a capable drop-in replacement for macOS and Windows today. However, when it comes to system security it's not competitive with iOS or GrapheneOS. For example, hard disk encryption is only active when the device is off, so the disk is unencrypted when the device is on but the screen is locked (which, for phones and laptops, is basically 100% of the time).
• Similarly, the app sandboxing story is still incomplete. XDG Portals get you most of the way there, but there are still no portal APIs for things like audio devices and networking. This means, for example, that you need to give microphone access (!) to any app that needs to play audio.
• While many of the pieces needed to compete with iOS and Android on phones are in place, so far nobody has put them together in a cohesive enough package for even most Linux Mobile developers to dogfood — let alone having anything ready for mass deployment to replace iPhones in the field.
• The best thing we have on offer to replace US clouds is self-hostable, "sovereign" clouds that come with many of the same risks and drawbacks (centralized, brittle, not end-to-end encrypted). Even ignoring that, there's close to no integration between these services and free OSes, like e.g. the integrated sync APIs on proprietary platforms.
• There are no competitive alternatives in important categories like office and email software. LibreOffice, Evolution, et al are decades behind their proprietary counterparts in terms of UX and almost entirely lack modern collaboration features.
• Openstreetmap has really good data in many areas, but there's no official app to replace Google Maps. The apps that do exist are not competitive in quality and feature set on either desktop or mobile, and important features like routing are much worse than on Google or Apple Maps.
• GNU Taler has most of the infrastructure and apps in place that you'd need for a privacy-preserving payment system, but still can't actually be used to pay anywhere.

In all of the cases above there are very understandable reasons for the current shortcomings, many of which are outside the developers' control — often it literally boils down to "there's no money in building open infrastructure". But the reality is that none of that matters to the rest of the world. For them, solutions either work or they don't. 80% might be good enough for a community of technical experts building things for themselves. It's not good enough to be widely deployed as an alternative to Big Tech.

Blueprints for Success

Given the prevalence of the 80% problem, is free software just structurally unable to break through and build solutions that can win? The good news is no! History has shown that, in the right circumstances, it can win.

One obvious historical example is the GNU project in the 80s and 90s. Regardless of what you think about them in recent years, it's a fascinating case of a community organizing towards a long-term political goal. In about a decade they went from there not being a usable free software operating system to GNU/Linux being a competitive alternative that ended up taking over the server OS market.

A more recent case study is the Steam Deck, an example of strategic long-term investment into a vertically integrated problem space (in this case running Windows games via Wine/Proton) to hedge against Microsoft's control of the Windows platform. The result is compelling enough that Microsoft still has nothing competitive despite trying for several years.

Higher up the stack there are examples like Signal, Blender, or OBS Studio, all of which are household names and leaders in their categories. So while real-world examples of success are rare, it's clearly possible for free software to win — if you're organized and strategic.

What Is to Be Done?

For the past year or so, we've been running the "Boiling the Ocean" event series in Berlin. The series evolved from the regular meetups organized by people from GNOME, postmarketOS, p2panda, and adjacent communities going back several years, but grew into something more concrete recently. They usually involve hacking, discussions, and talks around the shared topics the people in these communities work on. The name comes from the idiom, reflecting the magnitude and long-term dimension of the problems we're working on — but it's also a fitting reminder that we are all literally being boiled, in no small part due to how horrendously unsustainable the computing industry is.

At these events we started discussing topics such as local-first, mobile Linux, image-based operating systems, permacomputing, but also design and usability. We're privileged to have incredibly knowledgeable people from all of these fields in our local community. This often leads to unusual but very productive discussions and collaborations on topics such as platform security, peer-to-peer networking, hardware enablement, and how to do all of the above in a way that's useful and usable for the rest of the world. Together, we started imagining how all of this could be put together to address the problems of our time, including sustainability, digital sovereignty, and resilience in the face of present and future crises.

One thing that came out of this is a broader, more inclusive understanding of what software freedom should be in the 21st century. While the four freedoms remain relevant, they're clearly nowhere near enough to give people individual and collective control over their computing. We expanded that definition with additional principles and goals, such as building inclusive solutions for everyone, resilience against systemic failures, hardware longevity, and taking security seriously at every level. We call this broader concept emancipatory computing. We have yet to flesh out a fully formulated definition, but the Goals and Principles page reflects the current state of our thinking. We're also in active discussions with other groups around new theories and terminology, such as the "walk-away" stack idea that came out the D-Web Seminar, and Cade Diehm's exilic design. We plan to write more about this in the future.

We also identified a series of interconnected, very high priority issues towards which there is not enough work at the moment, including:

• Making the free desktop competitive with iOS and GrapheneOS in terms of security
• Linux phones as a viable hedge/alternative to iOS and Android
• Local-first sync and collaboration as a an alternative to brittle, centralized server setups

To formulate it more provocatively: We need a free software iPhone.

Looking at the political landscape and the lackluster state of free software alternatives and we developed a hypothesis: Many of these problems could be overcome if as developers we got more organized and strategically focused on actually getting some of the 80% solutions to 100%. One way to do that would be to focus on a specific, narrow configuration to start with. Think of something like the Steam Deck, but for phones.

This is, of course, easier said than done. All of these are complex long-term problems. They span multiple projects and communities and require deep knowledge of obscure parts of the stack. Sometimes they're held up by maintainer disagreement, lack of maintenance, or lack of funding. Sometimes they can't be easily addressed without changes in public policy. This is the case with bootloader locking, for example.

Solving these requires not just code and design, but also planning, coordination, and fundraising. Volunteer developers are often not interested in doing this in their free time, or are lacking the necessary skills.

Introducing Modal

What if there was a motivated group of experienced developers, designers, and organizers involved in projects across the stack? What if that group oriented itself around strategic goals, and contributed wherever necessary to achieve those goals?

Well hello, that's us!

Modal is a new collective, born out of the work that we've done over the past years. Right now it's a loose structure made up of people mostly in and around Berlin. We're involved in many of the key Linux infrastructure projects such as GNOME, systemd, and Flatpak, but also newer projects addressing more recent questions, such as postmarketOS (mobile) and p2panda (resilient networking).

Modal, as a structure, is very new and still taking shape. We're not sure yet how we want to grow or evolve it. But there are already a number of cool projects we've started under this umbrella and more are in the pipeline. We felt it's time to start having a website and more public appearance.

The Future we Want

Assuming we get organized and solve some of these problems, both technical and policy-wise, what does the future look like, say in 2035?

Firstly, there is a free software operating system that built in the commons, and just works. Let's call it "Modal OS". It comes with state of the art security, and smart protections against threats both old and brand-new. It runs smoothly on older devices and gets security updates forever. Because it's image-based, updates cannot break anything. It's also beautifully designed and a joy to use — a calm, elegant experience, even in stressful times. It's a space to express your creativity, connect with people, organize, and build things, without having to trade away your safety.

"Modal OS" runs on many different form factors, including desktops, laptops, phones, and whatever new devices become relevant in the future. Hardware support is excellent for most devices because there is a law requiring OEMs to publish documentation and upstream drivers for any devices they release.

New devices with "Modal OS" preinstalled are widely available for sale, but there's also a thriving scene of repair shops and collectives where you can get it installed on an existing device. This is possible because parts pairing and bootloader locking have been outlawed as part of a "right to software repair" law. These independent local repair spaces are also where people can get easy in-person support if they need help with their devices.

"Modal OS" has local-first sync built-in at the platform level. This infrastructure makes it easy to sync data between your devices, and exposes easy-to-use local-first APIs for apps to do the same. Because of this, there's a thriving ecosystem of free software apps that make use of this infrastructure for sync and collaboration. All of this is implemented with "walk-away" principles in mind: A modular networking stack allows using the internet, Bluetooth, Wifi-Aware, or even USB sneakernet, interchangeably.

Local-first networking has matured to the point that there's a standard for servers that act as bootstrap nodes and always-online backup peers. These ensure that peer-to-peer networks run smoothly and, when necessary, can pick up computationally intensive tasks in a privacy-preserving way. This has created an industry of small hosting providers for these servers, all fully compatible, with no vendor lock-in.

Both "Modal OS" and the apps built for it explain the security and privacy tradeoffs of potentially risky features in an approachable way rather than hiding them. This allows people to make informed decisions about potential risks, e.g. when and how to connect to the network.

Current Projects

Aside from organizing the regular Boiling the Ocean events, the main project we're currently working on is Reflection. It's a local-first collaborative notes app built on p2panda, with a native GTK frontend. Julian, Andreas, and Tobias (along with the rest of the p2panda team, Sam and glyph) are currently working on the app as part of a Prototypefund grant.

A medium-term goal of this initiative is getting more GTK app developers to add local-first sync to their apps. Eventually we want the developer experience for local-first to be so easy that any app can just get it "for free" with the GNOME stack, similar to e.g. spell checking. That future is still a few years off realistically, but we're already laying the groundwork for it on a number of fronts. There's ongoing work on GObject bindings for p2panda (which will allow non-Rust apps to use it), and a plan for a sync system service/portal prototype.

We're also planning to have an event specifically focused on local-first app development in the spring, where we hope all of this will become even more concrete. We'll share more details about this soon!

At a higher level, we're talking a lot about funding. As a group we understand and can contribute to pretty much any part of the stack, but that doesn't mean things are easy or fast to get done. Many of the technologies involved are chronically underfunded, with maintainers getting only minimal time from their employer, or going from one precarious grant to the next. Longer-term, we're interested in figuring out more sustainable ways to fund important infrastructure work like this collectively. In the short term we're focused on strategically applying for grants, and helping others in adjacent projects do the same (such as the current systemd STF project, which will unlock some of our goals at the OS level).

Some other goals and projects on our medium-term horizon:

• A public list of high level strategic issues — think a more modern version of the FSF High Priority Projects list, but with more specific/achievable objectives, and more concrete development and organizing behind it.
• Linux Mobile daily driving, at least for developers. If we want mobile support to get better faster, we really need to get to the point where more of us developers can daily drive it on our phones. This is of course easier said than done, and there's a lot of long-term pioneering work being done by postmarketOS to support lots of devices, but we think that focusing on one device as the developer phone for the next few years would be really helpful.
• System support for local-first sync, probably in the form of a daemon and portal API that allows apps to sync data with copies of themselves running on other computers. This will need discussions and coordination across the stack, but there's a lot of excitement around the topic and we have an NLNet grant lined up to prototype this next year.
• A campaign around the idea of "software repair", against OEM bootloader locking on phones. This would help avoid phones becoming e-waste when OEM support runs out, improve resilience in case companies go away, and of course enable people to actually be in control of their devices.
• In its current state Reflection is a collaborative notepad, and quite limited in its feature set. But even at this early stage we can already see how useful it can become once it gets just a couple more features like multiple documents, comments, and version control. We're also aiming to support macOS and Windows in the medium-term future, to allow collaborating across platforms.

Watch This Space

Over the coming months we'll write more about our ongoing work and future plans. For now, you can read a bit more about us on our Goals and Principles page. You can also follow us on Mastodon, or email us. If you're near Berlin, join us for a future edition of Boiling The Ocean.