An exploration of hardware-independent computing environments through CleraOS.
For most of the history of personal computing, we’ve understood a computer as a physical machine.
You buy a laptop, install an operating system, configure your applications, store your files, and build your workflows around that particular device.
When you get a new machine, you migrate your files, reinstall applications, restore settings, and spend time recreating the environment you already had.
And if you want more computing power, the conventional answer is simple: buy better hardware.
Want more RAM? Buy a machine with more RAM. Need a powerful GPU? Buy a workstation. Want to run demanding software? Your device’s hardware determines what you can do.
But what if we’ve been thinking about personal computers the wrong way?
What if your computer wasn’t necessarily the physical device you own, but the computing environment you use?
That’s the question behind CleraOS.
The idea: Your computing environment should belong to you
CleraOS is an attempt to explore a different model of personal computing.
Instead of treating the physical machine as the computer itself, CleraOS treats the computing environment as the computer.
The distinction is important.
Your identity, files, applications, settings, workspace, and workflows shouldn’t fundamentally depend on a particular piece of hardware.
A laptop, desktop, tablet, or browser could become different ways of accessing the same computing environment.
The hardware still matters. Different devices have different capabilities. But those capabilities shouldn’t define the user’s computing identity.
In this model, hardware determines what can execute locally. It doesn’t have to determine what computing environment you can access.
It started with an iPad
CleraOS didn’t begin as an attempt to reinvent personal computing.
It started with a much smaller problem.
I wanted a terminal on my iPad so I could work on my projects alongside GitHub Codespaces. I needed a more convenient development experience on a device I already owned.
But building a terminal exposed other requirements.
A useful computing environment needs more than a command line. It needs files, a filesystem, persistent storage, applications, windows, authentication, and a way to manage everything together.
Each requirement introduced another layer.
Eventually, the project stopped being simply a terminal for an iPad. It became an attempt to build a complete computing environment that happened to be accessible from an iPad.
And that led to a much bigger question:
Why does a person’s computer have to belong to a particular physical machine?
Not just another cloud desktop
It’s easy to interpret this idea as putting a desktop computer in the cloud.
That’s not quite what CleraOS is exploring.
The goal isn’t to move everything to a remote server and stream a desktop back to the user.
The goal is to make the computing environment independent of where it’s accessed and flexible about where work gets executed.
Some operations can run locally. Others can run through a browser-based execution environment. More demanding workloads can use remote computing resources.
The user should still experience one coherent environment.
This distinction matters because local and remote computing don’t have to be competing models.
A device can use its own hardware when appropriate and access other computing capabilities when necessary.
Imagine someone using an inexpensive laptop with limited memory and integrated graphics. They could still access more powerful computing resources without having to purchase an expensive workstation themselves.
The laptop becomes an access point rather than the ceiling of their computing capabilities.
That doesn’t mean hardware becomes irrelevant. It means access to computing power doesn’t have to be tied entirely to hardware ownership.
How CleraOS approaches the problem
CleraOS is being developed around several interconnected layers.
1. A persistent computing environment
CleraOS provides its own desktop experience, window management, applications, filesystem, identity, and system services.
The intention is for applications to feel like parts of one operating system rather than unrelated websites running in separate browser tabs.
The environment manages its own files and application experiences instead of making the user think in terms of the underlying repositories or infrastructure providers.
2. Local-first storage
A portable computing environment still needs to work with local data.
CleraOS uses browser-based persistent storage, including the Origin Private File System (OPFS), as part of its local storage model.
Cloud services can provide synchronization, backup, portability, and recovery without making the cloud the only place where a user’s files exist.
The broader objective is to preserve a usable local environment while allowing data and workflows to extend beyond one device.
3. Multiple execution environments
One of the more interesting parts of CleraOS is its execution model.
Software doesn’t necessarily have to execute in one specific place.
CleraOS is designed to work with different execution capabilities, including browser-based execution, local execution, and remote execution.
It also has a separate x86-64 execution-engine project, intended to progressively support running existing software rather than requiring every application to be recreated specifically for CleraOS.
The long-term direction includes support for Linux ELF binaries and, eventually, additional executable formats and compatibility layers.
This is a substantial engineering challenge, and compatibility is something that has to be developed and tested incrementally.
4. Web access and eventual native boot
CleraOS treats web and native access as complementary approaches.
The web/PWA environment allows users to access CleraOS through compatible devices without requiring them to install a completely new operating system.
The longer-term ambition is to make CleraOS bootable directly on supported hardware.
These aren’t intended to be two unrelated products. They are different ways of accessing the same underlying computing environment.
What exists today, and what comes next
CleraOS is an ongoing systems project, not a claim that the entire vision has already been achieved.
The current web environment includes a desktop, window management, filesystem, authentication, profiles, applications, terminal, browser, and local persistence. Remote execution is also part of the architecture.
The x86-64 execution engine, broader software compatibility, specialized execution environments, and native boot represent further development work and long-term goals.
A different mental model for personal computing
Consider two people.
One owns a powerful workstation with a high-end processor and graphics card. The other owns an inexpensive laptop.
In today’s conventional model, the second person’s hardware places significant limits on what they can do locally.
But what if both could access the same computing environment and draw on the same class of computing capabilities when those resources are available?
They wouldn’t need to own identical machines. They wouldn’t necessarily need to buy the latest laptop to access the capabilities of more powerful hardware.
Their devices would provide access. The computing environment would coordinate the available capabilities.
This is the broader shift CleraOS is exploring.
It isn’t about making every device equally powerful. It’s about making computing environments and capabilities less dependent on the particular device someone owns.
The machine is not the computer
I don’t think personal computing has to remain tied to the idea that one physical machine is someone’s entire computer.
A person’s computer could be a persistent environment that follows them between devices, uses local hardware when available, and accesses remote capabilities when necessary.
The device can change. The hardware can change. The execution location can change.
The environment remains yours.
That’s what I’m exploring with CleraOS.
It’s an ambitious project, and there are many engineering challenges still ahead. But the underlying question is worth exploring:
What if your computer was something you could access, rather than something you always had to carry?
CleraOS is an independent project exploring this approach to personal computing. The vision is evolving alongside its implementation.
Try CleraOS!
