Introduction

Operator is a command console and permission system for Roblox, written in pure Luau. You write commands; it handles the console, argument parsing, roles and the audit log.

export type KickArgs = { target: Player, reason: string }

return (Command.new("kick") :: Operator.Builder<KickArgs>)
	:description("Kick a player")
	:arg(Types.Player, "target", "Player to kick")
	:arg(Types.String, "reason", "Reason shown to the player", { rest = true })
	:permission("moderator")
	:run(function(context, args)
		args.target:Kick(args.reason)
		context:reply(`kicked {args.target.Name}`)
	end)

What is Operator and who is it for?

It is for developers who would rather define commands than build an admin panel. You get a console with autocomplete and inline validation, a role system, and a log of everything that ran, without writing a remote, a UI, or a permission check.

Inside run, args.target is a Player and args.reason is a string. Arguments arrive as a checked table, not positional strings, so a typo in a handler is a type error rather than a runtime surprise.

Why should I use it?

Nothing reaches a player who is not allowed it. Operator does not put anything in ReplicatedStorage. When a player is authorised, the server builds a bundle for that player alone. A player allowed nothing receives no modules, no remote, and no interface. They cannot tell the package is installed.

Roles are configuration, not code. Declare them by group rank or user ID, inherit between them, and permissions resolve themselves. There is no hook you must write before anything works.

Arguments are typed and extensible. Nine argument types ship. Define your own with validation, transformation and autocomplete, and compose them on the built-ins.

Everything that runs is logged. Every dispatch produces a server-built record, successful, denied and malformed alike, with an in-memory log you can read in-game and pluggable sinks for anywhere else.

No dependencies. The core depends on nothing outside the package.

Why shouldn't I use it?

You want a large library of ready-made commands. Operator ships 14 across three packs: debug, moderation and fun. They cover the basics and double as worked examples, but everything beyond them you write yourself. If you want hundreds of commands out of the box, this is the wrong package.

You want to restructure the console. Every colour is yours. Pick one of the three built-in themes or pass your own table of the twelve tokens, all of which merge over the default. Layout is not: spacing, sizes, corner radii and the arrangement of the input, history and suggestion list are fixed. The boundary is exactly that: recolour freely, rearrange not at all. If you need a different shape, your real option is Client.Mount: Operator hands your module the command API and you build the whole interface.

You are not comfortable writing Luau. Commands, argument types and guards are all code. There is no in-game builder and no configuration-file route.

Your players are mostly on mobile or console. Touch players get a button and larger tap targets, but the console is fundamentally a text field. There is no gamepad navigation.

You need moderation history that survives a restart. The log is in memory and per-server by design. It is gone when the server shuts down, and one server never sees another's activity. Durable history means attaching an audit sink and storing it yourself.

You need something battle-tested. Operator is at v0.2.0. Two releases, limited real-world use, and the public API can still change in a minor version.

How do I get started?

Installation gets the model into your game. Setup takes you from nothing to a working console in four steps. After that, Commands is where the real work starts.

If you would rather see it first, The Console has a live console you can type into in the browser.

How do I get help?

• Troubleshooting: the console will not open, a command does not appear, and the other things that catch people out
• Discord: questions and help
• GitHub issues: bugs and feature requests

Stick to the official docs

Third-party tutorials on YouTube and the DevForum go out of date quickly, and an admin system configured from stale instructions can leave commands exposed to people who should not have them. If something here disagrees with a video, trust this site.

Glossary

These three are easy to confuse, so they are worth reading together:

Term	Means
package	Operator itself, as you install it: the model in ServerStorage
bundle	what one authorised player receives at runtime, built for them alone
console	the interface a player sees, opened with F2

And the rest, used consistently throughout:

Term	Means
log panel	the searchable log view inside the console
role	a named set of players, like moderator
argument type	something that turns typed text into a real value, like Types.Player
manifest	the list of commands a player's client is told it may display
client-reported	an audit record a client sent, rather than one the server observed