StackNest Documentation

Everything you need to get better generations, cleaner outputs, and a smoother path from prompt to deployed plugin.

What is StackNest?

StackNest is an AI development tool for Minecraft server plugins, Fabric/Forge/NeoForge mods, and related server workflows. You describe what you want in plain English — for example “a Fabric mod that adds a /heal command and a glowing apple item” or “a plugin that rewards players when they vote” — and StackNest generates the code, metadata, and validation feedback.

You do not need to be a Java expert to get started. The goal is to shorten the path from idea to working plugin or mod, then give you enough tooling to refine, validate, and deploy with confidence.

Generating mods with AI

In addition to server plugins, StackNest can generate Fabric, Forge, and NeoForge mods from a single prompt. Mod generation runs through the same AI pipeline as plugin generation, but produces mod-specific source files instead of a compiled server plugin.

What you get from a mod generation:

• A main Java class implementing the correct mod entry point (ModInitializer for Fabric, @Mod class for Forge/NeoForge)
• The mod metadata file — fabric.mod.json for Fabric, mods.toml for Forge/NeoForge
• A Gradle build config stub (build.gradle)
• Inline comments explaining how to wire up the generated features

Fabric, Forge & NeoForge

Your first mod

1. Switch to Mods mode In the generator at /app, click the Mods pill at the top of the composer. The control strip will change to show mod options.
2. Choose your loader and MC version Select Fabric, Forge, or NeoForge and pick the Minecraft version you are targeting. Give your mod a name.
3. Select feature chips (optional) Toggle chips like Custom items, Commands, Event listeners, or Config file to add those patterns to your generation.
4. Describe your mod Write what the mod should do, e.g. “A Fabric 1.21 mod that adds a /heal command and a custom glowing apple item.” The more detail, the better the output.
5. Copy the source into your project Drop the generated Java file(s) into the correct package inside your Fabric/Forge/NeoForge project, merge the fabric.mod.json or mods.toml, and run ./gradlew build.

Skript generation

Skript is a scripting plugin for Paper that lets you add game logic in plain-English syntax — no Java compilation needed. StackNest generates complete .sk script files using the Skript 2.x rule set.

How to generate a Skript

1. Click the Skript pill On the generator at /app, click Skript in the mode pills row. The composer strips down to just a text box — no loader or version selector needed.
2. Describe what you want Write what the script should do, e.g. “A /sethome and /home command that saves each player’s home location and teleports them back to it.”
3. Download and install Save the generated .sk file into your server’s plugins/Skript/scripts/ folder. Run /sk reload all or restart the server.

What StackNest enforces for Skript

• Indentation-based scope — no braces, no semicolons
• Correct event names: on join: not on player join:
• Variables: {global} for persistent, {_local} for temporary, {list::*} for lists
• String interpolation with %expr% inside "..."
• Stores player UUIDs, not player objects, in long-lived variables
• No Java syntax leaking in (no ;, no {} blocks, no import)

Datapack generation

Vanilla datapacks let you modify game behaviour without a plugin or modloader — using only JSON files, .mcfunction scripts, and folder conventions that Minecraft reads natively.

StackNest generates a complete datapack file tree for MC 1.21+ and labels each file with its intended path, so you know exactly where to place it.

How to generate a datapack

1. Click the Datapacks pill On the generator at /app, click Datapacks. A MC version dropdown appears — pick the version you are targeting.
2. Describe your datapack Explain what it should do: “Give players the Speed II effect when they eat a golden carrot. Remove it after 30 seconds.”
3. Install the output Create a folder inside your world’s datapacks/ directory with the namespace name. Drop the generated files into the correct sub-paths (each file in the output starts with a comment showing its path). Run /datapack enable "file/<name>" and /reload.

What StackNest generates for datapacks

• pack.mcmeta — with the correct pack_format (48 for 1.21, 61 for 1.21.4)
• data/<namespace>/functions/ — .mcfunction files for tick, load, and any custom logic
• Tick & load function tags in data/minecraft/tags/function/
• Advancements, recipes, loot tables, and predicates in JSON
• Scoreboard initialisation in the load function

Your first plugin

1. Create a free account Go to /app and sign up with your email. Verify your email — you'll get a confirmation link.
2. Describe your plugin Type what you want in the prompt box. Be specific — the more detail you give, the better the result. See Writing better prompts.
3. Wait for generation Click Generate. StackNest writes your plugin, validates it, and attempts automatic corrections when needed. This usually takes 15–60 seconds, but larger plugins can take longer.
4. Download your JAR Once generated, click Download JAR. Drop the .jar file into your server's plugins/ folder and restart.

Writing better prompts

The quality of your plugin depends heavily on how clearly you describe it. Here are the key things to include:

• What triggers the plugin — a command, an event (player joins, breaks a block, dies), a timer
• What it does — the specific action or behaviour
• Who it affects — all players, specific permissions, ops only
• Any configuration — messages, cooldowns, limits
• Any dependencies — Vault, LuckPerms, PlaceholderAPI, databases, or other required plugins

Prompt template

Use this structure when you want more reliable results:

Build a Paper 1.21 plugin.

Main features:
- [feature 1]
- [feature 2]

Commands:
- /example

Permissions:
- example.use for regular players
- example.admin for admins

Config:
- message text should be configurable
- cooldown should default to 30 seconds

Storage / integrations:
- use YAML / SQLite / Vault / LuckPerms

Notes:
- make this Folia-compatible if needed
- keep messages formatted with Adventure components

Prompt examples

Platform overview

Minecraft server software comes in many flavours. Choosing the right one affects what features your plugin can use.

Which platform should I choose?

How generation works

When you hit Generate, StackNest goes through several steps automatically:

1. Your prompt is sent to the AI — it writes Java code and descriptor files based on what you described.
2. For plugins: the code is compiled — the plugin is compiled against the real PaperMC API and any errors are shown.
3. For plugins: automatic fixing — if the code has issues, StackNest retries with targeted corrections before returning the result.
4. For mods: source output only — mods are not compiled server-side. You receive Java source, fabric.mod.json/mods.toml, and a Gradle stub to build locally.
5. For Skript: .sk file output — a complete .sk script ready to drop into plugins/Skript/scripts/. No compilation step.
6. For datapacks: full file tree — pack.mcmeta, .mcfunction files, JSON tags, advancements, recipes, and loot tables. Each file is labelled with its install path.
7. You get the output — the code, any warnings, and a download button for the compiled JAR (plugins) or source files (mods, Skript, datapacks).

Architecture patterns the AI is guided to use

For complex plugins the AI follows a set of production-grade patterns, not just syntactically correct Java:

• Layered manager classes — a top-level DatabaseManager, CacheManager, and service layer instead of logic in the main plugin class.
• Async-safe player data loading — a ConcurrentHashMap<UUID, CompletableFuture<PlayerData>> dedup map so the database is hit exactly once per UUID even under concurrent join events.
• Bounded write queues — a LinkedBlockingQueue with a configurable size cap and inline fallback, flushed before shutdown.
• Config-driven backpressure — a Semaphore sized to availableProcessors() * 2 limits concurrent database operations so threads are not exhausted under load.
• Stale-task guards — async callbacks check both plugin.isEnabled() and a System.nanoTime() instance ID so they silently drop work if the plugin was reloaded mid-flight.
• Retry jitter — failed external API calls back off with Math.random() * baseDelay to prevent thundering-herd retry storms.
• Copy-on-write snapshots — mutable PlayerData is snapshotted on the main thread before being handed to async writers to prevent torn multi-field reads.

Validation & errors

StackNest validates your plugin at every stage before returning the result:

• Java compilation — the code is compiled against the real Paper 1.21 API using javac. Compiler errors are captured and fed back into the auto-heal loop.
• plugin.yml check — all required fields are verified: name, version, main, and api-version. Missing or malformed entries are caught before the JAR is packaged.
• Static analysis — catches unsafe and broken patterns before the code ever reaches a server:
  • Main-thread violations — reading or writing world state from an async callback
  • Deprecated API use — removed or legacy Bukkit calls that break on Paper 1.17+
  • Thread.sleep() in async tasks — blocks the thread pool slot; replaced with runTaskLaterAsynchronously
  • Raw NMS access — internal Minecraft internals that break on every version bump
  • Unbounded collections and missing ConcurrentHashMap on shared state
  • Stale async callbacks after plugin reload (isEnabled() checks)
• Quality review — no truncated methods, no empty catch blocks, no placeholder comments left in the output.

If warnings appear after generation they are usually minor (like an unused import) and the plugin will still work. Errors shown in red mean compilation failed — try regenerating with a more specific prompt, or describe what went wrong and the auto-heal loop will attempt a targeted fix.

Downloading your JAR

After a successful generation, click Download JAR. You'll get a .jar file ready to install:

1. Stop your server (or let it run — hot-loading is possible but not recommended).
2. Drop the .jar into your server's /plugins folder.
3. Start (or restart) the server.
4. The plugin loads automatically. Check your console for any startup errors.

Runtime plugin testing Beta

Instead of downloading a JAR and deploying it to your own server, you can ask StackNest to boot a real Paper 1.21.1 server instance, load your plugin, and return a structured diagnostic report — all within the browser, in under 60 seconds.

How to use it

1. Generate a plugin as normal in the editor.
2. Once generation succeeds, click the Test on Server button in the action bar (Starter and above only).
3. A results panel slides open and streams the test output. It takes roughly 30–60 seconds.
4. Review the stat tiles (load time, warnings, errors) and the StackNest Insights section for AI-powered fix hints.
5. Expand Full server log for the raw Paper output if you need to dig deeper.

Plan limits

What the report includes

• Load status — whether the plugin enabled successfully.
• Errors & warnings — counts extracted directly from the server log.
• Stack traces — any Java exceptions printed during startup or the first tick.
• StackNest Insights — up to 25 AI-powered hints matched against common plugin issues (missing dependencies, deprecated API calls, unsafe async operations, and more).
• Full server log — the complete Paper console output, expandable on demand.

Gallery

The Gallery is a community library of plugins that users have uploaded for others to use freely.

• Browsing — anyone can browse and download plugins from the gallery, no account needed.
• Uploading — you need a verified account. Upload a .jar or .zip containing your plugin (it must have a valid plugin.yml inside).
• Tagging — tag your upload with the platforms it supports (Paper, Spigot, etc.) so others can filter by platform.

Recommended workflow

1. Start narrow — generate one core feature first instead of a giant all-in-one plugin.
2. Test the basics — check commands, permissions, and startup logs on a local Paper test server.
3. Iterate in follow-ups — add one feature at a time so the AI has a clear next step.
4. Use the editor and log analyser — they are the fastest path when a plugin almost works but still needs cleanup.

Plans & limits

See the pricing page for full details and to upgrade.

Common issues

My plugin generated but doesn't work on the server

Check your server console for error messages when the plugin loads. Common causes:

• Wrong server version — make sure your prompt mentioned the Minecraft version (e.g. "Paper 1.21").
• Missing dependency — if the plugin requires another plugin (like Vault or LuckPerms), make sure it's installed first.
• Folia compatibility — if you're on Folia, regenerate with "make this Folia-compatible" in your prompt.

Generation is taking a long time

Complex plugins can take up to 90 seconds. Mod generation may also take 30–60 seconds as it uses the cloud AI tier. If the page shows a spinner, it’s still working — don’t reload. If it times out, try again with a slightly simpler prompt and build up from there.

I get a compilation error in the output

This happens occasionally with very complex or unusual requests. Try:

• Regenerating with the same prompt (the AI might get it right on the next attempt).
• Simplifying your prompt slightly, then adding complexity in a follow-up generation.
• Being more specific about the Minecraft version and API you're targeting.

The plugin has "StackNest" as the author — can I change it?

On the free plan, authors: [StackNest] is added to your plugin.yml automatically. You can edit the file manually to change it, or upgrade to Pro to remove this entirely.

I’ve hit my monthly limit

Free accounts get 3 plugin/mod generations per month. If you need more headroom, move to Starter, Pro, or Studio depending on how often you generate and whether you need premium tooling.

Service availability

StackNest uses cloud AI services to generate plugins. Occasionally these services may be slower or temporarily unavailable due to high demand.

Pro users get priority queue access, meaning their requests are processed before free-tier requests during high-traffic periods.