Open Source Confluence Alternatives

The team behind AppFlowy used Notion daily and paid for it, then ran into its limits on data security and mobile. AppFlowy is their answer: an open source AI workspace for documents, wikis and project management, and an alternative to the tool it grew out of.

It is written in Flutter and Rust, a single codebase covering desktop and mobile with a native feel and long-term maintainability. Self-hosting is documented, so an individual or a company can keep the data on infrastructure they control.

The project is shaped around who is running it.

• Desktop: macOS, Windows and Linux builds, plus FlatHub, Snapcraft and SourceForge channels.
• Mobile: iPhone through the App Store and Android 10 or above through the Play Store, with ARMv7 unsupported.
• Self-hosting: run the backend yourself and keep full control over where the data lives.
• Building blocks: collaboration infrastructure for enterprises and hackers who want to build their own apps on top.
• Translations: edit the JSON files by hand, use the inlang online editor, or run a machine translation command.

Development instructions are documented per operating system, the roadmap is public, and feature requests and bug reports go through their own templates. The stated values put data privacy first, and the codebase is open to anyone who wants to modify AppFlowy for their own needs.

Outline is a collaborative knowledge base for a team, written in React and Node.js, and this repository is the source that runs the hosted product together with its supporting services. Anyone who simply wants to use it does not need the code at all, since a hosted version is offered by the maintainers.

The repository exists for two audiences: people running their own copy and people contributing changes. Production hosting is documented separately, and container images are published for both.

Running your own instance means dealing with a handful of moving parts.

• Logging: category prefixed console output in development and JSON logs in production, ready for a log ingestion pipeline.
• Debug switches: environment variables that widen output for HTTP, for the database, or for every category at once.
• Migrations: Sequelize commands to create, apply and roll back schema changes, including against the test database.
• Tests: Vitest files placed next to the code they cover, with API endpoints and anything authentication related tested thoroughly.

Contributors are asked to open or comment on an issue before writing code, so an approach is agreed first. The maintainers state plainly that AI generated pull requests are unwelcome, having received a high volume of mass produced ones that are almost never mergeable. Translation, performance work and documentation are named as good places to start instead. The project is licensed under BSL 1.1.

Docmost is open source software for collaborative wikis and documentation, built for teams that would rather keep internal knowledge on infrastructure they control than in a hosted notes product.

Content is organized into spaces, with groups and permissions management deciding who reads and writes where. Pages keep their history, comments sit next to the text, and several people can edit the same page at the same time.

The editor is where most of the differences show up.

• Diagrams: Draw.io, Excalidraw and Mermaid diagrams are created inside a page.
• Embeds: content from Airtable, Loom, Miro and other services is embedded directly.
• Attachments: files can be attached to any page.
• Search: pages are searchable across the whole workspace.
• Translations: the interface is available in more than ten languages.

The codebase splits a server and a client application, with enterprise directories held apart from the core. Docmost core is licensed AGPL 3.0, while the files under those enterprise directories fall under a separate enterprise license, a distinction that matters if you plan to modify and redistribute.

Self-hosting and development instructions live in the documentation, and a hosted cloud version exists for teams that would rather not deploy anything themselves.

Docs is a collaborative editor for teams whose notes should turn into shared knowledge. It comes out of a joint initiative between the French and German governments, through DINUM and ZenDiS, and is aimed at public organizations, companies and open communities that want to keep their documents on their own infrastructure.

The editor is built on ProseMirror and BlockNote, with Yjs and HocusPocus handling live collaboration, a Django Rest Framework backend and a Next.js front end. Writing is rich text and Markdown with slash commands, a block system and offline editing.

Day to day, the workspace covers more than typing.

• Live collaboration: cursors and presence, comments, sharing and granular access control per document.
• Knowledge structure: subpages and hierarchy, with search across the content inside them.
• Presentations: a delimiter turns any document into slides, with full screen, keyboard navigation, a share link and PDF export.
• Import and export: bring in docx and Markdown, send out docx, odt and pdf.
• Optional AI: model and gateway agnostic rewriting, summarising and translating, configured with an API key and an address.

An interoperability API lets other services push content in, and the project's own video tool uses it to file meeting transcripts. Self-hosting runs on Kubernetes or Docker Compose, with community recipes for Nix and YunoHost. The license is MIT, though PDF export pulls in GPL packages, so a build flag produces an image without them.

Colanode puts team chat, documents, and structured data in one self-hosted application, so a team stops spreading its work across a messaging tool, a wiki, and a spreadsheet owned by three different vendors.

It ships as a client app, web or desktop, plus a server you run yourself. A single client can connect to several servers, each holding one or more workspaces for different teams or projects. Every change is written to a local SQLite database first and synced by a background process, so reading and writing continue when your machine or the server goes offline.

The workspace covers the surfaces a team actually collaborates on.

• Real-time chat: instant messaging for teams and individuals.
• Rich text pages: documents, wikis, and notes in an editor along the lines of Notion.
• Customizable databases: structured records with custom fields and table, kanban, and calendar views.
• File management: store, share, and manage files inside a workspace.
• Concurrent edits: conflict-free replicated data types, powered by Yjs, merge simultaneous edits to pages and database records.

Self-hosting needs Postgres with the pgvector extension, Redis or a compatible service such as Valkey, and a storage backend for user files, local filesystem by default with S3-compatible, Google Cloud Storage, and Azure Blob Storage available. Docker Compose files and Kubernetes Helm charts ship in the repository, and the server image now carries a full config file, so only the Postgres and Redis connection strings are strictly required to boot.

XWiki Platform offers runtime services for applications built on top of it, making it a generic wiki platform in the literal sense. The distinction matters: rather than a place to write pages, it is a substrate other tools are written against, which is why a wiki, a knowledge base, and a small internal application can all be the same deployment.

The platform is a large Java build released in step with XWiki Commons and XWiki Rendering, three projects sharing a version number and the same software forge. Its core splits into modules that each cover a single service, so a deployment carries only what it uses.

Those modules are where the platform's capabilities live.

• Editing: a CKEditor-based WYSIWYG surface alongside real-time collaborative editing built on Netflux and Yjs.
• Structured content: App Within Minutes, classes, sheets, and LiveData tables turn pages into structured records.
• Collaboration: notifications, mentions, annotations, ratings, and likes attach to the content people work on.
• Extension management: an extension repository and a flavor system install and update components at runtime.
• Integration: a REST API, WebSocket support, office document import, and feed handling connect the wiki to a wider stack.
• Administration: permissions, cryptography, CSRF protection, a scheduler, and statistics cover the operational side.

Distributions are published as a WAR for an existing servlet container, as a standalone Jetty and HSQLDB bundle for a quick start, and as a Debian package. The code is LGPL-2.1, continuous integration builds every commit, and issues are tracked in the project's own JIRA rather than on GitHub.

Typemill stores a website as markdown files on disk. There is no database to install, back up or migrate, which fits the text-driven sites it is aimed at, from user manuals and documentation through to knowledge bases, wikis and handbooks.

The stack is Slim PHP on the server with Vue.js and Tailwind CSS in the interface, and the whole application is roughly two megabytes gzipped. Authors get both a visual block editor and a raw markdown editor working over the same files, so writing and structuring do not require separate tools.

Extension points are aimed at developers who need the site to do something specific.

• Twig templates: themes are written against the template engine.
• Event dispatcher: the Symfony dispatcher exposes the hooks plugins attach to.
• YAML definitions: settings and forms are declared rather than coded by hand.
• Plugins and themes: both extend the system, with commercial options alongside the free ones.
• eBook plugin: the same content is published as PDF and ePUB from one source.

Running Typemill needs a web server, PHP 8.1 or higher and a handful of standard extensions, with five folders made writable. It installs from a zip uploaded over FTP followed by a setup page, from a clone plus Composer, or from the official Docker image. The core is MIT licensed, while plugins and themes are split between MIT and commercial terms.

Orgnise is one place for a team's knowledge and its projects: use cases, wikis, technical documentation, policies, guidelines and announcements on one side, work moving through a board on the other. It removes the split where the handbook sits in a wiki, delivery sits in a tracker, and nothing connects the two.

A team invites people into one shared space, then groups work into workspaces by project or function such as design, marketing or engineering. Pages are drafted in a Notion-style editor and belong to a collection rather than to a separate wiki. It is a Next.js and TypeScript application that keeps content in MongoDB, signs people in through NextAuth and deploys to Vercel.

Writing and delivery share the same pages.

• Notion-style editor: docs are drafted with headings, lists and embeds on a single page.
• Slash commands: blocks are inserted straight from the keyboard while writing.
• Collections: pages are grouped by project or function instead of scattered across chats and drives.
• Board view: a collection becomes columns, and a page moves from idea to done without being copied elsewhere.
• Team spaces: everyone invited sees the institutional knowledge and the progress against it.

Teams run it as an engineering source of truth, a customer support knowledge base or a project tracker, and a workspace is free to start with no credit card. The repository holds the whole application, so a developer who has shipped a Next.js project will recognize every dependency in it. Issues and pull requests are welcome for bugs and features.