Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is packwiz?
packwiz is a command-line tool for building and maintaining Minecraft modpacks. Rather than storing mod JAR files in the pack itself, it records each mod as a small TOML metadata file (for example pack.toml, index.toml, and per-mod mod.pw.toml). Those text files are easy to diff, review, and commit, so a modpack behaves like normal source code in Git instead of a folder of opaque binaries.
From that metadata, packwiz can export the pack to CurseForge or Modrinth formats, or drive packwiz-installer for an auto-updating instance on launchers such as MultiMC and ATLauncher. It also supports optional mods, server-only and client-only mod handling, and fetching or updating many mods at once from CurseForge and Modrinth. A built-in local HTTP server (packwiz serve) lets you test distribution before publishing.
Who it suits
- Server operators distributing a private modpack who want players to receive updates automatically.
- Pack authors who publish to CurseForge or Modrinth and want one source of truth.
- Teams comfortable with Git and a terminal, since version history and collaboration come for free.
Where it fits less well
- Managing the mod JARs you have already downloaded — a launcher or another CLI is the better tool for that.
- Anyone who wants a graphical interface; packwiz is command-line first.
A practical next step: if you already have a CurseForge pack, try importing it to see how packwiz represents your mods as metadata, then commit the result to a Git repository and test it with packwiz serve before distributing it to players.
How do I create a modpack with packwiz?
packwiz builds a modpack as a folder of TOML metadata files rather than a folder of JARs. You work from the command line in a project directory, and the tool records each mod's source, version and side (client, server or both) in text files you can commit to Git.
The basic workflow
- Install packwiz, then run
packwiz initinside an empty folder. This asks for the pack name, author, version and Minecraft version, and writes apack.toml. - Set the loader with
packwiz migrate loaderandpackwiz migrate minecraftif you need to change Fabric, Forge, NeoForge or the game version after init. - Add mods using
packwiz curseforge addorpackwiz modrinth add, which resolve the mod by name or ID and write amod.pw.tomlfile with a download URL and hash.packwiz url addhandles mods hosted elsewhere. - Review and adjust with
packwiz list, then usepackwiz pinandpackwiz unpinto lock or free a mod's version, andpackwiz removeto drop one. - Refresh metadata with
packwiz refresh, which rebuildsindex.tomlso the pack reflects your current mod set. - Test locally with
packwiz serve, which runs a small HTTP server so an instance can pull the pack from your machine. - Distribute by pushing the folder to a Git host, then either exporting with
packwiz curseforge exportorpackwiz modrinth export, or pointing players at packwiz-installer for an auto-updating MultiMC or ATLauncher instance.
Choosing how to ship it
| Goal | Approach | Trade-off |
|---|---|---|
| Private server pack | Git repo plus packwiz-installer | Players need the installer set up once; updates are then automatic |
| Public CurseForge or Modrinth listing | export command |
You upload the resulting archive yourself; the platform handles discovery |
| Quick local test | packwiz serve |
Temporary, not a distribution method |
Practical notes
Keep the pack folder in Git from the first commit. Because each mod is a small text file, a version bump shows up as a readable diff, and you can review or revert changes the same way you would code. For a server, mark client-only mods appropriately so they are not downloaded on the server side; packwiz's side handling exists for exactly this case.
If you would rather click through a GUI or manage downloaded JARs directly, packwiz is the wrong tool — its own documentation points those users toward launcher-based managers. Its strength is repeatable, reviewable, scriptable pack definitions.
Next step: run packwiz init in a fresh folder, add one mod from Modrinth, run packwiz serve, and confirm the pack loads before adding the rest. You can find the tool and its full command reference at packwiz.
How do I distribute a packwiz modpack to players or a server?
Distribute a packwiz modpack in one of two main ways: export it as a standard CurseForge or Modrinth pack, or host the pack metadata so players and servers can install and update it directly with packwiz-installer.
Exporting to a modpack platform
Use the CurseForge or Modrinth export commands to produce a pack that players can import through those platforms' launchers. This is the simplest route for public distribution, since players already have the launcher and account setup. The trade-off is that the pack is a snapshot: every change means a new export and a new download.
Auto-updating with packwiz-installer
This is the more distinctive option. You host the pack's metadata files on an HTTP server (or a Git host that serves raw files), and players point packwiz-installer at the URL. The installer is Java-based and works with MultiMC and ATLauncher. It supports optional mods and fast automatic updates, which is why it suits servers in particular: a server can run the installer on startup so it always matches the client pack.
Choosing between them
| Situation | Better fit |
|---|---|
| Public pack on CurseForge/Modrinth | Platform export |
| Private server pack, frequent changes | packwiz-installer over HTTP |
| Players who want a GUI launcher | Platform export |
| You want one source of truth for clients and server | packwiz-installer |
If you want to test distribution before committing, packwiz includes a built-in local server, so you can verify that the installer resolves the pack correctly on your own machine first. Then move the metadata to a real host and hand the URL to players or put it in your server startup script.
For reference on the commands themselves, see packwiz.
How does packwiz work with Git for version control?
packwiz stores your modpack as TOML metadata files rather than as a folder of JAR files, which is what makes Git version control practical. The pack definition lives in files like pack.toml, index.toml, and per-mod mod.pw.toml files, so what you commit to Git is a small set of text files describing which mods and versions belong in the pack — not the mod binaries themselves. A team can branch, diff, review and merge changes to the pack the same way they would any other source code.
What this means in practice
- Small, readable diffs. Adding or removing a mod changes a TOML entry, so a pull request shows exactly which mod and version changed.
- No binary bloat. Because the JARs aren't tracked, your repository stays lightweight and clones quickly.
- Shared server and client packs. Multiple people can work on the same pack definition, and server operators can pull the updated metadata and let the installer fetch the actual files.
- Reproducible versions. Pinning a mod locks its version in the metadata, so a checkout at a given commit describes a known set of mods.
A realistic workflow
A server admin keeps the pack in a private Git repository. When a mod needs updating, they run the packwiz update command, review the changed mod.pw.toml files, commit, and push. Players running a packwiz-installer-based instance pull the new metadata and the installer downloads only what changed — which is why the fast automatic updates matter for servers that can't ask everyone to re-download a full pack.
Where it fits and where it doesn't
This approach suits people comfortable with a command line and Git — especially those distributing private server packs or publishing to CurseForge and Modrinth. It is a poor fit if you mainly want to manage already-downloaded JAR files by hand, or if you want a graphical interface; packwiz is explicitly a CLI tool, and GUI options are third-party efforts rather than part of the project.
If you're deciding whether to adopt it, start by initialising a pack and committing the generated TOML files to a test repository, then add one mod and inspect the diff. If that diff is the kind of change you'd want to review in a pull request, the Git-based model will work well for your team.
How do I export a packwiz modpack to CurseForge or Modrinth?
Use the packwiz curseforge export command for a CurseForge pack and packwiz modrinth export for a Modrinth pack. Both are run from inside your packwiz pack directory, and each writes out a standard modpack archive you can upload to the respective platform. The exported format uses the platform's own metadata (CurseForge manifest or Modrinth index), so the launcher on the other end resolves and downloads the mods itself rather than shipping the JARs.
Practical workflow
- Finish and refresh your pack so all metadata is current (
packwiz refresh). - Run the export command for your target platform.
- Take the resulting archive and upload it through that platform's project upload flow.
- Test by importing the archive into a clean launcher profile before publishing.
A concrete scenario: you maintain a private server pack, keep the packwiz files in git, and want a public CurseForge release. You export to CurseForge, upload the archive, and continue developing from the same git-tracked metadata — the export is a build artifact, not your source of truth.
Choosing between the two
| Consideration | CurseForge export | Modrinth export |
|---|---|---|
| Best for | Reach and existing CurseForge audience | Modrinth-native projects and users |
| Mod sources | Resolves CurseForge-hosted mods | Resolves Modrinth-hosted mods |
| Mods not on that platform | Can't be resolved automatically | Can't be resolved automatically |
| Typical use | Public releases, server packs | Public releases on Modrinth |
The main trade-off is mod availability: a pack with mods hosted only on one platform won't export cleanly to the other, since the exported file references mods by platform ID. If you need both, expect to handle the gaps manually.
Related commands worth knowing
packwiz curseforge import— pull in an existing CurseForge pack as a starting point.packwiz modrinth add— add a Modrinth mod to your pack metadata.packwiz curseforge add— add a CurseForge mod.packwiz serve— run a local HTTP server to test distribution before exporting.
For the exact flags and output filenames, check the command reference at packwiz and the platform docs at CurseForge and Modrinth.
How do I set up packwiz-installer for automatic updates in MultiMC or ATLauncher?
packwiz-installer is a Java-based pack installer/updater that works with MultiMC and ATLauncher, and it's the piece that turns a packwiz pack into an auto-updating instance: instead of downloading mod JARs yourself, the instance re-checks the pack metadata and pulls changes on each launch. The pack itself is defined by TOML metadata files rather than the JAR files, which is what makes that update flow possible — see packwiz for the pack format and the packwiz-installer documentation.
The general shape of the setup is the same on both launchers:
- Build and publish the pack metadata somewhere reachable over HTTP — a web server, a static host, or the built-in local server (
packwiz serve) while you test. - In MultiMC or ATLauncher, create a new instance and add a pre-launch command that runs the installer with the Java runtime and points at your pack's
pack.tomlURL. - Launch the instance. The installer reads the metadata, downloads or updates only what changed, and then the game starts.
A typical pre-launch command follows this pattern (the URL is the part you supply):
"$INST_JAVA" -jar packwiz-installer-bootstrap.jar https://example.com/pack.toml
MultiMC exposes the Java path as $INST_JAVA, so using it avoids hardcoding a Java location. ATLauncher has its own variable conventions for the same purpose, so check its instance command documentation rather than copying a MultiMC command verbatim.
Practical decisions
- Bootstrap vs. plain installer: the bootstrap variant downloads and updates the installer itself, so you don't have to re-place a new JAR in the instance whenever the installer updates. For a server or a shared instance, that's usually the lower-maintenance choice.
- Server use: the same installer runs on a server, which is the main reason packwiz suits private server packs — players and the server stay on identical mod versions without manual file shuffling.
- Optional mods: the installer supports optional mods, so you can let users opt in or out of certain content without maintaining separate packs.
- Testing: run
packwiz servelocally and point the installer at your local URL first. Debugging a bad metadata path is much faster than debugging it through a live launch. - Version control: keep the pack in Git. Because the pack is metadata, a commit is a meaningful, reviewable change, and the instance picks up whatever is published at the URL you pointed it at.
What this approach is not for
If your main goal is managing a pile of already-downloaded JAR files, or you want a graphical interface for building packs, this workflow will feel indirect — packwiz's own guidance points those users toward launcher-managed mod folders or GUI tools instead. The trade-off is deliberate: you give up point-and-click file handling in exchange for reproducible, git-tracked packs that update themselves.
If you're starting from scratch, run packwiz init to create the pack, add mods with packwiz curseforge add or packwiz modrinth add, then set up the pre-launch command once the metadata is hosted.
User reviews (0)