Guide to Migrating to Modern Cores: Purpur, Paper, Folia

Choosing a server core is a fundamental decision that determines the performance, stability, and functionality of your Minecraft server. Utilizing outdated solutions like Vanilla, CraftBukkit, or even standard Spigot is highly inefficient in modern high-load realities. In this article, we will analyze the evolution of server platforms and explain how and why you need to upgrade to modern cores: Paper, Purpur, or the innovative multithreaded core, Folia.

Core Evolution: From Spigot to Purpur

To understand the value of modern technologies, let's examine the platform hierarchy:

• Spigot: The historical foundation. It introduced basic optimization compared to Mojang's original code, but today its algorithms are obsolete. It executes most operations within a single main thread (Main Thread).
• Paper: The recognized industry standard. This is a fork of Spigot that completely rewrote chunk generation systems, physics calculations, and mob AI behavior. Paper fixes critical bugs and vulnerabilities, delivering a massive boost to TPS (Ticks Per Second).
• Purpur: An elite fork of Paper. It inherits absolutely all optimizations from its parent core while introducing an unprecedented level of customization via the purpur.yml file. Here, you can configure individual mob behavior, modify Vanilla game mechanics, and implement features that previously required separate plugins.

Folia: The Multithreading Revolution

Traditionally, Minecraft operates on a "one server — one thread" principle. No matter how many cores your hosting CPU has, the server utilizes only one core at 100%. The Folia core (developed by the PaperMC team) drastically changes the rules of the game.

Folia splits the game world into independent zones called "regions" (Regionized Multithreading). If a group of players is at the spawn point while another group is 5,000 blocks away in the End dimension, these zones are processed in parallel across different CPU cores.

Important Limitation of Folia: Due to the complete restructuring of its architecture, standard plugins that utilize synchronous tasks will cause an immediate crash. Folia requires specialized, region-aware versions of plugins. Use this core only for massive projects (Anarchy, SkyBlock with thousands of players online) and only if you have sufficient technical experience. For classic servers, Purpur remains the ideal choice.

Step-by-Step Algorithm for Core Migration

The migration process in your hosting control panel is completely safe if you strictly follow this sequence of actions.

1. Create a Backup: Navigate to the "Backups" section in your server control panel and create a restoration point. Modifying core structures is a delicate process.
2. Download the Distribution File: Visit the official website of your chosen core (e.g., purpurmc.org) and download the latest .jar file corresponding to your game version.
3. Prepare the File System: Open the File Manager or connect via SFTP. Stop the server. Locate the old executable core file (usually named server.jar, spigot.jar, or paper.jar) and delete it.
4. Upload and Rename: Upload the downloaded new core file to the server root directory. Rename it according to your panel's requirements (e.g., to server.jar), or change the executable file name in the "Startup Settings" section.
5. First Launch and Config Generation: Start the server. The console will begin converting data and generating new configuration files (paper-world-defaults.yml, purpur.yml). Wait for the full boot and the Done! message, then restart the server.

Troubleshooting Common Issues

Issue 1: Server throws "Unsupported Class Version Error" on startup

Cause: Newer core versions require updated Java environments. For instance, Minecraft 1.20+ requires at least Java 17, while 1.20.6+ often demands Java 21.

Solution: Go to the "Startup Settings" section of your control panel, switch the Docker image (Java version) to the required one, and restart the server.

Issue 2: Custom mechanics disappeared or plugins throw errors in the console

Cause: Some plugins are hardcoded to Spigot's internal code (NMS). When migrating to Paper/Purpur, these methods may be removed or altered.

Solution: Update all plugins to their latest stable versions. Replace obsolete software with modern alternatives (e.g., use EssentialsX instead of the outdated Essentials).

Combating Lag: Fine-Tuning Config Files (paper.yml, purpur.yml, spigot.yml)

A stable 20.0 TPS is the primary marker of quality hosting and a properly configured server. By default, core developers keep settings maximized to maintain single-player mechanics. In a multiplayer environment, this results in massive lag. Professional optimization relies on subtly lowering the simulation distance and limiting excessive mob AI.

Areas of Responsibility for Configuration Files

Each core handles specific aspects of the game:

• spigot.yml — responsible for basic distances, crop growth rates, and entity activation.
• paper-world-defaults.yml (formerly paper.yml) — deep optimization of world mechanics, chunks, collisions, and loading.
• purpur.yml — fine-tuning individual mob attributes and unique gameplay parameters.

Optimal Parameters for Performance

Open these files via your hosting panel's built-in text editor and adjust the following parameters to achieve maximum performance:

Configuring spigot.yml

world-settings:
  default:
    verbose: false
    # Limits entity activation radius (mobs outside this range "go to sleep")
    entity-activation-range:
      animals: 16
      monsters: 24
      raiders: 48
      misc: 4
    # Limits tick frequency for mob AI tracking
    entity-tracking-range:
      players: 48
      animals: 48
      monsters: 48
      misc: 32
    # Reduces load from hopper tick checks
    ticks-per:
      hopper-transfer: 8
      hopper-check: 8

Configuring paper-world-defaults.yml (or paper.yml)

chunks:
  auto-save-interval: 6000 # Increases chunk auto-save interval (in ticks)
  max-auto-save-chunks-per-tick: 6
collisions:
  max-entity-collisions: 2 # Limits mob collision checks in one spot (critical for farms)
  fix-climbing-bypassing-cramming-rule: true
entities:
  spawning:
    despawn-ranges:
      monster:
        soft: 30
        hard: 56
    per-player-mob-spawns: true # Separate mob spawn limits for each individual player

Configuring purpur.yml

settings:
  # Disables performance degradation when processing villager pathfinding
  brain-deactivation-of-villagers-src: true
  dont-send-useless-entity-packets: true
  # Optimizes lag caused by projectiles and active buffs
  lag-compensation:
    enabled: true

Simulation vs. View Distance (The Most Critical Step)

In modern Minecraft versions (1.18+), visibility settings are split into two independent options within the server.properties file:

1. view-distance: The distance at which players see the landscape. Chunks are sent to the client, but the server spends no CPU resources processing active events inside them. Recommended value: 6 to 8.
2. simulation-distance: The radius around the player where physical processes happen, redstone circuits tick, crops grow, and mobs move. This is the main source of server lag. Set this to 4 or 5. Doing so reduces CPU load by 40-50% without causing visual discomfort.

How to Verify Your Optimization Results

Use Paper's built-in timings system. Enter the following command in the server console:

/timings on (wait 10-15 minutes during stable player activity), then enter /timings paste.

You will receive a link to a detailed, interactive web report showing exactly which system (plugins, entities, world generation) is consuming your CPU milliseconds (Tick Duration).

Installing and Configuring Protection Against Griefing and Bot Attacks

Public Minecraft servers face various threats daily, ranging from basic griefing (destruction of builds by regular players) to professional bot attacks aimed at flooding slots with fake connections and overloading the hosting CPU with authentication requests. In this guide, we will break down a comprehensive, layered defense system for your project.

Layer 1: World Protection (Griefing Defense)

To prevent destructive behavior from players, a classic, time-tested plugin stack is required:

• WorldGuard + WorldEdit: Allows creating regions where regular players cannot break blocks, open chests, or ignite flint and steel.
• CoreProtect: The most vital tool for an administrator. This plugin logs absolutely every action on the server (who placed a block, who took an item from a chest, who poured lava).

In the event of massive griefing, you don't need to roll back the entire server and wipe out other players' progress. You can run a precise rollback command targeting the specific offender within a timeframe:

/co rollback u:[Griefer_Nick] t:2h r:50 (rolls back all actions of that player over the last 2 hours within a 50-block radius).

Layer 2: Protection Against Bot Attacks and L7 DDoS

A bot attack simulates a massive influx of players joining simultaneously. A standard core wastes resources creating sessions, loading skins, and generating chunks for hundreds of bots per second, quickly driving the server offline.

Technical Info: Basic hosting protection (L3/L4 of the OSI model) deflects attacks on network ports. However, it cannot differentiate a real player packet from a bot packet, as both use the legitimate Minecraft game protocol (L7). Protocol-level security must be configured inside the server itself.

Implementing Security via Anti-Bot Plugins

Install specialized traffic filtering plugins, such as AntiBotDeluxe, UltimateAntibot, or the free alternative BKCommonLib / LimboFilter. They operate using the following logic:

1. Upon a sudden spike in connection rates, the server enters "Attack Mode".
2. New connections are blocked from entering the main world. The plugin redirects them to a virtual "Limbo world" (a lightweight buffer that doesn't strain RAM or CPU).
3. The player is prompted to pass a simple verification: click a specific item in a GUI, move around, or complete a captcha. Bot software cannot process these custom packets and gets filtered out.

Layer 3: Network Architecture (Proxy Setup via Velocity / BungeeCord)

For large projects or servers planning to scale, configuring a proxy architecture is mandatory. Instead of opening direct access to the actual game server (e.g., Survival), you place a proxy server in front, like Velocity (recommended) or BungeeCord.

To configure a secure link, you must set online-mode=false in the backend server's server.properties file, but make sure to enable modern modern player forwarding in paper-world-defaults.yml:

proxies:
  velocity:
    enabled: true
    online-mode: true
    secret: "your_secret_key_from_velocity_config"

This completely blocks malicious users from bypassing the proxy to log into your server using administrator nicknames.