Self-hosted service
windmill-labs/windmill avatar
windmill-labs/windmill

Windmill: a whole-cluster Postgres upgrade, a from-source sandbox, and a 13x benchmark claim

Open-source developer platform to power your entire infra and turn scripts into webhooks, workflows and UIs. Fastest workflow engine (13x vs Airflow). Open-source alternative to Retool and Temporal.

18,572 stars1,154 forksRustNOASSERTION

At a glance

What is it?
Windmill is an AGPLv3 code-first platform for workflows, apps and AI agents, with scripts in Python, TypeScript, Go, Bash, SQL, GraphQL, PowerShell, Rust and more. The compose file and Dockerfile hold the real constraints: a Postgres 18 volume that cannot read an old cluster, nsjail compiled from one pinned commit, and a 13x-versus-Airflow performance claim.
Who is it for?
Windmill fits teams that already script in several languages and want one place to expose those scripts as endpoints, flows and internal UIs, and who can operate a Postgres pair, a Rust worker fleet and a from-source sandbox image. Self-hosting it does not fit a team that wants no infrastructure of its own, since Windmill Labs offers dedicated instances for that, or one that needs to know how its numbers compare on its own graph shape.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • windmill-labs/windmill18,572 ★ · +578
Star history
Repository2026-09-212026-11-13
windmill-labs/windmill18k18.6k

578 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The Postgres volume path changed, and a stale cluster now exits loudly

The compose file carries a long comment about the one upgrade that bites, and it is worth reading before you copy the file. Because the bundled image is postgres:18, and the official image from 18 keeps its cluster in a major-version subdirectory such as /var/lib/postgresql/18/docker, the named volume is mounted at the parent directory /var/lib/postgresql instead of the old .../data path. That is deliberate: it is what lets pg_upgrade see an old and a new cluster inside a single mount point. The consequence for anyone arriving on a 16 volume is that the container exits with an explanatory error rather than coming up blank, which is a deliberate design choice to turn a stale cluster into a loud failure. Migrating means dumping the whole cluster with pg_dumpall, never just the windmill database, because Windmill keeps datatable, DuckLake and wm_fork_* databases beside it and grants its RLS policies to cluster-level roles. A single-database dump loses both, silently.

yaml
  ## UPGRADING FROM POSTGRES 16: db_data holds a cluster 18 cannot read, so the
  ## container exits with an explanatory error rather than coming up blank. Migrating
  ## means dumping the WHOLE cluster (pg_dumpall), never just the windmill database:
  ## Windmill keeps datatable, DuckLake and wm_fork_* databases beside it and grants
  ## its RLS policies to cluster-level roles, and a single-database dump loses both
  ## silently. Full procedure, and why 16 is still a valid choice until Nov 2028:
  ## https://www.windmill.dev/docs/advanced/self_host#upgrade-postgresql-to-18

A default install ships changeme as the database password

The defaults in the db service are development defaults, and the two that matter for a real deployment are the credential and the log rotation. The environment block sets POSTGRES_PASSWORD to changeme and POSTGRES_DB to windmill, so an instance that is exposed without being edited hands out a password that is published in the repository. The healthcheck is a shell probe, pg_isready -U postgres, on a 10 second interval with a 5 second timeout and 5 retries, which means the compose file treats the database as ready well before it has been load tested. Logging goes through an anchor that applies json-file with max-size defaulting to 20m, max-file defaulting to 10, and compression on, so container logs are rotated away unless LOG_MAX_SIZE and LOG_MAX_FILE are raised. The escape hatch for managed databases is written in a comment on the deploy block: set replicas to 0 and point DATABASE_URL at the external database url in the .env file.

yaml
    image: postgres:18
    shm_size: 1g
    restart: unless-stopped
    volumes:
      - db_data:/var/lib/postgresql
    expose:
      - 5432
    environment:
      POSTGRES_PASSWORD: changeme
      POSTGRES_DB: windmill

The image compiles nsjail and a forked duckdb from source

The Dockerfile does not download prebuilt artifacts, and that has consequences for anyone rebuilding it. The nsjail stage starts from debian:trixie-slim, installs a list of Debian packages with exact version pins including bison=2:3.8.*, g++=4:14.2.*, git=1:2.47.*, libprotobuf-dev=3.21.* and protobuf-compiler=3.21.*, then clones nsjail, checks out one specific commit and applies the patches from docker/nsjail-patches before running make. The commit pin makes the sandbox code deterministic, but the apt pins do not: when trixie rolls those package versions the build stops until the pins are updated, so a Windmill image is not something you can rebuild unattended on an arbitrary day. The Rust stage is rust:1.97-slim-trixie with cargo-chef 0.1.68 and sccache ^0.8. A separate windmill_duckdb_ffi_internal_builder stage builds DuckDB support. SQLX_OFFLINE=true is also set, so the Rust build reads checked-in query metadata instead of a live database.

dockerfile
RUN git clone -b master --single-branch https://github.com/google/nsjail.git . && git checkout dccf911fd2659e7b08ce9507c25b2b38ec2c5800 \
    && git apply /nsjail-patches/*.patch
RUN make

Your function signature becomes the endpoint and the form

The central mechanism is that a script's parameters are the interface. You write a minimal generic script in Python, TypeScript, Go or Bash, its parameters are parsed automatically, and a frontend is generated from them, which is why the overview can promise scripts turned into sharable UIs automatically. That design has a cost that is easy to miss while prototyping. Renaming a parameter, widening a type, or reordering arguments is not a refactor, it is an API change to every flow, webhook and generated form that calls it. The example makes the pattern concrete, importing the client library and an npm package that is resolved and pinned automatically, with a union of strings becoming a dropdown and defaults inferring the type.

typescript
import * as wmill from "windmill-client";
import dayjs from "dayjs"; // any npm package, resolved and pinned automatically

The same example writes to a data table, the workspace's Postgres queried without a connection string, and the overview lists SQL, GraphQL, PowerShell and Rust among its supported languages.

Four ways to develop locally, and the env vars a local run needs

Engineers keep writing code locally with the CLI, the VS Code extension and their coding agent, synced with Git, while business teams build in the same instance through AI sessions in a workspace fork that are reviewed before deploying. The repository tree backs this up with client packages in-tree, including go-client, python-client, rust-client and powershell-client, plus an lsp directory, a debugger, a multiplayer directory, ai_evals and an openflow.openapi.yaml. Contributors have a Caddyfile, a .envrc, a .devcontainer and a docker directory.

Three releases in three days, and the LTS story is not in the README

The release numbers move faster than a quarterly upgrade window. v1.856.0 shipped 2026-11-02T07:31:25Z, v1.857.0 followed on 2026-11-03T04:28:01Z, and v1.858.0 at 05:47:28Z the same morning, so three tags landed within about a day. The repository is not archived and its last push was 2026-11-02T18:39:49Z, which tells you the project is shipping, not that any particular tag is safe for you. What that means operationally is concrete: pinning to a minor version buys you about a day of being current, and an instance left on v1.856.0 was already two releases behind the next morning. The versioning history that would let you judge a jump lives in CHANGELOG.md, with release-please-config.json and .release-please-manifest.json at the top level, rather than in the overview. The overview's self-host section covers Docker compose, Kubernetes through Helm charts, and cloud providers, and adds sections for OAuth, SSO and SMTP.

The 13x claim covers two flow shapes against three engines

The performance claim is specific in a way that is easy to misread. The repository description calls Windmill the fastest workflow engine at 13x versus Airflow, the README has a section titled Fastest Self-Hostable Workflow Engine, and a benchmarks directory exists in the tree. A single multiplier against one competitor says nothing about your own graph shape, so read the methodology and run it yourself against your own workload before relying on the number.

Editorial conclusion

Windmill fits teams that already script in several languages and want one place to expose those scripts as endpoints, flows and internal UIs, and who can operate a Postgres pair, a Rust worker fleet and a from-source sandbox image. Self-hosting it does not fit a team that wants no infrastructure of its own, since Windmill Labs offers dedicated instances for that, or one that needs to know how its numbers compare on its own graph shape. Before you commit, read the license boundary between the AGPLv3 code and Windmill Labs' commercial offering, decide whether you are on the LTS-style discipline of pinning or tracking releases that land several times a day, and rehearse the Postgres 18 cluster migration on a copy.

Frequently asked questions

What is Windmill, and which products is it an alternative to?

Windmill is an open-source developer platform that turns scripts into webhooks, workflows and UIs; its README calls it a code-first platform for workflows, apps and AI agents. It describes itself as a self-hostable alternative to Lovable, Retool, n8n and a simplified Temporal.

Which languages can Windmill scripts be written in?

The overview names Python, TypeScript, Go, Bash, SQL, GraphQL, PowerShell and Rust, plus more.

How does a Windmill self-hosted install use an external Postgres database?

A comment in the compose file says to set replicas to 0 for the db service and set DATABASE_URL to the external database url in the .env file. The bundled database is the postgres:18 image, and a stale cluster left in the db_data volume makes the container exit with an explanatory error rather than start.

Is Windmill still releasing new versions?

The repository is not archived and its last push was 2026-11-02T18:39:49Z. Three releases shipped within about a day: v1.856.0 on 2026-11-02, then v1.857.0 and v1.858.0 on 2026-11-03.

What license does Windmill ship under?

The project is fully open-sourced under AGPLv3. Alongside it, Windmill Labs offers dedicated instances as well as commercial support and licenses.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. windmill-labs/windmill on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/windmill-labs-windmill.svg)](https://hysenlabs.com/projects/windmill-labs-windmill)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/windmill-labs-windmill.svg)](https://hysenlabs.com/projects/windmill-labs-windmill)

Was this useful?