Browse the documentation

Early preview

Overview

The OpenEng Executor is a polyglot runtime wrapper, an operating-system-level sandbox supervisor and an exit-event system in one Rust-native tool. You operate it through one command-line tool, oee.

The Executor takes a built application, such as a compiled Go service, a multi-worker Python uvicorn service, a Java .jar application or a Node.js server, and packages it with its portable language runtime and its security policy into a single standalone executable. When that executable starts, a small native supervisor, oee-stub, verifies the binary's integrity, applies the policy you sealed into it, and launches your application transparently.

What the Executor does

  • One binary. Your application, its runtime (a standalone CPython, a minimal JRE or a Node.js binary) and its policy travel as one signed file. The host needs no interpreter, no container daemon and no matching system libraries.
  • Sandboxing. Optionally, kernel-enforced isolation of the filesystem, the network, system calls and process trees, on Linux, Windows and macOS, without root and without a hypervisor. See Sandboxing.
  • Native CPU and memory capping. You state the CPU and memory the workload may use, as a share of the machine ("10%") or an absolute amount ("1vcpu", "10GB"), strict or flexible. The cap is sealed into the signed binary and enforced on the whole process tree, with or without the sandbox. See CPU and memory capping.
  • Exit events of any type. Any condition can end the application cleanly: a duration, a schedule, a date, idleness, CPU or memory or disk utilization, a polled URL, an inbound request, a watched file, a dependency probe, another process, a probe command, a Kafka, MQTT, NATS or Redis message, an application checkpoint, or an operator. Rules combine under ANY or ALL. See Exit events.
  • State-preserving stops. When an exit event fires, the Executor stops the entire guest process tree, every worker and descendant, and leaves the binary, the logs and every file the application wrote intact on disk. See Stopping and exit codes.
  • Native auto-scaling with a built-in load balancer. When usage stays above your upper threshold, the supervisor starts another replica on another free port and balances traffic across all replicas; below the lower threshold, it scales back in. See Auto-scaling and load balancer.

Why the Executor

ProblemWhat the Executor does instead
Exit logic is embedded per language through SDKs, and fails when the guest deadlocks or a garbage collector thrashes.Timers, polling and process-tree termination run in the native supervisor, outside the guest's virtual machine, so a stop happens even when the application hangs.
Wrapper scripts stop only the immediate child and orphan uvicorn, Gunicorn or subprocess workers.The whole process tree is contained and stopped, with zero orphaned workers.
Isolating a single binary on a bare-metal host or VM needs a privileged container daemon.Unprivileged kernel primitives sandbox the binary directly.
Python wheels, virtual environments and JVM applications break on mismatched host interpreters and missing shared libraries.The runtime travels inside the binary and runs from a verified, read-only cache.
CPU and memory limits live in a container runtime, an orchestrator or a systemd unit, so each host has different limits.The limits travel inside the signed binary, and a percentage resolves against whatever machine the binary lands on.
Running a second copy under load needs an orchestrator, a process manager and a reverse proxy.Replica management and load balancing run inside the supervisor, on one host.

Built for small overhead and fast starts

The supervisor is 100% memory-safe Rust, compiled to a compact static executable with no glibc version coupling and no C or OpenSSL libraries. Its design targets: less than 3.0 MB added to a wrapped binary in its core variant, less than 15 ms of overhead to start a native or warm-cached workload, and less than 6 MB of RSS and less than 0.1% CPU at idle while polling an exit event every minute. Performance specifications lists every target with its conditions.

Platforms and runtimes

HostsGuest runtimes
Linux (x86_64, aarch64), Windows (x86_64), macOS (aarch64, x86_64), OCI and Docker containersNative binaries (Go, Rust, C, C++), Python 3.10 to 3.13, Java and Kotlin on JVM 17, 21 and 25, Node.js, Deno and Bun

Runtimes and adapters describes how each runtime is packaged and launched.

Availability

The Executor is in early preview — message us for access; Install lists the platforms and packages.

In this section