Datapacks vs Plugins: Where's the Line?
Datapacks vs plugins minecraft: datapacks rearrange vanilla data like recipes and loot with no jar; plugins are code for commands, ranks, and databases.
A datapack rearranges data the game already ships — recipes, loot tables, advancements, worldgen, and logic scripted through functions — using vanilla's own loader, so there's no jar and no code involved. A plugin is code: a .jar that hooks server events, so the moment you need a custom command, a permission check, a saved database, or a clickable menu, you've left datapack territory. Custom recipes are almost always a datapack; a genuinely new mob or item usually isn't, and knowing which side of that line you're on saves a lot of wasted effort.
The one-line rule: data vs code
Ask yourself one question: am I re-arranging things the game already does, or teaching it a new trick? Datapacks rearrange. Plugins teach new tricks. That's the whole distinction, and almost every "which do I use" question collapses into it.
Both are server-side, and both are invisible to the people connecting. Nobody downloads anything to join a server running either one. The difference that bites you later is where they run. A datapack works everywhere because it's part of Minecraft itself — vanilla, Paper, Fabric, even your singleplayer world. A plugin needs a Bukkit-family server (Paper, Spigot, or Purpur) and won't load on plain vanilla or Fabric at all; drop a .jar on a vanilla server and nothing happens. The files live in different places too: a datapack goes in world/datapacks/, a plugin goes in plugins/.
What a datapack can do (its ceiling)
A datapack is a folder of JSON (and some .mcfunction files) under data/<namespace>/. Since the 1.21-era rename the folder names are singular in 26.x, so it's recipe/, loot_table/, advancement/, function/, predicate/, item_modifier/, tags/, enchantment/, and damage_type/. There's also a worldgen/ tree for custom biomes, structures, and whole dimensions. Anything the game already generates from data, you can override or add to here.
The scripting lives in function/. A .mcfunction file is just a list of commands, and two special function tags run them automatically: minecraft:load fires once when the pack loads, minecraft:tick fires every tick, twenty times a second. State is held in the scoreboard and in data storage, and you push it around with /execute. That's enough to build genuinely clever mechanics — custom kill counters, timed events, teleport puzzles — without a single line of Java. At the top of every pack sits pack.mcmeta, which carries the pack_format number, and that number has to match the running version or the pack quietly refuses to load.
The ceiling is real and worth stating plainly. A datapack can only combine mechanics the game already has. No new base block, item, or entity type. No new client-side rendering. No real database, no network calls, no true permission system. If you want the full folder-and-reload walkthrough for getting one running, see how to install a datapack on a server — the short version is that it drops into world/datapacks/ and /reload picks it up live.
What forces a plugin (the other side of the line)
The instant you need something the vanilla data model doesn't expose, you're writing (or installing) a plugin. The "only a plugin can do this" list is specific: custom commands with real arguments and tab-complete, permission nodes and ranks, a proper database (MySQL or SQLite) for persistent per-player data, clickable inventory-GUI menus, an economy, cross-server networking through Velocity or BungeeCord, event hooks like on-join or on-block-break for region protection, packet-level anti-cheat like Grim or Vulcan, and code-driven mob AI. None of those have a JSON equivalent, because none of them are things vanilla already does.
Installing one is different from a datapack in a way that trips people up. The .jar goes in plugins/, and you load it with a full server restart, not /reload — Paper has deprecated /reload for plugins and it will happily corrupt your plugin state if you lean on it. After the restart, run /plugins: green means loaded, red means it failed and you go read the console. Again, this only works on Paper, Spigot, or Purpur. The add-a-plugin walkthrough covers the restart-and-verify loop in detail, and if you're kitting out a fresh box, the must-have plugins list points at the permissions, protection, and command tools most servers install first.
Custom recipes: nearly always a datapack
This is the most common first job, and the answer is almost always "datapack." A crafting, smelting, blasting, stonecutting, or smithing recipe is a single JSON file dropped into data/<namespace>/recipe/. The game reads it directly, /reload applies it live with no restart, and you test it by opening the recipe book or running /recipe give @s <id> to make sure it registered. For a diamond-from-nine-coal joke recipe or a genuinely useful shortcut, this is a two-minute job.
You'd only reach for a plugin here in three cases: the recipe has to be gated to a specific rank, it needs to unlock dynamically based on some condition, or it outputs a plugin-defined custom item that vanilla doesn't know about. Those all require registration in code — a Bukkit ShapedRecipe tied to a NamespacedKey. Absent one of those reasons, datapack it every time.
Custom mobs and items: this is where it actually splits
"Custom mob" means three different things, and which one you want decides the tool. Think of it as a ladder.
A reskinned or scripted variant is an existing entity — say a zombie — with modified attributes, custom equipment, a custom name, and a minecraft:tick function watching for an entity tag to run its behavior. A datapack handles this well. You /summon it, tag it, and let a function drive the logic. Plenty of "custom boss" datapacks are exactly this.
A code-driven mob wants real AI, drops triggered by a death event, a boss bar, targeting logic beyond what tags can fake — but it's still riding an existing entity base. That's a plugin. The base entity is vanilla; the brain is Java.
A brand-new entity has its own model, its own texture, and its own hitbox. That's neither a datapack nor a plugin — that's a mod, on Fabric or Forge, installed on the client and the server. There's no server-side-only way to ship a new entity type that renders on a vanilla client.
Items follow the same ladder. An existing item carrying components — custom_model_data, attribute modifiers, a custom name and lore — plus a resource pack for the look is a datapack job; see what a server resource pack is for how the texture side gets delivered. Right-click abilities or on-use behavior push it to a plugin. A wholly new item type is a mod. When you find yourself wanting a truly new block or entity, that's the signal to weigh modded versus vanilla for your server, because it's a bigger commitment than either datapacks or plugins.
Running both (and the 26.x timing wrinkle)
Datapacks and plugins sit at different layers and don't fight by default. The typical real server runs datapacks for recipes, loot, and advancements and plugins for permissions, protection, and commands, all at once. Load order is the only thing to remember: /reload refreshes datapacks and is perfectly fine for them, while plugins still need a full restart.
There's one genuine collision. If a plugin recipe and a datapack recipe produce the same output, both register, and you get a duplicate or ambiguous result rather than one cleanly winning. The fix is to disable one side — pick the system you want to own that recipe and remove it from the other.
Close with the version fact that shapes all of this. When a new drop lands, datapacks are the customization you can count on running on it straight away. Mojang's jar is out on release day, but Paper keeps each new version behind an experimental toggle for a while, which is exactly why plugin servers tend to trail the vanilla crowd until Paper marks the new version stable. You can see the split in the live rankings between the vanilla crowd on /servers/version/26.3 and the plugin servers that haven't moved yet on /servers/version/26.2 or /servers/version/26.1. Datapacks aren't exempt from the churn, though: 26.3 moved the data pack format to 121.0 with a long list of breaking changes, so a pack written for 26.2 should be expected to need an update.
FAQ
Can a datapack add a genuinely new block or item?
No new base type. The closest you get is an existing item carrying a custom_model_data component paired with a resource pack that supplies the texture, so it looks new while still being, mechanically, a stick or a carrot on a stick. A "custom block" is usually a plugin faking it with note blocks or display entities. A real, new block type with its own ID needs a mod.
Do players have to install anything for either one?
No, for both — datapacks and plugins are entirely server-side. The one exception is textures: if either relies on a resource pack for a custom look, the client gets prompted to download it on join. That prompt is driven by the resource-pack= line in server.properties, not by the datapack or plugin itself.
Which is easier to build myself?
A datapack, by a wide margin. It's JSON plus .mcfunction text, no compiler, and you edit a file and /reload to see the change immediately. A plugin needs a JDK plus a build tool like Gradle or Maven, and every change means a recompile followed by a full restart. If you don't own a Java toolchain, a datapack is the only one of the two you can start today.
How do I tell which recipe is causing the conflict?
Open the recipe book in-game and search the output item: a duplicate shows up as two entries for the same result, or one entry whose ingredient grid flickers between two layouts as the book cycles them. To learn which side owns each, run /datapack list and check the plugins/ folder — the datapack's copy is a readable JSON file under data/<namespace>/recipe/, while the plugin's is baked into its jar. Turn off the datapack copy with /datapack disable "file/<name>" then /reload; if the clash clears, that side was the culprit, and if it doesn't, the plugin owns the recipe and you pull it there instead.

