CLI reference

elide --help lists everyday commands; elide --help-all adds the Advanced group and every flag. elide help <command> prints that command’s section of this page.

Run and develop

run

Run a file, a named script, or the project entrypoint. Resolution order: Project setup.

elide run app.ts -- --port 3000

Java and Kotlin snippets are whole programs with a main; arguments after -- reach it:

elide run -l java -s 'void main() { System.out.println("hello from java " + (6 * 7)); }'
elide run -l kotlin -s 'fun main(args: Array<String>) = println(args.joinToString())' -- a b

hello from java 42
a, b

A Java snippet without a class or main fails with Could not find a top-level class/record/enum or a main in the Java snippet.; a Kotlin snippet without main fails with Could not find a `main` function in the Kotlin snippet; declare `fun main() { ... }`.

Debugger, profiler, and coverage flags: Diagnostics flags.

serve (alias start)

Serve a directory as static files, or a script that exports a fetch handler (Development Server).

elide serve ./public
elide serve server.ts -- --verbose

dev

Like serve, with the same flags, on port 3000. For a directory, HTML pages reload in the browser when files change; a script is not reloaded. --no-watch turns off watching and reload.

install

Install project dependencies.

repl

Start the interactive REPL. A bare elide in a terminal does the same.

python

Run Python like python; tokens after the script go to the program. Install it with setup first.

elide python script.py --flag-for-the-script

Interpreter flags (-B, -W, -m, …): Python options.

Build and test

build

Build what elide.pkl declares. Bare tokens name tasks (deps, compile, test, clean; leading : optional). Arguments after -- go to the subprocess.

elide build deps compile

test

Run tests, or only those under the given paths. JVM tests come from a test source set: src/test/java or src/test/kotlin by convention, or one declared in elide.pkl (see Source sets).

Debugging tests: Debugging.

format (alias fmt)

Format Java and Kotlin sources. Paths and formatter flags follow --: elide format -- src.

--dry-run (after --) checks without writing; it exits 1 if a file would change.

project

publish

elide publish [PROJECT...] [--to <name>] [--skip-existing] [--dry-run] [--sign | --no-sign] [--no-wait]
              [--allow-http-repositories] [--offline]

Builds the project’s JARs and installs them with a POM into the local Maven repository (~/.m2/repository unless publishing.maven.localRepository says otherwise). From a workspace root it publishes every project. From a member it publishes that member and every workspace project its POM depends on, so the coordinates it names are installed too. Every project is built, staged and signed before any is published, so a failure there publishes nothing; a failed upload can still leave the projects uploaded before it in place. Configure it in the manifest’s publishing block.

Naming workspace projects publishes exactly those, for example only the ones that changed since the last release: elide publish core util --to central. A workspace project they depend on but that isn’t named must already be in the target, at the version its manifest declares, or nothing is published. Projects you leave out keep their publishing configuration, so a later run can publish them again.

A version is in the target when its POM is in the local repository, when the remote repository serves its POM, or when the Central Portal reports it published. A Central deployment that was validated but not yet released doesn’t count. A lookup that fails for any other reason, such as refused credentials, stops the run instead of counting as missing.

Project export formats

elide project export --format=<json|pom|intellij> prints to stdout. Default json.

pom

Sibling projects become coordinate dependencies and local JARs system-scoped. exclusions and kotlinPlugins are omitted. Extra source roots use build-helper-maven-plugin.

intellij

Modules are named <project>.<sourceSet>. Paths are relative to root, the workspace or project root. Libraries resolve from localRepository (default .dev/dependencies/m2), so run elide install first. The IntelliJ IDEA plugin imports this model.

JVM toolchain

Elide bundles JDK 25 and Kotlin. Elide’s flags go before --; tool arguments follow it.

java

Run JVM programs, like java.

elide java -- -jar app.jar

javac

Compile Java, like javac. See Java Compiler.

Header generation runs in memory before javac attribution. The native library is a separate runtime dependency. See C header bindings for named groups, source-set selection, generation-only builds, and a complete example.

kotlinc

Compile Kotlin, like kotlinc. See Kotlin Compiler.

jar

Build JARs, like jar. See JAR Assembly.

Native toolchain

cc

Embedded C compiler and linker via LLVM. Compile one freestanding C17 translation unit to a host object or LLVM IR, or compile and link a function in memory with LLVM ORC LLJIT. Backend arguments follow --:

elide cc -- -c answer.c -o answer.o
elide cc -- -S -emit-llvm answer.c -o answer.ll
elide cc -- --run answer answer.c

Select exactly one output mode. A JIT result is printed to stdout; a successful invocation exits with status zero. The current command exposes object output, IR output, and in-memory linking rather than executable or shared-library output. See Embedded C compiler and linker via LLVM for the complete frontend contract and distribution support.

jextract

Generate Java FFM sources from C headers with the embedded OpenJDK generator. Generator arguments follow --:

elide jextract -- --output generated --target-package example.ffi --header-class-name NativeApi native/api.h

Common generator options are --output, --target-package, --header-class-name, -I, -D, and -l. elide jextract -- --help lists the bundled generator’s options. Compile the generated Java and provide the native library and native-access permission at runtime. For generation and compilation in one invocation, use javac --jextract.

See C header bindings with jextract for a complete shared-library example, symbol selection, library lookup, and FFM memory lifetimes.

Setup and tooling

elide agent commands are for coding agents and other non-interactive callers; see Elide for AI Agents.

elide agent perf --runs 5 --warmup 1 -- elide run hi.mjs

elide run hi.mjs (5 runs, 1 warmup)
  wall 83.4 ms ± 20.1  min 57.7  max 107.0
  cpu  user 15.8 ms  sys 33.1 ms
  rss  max 66.8 MiB
For servers, measure with wrk or oha and paste the results

The command after -- is a full command line, including elide. Report fields and flags in detail: Report a problem.

init

Create a project from a template. With no flags, opens an editor.

Templates: java, ktjvm, web-demo, web-simple, workspace (Kotlin library plus app).

adopt

Migrate the project in the current directory to Elide with an AI coding harness (Adopt an Existing Project). With no flags, it asks for each choice. Exits 0 when the harness succeeds, 1 when it fails or cannot start, 130 on Ctrl+C.

help

Read this documentation offline. A command name prints its section, a slug or title prints the page, and options lists every flag.

info

Show binary, platform, language, and network transport details. --cargo-lockfile prints the embedded lockfile.

upgrade

Update Elide.

setup

Install an optional component: elide setup python.

setup installs the component for the running version and never upgrades or downgrades Elide. elide upgrade keeps installed components. setup refuses package manager installs (Homebrew, apt, RPM, MSI, nix, snap); use the install script:

curl -sSL --tlsv1.2 elide.sh | bash -s -- --with-python

use

Pin a version in .elideversion and download it: elide use 1.6.0.

Versions are releases (1.6.0, v1.6.0) or nightly datestamps (20260921). --ignore-version runs this binary anyway.

lsp

Start a Language Server Protocol server over stdio. Serves Java; see Other editors.

mcp

Start a Model Context Protocol server. See Project MCP server.

Advanced

Listed by elide --help-all.

classpath

Print a resolved classpath for [<sourceSet>:]<usage>, e.g. test:runtime. Usages: toolchain, processor, compile, modules, runtime, provided. Default main:compile; an unknown usage exits 2.

index

Index the project’s resolved Maven dependencies and query that index. Actions: build, status (default), get <address>, references <address>, used-by <name>, resolve <name>. An address is maven:group:artifact:version, optionally followed by /symbol and #member; a member is name(paramType,...) for methods and constructors (<init>) and the bare name for fields. build writes the layers named by --layers (default l0,l1; l2 adds member signatures, l3 adds outbound references) beside any already built. get, references and resolve exit 1 for an unknown artifact, symbol, member or name, and 2 when a layer they need has not been built; run elide index build --layers=....

build also compiles main Java and Kotlin sources and refreshes their local reference index. references local:<project>/<type> reads a local class’s outbound references; used-by <type>[#member] prints matching package-relative local source files. Queries do not refresh those compiled references. See Dependency code index for examples and experimental scope.

javadoc

Generate Javadoc, like javadoc. Arguments follow --.

javaformat

Format Java with google-java-format, or with the Netflix jfmt dialect given --jfmt. Arguments follow --. Takes format’s --list-files and --list-diffs. See Formatting.

javap

Disassemble JVM bytecode, like javap. Arguments follow --.

jdeps

Analyze JVM class dependencies, like jdeps. Arguments follow --.

ktfmt

Format Kotlin with ktfmt. Arguments follow --. Takes format’s --list-files and --list-diffs.

mvn

Run Maven, like mvn: elide mvn -- package. See Native Maven.

native-image

Build a JVM program into a native executable. Arguments follow --. See Native Image.

rewrite

Run OpenRewrite recipes on the project’s main Java sources (experimental in 1.6.0). Recipes come from the bundled libraries and dependencies.maven.devPackages; dependency types come from the code index. elide rewrite --list prints available recipes; elide rewrite <name>… applies them in order. The default workflow compiles main sources and filters candidate files when recipe preconditions support it. See OpenRewrite for setup, examples, and compatibility limits. Exit 1 for an unknown recipe, 2 for a usage error.

web

Web tooling: elide web build app.ts page.md --out dist builds files without a manifest. See Web Toolchain.

Global options

Accepted before or after the command name, before any --.

Common flags

Configuration files

Application commands load .env then .env.local from the invocation directory. --project selects the project directory, including enclosing Elide projects. Existing environment variables win, including empty values. .properties and .properties.local supply Java system properties; explicit VM/engine assignments win. Properties use Java syntax, including escapes and continuations.

The current standalone Java run path can still read an automatic .properties file despite --no-properties. See the documented isolation limitation.

Explicit paths are relative to the invocation directory; later files win. A file flag and its disable switch cannot be combined. Missing automatic files are silent; malformed or explicitly missing files fail.

Both formats accept dotenvx encrypted: values. Supply private keys through DOTENV_PRIVATE_KEY* or .env.keys beside the selected files. Key files are read only when decryption is needed and are never exported as application variables. The dotenvx CLI’s file authoring format remains dotenv; Java properties files use unquoted ciphertext as property values. Shell substitutions are not executed.

Use ${NAME} for dotenv interpolation. Properties and decrypted payloads are not interpolated. File loading does not grant additional manifest environment access or sandbox capabilities. In JVM mode, file variables reach guest environment APIs and child processes; the already-running JVM’s own System.getenv() remains its launch environment.

Automatic discovery applies to application and project execution commands, not every standalone tool. Explicit file flags also select a context for tool commands. See Environment and properties for the exact command scope, project-directory layering, per-file interpolation, encrypted-value authoring, key lookup order, and examples.

Sandbox flags

Programs run unconfined until you pass a sandbox flag. See Sandbox.

Diagnostics flags

Version flags

Advanced flags

Python options

CPython flags; put them before the script.

Network transport

Instruments

Exit codes

Once a timeout starts terminating the process tree, its 124 status takes precedence over child exit codes produced during cleanup (for example, 137 after SIGKILL).

Output streams

• Program output, test reports, and machine-readable output go to stdout.
• Progress and diagnostics go to stderr.
• Color is off when the stream is not a terminal. --color, FORCE_COLOR, or CLICOLOR_FORCE force it on; --no-color or NO_COLOR turn it off.
• --quiet hides progress only.