Etherpad vs HedgeDoc: Collaborative Editors Compared

Quick Verdict

Etherpad is the better choice if you need instant, anonymous collaboration — share a link and start typing with zero setup. HedgeDoc wins if you want Markdown support, user accounts, and structured documents with permissions. Pick Etherpad for quick scratchpads and meeting notes. Pick HedgeDoc for documentation and long-lived collaborative writing.

Overview

Etherpad and HedgeDoc both solve the “we need to edit a document together in real time” problem, but they approach it from opposite directions.

Etherpad is a pure real-time text editor. It launched in 2008 (originally by Google, then open-sourced), and its entire design philosophy is simplicity: open a pad, share the link, start typing together. No accounts required. A rich plugin ecosystem extends its capabilities, but the core product is deliberately minimal. It uses a custom rich-text editor with basic formatting.

HedgeDoc (formerly CodiMD, formerly HackMD CE) is a collaborative Markdown editor. It gives you a split-pane view — Markdown on the left, rendered preview on the right — and layers on user accounts, permissions, slide mode, and document organization. It targets teams that want something closer to Google Docs but with Markdown as the source format.

Both are Node.js applications, both support Docker deployment, and both handle real-time collaboration well. The difference is scope: Etherpad is a focused tool that does one thing fast, while HedgeDoc is a more feature-rich platform for structured collaborative writing.

Feature Comparison

Feature	Etherpad	HedgeDoc
Editor type	Rich text (WYSIWYG)	Markdown with live preview
Real-time collaboration	Yes, excellent	Yes, solid
User accounts	Optional (via plugins)	Built-in (local, LDAP, OAuth)
Anonymous access	Default behavior	Configurable per note
Permissions / access control	Basic (via plugins)	Built-in (private, limited, freely, locked)
Slide / presentation mode	No (plugin available)	Built-in
Plugin ecosystem	200+ plugins	Limited (built-in features instead)
Document organization	Flat (pad names only)	Tags, pinned notes, history
Export formats	HTML, plain text, PDF, Word, ODF	Markdown, HTML, PDF, slide deck
Revision history	Built-in timeline slider	Built-in revision list
Syntax highlighting (code)	Via plugin	Built-in (fenced code blocks)
Math / LaTeX support	Via plugin	Built-in (MathJax)
Image upload	Via plugin	Built-in (local or S3)
API	Full HTTP API	Full HTTP API
License	Apache-2.0	AGPL-3.0
Language	JavaScript (Node.js)	TypeScript (Node.js)
Database support	SQLite, MySQL, PostgreSQL	PostgreSQL, MySQL, SQLite
RAM usage (idle)	~100 MB	~150 MB

Docker Compose: Etherpad

Etherpad is straightforward to deploy. This configuration uses PostgreSQL for production reliability.

Create a docker-compose.yml:

services:
  etherpad:
    image: etherpad/etherpad:2.3.0
    container_name: etherpad
    restart: unless-stopped
    ports:
      - "9001:9001"
    environment:
      # Database configuration
      DB_TYPE: postgres
      DB_HOST: etherpad-db
      DB_PORT: "5432"
      DB_NAME: etherpad
      DB_USER: etherpad
      DB_PASS: change-this-db-password
      # Admin user (optional but recommended)
      ADMIN_PASSWORD: change-this-admin-password
      # Pad behavior
      DEFAULT_PAD_TEXT: ""
      PAD_OPTIONS_NO_COLORS: "false"
      # Trust the reverse proxy for correct client IPs
      TRUST_PROXY: "true"
    volumes:
      - etherpad-data:/opt/etherpad-lite/var
    networks:
      - etherpad-net
    depends_on:
      etherpad-db:
        condition: service_healthy

  etherpad-db:
    image: postgres:16-alpine
    container_name: etherpad-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: etherpad
      POSTGRES_USER: etherpad
      POSTGRES_PASSWORD: change-this-db-password  # Must match DB_PASS above
    volumes:
      - etherpad-db-data:/var/lib/postgresql/data
    networks:
      - etherpad-net
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U etherpad"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  etherpad-data:
  etherpad-db-data:

networks:
  etherpad-net:

Start it:

docker compose up -d

Access Etherpad at http://your-server:9001. Create a new pad instantly — no account required.

Docker Compose: HedgeDoc

HedgeDoc requires a database and has more configuration options due to its user management features.

Create a docker-compose.yml:

services:
  hedgedoc:
    image: quay.io/hedgedoc/hedgedoc:1.10.2
    container_name: hedgedoc
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      # Database
      CMD_DB_URL: postgres://hedgedoc:change-this-db-password@hedgedoc-db:5432/hedgedoc
      # Domain configuration (CHANGE THIS to your actual domain or IP)
      CMD_DOMAIN: hedgedoc.example.com
      CMD_PROTOCOL_USESSL: "true"
      CMD_URL_ADDPORT: "false"
      # Access control
      CMD_ALLOW_ANONYMOUS: "true"           # Allow anonymous viewing
      CMD_ALLOW_ANONYMOUS_EDITS: "true"     # Allow anonymous editing
      CMD_ALLOW_FREEURL: "true"             # Allow custom note URLs
      CMD_DEFAULT_PERMISSION: freely        # Default note permission: freely, editable, limited, locked, protected, private
      # Registration
      CMD_EMAIL: "true"                     # Enable email sign-up
      CMD_ALLOW_EMAIL_REGISTER: "true"      # Allow new registrations
      # Image uploads
      CMD_IMAGE_UPLOAD_TYPE: filesystem     # Store uploads locally (alternatives: s3, minio, imgur)
      # Session secret (CHANGE THIS to a random string)
      CMD_SESSION_SECRET: change-this-to-a-random-secret-string
    volumes:
      - hedgedoc-uploads:/hedgedoc/public/uploads
    networks:
      - hedgedoc-net
    depends_on:
      hedgedoc-db:
        condition: service_healthy

  hedgedoc-db:
    image: postgres:16-alpine
    container_name: hedgedoc-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: hedgedoc
      POSTGRES_USER: hedgedoc
      POSTGRES_PASSWORD: change-this-db-password  # Must match password in CMD_DB_URL
    volumes:
      - hedgedoc-db-data:/var/lib/postgresql/data
    networks:
      - hedgedoc-net
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U hedgedoc"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  hedgedoc-uploads:
  hedgedoc-db-data:

networks:
  hedgedoc-net:

Start it:

docker compose up -d

Access HedgeDoc at http://your-server:3000. You will see a landing page where you can sign up or create a new note.

Installation Complexity

Etherpad is simpler to deploy. The default configuration works out of the box — you can even skip the database entirely and use the built-in SQLite (fine for small teams). Environment variables cover the most common settings. Plugins install through the admin panel without restarting the container. Total setup time: 5 minutes.

HedgeDoc requires more configuration. You need to set CMD_DOMAIN, CMD_SESSION_SECRET, and decide on your authentication and permission model upfront. The database connection string format is less forgiving than Etherpad’s individual DB variables. You also need to think about image upload storage from the start. Total setup time: 10-15 minutes.

Winner: Etherpad, by a clear margin.

Performance and Resource Usage

Both applications are lightweight by modern standards.

Metric	Etherpad	HedgeDoc
Idle RAM	~100 MB	~150 MB
RAM under load (10 users)	~150 MB	~200 MB
CPU (idle)	Negligible	Negligible
Disk (application)	~200 MB	~300 MB
Startup time	~5 seconds	~8 seconds

Etherpad is leaner because it does less. HedgeDoc’s extra 50 MB buys you Markdown rendering, image handling, and user management. Neither will stress even a Raspberry Pi.

For large deployments (100+ concurrent editors), Etherpad scales better because its pad model is simpler. HedgeDoc handles dozens of simultaneous editors per note without issues, but the Markdown rendering adds overhead that Etherpad avoids.

Community and Support

Metric	Etherpad	HedgeDoc
GitHub stars	~17,000+	~5,000+
First release	2008 (open-sourced 2011)	2018 (as CodiMD)
Update frequency	Regular	Regular
Documentation	Good, wiki-based	Good, dedicated docs site
Community	Large, established	Smaller but active
Plugin ecosystem	200+ community plugins	Minimal (features built-in)

Etherpad has the larger community and longer track record. Its plugin ecosystem means the community has solved most edge cases. HedgeDoc has a smaller but focused community, and its development is more centralized — features get built into core rather than offloaded to plugins.

Both projects are actively maintained with regular releases.

Use Cases

Choose Etherpad If…

• You need instant, zero-friction collaboration — just share a link
• Anonymous access is a feature, not a bug (meeting notes, brainstorming, public events)
• You want a plugin ecosystem to customize behavior
• You prefer rich text over Markdown
• You are running on minimal hardware (Raspberry Pi, low-end VPS)
• You need to embed collaborative editing into another application (Etherpad’s API and iframe embedding are excellent)
• Your team does not need user accounts or document organization

Choose HedgeDoc If…

• You write in Markdown and want live preview
• You need user accounts and per-document permissions
• You want built-in features like slide presentations, LaTeX math, and syntax-highlighted code blocks
• Your team needs document organization (tags, pinned notes, history)
• You are building a knowledge base or documentation system
• You want image uploads without installing plugins
• You need to control who can view and edit specific documents

Final Verdict

For most self-hosting users, HedgeDoc is the better choice. Markdown is the lingua franca of technical writing, and HedgeDoc gives you a polished collaborative Markdown editor with user accounts, permissions, and document organization out of the box. If you are replacing Google Docs or Notion for a small team, HedgeDoc gets you closer to that experience.

Etherpad wins in one specific scenario: zero-friction, anonymous collaboration. If you want to spin up a pad for a meeting, share the link, and have everyone typing in seconds without creating accounts, Etherpad is unmatched. Its simplicity is its superpower.

The practical recommendation: run HedgeDoc as your primary collaborative editor for your team. If you also need quick throwaway pads for meetings or public collaboration, add Etherpad alongside it — they serve different purposes and both are light enough to run on the same server.

Related

• How to Self-Host Etherpad
• How to Self-Host HedgeDoc
• Best Self-Hosted Note-Taking Apps
• How to Self-Host Outline
• Docker Compose Basics
• Reverse Proxy Setup
• Backup Strategy