AivexaNewsSearch
AI news for builders and product teamsChecked every hour

Flint-interactive: A language for creating interactive data visualizations

Collected Oct 22, 2026

Microsoft Research has published Flint-interactive, a language for building interactive data visualizations on top of Flint, the lab's existing visualization specification system. The work is credited to Chenglong Wang, Yuwei Xiao of UCLA, Alper Sarikaya of Power BI, Michel Galley, Chris Quirk and Jianfeng Gao, and sits under the Deep Learning Group. No release date is given beyond a reference to "the latest release." The pitch is that agents and developers can describe how a chart should respond to clicks, brushing, filtering, zooming and highlighting using high-level semantics, leaving the compiler to work out how that becomes rendered pixels.

The motivating problem is generation cost and reliability. As the researchers frame it, even frontier models rarely produce a satisfactory interactive visualization in a single turn; iterating through reasoning, coding and debugging burns tokens and time. Expressive interactive charts also tend to introduce broken layouts or faulty interactions, and repairs can create fresh problems. Meanwhile, the built-in interactions bundled with some visualization libraries are not expressive enough for bespoke charts. The team's diagnosis is that what has been missing is an expressive yet high-level language for specifying visual interactions.

Flint-interactive answers that by splitting the problem in two. Visual logic stays with the compiler: it resolves raw inputs such as clicks, drags and key presses into semantic events that identify which chart element and which data were involved, and it turns update operators back into canvas changes, handling hit testing and low-level visual updates. Interaction logic belongs to the author or agent, who maps those semantic events to update operators such as set style (to highlight data), set annotation (to label a point) or set viewport (to pan or zoom), and can also use the events to drive external tables, widgets or application state. For a developer, the practical effect is that you never manipulate renderer-specific marks or reverse-engineer how a chart was drawn.

The runtime behind this is Flint Canvas, described as a state machine that tracks user interactions on the canvas and manages visual rendering state. Because event generation and visual updates are compositional, the same mechanism extends beyond a single chart to tables, text, other charts and widgets, which is what makes linked dashboards and data stories feasible with the same primitives rather than bespoke glue.

There are three documented ways to use it. The first is in chat or a canvas environment via Flint-MCP and MCP Apps, following an MCP setup guide; the agent is told what to chart and which interactions are wanted, and generates an interaction_spec alongside the Flint chart spec, rendering the interactive chart in the conversation. A side benefit the team highlights is that a user's selection can be passed as context into follow-up turns. The second is app building with the Flint Interactive Canvas: the application registers event handlers that consume semantic events from the canvas to filter a table, update another chart or change app state, and sends update operators back to control how the chart updates. The third is bespoke work through the programming API, where you define a trigger plus a custom handler that maps semantic events to a custom update sequence; the example given highlights a clicked country and labels it by name by combining set-style and set-annotation. Another example, a DimpVis-style chart, lets a user drag a point along a time path to see how temperature and precipitation change across cities.

Presets lower the floor further. A single preset, linked-brush, lets a user brush one view and have all groups of selected countries highlighted in a chart, which is the kind of cross-view coordination that normally takes a fair amount of wiring.

This suggests the most interesting consequence is for agent workflows rather than hand-written dashboards. Interactive charting has been a poor fit for code-generating models because the output space is renderer-specific and hard to verify; constraining the output to a small declarative interaction_spec, with a compiler owning the rendering, moves the task closer to constrained decoding. In practice that should mean fewer tool calls and fewer broken charts per request, which is the cost argument the team makes. A likely trade-off is expressiveness: preset-style semantics cover the common coordinated-views repertoire, but anything outside the operator vocabulary needs custom handlers and therefore real programming, so the low-effort path and the bespoke path diverge. It is also worth noting that interaction quality still depends on the chart spec the agent writes, and the semantic-event layer assumes the compiler can reliably identify elements and data from raw input, which is where the hard engineering lives.

Microsoft is inviting several audiences in: people who just want charts in chat can set up Flint and consult an interaction gallery; app builders can use the programming API and share an interaction-author skill with a coding agent to add presets; and interaction designers can study the bespoke examples, turn a new interaction into a reusable preset, and propose it on GitHub to grow the vocabulary.

Why it matters: Developers building agents that emit charts, and product teams shipping analytics dashboards, are the immediate audience, because the work targets the two things that block interactive output today — token cost from failed generations and fragility of hand-wired interaction code. If the compiler reliably absorbs rendering and dependency management as claimed, teams could treat interactivity as a declarative feature rather than a frontend project. My inference is that adoption will hinge on how far the preset and operator vocabulary stretches before teams fall back to custom handlers, and on how well MCP-based rendering fits existing chat and canvas stacks.

Read at Microsoft Research

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Flint-interactive gives AI agents a language for creating interactive visualizations. Click a chart, filter data, highlight related content, and explore beyond the view the author originally chose. The post Flint-interactive: A language for creating interactive data visualizations appeared first on Microsoft Research .