---
icon: material/ice-cream
title: "10x Engine Flavors: Compiler, Runtime, Runtime (JVM)"
description: "The 10x Engine ships as three binary distributions: the Compiler, which generates symbol libraries and loads extensions at launch, the Runtime native binary, and Runtime (JVM), the same run-only build packaged for a JVM and the only runtime available on Windows."
---

# Flavors
The 10x Engine ships as three flavors (i.e., binary distributions). All three read the same [config files](https://doc.log10x.com/config/yaml/) and run the same [pipelines](https://doc.log10x.com/engine/pipeline/). Two axes separate them: what the distribution can do (compile and run, or run only), and how the distribution is built (a JVM build, or an ahead-of-time native image).

|                     | JVM                                             | Native                                       |
|---------------------|-------------------------------------------------|----------------------------------------------|
| **Compile and run** | [:material-cogs: Compiler](#compiler)           | not buildable                                |
| **Run only**        | [:material-coffee: Runtime (JVM)](#runtime-jvm) | [:material-flash-outline: Runtime](#runtime) |

Three of the four cells ship. The fourth cannot be built. Compiling loads code at launch: the [jarfiles](https://doc.log10x.com/run/bootstrap/#jarfiles) launch argument reads extensions out of `.jar` files, and the [Compile](https://doc.log10x.com/compile/) pipeline generates [symbol libraries](https://doc.log10x.com/run/symbol/) while it runs. A native image is closed at build time: every class the binary will ever execute is compiled into it, and no class loader survives into the running process to add another one. So a distribution that compiles carries a JVM, and a native distribution runs only what was compiled into it before it shipped.

!!! note "Older flavor names"

    The installers accept the old spellings and print a notice: `cloud` maps to `compiler`, `native` maps to `runtime`, and `edge` maps to [`runtime-jvm`](#runtime-jvm), the jpackage JVM build it has always named.

    Bookmarks to the old `#cloud`, `#edge` and `#jit-edge` anchors still land on a live section. `#edge` lands on the native [Runtime](#runtime), the flavor the old *Edge* section documented, and `#jit-edge` lands on [Runtime (JVM)](#runtime-jvm).

### :material-cogs: Compiler

<a id="cloud"></a>

A JVM distribution, shipped as a container image (`log10x/compiler-10x`) and as OS packages carrying a packaged JRE subset. The Compiler holds every capability the Runtime holds, and adds the capabilities that require code loaded at launch.

Compiler only:

  - The [Compile](https://doc.log10x.com/compile/) pipeline, which generates [symbol libraries](https://doc.log10x.com/run/symbol/).
  - Dynamic loading of [input](https://doc.log10x.com/api/input/) and event/time-series [output](https://doc.log10x.com/api/output/) extensions from .jar files, via the [jarfiles](https://doc.log10x.com/run/bootstrap/#jarfiles) launch argument.
  - CloudWatch, Datadog, Elastic, Prometheus, log, and log10x [time-series](https://doc.log10x.com/run/output/metric/) outputs.
  - Log analyzer and object storage [input extensions](https://doc.log10x.com/api/input/).

:material-launch: Employed by the [dev](https://doc.log10x.com/engine/launcher/dev/), [function](https://doc.log10x.com/engine/launcher/function/), [job](https://doc.log10x.com/engine/launcher/job/), [trigger](https://doc.log10x.com/engine/launcher/trigger/) and [lambda](https://doc.log10x.com/engine/launcher/lambda/) launchers.

:material-docker: Install: the [Docker image](https://doc.log10x.com/install/docker/), `--flavor compiler` on the [single line installer](https://doc.log10x.com/install/singleline/), `TENX_FLAVOR=compiler` on [Windows](https://doc.log10x.com/install/win/), or the `log10x-cloud` cask on [macOS](https://doc.log10x.com/install/macos/).

### :material-flash-outline: Runtime

<a id="edge"></a>

A single-artifact [native binary](https://www.graalvm.org/latest/reference-manual/native-image/){target="\_blank"} built ahead of time, with a small footprint and a fast start. Every extension the Runtime can use is compiled into the binary, so the extension set is fixed at build time and the [jarfiles](https://doc.log10x.com/run/bootstrap/#jarfiles) launch argument does not apply.

The Runtime carries the reporter, receiver, retriever, MCP server, and CLI entry points, which covers the in-cluster and on-host [apps](https://doc.log10x.com/apps/).

The native binary is built for Linux and macOS only. Windows installs [Runtime (JVM)](#runtime-jvm) instead.

:material-launch: Employed by the [sidecar](https://doc.log10x.com/engine/launcher/sidecar/) launcher.

:material-console: Install: `--flavor runtime` (the default) on the [single line installer](https://doc.log10x.com/install/singleline/), or [Homebrew](https://doc.log10x.com/install/macos/) on macOS.

### :material-coffee: Runtime (JVM)

<a id="jit-edge"></a>

The same run-only build as the [Runtime](#runtime), delivered as an OS package with a bundled JRE rather than as a native binary: `.deb` and `.rpm` on Linux, `.dmg` on macOS, `.msi` on Windows. Same entry points, same pipeline stages, no [Compile](https://doc.log10x.com/compile/) pipeline. Against the native Runtime it trades footprint and start-up time for a JVM.

Two cases call for it:

  - **Windows**, which has no native Runtime artifact. Runtime (JVM) is the only way to run a reporter, receiver, retriever or MCP server on Windows without installing the [Compiler](#compiler).
  - Linux and macOS hosts where the native binary will not run, and the [Compiler](#compiler) is more than the job needs.

:material-console: Install: `--flavor runtime-jvm` on the [single line installer](https://doc.log10x.com/install/singleline/), `TENX_FLAVOR=runtime-jvm` on [Windows](https://doc.log10x.com/install/win/), or the `tenx-edge` package from the [releases page](https://github.com/log-10x/pipeline-releases/releases/latest){target="\_blank"}.

## :material-laptop: Platforms

| Platform                                   | [Compiler](#compiler) | [Runtime](#runtime) | [Runtime (JVM)](#runtime-jvm) |
|--------------------------------------------|-----------------------|---------------------|-------------------------------|
| :simple-linux: Linux `amd64` / `arm64`     | `.deb` / `.rpm`       | native binary       | `.deb` / `.rpm`               |
| :simple-macos: macOS Intel / Apple silicon | `.dmg`                | native binary       | `.dmg`                        |
| :material-microsoft-windows: Windows       | `.msi`                | none built          | `.msi`                        |

**Windows has no native Runtime.** No `tenx-*-windows-*-native` asset is built, so a request for `runtime` on Windows resolves to `runtime-jvm`.

The default flavor is the Runtime: the native binary on Linux and macOS, and Runtime (JVM) on Windows.

!!! note "musl (Alpine)"

    None of the three run on musl. The native binary links against glibc, and the JVM builds ship as `.deb` / `.rpm` packages, which Alpine cannot install either. Run the engine in a glibc container instead.

## :material-ice-cream: Features

The following table outlines the capabilities each flavor provides:

| Feature                                                                                          | Compiler                                                 | Runtime                            | Runtime (JVM) [^3]                                       |
|--------------------------------------------------------------------------------------------------|----------------------------------------------------------|------------------------------------|----------------------------------------------------------|
| OS                                                                                               | :simple-linux::material-microsoft-windows::simple-macos: | :simple-ubuntu::simple-macos: [^1] | :simple-linux::material-microsoft-windows::simple-macos: |
| [:material-cogs: Compile pipeline](https://doc.log10x.com/compile/)                               | :material-check-circle:                                  |                                    |                                                          |
| [:simple-fluentbit: Forwarder Inputs](https://doc.log10x.com/run/input/forwarder/)                | :material-check-circle:                                  | :material-check-circle:            | :material-check-circle:                                  |
| [:simple-elastic: Analyzer Inputs](https://doc.log10x.com/run/input/analyzer/)                    | :material-check-circle:                                  |                                    |                                                          |
| [:material-cloud-upload-outline: Storage Inputs](https://doc.log10x.com/run/input/objectStorage/) | :material-check-circle:                                  |                                    |                                                          |
| [:material-set-merge: Custom Inputs](https://doc.log10x.com/api/input/)                           | :material-check-circle:                                  |                                    |                                                          |
| [:material-chart-multiple: Time-Series Outputs](https://doc.log10x.com/run/output/metric/)        | :material-check-circle:                                  | :simple-prometheus: [^2]           | :simple-prometheus: [^2]                                 |
| [:material-set-split: Custom Outputs](https://doc.log10x.com/api/output/)                         | :material-check-circle:                                  |                                    |                                                          |

[^1]: Linux support covers Ubuntu variants only.
[^2]: Supports [Prometheus](https://doc.log10x.com/run/output/metric/prometheus) and [log](https://doc.log10x.com/run/output/metric/log/) time-series outputs.
[^3]: Runtime and Runtime (JVM) come from the same run-only build, so they carry the same pipeline stages. They differ in packaging, footprint and start-up time, and in which platforms have an artifact.

## :material-package-down: Flavor names and file names

The flavor name is what you type. The file name on the release page is a separate string, and that string does not change: published releases are immutable, and `--version` has to keep resolving every past one. The two differ on purpose, which is why `--flavor runtime` fetches a file called `tenx-edge-<ver>-<arch>-native`.

| Flavor        | Release assets                                                                                                                              |
|---------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
| `compiler`    | `tenx-cloud_<ver>_<arch>.deb`, `tenx-cloud-<ver>-1.<arch>.rpm`, `tenx-cloud-<ver>.dmg`, `tenx-cloud-<ver>-intel.dmg`, `tenx-cloud-<ver>.msi` |
| `runtime`     | `tenx-edge-<ver>-<arch>-native`, `tenx-edge-<ver>-macos-<arch>-native`                                                                       |
| `runtime-jvm` | `tenx-edge_<ver>_<arch>.deb`, `tenx-edge-<ver>-1.<arch>.rpm`, `tenx-edge-<ver>.dmg`, `tenx-edge-<ver>-intel.dmg`, `tenx-edge-<ver>.msi`      |

`runtime` and `runtime-jvm` share the `tenx-edge` file prefix and the `/opt/tenx-edge` install prefix. The native binary carries a `-native` suffix; the JVM build is an OS package.