bino cliOpen source · AGPL-3.0Commercial licence available

Your monthly reporting, under version control.

bino turns YAML manifests and SQL queries into IBCS PDFs. The definition lives in your repository and the build runs in your pipeline. The same manifests and data give the same report next quarter.

Read the docs Install Contact us bino-bi/bino-cli6AGPL-3.0

macOS · Linux · Windows
Runs in CI and Docker
No seat licences
AGPL-3.0

Install

One binary, then one command

The installer puts a single binary on your PATH. bino setup then downloads the browser runtime that renders the PDF, once and not per build. The container image already has it.

brew install bino-bi/tap/bino-cli
bino setup

/bin/bash -c "$(curl -fsSL https://github.com/bino-bi/bino-cli-releases/releases/latest/download/install.sh)"
bino setup

irm https://github.com/bino-bi/bino-cli-releases/releases/latest/download/install.ps1 | iex
bino setup

docker run --rm -v "$PWD:/work" ghcr.io/bino-bi/bino-cli:latest build --out-dir dist/

Supported on macOS (Intel and Apple Silicon), Linux x86_64 and arm64, and Windows x86_64. The container image is published for linux/amd64 and linux/arm64.

Why it matters

A report is a deliverable. Build it like one.

A report built by hand in a spreadsheet is hard to review, hard to diff, and hard to rebuild when its author is away. A report defined as code fixes all three.

Reviewed before it ships

A change to a report is a pull request. Someone reads the diff and approves it. The Git history shows who changed which figure and why.

The same output every time

Same manifests, same data, same PDF. A scheduled job renders the month-end pack, so nobody assembles it by hand under time pressure.

One visual standard

IBCS notation is built in. The engine draws scenarios, variances and scaling, not the person who builds the slide. Every report reads the same way.

No seat licence for readers

The output is a PDF. Anyone can read it without a licence, an account or a dashboard tool. Authors work in the editor they already use.

How it works

Scaffold, iterate, automate, serve

Four steps cover the life of a report, from an empty folder to a PDF your pipeline builds every month.

bino init writes a working bundle: a data source, a dataset, an IBCS table, a chart, a style and translations, in the standard folders.

# the full reference bundle
bino init standard -d my-report
cd my-report

# fetch the browser runtime once
bino setup

# render every artefact into dist/
bino build --out-dir dist/

Without a source argument, bino init writes the smaller minimal scaffold. A source can also be a remote template.

While you shape a report, preview reloads in the browser on every save. lint finds manifest problems before a build starts.

# live preview on 127.0.0.1:45678, reloading on save
bino preview

# check the manifests without rendering
bino lint

# see what depends on what
bino graph

Your editor gets the same checks: the VS Code extension, or bino lsp for any editor that speaks LSP.

In CI it is one install step and one build step. This is the recipe from the docs, unchanged:

name: Build Reports
on:
  push:
    branches: [main]
  schedule:
    - cron: "0 6 1 * *"
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest
    env:
      CI: "1"
      POSTGRES_PASSWORD: ${{ secrets.POSTGRES_PASSWORD }}
      DB_HOST: ${{ secrets.DB_HOST }}

    steps:
      - uses: actions/checkout@v4

      - name: Install bino
        run: |
          /bin/bash -c "$(curl -fsSL https://github.com/bino-bi/bino-cli-releases/releases/latest/download/install.sh)"
          bino setup

      - name: Build reports
        run: bino build --out-dir dist/

      - name: Upload PDFs
        uses: actions/upload-artifact@v4
        with:
          name: reports
          path: dist/

Environment variables go into manifests as ${VAR} or ${VAR:default}. preview warns about unresolved variables. build fails and lists them, so a pipeline never renders a report with an empty filter.

A LiveReportArtefact is served as an interactive web app instead of a PDF. Same manifests, rendered on request:

bino serve --live sales_dashboard --port 8080

The slim container image runs serve, lint, graph, lsp and mcp without a browser. The full image adds Chromium for build and preview.

What you define

Every part of a report is a YAML document

Data, components, page layout, style, translations and the output itself. Each is a document with a kind and a spec. There is no binary project file.

DataSourceDataSetConnectionSecretTableChartStructureChartTimeChartScatterChartBubbleChartBulletTreeGridTextImageAssetLayoutPageLayoutCardComponentStyleRuleSetScalingGroupInternationalizationReportArtefactDocumentArtefactLiveReportArtefactScreenshotArtefactSigningProfile

Agentic reporting

Let an agent write the manifests

A bino report is plain YAML and SQL, so an AI agent can write it. bino gives the agent the same schema and checks that guide a human author.

One pass through the MCP tools

introspect_source reads the columns and sample rows of a CSV, Excel file or database.
validate_draft checks a manifest against the schema in memory, before it is saved.
write_manifest writes the manifest. Every write is validated first, and atomic.
get_rows returns rows from a DataSet, so the agent can check its numbers.
build runs bino build and returns the PDF it produced.
get_layout_state reports what rendered: empty components, overflow, fitted fonts.

Watch a real agent run, with every tool call and the PDFs →

bino mcp

A Model Context Protocol server over stdio. Works with Claude Code, Claude Desktop, Cursor and other MCP clients. It also serves the IBCS rules as readable skills.

Claude Code plugin

Registers bino mcp for you and adds IBCS knowledge, slash commands such as /bino:report, and an autopilot that pauses for your approval at each checkpoint.

bino lint

Validates manifests and runs the lint rules without building. Fast enough to run after every change an agent makes, and in CI.

Plugins · early access

Extend bino with your own code

Plugins are separate programs that bino starts and talks to over gRPC. The plugin SDK for Go is Apache-2.0 licensed and still at v0.0.x, so expect the API to change.

Data sources for APIs or systems bino does not read yet
Visual components as Web Components
Lint rules for your own reporting conventions
Pipeline hooks after load, dataset, render
Commands under bino plugin exec

Plugin guide Plugin SDK on GitHub

Licensing

AGPL-3.0, or a commercial licence

bino is dual licensed. Most teams use it under the AGPL. The commercial licence covers the cases where the AGPL does not fit.

AGPL-3.0

free

Free to use, change and run, internally or commercially, at any scale.
No seat limits and no feature gates.
If you change bino and offer the changed version as a network service, you must publish that changed source.
Building your own reports with unchanged bino creates no obligation.

Commercial licence

enterprise

For organisations whose policy does not allow AGPL software.
For embedding bino in a closed-source product.
For running a SaaS on top of bino without publishing your changes.
Written terms for procurement and legal.

Licence and support

The CLI is complete without paying

Every feature is in the open-source version. If your organisation needs other licence terms, or wants our help, those are available too.

Open source

bino cli

Free

The whole CLI, under AGPL-3.0.

Every feature, no seat limits, no gated flags
CSV, Excel, Parquet, PostgreSQL and MySQL sources
PDF, live web reports and digitally signed documents
VS Code extension, language server and MCP server
Community support on GitHub

Licence

Commercial licence

On request

The same software, on other terms.

No AGPL obligations
Embed bino in a closed-source product
Run a service on top of bino without publishing changes
Written terms for procurement and legal
Priced per organisation, not per seat

Help

Support & coaching

On request

Our team next to yours while you start.

Response times agreed in writing
Bug fixes and feature requests with priority
IBCS workshops for authors and readers
We build your first reports with your team
Help with upgrades and integration

The core stays open source

You never need the commercial licence or our services to use bino cli. They pay for its development.

Technical detail

What your architects will ask

How bino queries, renders and guards a report. Each point is documented at cli.bino.bi.

Data

SQL runs in an embedded DuckDB engine, with its full dialect. No separate database to run.
Sources: CSV, Excel, Parquet, PostgreSQL and MySQL.
Credentials live in a ConnectionSecret, never inline in a manifest.
Environment substitution as ${VAR} or ${VAR:default}. build fails on anything unresolved.
PostgreSQL and MySQL do not work on Windows, because DuckDB does not ship those extensions there.

Rendering

A Chrome headless shell renders the HTML templates, so pagination, layout and typography are exact.
bino setup downloads that browser runtime once. The container image already has it.
Outputs: ReportArtefact (PDF), DocumentArtefact, ScreenshotArtefact and LiveReportArtefact.
--artefact and --exclude-artefact build a subset. --out-dir sets where it lands.

Compliance

PDFs can be signed: a SigningProfile takes a PEM certificate and key, a digest algorithm and a certification type.
The signing profile is linked to the artefact, so the report is signed when it is built, not afterwards.
The build runs from the repository, so an auditor can rebuild what was sent.
--data-validation warn|fail|off decides whether questionable data stops the build.

Guardrails

bino lint checks manifests against the rule set before anything renders.
JSON Schemas drive completion and validation in the editor, so most mistakes never reach a build.
Limits cap the number of manifest files, documents per file and total size.
Query limits cap rows and runtime. External assets have size and timeout limits.
bino graph shows what an artefact depends on before you change a dataset.

Your toolchain

The VS Code extension has a manifest explorer, completion, go-to-definition, preview and the dependency graph.
bino lsp gives the same features to any editor that speaks LSP.
bino mcp runs a Model Context Protocol server, so an agent writes manifests against the real schema and validation.
bino registry and bino publish connect a project to shared packages.

Containers

Image ghcr.io/bino-bi/bino-cli, tagged latest, X.Y and vX.Y.Z.
The -slim variant leaves out Chromium. It runs serve, lint, graph, lsp and mcp.
The full image has Chromium, fonts, the DuckDB extensions and the template engine. It downloads nothing at runtime, so it also works air-gapped.
Entrypoint bino, working directory /work, port 8080, uid 1000.

Documentation

Read the reference

Every command, flag and document kind is documented.

Installation

All install methods, supported platforms and what bino setup does.

Your first report

The guided path from an empty folder to a rendered PDF.

Command reference

init, add, build, preview, serve, lint, graph, registry, publish, lsp, mcp.

CI/CD pipeline

Recipes for GitHub Actions and GitLab CI, with secrets and schedules.

Data from databases

PostgreSQL and MySQL sources, connection secrets and typed queries.

Signing reports

Certificates, signing profiles and how to verify a signed PDF.

Running in Docker

The full and slim images, tags, volumes and serving a live report.

Licensing

What the AGPL asks of you, and when the commercial licence applies.

VS Code & MCP

Editing with the schema, and an MCP server for AI agents.

Handbuch · DeutschThe whole stack in one PDF, in GermanThe bino Handbuch explains the CLI step by step, from the first report to plugins, CI and Docker. It is written in German, and bino builds it: the chapters are Markdown files, rendered by bino build --artefact handbuch as a DocumentArtefact.Download the Handbuch (PDF) German · PDF · about 340 pages · 4.7 MB

Where it fits

bino sandbox: try all of this in a browser tab before you install anything.bino registry: share layouts and styles across teams as versioned packages.

Need other terms, or help?

Tell us what your policy needs, or where your reporting hurts. We will tell you whether the commercial licence, support, or just the docs fit.