Pandapi

An API-first Minecraft launcher for advanced automation.

Pandapi is a full Minecraft launcher (Rust / gpui) whose entire surface is a machine-readable control API: 110 commands over NDJSON, a replayable event stream, capability-scoped network access, and a headless mode. Anything the GUI can do (create, configure, launch and kill instances, manage accounts, install content, read logs, drive Microsoft login) a script, a CI job, or an LLM can do.

ekaii-launcher is the ekaii-branded distribution based on Pandapi. Both are a fork of Moulberry/PandoraLauncher, which provides the launcher core.

Drive it in 30 seconds

The launcher binary doubles as a CLI client (--api sends one command to the running launcher and prints the raw JSON response):

ekaii-launcher --api launcher.status
ekaii-launcher --api instances.start --api-params '{"name": "main", "wait": "running"}'
ekaii-launcher --api instances.list | jq '.data[].name'

Underneath it is plain NDJSON on a local Unix socket (named pipe on Windows), one JSON object per line:

SOCK="$HOME/Library/Application Support/EkaiiLauncher/api.sock"
echo '{"id":1,"cmd":"launcher.version"}' | nc -U "$SOCK"
{"id":1,"ok":true,"data":{"version":"5.7.1","protocol":1,"session_id":"18f3c0a1b2"}}

The API teaches itself. One call returns every command, every event type, and the security model:

ekaii-launcher --api api.describe

That is enough for a client, an SDK generator, or an LLM to learn the whole surface without reading a line of documentation.

The control API

• 110 commands in 17 groups, NDJSON framed, pipelined by id, served by the launcher process itself.
• Transports: Unix domain socket (macOS/Linux) and Windows named pipe, local and fully trusted; opt-in TCP for off-box clients, with a WebSocket (RFC 6455) upgrade accepted on the same port.
• Self-describing: api.describe returns the grouped command registry, all 19 event types, and a machine-readable security block (scopes, read-only set, local-only set, denied fields, env vars, error codes).
• Capability security for network mode: scoped bearer tokens (read, write, accounts, settings, *; write implies read), token minting is local-socket only, a path jail (EKAII_API_PATH_ALLOW) gates every path parameter, and execution-vector fields (wrapper_command, linux_wrapper, system_libraries, jvm_binary, jvm_flags) are denied over the network. There is no TLS: keep it on loopback or behind a tunnel.
• Event stream v2: monotonic seq, a 4096-event replay ring (events.subscribe {since_seq} resumes without gaps), server-side filters, op lifecycle events, semantic game events (game.ready, game.crash, game.server_connected, game.world_loading, game.player_chat, game.stopping, game.exited), and an opt-in console tee (game.capture / game.output).
• Orchestration: async operations with ops.wait, blocking launches with instances.start {wait}, and structured errors ({code, message, retryable}) so scripts can branch and retry without parsing message text.
• Headless: ekaii-launcher --headless runs the backend and the API with no GUI, turning the launcher into a scriptable daemon.

Command domains cover the launcher itself, instance lifecycle and configuration (export/import, diff, manifests, snapshot/restore, sessions, screenshots, crash reports), content (search/install/sync/resolve/dev-link/bisect via Modrinth and CurseForge), accounts (offline and Microsoft login via visit_url, skins, capes), worlds (backup/restore/duplicate/delete), servers, logs (read/tail/upload), metrics, health and diagnostics, infrastructure-as-code style state export and plan, webhooks, and network/auth management.

The full command reference is deliberately not in this README. See docs/API.md and the wiki.

Network mode

Off by default. Enabled and tuned with environment variables:

Variable	Meaning
PANDAPI_API_TCP	Bind a TCP listener (host:port, or a bare port for 127.0.0.1:<port>)
PANDAPI_API_WS	Also accept WebSocket clients on the same port
PANDAPI_API_NO_AUTH	Disable auth (honored only on loopback binds)
PANDAPI_API_PATH_ALLOW	Colon-separated directories network clients may reference in path parameters

Every build accepts both the PANDAPI_API_ names above and the legacy EKAII_API_ names (the PANDAPI_ name wins if both are set).

Themes and the unthemed build

The product is Pandapi; Ekaii is a theme. The default build carries the Ekaii theme (palette, community links) and keeps the Ekaii distribution's on-disk identifiers, so an existing install upgrades in place with no data loss. Build the unthemed Pandapi distribution, with its own clean Pandapi / fr.pandapi.launcher identifiers and a separate data directory, with:

cargo build --release --no-default-features          # unthemed Pandapi binary
PANDAPI_THEME=vanilla ./scripts/build_mac.sh v5.8.0  # packaged, signed macOS build

Automation and AI

Pandapi was built to be driven by machines. The combination of NDJSON framing, api.describe self-discovery, structured errors, and scoped tokens makes it directly usable by an LLM agent or an MCP server: one call to learn the surface, stable codes to branch on, a replayable event stream to observe with, and capability scopes to hand out narrow credentials.

One boundary matters for automation work: Pandapi launches and supervises the real Minecraft client. It can start and kill the game, read its console and semantic events, and manage accounts, instances, and content, but it does not speak the game protocol itself and cannot inject in-game input or chat. Headless-bot frameworks (Mineflayer, SoulFire, Minecraft Console Client, ZenithProxy) do speak the protocol. The ecosystem thesis is that Pandapi is the orchestration, identity, and observability hub, and the bot frameworks are the in-world actors: Pandapi supplies accounts and auth, server lists, fleet orchestration, live stats, and an LLM/MCP control plane, while a companion process executes in-world. See docs/ECOSYSTEM.md for the full roadmap.

Launcher features

The launcher core, inherited from PandoraLauncher and maintained in this fork:

• Instance management
• Cross-instance file syncing (options, saves, etc.) (https://youtu.be/wb5EY2VsMKg)
• Mod deduplication when installed through the launcher (using hard links)
• Secure account credential management using platform keyrings
• Custom game output window
• Mod browser (Modrinth and CurseForge)
• Automatic redaction of sensitive information (i.e. access tokens) in logs
• Unique approach to modpack management (https://youtu.be/cdRVqd7b2BQ)

Pandapi, ekaii-launcher, and PandoraLauncher

• Pandapi is this project: the API-first launcher and its control plane.
• ekaii-launcher is the ekaii-branded distribution based on Pandapi, shipped for the ekaii community. Same code, ekaii identity and defaults.
• PandoraLauncher by Moulberry is the upstream launcher this fork is built on; the instance management, syncing, and UI foundations are its work, and credit belongs there. This fork is an independent project: the control API and automation features are developed here and are not being upstreamed.

Build and install

Prebuilt packages (macOS .dmg, portable builds) are published on the releases page. Current release: v5.7.1.

From source (a recent stable Rust toolchain):

git clone https://forgejo.ekaii.fr/exo/ekaii-launcher.git
cd ekaii-launcher
cargo build --release

Documentation

• docs/API.md: complete control API reference (transports, every command, events, security)
• docs/CONTROL-ARCHITECTURE.md: how the API server is wired internally
• docs/ECOSYSTEM.md: the automation ecosystem roadmap (bot frameworks, MCP, fleets)
• Wiki: guides and the browsable command catalog

Screenshot