A quiet Show HN post landed a Flutter charting library called Graphic — MIT-licensed, from developer entronad — and its pitch is unusually honest for the genre. It does not sell you a gallery of forty chart types. It says, in plain terms, that its visualization grammar “derives from Leland Wilkinson’s The Grammar of Graphics” and lets “data processing steps and mark shapes be composed freely in a declarative specification, not limited to certain chart types.” That single sentence is worth more than the library. It names the foundation almost every serious plotting tool of the last twenty years quietly stands on — and that most architects and engineers have never been told they are already using.

This piece is not about Graphic. It is about the idea Graphic is a local instance of: the concept that a chart is not a thing you pick but a sentence you compose.

What it is: The Grammar of Graphics is a formal decomposition of any statistical chart into a small set of independent, combinable parts. Instead of “bar chart”, “scatter plot”, “pie”, you describe: the data, a set of transforms on it (filter, bin, aggregate), a mark (point, line, area, arc), an encoding that maps data columns onto visual channels (position, colour, size, shape), the scales that turn data units into pixels, a coordinate system (Cartesian, polar, geographic), and guides (axes, legends). A bar chart is not a template — it is a rectangle mark on a Cartesian coordinate. Bend that same specification onto a polar coordinate and you have a pie or a radial bar, with no new chart type invented. The chart types you learned are frozen sentences; the grammar is the language that generates them.

Why it works: The power is compositional orthogonality — the parts vary independently, so the number of expressible charts is the product of the choices, not their sum. Wilkinson’s insight was that the visual channels are ranked by how accurately the human eye reads them. Position along a common scale is the most precise; length and angle are middling; colour hue and area are poor for quantity, good for category. This is not taste — it rests on the Cleveland–McGill perception experiments (1984), which measured error rates when subjects judged values encoded different ways, and found position beat angle beat area in a stable ranking. So the grammar does not merely let you build any chart; it tells you which encoding is honest for which data. Mapping a continuous quantity to colour lightness where you could have used position is not a style choice, it is a measurable loss of precision — and a declarative grammar makes that swap a one-line, reviewable edit rather than a rebuild. The same discipline runs through PAZ’s Creative Coding concept panel: treat code as a design material, and a chart becomes “a function that can be re-run” rather than a one-off artefact.

←TODAY: A 2026 Flutter dev ships an MIT grammar-of-graphics library and openly credits a 1999 book. →3012: By the Zurich-3012 horizon, no dashboard is drawn by hand — every panel is a spec the mesh regenerates against live sensor streams. Fulcrum: The grammar is the one representation that is equally a design tool today and a machine-readable contract tomorrow — a picture is not, a sentence is.

Origins: Leland Wilkinson published The Grammar of Graphics with Springer in 1999 (second edition 2005), drawing on his work building the SYSTAT and later SPSS/Viz statistics engines. It sat mostly in the statistics world until Hadley Wickham turned it into software: ggplot2, released for R in 2007, made “grammar of graphics” a working verb rather than a monograph, and its aes()-plus-geom_ syntax is a near-direct transcription of Wilkinson’s layers. Jeffrey Heer’s group at the University of Washington then pushed it into the browser with Vega and Vega-Lite, where the entire chart is a JSON document — a spec you can version, diff, and generate. entronad’s Graphic is simply the newest node on that lineage: the same grammar, ported to Dart and Flutter’s canvas, MIT-licensed, wrapping three documented capabilities on top of Wilkinson’s layers — a freely composable declarative specification, event-and-selection interaction (highlight, tooltip, coordinate scaling), and mark-transition animation. Twenty-seven years, one idea.

In practice: For a Swiss studio this is not a data-science nicety — it is how a BIM or performance dashboard stops being a screenshot and becomes a repository. When you script a facade-optimisation sweep in Grasshopper or pull thousands of Karamba3D variants, the output is a table of columns: embodied carbon, structural mass, daylight autonomy, cost. A grammar-based plot library lets one specification render that table as a scatter today and a small-multiples grid tomorrow by changing a single facet field — no re-authoring. More to the point, the spec is text, so it lives in git next to the model, gets reviewed by the cost engineer, and survives the staff change that kills every hand-built Excel chart. A twin that only shows a dashboard, as our Digital Twin panel puts it, is a museum; the grammar is what makes the dashboard a queryable, regenerable thing rather than a frozen image.

Atelier: Offices that have industrialised their reporting report the same pattern — the win is not prettier charts, it is that the chart becomes a reviewable artefact under version control, so nobody re-draws it and everybody trusts it. This Monday, take one recurring project report your team rebuilds by hand and re-express it as a single declarative spec (ggplot2 if you are in R, Vega-Lite JSON if you want it web-native, Graphic if your reporting surface is Flutter) — commit the spec, not the PNG, and point next month’s data at the same file.

Hack: Encode a facade panel table as position-on-both-axes — the honest mapping — instead of hiding a quantity in colour. In plotnine, the Python port of ggplot2, the grammar reads almost as prose: name the data, map columns to channels with aes, add a geom, and the scales and axes are inferred. Change one word — swap geom_point for geom_line — and it is a different chart from the same sentence, which is the whole lesson.

from plotnine import ggplot, aes, geom_point
df = pd.read_csv("panels.csv")  # area_m2, embodied_kgCO2, assembly
(ggplot(df, aes("area_m2", "embodied_kgCO2", color="assembly"))
 + geom_point())

Run it, then map embodied_kgCO2 to colour lightness instead and watch how much harder the eye works to compare two panels — you will feel the Cleveland–McGill ranking in your own reading, not just read it in a footnote. Graphic’s own author gives a telling aside on the same instinct: he would rather you “use the skill above for your coding agent” (npx skills add https://github.com/entronad/graphic --skill flutter-chart) than lean on the docs — the grammar is compact enough that a machine can hold the whole thing, which is exactly why it will outlive every chart-type menu.

So the move is small and durable: learn the grammar once — data, transform, mark, encoding, scale, coordinate, guide — and you stop shopping for chart types for the rest of your career. Pick one report your studio redraws by hand and rewrite it as a spec you can commit today.