Univer: An Open-Source, Isomorphic SDK for Embeddable Office Experiences

A full-stack, isomorphic office SDK for building spreadsheets, documents, and presentations. Univer provides the building blocks to create embeddable productivity experiences with a plugin architecture, Canvas-based rendering, a robust formula engine, and a single Facade API that works in both the browser and Node.js. This makes it possible to embed rich editing surfaces into SaaS products, internal tools, BI workflows, or AI-driven applications without forcing you into a hosted app or a fixed UI.

In a world where teams want custom, scalable, and high-performance productivity surfaces, Univer stands out by offering a cohesive framework rather than a collection of disparate tools. It’s designed to be approachable yet powerful: you can start with presets for quick results or dive into plugin-driven composition for full control. The result is a consistent experience across spreadsheets, documents, and presentations, backed by a unified API surface and a rendering engine that scales with large surfaces.

What is Univer?

Univer is an open-source SDK that gives developers the core building blocks to create office-like experiences inside their products. It isn’t merely a viewer for spreadsheet files or document snippets; it’s a framework for constructing your own productivity surface. Key ideas include:

• Embedding capabilities: Build spreadsheet, document, or presentation editing into your SaaS product, internal tool, or AI workflow.
• Isomorphic architecture: UI runs in the browser while workbook and document processing can run on the server with the same architecture.
• Plugin-driven design: Every capability is delivered as a composable plugin, enabling you to add, replace, lazy-load, or customize features.
• Presets for fast starts: Curated plugin bundles help you ship quickly.
• Extensible UI: Drop-in UI components and a flexible rendering pipeline that works with React, Vue, Web Components, or your own shell.
• Unified Facade API: A single API surface to interact with workbooks, worksheets, ranges, documents, formulas, commands, and events across browser and Node.js.

In short, Univer is not just a set of widgets; it’s a framework for building your own productivity surface, covering the front-end rendering, the business logic, and the server-side processing in a coherent, maintainable way.

Highlights: What Makes Univer Stand Out

• Built for large surfaces: Canvas-based rendering and a dedicated formula engine keep even complex workbooks responsive, with smooth scrolling, panning, and editing across big canvases.
• Plugin-shaped by default: Features arrive as composable plugins, so you can mix, match, replace, or lazy-load capabilities to fit your product.
• Headless for AI infrastructure: Run workbook and document logic in Node.js to power agents, automation, and server-side workflows.
• Product-ready SDK: Framework adapters, Facade APIs, presets, and headless runtime align with real integration scenarios.
• Dark-mode readiness: UI components and the rendering engine adapt to light and dark themes for a seamless user experience.
• Unified Facade API: A single surface to work with workbooks, worksheets, ranges, documents, formulas, commands, and events, consistent across browser and Node.js.

These strengths are coupled with a strong emphasis on extensibility and practical integration, so you’re not forced into a single UI or a single hosting model. Univer provides the flexibility to assemble the exact surface you need, while keeping a coherent developer experience.

Why Univers: The Case for Isomorphic, Plugin-Driven Productivity

• Isomorphic by design: The same architecture powers client-side rendering and server-side processing, enabling consistent behavior whether or not a UI is present.
• Plugin-first architecture: Features arrive as modular plugins, enabling you to compose, replace, lazy-load, or extend capabilities without reworking the entire stack.
• Preset mode for fast integration: Curated bundles let you stand up a working app quickly, with recommended plugin sets and pre-registered Facade API surfaces.
• Plugin mode for full control: When you need deep customization, manual composition gives you control over package versions, loading strategies, and runtime orchestration.
• Facade API: A cohesive API set for interactive objects—workbooks, ranges, formulas, documents—delivered in a consistent way across environments.
• Canvas rendering: A rendering engine designed for large, editable surfaces, enabling in-place editing and responsive UI across documents and data types.
• Extensible UI: Integrations with React, Vue, Web Components, and custom application shells ensure you can blend Univer into your existing UI story.

Quick Start: Two Pathways to Getting Started

Presets: the recommended path if you want a working Sheets, Docs, or Node setup with minimal configuration.

• What you install:
• @univerjs/presets
• @univerjs/preset-sheets-core
• Conceptual steps:
• Import the preset and locale data.
• Create an Univer instance with a locale pack and a container where the app will render.
• Register the preset into Univer.
• Create a workbook to begin editing.

In practice, a typical workflow looks like:

• Install: pnpm add @univerjs/presets @univerjs/preset-sheets-core
• Initialize: import { UniverSheetsCorePreset } from '@univerjs/preset-sheets-core' and load the locale data for your language.
• Create: Use createUniver, pass in locale data and presets, and then call univerAPI.createWorkbook({}).

Plugin Mode: if you need granular control over package selection, loading order, locale merging, or custom runtime composition.

• What you install:
• Core packages for UI, rendering, formulas, and sheets
• Plugins for docs, slides, formula engine, render engine, and UI
• Conceptual steps:
• Create a Univer instance with a full locale suite.
• Register the various Univer plugins in the order you require.
• Create an API surface (the FUniver facade) and initialize a workbook.
• Provide a container in your app and render the workspace.

A practical outline for Plugin Mode would involve assembling and configuring a larger set of packages and locales, then wiring them into Univer with a registration sequence that suits your app’s needs. The approach is designed for teams that want precise control over bundle size, plugin order, and runtime behavior.

Note: Your page needs a container. Ensure your HTML includes a DOM element with the id or container you specify (for example, a div with container: 'app' in the initialization). This container acts as the host for the rendering surface.

Learn more in the Installation & Basic Usage guide, the createUniver reference, and the Facade API reference to understand how to wire up the surface in your app.

Preset Mode vs Plugin Mode: Choosing the Right Path

• Preset Mode: Best when you want a working Sheets, Docs, or Node setup with minimal configuration. It’s your fastest route to a functional app, with curated plugin bundles and pre-registered surfaces.
• Plugin Mode: Best when you need strict control over packages, plugin registration order, lazy loading strategies, or deep runtime customization. It gives you full visibility into how the surface is composed and how data and UI flow through the system.
• Headless Mode: When you need server-side workbook or document processing, formula calculation, or automation without a user interface. This is ideal for automation, agents, and back-end workflows.

In short, Preset Mode accelerates onboarding, while Plugin Mode provides power users with precise control over the architecture. The ecosystem also emphasizes consistency across modes via the Facade API and shared rendering technologies.

Compatibility considerations include browser runtime targets, polyfills for Intl.Segmenter, build tool compatibility (Vite, esbuild, Webpack 5), and React versions. Univer is designed to work with modern tooling and modern browsers, while still offering paths for headless, server-side processing when UI is not required.

What You Can Build: Core Areas and Capabilities

Sheets

• Core editing: workbooks, worksheets, ranges, selection, formulas
• Formatting: number formatting, conditional formatting, data validation
• Data handling: filtering, sorting, hyperlinks, comments, notes, tables
• UI integration: drawing integration, extensible UI plugins
• Pro extensions (via Pro packages): collaboration, edit history, import/export, printing, charts, pivot tables, sparklines, outlines, shapes, in-cell graphics, data connectors, server-side calculations, performance-optimized formulas

Docs

• Rich document model and editing UI
• Lists, hyperlinks, drawing integration, comments, quick insert
• Shared document architecture
• Pro extensions: collaboration, import/export, printing, enhanced tables/lists, columns, callouts, code blocks, quotes, shapes, and remote thread-comment resources

Slides

• Presentations data model and UI
• Pro slide model/UI, slide import/export, charts, tables, reusable shape editor tooling

Bases

• Extensible foundation for custom structured-data experiences
• Base database model, commands, formula integration, workbench UI, field editors, render-engine views

Runtime

• Browser apps and Node.js headless usage
• Web Worker/RPC patterns, multi-instance usage, server-oriented automation
• Pro features: collaboration, server services, SSR, computing delegation, server-side calculation, changeset replay tooling

Integrations

• Framework-agnostic UI layers and templating
• React, Vue, Web Components, localization, and theming
• Pro presets and enterprise deployment packages

Sheets are the most mature surface today, with Docs and Slides following the same architecture as part of Univer’s unified SDK.

Open Source and Pro: OSS Core, Pro as a Separate Layer

This repository hosts Univer’s open-source core and first-party OSS plugins. Univer Pro is developed separately as a commercial extension layer for more advanced product surfaces, collaboration features, server capabilities, and enterprise integrations.

• Foundation: Core SDK, plugin system, rendering engine, formula engine, Facade API, themes, i18n, and adapters.
• Sheets: Core editing capabilities, formulas, formatting, and UI plugins; Pro adds collaboration, history, import/export, and server features.
• Docs: Document model and editor UI; Pro adds collaboration, enhanced tables/lists, and remote resources.
• Slides: OSS presentation model and UI; Pro expands with more slide tooling and reuse.
• Bases: Extensible plugin architecture; Pro adds more enterprise-oriented data features.
• Server and runtime: Node.js headless runtime, RPC patterns, SSR, and automation primitives.

Pro features are documented in the Univer Pro guide. They are intentionally separated to keep the OSS surface clear and accessible under the Apache-2.0 license. The boundary emphasizes that Pro features are optional and designed to coexist with the public API without implying Pro capabilities in OSS packages.

Boundary principles include:

• OSS packages remain useful under Apache-2.0.
• Pro is optional and not required to use public APIs.
• Pro-specific APIs and packages are named explicitly.
• OSS behavior remains independently documented even when Pro enhancements exist.

Ecosystem: A Growing, Interconnected World

• Core SDK: dream-num/univer, the central monorepo.
• Presets: dream-num/univer-presets, curated bundles for browser and Node.js apps.
• AI agent skills: dream-num/univer-sdk-skills, reusable instructions for AI agents working with Univer integration, Pro features, plugin development, and Node backends (see the AI Skills guide for details).
• Documentation: docs.univer.ai, covering Sheets, Docs, Slides, recipes, and Pro guides.
• API Reference: docs.univer.ai/reference, containing the Facade API and generated API reference.
• Examples and showcase: Univer Showcase, and this repository’s examples directory.
• AI-native spreadsheets: dream-num/univer-mcp, Univer Platform / MCP integration for driving Univer Sheets with natural language.

The ecosystem is designed to be extensible, with a clear path from core components to advanced enterprise features, and a bridge to AI-driven workflows.

Repository Guide: How the Project is Organized

• packages: Core packages, engines, document types, UI plugins, and feature plugins.
• examples: Local browser and Node.js demos used for development.
• common: Shared internal tooling, mock data, Storybook, and utilities.
• e2e: Playwright and visual comparison tests.
• tests: Additional integration test projects.
• docs: Architecture notes, images, and repository-local documentation.

Package-level READMEs live beside each package under packages, so you can explore the structure and responsibilities of each module as you work.

Development Requirements: Getting Set Up

• Node.js: >= 22.18
• pnpm: >= 10

A typical local development flow might look like:

• Clone: git clone https://github.com/dream-num/univer.git
• Install: cd univer; pnpm install
• Start: pnpm dev

Useful commands to keep in mind:

• pnpm dev: Start the local examples app.
• pnpm build: Build workspace packages (excluding internal common packages).
• pnpm test: Run unit tests through Turbo.
• pnpm typecheck: Run TypeScript checks.
• pnpm lint: Run ESLint.
• pnpm test:e2e: Run Playwright tests.
• pnpm storybook:dev: Start Storybook for UI component development.

If you’re contributing, be sure to read repository-local notes that cover architecture decisions, API stability, facade API design, naming conventions, memory-leak debugging, and architecture TLDRs for engine behavior, workers, permissions, and reference ranges.

Contributor Notes: Practical Guidelines

• ISOMORPHIC development: Understand how to split browser, Node.js, UI, and shared plugin logic to maximize reuse and performance.
• API Stability: Distinguish between stable OSS APIs and experimental or internal APIs. Follow the API Stability Policy to manage compatibility expectations.
• Facade API design: Contribute with an eye toward a consistent interface for FUniver, FWorkbook, FRange, and related Facade classes.
• Naming conventions: Adhere to the project’s naming conventions for files, folders, interfaces, plugins, commands, and DI tokens.
• Memory management: Learn memory-leak diagnosis and apply patterns to ensure long-running Univer instances stay healthy.
• Architecture notes: Review TLDRs on formula engine, web workers, permission models, and changeset replay to guide design decisions.

Reading these notes helps contributors align with the project’s long-term goals and maintain a coherent codebase across the OSS surface.

Community, Security, and Support

• Community: Ask questions on GitHub Discussions, chat on Discord, and follow Univer on Twitter/X and YouTube. The community welcomes participation, feedback, and collaboration.
• Code of Conduct: Please read and follow the Code of Conduct when participating in community spaces.
• Security: If you discover a security issue, follow the Security Policy to report responsibly.
• Sponsors: Univer is supported by the community and sponsors via Open Collective, with multiple sponsor/backer avatars showing the ecosystem’s commitment.

These channels support a healthy, collaborative environment where developers, designers, and product teams can contribute to a robust, open productivity platform.

Licensing: Open Source with a Commercial Path

The Univer OSS core and first-party OSS plugins are licensed under Apache-2.0. Univer Pro exists as a separate commercial extension layer for advanced product surfaces, collaboration, server features, and enterprise integrations. This separation ensures open access to a useful OSS surface while offering a clear path to richer capabilities for teams that need them.

The licensing model is designed to be transparent and developer-friendly, enabling OSS adoption with the option to upgrade to Pro features as your product and organization scale.

Putting It All Together: Building Your Productivity Surface

Univer offers a practical, end-to-end path from quick starts to highly customized deployments:

• Start fast with Presets to ship a Sheets/Docs-like experience quickly, with pre-registered API surfaces and styles.
• Scale with Plugin Mode to tailor plugins, runtime loading, and integration points to your product architecture.
• Extend with your own UI components and custom plugins, leveraging the Canvas-based rendering engine for large, rich surfaces.
• Run AI-enabled workflows on the server, using headless Univer to power agents, automation, and server-side processing.
• Integrate with React, Vue, or Web Components to fit your UI landscape, keeping a unified API across platforms.
• Explore the broader ecosystem: AI agent skills, docs, examples, and API references to accelerate development.

If you’re evaluating Univer for your next productivity surface, start by reviewing the quick-start guides and then decide whether Preset Mode or Plugin Mode aligns with your goals. The combination of isomorphic architecture, a unified Facade API, and an adaptable rendering engine makes Univer a compelling foundation for embeddable office experiences.

Epilogue: A Vision for Embeddable Productivity

Univer envisions a future where you can embed sophisticated spreadsheets, documents, and presentations into any product without sacrificing control, performance, or developer experience. The SDK’s design—an isomorphic core, a plugin-first architecture, and a cohesive API—aims to empower teams to craft tailored productivity surfaces that feel native to their product while benefiting from a shared, well-supported foundation.

From fast-start presets to full-fledged plugin customization, from client-side rendering to server-side processing, Univer seeks to be the practical bridge between the power of modern web development and the demands of large, data-rich, collaborative office experiences. Whether you are building a SaaS analytics cockpit, an enterprise document hub, or an AI-assisted workspace, Univer provides the scaffolding, the tools, and the ecosystem to bring your vision to life.