Crate geop 

geop: the kernel on the command line.

geop compile part.geop builds a program — the JSON the web editor saves (see Program) — and writes the part it makes with the exporter the editor offers for the output’s extension (see geop_cad_base::outputs), told the options given as -O key=value — by default in the first format the editor offers, its STL mesh — the parts it places included, each where it is placed, read from the program files next to it.

geop prebuild builds programs on several threads at once, each in a kernel of its own, keeping what each builds beside its file, so that opening them next builds nothing of them (see prebuild).

geop serve is the other way in: the same editor the web app runs, as a process a front end spawns and talks to over stdin/stdout (see serve). geop mcp is that editor as a Model Context Protocol server, for an agent to drive (see mcp). geop open serves that editor to a browser, editing a folder of files (see open), geop app shows it in a window of its own (see app), and geop vscode installs the VS Code extension of this release (see vscode).

Modules

app 🔒

geop app [DIR | program.geop]: the web editor in a window of its own, editing the files of the folder DIR on the kernel of this process.

mcp 🔒

geop mcp: the editor as a Model Context Protocol server.

open 🔒

geop open [DIR]: the web editor in a browser, its kernel this process and its workspace the folder DIR.

release 🔒

The GitHub release this build of geop belongs to, and its files, as .github/workflows/release.yml names them and homepage/install.sh fetches them: every file listed with its SHA-256 in SHA256SUMS, and nothing downloaded is used before its sum is checked.

session 🔒

One editor (see geop_core_editor::editor) answering commands of the JSON protocol, one line each: what geop serve runs over stdin/stdout and geop open over a WebSocket.

vscode 🔒

geop vscode: install the VS Code extension of this very release — the one whose kernel and page speak this build’s protocol — into VS Code, or an editor built on it (Cursor, VSCodium).

Structs

Cli 🔒

CompileArgs 🔒

Compiled 🔒

What a compile wrote, for the report.

Disk 🔒

The program files on disk, by their paths.

ExamplesArgs 🔒

McpArgs 🔒

PrebuildArgs 🔒

ServeArgs 🔒

Enums

Command 🔒

Functions

build 🔒

The program at path, built, its parts where its mates hold them, and the mates the program’s state did not hold. A stale state — a file it places changed since it was saved — is solved for here, not in the file: that is the editor’s to write.

compile 🔒

default_output 🔒

program’s path with its extension replaced by the first format the first exporter offered writes: part.geop becomes part.stl.

export_examples 🔒

Write every built-in example as <out_dir>/<name>.geop and its part <out_dir>/<name>.stl, in the default format (see default_output) — and every example of several files as those files in <out_dir>/<name>/, its first one compiled — via compile, so an example’s part is written exactly the way any other program’s would be.

main 🔒

options 🔒

The exporter options pairs give, key=value each, as JSON: each value read as JSON, or else as text.

prebuild 🔒

Builds args.programs, args.jobs at once, each on a thread of its own in a kernel of its own — a kernel shares nothing with another thread — keeping what each builds beside its file (build): the cache files are what the threads share. Says, of each, what its build did, or why it failed.

serve 🔒

Run one Session until stdin closes: every line is a command, and the answer is one line (see session). After a panic the process ends: the front end starts another with the program it holds (vscode-extension/src/server.ts), rather than waiting for an answer that never comes.

today 🔒

Today’s date, YYYY-MM-DD (UTC): what an exported file is dated.