Game in the Brain

For years, my loyalty to LibreOffice was unwavering. I supported it because it was the rightful successor to OpenOffice—the champion mandated to provide a free, open-source office suite for the masses.

My loyalty wasn’t just theoretical. I took the time to write and publish my entire catalog of books using LibreOffice Writer—battling through complex Table of Contents generation, finicky formatting, and learning to overcome a myriad of obscure bugs just to get my work out the door. You can see the results of that labor here: https://www.drivethrurpg.com/en/publisher/17858

But loyalty can only stretch so far before reality sets in. Recently, I realized that LibreOffice has buried itself under so much technical debt that it can no longer fulfill its mandate in the modern era.

I discovered this the hard way while falling down a rabbit hole trying to build a simple “NumToWords” extension for LibreOffice Calc. What should have been a straightforward afternoon project turned into an agonizing 15-step debugging chronicle.

You can read the full horror story here: https://wiki.gi7b.org/index.php/LibreOffice_Calc_NumToWords_Extension_Complete_Guide

This grueling experience forced me to ask a hard question: If a developer wanted to build a custom, highly extensible office environment today, why would they ever choose LibreOffice? The truth is, they wouldn’t. To serve the modern masses, an open-source office suite needs to be agile, web-native, and mobile-ready.

It is time to pass the torch. I am giving my support to the true modern successor: ONLYOFFICE. Here is why, and how its modern architecture allows us to build powerful, mobile-friendly productivity tools that LibreOffice simply cannot match.

The Burden of Legacy vs. The Modern Mandate

Let’s look at the repositories that define these two eras:

• LibreOffice: https://github.com/LibreOffice
• ONLYOFFICE: https://github.com/ONLYOFFICE

The LibreOffice Stack is a monolithic beast. It’s built on decades-old C++, heavily tied to Java, and glued together by UNO (Universal Network Objects)—an architecture designed by Sun Microsystems in the late 1990s. Just to make a Python script talk to a spreadsheet cell, I had to compile binary RDB type libraries and navigate arcane XML manifests. Managing a hard fork or building extensions for this means maintaining an operating system within an operating system. LibreOffice is drowning in its own history.

The ONLYOFFICE Stack, by contrast, is built to fulfill the modern open-source mandate. It is highly consolidated around modern web technologies. The core is C++, but the UI and rendering engine are written entirely in JavaScript/TypeScript and rendered on an HTML5 <canvas>. If you write a plugin for ONLYOFFICE, you aren’t fighting a 25-year-old component model; you are just writing standard web app code (HTML/JS/CSS).

Because of this architectural superiority, ONLYOFFICE is perfectly positioned to solve a massive problem LibreOffice never could: bringing true desktop-level power to our mobile devices.

The Mobile Plugin Problem

ONLYOFFICE is famous for its rich Plugin Marketplace (AI, macros, translation tools) on the desktop and web. But out of the box, if you open their native Android app, those plugins vanish.

Why? Because the native mobile app acts as a file manager wrapping a stripped-down, touch-optimized version of their canvas renderer. The native interface lacks the framework to support injected web UI elements like sidebars and floating iframes. You can hack around this by opening your ONLYOFFICE cloud instance in Chrome for Android and requesting the “Desktop Site,” but the user experience is a nightmare of microscopic buttons and finicky touch targets.

But because ONLYOFFICE is web-native, we don’t have to rely on their native app. We can build something better.

The Ultimate Solution: Ditching Native Apps for a PWA

If native Android apps strip away our power features, the answer is to bypass the app stores entirely. We can build a custom Progressive Web App (PWA) that leverages ONLYOFFICE’s core web engine but wraps it in a seamless, mobile-friendly shell.

Because ONLYOFFICE is fundamentally a web application, we can serve it as a PWA and unlock native-level capabilities that finally deliver a truly free, powerful office suite to any device:

1. Massive Offline Storage (OPFS)

We don’t need to rely on tiny localStorage limits. Modern PWAs on Android can utilize the Origin Private File System (OPFS) and IndexedDB. We can build a UI with a simple “Make available offline” toggle. When toggled, the PWA downloads the raw .xlsx or .docx payload and saves it to a sandboxed, highly performant local file system.

2. True File System Access

Thanks to the File System Access API, our PWA isn’t forced to hide files in a browser cache. We can trigger the native Android file picker, allowing users to save and open documents directly from their phone’s local “Documents” folder, exactly like a native app.

3. Background Syncing

By implementing a Service Worker, we can intercept network requests. If a user edits a spreadsheet offline on a train, the Service Worker saves the changes locally. The moment the phone reconnects to Wi-Fi—even if the app is closed—the Android OS wakes the Service Worker up to silently push the saved data back to our server.

The 50 Million PHP Question: Scaling a Dev Team for Market Superiority

To truly understand the cost of technical debt, let’s run a scenario.

Imagine putting together a skilled, 20-person development team in the Philippines—comprising a standard mix of 12 developers, 5 QA engineers, 2 Product Managers, and 1 DevOps specialist. At roughly 13 Million PHP a year, this represents a ~50 Million PHP investment over 3 years.

Their goal? Push the open-source office suite to absolute market superiority against Google Workspace and Microsoft 365.

Here is what that 50 Million PHP buys you depending on the codebase you choose:

Scenario A: Forking LibreOffice (The Tech Debt Sinkhole)

• Year 1 (The Ramp-Up): The team spends 8 to 10 months just learning how to compile the 25-year-old C++ codebase. SDK processes are a nightmare to document. QA is overwhelmed by legacy cross-platform UI bugs. Output: Near zero user-facing features.
• Year 2 (The Crawl): The team finally manages to write a few Python/UNO extensions and polish some rough edges in the UI. Every new feature requires fighting the archaic VCL rendering engine. Mobile development is entirely stalled because the core architecture isn’t built for it.
• Year 3 (Stagnation): The 50 Million PHP is gone. The team has barely modernized the UI, the mobile app is still an afterthought, and developers are burnt out from maintaining the technical debt. Market superiority is a pipe dream.

Scenario B: Building on ONLYOFFICE (The Web-Native Rocket)

• Year 1 (The Foundation): Because ONLYOFFICE uses standard web tech (JS/TS/HTML5), the team is fully onboarded in 4 weeks. By month 3, they have mapped the SDK, laid down standard CI/CD pipelines, and built the core Nextcloud-to-PWA mobile wrapper.
• Year 2 (The Feature Push): The team becomes a feature factory. They are rapidly deploying complex Javascript plugins (like the Open Finance Engine and Local AI cell functions) directly to the PWA. QA moves swiftly because the canvas rendering is identical across all platforms.
• Year 3 (Market Superiority): With the PWA fully matured, the team successfully delivers the entire “Dream Feature Set” (see Appendix below). The 50 Million PHP investment results in a highly customized, mobile-first, AI-integrated powerhouse that legitimately rivals Google Docs, with zero walled-garden restrictions.

The Takeaway: Supporting the New Successor

LibreOffice fought a good fight. For years, it carried the torch of OpenOffice and kept the dream of a free office suite alive. But fighting against decades of legacy architecture is a losing battle, and it can no longer flexibly serve the modern needs of developers or end-users.

By embracing fully web-based engines like ONLYOFFICE and wrapping them in modern PWA capabilities, we can build an extensible, plugin-rich, and offline-capable document ecosystem that completely bypasses the limitations of legacy desktops and locked-down mobile apps.

My loyalty lies with the mandate of open-source productivity for all. And right now, ONLYOFFICE is the only suite built to deliver it.

Appendix: The Dream PWA Feature Set (and a Middle Finger to Walled Gardens)

The hardest challenge in open-source productivity is mobile accessibility. The dream scenario is tying this PWA architecture directly into a self-hosted cloud like Nextcloud. Imagine this: Every spreadsheet or document you have in Nextcloud automatically converts into a standalone PWA on your phone. No need to “Install” anything from an app store.

This is a HUGE middle finger to the Google app lockdown on Android. It means we don’t have to wait for corporate approval to run plugins on our mobile devices. By running the ONLYOFFICE web engine within a PWA, we can bring desktop-class plugins straight to our phones.

Here is the ultimate feature set we can build when we break free from native apps (and exactly what that 20-person team would build in Years 2 and 3):

1. The Open Finance Engine

I rely heavily on =GOOGLEFINANCE(). We need an open equivalent that allows users to fetch real-time and historical market data directly into cells, alongside a framework to easily add custom API endpoints for crypto or niche markets.

2. Local AI Cell Functions

Instead of sending data to OpenAI, imagine a plugin connected to your local LMStudio or Ollama instance. You could write a formula like =llama(A3, "Summarize this client feedback", "Mistral-7B") and process data entirely locally, with zero privacy risks.

3. Context-Aware AI Sidebar

A chat sidebar that actually understands the exact context of your document. It knows what data is inside each cell, what the current table structure is, and can manipulate the sheet directly based on your conversation.

4. Accessibility Vision Models

Model tools designed specifically for the visually impaired. An AI that can “look” at a complex spreadsheet or table and describe its layout, contents, and key data trends in natural spoken language.

5. Natural Language Graphing

Stop wrestling with chart wizards. A person should be able to use natural language to instruct the ONLYOFFICE engine to graph data. Just type, “Create a pie chart showing the breakdown of Column B,” and the plugin generates it.

6. Dynamic Cross-Sheet Linking

We need robust functionality similar to Google’s IMPORTRANGE and IMPORTDATA, allowing us to seamlessly link sections, dynamic arrays, and live data across completely different files and sheets within the Nextcloud ecosystem.

7. High-Density Rich Text Cells

Currently, spreadsheet cells are limited in how they handle formatting. We need the ability to hold high information density inside a single cell—meaning true rich text formatting, bullet points, and multiple distinct hyperlinks co-existing within one cell.

8. Contextual Country Plugins

Smart locale plugins that do more than just change the currency symbol. If you are working in a specific region, the plugin makes the spreadsheet aware of the country’s specific Timezone, Currency formatting, and ensures functions like =TODAY() automatically respect the correct GMT offset.

9. Instruction-Driven PDF Conversion (Vision Models)

Standard PDF-to-Spreadsheet converters are rigid, often mangling complex layouts or blindly extracting headers, footers, and irrelevant text. We need an intelligent converter powered by Vision Models where you can actually give instructions. Instead of a blind, automated conversion, you could prompt the model: “Read this PDF and extract only the Q3 financial tables. Ignore the watermarks and legal boilerplate, merge multi-page tables intelligently, and make sure the ‘Date’ column is formatted as YYYY-MM-DD.” This turns a frustrating data-cleaning chore into a single, flawless action.