Skip to content
Back to search

windmill

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.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/windmill-labs/windmill with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/windmill-labs/windmill'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/windmill-labs-windmill/badge.svg)](/listings/windmill-labs-windmill)

HTML

<a href="/listings/windmill-labs-windmill"><img src="/api/listings/windmill-labs-windmill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 320 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <a href="https://www.windmill.dev/"><img src="./imgs/windmill-banner.png" alt="windmill.dev"></a>
  3. </p>
  4. <p align=center>
  5. Open-source, self-hostable code-first platform for workflows, apps and AI agents, running on the fastest self-hostable orchestrator. Engineers write code in 20+ languages and sync it with Git. Business teams build on the same platform with AI, while review, promotion between environments and isolated workers keep engineers in control of what ships. Self-hostable alternative to Lovable, Retool, n8n and a simplified Temporal.
  6. <p align=center>
  7. Scripts are turned into sharable UIs, APIs and cron jobs automatically, and can be composed together into flows, data pipelines, AI agents or full-code React and Svelte apps. Supported languages: Python, TypeScript, Go, Bash, SQL, GraphQL, PowerShell, Rust, and more.
  8. </p>
  9. <p align="center">
  10. <a href="https://github.com/windmill-labs/windmill/blob/main/LICENSE-AGPL" target="_blank">
  11. <img src="https://img.shields.io/badge/License-AGPLv3-blue.svg" alt="Package version">
  12. </a>
  13. <a href="https://github.com/windmill-labs/windmill/actions/workflows/docker-image.yml" target="_blank">
  14. <img src="https://github.com/windmill-labs/windmill/actions/workflows/docker-image.yml/badge.svg" alt="Docker Image CI">
  15. </a>
  16. <a href="https://pypi.org/project/wmill" target="_blank">
  17. <img src="https://img.shields.io/pypi/v/wmill?color=%2334D058&label=pypi%20package" alt="Package version">
  18. </a>
  19. </p>
  20. <p align="center">
  21. <a href="https://img.shields.io/github/commit-activity/m/windmill-labs/windmill" target="_blank">
  22. <img src="https://img.shields.io/github/commit-activity/m/windmill-labs/windmill" alt="Commit activity">
  23. </a>
  24. <a href="https://discord.gg/V7PM2YHsPB" target="_blank">
  25. <img src="https://discordapp.com/api/guilds/930051556043276338/widget.png" alt="Discord Shield"/>
  26. </a>
  27. </p>
  28. <p align="center">
  29. <a href="https://app.windmill.dev">Try it</a> - <a href="https://www.windmill.dev/">Website</a> - <a href="https://www.windmill.dev/docs/intro/">Docs</a> - <a href="https://discord.gg/V7PM2YHsPB">Discord</a> - <a href="https://hub.windmill.dev">Hub</a> - <a href="./CONTRIBUTING.md">Contributing</a>
  30. </p>
  31. # Windmill - Code-first platform for workflows, apps and AI agents
  32. Windmill is fully open-sourced (AGPLv3) and Windmill Labs offers dedicated instances and commercial support and licenses.
  33. ![Windmill Diagram](./imgs/stacks.svg)
  34. https://github.com/user-attachments/assets/d80de1d9-64de-4d89-aacd-6df23fa81fc4
  35. - [Windmill - Code-first platform for workflows, apps and AI agents](#windmill---code-first-platform-for-workflows-apps-and-ai-agents)
  36. - [Build with AI, ship with review](#build-with-ai-ship-with-review)
  37. - [Main Concepts](#main-concepts)
  38. - [What the code looks like](#what-the-code-looks-like)
  39. - [Data: data tables, DuckDB and DuckLake](#data-data-tables-duckdb-and-ducklake)
  40. - [Develop locally or in the browser](#develop-locally-or-in-the-browser)
  41. - [Stack](#stack)
  42. - [Fastest Self-Hostable Workflow Engine](#fastest-self-hostable-workflow-engine)
  43. - [Security](#security)
  44. - [Performance](#performance)
  45. - [Architecture](#architecture)
  46. - [How to self-host](#how-to-self-host)
  47. - [Docker compose](#docker-compose)
  48. - [Kubernetes (Helm charts)](#kubernetes-helm-charts)
  49. - [Cloud providers](#cloud-providers)
  50. - [OAuth, SSO \& SMTP](#oauth-sso--smtp)
  51. - [License](#license)
  52. - [Integrations](#integrations)
  53. - [Environment Variables](#environment-variables)
  54. - [Contributing](#contributing)
  55. - [Copyright](#copyright)
  56. ## Build with AI, ship with review
  57. Business teams and engineers build on the same Windmill instance. What the AI builds is an ordinary script, flow or app, and goes through the same review as code written by engineers:
  58. - [AI sessions](https://www.windmill.dev/docs/core_concepts/ai_sessions) build scripts, flows and apps with AI in a workspace fork, with a live preview and a diff to review before deploying.
  59. - [Workspace roles](https://www.windmill.dev/docs/core_concepts/roles_and_permissions#workspace-roles) decide what each team can author, and [folders](https://www.windmill.dev/docs/core_concepts/groups_and_folders) scope the resources, skills and MCP servers its AI can reach.
  60. - [Protection rulesets](https://www.windmill.dev/docs/core_concepts/protection_rulesets) block direct deployment, so changes reach production only after an engineer reviews and deploys them.
  61. - [Dev workspaces](https://www.windmill.dev/docs/advanced/dev_workspaces) keep their own credentials, and promote to prod through Compare & Deploy or a Git pull request.
  62. - [Worker groups](https://www.windmill.dev/docs/core_concepts/worker_groups) run AI-built code on its own workers, or on a [separate instance](https://www.windmill.dev/docs/core_concepts/staging_prod#deploy-to-a-workspace-on-another-instance).
  63. See [let business teams build with AI safely](https://www.windmill.dev/docs/advanced/ai_guardrails) for the full setup. Engineers keep writing code locally with the [CLI](https://www.windmill.dev/docs/advanced/cli), the [VS Code extension](https://www.windmill.dev/docs/cli_local_dev/vscode-extension) and their coding agent, synced with [Git](https://www.windmill.dev/docs/advanced/git_sync).
  64. ## Main Concepts
  65. 1. Define a minimal and generic script in Python, TypeScript, Go or Bash that solves a specific task. The code can be defined in the provided Web IDE or synchronized with your own GitHub repo (e.g. through VS Code extension): [provided Web IDE](https://www.windmill.dev/docs/code_editor) or [synchronized with your own GitHub repo](https://www.windmill.dev/docs/advanced/cli/sync) (e.g. through [VS Code](https://www.windmill.dev/docs/cli_local_dev/vscode-extension) extension):
  66. ![Step 1](./imgs/windmill-editor.png)
  67. 2. Your scripts parameters are automatically parsed and [generate a frontend](https://www.windmill.dev/docs/core_concepts/auto_generated_uis).
  68. ![Step 2](./imgs/windmill-run.png)
  69. ![Step 3](./imgs/windmill-result.png)
  70. 3. Make it [flow](https://www.windmill.dev/docs/flows/flow_editor)! You can chain your scripts or scripts made by the community shared on [WindmillHub](https://hub.windmill.dev).
  71. ![Step 3](./imgs/windmill-flow.png)
  72. 4. Build [complex UIs](https://www.windmill.dev/docs/apps/app_editor) on top of your scripts and flows.
  73. ![Step 4](./imgs/windmill-builder.png)
  74. Scripts and flows can be triggered by [schedules](https://www.windmill.dev/docs/core_concepts/scheduling), [webhooks](https://www.windmill.dev/docs/core_concepts/webhooks), [HTTP routes](https://www.windmill.dev/docs/core_concepts/http_routing), [Kafka](https://www.windmill.dev/docs/core_concepts/kafka_triggers), [WebSockets](https://www.windmill.dev/docs/core_concepts/websocket_triggers), [emails](https://www.windmill.dev/docs/core_concepts/email_triggers), and more.
  75. Build your entire infra on top of Windmill!
  76. ## What the code looks like
  77. A script is a plain function. Its typed arguments become a generated form, an HTTP endpoint and a CLI command:
  78. ```typescript
  79. import * as wmill from "windmill-client";
  80. import dayjs from "dayjs"; // any npm package, resolved and pinned automatically
  81. export async function main(
  82. customerId: string,
  83. plan: "starter" | "pro", // a union of strings becomes a dropdown
  84. trialDays = 14 // defaults infer the type
  85. ) {
  86. const trialEnd = dayjs().add(trialDays, "day").toISOString();
  87. // a data table: the workspace's Postgres, queried without a connection string
  88. const sql = wmill.datatable();
  89. await sql`INSERT INTO trials (customer_id, plan, trial_end) VALUES (${customerId}, ${plan}, ${trialEnd})`.fetch();
  90. // secrets are permissioned by path
  91. const slackToken = await wmill.getVariable("f/sales/slack_token");
  92. await fetch("https://slack.com/api/chat.postMessage", {
  93. method: "POST",
  94. headers: { Authorization: `Bearer ${slackToken}`, "Content-Type": "application/json" },
  95. body: JSON.stringify({ channel: "#sales", text: `New ${plan} trial: ${customerId}` }),
  96. });
  97. console.log(`Trial started for ${customerId}`); // logs stream live in the UI
  98. return { customerId, plan, trialEnd }; // returned as JSON
  99. }
  100. ```
  101. Workflows are code too. Each task runs as its own job with its own logs, and waiting for an approval releases the worker:
  102. ```typescript
  103. import { task, waitForApproval, workflow } from "windmill-client";
  104. async function plan(env: string) {
  105. return { env, changes: 3 };
  106. }
  107. async function apply(plan: { env: string; changes: number }) {
  108. return `applied ${plan.changes} changes to ${plan.env}`;
  109. }
  110. export const main = workflow(async (env: string) => {
  111. const changes = await task(plan)(env);
  112. const approval = await waitForApproval({ timeout: 3600 });
  113. if (!approval.approved) {
  114. return `rejected by ${approval.approver}`;
  115. }
  116. return await task(apply)(changes);
  117. });
  118. ```
  119. Flows can also be built in the visual [flow editor](https://www.windmill.dev/docs/flows/flow_editor) or as YAML, with scripts like the first one as steps. See [workflows as code](https://www.windmill.dev/docs/core_concepts/workflows_as_code).
  120. ## Data: data tables, DuckDB and DuckLake
  121. - [Data tables](https://www.windmill.dev/docs/core_concepts/persistent_storage/data_tables) give each workspace managed Postgres tables, queried with type-checked SQL from TypeScript, Python and DuckDB scripts without exposing a connection string.
  122. - [DuckDB](https://www.windmill.dev/docs/integrations/duckdb) scripts query S3 and Azure Blob files (CSV, Parquet, JSON), data tables, Postgres, MySQL and BigQuery in SQL, on your workers.
  123. - [DuckLake](https://www.windmill.dev/docs/core_concepts/persistent_storage/ducklake) stores large datasets as lakehouse tables in your workspace object storage, queried in plain SQL.
  124. - [Pipelines](https://www.windmill.dev/docs/core_concepts/pipelines) (alpha) wire scripts by the data they read and write instead of a hand-drawn DAG. This script runs whenever `events` is materialized, and materializes its own table:
  125. ```sql
  126. -- pipeline
  127. -- on ducklake://main/events
  128. -- materialize ducklake://main/events_by_kind
  129. ATTACH 'ducklake://main' AS dl;
  130. SELECT kind, count(*) AS n
  131. FROM dl.events
  132. GROUP BY kind;
  133. ```
  134. Existing [dbt projects](https://www.windmill.dev/docs/getting_started/scripts_quickstart/dbt) run unmodified as scripts. See the [pipelines quickstart](https://www.windmill.dev/docs/getting_started/pipeline_quickstart).
  135. ## Develop locally or in the browser
  136. Engineers work from their editor and coding agent, business teams build with AI in the browser, and both land in the same workspace:
  137. | Tool | Description |
  138. |------|-------------|
  139. | **[CLI](https://www.windmill.dev/docs/advanced/cli)** | Sync a workspace with local files and Git, run scripts and flows from the command line. `wmill init` generates `AGENTS.md` and [skill files](https://www.windmill.dev/docs/misc/guides/local_dev_with_ai) for Claude Code, Cursor and other AI tools |
  140. | **[VS Code extension](https://www.windmill.dev/docs/cli_local_dev/vscode-extension)** | Edit and test scripts and flows from VS Code or Cursor with full IDE support |
  141. | **[Git sync](https://www.windmill.dev/docs/advanced/git_sync)** | Two-way sync between a workspace and your Git repository |
  142. | **[MCP server](https://www.windmill.dev/docs/core_concepts/mcp)** | Let coding agents and AI clients run scripts, manage resources and monitor jobs in a workspace |
  143. | **[AI sessions](https://www.windmill.dev/docs/core_concepts/ai_sessions)** | The same agent loop in the browser, with nothing to install: plan mode, skills and MCP servers, a live preview, and a diff to review before deploying, in a fork of the workspace |
  144. https://github.com/user-attachments/assets/c541c326-e9ae-4602-a09a-1989aaded1e9
  145. You can run scripts locally by passing the right environment variables for the `wmill` client library to fetch resources and variables from your instance. See [local development docs](https://www.windmill.dev/docs/advanced/local_development).
  146. ## Stack
  147. - **Database**: Postgres (compatible with Aurora, Cloud SQL, Neon, Azure PostgreSQL)
  148. - **Backend**: Rust - stateless API servers and workers pulling jobs from a Postgres queue
  149. - **Frontend**: Svelte 5
  150. - **Sandboxing**: [nsjail](https://github.com/google/nsjail) and PID namespace isolation
  151. - **Runtimes**:
  152. - TypeScript/JavaScript: Bun (default); Deno only on the `windmill-full` images
  153. - Python: python3 with uv for dependency management
  154. - PHP: only on the `windmill-full` images
  155. - Go, Bash, PowerShell, Rust, C#, Java, Ansible
  156. ## Fastest Self-Hostable Workflow Engine
  157. We have compared Windmill to other self-hostable workflow engines (Airflow,
  158. Prefect & Temporal) and Windmill is the most performant solution for both
  159. benchmarks: one flow composed of 40 lightweight tasks & one flow composed of 10
  160. long-running tasks.
  161. All methodology & results on our
  162. [Benchmarks](https://www.windmill.dev/docs/misc/benchmarks/competitors#airflow-setup)
  163. page.
  164. ![Fastest workflow engine](./imgs/fastest.png)
  165. ## Security
  166. - **Sandboxing**: [nsjail](https://github.com/google/nsjail) for filesystem/resource isolation, and PID namespace isolation (enabled by default) to prevent jobs from accessing worker process memory
  167. - **Secrets**: One encryption key per workspace for credentials stored in Windmill's K/V store. We recommend encrypting the Postgres database as well.
  168. See [Security documentation](https://www.windmill.dev/docs/advanced/security_isolation) for details.
  169. ## Performance
  170. Once a job started, there is no overhead compared to running the same script on
  171. the node with its corresponding runner (Deno/Go/Python/Bash). The added latency
  172. from a job being pulled from the queue, started, and then having its result sent
  173. back to the database is ~50ms. A typical lightweight deno job will take around
  174. 100ms total.
  175. ## Architecture
  176. Stateless API servers and workers share a PostgreSQL database that holds the job queue and all workspace state (remote agent workers go through the API servers instead). Workers pull jobs by tag, so each worker group can run in its own network, for example dev workers that only reach dev systems and prod workers that only run reviewed code.
  177. <picture>
  178. <source media="(prefers-color-scheme: dark)" srcset="./imgs/architecture-dark.svg">
  179. <img alt="Windmill architecture: business teams and engineers build through stateless API servers into workspaces, where changes move from dev and forks to prod after review. PostgreSQL holds the job queue and state. Worker groups for dev and prod, native workers and remote agent workers pull jobs by tag and reach your databases, APIs and AI model providers." src="./imgs/architecture-light.svg">
  180. </picture>
  181. ## How to self-host
  182. For detailed setup options, see [Self-Host documentation](https://www.windmill.dev/docs/advanced/self_host).
  183. ### Docker compose
  184. Deploy Windmill with 3 files ([docker-compose.yml](./docker-compose.yml), [Caddyfile](./Caddyfile), [.env](./.env)):
  185. ```bash
  186. curl https://raw.githubusercontent.com/windmill-labs/windmill/main/docker-compose.yml -o docker-compose.yml
  187. curl https://raw.githubusercontent.com/windmill-labs/windmill/main/Caddyfile -o Caddyfile
  188. curl https://raw.githubusercontent.com/windmill-labs/windmill/main/.env -o .env
  189. docker compose up -d
  190. ```
  191. Go to http://localhost - default credentials: `admin@windmill.dev` / `changeme`
  192. **Using an external database**: Set `DATABASE_URL` in `.env` to point to your managed Postgres (AWS RDS, GCP Cloud SQL, Azure, Neon, etc.) and set db replicas to 0.
  193. ### Kubernetes (Helm charts)
  194. ```bash
  195. helm repo add windmill https://windmill-labs.github.io/windmill-helm-charts/
  196. helm install windmill-chart windmill/windmill --namespace=windmill --create-namespace
  197. ```
  198. See [windmill-helm-charts](https://github.com/windmill-labs/windmill-helm-charts) for configuration options.
  199. ### Cloud providers
  200. Windmill works on AWS (EKS/ECS), GCP, Azure, Ubicloud, Fly.io, Render.com, Hetzner, Digital Ocean, and others. Rule of thumb: 1 worker per 1vCPU and 1-2 GB RAM.
  201. ### OAuth, SSO & SMTP
  202. Configure OAuth and SSO (Google Workspace, Microsoft/Azure, Okta) directly from the superadmin UI. [See documentation](https://www.windmill.dev/docs/misc/setup_oauth).
  203. ### License
  204. - Using the Community Edition as is, internally or through its APIs, is free and needs no commercial license, within the limits and quotas set in the software.
  205. - Selling, reselling or serving the Community Edition as a managed service, modifying or wrapping it, or re-exposing it to your users as a feature of your product (iframed public apps excepted) requires a commercial license: contact <sales@windmill.dev>.
  206. - The binary built from this repository without the `enterprise` feature flag is open source under [AGPLv3](./LICENSE-AGPL): the same uses are then allowed under the AGPLv3 terms, or with a commercial license. The API clients and the OpenAPI spec are [Apache 2.0](./LICENSE-APACHE).
  207. See [LICENSE](./LICENSE) for the full terms and [Pricing](https://www.windmill.dev/pricing) for plans.
  208. ### Integrations
  209. In Windmill, integrations are referred to as [resources and resource types](https://www.windmill.dev/docs/core_concepts/resources_and_types). Each Resource has a Resource Type that defines the schema that the resource
  210. needs to implement.
  211. On self-hosted instances, you might want to import all the approved resource types from [WindmillHub](https://hub.windmill.dev). A setup script will prompt you to have it being synced automatically everyday.
  212. ## Environment Variables
  213. The variables most deployments set:
  214. | Environment Variable name | Default | Description | Api Server/Worker/All |
  215. | ------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------ | --------------------- |
  216. | DATABASE_URL | | The Postgres database url. | All |
  217. | MODE | standalone | The mode of the binary: standalone, server, worker, agent (EE), indexer (EE image, full-text search), mcp | All |
  218. | WORKER_GROUP | default | The worker group the worker belongs to and gets its configuration pulled from | Worker |
  219. | BASE_URL | http://localhost:8000 | The base url that is exposed publicly to access your instance. Is overriden by the instance settings if any. | Server |
  220. | LICENSE_KEY (EE only) | None | License key checked at startup for the Enterprise Edition of Windmill | Worker |
  221. All other variables (database pool, queue, runtimes, private registries, certificates, zombie jobs and more) are documented in the [environment variables reference](https://www.windmill.dev/docs/core_concepts/environment_variables).
  222. ## Contributing
  223. At this time, we are not seeking outside contribution. Bug reports and feature requests remain very
  224. welcome, and small, trivially-verified PRs that fix a problem are still accepted. See
  225. [CONTRIBUTING.md](./CONTRIBUTING.md) for the full policy.
  226. To run Windmill from source, see [frontend/README_DEV.md](./frontend/README_DEV.md).
  227. ## Copyright
  228. © 2023-2026 Windmill Labs, Inc.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.