Open-source project
ranuts/document avatar
ranuts/document

document uploads nothing, but keeps a local copy of your file for seven days

Edit DOCX/XLSX/PPTX in your browser — client-side, no server, works offline (OnlyOffice + WebAssembly)

2,023 stars230 forksHTMLAGPL-3.0

At a glance

What is it?
A browser-based editor for Word, Excel and PowerPoint files that runs the office engine and its converter as WebAssembly on the visitor's own machine. The privacy story is genuinely good. The storage story is subtler than the headline, and the self-hosted default has no authentication at all.
Who is it for?
This is worth trying if you edit documents you would rather not upload anywhere, because the architecture genuinely delivers on that: there is no server component to leak your file to. Three things to check first.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository last received commits 9 days ago.
What is it written in?
Mainly HTML, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • ranuts/document2,023 ★ · +87
Star history
Repository2026-09-122026-11-15
ranuts/document1.9k2k

87 Stars in the last 64 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The self-hosted default has no authentication

The one line most people will copy has no login in front of it.

The quick start runs a published container image and publishes a port. The compose file beside it has the same shape, and everything security related is commented out under a heading for advanced configuration.

The commented block contains basic authentication, and the comments are careful about how it works: the value takes a username and a password, the password must be hashed with BCrypt rather than supplied in plain text, and there is a note about escaping the dollar sign in the shell environment when you paste the hash back. Alongside it are options to serve over TLS, pointing at a certificate and a private key.

So the protection is real once you switch it on, and the escape note suggests someone has actually done it. The problem is that it is off by default, and the published port means a default self-host is an unauthenticated document editor reachable by anything on that network.

The quick start command itself is short enough to paste without reading anything else:

bash
docker run -d --name document -p 8080:80 ghcr.io/ranuts/document:latest

Uncommenting four lines fixes it. Nothing in the quick start tells you the four lines exist.

Edits are kept in the browser for seven days, and it says they are not a backup

The privacy claim is that nothing is uploaded, and the architecture supports it. But the page is equally clear that the browser keeps copies.

While you work, the editor writes the document into the browser's own database so that a refresh, a closed tab or a crash does not cost you the session. Reopening the editor offers it back. And every stored document is deleted automatically seven days after you last edited or opened it, whether or not you come back.

The sentence that makes this section worth reading is the disclaimer: those copies exist so you can pick up where you left off, they are not a backup, and you should keep exporting anything you actually want to keep.

That is an unusual thing to say about your own safety net, and it is the honest framing. The copies are there to survive a refresh, not to survive a decision.

A history route lists everything stored, with a delete on every row, a delete-all, and a switch that turns autosave off entirely. Deleting there takes effect immediately, and the page says outright that on a shared machine this is the one to visit.

Embed mode turns the crash protection off

The embedding story is a full message-based interface, and it changes the storage model rather than just the layout.

You put the editor in an iframe pointed at the embed parameter, then open documents by posting a message with a document type and a URL, and you listen for an opened event and a saved event. On save the payload carries the file, and your host uploads it. The full reference covers every message type, the origin allowlist, read-only mode and the save flow.

The line that matters is this: embedded editors keep no local history, because the document belongs to the host page.

So the feature that stops a closed tab from costing you work is simply absent in embed mode. In exchange, an embedded instance stores nothing about your documents, which is the right trade for a host that already has its own persistence and its own access control.

It does mean the integration contract includes persistence. If your host does not handle the saved event, a crash loses the session, and nothing in the editor will have kept a copy.

Writing back into the file you opened only works in one browser family

The saving feature is presented as a headline and it is worth reading the qualifier attached to it.

The claim is that you pick your file once and every save after that writes back to it, so the document stays where it lives rather than accumulating in a downloads folder. The qualifier, in the same bullet, is that this applies in Chromium-based browsers and that everywhere else it downloads as before.

That is a file system access API difference, and it is not something a web application can work around. The consequence is that two users on the same team can have materially different behaviour with no error and no visible difference in the interface.

The format handling is more careful. Legacy binary and open formats are listed as openable alongside the current ones, PDFs can be annotated and exported, and anything can be exported to PDF. Comma-separated values get particular attention: three encodings are detected on open and preserved on the way back out, which is the kind of detail that only matters to someone who has lost a file to a mojibake bug.

The manifest says 1.0.0 and every published tag is 0.0.x

There is a version mismatch between the package manifest and the release history.

The three published releases are all in the zero series, the newest tagged in early September, and the manifest declares version one point zero point zero.

Nothing else in the repository suggests this is a transitional state. The build pins the package manager to an exact version, the runtime image is pinned to an exact version, and there is a dedicated config file whose job is to keep two deployment configurations in sync. The version declaration is the one place where precision stops.

For a self-hoster this is mostly harmless, since the published container image is tagged for the newest build rather than for a manifest version. For anyone pinning a dependency or auditing what they are running, it is the discrepancy that matters, and the answer is to read the tag rather than the manifest.

They abandoned nginx over a one-year asset cache

The container build has a comment that is worth reading in full, because it explains a decision that would otherwise look arbitrary.

The runtime stage uses a single-purpose static file server image, pinned to an exact version, with an alternative nginx-based image left in the file commented out.

The reason is caching. The configuration format the project uses for its hosted deployment is the header-file format of a specific hosting platform, and the static server does not read that format at all. Worse, the server's own defaults are extension-based, so HTML is cached for a day and every stably named script or stylesheet is cached for a year. The practical effect of getting that wrong is that a freshly pulled image can keep serving the previous front end out of the browser's cache.

So the server was chosen, or tolerated, with an explicit configuration file copied in, and the project kept the platform's header file alongside it. A unit test exists whose stated job is to keep the two in sync.

Testing a deployment contract rather than just the application is the part of this that generalises.

Seven interface languages, forty-five editor languages, two parameter spellings

A few smaller decisions in the documentation are worth recording.

The interface claims end-to-end support for seven languages, covering the pages, the application interface and the editor together, and then notes that the editor itself ships forty five. So the number a user sees and the number the vendored engine provides are different, and the project says so rather than implying parity.

Routes are four, and the landing page is specified to load no editor bundle until you open something, which is the right call for a page most visitors use once. The help and changelog routes are generated from markdown files in a content directory rather than hand-written, so documentation changes land in one place.

The URL parameters are where a genuine wart sits. Two parameters open a document from a URL: one current spelling and one legacy spelling. When both are present, the legacy one wins. That is a sensible compatibility decision and a footgun at the same time, since a caller who passes both gets the legacy one without any warning.

One more constraint is stated up front: opening a document by URL requires that URL to permit cross-origin requests.

Editorial conclusion

This is worth trying if you edit documents you would rather not upload anywhere, because the architecture genuinely delivers on that: there is no server component to leak your file to. Three things to check first. Your edits also sit in browser storage for a week, so on a shared machine visit the history page before you leave. Write-back to the file you opened only works in Chromium browsers and downloads elsewhere. And if you self-host it, the shipped configuration has no login, so put it behind your own authentication or a tunnel before you expose that port to a network you do not control.

Frequently asked questions

What is the ranuts/document project?

It is a browser-based editor for Word, Excel and PowerPoint files that runs entirely client-side. The office engine and its converter execute on the visitor's own device as WebAssembly, so documents are never uploaded and no account is involved. It can be self-hosted as a container or served as a static directory.

Are my documents uploaded anywhere when I edit them?

No. Every conversion, edit and export happens in the browser tab. Where the browser allows it, saving writes straight back into the file you picked. Edits are also autosaved into your own browser for seven days, and the project states plainly that those copies are not a backup.

How do I delete documents stored in the browser?

A history route lists what the browser is holding, with a delete on every row, a delete-all, and a switch that turns autosave off entirely. Deleting there takes effect immediately. Stored documents are also removed automatically seven days after you last edited or opened them.

Does the self-hosted version of document require a login?

Not by default. The published image and the compose file both ship with the authentication block commented out while publishing the port. When enabled it takes a username and a BCrypt-hashed password, with options to serve over TLS from a certificate and private key.

Which file formats can document edit?

It edits the current XML formats for documents, spreadsheets and presentations, plus comma-separated values. It opens the legacy binary and open equivalents, rich text and plain text, and can annotate and export PDFs. Any document can be exported to PDF, and CSV encodings are detected on open and preserved on export.

Official sources

  1. License: AGPL-3.0
  2. Project website
  3. ranuts/document on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/ranuts-document.svg)](https://hysenlabs.com/projects/ranuts-document)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/ranuts-document.svg)](https://hysenlabs.com/projects/ranuts-document)

Was this useful?