GitHub - IterateAI/lifeboat-releases: Lifeboat — downloads for macOS, Windows and Linux, plus Docker and Kubernetes install instructions. Run language models on your own hardware behind an OpenAI-compatible API.

Lifeboat serves open-weight models on machines you control — a laptop, a workstation, a GPU server, or a cluster — and puts an OpenAI- and Anthropic-compatible API in front of them, with a load balancer, a web console and no data leaving your network.

This repository is downloads and install instructions only. The source is not public.

Download

pip — no Docker, no GPU required

pip install lifeboat
lifeboat engine install
lifeboat up          # console on http://127.0.0.1:8001

The quickest way to evaluate Lifeboat, and how to run it on small hardware: console, model registry, load balancer and the full OpenAI-compatible API, with no container and no accelerator. Python 3.10–3.13 on macOS (Apple Silicon), Linux x86-64/ARM64 and Windows x64 — PyPI, quickstart.

Edge and embedded hardware is a first-class target. The Linux engines link an old system runtime and carry every processor variant, chosen at run time, so one download runs on distributions going back to 2018 and from an Atom to a current server — Raspberry Pi 4/5, mini-PCs and thin clients included. NVIDIA Jetson boards receive a CUDA build automatically. lifeboat doctor reports the board's cores, memory, GPU and the largest model it can serve before you download any weights.

It carries the GGUF engine only — safetensors, FP8 and the throughput optimizations stay with the container image.

Measured against other inference servers on the same hardware and the same model file, out of the box: 1.94x llama.cpp on a 64-core server, 2.01x ollama on a Jetson, 1.48x on a Mac. Harness and raw results: benchmark/comparison.

Android — running, not yet downloadable

The GGUF engine cross-compiles for arm64-v8a and runs on a handset, with a branded console in the app: it enumerates the phone's compute devices, lets you pick one, benchmarks them against each other, and serves the same OpenAI-compatible API on the device.

There is no APK to download yet. The build is signed with a local development key, which is fine for a device you own over adb and wrong for anything you hand to someone else. What is verified on real hardware is the engine, the console and the measurements — see benchmark/android for the numbers and the Android guide for what the phone build can reach.

Desktop — no Docker required

A native app with a tray icon, on all three platforms. No container runtime and no root. It serves models on whatever the machine has: Metal on Apple Silicon and Vulkan on Windows and Linux, which covers NVIDIA, AMD and Intel GPUs with one download — and the CPU otherwise.

The macOS and Windows builds are code-signed (macOS also notarized); the Linux builds are not, and ship a SHA256SUMS instead.

Desktop builds are cut per platform, so the newest version differs between them. Take the newest file for yours:

Because the platforms are cut separately, the newest build for yours may not be on the latest release — browse all releases and take the newest file bearing your platform's name.

docs/desktop.md is the full guide — requirements, GPU support, upgrading and uninstalling for each platform.

Windows

Download Lifeboat-<version>-setup.exe and double-click it. That is the whole procedure.

It installs for you rather than for the machine, so there is no administrator prompt: the app goes to %LOCALAPPDATA%\Programs\Lifeboat and your models to %LOCALAPPDATA%\Lifeboat. Start at sign-in and desktop shortcut are separate checkboxes; neither implies the other.

One prerequisite, which the installer checks for but cannot install:

winget install --id Microsoft.DotNet.DesktopRuntime.8 -e

The tray is a .NET application and does nothing without it. lifeboat-core.exe runs headless and does not need it.

The curl … | bash line in the welcome email is the Docker installer and is for Linux hosts. PowerShell has no bash, so it fails with "The term 'bash' is not recognized". On Windows, use setup.exe.

macOS

Open the .dmg, drag Lifeboat to Applications, and launch it.

The build is signed with a Developer ID, notarized by Apple and stapled, so there is no security warning and no need to right-click → Open — offline too, since the ticket travels inside the file. Lifeboat lives in the menu bar, not the Dock: there is no Dock icon and no window on launch.

Linux

Debian, Ubuntu and derivatives:

sudo apt install ./lifeboat-desktop_2.2.50_amd64.deb

Use apt install ./file.deb, not dpkg -i — the tray binding and the Vulkan loader are recommended packages and dpkg will not pull them in.

Any other distribution — the tarball unpacks to the same layout, rooted at /:

sudo tar -C / -xzf Lifeboat-2.2.50-linux-x86_64.tar.gz

Either way you get /opt/lifeboat plus two commands on PATH: lifeboat-core (the server and CLI, runs headless) and lifeboat-tray. Needs glibc 2.31+ (Debian 11+, Ubuntu 20.04+, RHEL 9+). For GPU offload install libvulkan1 and your vendor's Vulkan driver; for the tray icon on GNOME, gir1.2-ayatanaappindicator3-0.1 — without an AppIndicator it silently does not render.

lifeboat-core doctor     # what this machine can actually run, and why

Verifying a download

macOS and Windows builds are code-signed, so the OS checks them for you — that is the stronger check. Linux builds are not signed; where a release publishes a SHA256SUMS, check against it:

sha256sum -c SHA256SUMS --ignore-missing

pip — no Docker, no GPU

pip install lifeboat
lifeboat engine install
lifeboat up          # console on http://127.0.0.1:8001

The quickest way to evaluate Lifeboat: the console, model registry, load balancer and the full OpenAI-compatible API, with no container runtime and no accelerator. lifeboat serve <model> serves one model without the console, and lifeboat doctor reports what the machine can run before anything downloads.

Python 3.10–3.13, published for macOS (Apple Silicon), Linux x86-64 and ARM64, and Windows x64 — pypi.org/project/lifeboat, quickstart.

It carries the GGUF engine only, so the 2x concurrency, FP8 KV cache, speculative decoding and safetensors weights stay with the container image. Use the container on Intel Macs (no wheel is published) and on RHEL 9 and its rebuilds — Rocky, AlmaLinux, Oracle Linux — whose system C++ runtime is older than the prebuilt engine needs. Those also ship Python 3.9 as python3, below the floor; install 3.12 first.

The fastest path on a Linux GPU host. One command:

curl -sSL https://raw.githubusercontent.com/IterateAI/lifeboat-releases/main/install/get-lifeboat.sh | bash

It checks your host, picks the right image for your hardware, writes a .env, and starts the stack. Then open http://localhost:8001.

curl -sSLO https://raw.githubusercontent.com/IterateAI/lifeboat-releases/main/install/get-lifeboat.sh
less get-lifeboat.sh
bash get-lifeboat.sh

Pick the right image

The tags are not interchangeable — this is the single most common mistake:

:latest is the NVIDIA image and is multi-arch (amd64 + arm64). The arm64 half is built for NVIDIA arm64 parts such as Grace-Hopper and DGX Spark — on a CPU-only Graviton instance it is 17 GB of CUDA that cannot be used. Use :lite there.

An AMD customer pulling :latest gets a CUDA image that will not run on their GPU. There is no tag that serves both: a container manifest selects on CPU architecture, and both images are linux/amd64.

Manual Compose

curl -sSLO https://raw.githubusercontent.com/IterateAI/lifeboat-releases/main/install/docker-compose.yaml
curl -sSL  https://raw.githubusercontent.com/IterateAI/lifeboat-releases/main/install/.env.example -o .env
$EDITOR .env          # optional: LIFEBOAT_ADMIN_PASSWORD, else the
                      # console asks you to create the account on first visit
docker compose up -d

Copies of all three compose files are mirrored in install/, and docs/docker.md has the full detail — tags, host requirements, sizing and upgrades.

Kubernetes

helm repo add lifeboat https://raw.githubusercontent.com/IterateAI/lifeboat-releases/main/helm
helm repo update
helm install lifeboat lifeboat/lifeboat \
  --set admin.password='<choose-one>' \
  --set gpu.vendor=nvidia            # nvidia | amd | lite

admin.password is required and the install fails without it. gpu.vendor switches the image, the device resource and the runtime class together — set it to lite for CPU-only nodes.

First run

1. Open the console — http://localhost:8001 (Docker) or http://127.0.0.1:30800 via the tray's Open Console (desktop).
2. Create your administrator account. Lifeboat ships with no credentials: the first visit asks you to choose an email and password, and that account is the superadmin. (If you set LIFEBOAT_ADMIN_PASSWORD in .env before the first start, the account is created from that instead and you sign in normally.)
3. Models → Add Model, pick something that fits your machine.
4. Servers → New Server, choose the model, press Start.
5. Point any OpenAI-compatible client at http://localhost:8001/v1.

curl http://localhost:8001/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <your-api-key>' \
  -d '{"model":"<your-model>","messages":[{"role":"user","content":"Hello"}]}'

The Anthropic-compatible surface is at /v1/messages, so SDKs pointed at either vendor work unchanged.

Licensing

Every install runs for 24 hours with no key, so you can evaluate before deciding anything. After that an activation key is required to start inference servers — the console and the API stay reachable either way, so you can always activate from the same page that asked you to.

• Free tier — for non-commercial and evaluation use. No card. Up to 2 concurrent inference servers, single node.
• Paid — monthly or yearly.
• Air-gapped — offline licence files are available; they never contact a licence server. Install first, read the Cluster ID off the License page, and quote it when you ask — the file is bound to that one cluster.

All of it goes through iterate.ai/lifeboat — free tier, trial, purchase, upgrades and offline files. That is the only address you need.

What Lifeboat reports back

A licensed install sends a heartbeat every 6 hours: the licence key, a cluster id, a pod count, a version, and a hardware description sent once. An unlicensed install sends a smaller daily message so support can see an evaluation exists.

No model names, no prompts, no completions, no token counts. That is enforced in code, not just intended. LIFEBOAT_TELEMETRY=off disables the hardware and census reporting; an air-gapped licence sends nothing at all, ever.

The full payload, byte for byte, is documented in docs/telemetry.md.

Documentation

Support

• Issues with a download or an install — open an issue here.
• Anything involving your licence, your data or your account — email support@iterate.ai rather than filing a public issue.
• Security vulnerabilities — see SECURITY.md. Please do not open a public issue for these.

_{Lifeboat is built by iterate.ai. Source is not public; this repository carries releases and install instructions.}