Library / SDK
microsoft/flint-chart avatar
microsoft/flint-chart

Flint Chart: A Semantic Chart Compiler That Turns Typed Specs Into Vega-Lite, ECharts, Chart.js, Plotly or Excel Output

🪄 Flint is a visualization language that lets AI agents reliably create expressive, good-looking charts from simple, human-editable chart specs.

4,579 stars268 forksTypeScriptMIT

At a glance

What is it?
Flint is a Microsoft-hosted visualization language for AI agents and app developers. You describe data with semantic types and a short chart spec, and a compiler produces a backend-native spec. It ships as an MCP server and as the flint-chart npm library.
Who is it for?
Flint suits teams that want an AI agent or a React app to produce consistent, themed charts from a short spec across several chart libraries. It fits less well when you need one specific backend feature that the compiler does not expose.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • microsoft/flint-chart4,579 ★ · +391
Star history
Repository2026-09-112026-11-15
microsoft/flint-chart4.2k4.6k

391 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Flint compiles a spec into a backend-native chart instead of drawing anything itself

A Flint spec consists of the data, semantic types, a chart spec, and optional theme and interaction specs. The README says that instead of relying on complex user-side logic to glue these together, the compiler resolves each part against the others and composes a complete backend-native spec. The npm library compiles Flint specs into backend-native chart specs and offers React and vanilla JavaScript APIs for embedding interactive charts.

The consequence is that Flint sits in front of existing chart libraries rather than replacing them. It supports 52 chart types across five rendering backends: Vega-Lite, ECharts, Chart.js, Plotly and native Excel charts. When you give a coding agent the job of adding a chart, the instructions tell it to install flint-chart and also the renderer dependencies needed for the project. The compiled output is only useful if the matching renderer is present.

Semantic types are the part you must supply, and the compiler infers the rest from them

Fields are described with semantic types such as Rank, YearMonth, Delta or Temperature, along with their domains and units. The compiler uses these to infer parsing, scales, axes, formatting and colors, so a short Flint spec becomes a complete backend spec. The chart itself is defined with high-level chart types and encodings, and the compiler adapts sizing, spacing, labels and legends as the data gets denser.

That design moves effort from styling to labeling. If you tell Flint a column is a Quantity and another is a YearMonth, it chooses the axis behavior for you. If you label a field wrongly, the inferred formatting will be wrong in the same way, and the error shows up in the chart rather than in a schema message. For an agent, the semantic types are the one piece of judgment it has to get right about your data. Review them before blaming the renderer.

Two entry points: an MCP server for conversations and an npm library for applications

In an agent app, Flint is an MCP server that works with clients such as GitHub Copilot in VS Code, Claude, Claude Code, Codex and Cursor. The quick start is a prompt you paste into your agent. It offers two configurations: a local stdio server started with npx -y flint-chart-mcp, or the hosted server at https://flint.data-formulator.ai/mcp over HTTP. The agent can then open an interactive chart in the conversation, return a static PNG or SVG, or produce a backend-native spec.

The choice between the two has a cost. The stdio route runs the server on your machine. The hosted route means your client talks to a remote endpoint, which matters if the data you chart is sensitive. For building applications, the other entry point is the flint-chart npm package, and the repository also has an agent-skills directory containing chart authoring and interaction authoring skills that you can point a coding agent at.

A React spec is plain data with chart, theme and interaction keys

Install the library with npm:

bash
npm install flint-chart

The README then shows a spec typed as ChartAssemblyInput and rendered by the FlintChart component:

tsx
import type { ChartAssemblyInput } from 'flint-chart';
import { FlintChart } from 'flint-chart/react';

const spec: ChartAssemblyInput = {
  data: { values: [
    { Month: '2026-01', Users: 1200 },
    { Month: '2026-02', Users: 1800 },
  ] },
  semantic_types: { Month: 'YearMonth', Users: 'Quantity' },
  chart_spec: {
    chartType: 'Line Chart',
    encodings: { x: 'Month', y: 'Users' },
  },
  theme_spec: 'economist',
  interaction_spec: { interactions: [{ type: 'inspect-index' }] },
};

<FlintChart spec={spec} />

Because the spec is data, it can be stored, diffed and edited by hand, which is the sense in which it is human-editable. The limit is that the example shows one chart type and one interaction; other chart types need their own encodings, listed in the API reference.

Themes and interactions arrived in separate releases, so the version you install changes what works

The update log shows how the feature set grew. Flint 0.4.0 on July 24, 2026 added 38 Plotly chart types and 18 native, editable Excel chart templates. Flint 0.5.0 on August 5 introduced formal visual themes with presets, custom ThemeSpec authoring and preset inheritance. Flint 0.5.1 on August 12 extended visual themes to the Plotly backend and added a Vega-Lite Calendar Heatmap. Flint 1.0 on October 19 introduced Flint Interactive, with interaction presets, semantic events and an interaction API.

Two things follow. Themes did not cover the Plotly backend until 0.5.1, so a pinned older version gives uneven styling across backends. And the 1.0 release is only weeks old, so a spec that uses interaction settings should be tested against exactly the version you install. The overall tally in the README is 14 themes and 23 interaction presets, with a Theme Lab for custom themes.

The monorepo mixes JavaScript and Python tooling, and the scripts keep generated files in sync

The root package.json is a private monorepo with workspaces for packages/flint-js, packages/flint-mcp and the site. Its description calls Flint a semantic chart compiler for AI agents in JS and Python, and there are scripts for Python tests and linting that run through uv in packages/flint-py. The test:all script runs the JavaScript, MCP and Python tests together.

Several scripts exist only to keep generated artifacts consistent: build:copilot-plugin builds and then runs scripts/sync-copilot-plugin.mjs, check:copilot-plugin runs the same script in check mode, sync:skills copies skills, and gen:reference builds a chart reference. For a contributor, this means a change to the compiler or the skills can fail a check because a derived file was not regenerated. Run the sync script before opening a pull request, not after the first CI failure.

Fifty-two chart types across five backends does not mean every type exists on every backend

The headline numbers are totals. The visible README does not state a grid of which chart type works on which backend, and the update log hints at uneven coverage: Plotly gained 38 chart types in one release, and Excel gained 18 templates, which are not the same count. Treat the claim that charts are built once and rendered on any backend as the goal of the design, then verify the specific chart type and backend pair you need in the live editor or the generated chart reference.

A second boundary is licensing and provenance of the services. The code is MIT, but the hosted MCP endpoint is a service you do not run. If you need guarantees about availability or data retention for it, the repository text does not provide them, and the stdio server is the option you control.

Editorial conclusion

Flint suits teams that want an AI agent or a React app to produce consistent, themed charts from a short spec across several chart libraries. It fits less well when you need one specific backend feature that the compiler does not expose. Check the version you install, since themes and interactions arrived in separate releases through 2026.

Frequently asked questions

What is Flint?

Flint is a visualization language that lets AI agents reliably create expressive, good-looking and interactive charts from simple, human-editable chart specs. It ships as an MCP server and as the flint-chart npm library.

Which chart libraries can Flint Chart render to?

Flint supports 52 chart types across five backends: Vega-Lite, ECharts, Chart.js, Plotly and native Excel charts, through one interface, with 14 themes and 23 interaction presets.

How do I use Flint Chart with an AI agent?

Configure it as an MCP server, either locally with npx -y flint-chart-mcp or through the hosted HTTP endpoint at https://flint.data-formulator.ai/mcp, then ask the agent for a chart.

Official sources

  1. License: MIT
  2. microsoft/flint-chart on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/microsoft-flint-chart.svg)](https://hysenlabs.com/projects/microsoft-flint-chart)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/microsoft-flint-chart.svg)](https://hysenlabs.com/projects/microsoft-flint-chart)

Was this useful?