Installation

Project Super ships as static binaries (superd, super) with no runtime dependencies on Python or a JVM. Building from source requires Rust only.

Method 1: Docker (Recommended)

The official OSS image ships superd and super (API + CLI). There is no embedded web dashboard — install the optional UI plugin from your subscription package for the full control plane.

Pull and run

The image ships with a default config at /app/super/conf/super.toml (host = "0.0.0.0", port 9002, and allow_insecure_public_bind = true so the container can listen on all interfaces). No volume mount is required for a first try.

docker pull containerpi/super:latest

docker run --rm -p 9002:9002 containerpi/super:latest

Open http://localhost:9002 for the OSS HTML notice and HTTP API. Add programs via the CLI or API (or load the ui plugin for the dashboard).

Images are published for linux/amd64 (Intel/AMD servers and most cloud VMs).

Custom configuration

Mount your own conf/ (and optionally data/ for persistence):

docker run --rm -p 9002:9002 \
  -v /path/to/conf:/app/super/conf \
  -v /path/to/data:/app/super/data \
  containerpi/super:latest

Place super.toml under /path/to/conf/. Reference profiles in dockerbuild/conf/:

• super.toml — OSS default baked into the image (allow_insecure_public_bind = true for container networking).
• super.subscription.example.toml — subscription template with [license].key, auth_secret, and security plugin expectations.

Drop JSON stack files into conf/conf.d/*.json to seed programs on startup.

If you bind to 0.0.0.0 or another non-loopback address, set allow_insecure_public_bind = true in [server] (or load the **security plugin). The repo's example/conf/super.tomlsets this tofalse` for local-only deployments.

If you add licensed plugins, security.so and auth_secret are required for startup — security is included with every subscription. See Licensed deployments require security.

Build from this repository

git clone https://github.com/hzbd/super.git
cd super
docker build -f dockerbuild/Dockerfile -t containerpi/super:latest .

Or: make docker. See dockerbuild/README.md for publish notes.

Use as a base image in your stack

FROM ubuntu:22.04

COPY --from=containerpi/super:latest /usr/local/bin/superd /usr/local/bin/superd
COPY --from=containerpi/super:latest /usr/local/bin/super /usr/local/bin/super

COPY conf/ /app/super/conf/

RUN apt-get update && apt-get install -y --no-install-recommends tini \
    && rm -rf /var/lib/apt/lists/*

ENTRYPOINT ["/usr/bin/tini", "--", "/usr/local/bin/superd"]

For container signal handling and tini guidance, see Zombie reaping in containers. For how Super compares to Supervisor or shell entrypoints, see vs Supervisor.

Method 2: GitHub Releases or build from source

Pre-built archives are published on GitHub Releases. Extract and run bin/superd.

Each archive contains bin/superd, bin/super, and a README with quick-start steps and source links. A SHA256SUMS file is attached to every release.

Windows: Pre-built Windows binaries are not published at this time. Super targets Unix-like servers and edge devices. On Windows, use Docker (e.g. with WSL2), or build from source on Linux, macOS, or FreeBSD.

To build locally (requires Rust):

git clone https://github.com/hzbd/super.git
cd super
make build

./target/release/superd --help
./target/release/super --version

Method 3: Systemd (VM / bare metal)

1. Create unit file

/etc/systemd/system/superd.service:

[Unit]
Description=Project Super Process Manager
After=network.target

[Service]
Type=simple
# Must stay in the foreground. Do not set [server].daemon = true or pass --daemon.
ExecStart=/usr/local/bin/superd --foreground
Restart=always
User=root
Environment=SUPER_ROOT=/opt/super

[Install]
WantedBy=multi-user.target

2. Enable and start

sudo systemctl daemon-reload
sudo systemctl enable --now superd
sudo systemctl status superd

Note: Default layout is $SUPER_ROOT/conf/super.toml. Set SUPER_ROOT if your layout differs.

Daemonize without systemd: superd --daemon (or [server] daemon = true) writes $SUPER_ROOT/run/superd.pid by default. Do not combine that with this unit — superd refuses to start if both are detected. Stop with super shutdown as usual.