Graphy vs ECharts: which charting library fits your product?
Compare Graphy and ECharts for chart design, annotations, user editing, large datasets, AI workflows and licensing.
10 min read
Featured image

Apache ECharts is a powerful general-purpose charting library. It covers a wide range of visualisations, gives developers detailed control, handles interactive exploration and is available under the Apache License 2.0.
Graphy is built for a more specific product problem: helping people turn data into a chart they can style, annotate, and keep editing. It fits presentation tools, publishing products, reporting workflows and AI products where users keep working on the chart after the first version has been generated.
Both libraries can produce customised, interactive charts. The practical choice depends on what happens after the chart first appears. If developers own every visual decision and the product needs broad analytical coverage or very large point counts, ECharts is a strong place to start. If users need to apply their brand, call out what matters and refine the result inside your product, Graphy gives you more of that authoring workflow as one system.
Graphy is built for chart authoring
A chart in a board report, a personal activity recap and a newspaper article may use the same geometry but need completely different visual treatments. Graphy’s styling system can set reusable styles across a chart or target a particular layer or observation. Themes can carry a product’s visual language across many charts, while custom renderers can change how the marks themselves are drawn.
The explanation of the data on the chart lives in the same specification. Graphy supports highlights, data-anchored notes, shaded regions, arrows and difference annotations. A difference arrow can automatically calculate and label the change between comparable observations. Notes anchored to data move with their observations when the chart is recomputed, provided those observations still exist.
Graphy also supplies editable chart interactions and editing components. Users can edit titles, captions and text annotations directly on the chart. Supported changes flow through a command system, so an edit made on the canvas and one made from your own toolbar can share the same undo and redo history.
Your application still owns the surrounding product: permissions, collaboration, storage and the controls you choose to expose. It saves the updated chart specification and supplies it when the chart is reopened. Structure, transforms, styles, highlights and annotations can travel together as JSON-compatible values. Saving the specification does not preserve the previous undo stack.
A user can generate a chart as a starting point, restyle a series, add a note, undo a change and save the result without your team inventing a separate representation for each step.
How ECharts handles the same work
ECharts gives developers extensive design control. Its styling options include themes and palettes for a shared appearance, plus settings for individual marks, lines, areas and labels. Custom series support bespoke visuals beyond the built-in chart types.
It supports explanation too. Its configuration options include markPoint, markLine and markArea to identify values, draw reference lines and shade regions. The graphic component adds text, images and shapes for more bespoke treatments.
ECharts can also support basic visual editing. Its official dragging guide shows how to change a curve by dragging points, using graphic elements and event handlers to update the data. Its toolbox includes a data view that can allow users to edit values and update the chart.
You can build a full authoring interface around those options, events and actions from scratch. Your application can decide how users select chart elements, which controls appear, how changes are recorded and how a user returns to earlier work. Graphy’s advantage for this use case is the way styling, storytelling features, direct editing and command history are designed to work together.
Chart range and interactive exploration
ECharts’ chart types cover familiar bar, line and scatter charts alongside maps, relationship graphs, treemaps, sunbursts, gauges and parallel coordinates. Its components include zoom controls, tooltips, selectable legends and brushing, where users select a region of a chart to inspect the observations inside it. These are useful foundations for analytical interfaces.
ECharts also separates data from chart configuration through dataset, can reuse that data across series, and includes declarative filtering and sorting transforms. A dashboard can show several views of the same data without defining a separate copy for each chart.
Graphy takes a grammar-of-graphics approach. Developers map data to visual properties, then compose layers, scales and coordinates. The same specification can hold transforms, styles, highlights and annotations, which makes it a useful model for products where the chart keeps changing as the user develops its design and message.
So comparing the two really depends on the job. An operations dashboard built around geographic views and relationship graphs asks for different things from a presentation tool where users regularly restyle and annotate bar charts.
Performance with large datasets
Graphy and ECharts perform similarly on smaller line-chart datasets, but as of October 2026, ECharts pulls ahead when rendering large datasets. In our internal tests, a 10,000-point line chart settled in 60 ms with Graphy and 63 ms with ECharts.
At 500,000 points however, ECharts was substantially faster, especially for scatter plots and resizing.
Explore the chart above to compare workloads. If your product needs hundreds of thousands of points on screen at once, ECharts is currently the stronger starting point. For smaller line charts, the close timings leave more room to choose based on styling, annotations and editing.
These are medians from Graphy’s internal test on 20 October 2026 and have not been independently reproduced. Initial render settle measures chart mount plus two browser frames; progressive rendering can continue afterward, so it is not a measure of when every point is visible.
Creating charts with AI
Both libraries can support AI-generated charts. The difference is how much of the experience you need to build around them.
ECharts’ official MCP project connects an AI assistant to a chart-rendering tool. The assistant supplies the chart type, data and labels; the tool returns a link to a generated chart image. For an interactive experience, your application can instead have a model generate ECharts configuration and render it in the browser. You build the controls and editing workflow around that chart.
Graphy’s Agents API provides dedicated capabilities for creating charts, transforming data, adding annotations and writing titles or captions. Users can ask for changes such as “show only this year”, “highlight the highest value” or “add a note explaining the increase”, giving them a way to refine a chart without finding the right setting first.
Graphy’s advantage is how this fits alongside its chart-authoring tools. A user can start with a prompt, then adjust the title directly, change the styling or add an annotation using your interface. Your application can use Graphy’s editing components and command history to support those changes, including undo and redo.
Rendering, accessibility and licensing
ECharts offers Canvas and SVG rendering, plus documented server-side rendering paths. This gives teams options for browser charts and generated output. Choose the renderer against your data volume, devices and required interactions.
Graphy’s documented renderer integrates through React, with a provider that manages the data and specification. Check that integration against your application’s framework before planning a migration.
ECharts’ accessibility features include generated chart descriptions for assistive technologies and decal patterns that distinguish data beyond colour. These features need to be enabled. For either library, test the finished chart and editing controls with the keyboard and assistive technologies your users rely on.
ECharts is available under the Apache License 2.0, including for commercial use subject to its terms. Graphy uses a different licensing model, with qualifying free-use grants and commercial licensing. Check the terms that apply to your organisation and deployment.
Where each library fits
In summary then, Graphy is a strong fit for products where people create, style and explain charts themselves. Its styling, annotations and editing tools work together, giving you a foundation for report builders, presentation tools and AI features where users keep refining the result.
ECharts is a strong choice for analytical applications that need a wide range of chart types with exploration controls or need to handle very large datasets. You can build chart-authoring features around it too, but more of the editing interface and change history will be your team’s responsibility.
Your product needs | Where to start |
|---|---|
Charts users can style, annotate and refine | Evaluate Graphy’s styling, storytelling, editable interactions and command history as one workflow. |
An embedded chart editor without building every control | Use Graphy’s ready-made editor sections for axes, legends, labels, appearance and annotations, then add your own controls where needed. |
Undo and redo across styling and annotation changes | Use Graphy’s command history to give supported styling and annotation edits a shared undo/redo history, including changes from your own toolbar. |
AI-generated charts people can keep editing | Test Graphy’s generation-to-editing handoff, including SDK compatibility with the optional alpha Agents API. |
Large point counts and frequent resizing | Start with ECharts, then test your real workload and all-points-complete behaviour. |
Maps, relationship graphs and varied analytical views | Compare ECharts’ relevant chart types and exploration controls against your requirements. |
Canvas or SVG rendering and server-generated output | Explore ECharts’ rendering paths and their interaction trade-offs. |
Permissive open-source licensing | Review ECharts and the Apache License 2.0. |
Image

WRITTEN BY
Nick Smith
Graphy team
Nick has 13+ years experience of wrestling with the challenge of how to make data clear and easy to understand. He writes about product, marketing, and all things product marketing.
