# Prebuilt Binaries

> Download the prebuilt QUIC/MoQT engine, the ROS 2 RMW package, and the tunnel CLI from the shared artifact host.

Most integrations install the SDK from a language registry (npm, PyPI,
crates.io, and others) and do not use a raw binary. Sometimes you need the
engine itself: to embed it, to run the ROS 2 RMW, or to get the `tunnel` CLI.
One HTTPS origin serves all of these artifacts.

> **NOTE:**
> All artifacts are on one origin: **`https://artifacts.clutchcall.dev`**
> (the shared artifact host for every brand). The host is public and read-only.
> The URLs below are stable and need no auth.

## The QUIC/MoQT engine (`libclutchcall_moqt_ffi.so`)

This is the native transport core. You can embed it directly (FFI) or bundle
it with a custom build. It is built against a static libc++ with a glibc-2.17
floor. It loads on any modern Linux without extra runtime deps.

```bash
ORIGIN=https://artifacts.clutchcall.dev

# engine shared object + its C header
curl -fsSL $ORIGIN/sdk/libclutchcall_moqt_ffi.so -o libclutchcall_moqt_ffi.so
curl -fsSL $ORIGIN/sdk/clutch_moqt_ffi.h         -o clutch_moqt_ffi.h
```

Point your SDK at a custom engine with the per-language override, for example
Python's `CLUTCHCALL_LIB_PATH`. Or link against the header above from C/C++.

## ROS 2 RMW (`ros-jazzy-rmw-clutchcall-cpp`)

The Debian package ships from a **GPG-signed apt repo** on the same origin.
The [ROS 2 RMW page](/modalities/robotics/rmw) gives the full procedure:
env var, verification, and teleop.

```bash
ORIGIN=https://artifacts.clutchcall.dev

curl -fsSL $ORIGIN/apt/clutchcall-archive-keyring.asc \
  | sudo gpg --dearmor -o /usr/share/keyrings/clutchcall-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/clutchcall-archive-keyring.gpg] \
$ORIGIN/apt noble main" \
  | sudo tee /etc/apt/sources.list.d/clutchcall.list

sudo apt update
sudo apt install ros-jazzy-rmw-clutchcall-cpp
```

## Engine (`clutchcall-host` / `clutchcall-relay`)

The engine ships as two Debian packages from the same signed apt repo. Install
the package that matches the box:

- **`clutchcall-host`** — the modular voice/media engine: the launcher, shared
  core, service sidecars, and the native `mod_*.so` set, with systemd units,
  tunables, and a `modules.conf`.
- **`clutchcall-relay`** — the MoQT edge relay (the same core run with the
  built-in relay role, no modules).

```bash
ORIGIN=https://artifacts.clutchcall.dev

curl -fsSL $ORIGIN/apt/clutchcall-archive-keyring.asc \
  | sudo gpg --dearmor -o /usr/share/keyrings/clutchcall-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/clutchcall-archive-keyring.gpg] \
$ORIGIN/apt noble main" \
  | sudo tee /etc/apt/sources.list.d/clutchcall.list
sudo apt update

sudo apt install clutchcall-host      # engine box
# or, on an edge:
sudo apt install clutchcall-relay
```

On first install, the package seeds `/etc/clutchcall/services.env` (host) or
`relay.env` (relay) from a redacted example. Before you run
`systemctl enable --now clutchcall-core` (or `clutchcall-relay`):

1. Edit the env file. Set the endpoints and the secrets.
2. Put your TLS cert and key in `/opt/clutchcall/conf/`.

The two packages conflict. A box runs one or the other.

### Other distros (Fedora, RHEL 9, Rocky, Alma, openSUSE, Amazon Linux, Arch…)

The engine binary is **hermetic**: it statically links everything except
glibc. One build runs on **any x86-64 Linux with glibc ≥ 2.30 and a kernel
≥ 5.4**. A kernel ≥ 5.4 is necessary for the kernel-bypass fast path. On an
older kernel, the engine falls back to the standard kernel path.
For non-Debian systems, a self-contained tarball with `install.sh` does the
same setup (user, config, systemd units, tunables). It has no distro package
deps:

```bash
ORIGIN=https://artifacts.clutchcall.dev
curl -fsSL $ORIGIN/engine/clutchcall-host-latest-amd64.tar.zst | tar --zstd -x
sudo ./install.sh            # or: sudo ./install.sh --start
# edge relay: clutchcall-relay-latest-amd64.tar.zst
```

Arch/pacman users can install the native package instead:
`sudo pacman -U $ORIGIN/engine/clutchcall-host-1.0.0_git220eafc-1-x86_64.pkg.tar.zst`.
RPMs for dnf/zypper are available on request.

## Tunnel CLI

This command installs the QUIC tunnel client on any OS and architecture:

```bash
curl -fsSL https://artifacts.clutchcall.dev/rnp/install.sh | sh
```

## SDK language registries

Each SDK ecosystem is published as a **self-hosted static registry** on this
same origin: npm, pip, maven, go, cargo, and nuget. The SDKs are **not** on
the public registries (npmjs / PyPI / Maven Central / crates.io / nuget.org).
Install from the origin as shown below. Your own dependencies still resolve
from those public registries.

All six SDKs install from the same origin (`https://artifacts.clutchcall.dev`):

**TypeScript / npm:**
```bash
npm install https://artifacts.clutchcall.dev/npm/tarballs/clutchcall_connect-1.0.0.tgz
```

**Python / pip:**
```bash
pip install clutchcall-sdk --extra-index-url https://artifacts.clutchcall.dev/pip/simple/
```

**Go:**
```bash
GOPROXY=https://artifacts.clutchcall.dev/go,https://proxy.golang.org,direct GOSUMDB=off \
  go get github.com/clutchcall/go-sdk@v1.0.0
```

**Rust / Cargo:**
```toml
# ~/.cargo/config.toml — register the sparse index once
[registries.clutchcall]
index = "sparse+https://artifacts.clutchcall.dev/cargo/"

# Cargo.toml
[dependencies]
clutchcall-sdk = { version = "1.0.0", registry = "clutchcall" }
```

**Java / Maven:**
```xml
<!-- pom.xml -->
<repositories>
  <repository>
    <id>clutchcall</id>
    <url>https://artifacts.clutchcall.dev/maven</url>
  </repository>
</repositories>

<dependency>
  <groupId>com.clutchcall.api</groupId>
  <artifactId>clutchcall-sdk</artifactId>
  <version>1.0.0</version>
</dependency>
```

**.NET / NuGet:**
```bash
dotnet nuget add source https://artifacts.clutchcall.dev/nuget/index.json -n clutchcall
dotnet add package ClutchCall.SDK --source clutchcall
```

> **NOTE:**
> Each channel enforces integrity:
> 
> - The apt repo is **GPG-signed**.
> - The Cargo sparse index carries per-crate SHA-256 checksums.
> - Every artifact URL is **version-pinned and immutable**. When you pin the
>   version, the URL is reproducible.

## LiveKit transport plugins

Run LiveKit agents over the ClutchCall QUIC transport. The plugins are
published to the same origin, in both ecosystems:

**Python / pip:**
```bash
pip install livekit-plugins-clutchcall --extra-index-url https://artifacts.clutchcall.dev/pip/simple/
```

**TypeScript / npm:**
```bash
npm install https://artifacts.clutchcall.dev/npm/tarballs/clutchcall-livekit-transport-0.1.0.tgz
```