Way back in 2008
When news broke in 2007 that Google was building a mobile operating system, few understood why. Symbian and Windows Mobile were doing well, and mobile Linux (MeeGo) was rapidly evolving. Android didn’t seem to fit alongside the existing OS lineup, and it wasn’t clear why Google needed it at all.
The real objective only became clear in 2008 with the launch of the first Android smartphone. iOS (then called iPhone OS) already existed, and Android looked broadly similar, but it had one crucial difference: seamless integration with Google services. When you bought a phone, you entered your email and password during the initial setup and—voilà—your phone started receiving notifications about new emails and calendar events, Google Talk messages came through, and your address book synced with the cloud.
For Google, Android was a way to attract and lock in users to its own ecosystem. If you bought an Android phone, you probably wouldn’t spend time setting up other accounts and installing extra apps. It’s much easier to sign in with your Gmail once and just use Google’s default apps.
Over time, Google became more deeply integrated into users’ phones. You could sync and access the Chrome tabs open on your desktop, get Google Drive integration and voice search, and Google Now launched to automatically surface contextual cards based on your location, past searches, calendar events, and other activity. Google Now later expanded into Now on Tap, which showed suggestions based on whatever was on your screen, and was ultimately replaced by Google Assistant—a unified system for search and proactive suggestions.
Google is now working on a way to integrate parts of other apps into Google Assistant (the Slices technology), letting it embed itself even more deeply into users’ phones. The only problem is they’re doing all this on an operating system that wasn’t designed for it.
Google’s endgame isn’t to just integrate the OS with its services anymore—it’s to make the OS itself “Google” and get rid of the tired app-centric workflow where you have to find, download, and launch an app to do anything. The operating system should simply carry out the user’s requests and adapt to them. And Android isn’t well suited to that goal.
Google in Every Pocket
None of Fuchsia’s UI mockups show an app menu, icon grid, or anything like that. Instead, Fuchsia’s interface looks like a Google Feed-style stream with a search bar. You can see calendar events, emails, messages from chat apps, and more. It’s not much different from Google Feed, except that here you’re not seeing the output of a single app—you’re looking at a visual representation of how the OS itself operates.
Fuchsia’s core building blocks aren’t files and applications like in traditional operating systems, but entities and agents. In Fuchsia, an entity can be anything: a place, a person, an event, an object, an email, and so on. These are units of information that let the OS “understand” what the user is dealing with.
Entity generation is handled by agents—specialized application components designed to analyze data streams. The simplest agent is maxwell_btl. Its job is to scan on-screen text for email addresses, create entities based on what it finds, and pass them to the operating system, specifically the Maxwell subsystem.
Thanks to a simple agent like this, the OS always knows which email addresses the user has interacted with and in what context, and can later offer suggestions based on that history. But there are more interesting examples. Imagine a friend sends you a YouTube link. You open it in the player, and while you’re watching, the YouTube agent—odd as it may sound—collects various metadata about the video, packages it into an entity, and hands it off to Maxwell. Maxwell then passes it to the desktop feed. So after listening to a Husky track just once, you’ll already see prompts on your desktop and in your player to download and check out his new album.
Like Google itself, its new OS will know everything you do—only at a much deeper level. It will build mood-based playlists, suggest where to go tonight based on your calendar and email conversations, and prompt you to buy tickets because it knows you’re planning to fly to Syzran in two days. All the necessary technologies will be baked right into the operating system.
Just imagine this: you open your browser, go to a restaurant’s website, add the event to your calendar, and say, “OK Google, invite Irina to dinner.” And Google Assistant understands what you mean. It finds the calendar event in the list of entities, looks at the entities that came before it, ties everything together, and sends Irina a message inviting her to that restaurant at that time.
A truly cloud-native OS
Like any modern operating system, Fuchsia relies on cloud services, but it also goes much further than other OSes. Today, the cloud for mobile platforms is mostly treated as a warehouse for files, contacts, messages, and other odds and ends—the kind of data the FBI will pay a million dollars for to learn more about the owner.
In Fuchsia, the cloud won’t just be a data backup—it becomes the connective tissue for everything. Imagine you’re on your laptop, typing, chatting with someone in Telegram, with synthwave playing in the background. Suddenly your boss calls; you dash off with just your phone, unlock it, and see the exact same workflow: the editor, Telegram, and the music player.
The system synced your devices and even installed a lightweight text editor on your phone—the minimal component needed for basic text work—since bandwidth isn’t unlimited and it’s unclear whether you’ll need the full UI on the phone. It even preserved your clipboard contents and the layout of your open windows (or rather, “stories,” which we’ll discuss later).
Everything cloud-related in Fuchsia is handled by Ledger, a distributed store that serves as the device’s “second memory.” It mirrors everything: app data, the apps themselves (or rather, their components), documents, settings, histories, even those photos where you’re “holding the sun” in your hand. It’s not Google Drive or iCloud; think of it as a second hard drive in a RAID array. And it’s entirely optional to use.
Ledger is a modular system. By default, it uses Google’s Firestore as the storage backend, but smartphone manufacturers can swap it for their own cloud storage. A variant that uses your home server as the storage layer isn’t out of the question either.
Modular and Scalable
From the lowest levels up to the user-visible layers, Fuchsia’s components are highly isolated and logically separated from one another. Fuchsia is built on the Zircon microkernel, which in turn builds on the minimalist LK kernel.
Zircon provides capabilities such as memory management, process creation and termination, and it also serves as a multiplexer for drivers, file systems, and the networking stack—which are not part of the kernel and, as is typical for microkernels, run in isolated processes.
Zircon is the lowest layer of the Fuchsia stack. Above it sits Garnet, the layer that provides the application runtime. This includes drivers, libraries, the Escher graphics renderer, the Amber update system (built on The Update Framework), a package manager, and the Guest virtualization system, which lets you, for example, run a Linux environment inside Fuchsia.
The next layer, Peridot, is where components live. In Fuchsia, a component is essentially an executable unit of code—this could be the agents we’ve already discussed or user-facing apps (called modules here). Components differ significantly from executables in other OSes: they always run in their own sandbox and can interact with the outside world only through a dedicated IPC mechanism based on the FIDL language.
Thanks to its unified IPC mechanism, it doesn’t matter what language an individual component is written in. Fuchsia supports Dart, Go, Rust, Swift, Java, and JavaScript; all of these can communicate through a single interface. Fuchsia’s philosophy is to keep components as small and modular as possible. For example, a media player might be composed of many components written in different languages that operate together as a single unit.
All components are bundled into packages that can be synchronized or fetched on demand via Ledger. In Fuchsia, a package can be not just a single component or a set of components, but essentially anything. Much like modern Linux distributions, Fuchsia is entirely package-based—from the bootloader all the way to the video driver’s configuration file.
A modular design will help Google avoid the kind of hell it ran into with Android. Now manufacturers won’t have to update the entire OS just to fix a bug in the media decoder or update a driver.
Stories from the Future
Armadillo is — or rather, was — the graphical interface for Fuchsia until the developers removed it from the codebase just a few days ago. Think of Armadillo as a blend of the Google feed and the Recents screen (more precisely, a “Stories” panel), separated by an information strip — essentially a status bar that sits in the middle of the screen.
Two key things to know about Armadillo:
- A context-aware desktop
- The user works with stories rather than with applications and their windows
We’ve already discussed Fuchsia’s context-aware nature. It’s the Google Feed–style feed, generated by Maxwell agents that analyze anything and everything they encounter.
Window management is a bit more interesting. Armadillo doesn’t have a so‑called freeform windowing mode like we’re used to in Windows, macOS, or Linux. The UI targets a wide range of devices with different screen sizes, so window management works quite differently—closer to tiling window managers. You can open an app (or rather, a module) full screen, add another module and split the screen, or stack modules on top of each other like browser tabs.
Each module in Fuchsia is annotated with information about the function it performs and, consequently, what kinds of entities it can be associated with. The OS leverages this metadata to free the user from having to think in terms of applications.
Say a friend shares an e‑book with you—more precisely, an entity that describes that e‑book. Fuchsia automatically finds the book online, fetches the module needed to view or purchase it, and presents it to the user. The module itself can be very lightweight, with the full application downloaded on demand.
One for All
Fuchsia is an operating system designed to run across all kinds of devices. It can power smartphones, tablets, PCs, smart home systems, and even microcontrollers (when stripped down to just the LK kernel). Its interface can stretch, shrink, and freely reflow. For debugging, the Armadillo shell lets you tweak this on the fly.
Google says that within the next three years Fuchsia will run on devices like Google Home, and within five years it will replace Android. That might be overly ambitious, but according to an Ars Technica reporter who reviewed Fuchsia a year ago, his Pixelbook already had networking, the touchscreen, trackpad, keyboard, and USB ports working, and the OS—while it still looked like a prototype—was functional.
Very recently, there were also reports that Fuchsia will offer full support for Android apps. And they won’t run in an emulator, as they do on Chrome OS, but in a full Android runtime integrated directly into Fuchsia.
Speaking of apps: by default, Fuchsia uses the Flutter framework for building graphical applications. The key advantage of Flutter is that you can develop apps right now targeting Android and iOS. Developers love Flutter for its simplicity and performance, and they’re already building production software with it—so by the time Fuchsia launches, it will have access to a catalog of millions of Android apps and hundreds of thousands of native Flutter apps.
Scenic
Speaking of Fuchsia, there’s another particularly interesting aspect worth mentioning. Like most things with a Google logo, Fuchsia uses Material Design for its interface. A key feature of this design language is its extensive use of layers and shadows. A Material Design interface isn’t just a stack of graphic elements with a black outline underneath; it’s a sophisticated composition with multiple layers and several light sources that produce different shadows.
In Android and in web apps, this whole complex scene is merely emulated, but in Fuchsia it’s real. The Scenic engine, which renders the operating system’s UI, is a 3D engine. It constructs an actual 3D scene, positions UI elements and light sources at proper angles, and then uses a virtual camera to turn it all into a 2D image.
Another reason to use Scenic is its focus on positioning Fuchsia as an OS for virtual reality systems, which require rendering multiple views from different angles to create a sense of depth.
Conclusions
So how do we sum this up? Fuchsia is clearly an intriguing and ambitious project packed with compelling ideas and innovations. It offers a well-designed, modern kernel; solid mechanisms for application isolation and interprocess communication; and an excellent graphics engine and application framework.
But that’s Google in all its glory.
Every time I buy a new phone, I turn off all voice assistants and every kind of sync except the address book and calendar. I even keep a separate phone with no Google services at all. Will Fuchsia let me do the same? Is it really modular enough that I can strip out all the “smart” stuff and keep only what I need? We’ll see — after all, we won’t have to wait much longer.