Glossary¶
Every technical word this wiki uses, in plain language. Where a word has its own page, the entry links to it.
Terms specific to how otomo is built (ledger, enforcer, route class, allocation and so on) are in Glossary and where to look next.
- Access token
- A login pass the game attaches to every request. It lasts 15 minutes. See Logins and tokens.
- Admin website
- The private website where staff publish content and watch otomo's health. See Use the admin website.
- Allocation
- One reservation of a game server for one party's match (or, with matchmaking, for one match of several parties).
- Allocator
- The otomo service that knows which game servers are free, reserves them, and writes join tickets.
- API
- The list of requests a server understands. See HTTP and APIs.
- async / await
- C# keywords for waiting for something slow (like a server's answer) without freezing the game.
- Audience
- Whether a settings namespace is sent to players' games (client) or kept on the server (server).
- Auth
- The otomo service that logs players in. Also short for authentication: proving who you are.
- Autoload
- A Godot node created when the game starts and kept for the whole run. The SDK's is called
Otomo. - Backend
- The parts of an online game that run on servers, out of the player's sight. Otomo is a backend.
- Base URL
- The address the SDK sends every request to: otomo's gateway.
- bash
- The shell (command language) of Linux. See Command-line basics.
- Blob
- A stored file (a settings document or a pack), named by its SHA-256 fingerprint.
- Certificate
- A signed document proving a server owns its domain name, used for HTTPS.
- Channel
- A stream of releases:
dev,stagingorlive. Players getlive. See Content and patching. - CI (continuous integration)
- Automatic testing of every change. Otomo's repository uses GitHub Actions.
- Client
- A program that contacts a server. Your game is a client.
- Container
- A running copy of an image, sealed off from other containers. See Servers and containers.
- Dedicated server
- A Godot export with no window, graphics or sound, which runs matches on a server.
- Device ID
- A long random text the SDK creates on first run. It identifies the player's account.
- DNS
- The system that turns names like
play.example.cominto IP addresses. - Docker / Docker Compose
- The tools that package otomo's programs as images and run them as containers, all
described in one file,
deploy/compose.yaml. - Draft
- The unsaved, editable state of a settings namespace in the admin website.
- Edge
- Otomo's front door on the internet. It handles HTTPS and passes requests inward.
- ENet
- The networking library Godot's multiplayer uses, over UDP.
- Endpoint / route
- One specific request a server accepts, such as
POST /party/launch. - Event
- A message from Session telling the game that something changed. Delivered by long polling.
- Fallback
- The value your code uses when a setting is missing. Every
RemoteConfig.Get…call takes one. - Firewall
- A gatekeeper that decides which ports on a computer the internet can reach.
- Gameplay Proxy
- The one public door to otomo's game servers. It checks join tickets.
- Game server
- Your dedicated server program, running a match.
- Gateway
- The otomo service that checks login passes and rate limits, and routes each request to the right service.
- Head
- The release a channel is currently serving.
- Headless
- Running without a window or screen.
- Heartbeat
- A regular "still alive" message. Game servers send one to the Allocator every 5 seconds.
- HTTP / HTTPS
- The request-and-response language of the web. HTTPS is HTTP with TLS encryption. See HTTP and APIs.
- Image
- A program packed with everything it needs to run, from which containers are started.
- IP address
- A computer's numeric address on a network, such as
203.0.113.10. - Join ticket
- A single-use pass, valid for 60 seconds, that lets one player into one match. See Parties and matches.
- JSON
- A plain-text data format:
{"name": "value"}. See HTTP and APIs. - JWT
- JSON Web Token: a signed token format used for otomo's login passes and join tickets.
- Linux
- The operating system otomo's server runs.
- Live
- The channel every player receives.
- Local port
- The port on the player's own computer that their game sends from.
- localhost / 127.0.0.1
- "This same computer."
- Long polling
- Asking a server a question that it holds open until it has news. How Session delivers events.
- Manifest
- The list of files in a release, each with its size and fingerprint.
- Minimum client version
- The oldest game build a release allows. Older builds get
ClientTooOld. - Namespace
- A named settings document in the admin website, such as
balance.player. - Pack (.pck)
- A Godot file bundling resources, delivered by otomo and mounted into
res://. - Party
- A group of players who play together; also the pre-match lobby.
- Patch / patching
- The otomo service that serves content, and the process of downloading and loading it.
- Path
- The address of a file (
C:\Games\x,/home/mei/x), or the part of a URL after the domain name (/party/launch). - Port
- A number that picks which program on a computer receives a message.
- Postgres
- The database otomo's services store their data in.
- Promote
- Copy one channel's head release to the next channel (
dev→staging→live). - Pull request (PR)
- A request to review and merge a branch of changes.
- Rate limit
- A cap on how many requests a player may send per second.
- Refresh token
- A saved, single-use pass for getting a new access token. Lasts 30 days.
- Registry
- A store of Docker images, each with a tag.
- Release
- A published, unchangeable snapshot of content: namespace versions, packs and a minimum client version.
- RemoteConfig
- The SDK object your code reads settings from.
- Request ID
- A unique ID for one request, used to find it in the logs. Include it in bug reports.
- REST
- A common style of HTTP API: paths name things, and methods say what to do with them.
- Revision
- A party's change counter, used to stop out-of-date changes.
- Roll back
- Point a channel at an earlier release, undoing later ones.
- Schema
- A description of what a settings document must look like.
- SDK
- Software Development Kit: here, the Godot addon that connects your game to otomo.
- Server
- A program that waits for clients to contact it, or the computer such programs run on.
- Service
- One of otomo's programs, each with one job (Auth, Patch, Session…).
- Session
- The otomo service for profiles, friends, parties and events.
- SHA-256 / fingerprint
- A 64-character code computed from a file's exact contents, used to check a download isn't damaged or altered.
- Shell / terminal
- A text window for typing commands, and the program that runs them.
- Signal
- Godot's way for a node to announce that something happened.
- SSH / SSH key / SSH tunnel
- Secure remote login, the key pair that proves who you are, and a way to carry a port through that connection. See Command-line basics.
- Status code
- The three-digit number summarising an HTTP response, such as
200or404. - sudo
- Run a Linux command with administrator rights.
- Tag (image tag)
- A version name for a Docker image.
- TCP / UDP
- The two ways programs send data: TCP is a reliable connection, UDP is fast fire-and-forget packets. See How games go online.
- TLS
- The encryption that protects HTTPS.
- Token
- A signed pass proving who you are.
- Valkey
- A fast, in-memory store Session uses for things like who's online.
- Version (namespace version)
- A numbered, frozen copy of a settings namespace.
- VM (virtual machine)
- A computer simulated in software on a larger physical machine.
- WSL
- Windows Subsystem for Linux: Linux running inside Windows.