Jeff Bruchado
Back to blog

LibreOffice Without AI Breaks Download Record: Why Having No AI Became a Feature in 2026

Hello HaWkers, LibreOffice 26.8 came out on August 26, 2026 without a single generative AI feature, and The Document Foundation made a point of saying this was a choice, not a delay. A week later, the foundation published the numbers: 1,031,162 downloads from the official website in the first seven days, the best first week of any release in the project's history. The next day came a post with a title that sums up the whole discussion: "Yes, no AI is now a feature".

Stop for a second and think about the last app you updated. How many of them got a sparkly button you never asked for? In this article you will understand what the foundation actually announced, the six conditions it sets for any AI to make it into the default package, why this connects to the Microsoft 365 price increase and how to apply the same logic to your own product, with opt-in AI code and a pipeline that summarizes documents without taking them off your machine.

What Happened With LibreOffice 26.8

LibreOffice was born in 2010 as a fork of OpenOffice.org and is maintained by The Document Foundation (TDF), a German non-profit foundation. It is the best-known free alternative to Microsoft Office and runs in schools, hospitals, public agencies and law firms all over the world.

Version 26.8 shipped for Windows, macOS and Linux, in 120 languages. These are the numbers that caught people's attention:

  • 1,031,162 downloads in seven days, counting only the official website. Anyone who installs through Flathub, the Snap Store, PPAs or their Linux distribution's repository is left out, so the real total is higher.
  • Two consecutive weeks above 1 million downloads, something the project had never seen before. Part of that overlaps with the release of maintenance version 26.2.6 in the same window.
  • 29,755,011 downloads so far in 2026, according to figures compiled by Cybernews, up from 24,830,220 recorded in 2025 and 23,732,502 in 2024.

The news gained international traction from an article on the Brazilian site Manual do Usuário, which reached the front page of Hacker News with more than 700 points and more than 200 comments.

What's new in this release

No AI does not mean nothing new. The main changes in 26.8:

Module What's new
Writer Paragraph Composer, a layout algorithm that balances word spacing across consecutive lines
Writer Faster loading of large documents with images and groundwork for comparing documents side by side
Writer Support for OpenType font variations and automatic paragraph direction detection
Calc Command to shuffle the cells in a range and calculated fields in pivot tables
Chart Experimental support for importing and re-exporting the new Microsoft Office Chartex charts
Draw Option to invert zoom and scroll on the mouse wheel

Add to that better compatibility with XLSX files, which is still the most sensitive point for anyone switching office suites at work.

"No AI Is Now a Feature?": The Foundation's Six Conditions

The September 3 post, signed by Italo Vignoli on the TDF blog, opens by answering a comment left on the release announcement: "So, no AI is now a feature?". The answer is more careful than the title suggests. The foundation says LibreOffice does not reject artificial intelligence outright. What it refuses to do is put into the default package, used by tens of millions of people, a feature that cannot yet be delivered within the project's principles.

And those principles became an objective list of six conditions:

  1. User-controlled execution. The user chooses where inference runs: on their own computer, on infrastructure they control or on a service they chose independently. In TDF's words, "A default setting that silently redirects to a single provider is not a choice."
  2. No content leaves the computer without authorization. Sending the document has to be the user's decision, never a background behavior.
  3. No telemetry of any kind. "LibreOffice does not collect usage data, and this must also apply to AI features."
  4. No dependency on a single vendor. For the foundation, "An integration that only works with a single company's API is a lock-in mechanism."
  5. No compromise on format. Generated content must come out in ODF, just like any other content.
  6. Fully optional. The feature has to be installable, removable and absent from the interface for anyone who doesn't want to use it.

TDF's conclusion is blunt: "There is no integration that meets all the requirements" to make it into the default package today. Anyone who wants AI can install third-party extensions pointing to Ollama, LM Studio or any OpenAI API-compatible endpoint, and in that case the document never leaves the computer.

Notice that this is not an anti-AI manifesto. It is a requirements specification. I already covered here on the blog how Debian voted on rules for using generative AI in code, and the pattern is similar: big open source projects are swapping "yes or no" for "under what conditions".

The Other Side: AI as a Justification for Price Increases

The sharpest argument in the post is not technical, it is about business models. TDF points out that, as a non-profit foundation, it has "no subscription tiers to protect, no upsells, no data to monetise". In commercial suites, according to the post, the AI assistant serves to "justify a price increase and strengthen the case for keeping all documents within its own infrastructure".

The calendar helps the argument. On July 1, 2026 Microsoft raised prices on its Microsoft 365 commercial plans and, in the same move, added Copilot Chat to the base plans, with inbox and calendar access and agents in Word, Excel and PowerPoint. Some of the new prices per user, per month:

Plan Before After Increase
Business Basic $6.00 $7.00 +17%
Business Standard $12.50 $14.00 +12%
Microsoft 365 E3 $36.00 $39.00 +8%
Microsoft 365 E5 $57.00 $60.00 +5%
F3 (with Teams) $8.00 $10.00 +25%
F1 (without Teams) $1.75 $2.50 +43%

The full Microsoft 365 Copilot is still a separate add-on at $30 per user per month. In other words: basic AI came into the bundle together with the price increase, and the more complete AI is still sold separately. You can't claim one caused the other, but this is exactly the kind of combination TDF uses as a contrast.

The Product Lesson: When Everyone Adds, Subtracting Becomes Positioning

Positioning is, above all, perceived difference. When every office suite ends up with the same AI button, that button stops setting apart the products that have it and starts setting apart the ones that don't. LibreOffice didn't invent this. In August 2024 Procreate, the iPad drawing app, publicly promised it would never put generative AI in its products, and CEO James Cuda summed up the position in one sentence: "Creativity is made, not generated." The reaction from its artist base was mostly positive.

Three points make this strategy work in TDF's case, and they apply to any product.

1. The right customer values the absence

Schools, hospitals, public agencies and law firms deal with confidential, privileged or personal data. For them, knowing where the document goes is a purchase requirement, not a detail. In Brazil, any software that processes personal data runs into the LGPD, the country's data protection law, and "the content never leaves the machine" makes the conversation with the legal team much shorter. In Europe, the digital sovereignty movement pushes in the same direction, as shown by France's plan to replace American apps.

2. The position has to match the business model

TDF can say "no AI by default" with credibility because it doesn't live off subscriptions. If your SaaS charges per seat and pushes a premium plan with AI, the same pitch sounds fake. Before copying the strategy, ask yourself whether it is consistent with the way you make money.

3. It's not "never", it's "with conditions"

TDF left the door open and wrote down the criteria for opening it. That turns a refusal into a verifiable promise and gives people who want AI a path, the extensions, without forcing it on those who don't.

In Practice: Opt-In AI in Your Product

TDF's six conditions make a great architecture checklist. Let's turn the most important ones into code, starting with the basics: everything off by default.

// ai-settings.ts: product AI configuration, everything starts turned off
export type AiProvider =
  | { kind: 'local'; baseUrl: string; model: string } // e.g.: Ollama on the user's machine
  | { kind: 'self-hosted'; baseUrl: string; model: string } // server controlled by the user's company
  | { kind: 'external'; baseUrl: string; model: string; apiKeyRef: string }; // service chosen by the user

export interface AiSettings {
  enabled: boolean; // the feature only exists after the user turns it on
  provider: AiProvider | null; // no provider chosen by default
  allowContentUpload: boolean; // explicit permission to send content outside
  showInToolbar: boolean; // if false, the AI does not even show up in the interface
  telemetry: boolean; // usage collection is opt-in too
}

export const DEFAULT_AI_SETTINGS: Readonly<AiSettings> = Object.freeze({
  enabled: false,
  provider: null,
  allowContentUpload: false,
  showInToolbar: false,
  telemetry: false,
});

The golden rule lives in the default object: no provider chosen, no upload authorized, nothing in the interface. The user turns on whatever they want, whenever they want.

A barrier before any network call

TDF's condition number 2, no content leaves without authorization, has to be guaranteed in code, not left to the goodwill of whoever writes each screen. A central guard solves it:

// ai-guard.ts: every AI call goes through here before touching the network
import type { AiProvider, AiSettings } from './ai-settings';

export class AiNotAllowedError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'AiNotAllowedError';
  }
}

const isOnDevice = (provider: AiProvider): boolean => {
  if (provider.kind !== 'local') return false;
  const { hostname } = new URL(provider.baseUrl);
  // "local" only counts if the address really is the user's machine
  return ['localhost', '127.0.0.1', '[::1]'].includes(hostname);
};

export function assertAiAllowed(
  settings: AiSettings,
  hasUserContent: boolean
): AiProvider {
  if (!settings.enabled || !settings.provider) {
    throw new AiNotAllowedError('AI disabled: the user has not turned the feature on.');
  }

  // User content only leaves the machine with explicit permission
  if (hasUserContent && !isOnDevice(settings.provider) && !settings.allowContentUpload) {
    throw new AiNotAllowedError('Sending content to a remote provider is not authorized.');
  }

  return settings.provider;
}

With this in place, forgetting the check in a new feature doesn't leak a document: the call fails loud and early, and the error says exactly what was missing.

Absent from the interface for those who don't want it

Condition 6 asks for the feature to be removable and absent from the interface. On the front end, that means an honest v-if, not a disabled button blinking in the toolbar:

<script setup lang="ts">
// EditorToolbar.vue: the AI button only exists for those who turned the feature on
import { computed } from 'vue';
import type { AiSettings } from './ai-settings';

const props = defineProps<{ settings: AiSettings }>();
const emit = defineEmits<{ summarize: [] }>();

const showAiButton = computed(
  () => props.settings.enabled && props.settings.showInToolbar
);
</script>

<template>
  <nav class="toolbar">
    <button type="button">Save</button>
    <button type="button">Export PDF</button>
    <!-- No sparkly button for people who did not ask for it -->
    <button v-if="showAiButton" type="button" @click="emit('summarize')">
      Summarize with AI
    </button>
  </nav>
</template>

Local AI the Way TDF Suggests: Headless LibreOffice + Ollama

The path TDF points to for people who want AI, a model running on their own machine with an OpenAI-compatible endpoint, is easy to set up today. And LibreOffice comes in as an automation piece: headless mode converts documents without opening any interface at all. If you want to better understand the landscape of models running on-device, I wrote about local AI and edge computing here on the blog.

First, the terminal:

# 1. Download a model to run locally (first time only)
ollama pull llama3.2

# 2. Check that the OpenAI-compatible endpoint is responding
curl http://localhost:11434/v1/models

# 3. Convert a document to plain text without opening the LibreOffice interface
#    (on macOS the binary lives at /Applications/LibreOffice.app/Contents/MacOS/soffice)
soffice --headless --convert-to txt:Text --outdir ./output contract.odt

# 4. The same headless mode generates PDFs, useful on the back end and in CI pipelines
soffice --headless --convert-to pdf --outdir ./output report.docx

Now a Node.js script that brings the two together: it converts the document with LibreOffice and asks the local model for a summary. The file never leaves your computer at any point.

// local-summary.mjs: summarizes a document without it ever leaving your machine
import { execFile } from 'node:child_process';
import { mkdtemp, readFile, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { promisify } from 'node:util';

const run = promisify(execFile);
const SOFFICE = process.env.SOFFICE ?? 'soffice'; // path to the LibreOffice binary
const ENDPOINT = 'http://localhost:11434/v1/chat/completions'; // Ollama, OpenAI-compatible
const MODEL = process.env.MODEL ?? 'llama3.2'; // swap in the model you downloaded

async function documentToText(file) {
  const outDir = await mkdtemp(path.join(tmpdir(), 'lo-'));
  try {
    // Headless conversion: no window opens and nothing goes to the network
    await run(SOFFICE, ['--headless', '--convert-to', 'txt:Text', '--outdir', outDir, file]);
    const name = `${path.basename(file, path.extname(file))}.txt`;
    return await readFile(path.join(outDir, name), 'utf-8');
  } finally {
    await rm(outDir, { recursive: true, force: true }); // deletes the temporary file
  }
}

async function summarize(text) {
  const response = await fetch(ENDPOINT, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: MODEL,
      messages: [
        { role: 'system', content: 'Summarize the document in up to 5 bullet points, in English.' },
        { role: 'user', content: text.slice(0, 20_000) }, // trims texts that are too long
      ],
    }),
  });
  if (!response.ok) throw new Error(`The local model responded with ${response.status}`);
  const data = await response.json();
  return data.choices[0].message.content;
}

const file = process.argv[2];
if (!file) {
  console.error('Usage: node local-summary.mjs <document.odt|docx>');
  process.exit(1);
}

console.log(await summarize(await documentToText(file)));

To run it: node local-summary.mjs contract.odt. It is the spirit of the six conditions applied to a short script: the user picks the model, inference runs locally, there is no telemetry and the input document stays in an open format.

The Limits of the Argument

It would be dishonest to sell the record as proof that "no AI" sells. A few caveats before you bring this lesson to your product:

  • Correlation is not causation. The record first week was measured between August 26 and September 2, before the post that turned "no AI" into a headline. And the two weeks above 1 million overlap with two releases shipped back to back.
  • A download is not an active user. A significant share comes from people who already used the suite and just updated.
  • Plenty of people do want AI. The strategy works for the audience LibreOffice serves. An editor aimed at content marketing might lose customers with the same decision.
  • Third-party extensions also require care. "The document never leaves the computer" holds for the local model. An extension pointing to an external API brings the original problem right back, and the responsibility shifts to whoever installed it.

None of this invalidates the lesson. It just shows that it depends on context: audience, business model and trust built up over the years.

What This Means for Anyone Building Software in 2026

The message from LibreOffice 26.8 is not "don't use AI". It is that AI has become a product decision with a trust cost, and the market default of turning everything on for everyone now has competition. If you build and sell software, you can pull a short checklist out of this episode:

  • Off by default for any feature that sends user content outside.
  • Choice of provider, including a local option, instead of a single hard-wired API.
  • Zero telemetry by default, with explicit opt-in if you really need it.
  • Output in an open format, so users don't get locked into what the AI generated inside your product.
  • Real removal, with no ghost button left in the interface.

My bet is that, over the next few years, "optional and local AI" will stop being an open source foundation niche and become a purchasing criterion in public procurement, healthcare and legal. Whoever already has this architecture in place will have a short answer when the customer asks where the data goes. And there is a bonus: a product that works well without AI tends to get even better when the user decides to turn it on.

Let's go! 🦅

📚 Want to Keep Up With What Is Coming?

This article covered the LibreOffice 26.8 download record and the decision to keep AI out of the default package, but the ecosystem changes every week and not everything turns into an article here.

On X I share what I am testing, the behind the scenes of my projects and the news that shows up before it becomes a post.

Follow Me There

👉 Follow @jeffbruchado on X

💡 Daily content about development, career and the tools I actually use

Comments (0)

This article has no comments yet 😢. Be the first! 🚀🦅

Add comments