Rill

Rill is an open-source business intelligence tool that treats dashboards, metrics, and semantic definitions as code. Instead of clicking through a drag-and-drop UI, you define SQL models, YAML metrics views (dimensions, measures, time grains), and explore dashboards as version-controlled files, then Rill compiles them into sub-second queries against an embedded DuckDB engine or a managed/external ClickHouse cluster. A single rill start command scaffolds a project and opens a local dashboard UI, while rill deploy pushes the same project to Rill Cloud for git-backed, versioned collaboration.

What sets Rill apart from most self-hosted BI tools is that it was built from the ground up to be operated by both humans and AI agents. The runtime ships a dedicated agent layer with a router agent that dispatches prompts to specialized analyst, developer, and feedback agents, all exposed as typed tools over the Model Context Protocol (MCP) — so Claude Code, Cursor, or Rill’s own conversational BI chat can read, write, and query a project through the same interface. rill init can scaffold a project with ready-made Claude/Cursor agent instructions out of the box.

Under the hood, a reconciler-based controller (the same pattern used by Kubernetes operators) continuously reconciles the desired state expressed in your project’s code against the actual state of connected data infrastructure — sources, models, metrics views, alerts, and reports are all resources it manages. A parser compiles Rill project files into an internal representation, and a dedicated metrics-view layer translates a single semantic definition into dialect-specific SQL for whichever OLAP engine is attached (ClickHouse, DuckDB, Druid, Pinot, and more), so the same metrics view can be queried consistently across engines.

Rill supports 20+ data connectors (S3, GCS, BigQuery, Athena, Redshift, Databricks, Kafka, Salesforce, and more), row-level access policies for per-user data security, incremental ingestion for large datasets, and deployable APIs/embeds for shipping dashboards inside your own product. The entire codebase — including the Rill Cloud control plane, billing, and provisioning code — is released under the Apache 2.0 license.

What You Get

• Rill Developer — a local, embedded BI environment (rill start) with a managed DuckDB or ClickHouse engine, instant data profiling, and a live dashboard preview, all running on your machine with no signup required.
• BI-as-code project model — models, metrics views, dashboards, alerts, and APIs are plain YAML and SQL files that live in your git repo, get code-reviewed like any other code, and deploy via rill deploy or CI/CD.
• Agent-native runtime — a typed, MCP-exposed multi-agent system (router, analyst, developer, feedback agents) that lets Claude Code, Cursor, or any MCP-aware agent read, edit, and query a Rill project’s files and metrics directly.
• Cross-engine semantic layer — a single metrics view (dimensions, measures, time grains) compiles to dialect-specific SQL for ClickHouse, DuckDB, Druid, Pinot, or MotherDuck, so you don’t rewrite queries per engine.
• Rill Cloud deployment — git-backed, versioned deployment of a project with automatic CI/CD, interactive Explore and Canvas dashboards, conversational natural-language BI, and embeddable custom APIs.
• Governed row-level security — per-user and per-group access policies defined alongside the metrics view so the same dashboard shows different rows to different viewers without duplicating dashboards.
• 20+ data connectors — first-class support for S3, GCS, BigQuery, Athena, Redshift, Databricks, Snowflake-adjacent warehouses, Kafka, and Salesforce, in addition to local file and database sources.

Common Use Cases

• Embedding customer-facing analytics — product teams ship interactive dashboards or custom REST APIs directly inside their own application using Rill Cloud’s embedding support instead of building a bespoke charting layer.
• Version-controlled internal BI — data teams replace a drag-and-drop dashboard tool with YAML/SQL metrics views that go through the same PR review, CI, and git history as the rest of the codebase.
• Agent-assisted dashboard authoring — analysts use Claude Code or Cursor (via MCP) to scaffold new metrics views, debug a broken model, or answer an ad hoc question, with the agent operating on the live project through Rill’s tool interface.
• Real-time operational dashboards on ClickHouse — engineering and ops teams point Rill at an existing ClickHouse cluster to get sub-second dashboards over billions of rows of event or log data without standing up a separate BI stack.
• Fast local data exploration — analysts drop a Parquet or CSV file into rill start to get instant column profiling and an interactive dashboard before deciding whether the dataset is worth productionizing.

Under The Hood

Architecture Rill is organized as a Go monorepo split cleanly between a data plane and a control plane: runtime is the embeddable data-plane component (used both inside Rill Developer locally and deployed standalone in Rill Cloud) that owns parsing, reconciliation, connectors, and query execution, while admin implements the cloud control plane (projects, deployments, billing, provisioning). Within runtime, a Kubernetes-style reconciler pattern is the central abstraction: a parser compiles a project’s YAML/SQL files into typed resources, and per-resource reconcilers (sources, models, metrics views, themes, alerts) continuously drive the desired state expressed in code toward the actual state of connected data infrastructure. A separate resolvers package unifies how metrics queries, alerts, reports, and APIs all resolve data, and a metricsview package compiles a single semantic definition into dialect-specific SQL per OLAP engine. This is a genuinely modular, well-documented layering — the CLI (cli/) is a thin entry point over the runtime, and both runtime/README.md and admin/README.md explicitly describe the responsibilities of each subpackage.

Tech Stack The backend is Go 1.26, exposing gRPC/Connect-RPC APIs (connectrpc.com/connect plus vanguard for REST transcoding) generated from protobufs in proto/. It embeds DuckDB and speaks ClickHouse, Druid, Pinot, BigQuery, Athena, Redshift, Databricks, MySQL, Postgres, and Snowflake-adjacent engines through a common driver interface, uses Apache Arrow for columnar interchange, and integrates the Anthropic, OpenAI, and Gemini SDKs alongside the official MCP Go SDK for agent tooling. Background jobs run on the River queue, and billing runs through Orb. The frontend is an npm workspace (web-admin, web-common, web-local, web-integration) built on SvelteKit 2 with Svelte 5, TanStack Query, Vite, and TypeScript, tested with Vitest and Playwright. Releases are cut with GoReleaser and shipped as a single static binary plus a Docker image that installs DuckDB extensions at build time.

Code Quality The Go side carries an extensive test suite (hundreds of _test.go files) built on testify, run through dedicated CI workflows for linting, testing with coverage, and CodeQL security scanning. .golangci.yml enables a strict linter set — gosec, errcheck, errorlint, errname, exhaustruct, revive, staticcheck, and a testpackage rule that forces black-box test packages — and errors are explicitly wrapped with fmt.Errorf("...: %w", err) rather than swallowed, consistent with patterns seen throughout the agent-tooling code. The TypeScript/Svelte frontend is linted with ESLint and Prettier, type-checked with svelte-check, and covered by both unit tests (Vitest) and end-to-end tests (Playwright) across dedicated CI workflows.

What Makes It Unique Most open-source BI tools treat AI as a chat box bolted onto existing dashboards. Rill instead exposes its runtime as a typed, MCP-native tool surface: a RouterAgent dispatches prompts to specialized AnalystAgent, DeveloperAgent, and FeedbackAgent implementations, each defined against a generic Tool[Args, Result] interface with JSON-schema-typed arguments, so external coding agents and Rill’s own conversational BI chat share exactly the same file-read/write, metrics-query, and project-navigation primitives. Combined with the reconciler-driven BI-as-code model and a semantic layer that compiles once and executes across multiple OLAP dialects, Rill’s differentiation is architectural rather than cosmetic — the agent-first positioning is backed by a dedicated runtime/ai package, not a thin wrapper around a hosted LLM API.

Self-Hosting

Licensing Model Apache License 2.0 — the entire monorepo, including the code that powers the Rill Cloud control plane (admin, billing, provisioning), is released under this permissive license with no separate enterprise edition or license-gated source files found in the repository.

Self-Hosting Restrictions No feature flags, license-key checks, or isEnterprise/requiresLicense-style gates were found in the codebase. Rill Developer (the local BI environment) is fully functional when self-hosted.

Enterprise Features Rill Cloud is Rill’s own hosted deployment of the same open-source runtime, adding git-backed deployment/CI-CD, multi-user collaboration, natural-language conversational BI, hosted alerting/reporting, and managed billing (via the admin service) — these are operational/hosting conveniences rather than gated code paths, since the underlying source is in the same repository.

Cloud vs Self-Hosted Self-hosting requires standing up your own deployment, git integration, and (if desired) billing/multi-tenant provisioning yourself using the admin package; Rill Cloud provides this as a managed service.

License Key Required No. No license key or activation step was found anywhere in the CLI, runtime, or admin code paths.