Every few years the same argument returns: Why don’t we just build our own OS? After sanctions, app-store bans, or a geopolitically awkward software update, the idea sounds obvious. Control the stack. Own the kernel. Stop depending on Google, Apple, or Microsoft.
It sounds like a technical project. It is not.
The graveyard of operating systems is full of teams that could write code. Google has Fuchsia. Samsung had Bada, then Tizen. Huawei built HarmonyOS under real pressure. Microsoft spent years and billions on Windows Phone. Mozilla tried Firefox OS. Canonical tried Ubuntu Touch. Nokia and Intel tried MeeGo. Almost none of them became the default computer people actually live on.
The constraint is not “Can our engineers compile a kernel?” The constraint is everything that has to surround that kernel for a decade.
An OS is not a product. It is a city
A finished operating system is the least interesting part of the problem.
Users do not install “an OS.” They install a place where banking works, maps load, the camera app does not break after an update, WhatsApp receives calls, the printer driver exists, Netflix plays protected video, the phone connects to the car, and next year’s chip still has drivers. That place has to be safe enough that hospitals and ministries will trust it, cheap enough that manufacturers will ship it, and familiar enough that ordinary people will not revolt on day two.
Building the city hall is easy compared with filling the city.
Android and iOS did not win because their kernels were mystical. They won because millions of developers, carriers, chip vendors, accessory makers, and advertisers organized around them. That organization is the product.
The technical work is real — and it is the easy layer
Yes, the engineering is hard.
You need a kernel, a driver model, a graphics stack, a sandbox, a package format, an update system that does not brick devices, a permissions model people can understand, and a security team that ships patches for years. Hardware vendors will not hand you documentation out of charity. Every new SoC, modem, GPU, and camera ISP is a negotiation.
If you start from Linux, you inherit a mountain of work and also a mountain of assumptions. If you start from scratch, like Fuchsia with Zircon, you spend years rebuilding primitives the world already treats as free. Either path is expensive.
Then you discover that “it boots” is not a milestone users care about. Users care whether the fingerprint sensor works after a suspend-resume cycle on a mid-range phone sold in three countries.
That is still the solvable part. Governments can fund kernels. Universities can train systems programmers. What they cannot decree is an ecosystem.
Apps are the moat, and apps do not follow flags
Developers go where users already are. Users go where apps already are. That loop is brutal for a new platform.
A national OS can mandate that ministries use it. It cannot mandate that every global bank, ride-hailing firm, game studio, and messaging company rebuild their product, keep it updated, and treat your store as a first-class target. They will ask a simple question: How many customers is this?
Windows Phone learned this in public. The interface was often praised. The missing apps killed it. Tizen phones had the same hole. Firefox OS bet on the web as an app runtime and still could not outrun native Android software. HarmonyOS had a more plausible path because Huawei already shipped huge device volumes in China — and even then, early versions leaned on Android compatibility for a reason. Drop compatibility too early and you strand users. Keep it forever and you have not actually left the other ecosystem.
Sideloading and “it can run APKs” are not a strategy. They are an admission that the native world is not ready.
Hardware makers do not want a science project
Phone and laptop vendors optimize for yield, cost, certification, and time-to-market. Android gives them a known software baseline, known test suites, known carrier requirements, and a known story for customers.
A sovereign OS asks them to:
- port and maintain drivers
- recertify radios and safety features
- rebuild factory tools
- train support staff
- accept returns when an obscure sensor fails
- explain to buyers why familiar apps are missing
Unless the volumes are enormous or the alternative is being locked out of the market, most OEMs will politely decline. Samsung kept Tizen alive on TVs and watches, where the app bar is lower and Samsung controls the device. On phones, Android stayed. That split is a clue: national pride does not pay for a smartphone camera pipeline.
Updates are a political and operational problem
An OS that ships once is a demo. An OS that ships for ten years is an institution.
Someone has to:
- patch vulnerabilities every month
- decide which old devices still get updates
- negotiate with chip vendors for blobs
- not break enterprise apps
- not look captured by one company or one ministry
- keep a signing key from becoming a national incident
This is unglamorous work. It is also where trust is won or lost. A “national” system that lags on security updates is worse than dependence on a foreign vendor that at least ships patches.
Fragmentation makes it worse. If every agency or manufacturer forks the system, you recreate Android’s old coordination mess without Google’s scale to paper over it.
Users do not buy sovereignty. They buy Tuesday morning
Policy documents talk about digital independence. People talk about whether the taxi app still works, whether their child’s school portal opens, and whether photos sync.
If the national OS is slower, uglier, or missing three apps they use daily, they will treat it as punishment. Elites can use two phones. Everyone else will install the familiar system, legally or not.
That is why so many “independent” platforms quietly keep compatibility layers, dual stacks, or web wrappers. Purity loses to habit.
Talent, time, and boredom
Great systems people are scarce. They can work on compilers, clouds, cars, or quant shops. A national OS has to hold them for a decade through driver hell, committee meetings, and versions that look unfinished next to iOS 18.
The project also has to survive elections, budget cycles, and the moment when a minister wants a demo before the foundations exist. Operating systems reward patience. Politics rewards announcements.
HarmonyOS is the rare case with a forcing function: a giant vendor cut off from Google services, a huge home market, and years of money. Even there, the road from “Android with extra steps” to a truly separate NEXT-style world is slow, regional, and still incomplete as a global consumer platform. That should calibrate expectations for countries without Huawei’s device base.
The hidden economic model
Android is cheap for manufacturers because Google monetizes search, ads, Play, and services. iOS is expensive to enter and lucrative for Apple because hardware, software, and payments are one business.
A national OS needs an answer to a rude question: Who pays for the next ten years?
If the state pays, procurement politics will shape the roadmap. If a national champion pays, it will optimize for its own devices. If nobody pays, the project becomes a university distro with a flag on the wallpaper.
Open source helps with cost and auditability. It does not conjure an app store, a support network, or a reason for Samsung-class manufacturers to care.
What “success” would actually look like
A serious program would stop pretending the deliverable is a desktop screenshot.
It would pick a narrow beachhead: government laptops, industrial controllers, set-top boxes, school tablets, or a single phone family where the state can guarantee volume. It would fund drivers in partnership with one or two chip vendors. It would pay for the boring apps first — identity, payments, maps, messaging, accessibility — not a clone of every Western consumer feature. It would keep a compatibility story without lying that compatibility is independence. It would publish security SLAs. It would resist forking.
Most of all, it would measure success by devices still updated in year seven, not by a launch keynote.
Fuchsia, Tizen, and HarmonyOS are useful because they show different failure and partial-success modes: research OS without a consumer landing zone; vendor OS that retreated to TVs; sanctioned vendor OS that could move only because the vendor already owned hardware and a domestic internet.
None of them failed for lack of slogans.
The uncomfortable conclusion
Wanting a national operating system is rational. Software is infrastructure. Infrastructure that you cannot inspect, patch, or keep in an emergency is a strategic problem.
Building one because “we have programmers” is magical thinking.
The hard parts are coordination, incentives, hardware access, application economics, and time. Those problems do not yield to a weekend hackathon or a renaming of a Linux desktop. They yield, if they yield at all, to a long industrial policy that looks more like aviation or semiconductors than like a ministry website.
Until that reality is accepted, countries will keep announcing operating systems. The world will keep using the two that already have the city built.
