Star on GitHub Live co-editing Apache-2.0 + MIT 398 e2e green

The open-source
Google Docs & Sheets
you actually self-host.

A free, real-time collaborative office suite that opens native .docx and .xlsx in the browser and saves them back byte-for-byte — plus a high-fidelity PDF editor. Co-edit live, then docker run the whole thing on your own box. No accounts, no SaaS.

Star on GitHub Try the live demo →
bash — self-host in one command
$docker run -p 3000:3000 casualoffice/sheets
Open Sheets full-screen ↗ Open Editor full-screen ↗ Open OpenCalc full-screen ↗ Open OpenDoc full-screen ↗
sheet.casualoffice.org docs.casualoffice.org calc.casualoffice.org/editor.html opendoc.casualoffice.org/editor.html

Real production demos, not screenshots. Open a real file, edit it, save it back — nothing leaves your browser unless you click Share. The last two tabs are the next-generation Rust engines, OpenCalc and OpenDoc, running as WebAssembly with no server in the loop at all.

CASUAL DOCS 39/39 .docx fixtures · 100% round-trip
CASUAL SHEETS v0.3.3 production-grade · WOPI host
CO-EDIT live verified end-to-end · Yjs CRDT
LICENSE MIT + Apache no AGPL, no copyleft surprises
editors, one suite

A spreadsheet, a document editor,
and a PDF editor. Every line on GitHub.

/products

Casual Sheets

EXCEL-FLAVORED WEB SPREADSHEET

Open .xlsx, .ods, .csv, .tsv. Real-time co-editing, pivot tables with drill-down, 8 chart types with trendlines, sparklines, version history, and .xlsm macro passthrough that round-trips byte-equal.

  • .xlsx · .ods · .csv · .tsv round-trip
  • Pivot tables · 8 chart types · sparklines
  • Real-time via Yjs + Hocuspocus
  • Self-host: memory · local · S3 · Postgres
v0.3.3 · 398 e2e Read more →

Casual Docs

WORD-FLAVORED .DOCX EDITOR

Open .docx in the browser with WYSIWYG fidelity. Fork of eigenpal/docx-editor on top of ProseMirror with an OOXML-preserving model. The stateless Go gateway speaks the y-websocket protocol in roughly 120 lines.

  • .docx round-trip · 39/39 fixtures pristine
  • ProseMirror + OOXML model · page color · table fidelity
  • Yjs + Go y-websocket gateway
  • Co-edit verified end-to-end (smoke + tests)
public preview · npm SDK v1.2.0 Read more →

Casual Slides

POWERPOINT-FLAVORED WEB SLIDES

Open .pptx in the browser with deep OOXML fidelity — 68 of 87 fidelity probes passing. Office-style ribbon, slide-panel thumbnails, layout templates, theme pickers, Slide Show mode. Currently paused while Docs and PDF reach v1.

  • .pptx round-trip · 68 / 87 fidelity ✓
  • Office ribbon · 6 layouts · themes · backgrounds
  • Tables · charts · text outline · arrowheads · effects
  • Fork-and-patch on Univer Slides OSS
paused · not current priority Read more →

Casual Desktop

TAURI BINARIES · macOS · LINUX · WINDOWS

A native binary for macOS, Linux, and Windows that reuses the Casual Docs and Casual Sheets web cores verbatim. Single-user, offline, with signed in-app auto-update. v0.0.6 adds an on-device agentic AI assistant — it plans, edits, and reviews multi-step tasks entirely on your machine. Download v0.0.6.

  • Tauri shell · reuses the web cores
  • On-device agentic AI · plan → execute → review
  • Local model (llama.cpp) · docs never leave the machine
  • Signed in-app auto-update
available · v0.0.6 Read more →

Casual PDF

HIGH-FIDELITY PDF VIEWER + EDITOR

View, annotate, e-sign, and redact PDFs in the browser with one PDFium engine across web and desktop. Real-time text editing (Tier 2), certified PKCS#7 digital signing, true byte-level redaction, form filling, page operations, and a full annotation suite.

  • One PDFium engine — web + desktop, identical fidelity
  • Annotate · forms · in-place text edit · page ops
  • E-sign (visible stamp) + PKCS#7 certified signing
  • True byte-level redaction (rasterize + flatten)
v1 in progress · live at pdf.casualoffice.org Read more →

Casual RAS

WHITE-LABEL EMBEDDABLE REMOTE ACCESS

Casual Remote Access System — an embeddable platform vendors add to their own app for secure screen viewing, remote pointer, remote keyboard/mouse control, collaboration, and approved support actions, under their own brand. Shared Rust core, peer-to-peer over iroh/QUIC, host-authoritative per-message capability enforcement.

  • Embed in your app · white-label · not a standalone tool
  • P2P over iroh/QUIC · encrypted · NAT-traversing
  • Signed PASETO grants · per-message host enforcement
  • Consent + always-visible indicator + emergency stop
alpha · v0.0.2-alpha Read more →
engines & platform

The next generation, in Rust —
and the boundary you run them behind.

/engines

The editors above are apps you deploy. These are the pieces underneath: OpenCalc and OpenDoc are ground-up Rust rewrites of the spreadsheet and document cores — deterministic, embeddable, and compiled to WebAssembly so they run in a browser tab with no server behind them. Both have live editors you can type into right now. Enclave is the enterprise content and governance platform they sit inside.

OpenCalc

EMBEDDABLE RUST SPREADSHEET ENGINE

The successor to Casual Sheets, rewritten as a deterministic Rust engine that reads and writes .xlsx, calculates it, and paints a canvas grid — the whole engine client-side in WebAssembly, so co-editing scales without sticky sessions. Embeddable as a web component, a Rust crate, or a WOPI adapter.

  • 347 / 356 spec functions · LET · LAMBDA · dynamic arrays
  • .xlsx semantic fixed point · CSV/TSV/PSV · unmodelled parts kept byte-for-byte
  • WASM canvas grid · server-mediated OT · no sticky sessions
  • npm @opencalc/sheet · Rust SDK · WOPI for Nextcloud / SharePoint
alpha · SDK v0.0.0 · live at calc.casualoffice.org Read more →

OpenDoc

EMBEDDABLE RUST DOCX ENGINE

The successor to Casual Docs. It reads and writes .docx, holds the document in a normalized editable model, and lays it out and renders it to pixels — for native, WebAssembly, and headless hosts that need real DOCX fidelity without a browser, a server, or a UI framework.

  • Import: styles · numbering · tables · fields · footnotes · tracked changes
  • Export: byte-identical reconstruction, or a semantic re-write of an edited model
  • Own layout + raster: parley shaping, tiny-skia rendering, no DOM
  • Every surface takes every operation — enforced by a CI matrix
pre-release · live at opendoc.casualoffice.org Read more →

Enclave

ENTERPRISE WORKSPACE + POLICY BOUNDARY

Content, governance, search and AI access behind one policy boundary — SharePoint-class in purpose, self-hostable, and built so that every entry point (web, sync, REST, MCP, agent) runs through the same authorization chain, implemented once.

  • Workspaces · libraries · immutable versions · lists · 16 view types
  • OIDC · SAML · LDAP · SCIM · passkeys · per-action permissions
  • DLP · classification · retention · legal hold · tamper-evident audit
  • Permission-aware hybrid search + an MCP gateway under the same chain
in development · no hosted demo yet Read more →
Who it's for

Built for teams that want to
own their documents.

/audience
🔒

Privacy-first teams

Keep documents off Google and Microsoft clouds. Self-host on your own infrastructure so spreadsheets and contracts never leave your network.

🧩

Product teams embedding an editor

Drop a real .docx / .xlsx editor into your intranet, LMS, CRM, or SaaS via the React SDK — instead of building a spreadsheet from scratch.

🛠️

Self-hosters & homelabs

One multi-arch Docker container, one port, no database required. A collaborative office suite for your private cloud in a single docker run.

Developers & OSS contributors

Every line is on GitHub under Apache-2.0 + MIT. Small enough to read end-to-end, with green CI and good-first-issues — a serious open-source codebase, not a demo.

🏛️

Regulated & air-gapped orgs

No outbound calls, no accounts, no telemetry. Run it fully offline where compliance or air-gap requirements rule out the hosted office suites.

🌐

Anyone wanting a Google Docs alternative

A free, open-source alternative to Google Docs, Google Sheets, and OnlyOffice that you actually control — files in your format, on your server, forever.

What we support

A real office suite — the formats and
features you already rely on.

/capabilities
Sheets .xlsx
  • .xlsx · .ods · .csv · .tsv round-trip
  • Pivot tables with drill-down
  • 8 chart types · trendlines · sparklines
  • Conditional formatting · data validation
  • .xlsm VBA macro passthrough
  • Version history · autosave
Docs .docx
  • .docx round-trip · 39/39 fixtures pristine
  • Paginated WYSIWYG · headers/footers
  • Tables · lists · styles · footnotes
  • Spell check · find & replace (regex)
  • Citations · voice typing · outline
  • Agentic AI · MCP · tracked-change edits
  • Print / Export-as-PDF
PDF .pdf
  • PDFium-WASM · identical web + desktop fidelity
  • Annotate · forms · in-place text edit
  • E-sign · certified PKCS#7 digital signing
  • True byte-level redaction
  • Page ops · watermark · header/footer
  • Co-edit · public share links (v1 in progress)
Platform
  • Real-time co-editing (Yjs CRDT)
  • Self-host: memory · local · S3 · Postgres
  • Multi-arch Docker (amd64 + arm64)
  • Personal mode · auth · WOPI host
  • Embed via React SDK
  • Agentic AI · MCP · local & cloud, your keys
  • Apache-2.0 + MIT · no telemetry
Three ways to run it

Same suite, your privacy trade-off —
hosted demo, native desktop, or self-hosted.

/modes
Feature Web demo Desktop Self-host
Docker
Docs · Sheets · PDF editors✓✓✓
AI assistant · tracked-change edits✓✓✓
Agentic AI — plan → execute → review✓✓✓
MCP — connect external tools✓✓✓
On-device local model (private, offline AI)—✓—
Works fully offline—✓—
Real-time co-editing (Yjs CRDT)——✓
Multi-user · auth · WOPI host——✓
Documents never leave your machine / server—✓✓
Bring your own key / model✓✓✓

Desktop runs a local model on-device — your documents and prompts stay on your machine. The web demo and self-host use your own API key (or any provider you configure); nothing is sent anywhere you didn't set up.

why bother

Six reasons to take this seriously.

/why

The file is the source of truth

Open .xlsx or .docx, edit, save back to the same bytes. The audit counts every OOXML tag round-trip; Casual Docs is at 100% on 39 fixtures.

Real-time, actually verified

Yjs CRDT in the browser, a ~120 LOC Go gateway on the server. A 5-second smoke proves multi-peer text, awareness, and live rename — every push runs it.

Stateless backend

No database, no on-disk update log in the real-time path. Session state lives in memory while peers are connected, then drains to the host integration on the last disconnect.

Permissive, forever

MIT on the editor packages, Apache-2.0 on the backend. No copyleft, no AGPL trapdoor, no "open core" features hidden behind a paid tier.

One container, one port

Multi-arch images (amd64 + arm64) on Docker Hub. OCI labels, SBOM and provenance attestations. docker run and you're running both the editor and the WS gateway.

Built in the open

Every commit, every fixture, every failing-then-passing test visible on GitHub. The roadmap is a doc, not a slide deck. Pick an issue, open a PR.

embed

Drop it into your own app.

npm
Install
npm i @casualoffice/docs
npm i @casualoffice/sheets
Use
import { DocxEditor } from '@casualoffice/docs';

export default function App() {
  return <DocxEditor onSave={(blob) => saveAs(blob, 'doc.docx')} />;
}

Both editors ship one unified SDK contract — same document mode, events, imperative handle, feature flags, and declarative collab + AI props. See the Docs SDK guide and the Sheets SDK guide.

Works with
Vite Next.js Astro Remix Vue Nuxt

The editor packages ship as ESM + UMD. Mount the raw React component, the batteries-included wrapper, or an isolated iframe; the collab gateway is a separate process you run alongside any backend that speaks HTTP.

self-host

From zero to a running suite in one command.

docker 
services:
  app:
    image: casualoffice/sheets:0.3
    ports: ['3000:3000']
    environment:
      CASUAL_STORAGE: local
      CASUAL_LOCAL_PATH: /data/workbooks
    volumes:
      - data:/data
volumes:
  data:
Self-hosting guide → Optional JWT auth All docs
community-first

Help shape v1.

/contribute
★

Star the repos

Stars are the only signal that says "keep going." Two repos: docx for Casual Docs, sheets for Casual Sheets.

✎

Open an issue

Real-world .docx or .xlsx that breaks? Attach the file. Every regression fixture in the audit started life as someone's broken document.

⤴

Send a PR

The bar is the green CI suite plus a fixture that pins the change. Both repos have CONTRIBUTING.md; the issue trackers tag good-first-issue.

questions

Common questions.

/faq
What is Casual Office, in one sentence?
Real office editors — Casual Sheets (.xlsx), Casual Docs (.docx), and a high-fidelity PDF editor — that open native files in the browser, co-edit in real time, and save back to the original byte-for-byte format. Open source, self-hostable as one Docker container, free forever.
Is Casual Office a free alternative to Google Docs and Microsoft Office?
Yes. Casual Office is a free, open-source, self-hosted alternative to Google Docs, Google Sheets, Microsoft 365 / Office Online, and OnlyOffice. You run it on your own server, your documents stay in standard .docx / .xlsx, and there are no per-seat fees or accounts.
Is this a SaaS? Will it ever be?
No. The public demos at sheet.casualoffice.org and docs.casualoffice.org have no accounts, no plans, no upsell. The project is permissively licensed and free forever in the editions you can see today.
How does the .xlsx / .docx round-trip work?
The file is the source of truth. Open → in-memory snapshot → edit → re-serialize back to the original OOXML shape. Casual Sheets carries macros and pivot caches through byte-equal. Casual Docs scores 39/39 fixtures pristine in the per-tag fidelity audit.
Real-time co-editing — what powers it?
Yjs (industry-standard CRDT) in the browser, paired with Hocuspocus (Casual Sheets) or a custom ~120-line Go y-websocket gateway (Casual Docs). State lives in memory while a session is active; persistence is delegated to the host integration.
Do I need a database?
No. Default storage is in-memory or local filesystem. Casual Sheets also ships S3-compatible and Postgres backends, plus an optional personal mode (bcrypt + SQLite) for named per-user files — pick one with a single env var or skip them entirely.
Can I embed it in my own React or Vue app?
Yes — both editors now ship as installable npm SDKs: `@casualoffice/docs` (Casual Docs) and `@casualoffice/sheets` (Casual Sheets). They share one unified contract — the same document mode, event emitter, `getContent`/`setContent` handle, feature flag-map, and declarative collab and AI props — so a host wires both editors the same way. Each also offers an iframe + postMessage mount for process isolation.
What is the difference between Casual Sheets and OpenCalc, or Casual Docs and OpenDoc?
They are two generations. Casual Sheets and Casual Docs are the shipping web apps, built on TypeScript (a Univer fork) and ProseMirror respectively — those are what the live demos run today. OpenCalc and OpenDoc are their successors: the same jobs rewritten as deterministic Rust engines that compile to WebAssembly, so the spreadsheet or document engine can be embedded in any host — a browser, a native app, or a headless service — without a DOM, a server, or a UI framework. Both generations are developed in the open; the engines are not yet a drop-in replacement for the apps.
Can I embed the engine itself rather than a whole editor?
That is what OpenCalc and OpenDoc are for. OpenCalc ships as `@opencalc/sheet` on npm (a custom element with a shadow root) and as `casual_calc_sdk` for Rust hosts; OpenDoc exposes the same engine to Rust, wasm32, and headless hosts. Time and randomness are supplied to the engine rather than sampled by it, which is what makes a session replayable and testable.
What is Enclave?
Enclave is a self-hostable enterprise content and collaboration platform — SharePoint-class in purpose. Workspaces, libraries and versions; local/LDAP/OIDC/SAML/SCIM identity; per-action permissions with deny-wins ACL resolution; DLP, classification, retention, legal hold and tamper-evident audit; permission-aware hybrid search; and an MCP gateway so AI access runs through the same policy chain as everything else. It is in active development and has no hosted demo yet.
Where does it not fit?
The editors are editors. If you need server-side PDF rendering or automatic version history out of the box, that is not what they are. Enterprise identity (OIDC/SAML/SCIM), governance and retention live in Enclave rather than in the editors — and Enclave is still in development, so if you need any of that in production today, this is not yet it. Nothing here carries a compliance certification.
Why does this exist?
A counterposition to megasuites. Each product is small enough to read end-to-end, every line is on GitHub, and the file format is owned by the user — not the vendor.
Our goal

Office software you
own, not rent.

The goal is simple: a serious, production-grade office suite that anyone can self-host, read end-to-end, and trust with their data — where your files stay in open formats on your own server. Built like infrastructure, not a SaaS: composable, file-shaped, and permissively licensed forever.

Browse on GitHub → Documentation Changelog
Open source Self-hostable MIT + Apache-2.0 Real-time, verified