One binary · Linux, macOS, WSL · 25 MB RAM idle

Schedule, supervise, observe. One binary.

It's 3 AM. Your backup didn't run. You won't know until tomorrow morning. RunWisp fixes that: one binary that replaces crond, supervisord, and the tab you forgot to open.

Quick start in 30 seconds GitHub Browse the docs →

RunWisp web dashboard: task list, execution history, and live log streaming.

RunWisp terminal UI: task sidebar, live log output, and execution controls.

Three things, one binary.

Scheduled jobs, long-running services, and health checks, all defined in the same runwisp.toml file and run by the same process.

Scheduled tasks

Cron expressions with a real execution history. Skip, queue, or terminate overlapping runs. Catch-up missed runs after a reboot. Notify Slack, Telegram, or email on failure.

Long-running services

Supervise worker processes with restart policies, instance counts, and graceful-stop windows. Same TOML file, same dashboard, same logs.

Health checks

Hit an endpoint, exit non-zero if it's broken. RunWisp captures the run, retains the output, and pages you the way you want to be paged.

The 3 AM problem

Plain cron is invisible.

crond runs your job, dumps stderr somewhere you'll never read, and forgets about it. No exit code history. No "did the last run finish?" No notification when it didn't.

RunWisp captures every run (stdout, stderr, exit code, duration) and keeps the last N runs per task in embedded SQLite. Stream the output live in your browser. Re-trigger with one click. SSH at 3 AM is optional now.

Not a DAG engine. If you need workflows, try Dagu or Airflow. RunWisp does one machine, well.

RunWisp web dashboard showing per-task run history with exit codes, durations, and a live log pane.

Up and running in three commands.

From curl to "my backups have a dashboard." No package manager wrangling.

1

Install the binary

One curl, no Node, no Python, no Docker required.
```
curl -fsSL https://get.runwisp.com | sh
```

Write your runwisp.toml

Tasks and services in one file. Checked into your repo. The schema is the source of truth.

[tasks.backup-db]
cron       = "0 2 * * *"
on_overlap = "skip"
keep_runs  = 30
run = "pg_dump mydb | gzip > /backups/mydb-$(date +%F).sql.gz"

[services.worker]
run      = "./bin/worker"
restart  = "on-failure"

3

Run runwisp

Schedules fire, services supervise, logs persist. Open the web dashboard on http://localhost:9477 or stay in the terminal.
```
runwisp
```

Built for the operator who reads `journalctl`.

Predictable, observable, scriptable. The stuff a solo dev or a small ops team actually needs, without standing up Airflow.

Every run, every detail

Exit code, duration, stdout, stderr, timestamps. All captured for every run, browsable in the web UI, queryable via REST. No silent failures.

One binary, zero deps

Static Go binary. No Python, no Node, no external database. Embedded SQLite, embedded dashboard. Works on a Raspberry Pi.

TOML is the source of truth

Schedules, retries, services, notifiers, all in runwisp.toml. The dashboard reads and triggers; it never edits your config.

Never let runs stack up

Per-task on_overlap policy: skip, queue, or terminate. Per-service instance counts. Backoff with reset on stability.

Reboots don't drop runs

Reboot the machine, run RunWisp, and missed firings replay (bounded by max_catch_up_runs). No quiet gaps in your history.

Notify the way you want

Slack, Telegram, email, or an in-app bell. Per-task overrides. Route notifications by event. Or stay silent. Your call.

Web + terminal UI

A Svelte dashboard ships inside the binary. A Bubbletea TUI for SSH sessions. Same data, two surfaces, no extra installs.

Live log streaming

Watch a task's output as it happens, in the browser or over SSH. Tail historic logs without grep-ing through files.

Graceful shutdown

SIGTERM-then-SIGKILL with a configurable grace window per task. The daemon waits, the long-running task gets to flush.

Works without internet

Everything works with the network unplugged. The optional cloud control plane is strictly opt-in and never blocks execution.

What it replaces, and what it doesn't.

RunWisp sits between "edit crontab over SSH" and "stand up Airflow." If your scheduler needs a team to run it, you've outgrown us.

Tool	Today	With RunWisp
crond , compare	Fires the line. No history, no UI, no notification when it fails.	Every firing is a row with stdout, exit code, and a notification on failure.
supervisord , compare	Solid process supervisor, with a Python runtime to keep alive next to it.	One static binary supervises your processes, restart backoff included.
systemd timers , compare	Two units per job, journalctl spelunking, Linux-init-only.	One TOML stanza, queryable run history, same daemon on macOS/WSL/Docker.
PM2 , compare	Node-flavoured supervisor: pulls in npm, conflates services with scheduled jobs.	Language-agnostic; one binary, services and tasks as distinct kinds.
Airflow / Dagster	DAGs, schedulers, web UI, plus a Python install, a metadata DB, and a learning curve.	One binary, one TOML. Not a workflow engine, and proud of it.

Side-by-side configs and honest concessions on each linked page.

Start in 30 seconds. Ship on your terms.

A single Go binary. No telemetry. Apache-2.0, free to self-host, forever. If it doesn't earn the disk space, rm it.

Quick start GitHub