Introduction

mc is a command line tool to manage and run Minecraft instances.

An instance is described by a single manifest file, mc.toml. From that one file, mc run takes care of everything needed to bring the instance up:

  • installs a Java runtime
  • installs Minecraft for the configured version
  • installs a mod loader, when one is configured
  • downloads mods and resolves their dependencies into a lockfile
  • writes the configuration files Minecraft expects
  • launches the instance and supervises it until it stops
  • takes scheduled world backups to local storage or S3

If you have used a package manager, the workflow will feel familiar: a declarative manifest, a generated lockfile, and a small set of commands that operate on them.

$ mc init myserver --eula
$ cd myserver
$ mc run

Sections

Getting Started

Install mc and start your first instance.

Guides

Task-oriented guides: managing mods, configuring backups, and deploying an instance as a systemd service.

Reference

The mc.toml manifest format, the environment variables mc reads, and the on-disk layout of an instance.

Commands

Detailed documentation for every mc command.

Getting Started

To get started with mc:

Installation

Pre-built binaries

Every release publishes pre-built binaries on the GitHub releases page for:

  • Linux (x86_64, aarch64)
  • macOS (x86_64, aarch64)
  • Windows (x86_64)

Download the archive for your platform, extract it, and place the mc binary somewhere on your PATH:

$ tar -xzf mc-linux-x86_64.tar.gz
$ install -m 755 mc /usr/local/bin/mc
$ mc --version

Building from source

mc is written in Rust and builds with a recent stable toolchain:

$ git clone https://github.com/afrigon/mc
$ cd mc
$ cargo build --release

The binary is produced at target/release/mc.

First Steps with mc

This walkthrough creates a new instance and runs it.

Create an instance

Each instance lives in its own directory, with a mc.toml manifest at its root. mc init creates both:

$ mc init myserver
$ cd myserver

The generated manifest looks like this:

name = "myserver"
description = "A Minecraft Server"

[minecraft]
version = "..."

[server]
gamemode = "survival"
difficulty = "normal"
hardcore = false
# Setting this to true indicates YOU have read and agree to the Minecraft EULA (https://aka.ms/MinecraftEULA).
# This agreement is between you and Mojang/Microsoft.
eula = false

[backups]
enabled = true
frequency = "0 0 * * * *"

[mods]
lithium = "..."

By default mc init uses the optimized preset, which adds a mod loader and a small set of performance mods. Pass --preset vanilla for an unmodded instance. The manifest is yours to edit; every key is documented in The Manifest Format.

Agree to the EULA

The instance will not start until you have agreed to the Minecraft EULA. Once you have read it, set:

[server]
eula = true

You can also pass --eula to mc init to do this at creation time.

Run it

$ mc run

On first run, mc downloads a Java runtime, the Minecraft binary, the mod loader, and any configured mods, then starts the instance. Subsequent runs reuse what is already installed and start immediately.

The console is attached to your terminal. Stop the instance with Ctrl-C: mc asks it to save the world and waits for it to exit cleanly.

Note that the allow list is enabled by default, so players must be on it before they can join. To open the instance to everyone instead, set white-list = false under [server.properties] in the manifest.

Next steps

Guides

Task-oriented guides for operating an instance:

Managing Mods

Mods are declared in the [mods] table of mc.toml and installed when the instance starts. Each entry maps a mod's identifier on the mod registry to the version to install:

[minecraft]
version = "..."
loader = "fabric"

[mods]
lithium = "..."

A mod loader must be configured under [minecraft] for mods to be installed; without one, the [mods] table is ignored. See The Manifest Format for every supported form of a mod entry, including mods fetched from a direct URL.

Adding and removing mods

mc add and mc remove edit the [mods] table for you. mc add looks the mod up on the registry and pins the latest version compatible with the configured Minecraft version and loader:

$ mc add sodium lithium
$ mc remove sodium

Updating mods

mc update re-pins mods to the latest compatible version — every mod in the manifest, or only the ones you name:

$ mc update
$ mc update lithium

Mods fetched from a direct URL have no version to compare and are skipped.

How mods are installed

Changes to [mods] take effect the next time the instance starts. On startup, mc resolves each entry — including its required dependencies — and records the result in the mc.lock lockfile. It then downloads any mod that is missing and deletes any mod that is no longer in the lockfile.

Two consequences of this are worth knowing:

  • You do not need to declare a mod's dependencies; they are resolved and installed automatically.
  • The instance's mods directory is fully managed by mc. A jar placed there by hand is removed on the next start. To install a mod that is not on the registry, declare it in the manifest with a url entry instead.

Backups

mc can archive the instance's world on a schedule while it runs, and restore any archive later. Backups are coordinated with the running instance so the world is flushed to disk before it is captured — archives are always consistent, even under load.

Scheduled backups

[backups]
enabled = true
frequency = "0 0 * * * *"

With enabled = true, backups fire on the frequency schedule while the instance runs. frequency is a cron expression with six fields — seconds, minutes, hours, day of month, month, day of week. The example above backs up at the start of every hour.

Coordination with a running instance happens over RCON, Minecraft's remote console protocol. RCON is enabled whenever an RCON password is configured; when backups are enabled and no password is set, mc generates one at startup so backups work out of the box. See MC_RCON_PASSWORD to set the password yourself.

Manual backups

A backup can be taken at any time with mc backup, even when scheduled backups are disabled — enabled only controls the schedule. It works against a stopped instance, and against a running one as long as the instance was started with an RCON password configured (always the case when backups are enabled). When the instance is running but cannot be reached, mc refuses to back up rather than capture a world that is still being written to.

Storage

Archives go to a storage target configured under [backups.storage]. Two types are supported.

Local (the default) stores archives in a directory and keeps only the most recent ones:

[backups.storage]
type = "local"
path = "backups"
keep = 20

S3 uploads archives to a bucket:

[backups.storage]
type = "s3"
bucket = "my-minecraft-backups"

Credentials come from the standard AWS credential chain (environment, ~/.aws, or an IAM role). The bucket can also be supplied with the MC_BACKUPS_S3_BUCKET environment variable instead of the manifest. mc does not prune S3 backups; use a bucket lifecycle rule to expire old archives.

Give each instance its own bucket or directory: mc treats everything in the storage target as a backup of this instance.

Notifications

mc reports backup results — along with other instance events — to a webhook when one is configured through the environment (MC_DISCORD_WEBHOOK for Discord). The [notifications] section of the manifest selects which events are sent; see The Manifest Format. A failed notification never fails the backup itself.

Restoring

List the available backups, then restore one:

$ mc restore --list
myserver_2026-07-15_15-00-00.tar.gz (latest)
myserver_2026-07-14_15-00-00.tar.gz
$ mc restore --backup myserver_2026-07-14_15-00-00.tar.gz

Without --backup, the most recent backup is restored. The instance must be stopped to restore. The world being replaced is set aside rather than deleted, and is put back if the restore fails. See mc restore.

Running under systemd

mc run is designed to live under a process supervisor. It does not restart the instance when it crashes; it reports the failure through its exit code and lets the supervisor decide. On Linux, systemd is the natural fit.

Unit file

Assuming an instance at /srv/minecraft/myserver, create /etc/systemd/system/myserver.service:

[Unit]
Description=myserver Minecraft instance
After=network-online.target
Wants=network-online.target

[Service]
User=minecraft
WorkingDirectory=/srv/minecraft/myserver
ExecStart=/usr/local/bin/mc run
EnvironmentFile=/etc/minecraft/myserver.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

Then enable and start it:

$ systemctl enable --now myserver

WorkingDirectory must be the instance root — the directory containing mc.toml — since mc operates relative to it.

Secrets

Environment variables such as MC_RCON_PASSWORD or a notification webhook are best kept out of the unit file, in an EnvironmentFile readable only by root:

$ cat /etc/minecraft/myserver.env
MC_RCON_PASSWORD=...
MC_DISCORD_WEBHOOK=...

See Environment Variables for everything mc reads from the environment.

Stopping and restarting

systemctl stop sends the service SIGTERM. mc catches it, asks the instance to save the world and shut down, and waits for it to exit before returning — within systemd's default stop timeout, so the unit is not killed mid-save. The same applies to systemctl restart and to stops issued during a system shutdown.

Restart=on-failure brings the instance back up if it crashes, while a clean stop (including one requested from inside the game with /stop) stays stopped.

Logs

The instance's console output goes to standard output, which systemd captures in the journal:

$ journalctl -u myserver -f

mc's own log verbosity is controlled by the global --verbose flag; the instance's console log level follows it.

Reference

The Manifest Format

The mc.toml manifest at the root of an instance describes everything about it. It is written in TOML. Every section except the two top-level keys is optional; omitted keys take the defaults listed below.

name = "myserver"
description = "A Minecraft Server"

[java]
version = "graal@25"
min_memory = 4096
max_memory = 4096

[minecraft]
version = "..."
loader = "fabric"

[server]
gamemode = "survival"
difficulty = "normal"
eula = true

[server.properties]
white-list = false

[mods]
lithium = "..."

[backups]
enabled = true
frequency = "0 0 * * * *"

name (required)

The instance name. It names the world directory inside the instance and is used as the world's level-name. Must be usable as a directory name.

description (required)

A short description, used as the message of the day (motd) shown in the multiplayer list.

[java]

The Java runtime used to launch the instance.

  • version — the runtime to install and use, as a vendor@version descriptor. Defaults to "graal@25". Run mc java list to see the available runtimes; the one marked (recommended) is the default.
  • min_memory — initial heap size in megabytes. Defaults to 4096.
  • max_memory — maximum heap size in megabytes. Defaults to 4096.
  • jvm_arguments — extra arguments passed to the JVM. Defaults to a small set of tuned flags; setting this key replaces the defaults entirely.
[java]
version = "graal@25"
min_memory = 8192
max_memory = 8192
jvm_arguments = ["-XX:+AlwaysPreTouch"]

[minecraft]

The Minecraft version and mod loader.

  • version — the Minecraft version to run. Defaults to "latest", the latest release. "latest-snapshot" selects the latest snapshot, and any exact version id (see mc minecraft list) pins that version. Aliases are resolved every start, so an instance on "latest" upgrades itself when a new release comes out — pin an exact version if that is not what you want.
  • loader — the mod loader, as a name or name@version descriptor (for example "fabric", which resolves to the latest loader version for the configured Minecraft version). When omitted, the instance runs without a loader and the [mods] table is ignored. Run mc minecraft list-loaders to see loader versions.

[server]

Settings mc manages for the server. Each maps to a server.properties key, listed in parentheses; because these are managed here, they cannot be set through [server.properties].

  • gamemode — "survival", "creative", "adventure", or "spectator". Defaults to "survival". (gamemode)
  • difficulty — "peaceful", "easy", "normal", or "hard". Defaults to "normal". (difficulty)
  • level_type — "minecraft:normal", "minecraft:flat", "minecraft:large_biomes", "minecraft:amplified", or "minecraft:single_biome_surface". Defaults to "minecraft:normal". (level-type)
  • hardcore — defaults to false. (hardcore)
  • seed — the world seed, as an integer or a string. Random when omitted. (level-seed)
  • eula — indicates that YOU have read and agree to the Minecraft EULA. The instance refuses to start until this is true. Defaults to false.
  • ip — the address to bind. When omitted, the server binds all addresses, IPv6 included. (server-ip)
  • port — the game port. Defaults to 25565. (server-port)
  • rcon_port — the remote console port. Defaults to 25575. (rcon.port)
  • capacity — the maximum number of players. Defaults to 20. (max-players)
  • view_distance — in chunks. Defaults to 16. (view-distance)
  • simulation_distance — in chunks. Defaults to 16. (simulation-distance)

[server.properties]

Overrides for any other server.properties key. mc generates the file on every start — hand edits do not survive — so this table is the way to reach settings that have no [server] field:

[server.properties]
white-list = false
spawn-protection = 16
"query.port" = 25565

Values may be strings, integers, floats, or booleans. Keys containing a dot must be quoted, as above.

Keys managed by mc take precedence: an entry that conflicts with a value derived from the manifest or the environment is ignored with a warning. enable-rcon is always ignored — RCON is enabled exactly when an RCON password is configured (see Environment Variables).

Note two defaults that differ from a vanilla server: the allow list is enabled (white-list), and the server binds all addresses, IPv6 included (server-ip).

[mods]

The mods to install, keyed by the mod's identifier (slug) on the mod registry. Three forms are supported:

[mods]
# a version identifier on the registry
lithium = "..."

# the same, spelled out
carpet = { version = "...", service = "modrinth" }

# a jar fetched from a URL, for mods not on the registry
my-mod = { url = "https://example.com/my-mod.jar" }

service names the registry hosting the mod and defaults to "modrinth".

mc add, mc remove, and mc update edit this table for you and pin compatible versions. Required dependencies are resolved automatically when the instance starts and recorded in the mc.lock lockfile — see Managing Mods.

[backups]

Scheduled world backups, taken while the instance runs.

  • enabled — schedule backups while the instance runs. Defaults to false. Manual mc backup works regardless.
  • frequency — a cron expression with six fields: seconds, minutes, hours, day of month, month, day of week. Defaults to "0 0 * * * *" (hourly).

[backups.storage]

Where archives are stored. type selects the backend:

[backups.storage]
type = "local"
path = "backups"    # default
keep = 20           # most-recent archives to keep; default

[backups.storage]
type = "s3"
bucket = "my-minecraft-backups"

For s3, the bucket may also come from the MC_BACKUPS_S3_BUCKET environment variable, and credentials come from the standard AWS credential chain. The default is local storage.

See the Backups guide for the full picture.

[notifications]

Webhook notifications about the instance. A provider is activated by setting its webhook environment variable (MC_DISCORD_WEBHOOK for Discord) — the URL is a secret and is never read from the manifest, and without one no notifications are sent. This table selects which events are reported; every key defaults to true:

  • on_lifecycle_event — the instance started or stopped.
  • on_panic — the instance crashed.
  • on_sigkill — the instance was forced down without a clean save, because it did not stop within the grace period or a second stop signal arrived.
  • on_backup — a backup completed.
  • on_backup_failure — a backup failed.
[notifications]
on_lifecycle_event = false
on_backup = false

Environment Variables

The environment acts as an override layer on top of mc.toml, and is the only place mc reads secrets from — secrets are deliberately kept out of the manifest so it can be committed and shared safely.

MC_RCON_PASSWORD

The password for RCON, the remote console protocol used to coordinate backups with a running instance. It takes precedence over a "rcon.password" entry under [server.properties].

RCON is enabled exactly when a password is configured. When backups are enabled and no password is set anywhere, mc generates one at each start so backups work out of the box; set this variable when other tooling needs to reach the remote console with a known password.

MC_BACKUPS_S3_BUCKET

The S3 bucket that receives backup archives when [backups.storage] has type = "s3". It takes precedence over the bucket key in the manifest and can replace it entirely.

S3 credentials are not read through mc-specific variables; they come from the standard AWS credential chain — AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY, the ~/.aws configuration files, or an attached IAM role.

MC_DISCORD_WEBHOOK

The Discord webhook URL that notifications are posted to. Setting it is what turns notifications on; without it none are sent. The [notifications] section of the manifest selects which events are reported — instance lifecycle, crashes, forced shutdowns, and backup results are all on by default.

Instance Layout

An instance is a directory with mc.toml at its root. All mc commands run from that directory, and everything the instance needs lives under it:

myserver/
├── mc.toml
├── mc.lock
├── .java/
├── .minecraft/
├── backups/
├── instance/
│   ├── eula.txt
│   ├── server.properties
│   ├── mods/
│   └── myserver/
└── temp/

Only one running server is allowed per instance directory; a second mc run in the same directory refuses to start.

mc.toml

The manifest describing the instance — the only file you author. See The Manifest Format.

mc.lock

The mod lockfile: the fully resolved set of mods, including required dependencies, that the instance last started with. Regenerated when the instance starts.

.java/ and .minecraft/

Installed Java runtimes and Minecraft binaries, keyed by version, shared by every start of this instance. Safe to delete while the instance is stopped; whatever is missing is downloaded again on the next start.

backups/

The default destination for backup archives when local storage is used. The directory is dedicated to this instance's backups; see Backups.

instance/

The live working directory of the Minecraft process. Notable contents:

  • eula.txt — generated from the eula key in the manifest.
  • server.properties — generated from the manifest on every start; manual edits are overwritten. Use the [server.properties] section of mc.toml instead. When the file holds secrets, such as an RCON password, mc creates it readable only by the owning user and refuses to start if its permissions have been loosened.
  • mods/ — the installed mods. This directory is fully managed: mc adds and removes jars to match the lockfile, so a jar placed here by hand is deleted on the next start. Declare URL mods in the manifest instead.
  • myserver/ — the world, named after the instance's name. Everything else Minecraft writes at runtime (logs, player data, allow list, and so on) also lives here and is left untouched by mc.

temp/

Scratch space for in-flight downloads and archives. Cleared when the instance starts; safe to delete while nothing is running.

Commands

General Commands

mc

mc [OPTIONS] <COMMAND>

The mc binary is a collection of subcommands; run one of the commands documented in this chapter. Every command operates on the instance in the current working directory — the directory containing mc.toml.

Global options

These options are accepted by every command.

  • -v, --verbose — more detailed output. Repeat for more: -v prints informational messages, -vv debug, -vvv trace. The instance's console log level follows this setting.
  • -q, --quiet — do not print mc log messages.
  • --color <WHEN> — control colored output: auto (the default), always, or never.
  • -h, --help — print help.
  • -V, --version — print the mc version.

Exit status

mc exits with 0 on success and a non-zero code on failure. mc run propagates the instance's own exit code when the instance ends abnormally.

mc help

mc help [COMMAND]

Prints help for mc or for the given command. Equivalent to passing --help:

$ mc help init
$ mc init --help

Manifest Commands

Commands that create or edit mc.toml:

  • mc init — create a new instance.
  • mc add — add mods to the manifest.
  • mc remove — remove mods from the manifest.
  • mc update — update pinned mod versions.

mc init

mc init [OPTIONS] [PATH]

Creates a new instance: a mc.toml manifest and the supporting directories. PATH defaults to the current directory and is created if it does not exist. The command refuses to run where a mc.toml already exists.

Options

  • --name <NAME> — the instance name. Defaults to the directory name.
  • --eula — record your agreement to the Minecraft EULA in the generated manifest. Without it, the manifest is created with eula = false and the instance will not start until you edit it.
  • --preset <PRESET> — the shape of the generated manifest:
    • vanilla — no mod loader and no mods.
    • optimized — a mod loader plus performance mods. This is the default.
    • technical — a mod loader plus performance mods and tools for technical play.

Presets pin the latest Minecraft release and compatible mod versions at the time the command runs; the generated manifest is a starting point to edit, not a fixed template.

Examples

$ mc init myserver
$ mc init --preset technical --eula
$ mc init myserver --name "smp" --preset vanilla

mc add

mc add [OPTIONS] <MOD_SLUG>...

Adds mods to the [mods] table of the manifest. Each MOD_SLUG is the mod's identifier on the mod registry. The latest version compatible with the configured Minecraft version and loader is looked up and pinned; the command fails if a mod cannot be found for that combination.

A mod loader must be configured under [minecraft] before mods can be added.

Changes take effect the next time the instance starts, which also installs any required dependencies — see Managing Mods.

Options

  • --manifest-path <PATH> — path to mc.toml. Defaults to ./mc.toml.

Examples

$ mc add lithium
$ mc add carpet servux

mc remove

mc remove [OPTIONS] <MOD_SLUG>...

Removes mods from the [mods] table of the manifest. A slug that is not in the manifest is reported and skipped.

The jars are uninstalled the next time the instance starts. A removed mod's dependencies are not kept: anything no longer required disappears from the lockfile and is uninstalled along with it.

Options

  • --manifest-path <PATH> — path to mc.toml. Defaults to ./mc.toml.

Examples

$ mc remove carpet

mc update

mc update [OPTIONS] [MOD_SLUG]...

Re-pins mods in the manifest to the latest version compatible with the configured Minecraft version and loader. With no arguments every mod is updated; otherwise only the named ones. Mods already at their latest version, and mods fetched from a URL (which carry no version), are skipped.

The new versions are installed the next time the instance starts.

Options

  • --manifest-path <PATH> — path to mc.toml. Defaults to ./mc.toml.

Examples

$ mc update
$ mc update lithium carpet

Instance Commands

Commands that operate on the instance itself:

mc run

mc run [OPTIONS]

Brings the instance in line with the manifest, then starts it. Anything missing or out of date is installed first: the Java runtime, the Minecraft binary, the mod loader, and the mods (added, updated, and removed to match the manifest). The generated configuration files are rewritten from the manifest on every start.

Only one running server is allowed per instance directory; a second mc run refuses to start.

While the instance runs, mc supervises it: the console output is attached to the terminal, and scheduled backups fire when enabled — see Backups. The console is not interactive; use the remote console (RCON) for live administration.

Stopping

Ctrl-C (or SIGTERM, e.g. from a service manager) asks the instance to save the world and shut down, and waits for it to exit before returning. If the instance hangs past a grace period, or a second signal arrives, it is forced down immediately.

mc does not restart a crashed instance; run it under a supervisor for that — see Running under systemd.

Exit status

When the instance ends abnormally, mc run fails and propagates the instance's exit code.

Options

  • --manifest-path <PATH> — path to mc.toml. Defaults to ./mc.toml.
  • --lockfile-path <PATH> — path to mc.lock. Defaults to ./mc.lock.

mc backup

mc backup [OPTIONS]

Archives the world and stores it in the storage target configured under [backups.storage] — see Backups. Works whether or not scheduled backups are enabled.

The instance may be stopped or running. A running instance is reached over its remote console so the world is flushed to disk before it is archived; if the instance is running but the remote console is not available, the command refuses rather than capture a world that is still being written to. Only one backup can run at a time.

Options

  • --manifest-path <PATH> — path to mc.toml. Defaults to ./mc.toml.

Examples

$ mc backup

mc restore

mc restore [OPTIONS]

Replaces the world with one restored from a backup. The instance must be stopped.

The world being replaced is moved aside rather than deleted; if the restore fails, it is put back and the command reports the failure. One set-aside world is kept until the next restore replaces it.

Options

  • --list — list the available backups instead of restoring.
  • --backup <BACKUP> — the backup to restore, by the filename shown by --list. Defaults to the most recent backup.
  • --manifest-path <PATH> — path to mc.toml. Defaults to ./mc.toml.

Examples

$ mc restore --list
myserver_2026-07-15_15-00-00.tar.gz (latest)
myserver_2026-07-14_15-00-00.tar.gz
$ mc restore
$ mc restore --backup myserver_2026-07-14_15-00-00.tar.gz

Installation Commands

Commands to inspect available versions and pre-install components. mc run installs everything it needs automatically, so these are mostly useful for exploring what is available and for provisioning ahead of time:

mc java

Manage Java runtimes.

mc java list

mc java list

Lists the runtimes mc can install, as vendor@version descriptors. The one marked (recommended) is the default used when the manifest does not configure [java] version.

$ mc java list
graal@25 (recommended)
graal@21
...

mc java install

mc java install [OPTIONS] <VERSION>

Downloads a runtime into the instance's .java directory. VERSION is a descriptor from mc java list; the version half may be omitted to take the vendor's recommended version. Fails if the runtime is already installed.

mc run installs the configured runtime automatically; this command exists to provision one ahead of time.

Options

  • -p, --platform <PLATFORM> — install for a specific operating system instead of the current one.
  • -a, --architecture <ARCHITECTURE> — install for a specific CPU architecture instead of the current one.

Examples

$ mc java install graal@25
$ mc java install corretto@21

mc minecraft

Manage Minecraft versions and mod loaders.

mc minecraft list

mc minecraft list [OPTIONS]

Lists Minecraft versions, most recent first. By default only the ten most recent releases are shown, with the latest release and latest snapshot tagged.

Options

  • --all — show every version instead of the ten most recent.
  • -s, --snapshots — include snapshot versions.
  • -b, --betas — include beta versions.
  • -a, --alphas — include alpha versions.

mc minecraft list-loaders

mc minecraft list-loaders [OPTIONS]

Lists mod loader versions compatible with a Minecraft version, most recent first.

Options

  • -l, --loader <LOADER> — the loader to list versions for. Defaults to fabric.
  • -m, --minecraft-version <VERSION> — the Minecraft version to list loader versions for. Defaults to latest.
  • --limit <LIMIT> — the number of results. Defaults to 10.

mc minecraft install

mc minecraft install [OPTIONS] [VERSION]

Downloads a Minecraft binary into the instance's .minecraft directory. VERSION accepts the same values as [minecraft] version in the manifest (latest, latest-snapshot, or an exact version id) and defaults to latest. Fails if that version is already installed.

mc run installs the configured version automatically; this command exists to provision one ahead of time.

Options

  • -l, --loader <LOADER> — install the binary for a mod loader instead of the vanilla one, as a name or name@version descriptor (for example fabric).

Examples

$ mc minecraft install
$ mc minecraft install --loader fabric