saggar
Sign in

Push anything, get a built artifact back, with the logs in a web page.

saggar is a build engine: hand it a git URL, a tarball or a path, and it works out what to build, builds it in a disposable environment, and streams the logs while it runs. Green artifacts come back as registries. docker pull and apt install address the store directly. saggar.dev builds nothing itself: you pair your own runners (a home PC, a workstation, a fleet) and the hub coordinates while your hardware computes.

From the terminal

1
Sign in once Your token rides every submission after it.
$ saggar login
2
Pair a runner The builds run on your own hardware. saggar-worker doctor checks a machine is ready; pairing attaches it to the hub.
$ saggar-worker pair
3
Hand it the tree A directory, a git URL, or a tarball. The engine detects the format.
$ saggar submit ./my-project
4
Watch it build Live output, phase by phase, while it runs.
libfoo 1.0.0 on amd64 · debian:12
build cc -O2 -c ring.c -o ring.o
test running the suite…
package libfoo_1.0.0_amd64.deb
5
Take the artifact Green builds come back ready to install.
[✓] built! libfoo-1.0.0 ready
$ saggar download libfoo

In the browser

1
Sign in One click with your GitHub or OIDC account, no tokens to paste.
2
Pair a runner Your own machine asks to pair; approve it on the Fleet page and it pulls the builds.
3
Import a project Paste the repository URL; the name is suggested, a watch can follow pushes.
4
Watch it build The same live logs, on the job's own page.
libfoo 1.0.0 on amd64 · debian:12
build cc -O2 -c ring.c -o ring.o
test running the suite…
package libfoo_1.0.0_amd64.deb
5
Take the artifact The project page hands you the pull and install lines.
docker
docker pull saggar.dev/val/libfoo:release

Every format from one tree

One submission fans out per format and architecture: deb, rpm, snap, flatpak, AppImage, container. The jobs land as one group.

Logs while it builds

Every phase streams its output as it happens; a failure names the phase, the exit code and the log tail.

Your own registries

Green artifacts are served back where they land: docker pull and apt install address the store directly, multi-arch through one tag.

Builds on push

Watches poll a repo and take forge webhooks; a push matching a branch or tag glob becomes a job, with commit status reported back.

Tests gate the green

The same pipeline runs the tree's own suite; structured results name the failing cases, no log scraping.

One box or a fleet

Your machines do the building: workers pull jobs from a hub, so no inbound ports and NAT are fine, while a single process runs the whole pipeline alone.

saggar
push anything, get an artifact back