DOCSEARCHbyAlgolia
Submit Docs

Windmill Documentation

website·Indexed 35 days ago

https://docs.windmill.dev/

An open-source and self-hostable workflow engine and developer platform to build, orchestrate, and monitor internal software. Features include a CLI (wmill), browser automation with Playwright, Git synchronization, and client libraries for Python, Rust, and TypeScript.

Tokens
286.8K
Snippets
964
Records
2.2K
Agent score
63%

What's inside Windmill

  1. Overview of Windmill Table Components

    Windmill provides three distinct table-based components depending on the use case:

    • Table component: Best for most general use cases. It accepts an array of objects and uses object keys as headers. Supports action buttons and dropdowns based on row data.
    • AgGrid table: A wrapper around the AgGrid library providing advanced data grid features. Available in both free and Enterprise versions.
    • Database studio: A web-based management tool specifically for displaying and editing database content.

  2. Overview of Windmill MCP capabilities

    Windmill supports the Model Context Protocol (MCP), enabling LLMs (such as Claude, Cursor, and other MCP-compatible clients) to interact with Windmill. This allows users to trigger scripts and flows from a chat interface and provides API access to manage the following core entities:

    • Jobs: Monitor and manage job executions, track progress, and retrieve logs.
    • Resources: Create, read, update, and delete third-party system connections (e.g., databases, APIs).
    • Variables: Manage workspace variables and secrets for secure configuration.
    • Schedules: Control CRON-like automation for scripts and flows.
    • Workers: Monitor worker status, configuration, and resource allocation.

  3. Overview of Windmill Workers and Worker Groups

    Workers are autonomous processes that execute scripts and jobs in Windmill. They pull jobs from a queue based on the scheduled_for timestamp. By default, workers are interchangeable, but "worker groups" allow you to isolate jobs to specific pools of workers. This is useful for targeting scripts to machines with specific hardware (e.g., GPUs, high-memory) or pre-installed binaries. Worker groups listen to specific "tags," which act as queue names for flows and flow steps.

  4. Overview of the Windmill Code Editor

    The Windmill code editor is an integrated development environment (IDE) used to write scripts and build logic across several areas of the platform:

    • Scripts: The primary environment for building standalone scripts.
    • Flows: Used within the Flow editor to build individual steps.
    • Low-code Apps: Used to add inline scripts within the app editor.
    • Full-code Apps: Used in the UI editor to manage both frontend and backend code.

    Supported languages include TypeScript, Python, Go, Bash, and SQL. Additionally, any Docker container can be executed via Windmill's Bash support.

  5. Overview of the Decision Tree app component

    The Decision Tree component allows developers to create a flow-like structure where each node represents a decision point with its own subgrid. Based on specified conditions, the tree determines which subsequent node(s) the user will navigate to.

  6. Overview of Windmill Assets and Supported URIs

    Assets in Windmill track data flows and visualize data sets by detecting references in code. They are identified using specific URI schemes and are supported for Python, JavaScript, TypeScript, and DuckDB. Volume assets are an exception and are detected via volume: annotations in any supported language, including PHP and Go.
    - S3 objects: s3://storage/path/to/file.csv
- Resources: res://path/to/resource
- Volumes: volume://name
- dbt models: dbt://warehouse/schema/model

  7. Overview of AI Agent Evaluations

    Evals allow developers to determine if changes to an AI agent improve its performance by running the agent against a curated dataset of cases and scoring the results using AI judges or scripts. Evals are attached to reusable ai_agent resources; agents written inline in a flow step must be saved as reusable agents to use this feature.

  8. Overview of Windmill Native Triggers

    Native triggers enable external services to push events directly to Windmill via webhooks, triggering scripts or flows in real-time. This is an alternative to scheduled polling. Currently, Windmill supports native triggers for Nextcloud (file, folder, and calendar events) and Google (Drive and Calendar events).

  9. Overview of Windmill Full-code apps

    Full-code apps allow developers to build custom frontends using React or Svelte. Unlike low-code apps, full-code apps provide complete control over the UI, styling (CSS, Tailwind), and frontend logic (hooks, stores, routing). They connect to Windmill backend runnables and data tables. The frontend communicates with the execution engine via a WebSocket through an auto-generated wmill.ts module.

  10. Overview of Windmill Workspace Dependencies

    Workspace dependencies allow for central management of dependencies at the workspace level. Instead of defining dependencies per script, you create shared dependency files in the /dependencies directory that multiple scripts can reference. This ensures consistent environments and provides better control over dependency resolution.

  11. Overview of Ducklake persistent storage

    Ducklake allows you to store massive amounts of data in S3 and query it efficiently using natural SQL language. It uses DuckDB as its native query engine. Other integrations (TypeScript, Python) run DuckDB scripts inline within the same worker without starting a new job.

  12. Overview of ETL and data processing in Windmill

    Windmill supports ETL (Extract, Transform, Load) processes by treating them as Directed Acyclic Graphs (DAGs) of jobs. It is designed for high-performance data processing by streaming large datasets from object storage and processing them with DuckDB, avoiding the need to load entire datasets into memory. Each processing step is an independent script that can be written in the language best suited for the transformation.