A game engine your CI and your AI assistant can drive.
Floptle has a command line. Find out whether a project loads, whether it runs, what it looks like and what is inside it, and change it correctly, without opening the editor. No window, and for everything except rendering a frame, no graphics adapter either.
Shipped in v0.70.1 · No account required · MIT OR Apache-2.0 · Windows, macOS, Linux
An editor is a window. A terminal is not.
A person can open the editor and look, which is the whole point of an editor. An AI assistant working in the same project folder cannot. It has a terminal and your files, and everything the editor knows, whether the scene loads, what the sprite looks like, why the script raised, sits behind a window it has no way to open. It is not slowed down by that gap. It is stopped by it, and it fails in the worst way available, by guessing.
Ask whether it works
floptle check resolves every reference in the project. A .ron file that parses is not a scene that works, and until now the only thing that could tell you the difference was opening the project.
Actually play it
floptle run plays the project with no window, real scripts and real physics, and reports every warning, error and print with its file and line. Pointed at a real game it found a script indexing a nil value on the first try.
See what it looks like
floptle shot renders one frame to a PNG through the same path the editor's Game view uses, post-processing and all. What lands in the file is what the editor would show you.
Seven commands, and two things you need to know before running any of them.
Whether a command needs a display, and whether it will write into your project. Both travel with the command in the engine's own machine-readable description, because a caller that cannot see the source needs to know them before it runs anything in a container or over SSH.
| Command | What it does | Needs a display | Writes to your project |
|---|---|---|---|
floptle check |
Loads every scene, prefab, effect and material and reports every reference that does not resolve: a parent pointing at the wrong node, a material naming a texture that is not there, a node carrying a script with no file behind it. | no | no |
floptle run --frames 120 |
Plays the project for a fixed number of frames with no window at all, real scripts and real physics, and reports every warning, error and print with its file and line. Exits non-zero if anything raised. | no | no |
floptle shot --out look.png |
One frame through the scene's active camera, straight to a PNG, through the same rendering path the editor's Game view uses and with the project's post-processing applied. | yes | no |
floptle inspect --json |
What the project is, its scenes as a tree, or one node's whole document. It reads the files, and builds the hierarchy the way the engine does rather than the way the file happens to be ordered. | no | no |
floptle exec fix.lua |
Runs a Lua file against the project through the same scripting API the editor's own extensions use. Node ids, parent links and defaults come out right because the same code does it. | no | yes |
floptle api setSprite |
Every name a script can reach, with what it does and an example, searchable by part of a name or by a word from the description. Exits non-zero when nothing matches. | no | no |
floptle help --json |
The whole surface as one document: every command, its arguments, the values each accepts, what comes back, and what each exit code means. Generated from the same table the parser is built from. | no | no |
Every flag that worked before still works. --export, --new, --migrate, --play and --version are unchanged; the verbs sit alongside them. If you drive Floptle from a script today, nothing you wrote has to change.
Two commands, honest exit codes, no display.
Headless CI for a game project usually means fighting the engine: warming an import cache first, filtering scary error lines out of the log, and working around a runner that exits zero when your tests failed. These two are meant to be put in a pipeline.
Exit codes are stated rather than incidental: 0 success, 1 the operation ran and failed, 2 a usage error, and a verb may document more of its own. Every code a verb can return is listed in its entry in floptle help --json, so a pipeline can branch on them instead of grepping output.
check and run need no graphics adapter at all. shot does, because it renders a real frame: a Vulkan, Metal or DirectX 12 adapter. On a machine with only OpenGL it says so and stops rather than looking like a crash.
An interface that describes itself.
Most engine integrations for AI assistants are editor plugins: the editor has to be open, and a protocol server is hand-maintained against a GUI. Floptle went the other way round. One verb table is the single source of truth, and the parser, the help text and the machine-readable spec are all generated from it.
Read the interface once
floptle help --json emits the whole table: every verb, every flag, every exit code, every output schema. An assistant reads it once and knows the surface, instead of scraping help text. It cannot describe a command that does not exist, and a command cannot exist without appearing in it.
Every project explains itself
floptle new writes an AGENTS.md at the project root: which commands exist, what the folders are for, and two things about scene files that otherwise cost an afternoon. Written once and never touched again, so edit or delete it freely.
Edit through the engine, not the files
floptle exec runs Lua against the project through the editor's own scripting API. Node ids, parent links and defaults come out right because the same code does it. Nothing is written unless the script calls ed.saveScene(), and if it changes something and forgets, the run tells you.
A mistyped flag gets corrected
An assistant that types --platfrom and gets a suggestion recovers in one step. The same assistant against a parser that answers unknown argument gets an exit code and a guess.
There is no MCP server yet, and that is a decision rather than a gap. A protocol wrapper generated from the verb table is a small job once the table exists; a second hand-maintained surface is a large one forever. The command line is the interface, and anything else gets generated from it.
Your players get none of this.
Floptle ships as one binary, so an exported game contains the same code. A manifest sitting beside the binary already marks that process as a game, and with it present the developer verbs are not offered and not accepted. A player's build should no more expose floptle exec than it should open the Inspector.
The honest list.
- There is no
floptle serveyet. The dedicated server still has its own command line. checkreports problems but does not fix them.--bake-gistill opens the editor to do its work, despite what its help says.floptle shotneeds a Vulkan, Metal or DirectX 12 adapter. Everything else works with no graphics adapter at all.- Existing projects do not get an
AGENTS.md. Only new ones. - Floptle is pre-1.0. This is a young engine, and the command line is one release old.
Common questions about the Floptle CLI.
Does the Floptle command line need the editor open?
No. Every command runs as its own process with no editor and no window. Only floptle shot needs a graphics adapter, because it renders a real frame; check, run, inspect, exec, api and help all work on a machine with no display and no GPU at all, which is what makes them usable in a container and over SSH.
Can an AI coding agent use Floptle?
That is what the command line was designed for. An assistant working in your project folder has a terminal and your files; everything else an engine knows is behind a window it cannot open, so without a CLI it has to guess. With one it can ask whether the project loads (floptle check), play it and read the actual error with its file and line (floptle run), look at a frame (floptle shot), read the scene tree (floptle inspect), and make structural edits through the engine's own API rather than by hand-editing scene files (floptle exec). floptle help --json describes the entire surface in one document, so an agent reads the interface once instead of scraping help text.
Does Floptle have an MCP server?
Not yet, and deliberately so. The engine's decision record on this is explicit: the CLI is the interface, and anything else is generated from the same verb table. A protocol wrapper built from that table is a small job once the table exists; a second, hand-maintained surface is a large job forever. That is the opposite order from most engine integrations, which bolt a protocol server onto a GUI and then maintain it by hand.
Can I use it in CI?
Yes. floptle check and floptle run are both safe in a build pipeline, neither needs a display, and both exit non-zero when something is wrong. Exit codes are stated rather than incidental: 0 is success, 1 means the operation ran and failed, 2 is a usage error, and a verb may document more of its own. Every code a verb can return is listed in floptle help --json.
Will this break the flags I already use?
No. Every flag that worked before still works. --export, --new, --migrate, --play, --version and the rest are unchanged, and the verbs sit alongside them. If you drive Floptle from a script today, nothing you wrote has to change.
What is the AGENTS.md that floptle new writes?
AGENTS.md is an open standard for telling an AI assistant how a project works, read natively by a long list of agent tools. floptle new writes one at the root of every new project: which commands exist, what the project's folders are for, and two things about scene files that otherwise cost an afternoon. It is written once and never touched again, so you can edit or delete it freely. Existing projects do not get one.
Can a player run these commands against a shipped game?
No. Floptle ships as one binary, so an exported game contains the same code, and a manifest sitting beside the binary marks that process as a game. With it present the developer verbs are neither offered nor accepted. A player's build should no more expose floptle exec than it should open the Inspector.
What is still missing?
There is no floptle serve yet, so the dedicated server still has its own command line. check reports problems but does not fix them. --bake-gi still opens the editor to do its work despite what its help says. And floptle shot needs a Vulkan, Metal or DirectX 12 adapter; on a machine with only OpenGL it says so and stops rather than looking like a crash.
The command line comes with the engine.
The Hub installs Floptle and keeps it updated. The floptle binary is the engine, the editor and the command line in one file, which is why a build in CI runs exactly the code the editor's own dialog runs.