# The panel

> One command, one link, and the whole of Keystone in a browser — served by your own server.

Source: https://stygion.eu/docs/keystone/panel
Updated: 2026-10-10

Type `/keystone panel` in game. Keystone puts a link in chat, you click it, and
the editor opens signed in. That is the whole thing — no account, no portal, no
password to invent.

## Where the page comes from

**Your own server.** The editor is built into the jar and served off the same
process that runs the game, on the local API's address. Nothing is fetched from
us and nothing is sent to us, which is why it works with the network cable
pulled out and why it cannot stop working because something of ours is down.

## The link, and why it expires

A chat line is not a secret. It is in a log file, possibly in a screenshot, and
on a staffed server it was read by whoever was standing nearby. So the token in
the link:

- **works once** — the second person to click it gets nothing,
- **lasts five minutes**,
- and is exchanged for an ordinary key, not for a session that lives forever.

The key behind it is named after you (`panel: <your name>`), lasts a day, and
carries the scopes you already had. `keystone key revoke <id>` takes it back
early, and revoking yours touches nobody else's.

If a link is clicked late, or twice, the page says so and tells you to type the
command again. Which of the two it was is deliberately not said — that is not
the clicker's business.

**What you may do in the editor depends on who you are.** A level-4 operator
and the console get a link to everything. Somebody who reached the panel through
a group (say a moderator holding `keystone.admin`) gets a link that is **read and
moderate only**: settings, groups, perks, restoring a backup, running operations
by hand, the assistant's writes and translations can be changed only by the
owner. The owner is a level-4 operator.

## What is in it

The screens sit in a side rail, and **a screen appears only when its module
runs**:

| Screen | What it is for |
|---|---|
| Overview | Players, TPS, tick time and memory now and over the last day, what is coming up, and what needs somebody: open tickets, the assistant's proposals, a staged restore, a module that did not start. |
| Players | Look anybody up: what they hold and where from, a group for a while, a perk, "may they do this?", progress, votes and crate keys, leaderboards and the rank ladder. |
| Groups | Permission groups, what inherits from what, and every rule they end up with and where it came from. |
| Bans and accounts | Bans with an end and a reason, accounts and who was refused. |
| Operations | What is scheduled — restarts, backups, cleanups, notices — and what has already run, including what was skipped and why. Anything can be run now, in 1, 5 or 15 minutes, called off, or put into maintenance with a reason; it also shows what a clean would take. It all takes the same road: the same warnings, the same countdown, the same record. |
| Backups | Backups and putting one back (staged for the next boot and cancellable). |
| Performance | Live, a week of history, and every load test this server has run and what gave out first. |
| Console and chat | The server's own console, live, with levels, search and copy, and chat beside it. |
| Votes, Tickets, Crates | Votes and rewards, tickets, and crates: keys, odds and what is in them. |
| Discord | The state of the bridge and its settings. |
| Settings | Every setting Keystone has, with what it means, and the history of changes. |
| Languages, Warps | Translations (see [A player's language](/docs/keystone/languages)) and warps (see [Essentials](/docs/keystone/essentials)). |
| Assistant | Questions about this server, answered from its own state. Needs a model address set. |
| Keys and audit | The keys that can reach the local API, what each may do, a way to take one back, and who changed what. |

`Ctrl K` (or `/`) finds any screen, setting, player or group and runs the common
actions. The editor is light or dark with the system, or pinned by a switch.

**Settings are drafts until you apply them.** Change as many as you like; the
server checks each as you type and refuses in words what does not fit. `Ctrl S`
shows every change beside what it is now and applies the ones the server took —
each a version the history can put back, with an Undo right there. Drafts survive
a closed tab (secrets never leave the page). Flags are switches, lists are chips,
times of day are a clock, ids are picked from what the server loaded, and chat
text is drawn the way a vanilla client draws it.

A screen never appears before it answers. There is no tab that errors and no tab
labelled "coming soon".

## If the page does not open

- **"No editor in this build"** — the jar was built without the editor. Use a
  release build rather than one built from source without the front end.
- **The browser cannot reach the address.** The local API listens on `127.0.0.1`
  by default, so the link works from the machine the server runs on. From
  anywhere else, either [tunnel](/docs/keystone/troubleshooting) or set
  `api.reachable-at` (below) — and read [the local API](/docs/keystone/api) on
  what you are exposing before you change it.
- **The link expired.** Type `/keystone panel` again; they are free.

## When the editor has to be reachable from elsewhere *(0.1.1 and newer)*

The address the API **listens** on and the address somebody **types into a
browser** are not the same thing. `0.0.0.0` is a good answer to the first and an
unusable answer to the second — a link reading `http://0.0.0.0:25586/…` opens
nowhere. So:

```
/keystone set keystone.api.address 0.0.0.0
/keystone set keystone.api.reachable-at 192.168.1.100
```

Leave `api.reachable-at` empty with the API on a real address and that address is
used. Leave it empty with the API on `0.0.0.0` and the mod asks the machine for
its own address on the network, with loopback only as a last resort. Setting it
wins, which is what you need behind a router, through a tunnel, or under a name
you gave the machine.

**Behind a reverse proxy with https** *(0.2.3 and newer)*, write the whole address
with its scheme:

```
/keystone set keystone.api.reachable-at https://keystone.example.com
```

An address like that is used as written, without the API's port. The proxy only
has to pass `/panel` (including `/panel/claim`) and the `/v1` paths the editor
calls, with the live stream at `/v1/events` unbuffered. The editor sends its key
in an `Authorization` header and never a cookie, so the proxy has nothing to
rewrite. The editor's pages themselves refuse to be framed by another site and
do not pass their address on as a referrer.

The link is composed when you ask for one rather than when the server booted, so
this setting applies immediately — which matters, because it is the setting you
reach for *after* a link did not open.

## Turning it off

`/keystone set keystone.api.enabled false` stops the local API, and the panel with it.
Everything else keeps working — the panel is a way in, not a dependency.