bino cliOpen source · AGPL-3.0Commercial licence available

Your monthly reporting, under version control.

bino turns YAML manifests and SQL queries into pixel-perfect, IBCS-compliant PDFs. The definition lives in your repository, the build runs in your pipeline, and the report that went out last quarter can be rebuilt byte for byte today — no seat licences, no clicking, no drift.

Read the docs Install Talk to sales bino-bi/bino-cli5AGPL-3.0

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

Install

One binary, then one command

The installer places a single binary on your PATH. bino setup fetches the browser runtime it renders with — once, not per build. The container image already contains 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. It should be built like one.

Reports assembled by hand in a spreadsheet cannot be reviewed, cannot be diffed, and cannot be rebuilt once the person who made them is on holiday. Defining them as code fixes all three at once.

Reviewable before it ships

A change to a report is a pull request. Someone else reads the diff, approves it, and the history says who changed which figure and why — the same control your code already has.

The same output, every time

Same manifests, same query, same PDF. The month-end pack is rendered by a machine on a schedule instead of assembled by hand under time pressure.

One visual standard, enforced

IBCS notation is built in: scenarios, variances and scaling are decided by the engine, not by whoever built the slide. Every report in the company reads the same way.

No per-seat bill for readers

The output is a PDF. Everyone who needs to read the report can, without a licence, an account, or a dashboard tool — and the authors work in the editor they already use.

How it works

Scaffold, iterate, automate, serve

Four commands cover the whole life of a report — from an empty directory to a PDF landing in your pipeline artefacts every month.

bino init writes a working bundle — a data source, a dataset, an IBCS table, a chart, a style and translations, in the canonical 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/

With no source argument bino init renders the smaller minimal scaffold instead. A source can also be a remote template.

While you are shaping a report, preview hot-reloads in the browser on every save, and lint catches manifest problems before a build ever 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

The same intelligence is available inside your editor: the VS Code extension, or bino lsp for any LSP-capable editor.

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 substitute 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 a silently empty filter.

A LiveReportArtefact is served as an interactive web application instead of a PDF — the same manifests, rendered on demand:

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

Twenty-odd document kinds, one file format

Everything — the data, the components, the page layout, the style, the translations and the output itself — is a YAML document with a kind and a spec. Nothing is hidden in a binary project file.

DataSourceDataSetConnectionSecretTableChartStructureChartTimeChartScatterChartBubbleChartBulletTreeGridTextImageLayoutPageLayoutCardComponentStyleRuleSetScalingGroupInternationalizationReportArtefactDocumentArtefactLiveReportArtefactScreenshotArtefactSigningProfile

Licensing

Open source, with a way out for those who need one.

bino is dual licensed. Almost everyone uses it under the AGPL and never thinks about it again; the commercial licence exists for the cases where that does not work.

AGPL-3.0

free

Free to use, modify and run — internally, commercially, at any scale.
No seat limits, no feature gates, no telemetry-based tiers.
The obligation: if you modify bino and offer the modified version as a network service, you publish that modified source.
Building your own reports with unmodified bino triggers nothing at all.

Commercial licence

enterprise

For organisations whose policy does not permit AGPL software.
For embedding bino inside a closed-source product.
For operating a SaaS on top of bino without releasing your modifications.
Written terms your procurement and legal teams can sign.

Editions

Free to use. Paid where you need more than the licence.

The CLI itself is complete and free. What we sell is a different licence for organisations that cannot use the AGPL, and our time when a team wants to move faster.

Open source

bino cli

Free

The whole product, 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 in GitHub Discussions

Most asked for

Enterprise

Commercial licence

On request

The same software, on terms that fit your policy.

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

Enterprise

Support & coaching

On request

Our team beside yours while reporting as code lands.

Guaranteed response times (SLA)
Prioritised bug fixes and feature requests
IBCS workshops for authors and report consumers
We build your first reports together with your team
Upgrade and integration guidance

The core stays free

bino cli is open source and stays open source. The licence and the services are how the work is funded — you never need either one to put the product to work.

Technical detail

What your architects will ask before the first report ships

How bino queries, renders and guards a report.

Data

SQL runs in an embedded DuckDB engine — its full dialect, no separate database to operate.
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 are unavailable on Windows — the required DuckDB extensions are not supported there.

Rendering

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

Compliance

PDFs can be digitally signed: a SigningProfile takes a PEM certificate and key, a digest algorithm and a certification type.
Signing profiles are linked to the artefact, so a signed report is signed by construction rather than afterwards.
The build is reproducible from the repository, which is what an auditor actually wants to see.
--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.
Manifest scanning limits cap file count, documents per file and total size.
Query limits cap rows and runtime; external assets have size and timeout ceilings.
bino graph shows what an artefact depends on before you change a dataset.

Your toolchain

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

Running it anywhere

Container image ghcr.io/bino-bi/bino-cli, tagged latest, X.Y and vX.Y.Z.
A slim variant (~410 MB) drops Chromium and runs serve, lint, graph, lsp and mcp.
The full image (~1.1 GB) bundles Chromium, fonts, the DuckDB extensions and the template engine — nothing is downloaded at runtime, so it works air-gapped.
Entrypoint bino, working directory /work, port 8080, non-root uid 1000.

Documentation

Read the reference

Every command, flag and document kind is documented in full.

Installation

Every install method, platform support and what bino setup does.

Your first report

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

Command reference

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

CI/CD pipeline

The GitHub Actions and GitLab CI recipes, with secrets and scheduling.

Data from databases

PostgreSQL and MySQL sources, connection secrets and typed queries.

Signing reports

Certificates, signing profiles and verifying a signed PDF.

Running in Docker

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

Licensing

What the AGPL requires of you, and when a commercial licence is the answer.

VS Code & MCP

Schema-aware editing, and an MCP server for agent-assisted authoring.

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 it on different terms?

Tell us what your policy requires, or where your reporting hurts. We will tell you straight away whether a commercial licence, support, or just the docs is what you need.

Talk to sales Services