Category: Open Document Format

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.

There is a sophisticated mechanism by which proprietary technology ecosystems maintain their grip on users and institutions, even when those users and institutions believe they are making free choices, using open standards, and building independent digital infrastructure.

The mechanism does not work through force, but through a subtler and more durable strategy: the layering of dependencies, in which each layer obscures the one beneath it, so that when the system fails the apparent cause is something other than the real one.

It is a structural pattern with identifiable components and predictable failure modes, and with a single political consequence: the systematic attribution of interoperability failures to open alternatives rather than to the proprietary dependencies that actually cause them.

Understanding all of this is essential for anyone working on a genuine interoperability policy, because without it even the best-intentioned policy interventions address the visible symptom while leaving untouched the larger problem of the underlying architecture, which goes on working exactly as designed.

The perception of malfunction

Let us start from the user’s experience, because this is where the political damage occurs.

A document is created in Microsoft Word and sent to a colleague who uses LibreOffice on a Linux desktop. The colleague opens the file. Something is wrong: a table has shifted, the text has reflowed, a font looks different, the page breaks have moved.

The experience is familiar to millions of people in institutional settings that have adopted, or are considering adopting, open source software. It is the experience that generates the helpdesk tickets, the emails of pure frustration to the IT department, the conversations that end with “can you just send me a PDF?”, and the broader sentiment, consolidating over time, that open source software is not ready for professional use.

What is the cause of this failure? Users will blame LibreOffice, IT managers will blame format incompatibility, policymakers will blame the immaturity of open standards.

These are all wrong answers. Or rather, they are all answers to the wrong question, because they describe where the failure manifests rather than where it originates.

The actual cause is a set of interdependent technical systems, each contributing a different failure mode, all producing a single visible result.

The format contains proprietary structures that only Microsoft’s implementation handles correctly. The rendering introduces platform-dependent variations that the format specification does not control. The proprietary fonts cannot be legally bundled with open source software.

Three distinct failure modes producing the same symptom, and equally invisible to the user, who perceives only that things worked in Word and do not work in LibreOffice.

This is the architecture of layered dependency. Each layer absorbs the causal chain and emits a different signal, one that points toward the open alternative.

Layer One: the format and its hidden features

The first layer is the most discussed and the most politically visible: the document format. The conflict between ODF and OOXML has been extensively documented, litigated within standards bodies, and debated in national parliaments and in the European institutions.

But even within this well-mapped terrain, it is worth clarifying the specific mechanism of obscuration at the format layer.

OOXML, the format Microsoft Office produces by default, exists in two conformance levels. Strict is a reasonably clean specification. Transitional is something categorically different: a format designed to encode the accumulated behaviour of earlier Microsoft Office versions, preserving decades of proprietary implementation choices as normative elements of an apparently open standard.

OOXML Transitional includes VML — Vector Markup Language, a proprietary drawing format from the late 1990s that predates and contradicts the DrawingML system defined elsewhere in the same specification.

It includes references defined as “as in earlier versions of Microsoft Office”, which make sense only if one has access to those earlier versions and to their undocumented implementation details.

It includes extensions that allow Microsoft to embed proprietary functionality in documents, invisible to non-Microsoft implementations, and capable of causing silent rendering differences ranging from minor visual variation to complete layout failure.

Crucially, OOXML Transitional is what Microsoft Office produces by default.

Every time a user saves a Word document without selecting a different format, they produce a file optimised for the Microsoft ecosystem and subtly hostile to every other.

Users do not know this is happening, because the choice is made for them at the format level, and when the document fails in LibreOffice, the format layer’s contribution to that failure is invisible. The user sees a rendering problem, not a format problem.

This is the first layer of obscuration: proprietary format constructs masked by the label “industry standard”, producing errors that appear to be implementation shortcomings in the receiving software.

Layer Two: rendering and its unspecified behaviour

The second layer is less discussed, less politically visible, and for these very reasons more durable as a source of interoperability failure: text rendering.

Document format standards specify content. They define what a document contains: text, structure, logical relationships, embedded objects, and formatting instructions.

What they do not specify, and what none of the major document format standards has ever specified, is how that content should be rendered. The translation of encoded content into visible glyphs on a screen or a page is left to the implementation, and different implementations make different choices.

These choices operate across several subsystems.

Shaping engines — the software components that translate sequences of Unicode characters into sequences of glyphs, and that handle the complex rules of scripts such as Arabic, Devanagari and Thai — differ by platform.

HarfBuzz, the open source shaping engine used by LibreOffice and by most Linux applications, produces correct, standards-compliant output, but that output may differ in detail from Windows’ Uniscribe or DirectWrite engines, particularly for complex scripts with context-sensitive glyph selection.

The differences are almost always invisible for Latin text, but for the non-Latin scripts used by a significant portion of the European public sector and citizenry, they can be significant.

Hinting interpretation varies across rendering engines. Fonts embed hinting instructions — algorithms that adjust glyph outlines for crisp display at low screen resolutions — but those instructions are interpreted differently by different renderers.

A font optimised for Windows’ GDI rendering engine may display with different weight and spacing under FreeType on Linux, even at identical sizes.

The differences are minute for any single character, but they affect the perceived quality of the text and contribute to the general impression that open source environments are slightly less polished.

Line-breaking and justification algorithms are the most significant source of rendering variation and the most direct cause of document reflow.

The algorithm that determines where to break lines — how to distribute words across a line of a given width, whether and how to hyphenate, how to handle justified text — is an implementation choice that no format specification regulates.

Microsoft Word’s line-breaking algorithm is proprietary and undocumented, and it is very different from LibreOffice’s. Both are legitimate implementations of the same function, and they can produce different line breaks; different line breaks mean different page breaks; and different page breaks mean that a document paginated in Word will not be paginated the same way in LibreOffice.

This is not a defect in implementation quality, but the normal and predictable consequence of differing rendering choices that document format standards do not define. And it produces errors that are invariably attributed to the software receiving the document, because that is where the visible difference appears, rather than to the specifications that are their cause.

The rendering layer is the most technically complex component of the layered dependency and the hardest to address, but it is also the layer that most clearly reveals the dimensions of the problem: an error generated by a different choice made by two projects, attributed solely to the open source software, on the basis of an entirely unjustified, almost faith-based trust in the quality of the proprietary software.

Layer Three: fonts and the dependency on proprietary resources

The third layer completes the picture and, in many practical settings, causes the greatest damage: fonts. Here we will not analyse font-level lock-in as such, but will instead explain how the font layer operates within the layered dependency model.

Fonts interact with both layers above. At the format level, fonts appear as named references: a document declares that the body text is set in Calibri and the headings in Cambria. If those two fonts are not available on the receiving system — and this is the case on every system for which a licence for the proprietary fonts has not been acquired — the software must substitute them.

Substitution changes the metrics, and the metrics in turn change the geometry. Altered geometry produces reflow, broken layouts, forms overflowing their margins; and here too the failure is attributed to the application receiving the document.

At the rendering level, fonts interact with the shaping engine, the hinting system and the antialiasing pipeline in ways specific to each font’s design and embedded instructions. A font optimised for the Windows rendering stack will display differently under FreeType, even before any substitution occurs, and this contributes to the overall visual divergence between environments.

What makes the font layer particularly effective as a lock-in mechanism is the combination of legal unavailability and the user’s lack of information. The proprietary fonts at the heart of the problem — Calibri and Cambria, and before them Arial and Times — are not available under any kind of open source licence.

This is a legal constraint that open source software cannot overcome, but one that users perceive not as a licensing problem but as a software problem — not as the consequence of a strategy but as proof that open source software cannot handle ordinary documents.

Only Aptos, the latest of Microsoft’s proprietary fonts, is released under a partially restrictive licence, since it ties use to a download from Microsoft’s site. It can therefore be installed by Linux users too, and used legally, but this has not been communicated widely enough, so the lock-in mechanism is only reduced, not eliminated.

Why “invisible” is the key word

Each of the three layers would be a manageable problem if it were visible, and if users had the chance to see clearly that the error originates in the proprietary format, or in the insufficient rendering specifications, or in the proprietary font. Visible problems can be addressed and solved on the basis of accurate diagnosis and targeted intervention.

The strength of this scheme lies in its obscurity. Each layer acts as a signal re-encoder: it takes the output of the layer beneath it and re-emits it as something that looks like a different kind of problem.

So the dependency on proprietary fonts produces an error that looks like a software rendering issue; the rendering problem produces an error that looks like an implementation shortcoming; and finally the proprietary format structure produces an error that looks like a failure to comply with standards.

By the time the error reaches the user, its origin is completely obscured, and responsibility is systematically redirected to the last element in the chain: the open source software, which was merely trying to display a document designed to defeat it.

This is not a coincidence arising from poor design.

Software that generated random errors would be a problem for the company that developed it, because user frustration would flow back toward the originating software.
A system that generates errors at the boundary with competitors, in such a way that they are always attributed to those competitors, is a competitive asset.

Here the question of intent matters less than the question of structure: whatever the motivation behind the original design decisions, the resulting architecture functions as a constraint, and its effects are observable and measurable.

How policy responded, and where it failed

The policy response to document lock-in has concentrated on the format: mandating the use of ODF and open formats in public procurement, and guaranteeing that government documents can be created and consulted without the use of proprietary software. Unfortunately, these interventions have almost never been paired with penalties to enforce compliance, and the rules have often been ignored.

Moreover, these format mandates have not addressed the use of proprietary fonts in document templates, so by fixing only the upper layer they leave the lower one exposed and fully operational, where it is less visible and less politically salient, and therefore more durable.

Documents continue to fail at the boundary with open source software, and users continue to blame the latter. The political will behind the format mandate is progressively eroded by user complaints about interoperability problems, which seem to contradict the promise of the open, standard format mandate itself.

An institution that deploys LibreOffice but fails to address rendering consistency — allowing a mixed infrastructure of Windows and Linux systems to exchange documents without recognising that rendering variation is not a software defect — risks creating an internal interoperability problem that could be used to justify a return to monoculture.

The rendering layer has received almost no policy attention. No major digital sovereignty framework specifies rendering-fidelity requirements. No procurement standard defines conformance in terms of visual consistency across implementations.

The tools to address this problem — reference rendering implementations, rendering test suites, fidelity benchmarks — exist only as prototypes or proposals, and have not been integrated into any serious policy framework.

Knowing this pattern is a political act

The invisible layering of dependencies is a pattern born of nearly fifty years of unregulated evolution of personal productivity software, and one that threatens to make the path toward digital sovereignty extraordinarily complex.

It matters to give the pattern a name, so that it can be used in policy discussions, in parliamentary questions, in procurement specifications and in the public debate on digital sovereignty, at every level, including by the media.

The invisible layering of dependencies connects phenomena that do not appear to be related — document format incompatibilities, rendering variation, font substitution failures — and shows that they are expressions of the same underlying architecture.

Once these phenomena are seen as a pattern rather than as isolated technical problems, an appropriate policy response becomes clearer, because it is not enough to fix a single layer and mandate a single standard — even though that is a fundamental first step.

It is necessary to make all the dependencies legible and to integrate them into interoperability policies that address format, rendering and fonts explicitly and specifically, with enforcement mechanisms applying to all three layers.

The open source and open standards community has built the technical foundations for genuine interoperability: open formats are mature and solid, open source applications are fully up to the task, and there are hundreds of openly licensed fonts, many of them metric-compatible with the proprietary ones.

The architecture of lock-in does not persist because the alternatives are inadequate. It persists because policy has not yet learned to look beyond the visible surface of format conformance and to recognise the underlying layers where proprietary dependencies go on operating — invisible and ignored — doing the work they were designed to do.