Windmill is an open-source developer platform that enables teams to build, deploy, and monitor internal software — including APIs, background jobs, workflows, and custom UIs — without requiring platform engineering teams. It turns scripts written in Python, TypeScript, Go, Bash, SQL, and 20+ other languages into executable endpoints, scheduled jobs, and interactive applications with auto-generated UIs. Designed as a self-hostable alternative to Retool, Pipedream, and Temporal, Windmill provides full code control with Git-based collaboration and zero-ops infrastructure.
Built with Rust for the backend, Svelte 5 for the frontend, and PostgreSQL for state management, Windmill runs on Docker, Kubernetes, or cloud platforms like AWS and GCP. It supports sandboxed script execution via nsjail, integrates with OAuth, SSO, and SMTP, and offers AI-assisted development through Claude and VS Code extensions. The platform is AGPLv3-licensed with commercial licensing options for redistribution or managed services.
What You Get
- Auto-generated UIs - Windmill automatically generates interactive web interfaces for scripts based on their parameters, eliminating manual frontend development for internal tools.
- Flow Editor - A visual DAG editor to chain scripts and workflows together with dependencies, enabling complex orchestration without custom code.
- Multi-language Script Support - Run scripts in Python, TypeScript, Go, Bash, SQL, PowerShell, Rust, PHP, Java, C#, and Ansible with full LSP and dependency management via uv and Bun.
- Git Sync & VS Code Extension - Two-way synchronization between Windmill and GitHub repositories, with full IDE support for editing, testing, and deploying scripts directly from VS Code or Cursor.
- Webhook & Event Triggers - Each script and flow auto-exposes HTTP webhooks and supports triggers from Kafka, WebSockets, emails, schedules, and HTTP routes for event-driven automation.
- Self-Hostable & Kubernetes Ready - Deploy Windmill via Docker Compose or Helm charts on Kubernetes, with support for AWS EKS, GCP Cloud SQL, Azure, Neon, and other managed PostgreSQL services.
Common Use Cases
- Building internal data pipelines - A data engineer uses Windmill to orchestrate Python scripts that pull from Snowflake, transform data with SQL, and push results to a dashboard — all without writing a single line of backend infrastructure code.
- Automating customer onboarding workflows - A SaaS company creates a flow that triggers on new signups, sends Slack alerts, provisions resources via API calls, and emails users — all using auto-generated UIs for non-technical teams to monitor progress.
- Creating low-code admin dashboards - A product manager builds a custom UI to approve content changes by chaining a script that fetches data from PostgreSQL with a form UI and a notification flow — no frontend developer needed.
- Running high-throughput batch jobs - A finance team schedules 100+ daily scripts to reconcile transactions across systems using Windmill’s sub-20ms job orchestration and dedicated worker groups on Kubernetes.
Under The Hood
Architecture
- Modular monolith design with clear separation between server (REST API, flow engine) and worker (job execution, Docker-in-Docker isolation) components, enabling scalable and secure execution
- Dependency injection via environment variables and configuration-driven service registration, eliminating hard-coded dependencies and enhancing deploy-time flexibility
- Flow execution engine uses declarative JSON-based schemas (FlowValue, FlowModule) to define composable workflows with conditional logic, scripts, and subflows
- Native and Docker-based workers are isolated via process boundaries and environment flags, maintaining consistent semantics while enforcing security
- OpenAPI specification serves as the single source of truth for flow contracts, ensuring alignment between API, frontend, and backend
- Containerized orchestration with health checks and service dependencies ensures reliable inter-service communication and fault tolerance
Tech Stack
- PostgreSQL 16 deployed in Docker with health checks for data reliability
- Rust backend with Cargo and sccache for optimized builds, featuring DuckDB FFI and native WASM parser support
- Node.js 24 Alpine frontend with Vite, built via multi-stage Docker and auto-generating TypeScript clients from OpenAPI
- Docker Compose orchestrates server, worker, and Docker-in-Docker services with isolated execution environments
- OpenFlow OpenAPI 3.0.3 defines flow semantics, modules, and concurrency controls as a contract-first specification
- WebMux and MCP integration enables tmux-based service orchestration and AI agent-assisted developer workflows
Code Quality
- Comprehensive test suite covering unit, integration, and end-to-end scenarios with clear separation across frontend, backend, and API layers
- Strong type safety enforced in both TypeScript and Rust, with explicit interfaces and schema validation in test assertions
- Robust error handling through structured logging, custom error types, and precise HTTP status validation
- Consistent, descriptive naming and modular boundaries across languages, with test files focused on behavior over mocks
- Linting and static analysis integrated into development workflows, with CI/CD pipelines validating data consistency and storage behavior in production-like environments
What Makes It Unique
- Svelte 5 reactivity is deeply integrated with dynamic UI configuration systems, unifying component state, styling, and configuration in a single declarative flow without boilerplate
- Flow scheduling dynamically binds UI controls to backend state with automatic deployment detection and conflict-aware updates, removing reliance on external orchestration tools
- UI components are treated as configurable, style-resolvable modules with runtime injection and CSS scoping, enabling non-developers to customize behavior via JSON
- Indexer settings UI exposes low-level Elasticsearch optimizations through intuitive form controls with contextual guidance, bridging infrastructure tuning and end-user experience
- Svelte’s reactive stores directly subscribe to and mutate backend state, eliminating middleware layers and reducing complexity while preserving maintainability