Category: Standards

When governments and organisations talk about “digital sovereignty,” they usually mean one thing in practice: the ability to choose, control, and if necessary replace the software they depend on — without asking permission from a vendor.

It sounds simple. It rarely is.

Document software sits at the centre of almost every organisation’s operations. Contracts, reports, budgets, policy documents, public communications: they all live in files. And for decades, the format of those files — and therefore the tools required to open, edit, and share them — has been controlled by a single commercial entity. That is not sovereignty. That is dependency with a friendly interface.

LibreOffice Technology exists to make genuine sovereignty possible. Not as a promise, and not as a political statement — but as a technical architecture that removes the dependency by design.

This post explains what LibreOffice Technology actually is, why it is categorically different from a “free alternative to Microsoft Office,” and why it is the only open platform capable of supporting software that is fully compatible with the demands of digital sovereignty. It also reviews what several months of deployments, policy decisions, and one very public debate over what “sovereign” actually means have confirmed about that architecture since we first started making this argument.

Beyond the Application: LibreOffice Technology as a Platform

Most people who encounter LibreOffice encounter it as an application — a word processor, a spreadsheet editor, a presentation tool. That is a reasonable introduction, but it misses what makes LibreOffice Technology significant.

LibreOffice Technology is the underlying platform on which LibreOffice — and a growing number of other products — is built. It is a modular, open-source software framework for creating document applications. It includes rendering engines, import/export filters for dozens of file formats, scripting infrastructure, accessibility layers, and interfaces for integration with operating systems, cloud environments, and enterprise software stacks.

Think of it the way you might think of a general-purpose operating system kernel: the kernel itself is not what users interact with directly, but it is what makes everything else possible — and it is what determines whether the system is genuinely open or merely open-looking.

LibreOffice Technology is governed by The Document Foundation (TDF), a non-profit foundation incorporated under German law. Its source code is publicly available, its governance is transparent, and its development is carried out by a global community of contributors from dozens of countries and organisations — including Collabora, allotropia, Red Hat, and many others.

No single company controls it. No acquisition can change its licence. No pricing decision by a distant board can determine whether your organisation can keep using it next year.

That is what a platform for digital sovereignty looks like.

Open Standards Are Not Optional: The Role of ODF

Sovereignty over software is meaningless if the data is not equally free.

A document format is not just a technical specification. It is a commitment about who can read your files in ten years, which tools can process them today, and whether you are locked into a particular vendor’s upgrade cycle to maintain access to your own information.

LibreOffice Technology is built around the Open Document Format (ODF), an ISO/IEC international standard (ISO/IEC 26300) developed through an open, multi-stakeholder process. ODF defines how text, spreadsheets, presentations, and other document types are stored — in a way that any conforming application can read and write, regardless of who made it or on what platform it runs.

This matters in ways that are easy to underestimate. When a public administration stores its records in ODF, it is not dependent on any vendor to access those records in the future. When a hospital uses ODF for patient documents, it can switch tools without migrating data. When a ministry publishes a policy document in ODF, any citizen with any compliant application — on any operating system — can open it.

Contrast this with proprietary formats that, despite occasional published specifications, remain under the effective control of the companies that defined them. “Open enough” is not the same as open. Earlier this month, we set out a first version of what separates the two: a thirteen-criterion definition of what a genuinely open document format requires, from public specification and royalty-free implementation through to independent governance. That short version is only the opening statement — we originated this framework, and a fuller, more rigorous edition is in development, applying all thirteen criteria in detail to ODF, OOXML Strict, and OOXML Transitional in turn.

LibreOffice Technology’s commitment to ODF is not a preference. It is an architectural principle. The platform is designed around the assumption that the data belongs to the user, not to the software.

The Platform Others Build On

One of the clearest indicators that LibreOffice Technology is a genuine platform — not just a standalone application dressed up in platform language — is the ecosystem of products built on top of it.

Collabora Online, a cloud-native document editing solution deployed by enterprises, governments, and cloud providers across Europe and beyond, is built on LibreOffice Technology. Collabora’s 2025 merger with allotropia — whose engineering team brought deep WebAssembly and vertical-application expertise into the same organisation — is itself an example of how the ecosystem consolidates and grows without ever touching the underlying platform’s governance. Other commercial and community products remain in active development by organisations that have chosen LibreOffice Technology precisely because it provides a stable, open foundation they can build on without acquiring permission from or paying royalties to a gatekeeper.

This ecosystem diversity is itself a form of sovereignty insurance. If one vendor stops supporting a product built on LibreOffice Technology, the platform continues. If a government or organisation builds custom tooling on top of LibreOffice Technology, it owns that investment. If the community of contributors shifts, the codebase remains — licensed under the Mozilla Public License 2.0, which ensures it can never be made proprietary.

A sovereign digital infrastructure is not one built on a single vendor’s promises. It is one built on a platform that multiple independent actors develop, maintain, and depend on. LibreOffice Technology is that platform.

The Euro-Office Test Case: Why Compatibility Is Not Sovereignty

No event tested this argument more directly than the emergence of Euro-Office, the European coalition initiative that surfaced this spring under the digital sovereignty banner.

Our first reaction, when the initiative made its opening announcement, was blunt about the architecture: a European suite built around full compatibility with Microsoft’s OOXML formats does not escape dependency, it relocates it. The hosting moves to Europe. The format — and the vendor who controls its evolution — does not.

Euro-Office’s formal pre-announcement in June moved the conversation forward. It leaned much further into a commitment to open standards, and we welcomed that shift while correcting one detail then circulating in the press: LibreOffice, developed under this Foundation for a decade and a half by a global — and substantially European — community, was never absent from the field Euro-Office proposes to enter. We also set out, plainly, the one destination consistent with the sovereignty the coalition invokes: ODF as its native document format, not merely a supported one.

The distinction is not a technicality. As we laid out in A Standard in Name Only, the version of OOXML every proprietary vendor ships by default is the Transitional conformance class — built to preserve decades of undocumented legacy behaviour from Microsoft Office versions of the 1990s, not the cleaner Strict variant an independent implementer could actually build to. An office suite that treats OOXML Transitional as its working format, however European its servers, is building on a specification only one vendor has ever fully implemented. What Euro-Office does next will show whether the coalition takes the final step from sovereign hosting to sovereign format.

Where Sovereignty Is Not an Abstraction: Real Deployments

Digital sovereignty is sometimes discussed as though it were a future aspiration. For a growing number of organisations, it is a present operational reality — and this year produced the clearest evidence of that yet.

In March, Germany’s Federal Ministry for Digital and State Modernisation folded ODF, alongside PDF/UA, into the Deutschland-Stack, the technical framework that will govern digital infrastructure across every level of German public administration. OOXML did not make the list. “This is not a recommendation or a preference, it is a mandate,” said Florian Effenberger, TDF’s Executive Director, at the time — and as we argued in the days that followed, it is a decision the rest of Europe, and every digital policy advisor reading it, should be studying closely.

Germany is not alone. The Italian Ministry of Defence has spent several years migrating well over 100,000 workstations to LibreOffice under its LibreDifesa programme, reducing dependency on proprietary desktop software and building direct control over its document infrastructure. The French Gendarmerie nationale has pursued the same goal at comparable scale over two decades, moving the substantial majority of its computing estate to open-source software as part of a deliberate strategy to reduce vendor lock-in. And in August, in a two–part interview with the Austrian Bundesheer, we heard directly from the team that has moved 16,000 workstations off Microsoft Office: the decision traced back to a 2020 review of what guarantees existed for running office software without a cloud connection at all. The City of Munich’s long-running open-source initiative — despite its complex political history — remains the clearest illustration that sovereign document infrastructure is both technically achievable and organisationally demanding, at scale, inside a large public administration.

These are not proofs-of-concept. They are operational deployments in organisations for which the ability to control their own software stack is not an ideological preference but a security and continuity requirement.

They also illustrate something important: the question is no longer whether LibreOffice Technology can support enterprise-scale sovereign deployments, or whether governments will choose ODF when the choice is put to them plainly. Germany has already answered both. The question now is how quickly the rest of Europe follows.

Why “No Single Vendor Can Pull the Plug” Matters More Than Ever

In 2011, Oracle donated the OpenOffice.org codebase to the Apache Software Foundation and largely stepped back from development. The product that had been the leading open-source office suite effectively stalled. Development slowed, releases became infrequent, and the community migrated — mostly to LibreOffice, which had been founded in 2010 precisely to create a more independent governance structure.

This episode is instructive. A product can be open-source and still be effectively controlled by a single corporate actor. When that actor’s priorities change, the product suffers.

Much of what we have published this year has been an attempt to make that risk structural rather than anecdotal. The invisible architecture of lock-in traces how dependency on a document’s format cascades into dependency on the rendering engine that displays it and, beneath that, the fonts that give it its final shape — three technical layers, each one obscuring the one beneath it. The Calendar and the Invoice extends the same argument to two layers that are not technical at all: the migration deadline a vendor sets, and the subscription price it charges. Five layers, and what unites all of them is a single absence — the user has no exit.

The Document Foundation was designed with this risk explicitly in mind. TDF’s statutes prevent any single company or individual from controlling the foundation. Its governance model distributes decision-making across an elected board, a membership body, and an engineering steering committee. The LibreOffice Technology codebase cannot be re-licensed, sold, or restricted by any single party.

This is not an accident of history. It is an architectural decision about governance — as important to digital sovereignty as any technical specification.

What Sovereignty Requires of a Platform

Digital sovereignty is not a binary condition, and it is not the same thing as self-sufficiency. As we argued in July, it is not about owning everything — no institution, and certainly no continent, is going to reimplement the entire computing stack from silicon upward. It is about ensuring that nothing essential can be taken away. Different organisations will weigh that differently, but a platform that genuinely enables it must satisfy several non-negotiable criteria:

Open source with a robust licence. The code must be inspectable, modifiable, and redistributable. Not just available — auditable and forkable by any qualified party.

Open standards at the data layer. File formats must be governed by independent standards bodies, not by the platform vendor.

Independent governance. No single commercial entity should be able to make decisions — about licensing, pricing, feature development, or platform direction — that override the interests of the broader community of users and contributors.

An active, diverse contributor base. Sovereignty requires resilience. A platform maintained by a single company is a single point of failure.

Ecosystem depth. Sovereignty at the document layer requires that the platform be capable of supporting the full range of an organisation’s document needs — not just basic editing, but integration with enterprise systems, accessibility compliance, multi-language support, and cloud deployment.

LibreOffice Technology satisfies all of these criteria. We are not aware of another document software platform that does.

Sovereignty Starts Here: The Story So Far

When we first sketched out this argument, we framed it as the opening of a campaign. Several months on — with the Euro-Office debate still very much alive, Germany’s Deutschland-Stack mandate now a matter of public record, and the US CISA’s own guidance on open-source verifiability landing squarely in the same argument — it makes more sense to call it what it has become: an ongoing, evidence-led case, not a one-off pitch.

If you want the fuller version, the pieces above trace most of the argument in detail: what digital sovereignty actually means and doesn’t mean; the layered architecture of lock-in and its non-technical extensions; what separates a genuinely open format from one that merely claims the label; the Euro-Office exchange in both its instalments; and, most concretely, the Austrian Bundesheer’s own account of why and how it moved 16,000 desktops off Microsoft Office. Together with the Deutschland-Stack decision, they are the evidence behind everything argued in this piece.

We are not finished. There are interoperability failures we haven’t yet written about, further national deployments to document as they happen, and — with LibreOffice 26.8 due for release on 26 August — a platform that keeps giving us more to report on. Watch this space for what comes next.

If you are a journalist or analyst covering digital sovereignty, open source, or public-sector technology, we would like to talk. If you are an organisation considering or using LibreOffice Technology and would like to share your experience, we would welcome the conversation. Reach out to our communications team at media@documentfoundation.org.

Digital sovereignty requires infrastructure that is genuinely open. That infrastructure exists. It is called LibreOffice Technology, and — as the months since we first wrote that line have gone on to show — this really is where the story starts.

The Document Foundation is the non-profit organisation behind LibreOffice. It is independent, non-commercial, and governed by its membership community. LibreOffice Technology is the open platform on which LibreOffice and a growing ecosystem of document applications are built.

Tags: digital sovereignty, LibreOffice Technology, open document format, ODF, open source, The Document Foundation, public sector IT, vendor lock-in, document software, Euro-Office, Deutschland-Stack

Further Reading on This Blog

The posts behind the argument above, in the order they were published:

• Dear Europe: Germany has shown the way forward — March 2026
• Euro-Office: sovereign in name only, or in reality too? — April 2026
• A Standard in Name Only: What OOXML Transitional Tells Us About Format Sovereignty — June 2026
• Euro-Office, open standards, and native ODF — June 2026
• The Invisible Architecture of Lock-In: the Layering of Dependencies — June 2026
• The Non-Technical Dependency Layers: the Calendar and the Invoice — July 2026
• What Is Digital Sovereignty — July 2026
• CISA Publishes Open Source Security Guidance: Verifiability Is the Difference — August 2026
• The Characteristics of a Truly Open Document Standard Format — August 2026
• Why and How the Austrian Military Moved to LibreOffice (Part 1) — August 2026
• Why and How the Austrian Military Moved to LibreOffice (Part 2) — August 2026

External Resources

• ISO/IEC 26300:2006 — Open Document Format for Office Applications, the official ISO standard page for ODF.
• Public Money? Public Code!, the Free Software Foundation Europe’s campaign for public code as the default for publicly funded software.
• European Interoperability Framework, the European Commission’s guidance on interoperable digital public services.
• Deutschland-Stack, the German federal government’s official site for its sovereign digital infrastructure programme.

A truly open document format requires free public availability, royalty-free standards, and no usage restrictions.

Organizations like the Open Knowledge Foundation and the European Union use several core rules to guarantee long-term data access, system independence, and freedom from single-vendor control.

Core Openness Criteria

• Public Specification: The complete format rules are published and easy for anyone to access.
• Royalty-Free: Patents or licensing fees cannot block developers from building compatible software.
• No Discrimination: Anyone can use the format for any purpose without needing special permission.
• Independent Control: A transparent, non-profit standards body manages future updates.

Recognized Frameworks

• The Open Definition: Specifies exact legal and technical terms for open works.
• European Interoperability Framework (EIF): Requires governments to use truly open formats for public documents.

Comparison of ODF and OOXML

When evaluated against the strict criteria for open formats, Open Document Format (ODF) and Office Open XML (OOXML) take fundamentally different approaches.

While both are recognized as official ISO standards, ODF fully satisfies the open standard criteria by design, whereas OOXML features structural and legal complexities that often limit true open implementation.

Comparison Table

Key Openness Differences

Public Specification & Transparency

• ODF: Conceived from the beginning to be a modern, clean XML specification. “ODF is the only openly available standard, published fully in a document that is freely available and easy to comprehend”, as noted by GranneBlog: https://blog.granneman.com/2009/02/06/odf-compared-constrasted-with-ooxml/
• OOXML: Designed primarily to map Microsoft Office’s old binary data into XML. It is split into Strict and Transitional variants. “Transitional is everything else: a vast catalogue of compatibility features, deprecated elements, platform-specific behaviours, and references to undocumented quirks of Microsoft Office versions from the 1990s.”, as noted by the TDF Blog: https://blog.documentfoundation.org/blog/2026/06/02/a-standard-in-name-only/

Legal & Intellectual Property Rules

• ODF: Utilizes a standard open-source framework. Anyone can implement ODF in a project without fearing intellectual property or patent litigation.
• OOXML: Relies on the Microsoft Open Specification Promise (OSP): https://en.wikipedia.org/wiki/Microsoft_Open_Specification_Promise. The OSP is a unilateral covenant not to sue, but it only covers developers to the extent that they precisely mirror the specification. Any implementation-defined deviations or edge cases may leave developers legally unprotected.

Technical Discrimination & System Control

• ODF: Avoids hardware-specific dependencies, ensuring that independent applications (like LibreOffice or Apache OpenOffice) can render the data uniformly.
• OOXML: Contains platform-specific elements tied closely to the Windows OS ecosystem. Because Microsoft Office has traditionally produced Transitional OOXML by default, third-party platforms encounter massive conversion obstacles when interpreting legacy binary elements or proprietary formatting definitions embedded within the file structure.

INTERESTING REFERENCE: the Italian definition

The document Linee guida su acquisizione e riuso di software per le pubbliche amministrazioni (Guidelines on the procurement and reuse of software for public administrations), published by AgID in 2021, define an open format in the glossary as follows (translated from Italian):

Open (data) format. This is a public, versioned data format that is comprehensively documented and has no implementation constraints. An open format is one recognised by a standardisation body and maintained collaboratively by several organisations that provide competing implementations, through a transparent process. The format must remain consistent with the declared version.

The guidelines are not an interpretive gloss issued alongside the statute. They are adopted in implementation of articles 68 and 69 of the Codice dell’Amministrazione Digitale, under express delegations contained in the statute itself. They also supersede the earlier AgID circular 63/2013 on the same comparative assessment.

The definition of formato aperto (open format) is therefore not a recommendation that happens to be well drafted. It is the operative legal definition for Italian public administration, and it acquires that force through the statute rather than in spite of it.

In the previous article, we explored the importance of standards: how the unspoken agreements governing electrical sockets, paper sizes and file formats form the foundations of a world in which choices remain open and power is not concentrated in the hands of a single player. We concluded with a question: if open standards are so beneficial, why aren’t they universally adopted?

The answer, in the case of document formats, lies in a single page produced by Microsoft Office. Getting rid of it is harder than it seems.

A file is never just a file

When you save a document on your computer, you are choosing a format — that is, the language in which your document is written in a way that the computer can understand: the set of rules that determines how words, tables, images and formatting instructions are stored and, consequently, how they can be retrieved, shared and read in the future.

For decades, the dominant format for office documents has been that produced by Microsoft Office. Initially as binary files with extensions such as DOC and XLS, then as XML-based formats introduced with Office 2007: DOCX, XLSX and PPTX. These formats are used by hundreds of millions of people. They are the lingua franca of offices, schools, public administrations and courts around the world.

Furthermore, in significant and decisive ways, they are proprietary — meaning they belong to Microsoft, are controlled by Microsoft and serve Microsoft’s interests in ways that may not align with the interests of users.

Understanding how all this works — and why it matters far beyond mere matters of software preference — is the aim of this article.

The architecture of dependency

Proprietary formats create dependency through a mechanism that is simple in principle and extraordinarily effective in practice: they make the data contained in a document inseparable from the software used to create it.

This is not a law of physics, but a design choice.

An open format — a format whose specifications are published, freely available and implementable by any software without restrictions — stores information in such a way that any compliant application can read, write and reproduce it faithfully.

A proprietary format, by contrast, may contain undocumented features, private extensions or behaviours that only the original software implements correctly. The document may be opened by other applications, but it cannot always be reproduced faithfully.

The practical consequence is familiar to anyone who has tried to open a Microsoft Office document in another application: the formatting becomes distorted, bullet points shift, tables lose their proportions, and headings appear different.

A presentation that looked polished in PowerPoint seems slapdash in a different viewer: the content is all there, whilst the document, strictly speaking, is not.

This is “lock-in”: it is not a padlock, it is not a technical ban, it is not a contractual restriction, but a silent and persistent friction that makes any work outside the Microsoft ecosystem seem slightly off, slightly unreliable, slightly unprofessional — and ensures that the easiest route is to return to the tools that produce documents with the expected appearance.

The standard that isn’t a standard

Microsoft formats have been submitted to international standardisation bodies and approved. This has been used, time and again, to argue that concerns about “lock-in” are exaggerated — that OOXML, the Office Open XML format, is as open a standard as any other, and that the playing field is level.

The reality is considerably more complicated.

The standardisation of OOXML was one of the most contested processes in the history of ISO: national standardisation bodies reported procedural irregularities, and the votes were contested. The process has left an indelible mark on the credibility of international standards, and has resulted in a specification of extraordinary length and complexity — running to thousands of pages — which did not describe a format designed for interoperability, but rather the existing behaviour of Microsoft Office, including legacy behaviours, undocumented features and implementation details specific to Microsoft’s source code.

No other software could fully implement the format, yet it was required to do so out of respect for its users, who needed to exchange documents with Microsoft users.

The version of OOXML that was standardised — OOXML Transitional — initially co-existed with a stricter variant, OOXML Strict, which eliminated most of the problematic legacy elements, but not all. Moreover, Microsoft Office has always used OOXML Transitional as the default format, and has relegated OOXML Strict to the bottom of the options (to prevent it from being used).

The practical effect is that the format used daily by hundreds of millions of people is the one that only Microsoft’s own software implements correctly, whilst the cleaner variant — which other software could actually support — is not used, and has now even disappeared from some versions.

A standard that only one implementation fully supports is, from a functional point of view, a proprietary format with a standardisation certificate.

Lock-in, from the individual to the institution

Dependence on document formats is the main mechanism of lock-in, but it is not the only one. We discussed the layering of dependencies at length in a previous article, so we will not revisit the subject here. Levels of dependence vary depending on the importance of the documents involved and the size of the organisation producing them.

For an individual user, a document with altered layout is simply an inconvenience. For a law firm, it may mean that a contract submitted to court does not match the version in the client’s file. For a hospital, it may mean that a clinical form is printed incorrectly. For a government department, it may mean that a document appears differently depending on the software used: a silent and unintended form of unequal access to public information.

At the level of public administration, this dependency takes on a dimension that goes beyond operational efficiency. A government that archives official documents in a format controlled by a private company has, strictly speaking, delegated the custody of its institutional memory to that company. Today, documents are readable because Microsoft continues to support the format, but whether they can be read in twenty years’ time will depend on the company’s decisions, for reasons that have nothing to do with the public interest.

This is not a hypothetical risk: formats are phased out, software versions change, and features present in one version of Office may behave differently — or not work at all — in another.

The history of digital documents is littered with files that cannot be opened because the software with which they were created no longer exists or no longer works on modern systems. Proprietary formats accelerate this risk by concentrating the knowledge needed to interpret them within an organisation whose commercial interests may, at any time, diverge from the interests of those who depend on access to their own documents.

What true sovereignty requires

A truly independent document — one that displays identically on any system, in any country, for any user, regardless of the software used — requires informed choices at every stage of its creation.

At the format level, it requires an open standard such as the Open Document Format (ODF), whose specifications are published, freely implementable and managed by a body independent of any single vendor. ODF is an international ISO standard that has undergone a legitimate standardisation process and whose specifications can be fully implemented by any software that chooses to do so. LibreOffice, the leading open-source office suite, uses ODF natively. The same should apply to any other self-respecting open-source office application.

In terms of fonts, it requires open fonts, the designs of which are published under licences that allow any software to implement them and any user to install them without cost or restrictions. Open font repositories offer a wide range of high-quality options that have no proprietary dependencies.

In terms of templates and workflows, it requires institutional policies that specify open formats and open fonts as the default for all official documents — not as an aesthetic preference, but as a governance requirement, in the same way that a public administration might specify accessibility standards or data protection requirements.

At the archiving level, this requires a commitment to formats specifically designed for long-term preservation — such as PDF/A for documents intended for permanent archiving — whose specifications are public and whose readability does not depend on the commercial decisions of a single supplier.

None of this is technically complex, but it requires a conscious decision by someone with the authority to do so.

A document is never innocent

A document is an argument made visible. It is also, always, a set of dependencies made invisible.

When an institution sends a letter formatted with a proprietary font, embedded in a proprietary format, produced by proprietary software, it is not communicating information but perpetuating a dependency — in workflows, in the expectations of correspondents, in staff memory and in the implicit message to recipients — that this is precisely how documents work, that there are no alternatives, that the infrastructure of written communication belongs to someone else, and that it has always been this way.

Digital sovereignty begins with the recognition that this is a choice: the file format is a choice, the font on the page is a choice, and the software is a choice. And choices, unlike facts, can vary.

That document, which continues to be regarded as a “seemingly” innocent piece of paper, is in reality no longer a piece of paper — and hasn’t been for some time — but an executable file that is interpreted by software, and as such is no longer innocent but, in many cases, the insidious tool of lock-in.

Microsoft Office Icons: Ms Office Icon Vectors by Vecteezy
Protest against OOXML: Techrights
Innocent piece of paper: The Mazloom Law Firm, LLC

You arrive in a city you have never visited before. You are tired. You find your room, open your suitcase, pull out a charger, and plug it into the wall. The small green light comes on. You think nothing of it, because nothing happened. You moved between two countries, two electrical grids, two regulatory regimes, and the machine in your hand simply continued to work.

Behind that uneventful moment sits more than a century of meetings, arguments, technical drawings, and compromises between people who will never meet you. The plug fits because somebody, somewhere, decided that it should – and decided further that the decision should be written down, made public, and not owned by anyone. We almost never notice this kind of work. We only notice it when it fails: the adapter that does not fit, the document that does not open, the part that cannot be replaced. Standards are the infrastructure we live inside, and like most infrastructure, they are invisible until they are not.

The public agreement

A standard is a public agreement about how things should fit together. Two words in that sentence carry the weight: public and agreement. Public, because the rules are written down and anyone can read them. Agreement, because nobody imposes them alone; they are negotiated between parties who accept that the shared space is more valuable than any individual advantage within it.

This distinguishes a standard from two things it is often confused with. It is not a law, because no state enforces it directly. And it is not a product, because no company owns it. A standard sits in a peculiar middle ground – it is something that belongs to everyone and to no one, maintained by institutions whose only task is to keep it coherent and accessible. The metric system is a standard. So is the size of a sheet of A4 paper, the shape of a stop sign, the gauge of a railway track, the dimensions of a shipping container. None of these things were inevitable. Each of them was once contested, and each of them was resolved not by conquest but by convention.

A civic act, not a technical one

It is tempting to treat standards as a matter for engineers. They are not. Or rather, they are only incidentally so. The engineering is the easy part. The hard part is the decision that the rules of a shared space should not belong to any single actor – that the measurement of length, the width of a road, the voltage in a socket should be held in common rather than owned.

The history of standards is, almost without exception, a history of fragmentation followed by painful consolidation. In the nineteenth century, European railways had dozens of incompatible track gauges, because each company built its own. Goods had to be unloaded and reloaded at every border, and sometimes at every regional boundary. The loss was enormous, and it was eventually resolved not because engineers invented a better track but because societies decided that the common good of interoperability was worth more than the private advantage of incompatibility. The same story repeats with screw threads, with time zones, with paper sizes, with electrical systems. Each consolidation was a political act dressed in technical clothing.

When we say a standard is public, then, we are saying something quite radical. We are saying that a certain category of rules – the ones that govern how we connect to each other – must be held outside the market, because if the market owns them, the market can charge rent on the simple act of cooperation.

What standards give us

From the point of view of the person who uses them – which is to say, all of us, every day – open standards provide three things that are easy to take for granted until they are gone.

The first is interchangeability. Because the rules are public, anyone can build to them. If the lamp you bought five years ago breaks, you can replace the bulb with one from any manufacturer. If your supplier raises prices unreasonably, you can switch to another. If a company goes out of business, its customers are not stranded. You are not captured by the choices you made in the past, because the choices were made against a common framework rather than inside a private one.

The second is continuity. What works today will still work tomorrow, and what was made yesterday still works today. This is a quieter gift, but it may be the most important one. A standard that is public and stable means that your past remains legible to you. The documents you wrote twenty years ago, the tools your grandfather used, the measurements recorded in an old building plan – all of these remain available, because the rules that governed them are still available. Continuity is how a society talks to itself across time. It is how we remain connected to what we have done and what has been done for us.

The third is shared ground. Standards let people who have made different choices still cooperate. You and I do not need to use the same brand, the same supplier, the same tool. We only need to agree on the interface between us. A standard is, in this sense, a kind of peace treaty – a recognition that a common format for exchange matters more than uniformity of preference. It is the opposite of a monoculture. It is the condition that makes plurality possible without chaos.

When the rules become private property

Now consider what happens when the rules of a shared space are privately owned.

Imagine that the thread on every screw in your country belonged to a single company, and that using a screw at all required permission from that company. Imagine that the gauge of the railway tracks was the property of one firm, and that every other operator had to pay to run trains on lines they did not own. Imagine that the voltage of the electrical grid was licensed, and that plugs from any other manufacturer simply did not fit.

The three goods we just described begin to erode. Interchangeability disappears, because you cannot replace one part with another without the owner’s permission. Continuity depends on the corporate survival of a single actor: if the company changes its terms, raises its prices, or goes bankrupt, you lose access not just to a product but to the entire category of things that depended on it. Shared ground shrinks until it includes only the people who have paid the same licence as you have. Cooperation becomes a privilege extended by a third party, rather than a right held between equals.

This sounds absurd when we imagine it happening to physical infrastructure. We would never accept it for screws or rails or electricity. And yet the history of standards is also the history of attempts to do exactly this, resisted successfully in some domains and less successfully in others. The reason we have open standards for physical infrastructure is not that anyone thought them obviously good. It is that societies fought, sometimes for decades, to keep them out of private hands.

The ancestor question

There is a useful way to think about all of this, which is to ask what kind of ancestor we want to be.

Every time we accept an open standard, we are making a small bet on behalf of people who do not yet exist. We are saying that the thing we are building – the document, the product, the system – should remain accessible to them, even though we will not be here to help them open it. We are choosing to be hospitable to a future we cannot see. And every time we accept a closed one, we are making the opposite bet. We are saying that our successors will have to rely on the continued goodwill of a private actor to reach back to what we have made. We are outsourcing their access to our own lives.

This is not a technical question. It is a civic one, and it is also a moral one. Standards are how a society decides whether its own infrastructure should be owned or shared, whether its past should be accessible or licensed, whether its future should be open or gated. They look like engineering. They are really a quiet, continuous answer to the question of what we owe each other, and what we owe to those who come after us.

So the next time you plug something into a wall and it simply works – the next time a door handle fits, a page prints cleanly, a part slots into place without thought – consider for a moment what had to be true for that to happen. Consider who refused to own it. And ask yourself what kind of ancestor a closed standard lets you be.