> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/PaperMC/Paper/llms.txt
> Use this file to discover all available pages before exploring further.

# Paper vs Other Server Software

> Comprehensive comparison of Paper with vanilla Minecraft, Spigot, and other server implementations

# Comparison

Understand how Paper compares to vanilla Minecraft and other popular server software options.

## At a Glance

<CardGroup cols={3}>
  <Card title="Vanilla" icon="box">
    Official Mojang server with no modifications or plugins
  </Card>

  <Card title="Spigot/CraftBukkit" icon="plug">
    Plugin support with basic API and minimal optimizations
  </Card>

  <Card title="Paper" icon="bolt">
    Plugin support + extensive API + performance optimizations + bug fixes
  </Card>
</CardGroup>

## Feature Comparison Matrix

| Feature                   | Vanilla       | Spigot  | Paper     |
| ------------------------- | ------------- | ------- | --------- |
| Plugin Support            | ❌             | ✅       | ✅         |
| Bukkit API                | ❌             | ✅       | ✅         |
| Extended API              | ❌             | ❌       | ✅         |
| Performance Optimizations | ❌             | Basic   | Extensive |
| Bug Fixes                 | Official Only | Some    | Hundreds  |
| Gameplay Improvements     | ❌             | Limited | Many      |
| Per-World Configuration   | ❌             | ❌       | ✅         |
| Adventure API             | ❌             | ❌       | ✅         |
| Modern Text Components    | ❌             | ❌       | ✅         |
| Entity AI Customization   | ❌             | Limited | Full      |
| Registry Access           | ❌             | ❌       | ✅         |
| Data Components API       | ❌             | ❌       | ✅         |
| Async Chunk Loading       | ❌             | ❌       | ✅         |
| Active Development        | ✅             | ✅       | ✅         |
| Update Speed              | Fast          | Medium  | Fast      |
| Community Size            | Large         | Large   | Largest   |

## Vanilla Minecraft Server

The official server software provided by Mojang.

### Advantages

<CardGroup cols={2}>
  <Card title="Official Support" icon="check">
    Direct support from Mojang with guaranteed compatibility
  </Card>

  <Card title="Pure Gameplay" icon="gamepad">
    Unmodified Minecraft experience exactly as designed
  </Card>
</CardGroup>

### Limitations

<CardGroup cols={2}>
  <Card title="No Plugins" icon="ban">
    Cannot extend functionality with plugins or mods
  </Card>

  <Card title="Performance Issues" icon="gauge-low">
    No optimizations for chunk loading, entity processing, or redstone
  </Card>

  <Card title="Limited Configuration" icon="sliders">
    Minimal server.properties configuration options
  </Card>

  <Card title="Known Bugs" icon="bug">
    Gameplay and mechanics bugs remain unfixed for months or years
  </Card>
</CardGroup>

### When to Use Vanilla

* Running a small private server with friends
* Want guaranteed 100% vanilla Minecraft experience
* Don't need plugins or customization
* Playing on snapshots or experimental versions

## Spigot & CraftBukkit

Spigot builds on CraftBukkit to provide plugin support and basic optimizations.

### Advantages

<CardGroup cols={2}>
  <Card title="Plugin Ecosystem" icon="puzzle-piece">
    Access to thousands of Bukkit/Spigot plugins
  </Card>

  <Card title="Mature Platform" icon="clock">
    Long-established platform with extensive documentation
  </Card>

  <Card title="Basic Optimizations" icon="gauge-simple">
    Some performance improvements over vanilla
  </Card>

  <Card title="Wide Compatibility" icon="handshake">
    Most plugins support Spigot
  </Card>
</CardGroup>

### Limitations Compared to Paper

* **Limited API** - Missing many events, methods, and features that Paper provides
* **Fewer Optimizations** - Performance improvements are minimal compared to Paper
* **Legacy Systems** - Uses older APIs (e.g., legacy chat instead of Adventure)
* **Slower Bug Fixes** - Bugs are fixed at a slower pace
* **Less Configuration** - Fewer per-world and gameplay configuration options

### Migration from Spigot to Paper

<Note>
  **Paper is a drop-in replacement for Spigot.** All Spigot plugins work on Paper without modification.
</Note>

Migration steps:

<Steps>
  <Step title="Backup Your Server">
    Always backup your world files and configuration before switching
  </Step>

  <Step title="Download Paper">
    Get the latest Paper jar from [papermc.io/downloads/paper](https://papermc.io/downloads/paper)
  </Step>

  <Step title="Replace Server Jar">
    Replace your Spigot jar with the Paper jar
  </Step>

  <Step title="Start the Server">
    Launch your server - all plugins and worlds will work immediately
  </Step>

  <Step title="Configure Paper">
    Review `paper-global.yml` and `paper-world-defaults.yml` to customize settings
  </Step>
</Steps>

## Paper Server

The most widely used high-performance Minecraft server implementation.

### Why Paper Exists

Paper was created to address fundamental issues with both vanilla Minecraft and Spigot:

1. **Gameplay Bugs** - Mojang leaves many gameplay and mechanics bugs unfixed
2. **Performance Problems** - Vanilla has severe performance bottlenecks
3. **Limited API** - Spigot's API is incomplete for many common plugin needs
4. **Configuration Gaps** - Servers need more control over gameplay mechanics

### Key Advantages

#### 1. Extensive Performance Optimizations

Paper includes hundreds of optimizations across all server systems:

**Chunk System:**

* Async chunk loading and generation
* Chunk generation caching
* Incremental world saving
* Smart chunk unloading algorithms

**Entity System:**

* Optimized pathfinding (up to 10x faster)
* Activation range system
* Improved entity tracking
* Optimized collision detection

**Redstone:**

* Fast redstone wire algorithm (up to 20x faster)
* Optimized hopper transfers
* Improved piston mechanics

<Tip>
  A typical Paper server can handle 2-3x more players than vanilla or Spigot with the same hardware.
</Tip>

#### 2. Comprehensive Plugin API

Paper adds hundreds of API methods and events:

```java theme={null}
// Paper-exclusive events
AnvilDamagedEvent
BeaconEffectEvent
BlockDestroyEvent
CreeperIgniteEvent
EnderDragonFireballHitEvent
EndermanAttackPlayerEvent
// And hundreds more...
```

**API Categories:**

* Block manipulation and events
* Entity AI and behavior control
* Player interaction and connection
* World generation and modification
* Server lifecycle and commands
* Inventory and item data components
* Packet sending and protocol

#### 3. Modern Development Stack

<CardGroup cols={2}>
  <Card title="Adventure API" icon="message">
    Modern component-based text and chat system
  </Card>

  <Card title="Registry Access" icon="database">
    Full access to Minecraft's data registries
  </Card>

  <Card title="Data Components" icon="cube">
    Type-safe item and entity data access
  </Card>

  <Card title="Brigadier Commands" icon="terminal">
    Advanced command system integration
  </Card>
</CardGroup>

#### 4. Gameplay Bug Fixes

Paper fixes hundreds of bugs that Mojang hasn't addressed:

* TNT duplication exploits
* Inconsistent piston behavior
* Chunk loading edge cases
* Entity duplication bugs
* Redstone timing issues
* Mob AI pathfinding problems

#### 5. Flexible Configuration

**Global Configuration** (`paper-global.yml`):

```yaml theme={null}
chunk-loading:
  enable-world-gen-cache: true
  max-concurrent-sends: 2
  
packet-limiter:
  kick-message: "&cSent too many packets"
  limits:
    all:
      interval: 7.0
      max-packet-rate: 500.0
```

**Per-World Configuration** (`paper-world.yml`):

```yaml theme={null}
entities:
  spawning:
    mob-spawn-range: 8
    all-chunks-are-slime-chunks: false
  behavior:
    baby-zombie-movement-modifier: 0.5
    disable-chest-cat-detection: false
    
chunks:
  auto-save-interval: 6000
  prevent-moving-into-unloaded-chunks: true
```

#### 6. Active Development and Community

* **Daily updates** during Minecraft releases
* **Fastest update times** - often same-day as Minecraft updates
* **Largest community** - most plugins are built for Paper
* **Professional maintenance** - backed by PaperMC organization
* **Open source** - fully transparent development

### Trade-offs

<Warning>
  Paper fixes gameplay bugs and inconsistencies, which may break:

  * Exploits (TNT duplication, item duplication)
  * Unintended mechanics that some technical players rely on
  * Redstone contraptions built around bugs
</Warning>

Most gameplay fixes can be disabled via configuration if needed.

## Other Server Software

### Purpur

Builds on Paper with even more features and configuration options.

* **Relationship**: Fork of Paper
* **Compatibility**: All Paper plugins work
* **Focus**: Additional gameplay customization and features
* **Trade-off**: More experimental, may have stability issues

### Pufferfish

Paper fork focused on performance optimizations.

* **Relationship**: Fork of Paper
* **Compatibility**: All Paper plugins work
* **Focus**: Maximum performance
* **Trade-off**: Fewer features than Paper or Purpur

### Folia

Paper's regionized multithreading project.

* **Relationship**: Paper project
* **Compatibility**: Requires plugin updates
* **Focus**: Massive performance through multithreading
* **Trade-off**: Breaking API changes, not all plugins compatible

<Info>
  Folia is designed for extremely large servers (100+ players) and requires significant plugin updates.
</Info>

## Recommendation by Use Case

### Small Private Server (1-10 players)

**Recommended: Paper**

Benefits over vanilla:

* Better performance even with few players
* Plugin support for essentials, protection, etc.
* Bug fixes improve gameplay
* Same update speed as vanilla

### Medium Server (10-50 players)

**Recommended: Paper**

Critical advantages:

* Performance optimizations become essential
* Wide plugin compatibility
* Per-world configuration for different game modes
* Active community support

### Large Server (50+ players)

**Recommended: Paper or Folia**

* **Paper**: Best all-around choice, stable and performant
* **Folia**: If you need extreme performance and can update plugins

### Development/Testing

**Recommended: Paper**

* Largest plugin ecosystem
* Best API documentation
* Test plugin module included
* Most developers target Paper

## Migration Guide

### From Vanilla → Paper

<Steps>
  <Step title="Install Java 21">
    Paper requires Java 21 or later
  </Step>

  <Step title="Backup Everything">
    Backup worlds, configs, and player data
  </Step>

  <Step title="Download Paper">
    Get the jar for your Minecraft version
  </Step>

  <Step title="First Run">
    Run Paper to generate configuration files
  </Step>

  <Step title="Configure">
    Review and customize Paper configs
  </Step>

  <Step title="Add Plugins">
    Install desired plugins in the plugins folder
  </Step>
</Steps>

### From Spigot → Paper

<Note>
  This is a seamless process - Paper is 100% compatible with Spigot.
</Note>

1. **Stop your server**
2. **Replace** `spigot.jar` with `paper.jar`
3. **Start the server** - everything works immediately
4. **Review** new Paper configuration options

## Performance Benchmarks

Typical performance improvements compared to vanilla:

| Metric             | Vanilla | Paper  | Improvement |
| ------------------ | ------- | ------ | ----------- |
| Chunk Loading      | 100ms   | 30ms   | 3.3x faster |
| Entity Pathfinding | 5ms     | 0.5ms  | 10x faster  |
| Redstone Wire      | 20ms    | 1ms    | 20x faster  |
| Hopper Transfers   | 2ms     | 0.5ms  | 4x faster   |
| Players Supported  | \~50    | \~150+ | 3x more     |

<Tip>
  Actual performance gains depend on your specific use case, plugins, and hardware.
</Tip>

## Conclusion

Paper is the recommended choice for virtually all Minecraft servers:

✅ **Drop-in replacement** for both vanilla and Spigot\
✅ **Better performance** than any alternative\
✅ **More features** and configuration options\
✅ **Largest ecosystem** of compatible plugins\
✅ **Active development** with fast updates\
✅ **Professional maintenance** and community support

The only reasons to use vanilla are:

* You need 100% unmodified vanilla mechanics (including bugs)
* You're running experimental snapshots not yet supported by Paper
* You absolutely cannot use any third-party software

<CardGroup cols={2}>
  <Card title="Get Started" icon="rocket" href="/introduction">
    Download Paper and start your server
  </Card>

  <Card title="Explore Features" icon="compass" href="/features">
    Learn about Paper's capabilities
  </Card>
</CardGroup>