Mastodon vs Misskey vs Pleroma 2026

You’re About to Become Your Own Social Network Admin

Look, if you’re reading this, you’ve probably hit the Twitter-ification moment: the platform you loved got bought, ruined, or both. So you’re thinking about running your own fediverse instance. Noble. Slightly unhinged. Let’s talk about it.

The fediverse isn’t one platform — it’s a universe of independent servers all talking to each other via ActivityPub, a federating protocol that lets your selfie-sharing instance chat with your friend’s book-reviewing instance chat with that anime Discord’s meme server. It’s email, but for social media. Decentralized. Messy. Actually pretty cool.

Three servers dominate if you want to self-host: Mastodon (the household name), Misskey (the feature-packed anime favorite), and Pleroma/Akkoma (the “it runs on a Raspberry Pi” underdog). Each is a completely different engineering philosophy. Let me walk you through them before you commit to becoming your own moderator at 2 AM.

The ActivityPub Crash Course (Actual Federation Reality)

Before we dive in, you need to understand what’s actually happening when your instance federates.

ActivityPub is a W3C standard that lets servers advertise what they’re doing to each other. When you post on your Mastodon instance, your server signs the post cryptographically and pushes it to the inboxes of followers on other servers. Those servers verify the signature, store the post, and display it to their users. If someone on Akkoma follows you, they get your posts. If they reply, you get notified.

The magic part: you don’t need to know your followers’ servers exist. They just… exist in your timeline. Federation isn’t perfect (there are quirks, rate limits, and MFM rendering issues we’ll cover), but it’s the closest thing to decentralized social media that actually works.

The gotcha: Not all servers speak ActivityPub at the same level. Misskey has extra features (MFM, custom reactions) that Mastodon doesn’t fully render. Those features degrade gracefully on Mastodon instances, but you lose fidelity. Quote posts used to be in this bucket too — Mastodon finally shipped them in 4.5 (late 2025), so quotes now federate between the big three. More on that later.

The Resource Footprint: What Each One Actually Needs

This is the least glamorous section and the most important one.

Mastodon: The Heavy Lifter

Mastodon (Ruby on Rails) is the forklift of fediverse servers. It works, but it’s overkill for a single-user instance and it will eat your server’s lunch.

Baseline requirements (single-user instance):

• Postgres database
• Redis (for background jobs and caching)
• Elasticsearch or Meilisearch (for full-text search — optional but recommended)
• Multiple Puma (Rails) app servers (minimum 2 for HA, or 1 if you’re solo and accept downtime)
• Sidekiq worker processes (background jobs: notifications, federation, image processing)
• At least 4 GB RAM, preferably 8+ for reasonable performance
• 20-30 GB storage (grows with images and archives)

If you’re running this on a VPS, you’re looking at $12-20/month minimum. On a home lab box, you’ll be burning power and heating your office.

But here’s the upside: it’s mature. Polished. The web UI is professional. Moderation tools are production-ready. It’s what everyone knows. If you want to look “official,” Mastodon is your answer.

Misskey: The Feature Beast

Misskey (Node.js) is a different animal. It’s younger, way more feature-rich, and somehow still more efficient than Mastodon.

Baseline requirements (single-user instance):

• Postgres database
• Redis (for caching and job queues)
• Optional: Meilisearch for search (fast and lightweight)
• Optional: Object storage (S3, Minio, etc.) for images — local disk works fine for hobby instances
• One Node.js process (handles all HTTP traffic and job processing)
• 2-4 GB RAM is comfortable (more if you enable advanced analytics)
• 10-20 GB storage

Misskey needs less orchestration than Mastodon. One Node.js process handles the whole workload. It scales linearly as you add features, not exponentially.

The personality: Misskey is the anime one. Custom emoji reactions are first-class. Quoted posts (like Twitter quote tweets) are native. It has charts — built-in analytics showing your post activity, federation traffic, whatever. The interface is more playful. The emoji support is bonkers (you can use emojis in place of traditional reaction buttons).

The downside: it’s not as polished on mobile. The web UI is dense. Documentation is a tier lower than Mastodon’s. And when Misskey’s features hit Mastodon instances, they degrade — a quoted Misskey post shows up as a link on Mastodon, not as an inline quote.

Akkoma (formerly Pleroma): The Minimalist’s Dream

Akkoma is Elixir/OTP running on a single BEAM VM. It’s tiny.

Baseline requirements (single-user instance):

• Postgres database
• Redis (optional — some deployments skip it)
• One Akkoma process (Elixir handles concurrency at the language level, not process level)
• 512 MB to 2 GB RAM (seriously)
• 5-10 GB storage

Akkoma runs on Raspberry Pi 4s. It’s the car analogy: Mastodon is a semi-truck doing the job of a pickup truck. Akkoma is the pickup truck. It does less (fewer features, simpler UI), but it actually fits in your garage.

The personality: Akkoma is utilitarian. Pleroma-FE (the web UI) is functional, not fancy. It supports all the ActivityPub basics, has respectable moderation tools, and gets out of the way. It’s what power users run when they don’t want to babysit a Rails app.

The downside: Misskey and Mastodon devs don’t prioritize Akkoma compatibility. Some newer features fail to federate properly. The community is smaller.

Docker Compose Examples: Spin One Up

Here’s what a realistic deploy looks like for each.

Mastodon Single-User Setup

Updated: Mastodon’s official Docker image moved from Docker Hub (tootsuite/mastodon) to GitHub Container Registry (ghcr.io/mastodon/mastodon) as of v4.3.0.

version: "3.8"

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: mastodon
      POSTGRES_USER: mastodon
      POSTGRES_PASSWORD: change_this
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U mastodon"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  mastodon:
    image: ghcr.io/mastodon/mastodon:latest
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      LOCAL_DOMAIN: yourdomain.com
      SINGLE_USER_MODE: "true"
      RAILS_ENV: production
      DATABASE_URL: postgresql://mastodon:change_this@postgres:5432/mastodon
      REDIS_URL: redis://redis:6379
      SECRET_KEY_BASE: generate_with_rake_secret
      OTP_SECRET: generate_with_rake_secret
    ports:
      - "3000:3000"
    volumes:
      - mastodon_public:/mastodon/public
      - mastodon_assets:/mastodon/app/assets/compiled
      - mastodon_packs:/mastodon/app/javascript/packs
    healthcheck:
      test: ["CMD-SHELL", "wget -q --spider http://localhost:3000/health || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5

  sidekiq:
    image: ghcr.io/mastodon/mastodon:latest
    depends_on:
      - postgres
      - redis
    environment:
      RAILS_ENV: production
      DATABASE_URL: postgresql://mastodon:change_this@postgres:5432/mastodon
      REDIS_URL: redis://redis:6379
      SECRET_KEY_BASE: generate_with_rake_secret
      OTP_SECRET: generate_with_rake_secret
    command: bundle exec sidekiq -c 5 -v
    volumes:
      - mastodon_public:/mastodon/public

volumes:
  postgres_data:
  mastodon_public:
  mastodon_assets:
  mastodon_packs:

Reality check: You’ll spend 2 hours on initial setup (generating secrets, running migrations). Mastodon expects you to know Rails. Documentation is solid, but there’s a learning curve.

Misskey Single-User Setup

version: "3.8"

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: misskey
      POSTGRES_USER: misskey
      POSTGRES_PASSWORD: change_this
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U misskey"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  misskey:
    image: misskey/misskey:latest
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      NODE_ENV: production
    ports:
      - "3000:3000"
    volumes:
      - ./misskey.yml:/misskey/.config/default.yml
      - misskey_files:/misskey/files
    healthcheck:
      test: ["CMD-SHELL", "wget -q --spider http://localhost:3000 || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  postgres_data:
  misskey_files:

You’ll create a misskey.yml config file with your domain, database credentials, and instance settings. Misskey’s setup wizard is friendlier than Mastodon’s. One process handles everything.

Akkoma Minimal Setup

version: "3.8"

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: akkoma
      POSTGRES_USER: akkoma
      POSTGRES_PASSWORD: change_this
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U akkoma"]
      interval: 10s
      timeout: 5s
      retries: 5

  akkoma:
    image: akkoma/akkoma:latest
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      AKKOMA_DOMAIN: yourdomain.com
      DATABASE_URL: postgresql://akkoma:change_this@postgres:5432/akkoma
    ports:
      - "4000:4000"
    volumes:
      - ./config.exs:/etc/akkoma/config.exs
      - akkoma_uploads:/var/lib/akkoma/uploads
    healthcheck:
      test: ["CMD-SHELL", "curl -sf http://localhost:4000/api/v1/instance || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  postgres_data:
  akkoma_uploads:

Akkoma’s setup is the simplest. Config is Elixir syntax (a bit weird if you’ve never seen it), but there are fewer moving parts.

Features: Where the Personalities Diverge

Custom Emoji (All Three)

All three support custom emoji. Misskey makes them gorgeous. You can use them as reaction buttons instead of heart/star/repeat. Mastodon and Akkoma support emoji reactions, but they’re less central to the experience.

Quoted Posts

Misskey: Native. You quote-post like Twitter, and always have.
Mastodon: Native as of 4.5 (late 2025), with opt-in/withdraw controls and notifications so it can’t be used purely for dunking. Older Mastodon instances still render a Misskey quote as a plain link.
Akkoma: No native quote feature.

Quoting used to be the biggest federation gotcha — Mastodon ignored it for years. Now that Mastodon supports it, quotes federate reasonably well between the big two, but only if both instances are recent enough. Akkoma still sits this one out.

Markdown and MFM (Markup Formatting)

Misskey: MFM (Misskey Flavored Markdown). You get $[x2 BIG TEXT], spin effects, animations, color changes. It’s wild. Mastodon and Akkoma instances render it as plain text (you see the markup, not the effect).
Mastodon: Standard markdown only.
Akkoma: Standard markdown.

Reactions and Interactions

Misskey: Custom emoji reactions are first-class. Analytics dashboards showing what’s popular.
Mastodon: Boost/favorite/reply. Functional.
Akkoma: Same as Mastodon.

Search and Discovery

Mastodon: Elasticsearch or Meilisearch. Full-text search works great once indexed.
Misskey: Integrated search. Zippy.
Akkoma: Basic search. Not as powerful.

Mobile Clients: The UX Reality

Here’s the thing: none of these have official mobile apps (except Mastodon’s experimental ones). You’ll be using community-built clients.

For Mastodon instances:

• Tusky (Android) — Solid, polished, recommended.
• Ice Cubes (iOS/macOS) — Beautiful, feature-rich.

For Misskey instances:

• Sharkey app — Dedicated Misskey client. Nice UX.
• Iceshrimp — Web-based, works everywhere.

For Akkoma:

• Mastodon clients work (Akkoma is ActivityPub-compatible).
• Pleroma-FE — Built-in web UI. Functional but dated.

The reality: If you want native mobile, Tusky or Ice Cubes for a Mastodon instance. If you want Misskey’s features on mobile, you’re dealing with Sharkey (less polished) or web only.

Moderation: Running Your Own Space

You’re the admin. You set the rules.

Mastodon: Mature moderation tools. Silence/suspend users and instances. Auto-delete after configurable period. Word filters. Media descriptions (forcing alt text). Good audit logs.

Misskey: Similar moderation tools. Slightly less polished UX for the admin panel, but the features are there.

Akkoma: Solid moderation. Anti-spam features. Instance silencing/suspension.

Single-user reality: If it’s just you, moderation is: don’t post anything you’d delete later. Your followers see whatever you publish. If you do get spammed or stalked, all three let you block/silence/suspend.

Misskey Forks: Sharkey and Iceshrimp

Before we finish, mention the elephant in the room: Sharkey and Iceshrimp are Misskey forks. They take Misskey’s codebase and add their own features/themes. Sharkey adds some UX refinements. Iceshrimp is more aggressive with changes. They’re compatible with Misskey’s ecosystem (custom emoji, reactions, etc.).

If Misskey seems cool but you want different branding or features, Sharkey or Iceshrimp might be worth a look. They use the same resource footprint.

The Federation Quirks (Things Will Break)

Between Misskey and Mastodon:

• Quoted posts federate now (Mastodon 4.5+) — on older Mastodon instances they still show as links.
• MFM markup renders as text.
• Reactions work but look different.

Between Akkoma and Mastodon:

• Generally solid. Akkoma is ActivityPub-conformant.

Between Akkoma and Misskey:

• Most things work. MFM degrades. Quotes become links.

General federation reality:

• Instance admins control who can see your posts. You can block instances. Instances can block you.
• If your instance is young and has no followers, you’re shouting into the void until people follow you.
• Rate limits are real. If your instance hammers another instance, it gets blocked.

Decision Matrix: Which One?

The Honest Truth

Running your own fediverse instance is not running Twitter. You’re hosting a timeline where you are the only user (or a small group is). You post, people follow you, they see your posts in their feeds on their own instances. It’s intimate, not broadcast.

If you’re doing this for the community, for the decentralization story, or because you’re a self-hosting weirdo who likes running services — great. You’ll have fun. Akkoma if you want to keep the lights on cheap. Misskey if you want personality and features. Mastodon if you want it to feel like a real social network.

If you’re doing this because you want followers and engagement — you’re probably better off on a public instance (mastodon.social, pixelfed.social, whatever). Trying to be your own instance and build an audience is like trying to be your own ISP while also convincing people to sign up for your internet service.

Either way, you’re in for the long haul. You’ll be debugging Postgres, restarting services, and explaining federation to people who thought you just left Twitter. Your 2 AM self will either love you or hate you for it.

Good luck out there.