Changelog

• Opt into the experimental v2 transport with --transport=v2 or ELIDE_TRANSPORT_V2=1. An explicit --transport flag takes precedence; auto keeps the existing default.

• Serve static files faster, with cached-file revalidation.
• Reduce HTTP request overhead with native HTTP/1 parsing and response encoding for transport v2, cached URL parsing and header names, and fewer per-response allocations.
• Reduce JavaScript allocation and execution overhead in URL, header, buffer, and filesystem operations.
• Start faster and download a smaller distribution.

• Collect CLI profiler results after asynchronous work and exit handlers finish, including Python project entry points.
• Print profiler results when a long-running program is stopped with Ctrl+C, with bounded shutdown reporting.
• Show expected build-tool failures as user-friendly errors instead of stack traces or crash reports, and render Java and Kotlin compiler diagnostics consistently in direct tool calls and project builds.

• Start JavaScript programs faster: a Linux release benchmark cut elide run hello.js from 31 ms to 7.7 ms.
• Serve more HTTP requests: the Linux echo benchmark improved 4.5×, from 25K to 114K requests/sec at 256 connections. Static and development servers also reuse HTTP/1.1 connections for faster repeat requests.
• Download smaller distributions while keeping Java and Kotlin compilers, formatters, and other JVM tools included by default.
• Run JavaScript tests with less overhead and lower memory use after tests finish. Programs using buffers, URLs, events, timers, and console output also allocate less memory.
• Keep native HTTP and WebSocket services within a bounded number of background threads under load.

Development Server

• Attach a debugger to tests with elide test --debugger: use Chrome DevTools for JavaScript/TypeScript tests or a JVM debugger for Java/Kotlin tests. Select a JVM port with --debugger=5005.
• TAP test reports include test-start events and associate output with the test that produced it, helping editors show progress and diagnostics.
• Limit JavaScript/TypeScript workers and open node:fs handles with --limit=workers=COUNT and --limit=fds=COUNT on scripts and elide run. Limits include descendant workers; --timeout requests cleanup of the script and its workers.
• Select trusted execution with --sandbox=trusted and explicitly control native access with --allow-native or --no-native. Bare --sandbox keeps its filesystem-only behavior.
• Pin a nightly manifest schema at pkl.elide.dev/<version>-<stamp>/project.pkl; Elide rejects stamps that do not match its embedded build.

Debugging tests · Permissions and resource limits · Manifest reference

• Bundled JVM tools work through the standard macOS installation: elide javac -- -help, Java compilation, and other JVM tool commands no longer incorrectly report that jvmtools is missing when elide is launched through an installation symlink. No separate toolchain installation is needed.
• Keep filesystem, network, and subprocess permissions scoped to each workload, including its workers and background file operations, so one workload’s settings do not change another’s access.
• Cancel an HTTP request without a late cancellation interrupting an unrelated request.
• JVM debugging now listens on 127.0.0.1 by default. For remote attachment, set an explicit address such as --debugger=0.0.0.0:5005. Invalid debugger options are rejected instead of silently running without a debugger.
• Keep update notices out of redirected stderr and CI logs, and report timeout errors in the selected language.
• Fix elide classpath -q. Tool wrappers reject misplaced --version; pass tool flags after --, as in elide jar -- --version. Formatter help explains how to check without rewriting files.
• Copy code snippets throughout the docs with a dedicated copy button.

CLI reference

• New elide adopt command adopts Elide in an existing project through Claude or Codex; every prompt can be answered up front for non-interactive use.
• Typed build flags: --flag=NAME[=VALUE] or -fNAME on every project-aware command, read from build.flags in the manifest. See Build Flags.
• An ES module that exports a fetch handler runs as a server under elide run, elide serve, and elide dev; interactive serve and dev show the serving TUI for scripts.
• Native builds route fetch and Elide.serve through a native HTTP transport: HTTP/1.1 and HTTP/2, streaming bodies, cancellation, graceful shutdown, and HTTP proxy support. elide info reports the active backend.
• elide test --reporter tap emits one TAP 13 stream for JavaScript and JVM tests; --reporter-outfile writes .tap files.
• Capture JFR recordings and heap dumps with --jfr, --jfr-settings, --heap-dump, and --heap-dump-on-oom, or familiar -XX: options; see elide help instruments.
• Inspect running native processes with jvmstat and the JDK's jcmd on Linux and macOS: start and dump recordings, capture heaps, and print thread stacks.
• Profile JIT-compiled guest code with --jitdump and Linux perf.
• Elide-specific JFR events record runtime boot, guest program start and exit, and HTTP request lifecycle.
• Debugger listeners bind to configurable hosts and ports.
• The project manifest Pkl schema is published per Elide release at pkl.elide.dev/<version>/, for editor tooling and amends clauses; a manifest may pin one of those versions, and a pin newer than the Elide evaluating it is read with that Elide's schema.

• elide run sent a JVM program's stdout to stderr. Guest output is now written to Elide's own streams byte for byte, redirected output is free of ANSI, and --no-color and --quiet apply to build output.
• elide run --debugger no longer starts an unrequested MCP endpoint; the inspector identifies itself as Elide, suspension messages are clearer, and an errant flag warning is gone.
• --version and --help-all work on commands with required arguments, and --help-all describes the selected command rather than the root.
• --debugger and --profiler are global like the rest of the diagnostics flags; --quiet no longer suppresses manifest, project info, or project advice output; stale flags were removed from help.
• elide test rejects unknown --reporter values, parses -t=pattern, skips vendor/, resolves the project from a named test path, and skips JVM tests when paths match only JavaScript tests.
• elide init prints a diagnostic on every non-interactive failure path.
• elide javaformat --list-diffs no longer rewrites files in place, and elide mvn locates Maven home.
• Node: node:test files run outside elide test fail with an error instead of being skipped silently; scrypt accepts derived-key lengths below 16; performance.measure uses a named start mark; queuing strategy size is read correctly; spawnSync applies inherit and ignore stdio; dns.lookup with all; unknown node: imports throw; performance.nodeTiming and timeout messages match Node.
• Ticks and microtasks now run after each timer callback, matching Node's ordering; stream destroy callbacks run at the correct time.
• Context scheduling handles creation failures, shutdown races, and full callback queues.
• --profiler=memtracing no longer aborts at startup.
• Maven module dependencies are added to the elide native-image classpath; a build fails when it references a missing artifact.
• The apt repository's signing key verifies on current Ubuntu releases.

• Native builds on Linux and macOS arm64 allocate through one mimalloc core across Rust, C, and runtime unmanaged memory.
• The JVM toolchain is in a shared library beside the binary, loaded on demand; the main executable is smaller.
• Terminal rendering moved to a single Rust renderer, replacing the vendored JVM terminal libraries.
• The elide help corpus is a separate file at doc/elide-docs.bin beside the binary; ELIDE_DOCS overrides its location.

• Upgraded the Rust toolchain to 1.100.x and LLVM to 23.x.
• New guides: Monitoring and Profiling, Build Flags, VS Code and IntelliJ plugins, native Maven, architecture tours, and a generated embedded-versions page.

• fetch reads Node's TLS environment variables: NODE_TLS_REJECT_UNAUTHORIZED, NODE_USE_SYSTEM_CA, and NODE_EXTRA_CA_CERTS.

• The REPL handles newlines correctly and no longer renders multiline prompts incorrectly.

• The embedded Python runtime and bundled standard library target Python 3.13.
• The bundled Kotlin compiler is updated to 2.4.10; the Java toolchain targets JDK 25.
• elide:crypto, elide:fs, elide:net, and elide:process now match their node:* modules. Compression remains available through node:zlib and the Compression Streams API; there is no elide:compression module.
• Buffer, timer handles, process and OS data, performance APIs, async context and abort behavior, TLS, and other Node compatibility were expanded or corrected.
• process.env can be replaced, and process.loadEnvFile([path]) explicitly loads dotenv files.

• node:zlib adds Zstandard support, stream constructors, crc32, and codes.
• node:util adds formatting, callbackify, inherits, deep equality, deprecation and debug helpers, system-error helpers, ANSI stripping and styling, and dotenv parsing.
• PerformanceObserver.supportedEntryTypes includes function, and the module loader exposes node:http and node:tls.

• The CLI, project, installation, and language guides were consolidated and verified against the 1.5 binary.
• Server guidance now reflects the static and development servers' observed 3000 default.

• elide mvn --flavor spring@<version> selects a native Maven image specialized for a Spring Boot line. Without the flag, the project's POM is read for its Boot version and the matching image is chosen, or the generic one if none matches.

• elide upgrade --channel=nightly no longer offers a build to itself as v1.4.6 -> v1.4.6. Both sides of the message include the datestamp and commit that identify a nightly, so the running build and the candidate are distinguishable.
• elide javaformat and elide ktfmt walk directory arguments.
• elide init no longer requires a TTY for the documented non-interactive run.
• elide serve --host is applied.
• elide install --with rejects unknown classifiers.
• elide test runs sequentially by default on both engines.

• The distribution no longer bundles native Maven images. elide mvn installs the image it needs on first use.

• elide --help now groups commands under four headings and hides ten rarely used commands; --help-all prints everything.
• A --profiler=memtracing mode that uses the runtime memory tracer.
• Build tools record their argument vectors as <tool>.args beside primary outputs — javac and kotlinc as well as native-image — and the recorded argfiles are inputs to the build cache.

• All manifest evaluations now share one execution layer, fixing "invalid sharing of AST nodes" errors on a second manifest evaluation.
• Precompiler diagnostics are scoped per operation, so concurrent precompiles no longer report each other's errors.
• Maven POM profiles activated by <activation><condition> expressions now evaluate correctly.
• Mutable multipath container operations are implemented rather than stubbed.

• elide test runs in parallel on both engines: --concurrency defaults to one worker per CPU (test files for JavaScript, test classes for the JVM), --concurrency=1 forces a sequential run, and --concurrency=0 is rejected at parse time. Discovery overhead is reduced, and JVM tests are no longer recompiled on every invocation.
• Coverage is now opt-in on both test engines: collection happens only when --coverage is passed or the manifest enables it, and the manifest default is now off.
• elide install installs Maven dependencies and nothing else by default; a neighboring package.json, pyproject.toml, or requirements.txt produces a one-line note on stderr, and --ecosystems=<names> installs other ecosystems. uv is no longer bundled.
• The default elide test --coverage report is a rollup summary; per-file rows appear with --verbose.
• The download is roughly 30 MiB smaller.

• elide agent, commands for AI coding agents: agent help prints documentation as Markdown on stdout, agent diagnostics reports status (with --json), and agent bug assembles a bug report. elide help <topic> --format=markdown works everywhere, and elide help no longer panics for non-interactive callers.
• Elide detects when an AI coding agent is running it and switches to plain output — no ANSI sequences, no frames — in both the parsing and rendering layers.
• elide install writes resolved classpath files to .dev/dependencies/m2/{compile,runtime,test,processors}.classpath, in the same format elide classpath <usage> prints, so external tools can read a classpath without invoking Elide.
• Distributions include the Apache-2.0 LICENSE and NOTICE.

• elide format on Java silently did nothing in write mode — formatted output was discarded instead of written back — and check/dry-run modes mis-reported results for both Java and Kotlin.
• elide test <path> treats paths as a real filter: zero matches now fails and names the paths, and the JVM engine no longer runs the whole suite unfiltered while reporting success. A package-like bare token maps to a JUnit package selector, and an existing path always takes precedence, resolved against the project root.
• -t/--test-name-pattern performs the documented unanchored search on the JVM engine, and an empty filtered run exits non-zero.
• elide run <name> follows a total, documented resolution order — source file, then elide.pkl scripts, then package.json/pyproject.toml scripts, then node_modules/.bin/<name> — and produces a real diagnostic when nothing matches.
• elide build <target> accepts the documented target groups, and elide install --with is applied.
• elide classpath errors on an unparseable usage spec instead of silently returning the main compile classpath, and Maven exclusions are applied.
• --timeout starts before fast-path dispatch, so it now applies to repl, serve, dev, help, agent, and init.
• elide serve defaults to the documented port 8080, kotlinc accepts --max-errors, and a mistyped subcommand produces a clear error.
• --no-color, NO_COLOR, and TERM=dumb apply to the help masthead and progress output; a shared terminal check lets elide init < /dev/null exit cleanly; and the REPL reads piped stdin.
• Usage errors have their own exit code, distinct from guest failures, and error color is used only on a real terminal.
• process.exit codes are preserved on the inline-snippet path, and top-level -c snippets match CPython argv semantics.
• Retired subcommand names fail gracefully.
• Test discovery never descends into hidden directories, and a failing JavaScript test file prints its failure message.
• Python zoneinfo resolves timezones; constructing any ZoneInfo previously raised.
• A producer failure mid-body on a streamed HTTP response aborts the response instead of hanging the client.
• macOS/arm64: unwind information is preserved for native frames, so an exception thrown through a native frame no longer aborts; the mach exception port no longer leaks into child processes; and the crash handler is async-signal safe.
• Image compression entrypoints return cleanly instead of failing to link at runtime.
• elide install no longer recurses into its own post-install step and deadlocks an npm install.
• Diagnostics carry source identity across the native bridge, logging configuration is safe for concurrent readers, and log levels resolve by longest matching prefix.
• IPC socket writes are flushed to the peer, socket files are unlinked on drop, and a listener only unlinks the socket it bound.
• Builds without Python fail on an empty compile classpath instead of producing many "package does not exist" errors.
• The default container base image is pinned.

• The jib, aube, uv, pro, and s3 subcommands are permanently retired, along with the telemetry, cloud, sidecar, and licensing subsystems; their documentation is removed across locales. python, javap, jdeps, javadoc, native-image, and manifest are unaffected.
• Distributions no longer include duplicate or unreachable files.
• Kotlin language and API level are now 2.4.

• The Homebrew tap now receives an automatic version bump for each nightly release.

• elide test is now one test runner for every language: JavaScript and TypeScript tests are discovered with no configuration (no elide.pkl required) and run alongside JVM tests as one reported run — one tally, one exit code, one XML report format, one coverage table.
• JUnit console output uses the build display's format.
• elide lsp supports Java, with google-java-format integrated.
• pom.xml is accepted as a foreign project manifest.
• Elide's own CI now checks Java and Kotlin formatting with elide format.
• The native-image argument vector is recorded beside image outputs.

• TypeScript entry metadata.

• Dependency resolution — including classifier JARs from Maven Central — moves off the Elide Classic bootstrap and onto the managed toolchain via elide install.
• JVM code can execute inside the parent elide process; opt in with SPAWN_PROCESS=false in native mode.
• TextDecoder uses encoding_rs; URL setters work, XMLHttpRequest accepts data: URLs, and fetch() resolves relative URLs.

• Dependency updates across ecosystems include upstream security fixes.

• Native-image task cache keys now fingerprint the contents of configuration inputs, so editing reachability metadata under -H:ConfigurationFileDirectories or regenerating a profile correctly invalidates the cached image; previously only the flag text was tracked.
• Native-image output and configuration paths are relative to the resolved project root, configuration and linker inputs are fingerprinted through symlinks and external paths, and the complete JVM conf tree — including java.security — is packaged.

• Windows builds work natively: the builder no longer forces container mode on Windows and prefers a resolved native binary, postinstall resolves elide from the PATH, and the docs build script runs on an explicit 32 MiB stack.

• Java and Kotlin source files run directly with elide run.
• elide run executes scripts declared in elide.pkl, package.json, and pyproject.toml.
• Every legacy encoding in the WHATWG Encoding Standard for TextDecoder — the single-byte families (windows-125x, iso-8859-*, koi8-r/u, macintosh, and others) and the multi-byte CJK encodings (gbk/gb18030, big5, euc-jp, iso-2022-jp, shift_jis, euc-kr) with spec-correct streaming and error semantics.
• A Spring shorthand for JVM dependency declarations.
• Generic XML test reports.
• Elide itself can be built without Python support via --no-python.

• Maven dependency resolution now records the full dependency graph instead of a spanning tree, so shared transitive dependencies resolve correctly in multi-scope projects (for example Spring apps).
• JVM build task-graph fixes: javac targeting prefers --release and falls back to the default release when unset, -parameters is always passed, Kotlin tasks only run when Kotlin sources exist, and run-task resources resolve correctly.
• Worker threads now report their real script path via __filename, __dirname, and process.argv, and an entry module that imports itself resolves to a single module instance by canonical path.
• Ctrl+C now interrupts elide init.
• Arguments after -- are forwarded to JVM programs resolved from the project manifest.

• Build targets may be named without a prefix.
• --no-cache also skips local build state.
• macOS distributions carry all eight executables, and bundled dylibs are ad-hoc signed.
• The documentation site is completely rebuilt.

• node:net: TCP and Unix-domain sockets and servers with DNS resolution and Happy-Eyeballs dialing, plus BlockList and SocketAddress.
• node:dgram: UDP sockets covering unicast, connected, broadcast, and multicast transports with full socket-option support.
• node:child_process: the whole spawn family (spawn, exec, execFile, their sync forms) and fork with a working IPC channel, controlled by new --allow-run / --deny-run sandbox flags.
• Python support in watch insight scripts and targets, plus insight throw hooks, error capture, and argument destructuring.
• The error-stack accessor proposal is now enabled for JavaScript.

• node:vm contexts now bind this and globalThis to the sandbox and hide the internal contextify marker; node:buffer populates buffer.constants and validates allocation sizes with coded errors; process.argv[1] and __filename resolve to the real script path.
• Python: crash loading the time module, -m module parameter passing, and buffered stdout/stderr now flushing on exit across all eval paths.
• CLI: plain, parseable error output on non-interactive terminals, and the REPL accepts experimental options on language-probe engines.
• Dependency installation: npm overrides no longer corrupt install data, and package.json parsing handles previously failing edge cases.
• MCP and insights: attach failures are reported, in-flight requests are processed when stdio closes, source-path errors are clearer, and deeply nested values render completely.

• The linux-amd64 binary runs on older Linux distributions again.

• Broader Node.js compatibility, including node:path, process behavior, node:assert, node:util, node:test, module shims, stream behavior, and worker-thread support.
• An elide python subcommand with CPython-style flag compatibility.

• JavaScript module loading, CommonJS resolution, worker-thread runtime ownership, structured clone and message ports, stream lifecycle behavior, fetch URL resolution, and catchable guest errors for out-of-CWD module failures.
• Embedded native-image operation, embedded JVM staging, Pkl engine isolation, and Python builtins imports.

• NPM platform packages now download the Elide binary during install instead of bundling very large tarballs.

• Updated the runtime and toolchain base, the managed toolchains, and the profile-guided optimization configuration.

• Packaged installer support around embedded aube for NPM and uv for PyPI, with unified install smoke coverage.
• Local JAR dependencies for JVM projects.
• MCP insight and debugging tools, including project/build inspection and guest-code execution support.
• JavaScript conformance hooks: global print, plain scriptable error output, and $262 host API support for Test262 tooling.
• Web templates for elide init.

• The docs Examples button, by adding the backing code samples page.
• elide run for spawned JVM processes that read from stdin.
• MCP HTTP mode and high-level insight scripting behavior.
• javaformat and ktfmt helper handling for @argfile arguments.
• Several installer and snippet-runner issues.
• Embedded javac compatibility with ambient CLASSPATH defaults and DocLint reflection behavior.
• Runtime error reporting for module-resolution failures.
• Python home selection.
• Temporary writes, moved into a dedicated process directory that is freed on exit.
• NPM publishing reliability, by freeing disk space and reporting publish errors.

• Java ABI output for mixed Kotlin and Java source sets in elide kotlinc --abi-only.
• Bazel-aware Kotlin compiler diagnostics and project-relative source paths.
• node:fs and node:fs/promises support with a filesystem capability sandbox.
• A docs "File an issue" action, with fixed mobile layout for page actions.

• Explicit elide kotlinc --plugins=<suite> selections now take precedence.
• elide upgrade now downloads the full archive, not only the binary, when resources are needed.
• Docs crawler and discovery files, and robots behavior.
• NPM publishing, by moving @elide-dev/elide publishing into a dedicated, testable workflow.

• Disabled telemetry, cloud, and sidecar by default behind optional Cargo features.

• Kotlin Build Tools API work for Elide JVM builds.
• Pro i18n support.

• Kotlin incremental compilation behavior, with digest-driven invalidation, heap sizing, and classpath-default handling.

• Cached warm javac classpath state in persistent workers to reduce repeated classpath indexing.

• Python interop, Python 3.12 alignment, and sys.argv fixes.
• Native compression for gzip, Brotli, and Zstandard, replacing zstd-jni and brotli4j in the transport path.
• NPM distribution infrastructure for Elide binary packages.
• Publishing infrastructure for @elide-dev/types.
• Roll-up behavior for excessive Kotlin compiler diagnostics.

• Python cold start.
• Updated dependencies to address open security alerts.
• zstd JNI class registration on the dynamic dylib path.
• Native-image task output path semantics.
• Kotlin stdlib inclusion when Kotlin sources are present.
• Kotlin compiler API and language-version argument capture.
• Build-cache fingerprint corruption after cache restore.
• External native-image driver selection.
• JVM codegen, so build and version config stay in sync.
• Build-cache file attribute preservation.

• The Elide masthead in elide info.
• Channel and precise-version awareness to elide --version and elide info.

• Made elide upgrade channel-aware and cleaned up user-facing upgrade output.
• musl and LTO builds, by restoring Rust memory intrinsics via compiler-builtins-mem.
• License registration pages to use elide pro activate.
• The Windows installer, now syncing the staged Elide home instead of relying on stale hand-enumerated file paths.
• Python stdlib version resolution from the on-disk Python home layout.
• Native-image jdeps resource bundle inclusion for used-dependency reports.
• Docs for multiplex persistent-worker support.

• elide jdeps.
• node:crypto, Web Crypto digest behavior, and transparent tool passthrough.
• Reference and guide docs for remaining runtime and tooling topics.

• Automatic recovery from corrupt Kotlin incremental-compile caches.
• Bazel flags.
• Formatter check-mode output and Kotlin source counting.
• Generated Java projects, so they no longer include Kotlin dependencies.

• elide init template and metadata improvements, including inverted blocks, binary files, and conditional build/test/run invocation support.

• Installer script argument parsing and Unix executable permissions.
• Native-image localization configuration for ICU.
• Missing annotations for Java test compilations.
• A build-time nanoTime value that caused instant timeout behavior.