Richard Brock, Author at Collabora Online and Collabora Office

Distributed by Design: How Modern Open Source Works

Richard Brock — Mon, 30 Mar 2026 17:11:57 +0000

TL;DR
Modern open-source software isn’t built in one place or along a single path. Tools like Git enable independent development while preserving shared history, provenance, and open collaboration. This allows different organisations to move at different speeds, and supports long-term users without central coordination. Large projects such as the Linux kernel have long operated this way, combining decentralised development with shared standards and open code. What matters isn’t where development happens, but that users receive stable, secure, and openly auditable software that continues to serve diverse needs at scale.

Open source isn’t a single repository

There’s a mental model of a software repository as a single, central place where “the real code” lives, and everything else is somehow downstream of it.

In reality, open source today is a network of repositories, contributors, and workflows, connected by shared history and shared standards – not by a single gate.

And that’s largely thanks to Git.

A quick, practical explanation of Git?

Developed in 2005, Git is the system most modern open-source software uses to manage code.

At its simplest, Git answers three questions:

What changed?
Who changed it & when?
How does this relate to everything that came before?

But the important thing isn’t just tracking changes – it’s how Git enables collaboration.

Everyone has the whole project

With Git, every developer can have a full copy of the codebase on their own machine.

Not just the latest version – the entire history.

That means no single server is “the” source of truth, work doesn’t stop if a service goes offline, and it enables developers to work independently, offline, and in parallel
Each copy is complete and verifiable.

Work happens in many repositories

Instead of everyone editing the same version of the code at once, Git encourages work to happen on clones. There are many reasons for this, but essentially it enables developers to try new features and fixes on the code, without potentially causing disruption to others.

Copies can be short-lived or long-running, shared or private. They’re simple to create, easy to merge, and easy to discard.

Parallel development is the standard operating procedure.

Git makes independence normal - not exceptional

Git isn’t just a version control system; it’s a different way of thinking about collaboration.

With Git:

Everyone can have a complete copy of the codebase
Every copy usually includes the entire history, in a cryptographically linked chain
- This makes it extremely difficult to smuggle in malicious changes unnoticed. You can’t quietly rewrite the past – any alteration breaks this chain of links and is immediately detectable.
Every developer can work on their own code, at their own pace
A single developer can pull code from multiple remote sources
Code can flow between repositories, not just “up” or “down”

This is what makes Git a real powerhouse in the programming world. Each commit hash uniquely defines the full history up to that point and the entire repository state. Provenance is built in. Trust is verifiable. Collaboration doesn’t depend on a single server or a single workflow.

Built-in resilience and disaster recovery

One of the most overlooked strengths of Git’s distributed model is resilience. Because every clone is a complete copy of the project – including its full history – the future of the codebase does not depend on a single server, organisation, or hosting provider to survive.

If a hosting platform disappears, the project does not disappear with it. If a company changes direction, the code remains available. If infrastructure fails, development can continue from any full copy.

Traditional software vendors often rely on expensive source code escrow agreements as a safeguard in case a supplier collapses. With open-source software managed by Git, this protection comes baked into the technical architecture for everyone.

Disaster recovery is no longer a contingency plan, it is the default state of the system.

This resilience matters deeply for governments, enterprises, and long-term infrastructure projects. Software that underpins critical systems must not depend on a single point of failure – organisational or technical.

More forks than a restaurant ?

In some git-based development flows, the process of creating your own repository to work on new features and fixes independently is called forking.

On platforms like GitHub, it’s a prominent button at the top of the page because it’s a normal part of how distributed development works.

At the time of this screenshot for example, there were 978 forked copies of the Collabora Online source code – most of them made by developers eager to contribute back to the goodness – we love that!

Multiple remotes, multiple maintainers, multiple priorities, connected by shared code, shared history, bonds of friendship and collaboration powered by the Git synchronisation protocol. The choice of hosting and infrastructure becomes an almost irrelevant detail, with developers choosing the tools and processes that best support their work.

Improvements can be exchanged, and collaboration can happen without requiring everyone to follow the same internal processes or timelines.

At the same time, in ecosystems with many development paths, trusted editors play a critical role in curating, integrating, and supporting coherent, branded, secure releases.

This is how most large open-source projects already work

The largest open-source project in the world is the mainline Linux kernel.

While there is a widely recognised upstream integration tree, Linux development does not start in one place, nor does it follow a single linear path.

Most Linux code is written outside the mainline tree. Subsystem maintainers, vendors, researchers, and long-term support teams all develop in their own repositories, often with different goals, timelines, and constraints. Some of this work is later integrated upstream. Some of it remains long-lived and independent. Both are normal, accepted, and essential to how the ecosystem functions.

What people perceive as ‘Linux’ is usually a distribution kernel which is built not only from the mainline Kernel, but often includes a selection of drivers and updates and fixes maintained in many other Git repositories. This pattern is visible well beyond the kernel itself. Ubuntu is a long-running derivative of Debian. The two projects share a common foundation, diverge where their priorities differ, and regularly exchange fixes and improvements. They cooperate closely, but they are not trying to be the same thing, and both are excellent solutions for their use cases and target audiences.

This model of decentralised development, shared history, and open standards is what allows open-source projects to support different needs and directions without forcing a single pace or a single set of priorities. It’s how mature, secure software scales.

The outcome that matters

At the end of the day, this isn’t about repositories or hosting platforms.

It’s about delivering:

Stable, well-maintained software
Faster iteration where it matters
Long-term support users can rely on
Open-source code that remains open, auditable, and reusable

Independent development isn’t a departure from open-source values. It is how those values continue to work at scale.

So which repository do I use ?

Most organisations don’t want to build from source or track dozens of repositories. They want dependable releases: professionally built binaries, timely security updates, long-term maintenance, and stable leadership. What matters is having a version that is coherently integrated, responsibly maintained, and ready to deploy.

At the same time, open development thrives on participation. So if you want to contribute, follow the energy! Look at development pace, commit activity, responsiveness, and long-term sustainability. Join the project where work is happening, improvements are welcomed, collaboration is active, and you feel at home.

That’s the role we play with Collabora Office. In a landscape of many repositories and development paths, we provide a stable, security-hardened, professionally supported release – while keeping the door open for collaboration and contribution. Open source gives you the freedom to choose, we aim to be the choice you can build on.

The post Distributed by Design: How Modern Open Source Works appeared first on Collabora Online and Collabora Office.

You Are Not Sovereign If Microsoft Still Architects Your Documents

Richard Brock — Wed, 25 Mar 2026 15:37:53 +0000

Sovereignty or Legacy, You Choose

There is a lot of energy right now around European digital stacks. Self-hosted infrastructure. Local control. Reduced dependence on American cloud vendors. And all of that matters.

It seems to be a pattern that people take other people’s software that they have not written, and will struggle to support and put their brand on it, and wrap a European flag around it

But we should be honest about one thing – you are not sovereign if Microsoft still defines the fundamental design of your application, as well as your document formats.

You can move the server. You can change the branding. You can even swap out one vendor for another. But if the office layer at the heart of your stack is still at root built around Microsoft’s file formats, then they still set the rules that matter most. Your documents live inside a model you do not control, cannot meaningfully govern, and have no real power to shape.

That is not digital sovereignty. That is a hosting decision.

Self-hosting is not the same as sovereignty

A self-hosted office suite built around OOXML may reduce dependency on Microsoft 365 as a service. It may reduce exposure to American hyperscalers. It may tick some procurement boxes. But it does not solve the deeper problem – after all, you could do this with SharePoint 2019 till recently.

OOXML is Microsoft’s document model, standardised after the fact. Microsoft’s own documentation clearly describes .docx .xlsx and .pptx as formats to “support the features and behavior of Microsoft Office” while noting that ODF and Open XML reflect different application behaviours and feature sets. These are not neutral containers floating above the market, they reflect the architecture, priorities and direction of the organisations that created them.

That matters because formats are not just a way to save files. They encode the document model itself: what features exist, how layouts behave, how compatibility is judged, what gets preserved, and what gets lost. If you open an .odp presentation with the total slide count in the template in Microsoft PowerPoint, or save the file as a .pptx for example, PowerPoint and the .pptx file format simply throw away the information. If you want that feature back, good luck with the Microsoft support forums…

In short, if your strategy is to architect your software around Microsoft’s models, you can play with the UI styling and colours, but your product direction is being decided elsewhere.

You can call that interoperability, you can call it compatibility, for legacy workflows, it is certainly important and necessary. But you cannot call this strategy sovereignty.

OOXML is a legacy requirement, not a sovereign strategy

Realistically, organisations do need strong interoperability with Microsoft formats.

They exchange files with customers, suppliers, ministries, universities, courts, regulators, and partners, many of whom currently live in the Microsoft world. But the editing phase of a document’s life is usually very brief, even if it is to be archived for many years afterwards (for example the UK Healthcare Regulatory Agency mandates archiving medical records that are created in an afternoon for 25 years).

This is why moving forwards, OOXML should be treated as a legacy requirement, but it cannot be the foundation of a sovereign strategy. The strategic question is not whether you can open a .docx. Of course you need this. The strategic question is what format you want to build your future around.

If your answer is “whatever Microsoft does,” then you have not escaped the dependency – you are just reacting to it from a different server location.

A sovereign document strategy needs a format that is governed openly, developed through a genuine standards process, and not simply inherited from one vendor’s product decisions. That is where ODF matters. ODF is maintained through OASIS and published as an ISO/IEC standard. It is an open, international standard for text documents, spreadsheets, presentations, and graphics, developed through an open committee process. It is not “thrown over the wall” as the latest non-negotiable output of a single vendor’s decisions.

If you are serious about sovereignty, new templates, new internal workflows, and new documents should move towards an open standard you can actually participate in and build upon.

Old documents can remain old documents. They should be opened and rendered correctly, and archive formats like PDF and PDF/A remain important. Similarly, for the present time at least, external collaboration will continue to require excellent OOXML interoperability.

But new sovereign workflows should not be born dependent on Microsoft.

Don’t get confused by marketing

There is nothing wrong with saying a product has strong OOXML interoperability – we all work on it. The mistake is turning that into the main sovereignty story.

ONLYOFFICE, for example, leans heavily on this message. Its public materials describe its editor as using OOXML natively, with all files converted into the format “when opening and editing files”.

Quoting directly: “If the file format is different from OOXML, it will still be converted to the corresponding OOXML […] As the formats are fundamentally different, some data (such as charts, tables, autoshapes or images) and formatting can be lost due to the simple reason that some formats […] treat them differently than OOXML standard does.”

That’s great if you want to centre your digital strategy around Microsoft, but absurd as the centrepiece of a digital sovereignty pitch.

True interoperability is: “We can work with the legacy world.”

And true sovereignty says: “We won’t build our future around the proprietary past.”

If your product story begins and ends with how closely you follow Microsoft’s formats, then your roadmap is still architected by Microsoft.

Sovereignty is also about trust

Across the industry, buyers are starting to ask harder questions about where code comes from, who governs it, who controls the commercial rights around it, and whether the supply chain is something they can trust. So it is striking that some people seem willing to wave those questions away when it comes to the ONLYOFFICE code-base.

Public concern about the product’s Russian ties is not imaginary. TU Berlin for example announced that it was ending business relations with ONLYOFFICE and moving to Collabora Online, explicitly stating that, “ONLYOFFICE falls under the sanctions of the EU and Germany against Russia”.

Muddying the sovereign waters further, ONLYOFFICE’s own documentation states that ONLYOFFICE Docs Enterprise Edition is “distributed under a commercial proprietary license”. That alone should be enough for sovereignty-minded buyers to slow down and question their direction. What is open? What is closed? And what happens when the commercial incentives change?

Public campaign sites and community discussions have also pointed to the huge volume of Russian-language code comments, branding similarities with the Russian R7 Office suite, and a broader effort to distance the current commercial presentation from the project’s Russian history. Whether you agree with a national origin boycott or not, the underlying question raised seems fair – if buyers now care about provenance, why would they be relaxed about opaque or politically sensitive origins for such a critical layer of their document stack?

A serious sovereign strategy looks different

A serious sovereign office strategy is not anti-interoperability. It is not naive about legacy requirements, and it does not pretend the world can abandon Microsoft formats overnight.

It does something more serious than that. It supports legacy Microsoft formats, because reality demands it. It encourages ODF for new sovereign documents, because strategy demands it. And it chooses 100% open-source code, built in the open, for all to collaborate with – that strengthens independence rather than undermining it.

This is the real question for buyers evaluating office suites today. Not “Can it open a Word file?” Everyone can do that. But the harder and more important question is “Who defines the future of your documents?”

Where we stand

At Collabora Productivity, we are not confused about this.

Interoperability matters. Organisations need to work with Microsoft formats every day, and any serious office suite must support that reality. But sovereignty has to mean more than rendering the legacy world nicely, as we do.

It means open standards. It means giving organisations a path towards ODF for new documents and sovereign workflows. It means a platform built by a large, experienced team, in an open, friendly and welcoming community, and it means 100% open source code. Not open to a certain point, not open with strings attached, and especially not code controlled by countries hostile to free and open communications.

Don’t build on software endorsed by, and used by the Russian state and built around Microsoft’s file formats.

Free your documents today, with Collabora Office.

The post You Are Not Sovereign If Microsoft Still Architects Your Documents appeared first on Collabora Online and Collabora Office.

How Collabora Online Helps Integrations Build Safer Document Workflows

Richard Brock — Tue, 24 Mar 2026 16:58:47 +0000

When organisations talk about secure document handling, the conversation often jumps straight to infrastructure, hosting, and technical architecture. Those things matter, but they are only part of the picture. Security depends just as much on what users are able to do inside the document workflow.

For integrators building platforms for governments, education, legal teams, healthcare providers, or any other organisations handling sensitive information, secure editing is not just about opening a file securely. It is about keeping control of review, access, approval, and sharing inside the environment you manage.

This post aims to outline how the user-facing features of Collabora Online further strengthen the story for our partners and integrations. We will have another piece coming out soon about how the architecture of Collabora Online keeps documents secure.

Protect

Some of the most important security features are the simplest ones: preventing the wrong change in the wrong place.

The simplest way to achieve this is to impose read-only access over some documents. Complimenting read-only control, Collabora Online also offers restriction of specific commands such as copying or printing documents. Unlike other document editors however, Collabora Online enforces these controls at the server side[link owasp blog], helping ensure that restrictions are not just cosmetic interface choices. Combined with another server-enforced option of watermarking documents with user-specific details (not merely pasting ‘Confidential’ wording over the document), integrators and their end-users enjoy meaningful protection of the editing of documents, especially relevant in larger organisations to add confidence documents aren’t being downloaded or shared en-masse.

In many cases however, it is useful for users to be able to edit some parts of documents, but not others. In spreadsheets, features such as cell protection and sheet protection help teams preserve the integrity of critical information. That matters in budgeting, reporting, procurement, and operational planning, where some users may need to input or review data without altering formulas, structures, or approved sections. In practice, this helps turn a spreadsheet from a loose working file into a more controlled business document.

In written documents, section editing with optional password protection for individual paragraphs or longer ‘sections’ achieves the same goal. With section editing in Writer, the inverse may also be achieved such that sections in read-only documents can be made editable if needs be.

Control

Secure editing however is not about universally blocking change. It is about making sure the right people have the right level of access at the right time.

This is where platform integrations really matters. Integrating with Collabora Online, partners can enable custom per-user, per-document permissions, secure sharing controls, and granular guest access without breaking the connection between editing and the wider content system. The strength here is not that Collabora Online adds an additional control model to the storage platforms, but that it fits into it. Thanks to the WOPI-like protocol, permissions remain tied to the environment that already governs the document, instead of being redefined in the document editor.

Sensitive personal information, HR records, procurement documents, legal drafts, or citizen case files should not need to leave the managed environment just to be edited or reviewed. The more steps, services, and exports involved, the harder it becomes to maintain control. Collabora Online helps partners offer a cleaner model – keeping the workflows centralised, and access policy in one place.

Review

Because accountability is a security feature too.

In Writer, per-user tracked changes make it much easier to understand who changed what, and when. Changes are not only highlighted in red, but are tracked on a per-user basis. Each user has their own colour, and mousing over the change will show you who made the addition or deletion, and when. For review-heavy workflows, that is not just helpful for collaboration, it seriously strengthens auditability. In contracts, policies, internal approvals, and public-sector drafting, teams need a clear record of proposed edits and editorial responsibility. Named changes help make the review process visible rather than opaque.

Our newly released document comparison tool adds a further powerful layer here. Being able to compare two documents, and immediately highlight differences is invaluable anywhere precision matters, but especially in legal and contract workflows. Instead of relying on manual checks or trusting that nothing has been altered between versions, users can now see exactly what has been changed.

Version history also contributes to this broader accountability story. With the integration’s file storage layer and Collabora Online working in tandem, this is an important part of the overall secure workflow that integrators can offer end-users. Together, these powerful review features create a much stronger review chain most competitors can offer.

Signing

Unfortunately, document signing is one of the clearest examples where secure workflows break down.

Many organisations now end up sending all of their most sensitive documents to a third-party signing service, adding an additional storage layer (and jurisdiction?), another vendor relationship, and ending any on-premise or data-sovereignty promises (where is your document signing platform based?) Built-in PDF signing based on a document hash and not it’s content – directly from your document editor offers a better path. It allows integrators to support signing inside the document workflow rather than handing documents and data to someone else.

That matters for both privacy and process. Sensitive agreements, approvals, and public-facing forms should not be exported into a disconnected workflow just to get a signature. It also helps organisations simplify compliance-sensitive processes by reducing unnecessary exposure and keeping the entire document lifecycle within the integrator’s own platform.

Why this all matters for integrations

For integrators, the opportunity with Collabora Online is bigger than adding online editing (this is of course already a significant step!).

Collabora Online helps partners and integrators build secure workflows around documents by combining familiar editing with practical controls. Protection inside of documents, accountable review of changes, server-enforced access controls, integrated signing, and permission-aware access through open interfaces. For government and regulated sectors in particular, this is far more compelling than other editing experiences.

Secure document handling is not just about where software runs and the technical architecture. It is just as much about whether the features inside the editor help organisations and users stay in control. That is what customers increasingly need, and it is where Collabora Online gives partners a strong and secure story.

Integrate Collabora Online today, and secure your workflows.

The post How Collabora Online Helps Integrations Build Safer Document Workflows appeared first on Collabora Online and Collabora Office.

FLOSS FOSS OSS? Open Source Explained

Richard Brock — Fri, 06 Mar 2026 15:26:36 +0000

Confused by buzzwords? You’re not alone.

EXPLAINED is a new explainer series for people who work with technology – but don’t want marketing fluff or academic theory.

We break down complex digital topics clearly and practically: what they mean, why they matter, and how they work in the real world.

Open Source Software is software whose source code is publicly available to use, study, modify, and share.

That sounds simple — and it is — but the consequences are anything but.

Open source shapes how software is built, who controls it, how long it lasts, and who gets a say when things change.

FLOSS, FOSS, and why words matter

You’ll see a few acronyms used almost interchangeably: FOSS, FLOSS, or just OSS.

They all point in roughly the same direction, but with slightly different emphasis.

OSS: Open Source Software
FOSS: Free and Open Source Software
FLOSS: Free/Libre and Open Source Software

We tend to prefer FLOSS, because it makes something explicit that often gets lost: free doesn’t mean price.

A side note: Capital Letters and Hyphens?

That depends on who you’re asking! The CERN Open Source Program Office has a nice style guide write up here in favour of hyphens when used as a compound adjective (eg. open-source hardware, open-source software), the Open Source Initiative however recently published an opinion piece arguing it should in fact never be hyphenated. The Microsoft style guide argues for hyphens and lower case (unless being used as part of a pronoun), or you can talk to our CEO who will tell you it should always be capitalised. We’ll let you choose this one…

“The nice thing about standards is that there are so many of them to choose from.” — Andrew S. Tanenbaum

Free as in freedom, not free as in beer

Open source is “free” in the sense of freedom, not cost (but it might be that as well).

The freedom to:

run the software for any purpose
understand how it works
modify it
share it with others

You can (and often do) pay for open source – for support, hosting, updates, or guarantees. What you don’t lose is your ability to understand the code behind it or leave.

That distinction turns out to be crucial.

How much technology is running on open source?

A lot.

A 2024 Synopsis report showed that 96% of the commercial code bases they sampled contained open source software, and 77% of the code within those code bases was open source. Further research suggests Linux is used by around 60 % of all websites where the OS is known and is the majority of workloads in Microsoft Azure cloud. Measurements also show that open-source web servers like Nginx and Apache make up 70% of the web server landscape.

[insert pretty pie charts]

It’s not because it’s trendy, but because:

it scales,
it lasts,
and it can be trusted by people who need to look under the hood.

Open source isn’t the alternative – for most use cases it’s the default.

If it’s open, how does it stay open?

Open source stays open because of licences. These legally enforce the freedoms that define open-source software and ensure that improvements can’t simply be taken private and locked away.

That legal backbone is what allows open-source projects to outlive companies, products, and even entire technology cycles. Open-source licenses however is a First Principles topic for another day!

But how do businesses make money?

People pay for open-source software because it delivers value, and because someone needs to be accountable when it matters.

Generally speaking, open-source companies don’t sell access to the source code. They sell the things organisations actually need in the real world: professional support, long-term maintenance, security updates, predictable releases, enterprise integrations, and help when something goes wrong at 5pm on a Friday.

Just as importantly, many organisations choose to pay because they want the software to stay open, and to have a product management discussion with the developers behind it. They know that sustainable, well-maintained open source doesn’t happen by accident. It happens when skilled teams are paid to work on it full time.

Anyone can support an open-source deployment. That’s the point. In practice however, organisations choose to pay the people who know the software best and contribute to it every day.

Solutions like Collabora Online follow exactly this model: open-source code, open standards, and commercial services wrapped around them so organisations can rely on the software in production. Customers aren’t buying access or exclusivity – they’re choosing expertise, continuity, and a team they trust to keep the software healthy.

That’s not a contradiction of open source. It’s how it works.

Is open source more secure?

Often, yes – but not magically.

Open source benefits from transparency. Code can be audited, vulnerabilities can be found by anyone, and fixes aren’t limited to a single vendor’s timeline. That doesn’t mean bugs don’t exist; it means they’re harder to hide, and anyone can fix it.

As an added accountability layer, as an engineer, your name is on every commit, in perpetuity – so you’re somewhat more careful!

The trade-off nobody mentions

Open source gives you freedom, but it also expects engagement.

Behind most successful open-source projects are vibrant communities: developers sharing ideas, reviewing code, and improving the software in the open. That energy is one of open source’s greatest strengths. But for many organisations, especially those with compliance, security, or regulatory requirements, relying directly on community development can feel like a leap.

This is where professional open-source companies come in. They act as a bridge between fast-moving global communities and organisations that need stability, accountability, compliance and predictable releases. They package the innovation of the open-source ecosystem into something businesses can confidently deploy and support.

So what’s the point?

Open source isn’t simply about ideology or getting something for nothing.

It’s about building software that can be trusted, understood, improved, and relied upon over time by users, organisations, and entire societies. Without it, you’re relying on trust you can’t verify.

If you’re interested in taking back control of your documents, contact us today.

The post FLOSS FOSS OSS? Open Source Explained appeared first on Collabora Online and Collabora Office.

Customers Deserve a Choice: Cloud or On-Prem

Richard Brock — Mon, 02 Mar 2026 11:19:36 +0000

In this episode of Open Matters, Richard Brock speaks with Johan Bernhardsson from Redpill Linpro, one of the Nordic region’s leading open-source consultancies. Johan shares what real-world migrations look like: from replacing aging NAS drives with Nextcloud to building GDPR-sensitive collaboration platforms, and helping organizations move at their own pace.

We discuss:

-Why “cloud-first” often means “no real choice”
-How open-source migrations actually begin
-Why user experience matters more than features
-The growing demand for on-prem and sovereign deployments
-And why digital change is still slow — but accelerating

If digital sovereignty is more than a slogan, this is what it looks like on the ground.

Subscribe for more discussions on open-source tech!
iTunes: https://podcasts.apple.com/us/podcast/open-matters-podcast/id1807042369
Spotify: https://open.spotify.com/show/4frqRzV9DsAC0HfJ3ewaeD
RSS: https://www.collaboraonline.com/feed/mp3/

The views and opinions expressed in this podcast are those of the hosts and guests and do not necessarily reflect the views of Collabora Productivity or its affiliates. The content is provided for informational purposes only and should not be considered official guidance or fact-checked technical documentation.

The post Customers Deserve a Choice: Cloud or On-Prem appeared first on Collabora Online and Collabora Office.

Who Has the Keys to Your Data?

Richard Brock — Tue, 24 Feb 2026 13:20:18 +0000

The Uncomfortable Truth About Microsoft Customer Lockbox

There is a question that every organisation storing data in Microsoft 365 should be asking, but most never do: can Microsoft access your files, emails, and documents without your knowledge or consent?

The answer, by default, is yes – and Microsoft will even sell you a feature to do something about it.

What Is Customer Lockbox?

Customer Lockbox is a Microsoft 365 feature that gives organisations the ability to explicitly approve or deny access requests from Microsoft support engineers before they can view customer content. When a Microsoft engineer needs access to your data to investigate a support issue, a notification is sent to your administrators, who must approve the request. If they don’t respond within the time window, access is denied.

On the surface, this sounds perfectly reasonable. But step back for a moment and consider what this feature’s very existence implies.

The Feature That Should Never Have Been Necessary

Customer Lockbox exists because, without it, access to your data is governed entirely by Microsoft’s own internal policies and processes – not by you.

Microsoft’s standard position is that it operates on a “Zero Standing Access” principle: engineers don’t have persistent access to customer data, and access is granted on a just-in-time, least-privilege basis. That sounds reassuring. But here is the critical distinction: those controls are Microsoft’s controls, not yours. The gatekeeper is the same organisation that also wants access to your data. You are not in the room when that decision is made. You may not even be notified that it happened.

Customer Lockbox changes this by adding the customer as a required approver. It shifts the control point from Microsoft’s internal process to your organisation’s administrators. In other words, it gives you the ability to consent.

Consent however shouldn’t be a premium feature.

That Microsoft has packaged the ability to approve access to your own data as an optional add-on – available only to customers willing and able to pay for it – tells you a great deal about how the company thinks about data privacy.

Who Can Afford Privacy?

Customer Lockbox is bundled with Microsoft 365 E5, the highest and most expensive enterprise licensing tier, or available as part of the Microsoft 365 E5 Compliance add-on. For the vast majority of organisations – small and medium businesses, schools, non-profits, public sector bodies operating on constrained budgets – it is simply out of reach.

This creates a two-tier privacy landscape. Large, well-resourced enterprises can buy some oversight* of their own data. Everyone else accepts whatever Microsoft’s internal policies happen to say on any given day.

This should be deeply uncomfortable. Data sensitivity is not proportional to the size or wealth of the organisation holding it. Healthcare providers, legal services, schools small and large and everything in between all handle highly sensitive and personal data. They should be accessing the same level of control over their data as a Fortune 500 company. The idea that of data sovereignty as a luxury good is not a neutral business decision. It is a statement about whose privacy matters.

*The Lock Microsoft Will Always Open

The CLOUD Act (Clarifying Lawful Overseas Use of Data Act), passed in the US in 2018, allows US law enforcement to compel US-headquartered companies – including Microsoft – to produce data stored on their servers, regardless of where in the world that data physically resides.
Customer Lockbox does not protect against this. Customer Lockbox governs Microsoft engineer access for support and operational purposes. It has no bearing on legally compelled government disclosure. Microsoft can be required to hand over your data without notifying you, without your consent, and potentially under a gag order that prevents them from telling you it happened.
Microsoft is a US company. No matter where your data is hosted – including EU data centres – it remains subject to US jurisdiction through the CLOUD Act.

Privacy Should Be the Default, Not a Product

The deeper issue here is one of design philosophy. A company that genuinely places privacy at the centre of its product decisions builds oversight, transparency, and consent into the default experience. It does not reserve these things for paying subscribers.

Our approach at Collabora Productivity is rooted in a different set of assumptions. Our products are built on open-source foundations, designed for self-hosted deployment, and architected so that your data stays where you put it – on infrastructure you control, with access policies that you define. We don’t provide a back-door support channel through which a third party can request access to your documents. There is no premium tier required to retain meaningful sovereignty over your files.

Because that is what software should look like when the organisation building it genuinely thinks privacy matters.

What You Can Do

If you are using Microsoft 365, it is worth understanding exactly what tier you are on and whether Customer Lockbox is available to you.

More broadly, we would encourage organisations to ask harder questions of any cloud platform they use:

Who can access our data, and under what circumstances?
Do we receive notification when that access occurs?
Do we have the ability to approve or deny it?
Is that ability included as standard, or is it something we have to pay for?

And if you’re not sure about any of the answers, get in touch with us to experience a truly customer-centric, privacy-respecting office suite.

The post Who Has the Keys to Your Data? appeared first on Collabora Online and Collabora Office.

Digital Sovereignty Explained

Richard Brock — Thu, 19 Feb 2026 17:01:27 +0000

Confused by buzzwords? You’re not alone.

EXPLAINED is a new explainer series for people who work with technology – but don’t want marketing fluff or academic theory.

We break down complex digital topics clearly and practically: what they mean, why they matter, and how they work in the real world.

Digital sovereignty is the ability to make independent, enforceable decisions about your digital infrastructure – without being forced by vendors, platforms, or jurisdictions you do not control.

This might include but is not limited to:

Where your data lives
Who can access it
What laws apply
What happens if a vendor changes terms, pricing, or strategy
Whether you can realistically switch providers

Crucially, it is not:

A synonym for “on-prem”
A rejection of cloud technologies
A nationalist or isolationist idea

It is about control and choice.

Why digital sovereignty is suddenly everywhere

Because the ground shifted.

Over the past few years, digital sovereignty has moved from policy papers into the headlines. Court rulings, sanctions, sudden service withdrawals, and changes to data-access rules have all served as reminders that digital infrastructure is never neutral. Software and services are governed somewhere, data is subject to someone’s laws, and platforms ultimately answer to jurisdictions – not users. For many organisations, this has turned digital sovereignty from a theoretical concern into a deeply practical one.

A handful of large platforms now sit underneath email, documents, identity, storage, and collaboration. For governments especially, this raises an awkward question: can you really run public services on infrastructure you don’t control and can’t easily change?

What digital sovereignty is not?

Digital sovereignty is often misunderstood, partly because it increasingly gets used as a catch-all for very different concerns.

It does not mean rejecting the cloud, going back to on-prem-only infrastructure, or pretending global technology markets don’t exist. It is also not about nationalism with server racks, or building everything yourself from scratch.

At its core, digital sovereignty is about maintaining the ability to decide, even when vendors, markets, or regulations change. If your choices disappear the moment circumstances shift, sovereignty was never really there.

Where sovereignty actually breaks

Loss of digital sovereignty is rarely dramatic. There’s no single switch that gets flipped. Instead, it erodes quietly, layer by layer.

It might start with data that technically belongs to you, but only works properly inside one ecosystem. Or software that looks interchangeable on paper, but in practice only runs where the vendor allows it to. Sometimes it’s integration: “open” APIs that turn out to be undocumented, unstable, or strategically limited.

Deployment choices matter too. When SaaS is the only option, control over updates, lifecycle, and availability inevitably moves elsewhere. You don’t have to lose control everywhere for sovereignty to fail – losing it in one critical layer is enough.

Where open source helps

Open source is one of the strongest foundations for digital sovereignty.

Access to source code enables transparency, auditability, and long-term access. It reduces the risk of being locked out of your own infrastructure and makes it possible to change direction later.

Just as importantly, open-source solutions are built and maintained in the open by global, distributed communities and companies. Development happens in the open, improvements are shared publicly, and progress can be tracked directly – down to individual commits in a public repository. That openness is a powerful counterbalance to closed platforms and opaque decision-making.

Solutions such as Collabora Online and the many integrations and partners we work with combine these open-source foundations and open standards with professional support and flexible deployment options – including self-hosted and sovereign cloud environments. That combination is what turns theoretical freedom into something usable.

The trade-off nobody mentions

Organisations that prioritise sovereignty gain clearer exit options, stronger compliance positions, and more predictable long-term costs. In return, they accept that not everything is a black box handled by someone else.

So what’s the point?

Digital sovereignty is not about developing everything in-house, choosing national software providers, or hosting everything in your own underground vault. It’s about being able to choose your tools, understand your systems, and change course when needed.

If you’re interested in taking back control of your documents, contact us today.

The post Digital Sovereignty Explained appeared first on Collabora Online and Collabora Office.

WOPI Is Open. Your Office Stack Should Be Too.

Richard Brock — Wed, 11 Feb 2026 11:00:02 +0000

Web Application Open Platform Interface (WOPI) is a REST-based protocol originally developed by Microsoft to enable web-based document editing between third-party applications.

It’s the “plumbing” that connects document storage systems (such as Microsoft SharePoint, file servers or cloud storage) with online office suites for seamless editing experiences. Microsoft created WOPI in 2012 as part of its transition to cloud-based Office 365. (For a more light-hearted run through this topic, check out this post!)

WOPI abstracts document storage from editing applications and defines standardised ways for incorporating:

Authentication: Between storage systems and office applications
Metadata exchange: File properties, user permissions and capabilities
Storage operations: Load, Save, Save-As, Locking
Session management: For concurrent user editing

The protocol handles authentication, file metadata, content retrieval, conversion and saving. Everything needed to edit documents is stored in one system using editing tools from another system, so it enables an office editing platform to access documents without requiring direct access to the storage system.

A Sovereign WOPI?

While WOPI is often associated with Microsoft’s cloud-operated Office Online services, the protocol itself does not require vendor-controlled infrastructure. Collabora Online demonstrates how a WOPI-like protocol can be used with private cloud, sovereign cloud, or on-premise deployments, without introducing external service dependencies.

1. Data Sovereignty

Collabora Online runs entirely within infrastructure you control – whether on-premise, private cloud, or a sovereign public cloud provider. Documents, editing operations, and user metadata remain within your chosen jurisdiction and administrative domain at all times.

2. Open Source Foundation

All of Collabora Online (our WOPI-like protocol and document editor) is fully open source and auditable. This includes request handling, permission evaluation, document lifecycle management, and save semantics – allowing organisations to verify behaviour, meet regulatory requirements, or adapt integrations to local policy.

3. No Telemetry

Collabora Online does not require telemetry, analytics callbacks, or external service connectivity. The integration can function entirely within the deployment environment, including in restricted networks and regulated environments where outbound connections are prohibited.

Migrating Without Disruption

Lowering Risk Without Breaking Existing Workflows

Migrating an online office solution is often perceived as high risk – particularly where document locking, synchronisation, and existing integrations are involved. Collabora Online is designed to minimise that risk by maintaining WOPI compatibility while addressing common pain points encountered in real-world deployments.

At its core, Collabora Online can act as a drop-in WOPI-compatible editor, allowing organisations to migrate editing workloads without changing storage platforms, user workflows, or integration patterns.

Safer Locking for Sync-and-Share Environments

Traditional file-locking mechanisms often conflict with modern file sync and share systems, particularly during collaborative editing or partial migrations. Our solution eliminates traditional file-locking mechanisms that conflict with standard file sync and share patterns, instead using timestamp-based conflict detection and auto-expiring lease-based locks.

Fast Integration With Existing Systems

For teams integrating Collabora Online into custom platforms, implementation effort is deliberately kept low. A basic WOPI integration is very fast, with supported SDK examples available for common environments including Node.js, PHP, Python, React, and .NET.

In addition, we have a list of available full production-grade integrations, including Drupal and WordPress integration, in the SDK.

Node.js example – integrating COOL via iFrame in Node.js. (Requires familiarity with npm and the node.js framework.)
PHP example – integrating Collabora Online via iFrame in PHP. Note: Apache Web Server must be installed on the host machine and started. Also requires PHP module for Apache to be installed and loaded.
Python example – A simple example integrating Collabora Online via iFrame in Python. (Requires familiarity with Python and Django framework.)
ReactJS example – A simple example integrating Collabora Online via iFrame in ReactJS and Express. We assume you are familiar with ReactJS, npm and node.js framework.
.NET example – A simple example integrating Collabora Online via iFrame with .NET backend.

More Than a Like-for-Like Replacement

While Collabora Online can be introduced as a direct replacement, its WOPI-based integration also enables additional capabilities that organisations can adopt incrementally. These include document conversion APIs commonly used for previews, richer configuration options, and integration with open-source tools such as Zotero for citation management.

These enhancements do not require changes to document storage or access models, allowing organisations to extend functionality after migration rather than during it.

Secure Viewing for Secure Sharing

While Collabora Online provides many integration features through its WOPI-based APIs, it shares pixels of documents – rendered tiles, to another user’s screen and not the document itself. In addition, the pixels can be further secured by including server-side watermarks, which may include the name of user viewing the file for example. Collabora Online does not store any of the data itself.

Real-World Migration Case Studies

Dutch Education and Research (SURF)

From: Microsoft Office Online + various storage requirements
To: NextCloud + Collabora Online
Result: ~100,000 users, complete data sovereignty, significant cost reduction

SURF, the Netherlands education and research network, exemplifies large-scale success with 100,000 users across 59 institutions processing 850GB of data daily with 21 new users added continuously. This deployment replaces traditional commercial alternatives while providing superior security and data control.

University of Lille

From: Mixed Microsoft/Google environment
To: Nextcloud + Collabora Online
Result: 70,000 users, standardised tooling, enhanced security

The University of Lille serves 70,000 users (67,000 students and 6,300 staff) through Nextcloud integration, achieving standardised office tools across diverse IT cultures. “The University is really aiming at facilitating open standards across the whole campus,” IT Director Cédric Foll.

German Federal Government

From: Microsoft 365
To: openDesk (sovereign cloud + Collabora Online)
Result: Digital sovereignty compliance, reduced foreign dependency

Recently the German federal government launched the openDesk initiative to migrate from Microsoft 365 to a sovereign digital workplace combining Collabora Online, Nextcloud, and other productivity applications.

Break Vendor Lock-In Without Breaking Your Stack

Collabora Online provides a clear path away from Microsoft dependency while preserving familiar workflows, integration patterns, and operational models. By building on Microsoft’s own open WOPI protocol, organisations gain the freedom to choose an interoperable editor without rewriting their storage, identity, or collaboration layers.
For CTOs evaluating long-term strategy, Collabora Online’s WOPI implementation offers a rare and practical combination:

Compatibility with existing Microsoft-based workflows
Independence from vendor-controlled cloud services
Predictable cost savings through open-source economics
Security and compliance through self-managed deployment

If reducing platform risk, cost exposure, and dependency is part of your roadmap, Collabora Online enables migration on your terms – incrementally, safely, with long term flexibility built in.

Contact us today to discuss how office migration can transform your workflows and position your organisation for continued success. Visit collaboraonline.com or contact our engineering sales team at hello@collaboraoffice.com to explore your opportunities.

The post WOPI Is Open. Your Office Stack Should Be Too. appeared first on Collabora Online and Collabora Office.

Why the Best Online Office Doesn’t Try to Store Your Files

Richard Brock — Wed, 11 Feb 2026 10:59:58 +0000

Keep your storage. Upgrade your editing.

If you’ve ever wondered whether Collabora Online is a “cloud drive”, the simple answer is no. We are focussed on making the best document editor possible, and don’t handle document storage.

For document storage, we integrate beautifully with Enterprise File Sync & Share solutions (EFSS). If you are more technically minded, and want a more in-depth look at how we do that, check out this post, but for a more light-hearted run through, read on here…

Collabora Online is a kitchen. It’s where the work happens – chopping, mixing, frying, baking. Rendering, editing, tracked changes, comments, styles, spreadsheets, presentations and formulas. The process of making beautiful and powerful documents happens here.

Your Enterprise File Sync & Share solution is the fridge (a really smart fridge). Nextcloud, OpenCloud, Seafile, SharePoint, etc. The fridge handles storing what you’ve made, plus who can open the door: access control, sharing links, retention policies, DLP, all that operational goodness. (OK OK! – most modern EFSS solutions do way more than storage. Our partners and integrators are doing awesome things with video-calls, calendars, email, projects management etc. But no one has invented a fridge/dishwasher/smoke-alarm/100-seater dining table combo yet, so we’re going to stick with the fridge analogy for now!)

You don’t cook in the fridge, and you don’t keep food out on the kitchen worktop.

Collabora Online runs in stateless containers by design: we open what your EFSS hands us, let you create your masterpiece, and continuously sync changes back to your EFSS – no long-term storage in the editor. The sharing uses a WOPI-like communication standard making sure the fridge and the kitchen speak the same language. If you want a new fridge? No problem! Bigger, smaller, one of the models with an integrated ice-cube dispenser? No problem. You use what works for you, and we make the rest of the kitchen fast, reliable, and a joy to cook in.

But surely Microsoft does everything right?

It’s undeniably convenient when your editor, storage, chat, meetings and identity all live under one roof. That tight integration is a big reason many people don’t realise there’s a difference between SharePoint/OneDrive (storage/EFSS) and Office for the web (the editor). For many teams, “It’s all Microsoft” just… works.

The trade-offs show up when you need choice and control.

Where your fridge lives. Microsoft’s cloud is, by default, their cloud. If you need data-hosting choices, on-premise hosting, or jurisdictional control, the options narrow quickly – especially now that Office Online Server (the self-hostable web editor) has an end-of-support date and no like-for-like on-prem replacement1, forcing organisations to Microsoft 365’s cloud services. If you want control over where you keep your food, this is a problem.
How extensible the experience is. In a closed ecosystem you inherit one vendor’s timeline and guardrails. If you want a particular governance stack, a specific link-sharing model, unusual retention, or to keep everything on your own infra, you’re often choosing between “do it their way” or “don’t do it.” By contrast, Collabora Online’s model is designed to sit inside your architecture. We are a software developer, not a cloud service – making bundling easy. We also offer 3 years’ LTS for each release [link to recent blog] so you upgrade when you’re ready, not when we say go.
All-in-one stacks bolt the kitchen to the ground. Collabora Online is different: if you want, we can even be a moveable food truck, we’ll cook documents from whichever fridge (EFSS) you prefer (or even multiple EFSS’s!). Running in stateless containers, means not only your files, but all your settings stay in the EFSS, so you can deploy wherever it makes sense – on-prem, your private cloud, multi-cloud, even air-gapped – without refitting your storage.

Keep Cooking When Clouds Go Cold

And that’s all before we start talking about the associated problems with vendor lock-in. Long story short – throwing all your eggs in one basket (especially a basket you rent and aren’t allowed to move) isn’t usually a good idea.

So what’s “missing” in an all-in-one world? Not missing features in the editor per se (although there’s plenty missing from Microsoft’s online editor) but rather missing options for how you deploy, store, and govern.

A 60-second WOPI explainer*** (no handshakes, promise)

Think of WOPI as a kitchen–fridge conversation:

Your EFSS (WOPI host) invites the editor with a short-lived token and a “please open this file” URL.
Collabora Online (WOPI client) opens the document, renders it, and when you edit, calls back to the EFSS’s endpoints to read/write.
Identity, permissions, and audit stay with the EFSS, the editor focuses on editing.

If your fridge speaks WOPI, our kitchen cooks.

What does this mean in practice? No download-save-reupload dance, no losing track of whether DocumentName_v003_FINAL_printthisone.docx is the one to email to your client. You click on a file in your EFSS, the file opens in the same browser window, while all the syncing magic happens behind the scenes.

*** This is hugely simplified, but hopefully you get the idea! Want more of the nuts and bolts later? Check out this post or have a look at our SDK.

Make Your Sysadmin Happy

Sysadmins get a simple life: our architecture scales beautifully, rolls through updates cleanly, and doesn’t hoard storage. We even have a kubernetes controller making 10,000+ user deployments easy to manage (because some people have really big kitchens!) Storage, identity, logging and retention stay where policy says they belong – inside the EFSS. And if you need long-term support, we publish multi-year LTS so you upgrade on your schedule, not because someone else’s roadmap says so.

A Solution that Works For You

Putting everything under one roof can feel tidy – but it also means your users have no choice. As an EFSS vendor, OEM’ing Collabora Online gives you a self-contained “kitchen” that slots cleanly into your platform, looks like your brand, and deploys anywhere (on-prem, your cloud, their cloud). You keep ownership of storage, identity, sharing, and roadmap, we bring the editor that users expect without dragging you into the years-long grind of office compatibility and performance engineering.

A partner that respects your business

EFSS looks simple on the surface, but it isn’t! Authentication, multi-tenant storage, replication, retention, legal holds, link policies – that’s a seriously full-time project. Office editing is its own craft too – and it’s the one we focus on. Rather than everyone building mediocre/buggy “all-in-one” solutions we are staying out of the EFSS market and make the best document editor we can. The result: a faster time-to-market, fewer moving parts to support, stateless containers that scale with your needs, multi-year LTS so upgrades fit your cadence, and a team that ships features your customers will love. All the while you keep control of the customer relationship and the business value you’ve already built.

Try it now

Give Collabora Online a go with our free trial. Or if you’re feeling technical, try pointing Collabora Online at your EFSS, open a file, and enjoy working!

The post Why the Best Online Office Doesn’t Try to Store Your Files appeared first on Collabora Online and Collabora Office.

Collabora Productivity contributions in LibreOffice 26.2

Richard Brock — Thu, 05 Feb 2026 14:42:13 +0000

For over 12 years, Collabora Productivity has been privileged to work as one part of a broader community of enthusiastic developers, both volunteers and paid, collaborating to make an open source office suite that is free to download and trusted by millions of users.

The LibreOffice codebase is the foundation of Collabora Online, our enterprise, document-editing and online collaboration product – and as long-standing members of the community, we are excited to contribute to LibreOffice releases with 26.2 available today!

Our contributions

With the merger with allotropia software GmbH in May 2025, our commits to the codebase for 2025 (from January to the end of December), as per The Document Foundation’s State of the Project 2025, amounted to around 45% of the total commits from over 50 individuals. While Collabora Productivity is part of a global community of committers, we were fortunate enough to be able to contribute more than half of the documented features from the release notes for LibreOffice 26.2. In terms of total commits, this amounted to around 2,000, but, more importantly, fixed over 500 issues (including commits merged from 25.8 to 26.2.02). The chart shows the feature areas from the release notes where Collabora engineers contributed code.

Improvements in LibreOffice 26.2

It is fair to say this release focuses less on new features and instead offers many improvements to app performance and a smoother overall experience with LibreOffice. Collabora Productivity, together with peers in the community, have also worked diligently to improve interoperability and compatibility issues, and here are some of Collabora’s contribution highlights:

Writer: Auto Captions and Fixes

AutoCaptions – When you paste in an image, Writer auto-inserts a caption, as long as you check the box in Tools > Options > LibreOffice Writer > AutoCaptions.
Better handling of Floating Tables – Tables are better behaved! Previously, Writer prioritised keeping tables and headers together, which meant they could both slide onto the next page if there wasn’t enough space left on the page. Sometimes this disrupted document flow, creating a large gap on the previous page, but this is now fixed. Read how it was fixed on Miklos Vajna’s blog.
Better DOCX interoperability for Floating Tables – The handling of the Table Split feature has improved. Prior to 26.2, this would result in two floating tables inside one frame, which couldn’t be exported to DOCX.

Track Changes improved – You have greater choice when handling interdependent changes now, and can select the ‘layer’ to change in the Manage Changes, e.g., you can choose a format change that’s on top of a Delete or Insert change.

Calc: Supporting more features

BIFF12 support – The max limit for pasting from Excel to Calc has increased. Prior to 26.2, Calc could paste 65,536 rows. With the Biff12 file format (Excel 2007+) supported, users can paste 1,048,576 rows by 16,384 columns per sheet.
XmlMaps support – Users spotted that XLSX spreadsheets lost xmlMaps.xml when opened in Calc and saved as an XLSX file. With xmlMaps.xml support, users can create direct, structural links between cells and external XML data files, e.g., turning Calc into an interface for managing XML data.

Chart: Live Preview for Sidebar

Live Preview – It’s quicker to select colour schemes. When a user mouses over Chart data range colour palette entries, it shows a live preview in the active chart.

Performance: Boosts and Fixes

Calc – Lots of fixes, like faster scrolling on spreadsheets with many hidden columns, faster removal of duplicates, and Reject All in Track Changes was slow to complete, so that’s been optimised.
Graphics – Again, a lot more optimisation for many user cases, especially when exporting SVGs with bitmaps and importing certain SVGs (usually because of fills) and polygons (with tiled image fill) that were noticeably slow to render.
UI – for example, Go To Page / Slide / Sheet Dialogs are async now, which means the UI stays responsive when navigating large documents.

UI: New Context Menu option

Insert Hyperlink – Another new time-saver courtesy of the Context Menu, which works across all the core apps. This time, when you highlight text, and the Context Menu pops up automatically, you will find an ‘Inset Hyperlink’ as an option.

Filters: Improved Interoperability and Markdown

Markdown – Both Markdown export and import features are improved, and you can apply templates to imported Markdown, too, so your documents pick up the colour theme and formatting, for example.
Calc: Generic XML and JSON Tabular Mapping Support – Linkable tabular ranges are auto-mapped to sheets in Calc when opened now. A linkable range is a section of a document containing tabular records. When a document contains multiple linkable ranges, each range gets mapped to a single sheet.

There are many other commits from many people in LibreOffice 26.2, so while we are acknowledging the time and effort contributed by our engineering team here, we want to celebrate the collective contributions of everyone involved in the LibreOffice project.

“We are pleased that Collabora Productivity's business model of selling maintenance subscriptions has allowed us to contribute the majority of highlighted new features in this release cycle - alongside the community.”

—Michael Meeks, CEO of Collabora Productivity on LibreOffice 26.2

For a detailed document on Collabora Productivity’s contributions to LibreOffice 26.2 and the support we provide in areas such as crash-testing, security maintenance and interoperability, download the fact sheet (PDF).

We love to work in the open for the benefit of everyone and empower each user to control their documents!

If you’re new here, and you’re looking for a feature rich and compatible open source solution for editing and collaboration your users will love, try Collabora Online today!

The post Collabora Productivity contributions in LibreOffice 26.2 appeared first on Collabora Online and Collabora Office.