Last updated:
August 25, 2025 04:00 AM
All times are UTC.
Powered by:
Imprint
Privacy Policy
Get a quick overview of some of the new features in LibreOffice 25.8, released on Wednesday. (This video is also available on PeerTube).
Please confirm that you want to play a YouTube video. By accepting, you will be accessing content from YouTube, a service provided by an external third party.
If you accept this notice, your choice will be saved and the page will refresh.
The best open source office suite continues to evolve, while maintaining its focus on privacy and digital sovereignty
Berlin, 20 August 2025 – The Document Foundation announces the release of LibreOffice 25.8. This latest version of the market-leading free open source office suite maintains its focus on digital sovereignty and privacy protection. It offers individuals, organisations, and governments total control over their data and the most comprehensive productivity tools.
In a global context of growing concern about data privacy, cloud lock-in, and surveillance capitalism, LibreOffice 25.8 provides concrete solutions.
Open Source: The source code is available for inspection and is completely free from proprietary technology constraints.
Privacy and Control: LibreOffice does not collect personal data, usage metrics or diagnostic information, and complies with the data protection regulations required by public administration implementations (GDPR).
Local Execution: all features are executed locally on the user’s computer, without the need for an internet or cloud connection.
Self-Hosted Collaboration: Integration with on-premises cloud solutions, such as Nextcloud, enables teams to collaborate without sharing information with Big Tech.
User Interface: the Welcome/What’s New dialog now offers access to the user interface picker and appearance options, allowing new users to leverage LibreOffice’s flexible UI and personalise the look and feel according to their preferences.
Performance: everything is faster, from startup to scrolling through large documents – with significant speed improvements on less powerful machines.
Better Interoperability with Microsoft Office files, with more accurate handling of DOCX, XLSX and PPTX files and fewer formatting issues, thanks to changes such as:
There are, of course, other important new features, such as the ability to export to the PDF 2.0 format, and several new ScriptForge library services. The complete list is available here: wiki.documentfoundation.org/ReleaseNotes/25.8.
In terms of operating system support changes, LibreOffice 25.8 will no longer run on Windows 7 or 8/8.1 versions. It is also the last version to run on macOS 10.15. Support for x86 (32-bit) Windows versions is deprecated.
The Document Foundation collaborates with a global network of certified partners who offer enterprise-grade support and maintenance, customised features and integrations, and assistance with user migration and training. A full list of partners can be found here: www.libreoffice.org/get-help/professional-support/.
LibreOffice 25.8 is completely free and offers a viable alternative to proprietary office suites for individual users, schools, businesses, and public institutions. It contains no advertising, data tracking, or subscriptions.
It is ideal for students and teachers who need reliable tools for documents, presentations and data analysis, as well as for home users and freelancers looking for a solid, free alternative to Microsoft Office/365 or Google Docs. It is also ideal for public administrations and companies that value data sovereignty and the long-term accessibility of documents.
LibreOffice 25.8 reaffirms our dedication to safeguarding the freedom and privacy of end users in the digital age. With this new release, we ensure that personal information stays where it belongs – with the individual. LibreOffice gives end users full control over their documents, helping them to avoid reliance on third-party platforms that might compromise their data or privacy. It’s about empowering users to work securely, independently and confidently, said Eliane Domingos, chairwoman of The Document Foundation.
LibreOffice 25.8 is available for Windows, macOS and Linux, with versions for Intel and ARM/Apple processors, at www.libreoffice.org/download/.
The Document Foundation is a non-profit organisation that promotes open document formats and develops LibreOffice, the market-leading free open-source office suite. Its mission is to empower individuals and organisations to maintain control over their data and tools in an increasingly digital world dominated by closed platforms.
—
Press Kit: nextcloud.documentfoundation.org/s/doGTtfJSkNAtrNi
Video YouTube: www.youtube.com/watch?v=6dIRR37PF7M
Video PeerTube: peertube.opencloud.lu/w/1J49cZ9NvZy1sLmx8dJKDi
LibreOffice does not include artificial intelligence (AI) out-of-the-box. But many users want AI features in the suite – so we encourage developers to make them available as optional extensions. And that’s what Igor Támara did, creating the “Stable Diffusion for LibreOffice” extension for AI-generated images powered by AI Horde (a volunteer crowd-sourced distributed cluster of image generation workers).
We talked to Igor about the extension – here’s what he had to say:
You write some text describing an image, and get an AI image generated from the given text. You can tweak parameters, choose a model and use the best result on written documents, presentations or the place you prefer. The images are generated on volunteer GPUs through AI Horde.
Two weeks ago, starting from a Gimp plugin as a base. I’m brand new to the LibreOffice project, and started it as a macro to get this functionality in the software. One week later I put it on GitHub.
Later on I got help from friendly people on the forum to turn it into an extension. I also joined the the chat and filled some requests in the bug tracker.
Be aware that the text you provide is sent to AI Horde and seen by the machines that create the image, so do not send sensitive data. Also, you can get better results if you send the description of the desired image in English. You are encouraged to try different languages to see the results.
You need internet connection to use it. If you wanted to create images locally on your machine, it would take time to configure your environment with local AI models, with gigabytes of memory dedicated to this purpose, and maybe processing for hours to get something useful.
Sometimes the text can be marked as NSFW (“not safe for work”) – in which case you end up with black and white text saying so.
For now, the extension works in Writer and Impress; when invoked from other LibreOffice components, it opens a new text document and inserts the image along with the provided text.
The roadmap includes:
Report any problems you find, and help to translate into your language. Please do so by filling an issue with your intention saying which language.
If you have a GPU (and good graphics hardware in general), you can volunteer as a worker joining the horde, to add to the computing power – and you can earn kudos to have higher priority when you need it.
If you work with a friendly company that wants to make use of the existing hardware, you can join the horde too.
One of the purposes of AI Horde is to aid education, having a special program for that.
This plugin and AI Horde are all open source, so everyone can learn and be as transparent as possible in this changing and revolutionary world of AI times.
There might be concerns about the use of products and the ownership of work. As I see it, we are always learning by example and reusing what others have invented from thousands of years ago, like how to walk, make fire, communicate, explore, recreate and mix. We can continue to learn and make fair use of resources – and contribute too.
In the digital world, document formats are essential. Proprietary formats such as Microsoft Word’s DOCX or Excel’s XLSX dominate the workplace, but at the same time they lock users into a specific vendor and its business strategies, which tend to exploit users to the maximum in every way. The Open Document Format (ODF) offers an open, standard alternative that protects users and their privacy, promotes interoperability, long-term access and data ownership.
Migrating documents from proprietary formats to ODF is the solution, and although vendors who rely on proprietary formats – not only Microsoft, but also its freeware clones such as OnlyOffice or WPS Office – do everything they can to prevent it, it is very easy and represents a fundamental step forward for users in terms of privacy and digital sovereignty (i.e., ownership of their own content).
This guide breaks down the migration process to make the transition smooth, efficient and sustainable, both at the individual level (where problems are virtually non-existent) and at the enterprise level, where problems exist due to the lock-in strategies of proprietary formats.
Step 1: Understand ODF and its advantages
Step 2: Document inventory to define conversion priorities and estimate the effort required for migration
Step 3: plan the migration workflow
Step 4: Converting documents to ODF format
Step 5: Monitoring the migration
Conclusion
Migrating from proprietary formats to ODF is a strategic move, both individually and for businesses, towards openness, content control and document protection for the future. In a business environment, it requires careful planning and user involvement, but the benefits in terms of flexibility, interoperability and cost savings are well worth the effort.
This post is part of a series to describe how Writer now gets a feature to handle tables that are both floating and span over multiple pages.
This work is primarily for Collabora Online, but is useful on the desktop as well. See the 11th post for the previous part.
Previous posts described the hardest part of multi-page floating tables: making sure that text can wrap around them and they can split across pages. In this part, we'll look at a conflicting requirement. On one hand, headings want their text to not split across pages (and shapes anchored into paragraphs are considered part of the paragraph, too). On the other hand, it should be OK to have a floating table at the bottom of a page and the following heading to go to the next page.
It turns out, Writer gave "keep together" a priority, while Word gave "floating tables are OK to split to a previous page" a priority.
Note that if you have a shape (e.g. a triangle) and not a floating table, then both Word and Writer prevents the move of that shape to a previous page (if the shape is anchored in a heading); this difference was there just for floating tables.
Here is how the tdf#167222 bugdoc looks like now in Writer:
And here is how it used to look like:
And here is the reference rendering:
This means that we leave layout for shapes unchanged in general: shapes anchored in headings are still considered to be part of headings and don't split. But for floating tables, we now allow them to split and use space at a previous page if they fit there.
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes:
You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (26.2).
LibreOffice 25.8 will be released next week, on August 20, 2025 (check the Release Plan). LibreOffice 25.8 RC3 brings us closer to the final version, which will be preceded by a last minute LibreOffice 25.8 RC4 needed for a fix solving an easy to trigger crash. Check the release notes to find the new features included in this version of LibreOffice.
LibreOffice 25.8 RC3 is already available, while LibreOffice 25.8 RC4 will be available from Thursday, August 14. Both can be downloaded for Linux, macOS and Windows, and will replace the standard installation.
In case you find any problem in these pre-releases, please report it in Bugzilla (you just need a legit email account in order to create a new account). For help, you can contact the QA Team directly in the QA IRC channel or via Matrix.
LibreOffice is a volunteer-driven community project, so please help us to test, we appreciate your contribution! Happy testing!!!
Kudos to Ilmari Lauhakangas for helping to elaborate this list.
429 bugs, 56 of which are enhancements, have been reported by 287 people.
Top 10 Reporters
314 bugs have been triaged by 70 people.
Top 10 Triagers
268 bugs have been set to RESOLVED.
Check the following sections for more information about bugs resolved as FIXED, WORKSFORME and DUPLICATE.
142 bugs have been fixed by 35 people.
Top 10 Fixers
List of high severity bugs fixed
List of crashes fixed
List of performance issues fixed
List of old bugs ( more than 4 years old ) fixed
32 bugs have been retested by 21 people.
Top 10 testers
40 bugs have been duplicated by 19 people.
Top 10 testers
14 bugs have been verified by 10 people.
Top 10 Verifiers
193 bugs have been categorized with a metabug by 24 people.
Top 10 Categorizers
43 bugs have been set as regressions by 18 people.
Top 10
52 bugs have been bisected by 10 people.
Top 10 Bisecters
LibreOffice 25.8 will be released as final on August, 20, 2025 (check the Release Plan). LibreOffice 25.8 Release Candidate 2 (RC2) brings us closer to the final version, which will be preceded by Release Candidate 3 (RC3). Since the previous release, LibreOffice 25.8 RC1, 70 commits have been submitted to the code repository and 34 issues got fixed. Check the release notes to find the new features included in this version of LibreOffice.
LibreOffice 25.8 RC2 can be downloaded for Linux, macOS and Windows, and it will replace the standard installation.
In case you find any problem in this pre-release, please report it in Bugzilla (you just need a legit email account in order to create a new account).
For help, you can contact the QA Team directly in the QA IRC channel or via Matrix.
LibreOffice is a volunteer-driven community project, so please help us to test, we appreciate your contribution! Happy testing!!!
…
You know what: Microsoft became miserably incompetent in IT.
I develop open-source code. But that never made me one of the “I hate proprietary software or IT giant corporations” types. I always saw the nice things that Microsoft offered to its users; I saw not only downsides in its products. And I also used (and continue to use) things created by it: Windows to start with (and I develop there, being able to debug and address issues specific to the platform that most of our users use); but also its email service for personal mail.
This Monday, I decided to send something to LibreOffice dev mailing list. Something I do from time to time, you know. Not too fascinating, right?
Well, this time, it turned out, Microsoft decided to teach me to fear them. Thunderbird shown me a message, that the mail couldn’t be sent (well, not a problem: will re-try again…), but then I found myself logged off, with “Your account has been blocked” message. They decided, that I violated their service agreement!
FTR: here is the mail. I was able to send it using another tech giant’s mail service. You may see that it’s full of links. Yes, that’s true; I prefer to provide references to my words. But tell me where was it violating anything in MS agreement?
OK, they have a stupid AI that is worse than good old filters. OK, they made it react immediately, as an undoubted authority. But that’s not a big problem, right? They provide a way to appeal! Let me do that.
And of course, they ask for the phone, and I provide it, just to get a nice reply:
And guess what: there is no other method!
OK! Let’s ask their support. (I am approaching to the point that fascinated me most.) I found a link to “Contact Microsoft Support” on the “Troubleshooting verification code issues” page; and after some automatic answers there, which didn’t answer my problem, I finally got a button telling me … tada …
Yes, you got it right. “Here is a page where we discuss problems signing in. You attempted our FAQ suggestions? You still can’t sign in? No problem! Contact our Support team, and we will solve your problem is a minute! But first, please sign in to continue.”
Heh. I used my wife’s account to contact support. And then I was given a very secret link to an appeal form, where I could file a support ticket. And the next morning, I got a message! Yay! It told me to do something! Let me try! What is that they tell me to do? Reading… hmm… go to sign-in page, and when they tell me that my account is blocked, provide a phone number? Wasn’t it exactly the thing I attempted and failed, and told them about that? But hey, they obviously fixed that problem overnight, they couldn’t just send me the useless instructions, right? Or could they?
They could.
They just ignored my description. They repeated the useless instructions, without taking care to check what the problem was. And they closed the ticket automatically. It has been resolved, you know.
I still am in the process. I filed another ticket, which they didn’t care to answer. I am still hopeful.
But this, once an IT tech leader, became utterly incompetent in IT. And for me, it’s a pity.
LibreOffice 25.8 will be released as final at the end of August, 2025 ( Check the Release Plan ) being LibreOffice 25.8 Release Candidate 1 (RC1) the third pre-release since the development of version 25.8 started at the beginning of December, 2024. Since the previous release, LibreOffice 25.8 Beta1, 178 commits have been submitted to the code repository and 101 issues got fixed. Check the release notes to find the new features included in this version of LibreOffice.
LibreOffice 25.8 RC1 can be downloaded for Linux, macOS and Windows, and it will replace the standard installation.
In case you find any problem in this pre-release, please report it in Bugzilla ( You just need a legit email account in order to create a new account ).
For help, you can contact the QA Team directly in the QA IRC channel or via Matrix.
LibreOffice is a volunteer-driven community project, so please help us to test – we appreciate it!
Happy testing!!
…
Writer has some support for interdependent (or hierarchical) tracked changes: e.g. the case when you have a delete on top of an insert. See the first post for background.
This work is primarily for Collabora Online, but the feature is available in desktop Writer as well.
With the already mentioned improvements in place, a few areas were still lacking: we didn't have UI for all cases where the DOCX import was possible already; combining tracked changes (redlines) were not complete (so you don't have to reject all parts of a logical redline one by one) and some of the undo/redo code didn't work as expected.
Here is a sample case where the UI was missing to create something that was possible to import from DOCX: a format redline on top of an insert redline.
If you had a document with an insert:
And you selected BBB to mark those characters as bold, we just updated the existing insert redline to be bold:
But now we track a format change on top of the insert separately:
This is also visible if you open the track changes dialog, which explains that now you have part of the insert redline covered by a format redline:
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes. Core side:
You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (25.8).
Kudos to Ilmari Lauhakangas for helping to elaborate this list.
488 bugs, 80 of which are enhancements, have been reported by 278 people.
Top 10 Reporters
379 bugs have been triaged by 72 people.
Top 10 Triagers
344 bugs have been set to RESOLVED.
Check the following sections for more information about bugs resolved as FIXED, WORKSFORME and DUPLICATE.
180 bugs have been fixed by 30 people.
Top 10 Fixers
List of high severity bugs fixed
List of crashes fixed
List of old bugs ( more than 4 years old ) fixed
39 bugs have been retested by 28 people.
Top 10 testers
75 bugs have been duplicated by 22 people.
Top 10 testers
16 bugs have been verified by 15 people.
Top 10 Verifiers
178 bugs have been categorized with a metabug by 24 people.
Top 10 Categorizers
48 bugs have been set as regressions by …
LibreOffice 25.8 will be released as final at the end of August, 2025 ( Check the Release Plan ) being LibreOffice 25.8 Beta1 the second pre-release since the development of version 25.8 started at the beginning of December, 2024. Since the previous release, LibreOffice 25.8 Alpha1, 782 commits have been submitted to the code repository and 154 issues got fixed. Check the release notes to find the new features included in this version of LibreOffice.
LibreOffice 25.8 Beta1 can be downloaded for Linux, macOS and Windows, and it can be installed alongside the standard version.
In case you find any problem in this pre-release, please report it in Bugzilla ( You just need a legit email account in order to create a new account ).
For help, you can contact the QA Team directly in the QA IRC channel or via Matrix.
LibreOffice is a volunteer-driven community project, so please help us to test – we appreciate it!
Happy testing!!
…
Writer has some support for interdependent (or hierarchical) tracked changes: e.g. the case when you have a delete on top of an insert. While there were some working cases, handling of many combinations were missing. I started to make systematic improvements in this area in the recent past, this post gives you an overview what's done so far.
This work is primarily for Collabora Online, but the feature is available in desktop Writer as well.
DOCX files in Word can often have overlapping tracked changes: Writer tries to split these up to make sure there is only one tracked change under the cursor at the same time. Still, it's possible that you have a tracked change with multiple types: e.g. a delete on top of an insert.
The focus in on 3 combinations which appear in DOCX files a lot: "insert, then delete", "insert, then format" and "delete, then format".
This mostly affects the UI and import/export filters of ODT and DOCX.
Given an insert, then delete:
Most operations worked nicely here, but in case your cursor was in the middle of AAA and you did a reject, followed by an undo, proper handling of that was missing, now implemented.
But then given an insert, then a format:
Then a handling of more actions were missing:
The combined implementation of these should give you a smooth feeling in case you're used to how Word works: if there is a format redline combined with an insert, then the operations act on the insert type, and format is only accepted/rejected when there is no insert "under" the format.
Similarly: it's a bit of an implementation detail that Writer splits redlines on DOCX import: so if you e.g. accept AAA then we combine that with BBB and CCC when it makes sense, so you need to click a lot less.
Finally, given a delete, then a format:
Then again handling of some actions were missing:
The current state is not yet complete, but it's a big improvement over what we had in the past, which was mostly focusing on just "insert, then delete".
You may wonder what about some other cases: if you insert some content with change tracking, that always creates a new tracked change, so "insert" is never on top of something else. Similarly, format is always on top of something. Finally the same type is never on top of itself.
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes. Core side:
You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (25.8).
This deal unites the largest team of corporate Office engineers to deliver on Collabora Productivity’s mission to restore Digital Sovereignty to its users, while making Open Source Office Rock. It supercharges Collabora’s Online Office products and services portfolio with rich German language capability, deeper experience of vertical applications, new Web Assembly skills, and a wider unified partner ecosystem. Through improved product richness this sharpens the competitive edge of FLOSS Office productivity against mass-market proprietary alternatives.
CAMBRIDGE, UK – May 28th 12:00 CEST – 2025
Collabora Productivity, the world’s leading provider of collaborative Open Source Office editors have completed a merger with allotropia. Collabora has invested heavily in building Collabora Online (COOL) – a market leading, on-premise, secure, interoperable, open-source solution for document editing and collaboration deployed to any modern browser. This is complemented by desktop and mobile apps across Linux, Windows, Mac, Android, iOS and Chrome-OS. Collabora provides support subscriptions to enterprise customers worldwide via a network of hundreds of trusted partners. This is now augmented by allotropia’s partner and customer base. Together with our partners we deliver document and productivity excellence integrated with our partners product and service offerings.
allotropia’s expertise around Web Assembly combined with Collabora Online will we expect, in time, enable customer use-cases such as well as office-as-component embedding scenarios in vertical applications as well as off-line and end-to-end encrypted editing, and. This work builds on some visionary prototype funding from the Bundesministerium des Inneren (BMI) for a collaboration between the companies to enable the use of Collabora Online off-line in the browser.
Further details of product investment, and direction will be announced and decided in workshops with our key customers and partners at our annual COOL Days conference in Budapest next week where staff, community and our customer and partner-ecosystem meet, swap ideas, and hear about the latest work in our upcoming major release featuring improved performance, usability, interoperability and much more.
“Collabora is excited to welcome each member of the allotropia team today!” said Michael Meeks, CEO, Collabora Productivity, “We are excited to work together to accelerate our product development, enjoy our first COOL Days together, and plan the next features and possibilities to delight our customers.”
Collabora has invested in building a network of hundreds of partners and is approaching one hundred million docker image downloads of its document editing server software, with millions of paying users of its products, all of whom will start to benefit from this merger from today.We expect to bring the experience that allotropia has from it’s relationship with CIB around vertical desktop applications (Fachverfahren) to help partners and customers migrate their Windows & Microsoft Office based business process to easy to deploy multi-platform web applications.
“With our awesome team of engineers, and our WebAssembly know how, we can add significantly to Collabora’s powerhouse of Office engineering prowess & their product offerings”, says Thorsten Behrens, CEO of allotropia, “we’ve worked with them as partners for many years, and align perfectly in our goals to make Open Source office rock!”
allotropia’s skills in supporting and contributing to the LibreOffice code-base in Germany strengthens and unifies popular shared partner products such CIB Office and Nextcloud Office. A larger team will accelerate development and improvement of Collabora Office based products, while providing an even deeper pool of support resources to rapidly respond to customers’ needs.
Together we want to pay tribute to the vast legacy of those who have worked so hard to preserve and improve the source code that we depend on from Sun Microsystems, Oracle, SUSE, RedHat, IBM, TDF, Canonical, and many more, as well as the innumerable volunteer community contributors who make the Collabora Online and LibreOffice ecosystem so rich and interesting: thank you allowing us the privilege of working alongside you as we revolutionize the office productivity world together.All of our code is open source and available to the public on GitHub. Join the Collabora Online Community, take part in easy hacks and discussions in the forum.
Please also see our new parent company’s mirror announcement!
Yesterday I merged a fix for Writer’s tdf#165094. Not that it was something exceptional; something that often happens when we change the huge code: a regression. Something that we try to do for them: a fix. Why mention it here?
It happens to show something, that people underestimate. The complexity of what they call “proper testing” – you know, that “I found a bug! Do you even try to test your software???” rant you often see in discussions. Let’s look at this case.
The problem was, that in some specific document, where there was a manually inserted page break, that page break, defined in a hidden paragraph, disappeared after an upgrade. Sounds easy? Should be caught immediately in the release testing? But other page breaks weren’t lost.
Debugging showed, that the bug would only occur when all of the following happened:
I suppose, that’s a combination of factors, that any QA engineer would naturally test first, don’t you agree? (Disclaimer: no I don’t think so.)
Note that the complexity of this constellation of causing factors is, again, not uncommon in our codebase. In fact, it only needed less than ten features to take their specific forms, from thousands of features and options that the suite offers.
But it is completely unsurprising, that the bug, that requires such a constellation of factors, actually appeared in our bug tracker. Given the tens of millions of users, who work with who knows how many documents, every low-probability event will happen, sooner or later. This is good; and we are thankful to everyone who files bugs.
And let me say, that we at Collabora Productivity are glad to do many good things to make the office suite better for everyone.
Writer has the concept of rejecting tracked changes: if a proposed insertion or deletion is not wanted, then one can reject it to push back on the proposal. So far such an action left no trace in the document, which is sometimes not wanted. Calling reinstate on a change behaves like reject, but with history: it reinstates the original state, with the rejected change preserved in the document.
This work is primarily for Collabora Online, but the feature is available in desktop Writer as well.
When Alice works on a document to insert e.g. new conditions for a contract, then perhaps Bob is not happy with the proposal. But just rejecting the change "silently" would not be polite: the tracked change then disappears, so possibly Alice thinks it was accepted and Bob didn't communicate the pushback explicitly in the resulting document, either.
Reinstate is meant to improve this interaction: if an insert is reinstated, then an explicit delete is created on top of the insert, so Alice can see that Bob was not happy with the proposal. Or in case Alice proposed a delete, Bob can reinstate that by adding the same content again to the document, without typing the text manually after the delete.
This is a UI feature: the resulting model still only contains inserts and deletes, so it works even with DOCX files.
Given an insert:
Now you can easily create a delete on top of the insert:
And given a delete:
Now you can easily create an insert right after the delete, preserving complex content:
As you can see, this creates the opposite of the original change as a new tracked change, so it will in the end still reject the change, but without deleting the original change.
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes. Core side:
Online side:
You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (25.8).
by Popa Adrian Marius (noreply@blogger.com) at April 30, 2025 11:36 AM
by Popa Adrian Marius (noreply@blogger.com) at April 30, 2025 07:24 AM
As a LibreOffice user, you have certainly seen the LibreOffice splash screen. It is displayed when you open LibreOffice, it has a progress bar, and when loading the application is finished it goes away. Here we discuss a suggested improvement for this splash screen.
Currently, the splash screen is implemented by creating a custom widget with a custom painting mechanism that draws the splash image and also the progress bar and moves the progress indicator.
This has some drawbacks:
1. The splash screen does not always scale to the same size as the main LibreOffice Window.
2. The style of the progress bar is somehow different from other UI elements, looks mostly like gen interface.
3. It needs and uses a custom paint code.
4. It does not conform to the dark/light theme.
5. It is not easily localize-able. In fact, the only text is from the displayed image, in English. When you build from sources, the image file is instdir/program/intro.png.
LibreOffice splash screen bitmap
6. It is a separate binary (oosplash). You may run it with:
$ ./instdir/program/oosplash
LibreOffice dev splash screen
I have previously written about VCL weld mechanism, which is based on creating user interface files (.ui) and loading them inside the application.
The weld mechanism greatly reduces the complexity of creating user interfaces, and also improves other aspects of the user interface, including the consistency.
Most of the code for the current implementation resides in:
desktop/source/splash/splash.cxx.
The SplashScreenWindow class has an custom paint method, SplashScreenWindow::Paint(), which draws the bitmap, and also the progress. A new UI file is needed for this purpose, which should use GtkProgressBar, which will be considered a weld::ProgressBar. VCL then uses appropriate progress bar widget in different graphical plugins of VCL.
You may look into some dialogs like tip of the day to get some insight:
It would be interesting to avoid a separate binary, but it is fine to keep things as is, and just change to use .ui file.
The above issue is tdf#166128. If you would like to work on fixing it, you can just follow the Bugzilla link to see more information.
You may also use ideas from a minimal weld application here:
by Popa Adrian Marius (noreply@blogger.com) at April 08, 2025 09:17 AM
by Popa Adrian Marius (noreply@blogger.com) at April 07, 2025 11:11 AM
Writer has the concept of recording tracked changes or not: if recording, typing into a document or deleting content will create tracked changes of type insertion or deletion. So far this was a per-document setting, but now individual users can enable or disable this as they wish.
This work is primarily for Collabora Online, but the feature is available in desktop Writer as well.
When Alice keeps typing and Bob enables change tracking, then surprisingly the typed characters of Alice will form a tracked insertion, which is surprising, since that was not the case a second ago and Alice didn't do anything other than typing.
Giving users a choice if they enable recording for just this user or for all users fixes this problem.
Here is how the per-user (technically per-view) tracked changes recording looks like:
As you can see, the user on the left has recording turned on and this doesn't influence the user on the right, while this was not possible before.
If you would like to know a bit more about how this works, continue reading... :-)
As usual, the high-level problem was addressed by a series of small changes. Core side:
Online side:
You can get a development edition of Collabora Online 25.04 and try it out yourself right now: try the development edition. Collabora intends to continue supporting and contributing to LibreOffice, the code is merged so we expect all of this work will be available in TDF's next release too (25.8).
We’ve added a great new Vue.js-3 ZetaJS demo (source)! It showcases word processing and spreadsheets inside a single web app. Calc is being used as a data source for an HTML app, filling letter templates in Writer. You can even upload custom data spreadsheets or document templates! And have you seen the nice Writer toolbar, all done with Vue.js?
We’ve also updated the existing demos, showcasing Chrome PWA support with the Ping Monitor demo – just click the little install button at the top-right of the address bar, to get the Ping Monitor “installedâ€� on your desktop!
Meanwhile, our team was giving some great talks about our work for ZetaOffice and LibreOffice. Why not check out the recordings during your lunch break?
Look, we made some headlines! TheRegister was following up some earlier coverage about the WebAssembly port, after Thorsten gave Liam a demo during FOSDEM. Read up the full article here.
In case you’re around, meet us in two weeks at the FOSSAsia Summit in Bangkok, where Sarper Akdemir will give an update over our work. Dates are March 13-15.
If you’re based in Europe, you might instead enjoy Thorsten’s talk at the Chemnitz Linux Days (Germany) from March 22-23.
Looking forward to meet you there!
Please subscribe to our Newsletter or on Mastodon and let us know how you liked ZetaJS and the demos! If you’re playing with the code leave a star at the ZetaJS repo or if you hit any issues please file a report on GitHub.
Or just leave a comment and let us know directly – thanks for reading! 
For the past two months, I’ve been working on adding more templates to LibreOffice Writer as part of my Outreachy project. My goal has been to create functional templates that users need the most.
I created these templates based on what you told us in our survey and your response was incredible!…
by Popa Adrian Marius (noreply@blogger.com) at February 26, 2025 10:57 AM
LibreOffice inherits a gigantic code base from its ancestors, StarOffice and OpenOffice. Here I discuss some notes for the newcomers on how to better understand the existing LibreOffice code, and improve the patches.
As said, LibreOffice is a huge code base, containing ~10 million lines of mostly C++ code. There are different assumptions, conventions and coding styles across ~200 modules that LibreOffice has.
Therefore, it is important to first, study the existing code, through reading and debugging LibreOffice source code, to understand the things that it does, and the way you can implement your ideas, including bug fixes and adding new features.
And although implementing some ideas seem to be straightforward at first sight, it is meaningful to study the details.
First of all, you should understand the thing that you want to implement. No matter if it is a bug, a new feature, or just an EasyHack, you should understand what is requested, what works and what does not work. This requires careful reading of the Bugzilla pages.
Then, you should try to run LibreOffice to understand the exact place in the application where you want to change. LibreOffice user interface has thousands of dialog boxes, so you need to make sure that you understand the thing that you want to do.
And at last, you get into implementing something in the code. Here are some questions that you can ask yourself about the details, when reading the existing code:
git blame to see the last author of a specific linegit log to study the details by knowing the commit hash
git log
Or, you may be interested in the code behavior in the big picture:
You can do some small changes, before even getting into implementing your idea:
Then, you can work on the actual implementation. Ask yourself:
After understanding some of the basic details about the way things work, you may go into improving your implementation.
These were the questions to give you some ideas of some of the underlying complexities in the code. You can start from small changes to become familiar with these complexities, and then grow to do more complex stuff in the code.
We have various different EasyHacks in LibreOffice, with different difficulty levels. If you are interested in coding, you can always find something that fits you, and grow gradually.
You can read more in these links:
When you want to interact with users, sometimes simple dialog boxes are sufficient: a simple yes or no, or some info box. But in other cases, you may need more complex message boxes. Here I discuss how to use VCL Weld to create a custom one.
You can create a simple message box, using predefined templates like Info box using a code snippet like this:
std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(pParent, VclMessageType::Question, VclButtonsType::YesNo, u"Are you sure?"_ustr)); xInfoBox->run();
And, this is the result, which is very simple, without any title bar:
Yes / No message box
There are other predefined types, which can be used in different scenarios:
enum class VclMessageType { Info, Warning, Question, Error, Other };
But, if you want custom message boxes, you should be using weld mechanism, with its CreateBuilder function.
Below is the code from the source code sfx2/source/doc/QuerySaveDocument.cxx, which is inside sfx2 (framework) module. This dialog box is accessible across different modules, including Writer, Calc and Draw/Impress.
Let’s look into the code:
short ExecuteQuerySaveDocument(weld::Widget* _pParent, std::u16string_view _rTitle) { ... std::unique_ptr<weld::Builder> xBuilder( Application::CreateBuilder(_pParent, u"sfx/ui/querysavedialog.ui"_ustr)); std::unique_ptr<weld::MessageDialog> xQBox( xBuilder->weld_message_dialog(u"QuerySaveDialog"_ustr)); xQBox->set_primary_text(xQBox->get_primary_text().replaceFirst("$(DOC)", _rTitle)); return xQBox->run(); }
The code is using a UI file, named sfx/ui/querysavedialog.ui to create a message dialog, and then change the title of it.
QuerySaveDialog
If you look into the include file, include/vcl/weld.hxx inside Builder class, you may see functions like weld_… that are suitable to find various different UI elements from the UI, by mentioning the element ID. For example, to find a label with the ID equal to lable_id, you do this:
std::unique_ptr<weld::Label> m_pTextLabel label = m_xBuilder->weld_label(u"label_id"_ustr)
This is the result, when you try to close an unsaved document.
QuerySaveDialog running
This is not the only way you can create nice dialog boxes using VCL weld mechanism. There are some predefined message boxes that look nice which use weld mechanism, and are available for use via relevant C++ classes.
An interesting one here, is the QueryDialog, which is created by a factory method design pattern.
It uses a predefined dialog, using cui/uiconfig/ui/querydialog.ui as the UI file, and it contains a nice stock image! You can test it easily, by modifying a LibreOffice example, minweld.
IMPL_LINK_NOARG(TipOfTheDayDialog, OnNextClick, weld::Button&, void) { VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create(); auto pDlg = pFact->CreateQueryDialog(getDialog(), u"Tips"_ustr, u"Tip of the day"_ustr, u"Are you sure you want to see the next tip of the day?"_ustr, false); sal_Int32 nResult = pDlg->Execute(); pDlg->disposeOnce(); if(nResult == RET_YES) { ++m_nCounter; m_pTextLabel->set_label(u"Here you will see tip of the day #"_ustr + OUString::number(m_nCounter) + "."); } }
Assuming that you have a working build of LibreOffice, you can simply run the minweld workbench by invoking:
./bin/run minweld
The result looks much more interesting:
QueryDialog
The possibilities are endless! It only depends on your ideas and understanding of the user’s needs and requirements. It would be good if you look into what design team does to understand the design process:
Happy new year 2025! I wish a great year for you, and the global LibreOffice community. Now that we are now in 2025, I briefly discuss the year 2024 and outlook for 2024 in the development blog.
LibreOffice Conference 2024, Luxembourg
At The Document Foundation (TDF), our aim is to improve LibreOffice, the leading free/open source office suite that has millions of users around the world. Our work is community-driven, and the software needs your contribution to become better, and work in a way that you like.
My goal here, is to help people understand LibreOffice code easier, and eventually participate in LibreOffice core development to make LibreOffice better for everyone. In 2024, I wrote 22 posts around LibreOffice development in the dev blog (4 of them are unpublished drafts).
Focus of the development blog for 2025 in this blog will be:
I have written about some of these topics in 2024. Therefore, this year I will try to expand the previous writings and provide new articles about them. For example, creating user interfaces using VCL with the help of glade interface designer will be one of important things to discuss.
You can give feedback by writing a comment here, or sending me an email to hossein AT libreoffice DOT org.
We provide mentoring support to those who want to start LibreOffice development. You are welcome to contact me if you need help to build LibreOffice and do some EasyHacks via the above email address. Also, you can always refer to our Getting Involved Wiki page:
Let’s hope a great year for LibreOffice (and the world) in 2025.
LibreOffice Writer has long been a trusted tool for users worldwide, offering an open-source solution for documents. But what happens when we take a step back and look at the user experience? How do templates fit into the workflows of users, what makes a great template and where do users want LibreOffice writer to improve?…
Since the first implementation of a dark color theme we continuously improved the customization of LibreOffice. In a GSoC projects this year, Sahil Gautam made it possible to not only change the application colors but also what is defined by the operating system respectively the desktop environment.…
Let me count the ways, in no particular order and in no way exhaustive:
std::unique_ptr<SalLayout> ImplLayout( const OUString&, sal_Int32 nIndex, sal_Int32 nLen, const Point& rLogicPos = Point(0, 0), tools::Long nLogicWidth = 0, KernArraySpan aKernArray = KernArraySpan(), std::span<const sal_Bool> pKashidaArray = {}, SalLayoutFlags flags = SalLayoutFlags::NONE, vcl::text::TextLayoutCache const* = nullptr, const SalLayoutGlyphs* pGlyphs = nullptr, std::optional<sal_Int32> nDrawOriginCluster = std::nullopt, std::optional<sal_Int32> nDrawMinCharPos = std::nullopt, std::optional<sal_Int32> nDrawEndCharPos = std::nullopt) const;
by Chris Sherlock (noreply@blogger.com) at November 29, 2024 10:58 PM
This post is about recent improvements for ZetaJS, the JavaScript wrapper library for ZetaOffice’s WebAssembly version of LibreOffice:
There is something of a mismatch between the UNO type system and the JavaScript types used by zetajs. For example, JavaScript only has a single number type for both integer and floating point values, while UNO has a whole slew of different numeric types (BYTE, SHORT, UNSIGNED SHORT, LONG, UNSIGNED LONG, FLOAT, DOUBLE) that all map to that one JavaScript type. Similarly, the different UNO sequence<T> types all map to JavaScript arrays, where information about the UNO element type T is lost.
Normally, that’s not an issue. When you call a UNO method that returns a LONG, you get a number just like when you call a UNO method that returns a DOUBLE, and your JavaScript code then has a number to work with, and that’s all. Similarly, when you call a UNO method that returns a sequence<LONG>, you get an array of numbers you can work with, just like when you call a UNO method that returns a sequence<DOUBLE>. And when you then call a UNO method that takes a seaquence<LONG> as an argument, you pass in an array of numbers, and the zetajs runtimes figures out how to dress that array up as a UNO sequence<LONG>, and all is well.
However, one place where UNO’s insistance on more precise typing gets in the way is the UNO ANY type. It is not just a means to transport any kind of UNO value, it also carries precise type information. A UNO ANY value that contains a LONG of value 1 is something different than a UNO ANY vlaue that contains an UNSIGNED LONG of value 1. And a UNO ANY value that contains a reference of type css.uno.XInterface to some UNO object is something different than a UNO ANY value that contains a reference of type css.lang.XComponent to the same UNO object.
Again, most of the time, those precise distinctions are irrelevant to most of the code. When you call a UNO method that returns an ANY, and you know that that ANY value must contain a LONG, you just want to get a JavaScript number out, regardless of what precise numeric UNO type was encoded in that ANY value. Similarly, when you call a UNO method that returns an ANY that must contain a css.uno.XInterface reference, you just want to get some JavaScript object that you can do further UNO method calls on (or null), regardless of what precise UNO interface type was encoded in that ANY value. And when you then call a UNO method that takes an ANY that must contain a LONG, you want to just pass in a JavaScript number, and the zetajs runtime shall figure out how to dress that up as a UNO ANY containing a LONG (or throw an exception, if you passed something that just can’t be dressed up accordingly).
But, sometimes, you need more fine-grained control. There might be a UNO method that takes an ANY argument and behaves completely differently when you pass it a LONG of value 1 or an UNSIGNED LONG of value 1. But when you call that UNO method with the JavaScript number 1, zetajs will always dress that up as a UNO ANY of type LONG for you, never as an UNSIGNED LONG. To solve that issue, the zetajs UNO binding also has the notion of a zetajs.Any JavaScript type, which records a value along with its precise UNO type. You can thus pass either a new zetajs.Any(zetajs.type.long, 1) or a new zetajs.Any(zetajs.type.unsigned_long, 1) when you call that picky UNO method.
Now, when a UNO method returns an ANY value, the zetajs binding used to be conservative: You might want to know exactly what UNO type it contains (even though, most of the time you don’t actually care), so it always returned those wrapped zetajs.Any objects that carry the precise contained UNO type. But that lead to awkward code. When you call e.g. x.nextElement() to get a UNO ANY that contains a reference to another UNO object, you had to unwrap that first (with zetajs.fromAny) before you could do any further calls on the obtained UNO object: zetajs.fromAny(x.nextElement()).doSomething(). But you know that this call to x.nextElement() will return an ANY containing an interface reference, and you don’t care about the exact UNO interface type—you just want to do another method call on the obtained object.
So, recently (in Let zetajs return unwrapped ANY representations), the zetajs binding was changed so that it now always returns unwrapped UNO ANY values: x.nextElement() no longer returns a zetajs.Any wrapper (on which you would need to call zetajs.fromAny first), it directly returns the relevant JavaScript object. And the resulting overall code looks way better: x.nextElement().doSomething().
When, in the other direction, you pass something into a UNO method that takes an ANY argument, you still have the same options you had before: Either, you simply pass the JavaScript number 1, and zetajs figures out for you that that should be dressed up as a UNO ANY of type LONG, or you want to be picky and pass in either a new zetajs.Any(zetajs.type.long, 1) or a new zetajs.Any(zetajs.type.unsigned_long, 1).
And when it comes time that you do want to be picky about the ANY values that you obtain as return values from UNO method calls, there’s now a $precise way to do that: x.$precise.nextElement() (and same for any other UNO method call) will always give you back a wrapped zetajs.Any value. See the updated The zetajs UNO Mapping for all the details.
LibreOffice uses VCL (Visual Class Library) as its internal widget toolkit to create the graphical user interface (GUI) of LibreOffice. Here I discuss how to use UI files designed with Glade interface designer to create LibreOffice user interfaces with a framework called weld, which is part of LibreOffice core source code.
In my previous blog post, you can find out about the structure of a minimal VCL application. Please refer to the below blog post to see how a Window is created in VCL, and how it can be used as a test workbench called minvcl. You can run it with ./bin/run minvcl after you build LibreOffice.
Here I discuss how to go further, and create user interface with Glade interface designer, and do most of the things without writing code.
In order to simplify user interface creation in LibreOffice, experienced LibreOffice developer, Caolán, has introduced a mechanism to load UI files created with Glade interface designer, and use them as if they are UI files for each and every GUI framework that LibreOffice supports: from GTK itself to Qt, Windows, macOS and even the so-called gen backend that only requires the X11 library on Linux.
To illustrate how the VCL weld mechanism works, I have added a minimal example, minweld, as a test workbench. The structure of the code is very similar to the previous example, minvcl, but there are some changes in the code. In the new code, UI is created from a .ui file that is designed visually with Glade interface designer. The .ui file is an XML file which contains placement of widgets that should be displayed on the screen.
The complete code for minweld is available in the LibreOffice core source code repository, which can also be viewed online:
In minweld, I have used an existing Glade UI file, tipofthedaydialog.ui. This is the user interface for displaying a tip of the day in LibreOffice at startup. Heiko, the TDF design mentor, has discussed this dialog box in detail before:
But, you can assume that it is a simple .ui file, that one can create with Glade. Here, we use it to create our own user interface in C++. You may use any other .ui file that you have created with almost the same code.
Tip of the day displayed at LibreOffice startup
This UI file is found in cui/uiconfig/ui/tipofthedaydialog.ui, and minweld loads it. This is how it looks when you open it in Glade interface designer:
tipofthedaydialog.ui in Glade user interface designer
Let’s look into the specifics of minweld.cxx.
Headers are almost the same, but here we use vcl/weld.hxx instead of vcl/wrkwin.hxx. Therefore, you can see this line in the code:
#include <vcl/weld.hxx>
Then we have the C++ code for the application. The TipOfTheDayDialog class is defined with:
class TipOfTheDayDialog : public weld::GenericDialogController { public: TipOfTheDayDialog(weld::Window* pParent = nullptr); DECL_LINK(OnNextClick, weld::Button&, void); private: std::unique_ptr<weld::Label> m_pTextLabel; std::unique_ptr<weld::Button> m_pNextButton; sal_Int32 m_nCounter = 0; }; ... }
As you can see, TipOfTheDayDialog inherits from weld::GenericDialogController, and not Application class as before. Also, TipOfTheDayDialog constructor receives a parent of type weld::Window*, which is nullptr now. The reason is that there is no parent window in this example. Using weld:: prefix is also done for other types of widgets that we use in LibreOffice. For example, we use weld::Button to denote a push button in LibreOffice, or in any application that is created with the vcl::weld mechanism.
This is the code for the TipOfTheDayDialog constructor. Here, we initialize two member variables, m_pTextLabel and m_pNextButton which point to a label and a button, respectively. We will interact with these two in our code. There are string literals like lbText and btnNext , which are the IDs of those widgets in Glade. The IDs should be unique for linking to specific variables in the code.
TipOfTheDayDialog::TipOfTheDayDialog(weld::Window* pParent) : weld::GenericDialogController(pParent, u"cui/ui/tipofthedaydialog.ui"_ustr, u"TipOfTheDayDialog"_ustr) , m_pTextLabel(m_xBuilder->weld_label(u"lbText"_ustr)) , m_pNextButton(m_xBuilder->weld_button(u"btnNext"_ustr)) { m_pNextButton->connect_clicked(LINK(this, TipOfTheDayDialog, OnNextClick)); }
One last step is linking the events with functions in the code. You may do that with the LINK macro. In the last line, connect_clicked activates OnNextClick from the class TipOfTheDayDialog, whenever m_pNextButton is clicked.
This is the implementation of the event handler. It should be started with IMPL_LINK macro, in the form of IMPL_LINK_NOARG(Class, Member, ArgType, RetType). The code is straightforward: It increases a counter which is initially zero, and displays it alongside a text:
IMPL_LINK_NOARG(TipOfTheDayDialog, OnNextClick, weld::Button&, void) { ++m_nCounter; m_pTextLabel->set_label(u"Here you will see tip of the day #"_ustr + OUString::number(m_nCounter) + "."); }
With a call to set_label function, m_pTextLabel is updated every time that you click on “Next Tip” button.
You may run the example after you have built LibreOffice from sources. Then, you may simply invoke:
./bin/run minweld
The result is a little bit different from the tipoftheday dialog in LibreOffice, as it does not use a picture. But, it has a nice feature: if you click on “Next Tip”, it will show a text and a counter that goes up whenever you click on it again.
You may look into the original “tip of the day” dialog box in cui/source/dialogs/tipofthedaydlg.cxx, which is more complex than the one that we created here, as it reads some data from the configuration and uses images. But, the idea is the same. Inherit a class from GenericDialogController, define and link variables to the widgets with their IDs, add event handlers. Now, the application with VCL graphical user interface is ready to use!
This is somehow similar to the way one creates dialog boxes with Qt and other widget toolkits. On the other hand, the VCL weld mechanism is different in the way that it uses such a toolkit to create UI on the fly. Therefore, if you choose a desired VCL UI plugin, then it will use that specific library for creating user interface. For example, you can run minweld example with Qt this way:
export SAL_USE_VCLPLUGIN=qt5 ./bin/run minweld
The minweld example in Qt (light theme)
You may also run it with GTK3 UI, this way:
export SAL_USE_VCLPLUGIN=gtk3 export GTK_THEME=Adwaita:light # For light/dark theme ./bin/run minweld
The minweld example in GTK3 (light theme)
I hope that this explanation was helpful for you to understand the basics of GUI design and implementation in LibreOffice. You can try doing small improvements in LibreOffice GUI by looking into the EasyHacks that with the tag “Design“:
TDF Wiki: EasyHacks categorized by “Design” as the required skill
We welcome your code submissions to improve LibreOffice. If you would like to start contributing to LibreOffice, please take a look at our video tutorial:
Hamburg and Bolzano, November 8th, 2024 – During the two-day annual South Tyrol Free Software Conference, allotropia software GmbH today announces beta versions of its new product line “ZetaOffice”.
ZetaOffice is a new set of applications, libraries and services, all powered by the LibreOffice Technology stack. Featured among its products is ZetaJS, an innovative browser-based plugin, with unique programmability & embeddability – the perfect tool for complex office editing, process automation and line-of-business applications in the web.
Additionally, leveraging the unique portability and flexibility of the LibreOffice Technology stack, ZetaOffice will be available in bit-by-bit identical versions (allowing for perfect interoperability and feature parity) also for open-source-based mobile operating systems (Android, and derived OS), as well as for all relevant desktop operating systems (Windows, macOS, Linux – via flatpak and snapcraft).
“We’re very excited being able to offer powerful, data-sovereign Open Source office functionality on even more platforms today”, says Thorsten Behrens, owner and managing director of allotropia software. “In particular our innovative, WASM-based browser version of LibreOffice will be a game-changer for every web developer in need of processing, analysing or integrating with office documents.”
“This could not have come at a better time”, says Michiel Leenaars, director of strategy at philanthropic investor NLnet Foundation. “It is long overdue but certainly in the wake of the recent geo-political developments, we all recognise the urgent need for Europe to regain its technological independence when it comes to core technologies – as boring as these may seem. ZetaOffice shows that Europe has the talent and capacity to break with the past and create new paradigms and use innovation and collaboration to save the day.”
“ZetaOffice is the perfect addition to our portfolio of tools for document and business process automation”, says Uli Brandner, CEO and owner of CIB Group. “With solutions like CIB flow for workflow modeling and CIB coSys for high-quality template management, CIB Group already offers powerful digitalization tools. As demand grows to bring proven applications to the web and stay on the cutting edge of technology, ZetaOffice stands out as an innovative solution precisely tailored to our customers’ needs.”
A detailed blog post, including links to beta versions of the software, is available here.
For the products, please refer to our website at zetaoffice.net.
ZetaOffice and the team at allotropia thanks the European Commission’s Next Generation Internet initiative/NGI Zero for its financial contribution to the development of this software.
About ZetaOffice:
ZetaOffice is a product line based on LibreOffice Technology, comprising of desktop LTS products for classical office productivity requirements; a browser-native version based on WebAssembly for fast, client-side integration and automation of office technology; and an
upcoming mobile app widget, for deep integration in mobile line-of-business applications. ZetaOffice is focused on speed, superb embeddability, excellent inter-product as well as Office compatibility, and geared towards digital-sovereign & data protection needs.
About ZetaJS:
ZetaJS is a JavaScript library, available via the npm package manager, to enable developers to quickly & conveniently embed ZetaOffice WebAssembly in web applications. ZetaJS makes available the entire gamut of the LibreOffice programmability interfaces, providing a web-native component for JavaScript developers to deeply embed an office suite into their web apps. In contrast to classical cloud-office setups, ZetaJS can be used as an integral, client-side part of any web application – permitting users to interact with office documents as part of a larger application framework, with very low latency. That way, e.g. direct integration for editing, suggestions or running calculations in complex spreadsheets can be provided. Similarly, it’s trivially easy to implement direct, client-side rendering and export of office documents into PDF or HTML – all via a self-hostable, digital-sovereign Open Source solution.
About allotropia software GmbH:
The company allotropia software GmbH provides services, consulting and products around LibreOffice and related opensource projects. Founded in 2020 by long-time developers of the project, its stated mission is to make LibreOffice shine – in as many different shapes and forms as necessary to serve modern needs towards office productivity software. allotropia software GmbH is headquartered in Hamburg, Germany at the birthplace of the OpenOffice/LibreOffice project. For more information, visit allotropia.de, or follow fosstodon.org/@allotropia on Mastodon and LinkedIn: www.linkedin.com/company/allotropia-software-gmbh
| Imprint Privacy Policy | |
|
The Document Foundation is not responsible for the content on planet.documentfoundation.org. However - if you have any concerns about content please contact Uwe Altmann for moderation. Copyright information: Unless otherwise specified in the author's blog, all text and images on this website are licensed under the Creative Commons Attribution-Share Alike 3.0 License. This does not include the source code of LibreOffice, which is licensed under the Mozilla Public License (MPLv2). |
|