💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

> "The purpose of visualization is insight, not pictures. Tools are the shortest bridge to that insight." — Edward Tufte, 1983 (paraphrased)

Data visualization tools in 2026 have long outgrown the simple definition of "chart libraries." Even for a single bar chart, your choice depends entirely on context: ECharts or Tremor for interactive dashboards, Recharts or Visx for React components, Datawrapper or Flourish for data journalism, Tableau or Looker for analyst BI, Metabase or Superset for in-house OSS BI.

This article surveys the most-used data visualization tools as of May 2026, grouped into five categories — JS libraries / React-friendly / declarative grammars / network and graph / BI and newsroom. We cover D3.js v8, Apache ECharts, Plotly, Chart.js v5, Highcharts, Recharts, Visx, Nivo, Tremor, Vega-Lite, Observable Plot, Sigma.js, Cytoscape.js, AntV (G6/X6), Apache Superset, Metabase, Lightdash, Evidence.dev, Grafana, Kibana, Looker, Tableau, Power BI, Datawrapper, Flourish, plus Korean and Japanese case studies.

1. The 2026 Data Viz Map — Five Categories

Visualization tools fall into five buckets based on "who uses them" and "what they produce."

|---|---|---|---|

The line between "library" and "BI tool" keeps blurring. Tremor is a React component library on top of Recharts but effectively delivers a small BI-like UX. Evidence.dev turns Markdown files with SQL and chart code into a static site. Meanwhile, Observable Plot, built on top of D3, adopts a Vega-Lite-style declarative grammar to be "D3 with less code."

The first decision point is always **"are developers writing code, or are analysts using a GUI?"** Next comes **"is the render target SVG, Canvas, or WebGL?"**, then **"is the license OSS or commercial?"**, and finally **"how does it connect to our data stack (dbt, Snowflake, ClickHouse, Postgres, etc.)?"**

2. D3.js v8 (Mike Bostock) — The Original

**D3 (Data-Driven Documents)** was created in 2011 by Mike Bostock (then a Stanford PhD student, later at NYT Graphics) and is effectively the origin of modern web data visualization. After v7.9 in 2024, the v8 series shipped in late 2025, and v8.1.x is the stable line as of May 2026.

D3's philosophy is **"a DOM manipulation library, not a chart library."** D3 doesn't ship a `barChart` function — it gives you the lower-level primitives to "bind data to DOM elements and map attributes to data functions." The freedom is overwhelming; the learning curve is too.

// D3 v8: simple bar chart

const data = [30, 50, 80, 40, 60]

const svg = d3.select('#chart').append('svg').attr('width', 400).attr('height', 200)

const x = d3.scaleBand().domain(d3.range(data.length)).range([0, 400]).padding(0.1)

const y = d3.scaleLinear().domain([0, d3.max(data)]).range([200, 0])

svg.selectAll('rect')

.data(data)

.join('rect')

.attr('x', (_, i) => x(i))

.attr('y', d => y(d))

.attr('width', x.bandwidth())

.attr('height', d => 200 - y(d))

.attr('fill', 'steelblue')

Key v8 changes: ESM-first (CJS builds removed), TypeScript types as first-class citizens (the `@types/d3` integration), and finer-grained module splits (`d3-color`, `d3-format`, `d3-scale`, etc., installable as standalone packages).

D3 remains number one for "newspaper interactives," "one-off custom charts," and "non-standard visualizations no library can express." The New York Times, FT, Bloomberg, Korea's SBS/KBS data desks, and Japan's NHK data team all build interactive features on D3. For "draw 100 bar charts in a business dashboard quickly," however, higher-level tools like ECharts, Recharts, or Tremor are far more efficient.

3. Apache ECharts (Baidu) — Rich Chart Catalog

**Apache ECharts** was built in 2013 by Baidu as an internal library, incubated by the Apache Software Foundation in 2018, and graduated as a top-level Apache project in 2021. The v5.6 series is stable as of May 2026.

ECharts stands out for its **sheer chart variety**, its **Canvas/SVG dual rendering**, and an **official GeoJSON map module**. Beyond bar/line/pie/scatter, you get treemaps, heatmaps, parallel coordinates, sunbursts, graph layouts, calendar heatmaps, boxplots, candlesticks, gauges, geo maps, and even 3D (WebGL) charts in a single library.

ECharts dominates China. Alibaba, Tencent, Baidu, ByteDance, and JD.com use it for most of their internal and external dashboards. Outside China, several global OSS BI projects (Apache Superset, Apache DolphinScheduler) chose ECharts as their default chart engine.

// ECharts

const chart = echarts.init(document.getElementById('chart'))

chart.setOption({

title: { text: 'Monthly Sales' },

tooltip: { trigger: 'axis' },

xAxis: { type: 'category', data: ['Jan', 'Feb', 'Mar', 'Apr', 'May'] },

yAxis: { type: 'value' },

series: [{ type: 'bar', data: [120, 200, 150, 80, 70], itemStyle: { color: '#5470c6' } }],

})

ECharts is the flagship of the "define charts via a declarative options object" school. You can describe an entire chart as a single JSON blob, which fits patterns where the backend generates options dynamically and the frontend renders them.

In Korea, ECharts is used by Toss, parts of Kakao, and some teams at LINE Plus. In Japan, Mercari and Rakuten use ECharts for some internal dashboards.

4. Plotly + Dash — The Python Camp

**Plotly** was created in 2012 by Plotly Inc. (Montreal, Canada) and ships both a JavaScript library (`plotly.js`) and Python/R/Julia bindings. That means data scientists can build a chart in a Jupyter notebook and serve the same interactive view on the web.

Plotly Python

df = px.data.gapminder().query("year == 2007")

fig = px.scatter(df, x="gdpPercap", y="lifeExp",

size="pop", color="continent",

hover_name="country", log_x=True, size_max=60)

fig.show()

Plotly's second product, **Dash**, lets you deploy Python-written interactive dashboards as web apps. Flask + Plotly + React are bundled together — the shortest path for a Python-only analyst to turn data into an interactive site.

In 2024 Plotly shipped **Dash 3.0**, and in 2025 **Dash Enterprise 5.x** rolled out with deeper Snowflake/Databricks integration and compute-cluster scaling. As of 2026, Plotly runs both the OSS charts (Python/R/JS) and the commercial Dash Enterprise platform.

Plotly's weaknesses: **bundle size** (the JS build is roughly 3–4 MB) and **render cost**. A dashboard with dozens of charts on one page tends to underperform compared with ECharts or Recharts. On the other hand, its catalog of statistical visualizations (violin, box plot, scatter matrix) is unmatched.

In Korea and Japan, Plotly is mostly used by data scientists and ML engineers. Toss's data analytics team, LINE Data Science, and Coupang's ML team all use Plotly in Jupyter environments.

5. Chart.js v5 — Simplicity Wins

**Chart.js** was created in 2013 by Nick Downie as the simplest possible chart library; **v5** shipped in 2025, and the v5.1 series is stable as of May 2026.

Chart.js wins on **sheer simplicity** and **small bundle size** (~80 KB gzip). Eight basic chart types (line, bar, radar, doughnut, pie, polarArea, bubble, scatter) take just a few lines of code, and anyone can produce useful charts within an hour with no prior training.

// Chart.js v5

Chart.register(LineController, LineElement, PointElement, LinearScale, CategoryScale)

new Chart(document.getElementById('chart'), {

type: 'line',

data: {

labels: ['Jan', 'Feb', 'Mar', 'Apr'],

datasets: [{ label: 'Sales', data: [120, 200, 150, 80] }],

})

The big v5 changes: ESM tree-shaking is much more aggressive (you register only the components you use), TypeScript is supported out of the box, and the plugin system is new. From 2025 onward, "Web Components compatibility" is on the public Chart.js roadmap.

Chart.js is the most-used library for internal admins, small SaaS dashboards, student/hobby projects, and marketing-page charts. When the brief is "I just need five clean bar charts, no fancy visualizations," Chart.js is the right answer.

6. Highcharts — Commercial Polish

**Highcharts** was created in 2009 by Norway's Highsoft and is widely considered to lead OSS libraries in design quality and interaction polish. It's free for non-commercial, individual, educational, and evaluation use, but commercial use requires a paid license (starting at USD 535 per developer as of 2026).

Highcharts ships as several modules — `Highcharts` (base), `Highstock` (financial charts), `Highmaps` (maps), and `Gantt` — each with its own license. JPMorgan, Goldman Sachs, Bloomberg, and Japan's SBI Securities all rely on Highstock-powered charts in many places.

In 2025 Highcharts added a new product, **Dashboards**, so you can build BI dashboards using only their stack. In 2026, **Highcharts Cloud** (a SaaS hosting option) is in beta.

You choose Highcharts almost entirely for **design quality** and **official support**. Having a commercial library with SLA-backed support, plus details OSS often lacks — smooth zoom/pan, refined tooltips, consistent theming — is the draw. If OSS licensing is acceptable, ECharts or D3 are nearly always a substitute.

7. Recharts (React) — The React Standard

**Recharts**, started in 2016 by the Recharts Group (a US–China mixed team), is a React-friendly chart library and effectively the de facto standard for assembling charts from React components. The v3.x series is stable as of May 2026.

// Recharts v3

const data = [

{ month: 'Jan', sales: 120, target: 100 },

{ month: 'Feb', sales: 200, target: 150 },

{ month: 'Mar', sales: 150, target: 200 },

]

Recharts's appeal: **JSX-native composition**, **stability from being built on D3**, and a **rich component set** (Bar/Line/Area/Pie/Radar/Scatter/Composed). React developers can assemble charts the React way — through props on declarative components — without learning a separate library.

Weaknesses: **performance** (SVG-based; slows down past a few thousand data points), **limited ceiling** (custom visualizations quickly push you back to direct D3), and gaps in **mobile interaction polish**. Recharts has thus settled into roles like "the default chart layer in admin dashboards" and "the underlying library for larger UI kits like Tremor."

In Korea, nearly every Vercel/Next.js-based internal dashboard uses Recharts. In Japan, parts of freee, SmartHR, and Mercari admin tools are built on Recharts.

8. Visx (Airbnb) — React + D3

**Visx** (pronounced "vis ex") was open-sourced by Airbnb in 2018 as a React visualization library that "combines D3's math with React components" at a low level. The v3.x series is stable as of May 2026.

Unlike Recharts, Visx doesn't give you big "BarChart" components. Instead, it offers smaller building blocks like `@visx/scale`, `@visx/shape`, `@visx/axis`, `@visx/group`, `@visx/text` — D3's functional toolkit (scaleLinear, line, area, etc.) wrapped in React-friendly modules.

// Visx

const data = [30, 50, 80, 40, 60]

const xScale = scaleLinear({ domain: [0, data.length], range: [0, 400] })

const yScale = scaleLinear({ domain: [0, 100], range: [200, 0] })

{data.map((d, i) => (

key={i}

x={xScale(i)}

y={yScale(d)}

width={70}

height={200 - yScale(d)}

fill="#3182bd"

))}

Visx fills the gap where "Recharts can't express it, but rewriting in D3 from scratch is too much." Teams at Airbnb, Stripe, and Lyft use Visx for internal data visualizations, and companies building interactive analytics tools tend to prefer it.

The learning curve is steeper than Recharts but gentler than raw D3. So Visx fits React developers who sit in the middle — "I don't want to go all the way to D3, but Recharts is too constrained."

9. Nivo — React + Themes

**Nivo** was created in 2017 by Raphaël Benitte (France) as a React visualization library. Like Recharts and Visx it pairs D3 with React, but it stands out for its **theme system**, **SVG/Canvas/HTML multi-target rendering**, and **server-side rendering (SSR)** support. The v0.88 series is stable as of May 2026.

Nivo's differentiator is **chart variety** (around 30 types) and **interaction polish**. Treemaps, calendar heatmaps, sunbursts, Voronoi, time-series lines, boxplots, word clouds — all available as React components.

// Nivo Line

const data = [

{

id: 'sales',

data: [

{ x: 'Jan', y: 120 },

{ x: 'Feb', y: 200 },

{ x: 'Mar', y: 150 },

]

data={data}

margin={{ top: 50, right: 110, bottom: 50, left: 60 }}

axisBottom={{ legend: 'Month', legendOffset: 36 }}

axisLeft={{ legend: 'Sales', legendOffset: -40 }}

pointSize={10}

useMesh={true}

Nivo is the right answer when "Recharts is too plain, but Visx is too low-level." Drawbacks: bundle size (large component set means heavy without tree-shaking) and a fairly opinionated visual language.

10. Tremor — Dashboards

**Tremor** was launched in 2022 by Tremor Labs in Berlin (now part of Vercel) with the goal "build a dashboard in 30 minutes." After Vercel acquired it in 2024, the v4 (2025) series shipped, and v4.2 is stable as of May 2026.

Tremor is less a chart library and more a **dashboard building-block library** — KPI cards, stat boxes, metric cards, progress bars, charts (built on Recharts), tables, tabs, and calendars — all delivered as React + Tailwind CSS components.

// Tremor

const data = [

{ date: 'Jan', sales: 2890 },

{ date: 'Feb', sales: 3100 },

{ date: 'Mar', sales: 2980 },

]

data={data}

index="date"

categories={['sales']}

colors={['blue']}

Tremor's strengths: **time to ship**, **natural Tailwind integration**, and a **free OSS license** (Apache 2.0). Its weaknesses are chart-type constraints (only what Recharts can draw) and limited design customization.

Since the Vercel acquisition, Tremor has settled in as "the default component library behind Vercel Analytics dashboards," and in 2025–2026 modern SaaS like Stripe, Linear, and Cal.com have used Tremor in parts of their internal dashboards.

11. Vega-Lite + Vega — Declarative

**Vega** and **Vega-Lite** come from the University of Washington's Interactive Data Lab (UW IDL, led by Prof. Jeff Heer). Vega is the lower-level grammar; Vega-Lite is the higher-level one on top of it. Together they exemplify the paradigm of "describing a chart as a JSON object."

{

"data": { "values": [{"month": "Jan", "sales": 120}, {"month": "Feb", "sales": 200}] },

"mark": "bar",

"encoding": {

"x": { "field": "month", "type": "ordinal" },

"y": { "field": "sales", "type": "quantitative" }

}

That JSON blob renders directly as an interactive bar chart. Vega-Lite's appeal: **declarative clarity** and **interoperability**. The same JSON spec runs across Jupyter Notebook (Altair for Python), Observable, and parts of Microsoft Power BI.

In 2026 Vega-Lite is one of the standard tools for data scientists, especially via **Altair** (the Python binding) which integrates naturally with Pandas DataFrames. JupyterLab, Marimo, Hex, and Deepnote all adopted Altair/Vega-Lite as one of their default chart engines.

Weaknesses: learning curve (JSON specs feel foreign at first) and interaction ceiling (not as flexible as raw D3).

12. Observable Plot (Mike Bostock) — The D3 Successor

**Observable Plot** was created in 2021 by Mike Bostock (D3's author) at Observable, with the goal "draw the same chart in less code than D3." The v0.7 series is stable as of May 2026.

// Observable Plot

const data = [

{ month: 'Jan', sales: 120 },

{ month: 'Feb', sales: 200 },

{ month: 'Mar', sales: 150 },

]

const chart = Plot.plot({

marks: [

Plot.barY(data, { x: 'month', y: 'sales', fill: 'steelblue' }),

Plot.ruleY([0]),

})

document.getElementById('chart').append(chart)

Plot is declarative like Vega-Lite but uses JavaScript function calls instead of JSON. Compared with hand-rolled D3, code volume drops by roughly an order of magnitude.

In a 2023 talk, Mike Bostock himself drew the distinction: "D3 is a library; Plot is a chart system." You keep D3-style freedom while writing standard charts in a single line and dropping down to D3 primitives only when needed. The New York Times Graphics team has used D3 and Plot together for new interactives since 2024.

Observable Plot sits in roughly the same niche as Vega-Lite, but because it's a JS function API rather than JSON, it composes more naturally inside React or Vue components.

13. Sigma.js / Cytoscape.js / G6 / X6 (AntV) — Network and Graph

Visualizing **graphs (nodes and edges)** is a category of its own, separate from standard bar/line charts. Network analysis, social graphs, system dependencies, and workflow diagrams all live here.

| Library | Origin | Notes |

|---|---|---|

| Sigma.js | médialab, Sciences Po (France) | WebGL rendering, large graphs (10k–100k nodes) |

| Cytoscape.js | Cytoscape Consortium, University of Toronto | Bioinformatics origins, rich graph algorithms |

| G6 | AntV (Alibaba) | Business graphs (org charts, topologies), TypeScript-first |

| X6 | AntV (Alibaba) | Diagrams (workflows, ER diagrams) |

| React Flow | xyflow (Germany) | React components, node editors (workflow builders) |

**AntV** is an Alibaba-led OSS visualization ecosystem, running G2 (statistical charts), G6 (graphs), X6 (diagrams), and L7 (geo). Many internal dashboards at Chinese tech giants run on AntV.

// G6 (AntV)

const graph = new G6.Graph({

container: 'container',

width: 800,

height: 600,

modes: { default: ['drag-canvas', 'zoom-canvas', 'drag-node'] },

})

graph.data({

nodes: [{ id: 'A', label: 'Node A' }, { id: 'B', label: 'Node B' }],

edges: [{ source: 'A', target: 'B' }],

})

graph.render()

**React Flow** (xyflow), born in Germany in 2020, specializes in "node-based editors." Most workflow builders — Stripe Flow, Cal.com Workflow Builder, n8n — sit on top of React Flow.

14. Apache Superset / Metabase / Lightdash / Evidence.dev — OSS BI

OSS BI in 2026 consolidates around four main players.

| Tool | License | Strengths |

|---|---|---|

| Apache Superset | Apache 2.0 | Rich charts (ECharts-based), SQL-friendly |

| Metabase | AGPL v3 + commercial | Friendly UI, accessible to non-engineers |

| Lightdash | MIT | Reuses dbt metrics directly as BI dimensions |

| Evidence.dev | MIT | Build BI reports in Markdown |

**Apache Superset** started as an Airbnb internal tool, was donated to the ASF in 2017, and v5.1 is stable as of May 2026. It has a rich ECharts-based chart catalog and strong SQL ergonomics via SQL Lab. Toss, Kakao, LINE, Mercari, and ZOZO all run Superset as part of their internal BI.

**Metabase**, founded in 2014 in San Jose, leads with "non-engineers can build charts without SQL." It runs as AGPL OSS, Metabase Cloud (SaaS), and Metabase Enterprise (commercial).

**Lightdash**, founded in the UK in 2021, **reuses dbt `metrics` definitions directly as BI dimensions** — the shortest path for teams that have adopted dbt as their modeling standard.

**Evidence.dev**, founded in Canada in 2022, introduces a new paradigm: **write Markdown files containing SQL queries and chart code, and they build into a static site**. It sits between notebook tools like Hex/Mode and static-graphics tools like Datawrapper.

15. Grafana / Kibana — Observability

**Grafana** and **Kibana** are technically **observability** tools, but they're usually discussed alongside visualization tools.

**Grafana** was created in 2014 by Torkel Ödegaard (Sweden) and is now stewarded by Grafana Labs. The v11.x series is stable as of May 2026. Beyond its own data sources (Prometheus, Loki, Tempo, Mimir), it can visualize almost any source — Postgres, MySQL, CloudWatch, BigQuery, Snowflake — so it doubles as a "general-purpose time-series BI."

**Kibana**, created by Elastic in 2013, specializes in visualizing Elasticsearch search results and is effectively the standard for log search and analysis. In 2026 the space is split between Kibana and OpenSearch Dashboards (the OSS fork maintained by AWS).

Both tools optimize for "system-metric dashboards" rather than "business-KPI dashboards," so their usage moments differ from typical BI tools. That said, more teams are using Grafana with its Loki/Tempo data sources for BI-adjacent purposes.

16. Looker / Tableau / Power BI — Enterprise BI

The enterprise BI world is effectively a three-way oligopoly.

| Tool | Vendor | Strengths |

|---|---|---|

| Tableau | Salesforce (acquired 2019) | Visual analytics, data discovery |

| Power BI | Microsoft | Office integration, Excel/Azure-friendly |

| Looker | Google (acquired 2020) | LookML semantic layer, BigQuery-native |

**Tableau** spun out of Stanford in 2003 as a visual analytics company; Salesforce acquired it for USD 15.7 billion in 2019. It set the standard for "explore data by drag and drop." The 2026 product family is Tableau Cloud, Tableau Server, and Tableau Public.

**Power BI**, released by Microsoft in 2015, spread quickly across enterprises thanks to Excel and Azure integration. In 2025 it was re-positioned as part of Microsoft Fabric.

**Looker** was founded in the US in 2012 and acquired by Google for USD 2.6 billion in 2020. Its differentiator is **LookML**, a custom semantic-layer language that defines data models, and the tightest possible BigQuery integration.

All three are expensive (tens to hundreds of dollars per user per month), and adoption is usually a CFO/CDO-level decision. But once adopted, they enable analysts and executives to build their own charts and become a cornerstone of "data democratization."

17. Datawrapper / Flourish — Newsrooms

**Datawrapper** started in Berlin in 2012 with the motto "build a clean chart in 30 seconds." It became the de facto standard in newspaper/magazine data journalism, used by FAZ, Die Zeit, Le Monde, The Wall Street Journal, and Korean outlets like Chosun Ilbo and JoongAng Ilbo's data teams.

Datawrapper's core is **a simple editor** and **aesthetic quality of output**. Paste a CSV, and it suggests the right chart type while applying colorblind-friendly palettes and accessibility defaults.

**Flourish** was founded in London in 2017 and beats Datawrapper at **storytelling**. You can build "scrollytelling" interactives — charts that change as you scroll — with no code, making it a core tool for data journalists. Canva acquired it in 2022.

Both are GUI-based and produce interactive charts you embed via iframe. They're the strongest answer when "developers shouldn't build it; analysts or journalists need to ship it quickly."

18. Korea / Japan — Toss, Kakao, Nikkei, freee

**Korea**

- **Toss** — Most internal dashboards run on Apache Superset. Some production visualizations (charts, user behavior analytics) use React components built in-house. Externally shared charts (blog posts, tech talks) often use Recharts or Visx.

- **Kakao** — ECharts-based visualizations appear in Kakao Ads and parts of the Kakao Talk Business dashboard. The data team also runs Superset/Metabase for internal BI.

- **Naver / LINE** — LINE Business Manager and LINE Ads dashboards mix in-house components with ECharts and Recharts. The data team runs Tableau and Looker side by side.

- **Coupang** — Tableau is the internal-analytics standard; ML/DS visualizations use Plotly inside Jupyter.

- **Media** — The data teams at Chosun Ilbo's design desk, JoongAng Ilbo, and SBS/KBS combine D3 with Datawrapper for interactive articles.

**Japan**

- **Nikkei** — The Nikkei Visual Data team builds interactive articles using D3 + Observable Plot + Datawrapper. Their COVID dashboards (2020–2023) became famous as D3-driven in-house visualizations.

- **freee** — The accounting SaaS runs Metabase for internal BI and builds product dashboards with Recharts-based in-house components.

- **Mercari** — Runs Superset and Looker together, with Plotly in some product analytics tools.

- **SmartHR** — The HR SaaS uses Looker for internal BI and Recharts for product visualizations.

- **NHK data team** — Combines D3 and Highcharts to produce election and disaster interactive visualizations.

19. Who Should Pick What

With so many tools on offer, simplifying the decision flow helps.

| Situation | Recommended tools |

|---|---|

| React admin dashboard | Recharts (default), Tremor (lots of KPI cards), Nivo (many chart types) |

| Interactive data journalism | D3.js + Observable Plot + Datawrapper |

| Python notebooks, ML viz | Plotly + Altair (Vega-Lite) |

| Large interactive dashboards | Apache ECharts (Canvas/WebGL option) |

| Five simple charts | Chart.js v5 |

| Commercial/financial charts | Highcharts (Highstock) |

| Network and graph | Cytoscape.js (analytics), Sigma.js (large scale), G6 (business) |

| Workflow editor | React Flow (xyflow) |

| In-house BI (OSS) | Metabase (user-friendly), Superset (engineer-friendly), Lightdash (dbt-friendly) |

| Markdown-based BI | Evidence.dev |

| Observability dashboards | Grafana (metrics), Kibana (logs) |

| Enterprise BI | Tableau (exploration), Power BI (MS stack), Looker (BQ + LookML) |

| Newsroom/blog charts | Datawrapper (static), Flourish (storytelling) |

**Suggested learning order**: (1) Chart.js for the fundamentals → (2) Recharts for React-native charts → (3) Vega-Lite/Altair for declarative grammars → (4) D3 for full freedom → (5) Observable Plot or Visx to balance the two. For BI tools, start with Metabase and expand to Superset or a commercial tool only when needed.

20. References

- D3.js — https://d3js.org/

- D3.js v8 release notes — https://github.com/d3/d3/releases

- Apache ECharts — https://echarts.apache.org/

- Apache ECharts examples — https://echarts.apache.org/examples/

- Plotly JavaScript — https://plotly.com/javascript/

- Plotly Python — https://plotly.com/python/

- Dash — https://dash.plotly.com/

- Chart.js — https://www.chartjs.org/

- Highcharts — https://www.highcharts.com/

- Recharts — https://recharts.org/

- Visx (Airbnb) — https://airbnb.io/visx/

- Nivo — https://nivo.rocks/

- Tremor — https://tremor.so/

- Vega — https://vega.github.io/vega/

- Vega-Lite — https://vega.github.io/vega-lite/

- Altair (Vega-Lite Python) — https://altair-viz.github.io/

- Observable Plot — https://observablehq.com/plot/

- Sigma.js — https://www.sigmajs.org/

- Cytoscape.js — https://js.cytoscape.org/

- AntV — https://antv.vision/

- G6 (AntV) — https://g6.antv.antgroup.com/

- X6 (AntV) — https://x6.antv.antgroup.com/

- React Flow (xyflow) — https://reactflow.dev/

- Apache Superset — https://superset.apache.org/

- Metabase — https://www.metabase.com/

- Lightdash — https://www.lightdash.com/

- Evidence.dev — https://evidence.dev/

- Grafana — https://grafana.com/

- Kibana — https://www.elastic.co/kibana

- Looker — https://cloud.google.com/looker

- Tableau — https://www.tableau.com/

- Power BI — https://powerbi.microsoft.com/

- Datawrapper — https://www.datawrapper.de/

- Flourish — https://flourish.studio/

- Mike Bostock, "Observable Plot is a JavaScript library for exploratory data visualization" — https://observablehq.com/@observablehq/plot

- The New York Times Graphics team — https://www.nytimes.com/spotlight/graphics