READ BEFORE USE:

For questions, you can always join my Discord server and talk to me there.

ServerPackCreator creates a server pack from any given Forge, Fabric, Quilt, LegacyFabric and NeoForge modpack.

Whenever you are working on an update to your modpack, you simply run ServerPackCreator and BAM! You've got yourself a server pack for your new modpack version.

ServerPackCreator is a passion project on which I am working in my spare time. It is also the main reason for why I got into programming in the first place. Patience with issues and support is appreciated!

I started getting into Java programming in February 2021, when I was working on an update for one of my Minecraft modpacks, Survive Create Prosper 4, and got tired and bored with manually creating a server pack everytime I wanted to update and test something, or just release a new server pack for the new modpack version.

The thought " There must be a way to automate this, or at least make it less tedious... " was the spark which sent me off into the world of programming. And here we are.

FOR THE LOVE OF GODS, TEST YOUR SERVER PACKS BEFORE YOU SHIP THEM!

ServerPackCreator is not a guarantee for working server packs. It helps you create them, but you must still test them!
You are still expected to be knowledgeable about your modpack, server packs in general, server administration and managing your Java installations. ServerPackCreator is not intended to take all the work off your shoulders!
When using alpha, beta or in-dev version of ServerPackCreator, it is advised to make a backup of your ServerPackCreator-directory in your home-directory.
Things will break with alpha releases, stuff may break when using beta releases.
If you distribute server packs generated with a pre-release (alpha, beta) of ServerPackCreator, you do so at your own risk.
I will not be held responsible for errors in your server pack caused by you using a pre-release.
I will not be held responsible for errors in your server pack in general. Test your server packs before you ship them!
TL;DR: Don't use test to ship to prod! Test before shipping!

Pre-Releases:

There are two kinds of pre-releases: Alphas and Betas

Alphas: Missing features, incomplete features, almost guaranteed to have bugs / errors
Betas: Feature complete, probably contains bugs / errors

Screenshots

CLI	GUI	WEB

Advantages/Disadvantages of CLI, GUI and WEB:

Each way of using ServerPackCreator has its advantages and disadvantages. Depending on your environment, it may be better to use one way over the other. This section highlights some of the advantages and disadvantages of each version to help you decide which way you are going to use. Note: All three ways are supported by the .jar-file. Which one is started depends on the CLI arguments used and your environment.

CLI:

Advantages	Disadvantages
No need for a graphical environment. Can be used on a server to generate a server pack for immediate use.	Gathering of information for a configuration file is tedious.
Step-by-Step generation of a configuration-file with the use of the `-cgen` argument. Generated config will be used immediately afterwards.	No convenience features file folder-browsing or jumping to the generated server pack after generation.
Load and edit an existing configuration. Editing is limited to base values of a given configuration. Not editable via CLI are script settings as well as any potentially installed plugin configuration.	Debugging in case of a broken/erroring configuration file can be time consuming. Careful reading of logs is required.
	Manual editing of the configuration-file in case you want to change it.
	Unable to edit start script placeholders and variables

GUI:

Advantages	Disadvantages
Browse the filesystem for folders and file required by the configuration.	Requires a graphical environment.
Setting up a configuration by browsing the filesystem and selecting your Minecraft and modloader versions from a list.
Browsing the generated server pack after generation has finished.
Loading and saving different configurations for quick generation of multiple server packs in short succession.
Edit the configuration in the GUI. No manual file-editing required.
Edit start script placeholders and values

WEB:

Advantages	Disadvantages
No software installation on clients required	Requires a server with sufficient space
Easy access via web-browser	Requires server-administration knowledge for setup and control
Quickly share mod- and server packs with friends / colleagues	No custom script templates
Multiple server packs for the same modpack	No custom server icons
Re-use configurations	No custom server-properties
	No custom server pack suffix
	No custom script variables or values
	No custom inclusions or exclusions

1. Small feature overview

Exclude clientside-only mods
- Automatically by letting ServerPackCreator scan the mods of your modpack for their sideness
- Manually by configuring a list mods which ServerPackCreator will filter out according to your input and the chosen filter.
Add files and directories in your server pack.
- Files and directories in your modpack
- Files and directories from your computer
Add a server icon
- Server icons are automatically scaled down, or up, to 64x64!
- Specify a custom one, or use a default provided by ServerPackCreator.
  - Change the default to your liking if you intend on using the same icon across multiple server packs!
Add a server.properties
- Ship your server pack with default settings!
- Specify a custom one, or use a default provided by ServerPackCreator.
  - Change the default to your liking if you intend on using the same icon across multiple server packs!
Many modloaders supported
- Forge
- Fabric
- LegacyFabric
- Quilt
- NeoForge
Use Minecraft snapshots and pre-releases
- Per default, only regular releases enabled
Let ServerPackCreator install the modloader-server for your server pack, for immediate testing and debugging after generation!
Let ServerPackCreator generate a ZIP-archive, for immediate upload to places like CurseForge (after you've tested your server pack, of course 😉)
Configure commandline arguments with which to start the Minecraft server
- Does your modpack require a lot of RAM? Well, tell ServerPackCreator to create the start scripts with -Xms8G -Xmx8G or similar values!
- Aikars flags are available, too. If you like 'em, use 'em.
Create your own start-script templates
- Add additional functionality to your servers start scripts
- Use placeholders in your templates, to be replaced with custom values
  - Example: placeholder SPC_FLYNN_LIVES_SPC in the templates can be replaced with a value configured on a per-server pack basis, i.e Now that's a big door
Plugins!
- ServerPackCreator allows you to use plugins to add new features in various places.
- Four plugins ship with every release, each marked _experimental in its filename — a grinder-backed clientside-mod picker, a server-pack test launcher, a self-extracting-archive writer, and a worked example to copy from. See 6. Experimental plugins.
- The source for the example is in this repository, at Example Plugin

2. Issues and help

Report a bug / ask for a feature / ask for an improvement / request a documentation improvement:
- https://github.com/Griefed/ServerPackCreator/issues/new/choose
There's a Wiki available which goes into further detail for many of ServerPackCreators available aspects:
- https://help.serverpackcreator.de/help-topic.html
The same as the Wiki, but as a file should you prefer it. 😊
- HELP.md

3. How To

The first time you start ServerPackCreator, you will be asked whether you want to see a small step-by-step guide. Said guide will show you the most important parts in configuring your server pack.

Should you at any point want to revisit said guide, simply hit About -> Step-By-Step Guide in the menu at the top.

kreezxil has made a video showing a step-by-step video-tutorial for ServerPackCreator:

4. Java

Required:

Using the JAR-file release requires Java 21.
Working internet connection recommended.

The installers ship their own Java installations.

ATTENTION: I can not and will not guarantee that ServerPackCreator will work flawlessly with any other Java version other than version 21. Things may break at random, at any place, if a different Java version is used. You are welcome to try and use any other version, but do not report issues back to me if you do encounter problems when running ServerPackCreator with a more recent Java version.

5 Running

If you've used the installer to acquire ServerPackCreator, use the shortcut created by the installer to run ServerPackCreator. The installers provide their own Java runtime, so you do not need to install Java separately.
If you've downloaded the JAR-file, and depending on how your Java installation is set up, you may be able to simply run the JAR via double-click or other methods, or you may need to run it from the commandline.

There are a couple of arguments which may or may not be helpful for you, depending on how you plan on using ServerPackCreator:

Argument	Description
`-help`	Print ServerPackCreators help to commandline.
`-update`	Check whether a newer version of ServerPackCreator is available.
`-gui`	Run ServerPackCreator with our GUI. If a graphical environment is supported, this is the default ServerPackCreator will enter, even when starting ServerPackCreator with no extra arguments at all.
`-cli`	Run ServerPackCreator in commandline-mode. If no graphical environment is supported, this is the default ServerPackCreator will enter, even when starting ServerPackCreator with no extra arguments at all.
`-web`	Run ServerPackCreator as a webservice.
`-cgen`	Run the generation of a basic server pack config from a given modpack.
`-config`	Generate a server pack from a specific server pack config, without a UI.
`--destination`	Generate the server pack from the config given to `-config` in a specific location. Requires `-config` or `-feelinglucky`.
`-feelinglucky`	Generate a server pack config from a passed modpack-directory and generate the server pack in one go. No warranty, no guarantees. Combine with `--destination` to choose where it lands.
`-withallinconfigdir`	Run a generation for every configuration present in ServerPackCreator's configs-directory.
`-scan`	Scan the mods in a directory for the sideness they declare in their metadata and print the result as JSON. Requires a directory, a modloader and a Minecraft version.
`-clientsidereport`	Assess whether the mod behind a CurseForge/Modrinth project-link is clientside-only and print a Markdown report. Requires the project-link.
`-verifyclientside`	Like `-clientsidereport`, but additionally boots a server with the mod force-included, to detect crashes. Requires the project-link.
`-clientsideapply`	Apply the suggested entries from a clientside-report JSON to the official fallback-list files. Requires the report-JSON path.
`--setup`	Set up and prepare the environment for subsequent runs of ServerPackCreator. Creates/copies all files needed for ServerPackCreator to function from inside its JAR. Optionally takes a `properties`-file whose values are loaded and then stored in the `serverpackcreator.properties` in ServerPackCreators home-directory.
`--home`	Override any and all configuration of ServerPackCreators home-directory. Usable on the initial run, or to move the home-directory later on.
`-lang`	Change the language ServerPackCreator uses.

The four clientside-verification arguments (-scan, -clientsidereport, -verifyclientside, -clientsideapply) are aimed at maintainers of the clientside-only mod list rather than at everyday use. -verifyclientside boots a real Minecraft server, so expect it to take a while.

5.1 Generating a server pack from a modpack, via CLI

Everything the GUI does to turn a modpack into a server pack is reachable from the commandline, and none of it needs a graphical environment. There are three routes, and which one you want depends on how much control you need:

Route	You get	Use it when
`-feelinglucky <modpack>`	Config and server pack, in one go, no questions asked.	The modpack carries a launcher-manifest and you want the pack now.
`-cgen <modpack>` then `-config <config>`	A config you can edit before anything gets generated.	You want to tweak exclusions, Java args, inclusions, the suffix, …
`-withallinconfigdir`	One server pack per config in the configs-directory.	You maintain several packs and want to rebuild them all.

All three are one-shot: ServerPackCreator starts, does the thing, prints the result and exits. The interactive shell (-cli, see 5.1.6) wraps the same verbs in a prompt with tab-completion, if you'd rather poke around.

5.1.1 The thirty-second version

# Generate a server pack from a modpack directory. That's it. That's the command.
java -jar ServerPackCreator.jar -feelinglucky "/home/griefed/CurseForge/Instances/Survive Create Prosper"

On success the last line printed is:

Successfully generated Server Pack: /home/griefed/serverpackcreator/server-packs/Survive Create Prosper

5.1.2 Where things end up

Unless you say otherwise, every path is resolved relative to ServerPackCreator's home-directory. The home-directory is picked on first run and remembered afterwards; --home (see 5.1.7) overrides it.

What	Where	Overridable with
The default config	`<home>/serverpackcreator.conf`	`-config <file>`
Configs written by `-cgen`/`-feelinglucky`	`<home>/configs/<modpack name>`	–
Generated server packs	`<home>/server-packs/`	`--destination <dir>`, or `de.griefed.serverpackcreator.configuration.directories.serverpacks`
Logs	`<home>/logs/`	–

Not sure where your home-directory is? Check the log for Home directory set to:, or run with --home to put it somewhere you chose.

5.1.3 `-feelinglucky` — modpack in, server pack out

-feelinglucky does the whole pipeline in one shot: derive a config from the modpack, save that config into <home>/configs/, check it, and — if the check passes — generate the server pack. No warranty, no guarantees; if the check fails it prints the problems and stops without generating.

# Simplest form. Server pack lands in <home>/server-packs/
java -jar ServerPackCreator.jar -feelinglucky "/home/griefed/modpacks/Survive Create Prosper"

# Choose where the server pack lands. Parent folders are created for you.
java -jar ServerPackCreator.jar -feelinglucky "/home/griefed/modpacks/SCP" --destination "/srv/minecraft/scp-server"

# Paths with spaces MUST be quoted. This is the single most common mistake.
java -jar ServerPackCreator.jar -feelinglucky "/home/griefed/Some Modpack With Spaces"

# Relative paths work and are resolved against your current working directory.
java -jar ServerPackCreator.jar -feelinglucky "./modpacks/SCP"

# A CurseForge (Overwolf) instance — point at the instance folder, the one holding minecraftinstance.json
java -jar ServerPackCreator.jar -feelinglucky "/home/griefed/CurseForge/Instances/All the Mods 9"

# Windows, PowerShell. Forward slashes are fine and spare you the escaping.
java -jar ServerPackCreator.jar -feelinglucky "C:/Users/Griefed/curseforge/minecraft/Instances/All the Mods 9"

# Windows, cmd.exe, with backslashes
java -jar ServerPackCreator.jar -feelinglucky "C:\Users\Griefed\curseforge\minecraft\Instances\All the Mods 9"

# Windows, generating straight onto a mapped network drive
java -jar ServerPackCreator.jar -feelinglucky "C:/modpacks/SCP" --destination "Z:/servers/scp"

# Combine with an explicit home-directory, so nothing touches your normal installation
java -jar ServerPackCreator.jar --home "/tmp/spc-scratch" -feelinglucky "/home/griefed/modpacks/SCP"

5.1.4 `-cgen` and `-config` — the two-step, when you want control

-feelinglucky gives you no chance to intervene. Splitting it in two does:

Step 1 — derive the config:

java -jar ServerPackCreator.jar -cgen "/home/griefed/modpacks/Survive Create Prosper"

-cgen inspects the modpack, writes a config to <home>/configs/<modpack name> and prints the resulting configuration to the console. It does not generate a server pack. The path it wrote to is in the log line Config for <modpack> available at <config>.

Step 2 — edit it, then generate from it:

# Open <home>/configs/Survive Create Prosper in your editor, change what you like, then:
java -jar ServerPackCreator.jar -config "/home/griefed/serverpackcreator/configs/Survive Create Prosper"

More -config examples:

# Config kept next to your modpacks rather than in the configs-directory
java -jar ServerPackCreator.jar -config "/home/griefed/modpacks/scp/serverpackcreator.conf"

# Generate into a specific location instead of <home>/server-packs/
java -jar ServerPackCreator.jar -config "/home/griefed/configs/scp.conf" --destination "/srv/minecraft/scp"

# Straight into a running server's directory, ready to be started
java -jar ServerPackCreator.jar -config "./scp.conf" --destination "/opt/minecraft/servers/scp"

# Windows
java -jar ServerPackCreator.jar -config "C:/Users/Griefed/serverpackcreator/configs/AllTheMods9" --destination "C:/servers/atm9"

# Same config, several destinations — handy when you run a test server and a live one
java -jar ServerPackCreator.jar -config "./scp.conf" --destination "/srv/mc/scp-test"
java -jar ServerPackCreator.jar -config "./scp.conf" --destination "/srv/mc/scp-live"

# Explicit home-directory, so the config-, server-pack- and log-directories all come from there
java -jar ServerPackCreator.jar --home "/srv/spc" -config "/srv/spc/configs/scp" --destination "/srv/mc/scp"

If you pass no -config, the interactive shell's run verb falls back to <home>/serverpackcreator.conf — see 5.1.6.

5.1.4.1 What a config looks like

A config derived by -cgen is a plain text file you can edit by hand. The interesting fields:

# Path to your modpack. Can be either relative or absolute.
modpackDir = "/home/griefed/modpacks/Survive Create Prosper"

# Mods to force-include even if they look clientside. Filenames, no versions.
whitelist = ["Ping-Wheel-"]

# Additional clientside-only mods to delete from the server pack. Filenames, no versions.
clientMods = ["AmbientSounds_","ClientTweaks-","PackMenu-","BetterAdvancements-"]

# What gets copied into the server pack. Source is required, the rest is optional.
[[inclusions]]
	source = "mods"
	destination = ""
	inclusionFilter = ""
	exclusionFilter = ""
[[inclusions]]
	source = "config"
[[inclusions]]
	source = "defaultconfigs"

minecraftVersion = "1.20.1"
modLoader = "Forge"          # Forge, NeoForge, Fabric, Quilt or LegacyFabric
modLoaderVersion = "47.2.20"

includeServerIcon = true
includeServerProperties = true
includeZipCreation = true

# Java arguments baked into the generated start-scripts. "empty" for none.
javaArgs = "-Xmx4G -Xms4G"

# Appended to the server pack's name, so several variants can coexist
serverPackSuffix = ""

# Replaced verbatim in the start-scripts
[scripts]
	SPC_JAVA_SPC = "java"

Editing that file and re-running -config is the whole "advanced" workflow. Common edits:

# 1. Derive
java -jar ServerPackCreator.jar -cgen "/home/griefed/modpacks/SCP"
# 2. Add a mod to clientMods, bump javaArgs to -Xmx8G, set serverPackSuffix = "-lite"
$EDITOR "/home/griefed/serverpackcreator/configs/SCP"
# 3. Generate
java -jar ServerPackCreator.jar -config "/home/griefed/serverpackcreator/configs/SCP"

5.1.4.2 Which modpacks get detected automatically

-cgen and -feelinglucky fill in minecraftVersion, modLoader, modLoaderVersion and the pack name by reading whichever launcher-manifest they find. The first match wins, in this order:

Manifest	Looked for in	Written by
`minecraftinstance.json`	the modpack directory	CurseForge (Overwolf) app
`manifest.json`	the modpack directory	a CurseForge modpack export
`instance.json`	the modpack directory	ATLauncher
`instance.json`	the parent directory	recent GDLauncher versions
`mmc-pack.json` (+ `instance.cfg`)	the parent directory	MultiMC / Prism Launcher

That "parent directory" row is the one that trips people up. For MultiMC, Prism and GDLauncher you point the argument at the .minecraft/minecraft folder inside the instance, not at the instance folder — the manifest then sits one level up, which is exactly where ServerPackCreator looks:

# Prism Launcher
java -jar ServerPackCreator.jar -cgen "/home/griefed/.local/share/PrismLauncher/instances/ATM9/minecraft"

# MultiMC
java -jar ServerPackCreator.jar -cgen "/home/griefed/MultiMC/instances/ATM9/.minecraft"

# GDLauncher
java -jar ServerPackCreator.jar -cgen "/home/griefed/gdlauncher_next/instances/ATM9/instance"

# ATLauncher — manifest sits in the instance directory itself
java -jar ServerPackCreator.jar -cgen "/home/griefed/ATLauncher/instances/ATM9"

If none of those manifests is present — a hand-assembled modpack, a .mrpack you unzipped yourself, a server directory you are re-packing — nothing breaks, but minecraftVersion, modLoader and modLoaderVersion come out empty. Fill them in by hand, then run -config:

java -jar ServerPackCreator.jar -cgen "/home/griefed/modpacks/hand-rolled"
$EDITOR "/home/griefed/serverpackcreator/configs/hand-rolled"   # set the three version fields
java -jar ServerPackCreator.jar -config "/home/griefed/serverpackcreator/configs/hand-rolled"

5.1.5 `-withallinconfigdir` — rebuild everything

Runs a check-and-generate for every file in <home>/configs/, one after another.

# Rebuild every server pack you have a config for
java -jar ServerPackCreator.jar -withallinconfigdir

# Same, against a dedicated home-directory — the pattern for a build server
java -jar ServerPackCreator.jar --home "/srv/spc" -withallinconfigdir

--destination is not honoured here; each pack lands in <home>/server-packs/. Give each config a distinct serverPackSuffix if you need to tell variants apart.

5.1.6 `-cli` — the interactive shell

-cli opens a prompt with tab-completion, autosuggestions and inline help. It is the same set of verbs, just interactive, and it is what you get automatically in a headless environment when no other argument was passed.

java -jar ServerPackCreator.jar -cli

ServerPackCreator> feelingLucky -m "/home/griefed/modpacks/SCP"
ServerPackCreator> feelingLucky -m "/home/griefed/modpacks/SCP" -d "/srv/mc/scp"
ServerPackCreator> cgen                                   # prompts for the modpack directory
ServerPackCreator> run                                    # generates from <home>/serverpackcreator.conf
ServerPackCreator> run withSpecificConfig -c "/home/griefed/configs/scp.conf"
ServerPackCreator> run withSpecificConfig -c "./scp.conf" -d "/srv/mc/scp"
ServerPackCreator> run withAllInConfigDir                 # same as -withallinconfigdir
ServerPackCreator> homeDir                                # change the home-directory
ServerPackCreator> lang                                   # list and pick a language
ServerPackCreator> setup                                  # re-run first-time setup
ServerPackCreator> update                                 # check for a newer release
ServerPackCreator> printHelp                              # the full help-text
ServerPackCreator> help run                               # help for one verb
ServerPackCreator> clear                                  # or 'cls'

Press Tab to complete, Alt+S to toggle the suggestion line, and Ctrl+D to leave.

5.1.7 Combining with the global arguments

--home and -lang are parsed before the mode is decided, so they combine with any of the above.

# Run against a throwaway home-directory. The directory must already exist.
java -jar ServerPackCreator.jar --home "/tmp/spc-test" -feelinglucky "/home/griefed/modpacks/SCP"

# Prepare a fresh home-directory before the first generation
mkdir -p /srv/spc
java -jar ServerPackCreator.jar --home "/srv/spc" --setup

# Seed that home-directory from a prepared properties-file, then generate
java -jar ServerPackCreator.jar --home "/srv/spc" --setup "/srv/spc-defaults.properties"
java -jar ServerPackCreator.jar --home "/srv/spc" -withallinconfigdir

# Pick a language for this run (and every run after it — the choice is stored)
java -jar ServerPackCreator.jar -lang en_GB -feelinglucky "/home/griefed/modpacks/SCP"
java -jar ServerPackCreator.jar -lang pt_BR -cgen "/home/griefed/modpacks/SCP"

# Print the help-text, which lists every argument with examples
java -jar ServerPackCreator.jar -help

# Check for a newer release. With an installer-based installation this also installs it.
java -jar ServerPackCreator.jar -update

--home is sticky. It is not a per-run override — it is written to your user preferences, and every subsequent run without --home uses it too. Pass it again to move back.

5.1.8 Automating it

Generation is one process invocation, so anything that can run a command can run this.

#!/usr/bin/env bash
# Rebuild one server pack and deploy it. Run from cron, a git hook, CI, whatever.
set -euo pipefail

SPC_JAR="/opt/serverpackcreator/ServerPackCreator.jar"
MODPACK="/srv/modpacks/SCP"
DESTINATION="/srv/minecraft/scp"

java -jar "$SPC_JAR" --home /srv/spc -feelinglucky "$MODPACK" --destination "$DESTINATION"

# Rebuild every modpack under a directory, one server pack each
for modpack in /srv/modpacks/*/; do
    java -jar /opt/serverpackcreator/ServerPackCreator.jar \
        -feelinglucky "$modpack" \
        --destination "/srv/server-packs/$(basename "$modpack")"
done

# Nightly rebuild of everything you have a config for, at 04:00
0 4 * * * java -jar /opt/serverpackcreator/ServerPackCreator.jar --home /srv/spc -withallinconfigdir >> /var/log/spc.log 2>&1

# Windows, PowerShell
& java -jar "C:\Tools\ServerPackCreator.jar" -feelinglucky "C:/modpacks/SCP" --destination "C:/servers/scp"

# Containerised, no GUI involved. Note this uses a plain JRE image and the JAR — NOT the
# griefed/serverpackcreator image, which is hard-wired to start the webservice and does not
# forward arguments to the application.
docker run --rm -v "$PWD:/work" -w /work eclipse-temurin:21-jre \
  java -jar /work/ServerPackCreator.jar \
    --home /work/spc-home \
    -feelinglucky "/work/modpacks/SCP" \
    --destination "/work/server-packs/SCP"

The exit code is meaningful. A one-shot run exits 0 only when it produced what you asked for, and 1 when it did not — a missing argument, a path that does not exist, a configuration check that failed, or a generation that errored. So && does what you would expect:

java -jar "$SPC_JAR" -config "./scp.conf" && deploy_the_server_pack

if ! java -jar "$SPC_JAR" -withallinconfigdir; then
    echo "At least one server pack failed to generate, see output above." >&2
    exit 1
fi

-withallinconfigdir exits 1 if any configuration failed, and 0 when the configs-directory is simply empty — nothing to do is not a failure. The long-running modes (-gui, -web, -cli) do not exit on their own, so there is nothing to check.

5.1.9 Argument precedence, and other things that will bite you

The arguments are not independent flags — the first one that matches decides the whole run, and everything else on the commandline is ignored. The order checked is:

-help → -update → -withallinconfigdir → -scan → -clientsidereport → -verifyclientside → -clientsideapply → -cgen → -config → -feelinglucky → -cli → -web → -gui → --setup

So -cgen "/modpack" -feelinglucky "/modpack" writes a config and does not generate a server pack, because -cgen is checked first. Pick one.

Everything else worth knowing:

The path is a separate argument, not =. --home "/srv/spc" works; --home=/srv/spc does not.
Always pass the path. -cgen, -config, -feelinglucky, --setup, --destination and --home all read the next argument. Leaving it off — java -jar ServerPackCreator.jar -config — is reported as a missing value, nothing is generated, and the run exits 1.
-config wants a file that exists, -cgen/-feelinglucky want a directory that exists. A typo'd path is reported, naming the path it could not find; it is never created for you.
--home needs the directory to exist already. If it does not, the run says so and keeps the previously configured home-directory.
--destination only does something next to -config or -feelinglucky. On its own, or with -cgen or -withallinconfigdir, it is ignored.
Quote paths with spaces. On every platform, in every shell.
Windows paths take / as well as \. Forward slashes save you a round of escaping.
A first run has setup to do. Expect the very first invocation on a fresh home-directory to take longer and to reach out to the network for version manifests.

5.2 Running ServerPackCreator as a webservice

DISCLAIMER

There is no publicly available instance of ServerPackCreators webservice due to security concerns with the ability to upload zip-archives. If you want to make use of the webservice, you will have to host your own instance. As such, you are advised to not make your instance of the webservice of ServerPackCreator publicly accessible.

ZIP-archives uploaded by anonymous people may contain illegal or otherwise dangerous data, which could corrupt your system or get you into legal trouble.

If you want to open your webservice-instance to the public, make sure to properly protect it by putting it behind required authorization.

5.2.1 JAR

Download the JAR-file from the latest release
Run it once, using the -web argument. It will fail to reach a database — you have not configured one yet — but this first run is what creates the home-directory you need in the next step. This is expected, don't worry.
Browser to the now generated ServerPackCreator home-directory
1. Unsure where said home-directory is? Check the logs for Home directory set to:!
Install / setup / provide a MongoDB-database for ServerPackCreator. See MongoDB Installation Tutorial
Set the database-properties in the serverpackcreator.properties according to your database
1. spring.mongodb.uri=
  - Named spring.data.mongodb.uri before ServerPackCreator moved to Spring Boot 4, which retired that key. An existing file using the old name is still read and upgraded automatically.
  - Example: mongodb\://<USER>:<PASSWORD>@localhost\:27017/serverpackcreatordb
  - If the username or password includes the following characters $ : / ? # [ ] @, those characters must be converted using percent encoding (https://datatracker.ietf.org/doc/html/rfc3986#section-2.1) : $ : / ? # [ ] @
Run ServerPackCreator, using the -web-argument, again
Browse to http://localhost:8080

5.2.1.1 Tweaking the webservice

You may edit the following properties inside the serverpackcreator.properties if you wish to change some parts of the webservice-behaviour:

Property	Description
`de.griefed.serverpackcreator.spring.schedules.database.cleanup`	Time when the database-cleanup operations run.
`de.griefed.serverpackcreator.spring.schedules.files.cleanup`	Time when the filesystem-cleanup operations run.
`de.griefed.serverpackcreator.spring.schedules.versions.refresh`	Time when the version-refresh operation runs.
`spring.servlet.multipart.max-file-size`	In combination with the property below, this sets the maximum upload size of modpacks.
`spring.servlet.multipart.max-request-size`	See above.
`de.griefed.serverpackcreator.configuration.directories.mustinclude`	Directories which must be included in a server pack, if they are present in a modpack.
`de.griefed.serverpackcreator.configuration.directories.shouldexclude`	Directories which should be excluded from a server pack.
`de.griefed.serverpackcreator.configuration.fallback.updateurl`	URL to a `.properties`-file which contains definitions for clientside-only mods.
`de.griefed.serverpackcreator.serverpack.autodiscovery.enabled`	Whether ServerPackCreator should try to automatically excluded clientside-mods, in addition to the list of excluded clientside-mods.
`de.griefed.serverpackcreator.serverpack.autodiscovery.filter`	Filter method used to exclude mods from the clientside-only list. Possible values are `START`, `END`, `CONTAIN`, `REGEX`, `EITHER`
`de.griefed.serverpackcreator.serverpack.zip.exclude`	Files or directories which should be excluded from a server pack archive.
`de.griefed.serverpackcreator.serverpack.zip.exclude.enabled`	Whether files should be excluded from a server pack archive.
`server.port`	The port at which the webservice will be available at. Default is `8080`.

5.2.2 Docker (recommended)

The recommended, and easiest, way to deploy ServerPackCreator as a webservice is via docker and docker-compose.

Available images can be viewed at https://hub.docker.com/r/griefed/serverpackcreator/tags

About Tags: The example below makes use of the latest-tag. However, using said tag is not recommended, as there may be breaking changes between versions. When setting up ServerPackCreator as a webservice for production, make sure to not use latest and instead use the tag corresponding to the, at this point, latest available release version available.

You must replace <DB_ROOT_USERNAME> and <DB_ROOT_PASSWORD> accordingly. Do note the - ./init-mongo.js:/docker-entrypoint-initdb.d/init.js:ro in the serverpackcreatorb-service. An example for this file is available at docker/init-mongo.js. This init-script initializes the MongoDB with the required user, database and collection.

services:
  serverpackcreatordb:
    image: mongodb/mongodb-community-server:8.0.5-ubuntu2204
    container_name: serverpackcreatordb
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: <DB_ROOT_USERNAME>
      MONGO_INITDB_ROOT_PASSWORD: <DB_ROOT_PASSWORD>
      MONGO_INITDB_DATABASE: serverpackcreatordb
    volumes:
      - ./init-mongo.js:/docker-entrypoint-initdb.d/init.js:ro
      - spcdb-data:/data/db
      - spcdb-conf:/data/configdb

  serverpackcreator:
    container_name: serverpackcreator
    image: griefed/serverpackcreator:latest # For a list of available tags, see https://hub.docker.com/r/griefed/serverpackcreator/tags
    restart: unless-stopped
    depends_on:
      - serverpackcreatordb
    environment:
      - TZ=Europe/Berlin # Your timezone
      - PUID=1000 # Your user ID
      - PGID=1000 # Your group ID
      - SPC_DATABASE_PASSWORD=<DB_ROOT_PASSWORD> # $ : / ? # [ ] @ those characters must be converted using https://datatracker.ietf.org/doc/html/rfc3986#section-2.1
      - SPC_DATABASE_USERNAME=<DB_ROOT_USERNAME> # $ : / ? # [ ] @ those characters must be converted using https://datatracker.ietf.org/doc/html/rfc3986#section-2.1
      - SPC_DATABASE_HOST=serverpackcreatordb  # Do not change this unless you absolutely know what you are doing.
      - SPC_DATABASE_PORT=27017  # Do not change this unless you absolutely know what you are doing.
      - SPC_DATABASE_DB=serverpackcreatordb # Do not change this unless you absolutely know what you are doing.
    ports:
      - "8080:8080" # Port at which SPC will be available at on your host : Port of the webservice inside the container. Only change the left value, it at all.
    volumes:
      - ./modpacks:/app/serverpackcreator/modpacks # Path at which modpacks from the container will be stored at on your host : Path to the modpacks in the container. Only change the left value, if at all.
      - ./server-packs:/app/serverpackcreator/server-packs # Path at which server packs from the container will be stored at on your host : Path to the server packs in the container. Only change the left value, if at all.
      - ./logs:/app/serverpackcreator/logs # Path at which logs from the container will be stored at on your host : Path to the logs in the container. Only change the left value, if at all.

volumes:
  spcdb-data:
  spcdb-conf:

5.2.2.1 Tweaking the docker deployment

You may edit the following container-properties if you wish to change some parts of the webservice-behaviour:

Property	Description
`SPC_SCHEDULE_DATABASE_CLEANUP`	Time when the database-cleanup operations run.
`SPC_SCHEDULE_FILES_CLEANUP`	Time when the filesystem-cleanup operations run.
`SPC_SCHEDULE_VERSIONS_REFRESH`	Time when the version-refresh operation runs.
`SPC_MAX_UPLOAD_SIZE`	This sets the maximum upload size of modpacks.
`SPC_CONFIGURATION_DIRECTORIES_MUSTINCLUDE`	Directories which must be included in a server pack, if they are present in a modpack.
`SPC_CONFIGURATION_DIRECTORIES_SHOULDEXCLUDE`	Directories which should be excluded from a server pack.
`SPC_CONFIGURATION_FALLBACK_UPDATEURL`	URL to a `.properties`-file which contains definitions for clientside-only mods.
`SPC_SERVERPACK_AUTODISCOVERY_ENABLED`	Whether ServerPackCreator should try to automatically excluded clientside-mods, in addition to the list of excluded clientside-mods.
`SPC_SERVERPACK_AUTODISCOVERY_FILTER`	Filter method used to exclude mods from the clientside-only list. Possible values are `START`, `END`, `CONTAIN`, `REGEX`, `EITHER`
`SPC_SERVERPACK_ZIP_EXCLUDE`	Files or directories which should be excluded from a server pack archive.
`SPC_SERVERPACK_ZIP_EXCLUDE_ENABLED`	Whether files should be excluded from a server pack archive.
`SPC_CONFIGURATION_AIKAR`	JVM flags offered as "Aikar's flags". Mind the escaping — see the example compose-file.
`SPC_LOG_LEVEL`	Log level of the containerised ServerPackCreator. `INFO` by default, `DEBUG` to troubleshoot.

6. Experimental plugins

Four plugins ship with every release, as serverpackcreator-plugin-<name>-<version>_experimental.jar. The _experimental is in the filename on purpose: these are newer and far less travelled than the application they plug into, and you should be able to tell that from the download alone.

What that means: they are not guaranteed to work. Settings keys may move between releases — a plugin's config file is only written if it does not already exist, so a renamed key orphans your settings rather than migrating them — and a bug in one does not hold up a release. They are opt-in; ServerPackCreator installs none of them for you and behaves exactly as documented everywhere else in this README without them.

They can leave experimental one day, and testing is what gets them there. So far they have been exercised by their author, on their author's machines, against their author's modpacks. If you run one, you are testing it — tell me what broke or confused you, see 2. Issues and help.

Installing one: download the *_experimental.jar from a release, drop it into the plugins-directory of your ServerPackCreator home-directory, restart. Settings land in plugins/config/<plugin-id>.toml. To switch one off without deleting it, add its ID on its own line in plugins/disabled.txt — see HELP.md.

Plugin	Adds	Settings	Works without a GUI
Grinder	A Grinder tab, and clientside-mod exclusions at generation time	yes	yes — exclusions apply to CLI and web runs too
Server Test	A Server Test tab	yes	no — the tab is the feature
Self-Extract	Two extra artifacts beside every generated server pack	no	yes
Example	A Tetris tab, a config panel, and one of every other extension point	yes	partly

6.1 Grinder

The grinder boot-verifies mods at scale and publishes which ones are genuinely clientside-only. This plugin puts that feed in front of you and lets you pick: tick a row and the entry joins the clientside-mod exclusion list of every server pack you generate — GUI, CLI and webservice alike, no restart. Each row shows the verdict and the two readings behind it, what the platform declared and what the jar itself says, which is what makes a disagreement worth checking by hand. Confirmed findings and everything else are kept in separate lists, because excluding a mod that was never proven clientside-only breaks client/server compatibility. A dashboard shows what the daemon is doing right now.

Rough edges: it needs a reachable grinder, or it sits idle and does nothing. It is a read-only view — a verdict you disagree with is yours to un-tick, not to correct. Suggested entries match by prefix, so an unusually-named jar can slip past the pattern proposed for it.

6.2 Server Test

Lists every pack in your server-packs directory and launches the selected one through the pack's own start script — not a hand-built java command, so the scripts get tested too. The server's console appears in the window with a line into its standard input: type I agree to get past Mojang's EULA, stop later to shut it down. Each server gets its own bind-tested port, so two can run at once, and server.properties is borrowed for the duration and restored byte-for-byte afterwards.

Rough edges: it deliberately will not accept the EULA for you. A pack missing its chosen start script is refused by name, never quietly substituted. A script this host has no interpreter for is still offered — it fails with the interpreter's own error, which beats a disabled control explaining nothing.

6.3 Self-Extract

The only one with no interface at all. It wraps every generated server pack in two self-extracting artifacts, written beside it:

server-packs/
├── Survive_Create_Prosper_4_custom/
├── Survive_Create_Prosper_4_custom.bsx    <- self-extracting, Linux / macOS
├── Survive_Create_Prosper_4_custom.cmd    <- self-extracting, Windows 10 1803+
└── Survive_Create_Prosper_4_custom_server_pack.zip

Each carries the whole pack inside it — run it and it unpacks itself and starts the server, no unzip step and nothing else to download. It is HELP.md's Fun Stuff → Self-extracting, self-contained script, executed automatically. There is nothing to configure on purpose: installing the plugin is the setting.

Rough edges: each artifact is as big as the pack, so a generation that produced a 6 GB server pack now writes about 18 GB. The Windows .cmd is the less travelled of the two.

6.4 Example

Documentation-by-example: one of every extension point ServerPackCreator offers, kept in step with the current plugin API on purpose. If you want to write your own plugin, copy from this one — the source is at Example Plugin, and HELP.md's Plugins chapter covers the plugin API itself.

The screenshot shows two of its extension points at once: a tab — a playable Tetris, because a tab has to display something — and a global config panel whose values are saved and handed back on the next start. It also contributes a configuration check and pre-, post- and generic generation listeners, each small enough to read in one sitting.

7. API

ServerPackCreator's API is available on maven for use in your own projects: https://central.sonatype.com/artifact/de.griefed.serverpackcreator/serverpackcreator-api

Note: The API does not include the REST-API of the webservice in the app. It is explicitly not part of the ServerPackCreator API.

Implementation

Replace $VERSION with the version you want to use.

Maven

<dependency>
    <groupId>de.griefed.serverpackcreator</groupId>
    <artifactId>serverpackcreator-api</artifactId>
    <version>$VERSION</version>
</dependency>

Gradle

implementation 'de.griefed.serverpackcreator:serverpackcreator-api:$VERSION'

Gradle Kotlin

implementation("de.griefed.serverpackcreator:serverpackcreator-api:$VERSION")

Example

Initialize the API with your properties file, containing some basic settings for the API to use. /path/to/file.properties represents the path to your properties-file.

Make sure to select a directory which doesn't contain any vital data for the API, as the API will setup and create any and all required files in said directory. Best to give it its own directory all to itself.

For information about possible settings, see https://help.serverpackcreator.de/settings-and-configs.html#serverpackcreator-properties

val spcAPI = ApiWrapper.api(File("/path/to/file.properties"))

After initializing the API you can now access the ConfigurationHandler as well as the ServerPackHandler, among other things. Here's a very basic example:

val packConfig = PackConfig()
val configCheck = spcAPI.configurationHandler.checkConfiguration(File("/path/to/serverpack-config.conf"), packConfig)

if (configCheck.allChecksPassed) {
    val serverPackGeneration = spcAPI.serverPackHandler.run(packConfig)

    if (serverPackGeneration.success) {
        println("Path to your server pack: ${serverPackGeneration.serverPack.absolutePath}")

        if (serverPackGeneration.serverPackZip.isPresent) {
            println("Path to your server pack ZIP: ${serverPackGeneration.serverPackZip.get().absolutePath}")
        }
        
    } else {
        
        println("Encountered the following errors during generation:")
        for (error in serverPackGeneration.errors) {
            println(error)
        }
        
    }
    
} else {
    
    println("There are errors in your server pack config:")
    for (error in configCheck.encounteredErrors) {
        println(error)
    }
    
}

8. Awesomesauce!

None of this would have been possible without the excellent IDEs by JetBrains. They have kindly provided this open source project with an All Products Pack license. Additionally, ej-Technologies has provided an open-source license for JProfiler and install4j for ServerPackCreator, which allows me to resolve performance bottlenecks, pin down memory leaks and understand threading issues, as well as generated fancy high-end installers. Huge shoutout and thank you!