Forem: Eric Lewis

Advanced Data Visualizations with React Muze

Eric Lewis — Mon, 19 Jan 2026 18:26:23 +0000

React Muze is a React wrapper for Muze, a powerful data visualization library that provides a grammar-of-graphics approach to creating complex, interactive visualizations. It offers flexible components for building sophisticated data visualizations with extensive customization options. This guide walks through advanced usage of React Muze, including complex chart configurations, interactive features, and dashboard implementations.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React hooks (useState, useEffect, useRef)
Familiarity with JavaScript/TypeScript
Understanding of data visualization concepts

Installation

Install React Muze and Muze core:

npm install react-muze muze

Or with yarn:

yarn add react-muze muze

Or with pnpm:

pnpm add react-muze muze

After installation, your package.json should include:

{
  "dependencies": {
    "react-muze": "^1.0.0",
    "muze": "^1.0.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

React Muze requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React, { useEffect, useRef } from 'react';
import Muze from 'muze';
import 'muze/dist/muze.css';

function ChartExample() {
  const chartRef = useRef(null);

  useEffect(() => {
    const data = [
      { month: 'Jan', sales: 35 },
      { month: 'Feb', sales: 28 },
      { month: 'Mar', sales: 34 },
      { month: 'Apr', sales: 32 },
      { month: 'May', sales: 40 },
      { month: 'Jun', sales: 32 }
    ];

    const DataModel = Muze.DataModel;
    const schema = [
      { name: 'month', type: 'dimension' },
      { name: 'sales', type: 'measure' }
    ];

    const dm = new DataModel(data, schema);
    const env = Muze();
    const canvas = env.canvas();

    if (chartRef.current) {
      canvas
        .data(dm)
        .rows(['sales'])
        .columns(['month'])
        .mount(chartRef.current);
    }

    return () => {
      if (env) {
        env.destroy();
      }
    };
  }, []);

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Muze Chart Example</h2>
      <div ref={chartRef} style={{ width: '100%', height: '400px' }} />
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic chart displaying monthly sales data.

Understanding the Basics

React Muze provides a grammar-of-graphics approach:

Muze instance: Main visualization engine
DataModel: Data structure with schema
Canvas: Chart rendering container
Rows and columns: Define chart layout
Grammar of graphics: Declarative visualization approach

Key concepts for advanced usage:

DataModel: Create data model with schema definition
Schema: Define dimensions and measures
Canvas: Configure chart rendering
Rows/Columns: Define chart structure
Mount: Render chart to DOM element

Here's an example with multiple chart types:

// src/AdvancedChartExample.jsx
import React, { useEffect, useRef } from 'react';
import Muze from 'muze';
import 'muze/dist/muze.css';

function AdvancedChartExample() {
  const chartRef1 = useRef(null);
  const chartRef2 = useRef(null);

  useEffect(() => {
    const lineData = [
      { day: 'Mon', value: 120 },
      { day: 'Tue', value: 132 },
      { day: 'Wed', value: 101 },
      { day: 'Thu', value: 134 },
      { day: 'Fri', value: 90 }
    ];

    const barData = [
      { product: 'Product A', revenue: 120 },
      { product: 'Product B', revenue: 200 },
      { product: 'Product C', revenue: 150 }
    ];

    const lineSchema = [
      { name: 'day', type: 'dimension' },
      { name: 'value', type: 'measure' }
    ];

    const barSchema = [
      { name: 'product', type: 'dimension' },
      { name: 'revenue', type: 'measure' }
    ];

    const DataModel = Muze.DataModel;
    const env = Muze();

    if (chartRef1.current) {
      const dm1 = new DataModel(lineData, lineSchema);
      env.canvas()
        .data(dm1)
        .rows(['value'])
        .columns(['day'])
        .mount(chartRef1.current);
    }

    if (chartRef2.current) {
      const dm2 = new DataModel(barData, barSchema);
      env.canvas()
        .data(dm2)
        .rows(['revenue'])
        .columns(['product'])
        .mount(chartRef2.current);
    }

    return () => {
      if (env) {
        env.destroy();
      }
    };
  }, []);

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Advanced Muze Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h3>Line Chart</h3>
          <div ref={chartRef1} style={{ width: '100%', height: '300px' }} />
        </div>
        <div>
          <h3>Bar Chart</h3>
          <div ref={chartRef2} style={{ width: '100%', height: '300px' }} />
        </div>
      </div>
    </div>
  );
}

export default AdvancedChartExample;

Practical Example / Building Something Real

Let's build a comprehensive analytics dashboard:

// src/AnalyticsDashboard.jsx
import React, { useEffect, useRef, useState } from 'react';
import Muze from 'muze';
import 'muze/dist/muze.css';

function AnalyticsDashboard() {
  const [selectedPeriod, setSelectedPeriod] = useState('monthly');
  const chartRef1 = useRef(null);
  const chartRef2 = useRef(null);
  const chartRef3 = useRef(null);

  useEffect(() => {
    const monthlyData = [
      { month: 'Jan', sales: 35, target: 40 },
      { month: 'Feb', sales: 28, target: 35 },
      { month: 'Mar', sales: 34, target: 38 },
      { month: 'Apr', sales: 32, target: 36 },
      { month: 'May', sales: 40, target: 42 },
      { month: 'Jun', sales: 32, target: 38 }
    ];

    const quarterlyData = [
      { quarter: 'Q1', sales: 97, target: 113 },
      { quarter: 'Q2', sales: 106, target: 116 },
      { quarter: 'Q3', sales: 112, target: 120 },
      { quarter: 'Q4', sales: 120, target: 125 }
    ];

    const revenueData = [
      { quarter: 'Q1', revenue: 12000 },
      { quarter: 'Q2', revenue: 15000 },
      { quarter: 'Q3', revenue: 18000 },
      { quarter: 'Q4', revenue: 20000 }
    ];

    const categoryData = [
      { product: 'Product A', value: 35 },
      { product: 'Product B', value: 28 },
      { product: 'Product C', value: 34 },
      { product: 'Product D', value: 32 }
    ];

    const currentData = selectedPeriod === 'monthly' ? monthlyData : quarterlyData;
    const dimensionField = selectedPeriod === 'monthly' ? 'month' : 'quarter';

    const salesSchema = [
      { name: dimensionField, type: 'dimension' },
      { name: 'sales', type: 'measure' },
      { name: 'target', type: 'measure' }
    ];

    const revenueSchema = [
      { name: 'quarter', type: 'dimension' },
      { name: 'revenue', type: 'measure' }
    ];

    const categorySchema = [
      { name: 'product', type: 'dimension' },
      { name: 'value', type: 'measure' }
    ];

    const DataModel = Muze.DataModel;
    const env = Muze();

    if (chartRef1.current) {
      const dm1 = new DataModel(currentData, salesSchema);
      env.canvas()
        .data(dm1)
        .rows(['sales', 'target'])
        .columns([dimensionField])
        .mount(chartRef1.current);
    }

    if (chartRef2.current) {
      const dm2 = new DataModel(revenueData, revenueSchema);
      env.canvas()
        .data(dm2)
        .rows(['revenue'])
        .columns(['quarter'])
        .mount(chartRef2.current);
    }

    if (chartRef3.current) {
      const dm3 = new DataModel(categoryData, categorySchema);
      env.canvas()
        .data(dm3)
        .rows(['value'])
        .columns(['product'])
        .mount(chartRef3.current);
    }

    return () => {
      if (env) {
        env.destroy();
      }
    };
  }, [selectedPeriod]);

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Analytics Dashboard</h1>
      <div style={{ marginBottom: '20px', textAlign: 'center' }}>
        <button
          onClick={() => setSelectedPeriod('monthly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'monthly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Monthly
        </button>
        <button
          onClick={() => setSelectedPeriod('quarterly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'quarterly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Quarterly
        </button>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Sales vs Target</h2>
          <div ref={chartRef1} style={{ width: '100%', height: '400px' }} />
        </div>
        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
          <div>
            <h2>Quarterly Revenue</h2>
            <div ref={chartRef2} style={{ width: '100%', height: '400px' }} />
          </div>
          <div>
            <h2>Product Distribution</h2>
            <div ref={chartRef3} style={{ width: '100%', height: '400px' }} />
          </div>
        </div>
      </div>
    </div>
  );
}

export default AnalyticsDashboard;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import AnalyticsDashboard from './AnalyticsDashboard';
import './App.css';

function App() {
  return (
    <div className="App">
      <AnalyticsDashboard />
    </div>
  );
}

export default App;

This example demonstrates:

Analytics dashboard
Multiple chart types
Dynamic data updates
Interactive features
Grammar-of-graphics approach
Custom styling

Common Issues / Troubleshooting

Chart not displaying: Make sure you've imported Muze CSS. Check that the DataModel schema matches your data structure.
Data format error: Ensure data is an array of objects. Define schema with correct dimension and measure types.
Schema errors: Use 'dimension' for categorical data and 'measure' for numeric data. Check that schema field names match data property names.
Mounting issues: Use useRef to get DOM element reference. Mount chart after component mounts using useEffect.
Memory leaks: Clean up Muze instances in useEffect return function. Call env.destroy() to prevent memory leaks.
Performance: For large datasets, consider data aggregation or sampling. Muze handles large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have an advanced understanding of React Muze:

Explore all available chart types
Learn about advanced grammar-of-graphics configurations
Implement custom visualizations
Add interactive features
Create complex dashboards
Learn about other visualization libraries
Check the official repository: https://github.com/chartshq/react-muze

Summary

You've successfully integrated React Muze into your React application with advanced features including analytics dashboards, interactive charts, and complex visualizations. React Muze provides a powerful, grammar-of-graphics approach to creating data visualizations with extensive customization options.

SEO Keywords

react-muze
React Muze
react-muze tutorial
React data visualization
react-muze installation
React chart library
react-muze example
React grammar of graphics
react-muze setup
React interactive charts
react-muze customization
React chart component
react-muze dashboard
React visualization library
react-muze getting started

Building Interactive Charts with Smart React Chart

Eric Lewis — Mon, 19 Jan 2026 18:23:32 +0000

Smart React Chart is a comprehensive charting library for React that provides a wide range of chart types and interactive features. It offers a declarative API for creating responsive, animated charts with extensive customization options. This guide walks through setting up and creating charts using Smart React Chart with React, from installation to a working implementation. This is part 89 of a series on using Smart React Chart with React.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React hooks (useState)
Familiarity with JavaScript/TypeScript
Understanding of data visualization concepts

Installation

Install Smart React Chart using your preferred package manager:

npm install smart-webcomponents-react

Or with yarn:

yarn add smart-webcomponents-react

Or with pnpm:

pnpm add smart-webcomponents-react

After installation, your package.json should include:

{
  "dependencies": {
    "smart-webcomponents-react": "^12.0.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

Smart React Chart requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple line chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import { SmartChart } from 'smart-webcomponents-react/chart';

function ChartExample() {
  const dataSource = [
    { month: 'Jan', sales: 35 },
    { month: 'Feb', sales: 28 },
    { month: 'Mar', sales: 34 },
    { month: 'Apr', sales: 32 },
    { month: 'May', sales: 40 },
    { month: 'Jun', sales: 32 }
  ];

  const chartSettings = {
    caption: 'Monthly Sales',
    description: 'Sales data for the first half of the year',
    showLegend: true,
    padding: { left: 5, top: 5, right: 5, bottom: 5 },
    titlePadding: { left: 90, top: 0, right: 0, bottom: 10 },
    dataSource: dataSource,
    colorScheme: 'scheme01',
    xAxis: {
      dataField: 'month',
      gridLines: { visible: true }
    },
    valueAxis: {
      visible: true,
      title: { text: 'Sales' }
    },
    seriesGroups: [
      {
        type: 'line',
        series: [
          {
            dataField: 'sales',
            displayText: 'Sales',
            lineWidth: 2
          }
        ]
      }
    ]
  };

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Smart Chart Example</h2>
      <SmartChart {...chartSettings} />
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic line chart with monthly sales data.

Understanding the Basics

Smart React Chart provides a comprehensive chart component:

SmartChart component: Main chart component
dataSource prop: Chart data array
chartSettings: Chart configuration object
Chart types: Line, Bar, Area, Pie, etc.
Interactive features: Tooltips, zoom, pan, etc.

Key concepts:

Data structure: Array of objects with consistent properties
Configuration object: Configure chart through settings
Series groups: Define chart series and types
Axis configuration: Configure X and Y axes
Styling: Customize colors and appearance

Here's an example with multiple chart types:

// src/MultipleChartsExample.jsx
import React from 'react';
import { SmartChart } from 'smart-webcomponents-react/chart';

function MultipleChartsExample() {
  const lineData = [
    { day: 'Mon', value: 120 },
    { day: 'Tue', value: 132 },
    { day: 'Wed', value: 101 },
    { day: 'Thu', value: 134 },
    { day: 'Fri', value: 90 }
  ];

  const barData = [
    { product: 'Product A', revenue: 120 },
    { product: 'Product B', revenue: 200 },
    { product: 'Product C', revenue: 150 }
  ];

  const lineSettings = {
    caption: 'Line Chart',
    dataSource: lineData,
    xAxis: { dataField: 'day' },
    valueAxis: { visible: true },
    seriesGroups: [
      {
        type: 'line',
        series: [{ dataField: 'value', displayText: 'Value' }]
      }
    ]
  };

  const barSettings = {
    caption: 'Bar Chart',
    dataSource: barData,
    xAxis: { dataField: 'product' },
    valueAxis: { visible: true },
    seriesGroups: [
      {
        type: 'column',
        series: [{ dataField: 'revenue', displayText: 'Revenue' }]
      }
    ]
  };

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Multiple Charts Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <SmartChart {...lineSettings} />
        <SmartChart {...barSettings} />
      </div>
    </div>
  );
}

export default MultipleChartsExample;

Practical Example / Building Something Real

Let's build a comprehensive dashboard with multiple charts:

// src/DashboardCharts.jsx
import React, { useState } from 'react';
import { SmartChart } from 'smart-webcomponents-react/chart';

function DashboardCharts() {
  const [selectedPeriod, setSelectedPeriod] = useState('monthly');

  const monthlyData = [
    { month: 'Jan', sales: 35, target: 40 },
    { month: 'Feb', sales: 28, target: 35 },
    { month: 'Mar', sales: 34, target: 38 },
    { month: 'Apr', sales: 32, target: 36 },
    { month: 'May', sales: 40, target: 42 },
    { month: 'Jun', sales: 32, target: 38 }
  ];

  const quarterlyData = [
    { quarter: 'Q1', sales: 97, target: 113 },
    { quarter: 'Q2', sales: 106, target: 116 },
    { quarter: 'Q3', sales: 112, target: 120 },
    { quarter: 'Q4', sales: 120, target: 125 }
  ];

  const revenueData = [
    { quarter: 'Q1', revenue: 12000 },
    { quarter: 'Q2', revenue: 15000 },
    { quarter: 'Q3', revenue: 18000 },
    { quarter: 'Q4', revenue: 20000 }
  ];

  const categoryData = [
    { product: 'Product A', value: 35 },
    { product: 'Product B', value: 28 },
    { product: 'Product C', value: 34 },
    { product: 'Product D', value: 32 }
  ];

  const currentData = selectedPeriod === 'monthly' ? monthlyData : quarterlyData;
  const xAxisField = selectedPeriod === 'monthly' ? 'month' : 'quarter';

  const salesSettings = {
    caption: 'Sales vs Target',
    dataSource: currentData,
    xAxis: { dataField: xAxisField },
    valueAxis: { visible: true, title: { text: 'Sales' } },
    seriesGroups: [
      {
        type: 'line',
        series: [
          { dataField: 'sales', displayText: 'Sales' },
          { dataField: 'target', displayText: 'Target' }
        ]
      }
    ]
  };

  const revenueSettings = {
    caption: 'Quarterly Revenue',
    dataSource: revenueData,
    xAxis: { dataField: 'quarter' },
    valueAxis: { visible: true, title: { text: 'Revenue ($)' } },
    seriesGroups: [
      {
        type: 'column',
        series: [{ dataField: 'revenue', displayText: 'Revenue' }]
      }
    ]
  };

  const pieSettings = {
    caption: 'Product Distribution',
    dataSource: categoryData,
    seriesGroups: [
      {
        type: 'pie',
        series: [
          {
            dataField: 'value',
            displayText: 'product',
            radius: 120
          }
        ]
      }
    ]
  };

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Analytics Dashboard</h1>
      <div style={{ marginBottom: '20px', textAlign: 'center' }}>
        <button
          onClick={() => setSelectedPeriod('monthly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'monthly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Monthly
        </button>
        <button
          onClick={() => setSelectedPeriod('quarterly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'quarterly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Quarterly
        </button>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <SmartChart {...salesSettings} />
        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
          <SmartChart {...revenueSettings} />
          <SmartChart {...pieSettings} />
        </div>
      </div>
    </div>
  );
}

export default DashboardCharts;

Now create an interactive chart with custom styling:

// src/InteractiveChart.jsx
import React from 'react';
import { SmartChart } from 'smart-webcomponents-react/chart';

function InteractiveChart() {
  const data = [
    { month: 'Jan', sales: 35, target: 40 },
    { month: 'Feb', sales: 28, target: 35 },
    { month: 'Mar', sales: 34, target: 38 },
    { month: 'Apr', sales: 32, target: 36 },
    { month: 'May', sales: 40, target: 42 },
    { month: 'Jun', sales: 32, target: 38 }
  ];

  const settings = {
    caption: 'Interactive Sales Chart',
    dataSource: data,
    xAxis: { dataField: 'month' },
    valueAxis: { visible: true, title: { text: 'Sales' } },
    seriesGroups: [
      {
        type: 'line',
        series: [
          {
            dataField: 'sales',
            displayText: 'Sales',
            lineWidth: 2,
            symbolType: 'circle',
            symbolSize: 8
          },
          {
            dataField: 'target',
            displayText: 'Target',
            lineWidth: 2,
            symbolType: 'square',
            symbolSize: 8
          }
        ]
      }
    ],
    toolTipFormatFunction: (value, itemIndex, series, group, categoryValue, categoryAxis) => {
      return `${categoryValue}: ${value}`;
    }
  };

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Interactive Chart</h2>
      <SmartChart {...settings} />
    </div>
  );
}

export default InteractiveChart;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import DashboardCharts from './DashboardCharts';
import InteractiveChart from './InteractiveChart';
import './App.css';

function App() {
  return (
    <div className="App">
      <DashboardCharts />
      <InteractiveChart />
    </div>
  );
}

export default App;

This example demonstrates:

Multiple chart types
Dashboard layout
Multiple series
Interactive features
Dynamic data updates
Custom tooltips
Custom styling

Common Issues / Troubleshooting

Chart not displaying: Make sure you're importing SmartChart correctly from 'smart-webcomponents-react/chart'. Check that the dataSource array is properly formatted.
Data format error: Ensure dataSource is an array of objects with consistent property names. Check that dataField values match your data properties.
Series not showing: Verify that dataField in series matches your data property names. Ensure the type prop in seriesGroups is set correctly.
Styling issues: Customize colors through colorScheme or individual series styling. Use the style property for custom styling.
Axis not configured: Set xAxis and valueAxis properties in settings. Configure them with dataField and other options.
Performance: For large datasets, consider data sampling or pagination. Smart Chart handles large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have an understanding of Smart React Chart:

Explore all available chart types
Learn about advanced configurations
Customize themes and styles
Add animations
Create real-time updating charts
Learn about other chart libraries
Check the official documentation: https://www.htmlelements.com/react/demos/chart/overview/

Summary

You've successfully set up Smart React Chart in your React application and created line charts, bar charts, pie charts, and dashboard visualizations. Smart React Chart provides a comprehensive solution for creating professional data visualizations with extensive customization options.

SEO Keywords

smart-react-chart
React Smart Chart
smart-react-chart tutorial
React data visualization
smart-react-chart installation
React chart library
smart-react-chart example
React Smart HTML Elements
smart-react-chart setup
React interactive charts
smart-react-chart customization
React chart component
smart-react-chart dashboard
React chart visualization
smart-react-chart getting started

Getting Started with DevExtreme React Chart: Creating Charts in React

Eric Lewis — Mon, 19 Jan 2026 18:22:20 +0000

DevExtreme React Chart is a comprehensive charting library for React that provides a wide range of chart types and features. It offers a declarative API for creating interactive, responsive charts with extensive customization options. This guide walks through setting up and creating charts using DevExtreme React Chart with React, from installation to a working implementation.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React components
Familiarity with JavaScript/TypeScript

Installation

Install DevExtreme React Chart and required dependencies:

npm install @devextreme/runtime devextreme-react

Or with yarn:

yarn add @devextreme/runtime devextreme-react

Or with pnpm:

pnpm add @devextreme/runtime devextreme-react

After installation, your package.json should include:

{
  "dependencies": {
    "@devextreme/runtime": "^3.0.0",
    "devextreme-react": "^23.0.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

Import DevExtreme CSS in your main entry file:

// src/index.js
import React from 'react';
import ReactDOM from 'react-dom/client';
import 'devextreme/dist/css/dx.light.css';
import App from './App';

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <React.StrictMode>
    <App />
  </React.StrictMode>
);

First Example / Basic Usage

Let's create a simple line chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import { Chart, Series, CommonSeriesSettings, Legend, ValueAxis, ArgumentAxis, Tooltip } from 'devextreme-react/chart';

function ChartExample() {
  const data = [
    { month: 'Jan', sales: 35 },
    { month: 'Feb', sales: 28 },
    { month: 'Mar', sales: 34 },
    { month: 'Apr', sales: 32 },
    { month: 'May', sales: 40 },
    { month: 'Jun', sales: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic DevExtreme Chart Example</h2>
      <Chart dataSource={data}>
        <ArgumentAxis argumentField="month" />
        <ValueAxis />
        <Series
          valueField="sales"
          argumentField="month"
          type="line"
        />
        <Legend visible={false} />
        <Tooltip enabled={true} />
      </Chart>
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic line chart with monthly sales data.

Understanding the Basics

DevExtreme React Chart provides composable chart components:

Chart: Main chart container
Series: Data series component
ArgumentAxis: X-axis component
ValueAxis: Y-axis component
Legend: Chart legend
Tooltip: Interactive tooltips
CommonSeriesSettings: Shared settings for all series

Key concepts:

dataSource prop: Array of data objects
valueField: Property name for Y-axis values
argumentField: Property name for X-axis values
type prop: Chart type (line, bar, area, pie, etc.)
Composable: Build charts by composing components

Here's an example with multiple chart types:

// src/MultipleChartsExample.jsx
import React from 'react';
import { Chart, Series, ArgumentAxis, ValueAxis, Legend, Tooltip } from 'devextreme-react/chart';

function MultipleChartsExample() {
  const lineData = [
    { day: 'Mon', value: 120 },
    { day: 'Tue', value: 132 },
    { day: 'Wed', value: 101 },
    { day: 'Thu', value: 134 },
    { day: 'Fri', value: 90 }
  ];

  const barData = [
    { product: 'Product A', revenue: 120 },
    { product: 'Product B', revenue: 200 },
    { product: 'Product C', revenue: 150 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Multiple Charts Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h3>Line Chart</h3>
          <Chart dataSource={lineData}>
            <ArgumentAxis argumentField="day" />
            <ValueAxis />
            <Series
              valueField="value"
              argumentField="day"
              type="line"
            />
            <Tooltip enabled={true} />
          </Chart>
        </div>
        <div>
          <h3>Bar Chart</h3>
          <Chart dataSource={barData}>
            <ArgumentAxis argumentField="product" />
            <ValueAxis />
            <Series
              valueField="revenue"
              argumentField="product"
              type="bar"
            />
            <Tooltip enabled={true} />
          </Chart>
        </div>
      </div>
    </div>
  );
}

export default MultipleChartsExample;

Practical Example / Building Something Real

Let's build a comprehensive dashboard with multiple charts:

// src/DashboardCharts.jsx
import React, { useState } from 'react';
import { Chart, Series, ArgumentAxis, ValueAxis, Legend, Tooltip, CommonSeriesSettings } from 'devextreme-react/chart';

function DashboardCharts() {
  const [selectedPeriod, setSelectedPeriod] = useState('monthly');

  const monthlyData = [
    { month: 'Jan', sales: 35, target: 40 },
    { month: 'Feb', sales: 28, target: 35 },
    { month: 'Mar', sales: 34, target: 38 },
    { month: 'Apr', sales: 32, target: 36 },
    { month: 'May', sales: 40, target: 42 },
    { month: 'Jun', sales: 32, target: 38 }
  ];

  const quarterlyData = [
    { quarter: 'Q1', sales: 97, target: 113 },
    { quarter: 'Q2', sales: 106, target: 116 },
    { quarter: 'Q3', sales: 112, target: 120 },
    { quarter: 'Q4', sales: 120, target: 125 }
  ];

  const revenueData = [
    { quarter: 'Q1', revenue: 12000 },
    { quarter: 'Q2', revenue: 15000 },
    { quarter: 'Q3', revenue: 18000 },
    { quarter: 'Q4', revenue: 20000 }
  ];

  const categoryData = [
    { product: 'Product A', value: 35 },
    { product: 'Product B', value: 28 },
    { product: 'Product C', value: 34 },
    { product: 'Product D', value: 32 }
  ];

  const currentData = selectedPeriod === 'monthly' ? monthlyData : quarterlyData;
  const argumentField = selectedPeriod === 'monthly' ? 'month' : 'quarter';

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Sales Dashboard</h1>
      <div style={{ marginBottom: '20px', textAlign: 'center' }}>
        <button
          onClick={() => setSelectedPeriod('monthly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'monthly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Monthly
        </button>
        <button
          onClick={() => setSelectedPeriod('quarterly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'quarterly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Quarterly
        </button>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Sales vs Target</h2>
          <Chart dataSource={currentData}>
            <ArgumentAxis argumentField={argumentField} />
            <ValueAxis />
            <CommonSeriesSettings argumentField={argumentField} type="line" />
            <Series valueField="sales" name="Sales" />
            <Series valueField="target" name="Target" />
            <Legend visible={true} />
            <Tooltip enabled={true} />
          </Chart>
        </div>
        <div>
          <h2>Quarterly Revenue</h2>
          <Chart dataSource={revenueData}>
            <ArgumentAxis argumentField="quarter" />
            <ValueAxis />
            <Series
              valueField="revenue"
              argumentField="quarter"
              type="bar"
            />
            <Tooltip enabled={true} />
          </Chart>
        </div>
        <div>
          <h2>Product Distribution</h2>
          <Chart dataSource={categoryData}>
            <Series
              valueField="value"
              argumentField="product"
              type="pie"
            />
            <Legend visible={true} />
            <Tooltip enabled={true} />
          </Chart>
        </div>
      </div>
    </div>
  );
}

export default DashboardCharts;

Now create an interactive chart with custom styling:

// src/InteractiveChart.jsx
import React from 'react';
import { Chart, Series, ArgumentAxis, ValueAxis, Tooltip, Legend } from 'devextreme-react/chart';

function InteractiveChart() {
  const data = [
    { month: 'Jan', sales: 35, target: 40 },
    { month: 'Feb', sales: 28, target: 35 },
    { month: 'Mar', sales: 34, target: 38 },
    { month: 'Apr', sales: 32, target: 36 },
    { month: 'May', sales: 40, target: 42 },
    { month: 'Jun', sales: 32, target: 38 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Interactive Chart</h2>
      <Chart dataSource={data}>
        <ArgumentAxis argumentField="month" />
        <ValueAxis />
        <Series
          valueField="sales"
          argumentField="month"
          type="line"
          name="Sales"
          color="#1f77b4"
        />
        <Series
          valueField="target"
          argumentField="month"
          type="line"
          name="Target"
          color="#ff7f0e"
        />
        <Legend visible={true} />
        <Tooltip enabled={true} />
      </Chart>
    </div>
  );
}

export default InteractiveChart;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import DashboardCharts from './DashboardCharts';
import InteractiveChart from './InteractiveChart';
import './App.css';

function App() {
  return (
    <div className="App">
      <DashboardCharts />
      <InteractiveChart />
    </div>
  );
}

export default App;

This example demonstrates:

Multiple chart types
Dashboard layout
Multiple series
Interactive features
Dynamic data updates
Custom styling

Common Issues / Troubleshooting

Chart not displaying: Make sure you've imported the CSS file. DevExtreme requires CSS for proper styling.
Data format error: Ensure dataSource is an array of objects with consistent property names. Check that valueField and argumentField match your data properties.
Styling issues: Import the theme CSS file. Available themes include 'dx.light.css', 'dx.dark.css', etc.
Series not showing: Check that valueField and argumentField props match your data property names. Ensure the type prop is set correctly.
Axis not configured: Add ArgumentAxis and ValueAxis components. Configure them with appropriate argumentField and settings.
Performance: For large datasets, consider data sampling or pagination. DevExtreme handles large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have a basic understanding of DevExtreme React Chart:

Explore all available chart types
Learn about advanced configurations
Customize themes and styles
Add animations
Create real-time updating charts
Learn about other chart libraries
Check the official documentation: https://devexpress.github.io/devextreme-reactive/react/chart/

Summary

You've successfully set up DevExtreme React Chart in your React application and created line charts, bar charts, pie charts, and dashboard visualizations. DevExtreme React Chart provides a comprehensive solution for creating professional data visualizations with extensive customization options.

SEO Keywords

devextreme-react-chart
React DevExtreme Chart
devextreme-react-chart tutorial
React data visualization
devextreme-react-chart installation
React chart library
devextreme-react-chart example
React DevExtreme charts
devextreme-react-chart setup
React interactive charts
devextreme-react-chart customization
React chart component
devextreme-react-chart dashboard
React chart visualization
devextreme-react-chart getting started

Advanced Data Visualizations with Semiotic

Eric Lewis — Mon, 19 Jan 2026 18:21:29 +0000

Semiotic is a powerful React visualization library that provides a grammar-of-graphics approach to creating data visualizations. It offers flexible, composable components for building complex visualizations with extensive customization options. This guide walks through advanced usage of Semiotic, including complex chart configurations, interactive features, and dashboard implementations.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React hooks (useState, useEffect)
Familiarity with JavaScript/TypeScript
Understanding of data visualization concepts

Installation

Install Semiotic using your preferred package manager:

npm install semiotic

Or with yarn:

yarn add semiotic

Or with pnpm:

pnpm add semiotic

After installation, your package.json should include:

{
  "dependencies": {
    "semiotic": "^2.0.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

Semiotic requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple bar chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import { XYFrame, OrdinalFrame } from 'semiotic';

function ChartExample() {
  const data = [
    { x: 'Jan', y: 35 },
    { x: 'Feb', y: 28 },
    { x: 'Mar', y: 34 },
    { x: 'Apr', y: 32 },
    { x: 'May', y: 40 },
    { x: 'Jun', y: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Semiotic Example</h2>
      <OrdinalFrame
        data={data}
        size={[600, 400]}
        oAccessor="x"
        rAccessor="y"
        style={{ fill: '#1f77b4' }}
        type="bar"
      />
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic bar chart displaying monthly sales data.

Understanding the Basics

Semiotic provides frame-based chart components:

XYFrame: XY coordinate charts (line, area, scatter)
OrdinalFrame: Ordinal/categorical charts (bar, point)
NetworkFrame: Network/graph visualizations
ResponsiveFrame: Responsive wrapper
Grammar of graphics: Declarative visualization approach

Key concepts for advanced usage:

Frame components: Main chart containers
Accessors: Functions to access data properties (oAccessor, rAccessor, xAccessor, yAccessor)
Type prop: Chart type (bar, line, area, point, etc.)
Styling: Customize through style prop or style functions
Annotations: Add annotations and overlays

Here's an example with multiple chart types:

// src/AdvancedChartExample.jsx
import React from 'react';
import { XYFrame, OrdinalFrame } from 'semiotic';

function AdvancedChartExample() {
  const lineData = [
    { x: 0, y: 120 },
    { x: 1, y: 132 },
    { x: 2, y: 101 },
    { x: 3, y: 134 },
    { x: 4, y: 90 }
  ];

  const barData = [
    { x: 'Product A', y: 120 },
    { x: 'Product B', y: 200 },
    { x: 'Product C', y: 150 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Advanced Semiotic Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h3>Line Chart</h3>
          <XYFrame
            data={lineData}
            size={[600, 300]}
            xAccessor="x"
            yAccessor="y"
            lineStyle={{ stroke: '#1f77b4', strokeWidth: 2 }}
            lineType="line"
          />
        </div>
        <div>
          <h3>Bar Chart</h3>
          <OrdinalFrame
            data={barData}
            size={[600, 300]}
            oAccessor="x"
            rAccessor="y"
            style={{ fill: '#ff7f0e' }}
            type="bar"
          />
        </div>
      </div>
    </div>
  );
}

export default AdvancedChartExample;

Practical Example / Building Something Real

Let's build a comprehensive analytics dashboard:

// src/AnalyticsDashboard.jsx
import React, { useState } from 'react';
import { XYFrame, OrdinalFrame } from 'semiotic';

function AnalyticsDashboard() {
  const [selectedPeriod, setSelectedPeriod] = useState('monthly');

  const monthlyData = [
    { x: 'Jan', y: 35 },
    { x: 'Feb', y: 28 },
    { x: 'Mar', y: 34 },
    { x: 'Apr', y: 32 },
    { x: 'May', y: 40 },
    { x: 'Jun', y: 32 }
  ];

  const quarterlyData = [
    { x: 'Q1', y: 97 },
    { x: 'Q2', y: 106 },
    { x: 'Q3', y: 112 },
    { x: 'Q4', y: 120 }
  ];

  const revenueData = [
    { x: 'Q1', y: 12000 },
    { x: 'Q2', y: 15000 },
    { x: 'Q3', y: 18000 },
    { x: 'Q4', y: 20000 }
  ];

  const categoryData = [
    { x: 'Product A', y: 35 },
    { x: 'Product B', y: 28 },
    { x: 'Product C', y: 34 },
    { x: 'Product D', y: 32 }
  ];

  const currentData = selectedPeriod === 'monthly' ? monthlyData : quarterlyData;

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Analytics Dashboard</h1>
      <div style={{ marginBottom: '20px', textAlign: 'center' }}>
        <button
          onClick={() => setSelectedPeriod('monthly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'monthly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Monthly
        </button>
        <button
          onClick={() => setSelectedPeriod('quarterly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'quarterly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Quarterly
        </button>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Sales Performance</h2>
          <OrdinalFrame
            data={currentData}
            size={[800, 400]}
            oAccessor="x"
            rAccessor="y"
            style={{ fill: '#1f77b4' }}
            type="bar"
          />
        </div>
        <div>
          <h2>Quarterly Revenue</h2>
          <XYFrame
            data={revenueData}
            size={[800, 400]}
            xAccessor="x"
            yAccessor="y"
            lineStyle={{ stroke: '#ff7f0e', strokeWidth: 2 }}
            lineType="line"
          />
        </div>
        <div>
          <h2>Product Distribution</h2>
          <OrdinalFrame
            data={categoryData}
            size={[600, 400]}
            oAccessor="x"
            rAccessor="y"
            style={{ fill: '#2ca02c' }}
            type="bar"
          />
        </div>
      </div>
    </div>
  );
}

export default AnalyticsDashboard;

Now create an interactive chart with annotations:

// src/InteractiveChart.jsx
import React, { useState } from 'react';
import { XYFrame } from 'semiotic';

function InteractiveChart() {
  const [selectedPoint, setSelectedPoint] = useState(null);

  const data = [
    { x: 0, y: 35 },
    { x: 1, y: 28 },
    { x: 2, y: 34 },
    { x: 3, y: 32 },
    { x: 4, y: 40 },
    { x: 5, y: 32 }
  ];

  const annotations = selectedPoint ? [
    {
      type: 'circle',
      x: selectedPoint.x,
      y: selectedPoint.y,
      r: 5,
      style: { fill: '#ff0000' }
    }
  ] : [];

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Interactive Chart</h2>
      {selectedPoint && (
        <div style={{
          padding: '10px',
          backgroundColor: '#f8f9fa',
          borderRadius: '4px',
          marginBottom: '20px'
        }}>
          Selected: x={selectedPoint.x}, y={selectedPoint.y}
        </div>
      )}
      <XYFrame
        data={data}
        size={[700, 500]}
        xAccessor="x"
        yAccessor="y"
        lineStyle={{ stroke: '#1f77b4', strokeWidth: 2 }}
        lineType="line"
        points={true}
        pointStyle={{ fill: '#1f77b4', r: 4 }}
        onPointClick={(d) => setSelectedPoint(d)}
        annotations={annotations}
      />
    </div>
  );
}

export default InteractiveChart;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import AnalyticsDashboard from './AnalyticsDashboard';
import InteractiveChart from './InteractiveChart';
import './App.css';

function App() {
  return (
    <div className="App">
      <AnalyticsDashboard />
      <InteractiveChart />
    </div>
  );
}

export default App;

This example demonstrates:

Analytics dashboard
Multiple chart types
Interactive features
Dynamic data updates
Annotations
Custom styling

Common Issues / Troubleshooting

Chart not displaying: Make sure you're importing components correctly from 'semiotic'. Check that the data array is properly formatted.
Data format error: Ensure data follows the correct format. Use appropriate accessors (xAccessor, yAccessor for XYFrame, oAccessor, rAccessor for OrdinalFrame).
Accessor errors: Set the correct accessor props based on your frame type. XYFrame uses xAccessor/yAccessor, OrdinalFrame uses oAccessor/rAccessor.
Styling issues: Customize colors through the style prop. Use functions for dynamic styling based on data.
Type not working: Use valid chart types: 'bar', 'line', 'area', 'point', etc. Check Semiotic documentation for all available types.
Performance: For large datasets, consider data sampling or using optimized rendering options. Semiotic handles large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have an advanced understanding of Semiotic:

Explore all available frame types
Learn about advanced configurations
Implement custom annotations
Add interactive features
Create network visualizations
Learn about other visualization libraries
Check the official documentation: https://semiotic.nteract.io/

Summary

You've successfully integrated Semiotic into your React application with advanced features including analytics dashboards, interactive charts, and complex visualizations. Semiotic provides a powerful, grammar-of-graphics approach to creating data visualizations with extensive customization options.

SEO Keywords

semiotic
React Semiotic
semiotic tutorial
React data visualization
semiotic installation
React chart library
semiotic example
React grammar of graphics
semiotic setup
React interactive charts
semiotic customization
React chart component
semiotic dashboard
React visualization library
semiotic getting started

Building Interactive Charts with Victory

Eric Lewis — Mon, 19 Jan 2026 18:20:44 +0000

Victory is a powerful charting library for React that provides a comprehensive set of composable components for creating beautiful, animated, and interactive data visualizations. It offers extensive customization options and built-in animations, making it ideal for creating professional dashboards and analytics visualizations. This guide walks through setting up and creating charts using Victory with React, from installation to a working implementation.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React hooks (useState)
Familiarity with JavaScript/TypeScript
Understanding of data visualization concepts

Installation

Install Victory using your preferred package manager:

npm install victory

Or with yarn:

yarn add victory

Or with pnpm:

pnpm add victory

After installation, your package.json should include:

{
  "dependencies": {
    "victory": "^36.0.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

Victory requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple line chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import {
  VictoryChart,
  VictoryLine,
  VictoryAxis,
  VictoryTheme
} from 'victory';

function ChartExample() {
  const data = [
    { x: 'Jan', y: 35 },
    { x: 'Feb', y: 28 },
    { x: 'Mar', y: 34 },
    { x: 'Apr', y: 32 },
    { x: 'May', y: 40 },
    { x: 'Jun', y: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Victory Example</h2>
      <VictoryChart theme={VictoryTheme.material}>
        <VictoryAxis />
        <VictoryAxis dependentAxis />
        <VictoryLine data={data} />
      </VictoryChart>
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic line chart with animated transitions.

Understanding the Basics

Victory provides composable chart components:

VictoryChart: Main chart container
VictoryLine, VictoryBar, VictoryArea: Data series components
VictoryAxis: Axis components
VictoryTheme: Pre-built themes
VictoryTooltip: Interactive tooltips
VictoryLegend: Chart legends

Key concepts:

Composable API: Build charts by composing components
Data format: Array of objects with x and y properties
Themes: Use pre-built themes or create custom ones
Animations: Built-in animations for all components
Interactive: Built-in tooltips and event handling

Here's an example with multiple chart types:

// src/MultipleChartsExample.jsx
import React from 'react';
import {
  VictoryChart,
  VictoryLine,
  VictoryBar,
  VictoryArea,
  VictoryAxis,
  VictoryTheme
} from 'victory';

function MultipleChartsExample() {
  const lineData = [
    { x: 'Mon', y: 120 },
    { x: 'Tue', y: 132 },
    { x: 'Wed', y: 101 },
    { x: 'Thu', y: 134 },
    { x: 'Fri', y: 90 }
  ];

  const barData = [
    { x: 'Product A', y: 120 },
    { x: 'Product B', y: 200 },
    { x: 'Product C', y: 150 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Multiple Charts Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h3>Line Chart</h3>
          <VictoryChart theme={VictoryTheme.material}>
            <VictoryAxis />
            <VictoryAxis dependentAxis />
            <VictoryLine data={lineData} />
          </VictoryChart>
        </div>
        <div>
          <h3>Bar Chart</h3>
          <VictoryChart theme={VictoryTheme.material}>
            <VictoryAxis />
            <VictoryAxis dependentAxis />
            <VictoryBar data={barData} />
          </VictoryChart>
        </div>
        <div>
          <h3>Area Chart</h3>
          <VictoryChart theme={VictoryTheme.material}>
            <VictoryAxis />
            <VictoryAxis dependentAxis />
            <VictoryArea data={lineData} />
          </VictoryChart>
        </div>
      </div>
    </div>
  );
}

export default MultipleChartsExample;

Practical Example / Building Something Real

Let's build a comprehensive dashboard with multiple charts:

// src/DashboardCharts.jsx
import React, { useState } from 'react';
import {
  VictoryChart,
  VictoryLine,
  VictoryBar,
  VictoryPie,
  VictoryAxis,
  VictoryTheme,
  VictoryTooltip,
  VictoryLegend
} from 'victory';

function DashboardCharts() {
  const [selectedPeriod, setSelectedPeriod] = useState('monthly');

  const monthlyData = [
    { x: 'Jan', y: 35 },
    { x: 'Feb', y: 28 },
    { x: 'Mar', y: 34 },
    { x: 'Apr', y: 32 },
    { x: 'May', y: 40 },
    { x: 'Jun', y: 32 }
  ];

  const quarterlyData = [
    { x: 'Q1', y: 97 },
    { x: 'Q2', y: 106 },
    { x: 'Q3', y: 112 },
    { x: 'Q4', y: 120 }
  ];

  const revenueData = [
    { x: 'Q1', y: 12000 },
    { x: 'Q2', y: 15000 },
    { x: 'Q3', y: 18000 },
    { x: 'Q4', y: 20000 }
  ];

  const categoryData = [
    { x: 'Product A', y: 35 },
    { x: 'Product B', y: 28 },
    { x: 'Product C', y: 34 },
    { x: 'Product D', y: 32 }
  ];

  const currentData = selectedPeriod === 'monthly' ? monthlyData : quarterlyData;

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Analytics Dashboard</h1>
      <div style={{ marginBottom: '20px', textAlign: 'center' }}>
        <button
          onClick={() => setSelectedPeriod('monthly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'monthly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Monthly
        </button>
        <button
          onClick={() => setSelectedPeriod('quarterly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'quarterly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Quarterly
        </button>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Sales Performance</h2>
          <VictoryChart theme={VictoryTheme.material}>
            <VictoryAxis />
            <VictoryAxis dependentAxis />
            <VictoryLine
              data={currentData}
              style={{
                data: { stroke: '#c43a31', strokeWidth: 2 }
              }}
            />
            <VictoryTooltip />
          </VictoryChart>
        </div>
        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
          <div>
            <h2>Quarterly Revenue</h2>
            <VictoryChart theme={VictoryTheme.material}>
              <VictoryAxis />
              <VictoryAxis dependentAxis />
              <VictoryBar
                data={revenueData}
                style={{
                  data: { fill: '#c43a31' }
                }}
              />
              <VictoryTooltip />
            </VictoryChart>
          </div>
          <div>
            <h2>Product Distribution</h2>
            <VictoryPie
              data={categoryData}
              colorScale={['#c43a31', '#f39c12', '#3498db', '#2ecc71']}
              labelRadius={({ innerRadius }) => innerRadius + 20}
              style={{
                labels: { fill: 'white', fontSize: 12, fontWeight: 'bold' }
              }}
            />
          </div>
        </div>
      </div>
    </div>
  );
}

export default DashboardCharts;

Now create an interactive chart with custom styling:

// src/InteractiveChart.jsx
import React, { useState } from 'react';
import {
  VictoryChart,
  VictoryLine,
  VictoryAxis,
  VictoryTheme,
  VictoryTooltip,
  VictoryVoronoiContainer
} from 'victory';

function InteractiveChart() {
  const [selectedPoint, setSelectedPoint] = useState(null);

  const data = [
    { x: 'Jan', y: 35 },
    { x: 'Feb', y: 28 },
    { x: 'Mar', y: 34 },
    { x: 'Apr', y: 32 },
    { x: 'May', y: 40 },
    { x: 'Jun', y: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Interactive Chart</h2>
      {selectedPoint && (
        <div style={{
          padding: '10px',
          backgroundColor: '#f8f9fa',
          borderRadius: '4px',
          marginBottom: '20px'
        }}>
          Selected: {selectedPoint.x} - {selectedPoint.y}
        </div>
      )}
      <VictoryChart
        theme={VictoryTheme.material}
        containerComponent={<VictoryVoronoiContainer />}
        onActivated={(points) => {
          if (points.length > 0) {
            setSelectedPoint(points[0]);
          }
        }}
      >
        <VictoryAxis />
        <VictoryAxis dependentAxis />
        <VictoryLine
          data={data}
          style={{
            data: { stroke: '#c43a31', strokeWidth: 2 }
          }}
        />
        <VictoryTooltip />
      </VictoryChart>
    </div>
  );
}

export default InteractiveChart;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import DashboardCharts from './DashboardCharts';
import InteractiveChart from './InteractiveChart';
import './App.css';

function App() {
  return (
    <div className="App">
      <DashboardCharts />
      <InteractiveChart />
    </div>
  );
}

export default App;

This example demonstrates:

Multiple chart types
Dashboard layout
Interactive features
Custom styling
Dynamic data updates
Tooltips and legends

Common Issues / Troubleshooting

Chart not displaying: Make sure you're importing components correctly from 'victory'. Check that the data array is properly formatted.
Data format error: Ensure data is an array of objects with x and y properties. Both should be present in each object.
Styling issues: Customize colors through the style prop. Use data property for series styling and labels for text styling.
Axis not showing: Add VictoryAxis components inside VictoryChart. Use dependentAxis prop for Y-axis.
Animations not working: Animations are enabled by default. Disable them with animate={false} if needed.
Performance: For large datasets, consider data sampling or using VictoryZoomContainer for zooming. Victory handles large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have an understanding of Victory:

Explore all available chart types
Learn about advanced configurations
Implement custom themes
Add animations and transitions
Create real-time updating charts
Learn about other chart libraries
Check the official repository: https://github.com/FormidableLabs/victory

Summary

You've successfully set up Victory in your React application and created line charts, bar charts, pie charts, and interactive visualizations. Victory provides a powerful, composable solution for creating animated data visualizations with extensive customization options.

SEO Keywords

victory
React Victory
victory tutorial
React data visualization
victory installation
React chart library
victory example
React animated charts
victory setup
React interactive charts
victory customization
React chart component
victory dashboard
React visualization library
victory getting started

Getting Started with Rumble Charts: Creating Charts in React

Eric Lewis — Mon, 19 Jan 2026 18:19:12 +0000

Rumble Charts is a composable charting library for React that provides a simple, declarative API for creating various types of charts. It offers a flexible component-based architecture that makes it easy to build custom visualizations. This guide walks through setting up and creating charts using Rumble Charts with React, from installation to a working implementation.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React components
Familiarity with JavaScript/TypeScript

Installation

Install Rumble Charts using your preferred package manager:

npm install rumble-charts

Or with yarn:

yarn add rumble-charts

Or with pnpm:

pnpm add rumble-charts

After installation, your package.json should include:

{
  "dependencies": {
    "rumble-charts": "^1.0.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

Rumble Charts requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple line chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import { Chart, Bars, Ticks, Layer, Animate } from 'rumble-charts';

function ChartExample() {
  const data = [
    { x: 'Jan', y: 35 },
    { x: 'Feb', y: 28 },
    { x: 'Mar', y: 34 },
    { x: 'Apr', y: 32 },
    { x: 'May', y: 40 },
    { x: 'Jun', y: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Rumble Charts Example</h2>
      <Chart width={600} height={400} data={data}>
        <Layer width="80%" height="70%" position="middle center">
          <Bars />
          <Ticks
            axis="x"
            ticks={{ maxTicks: 6 }}
            lineLength="100%"
            lineStyle={{ stroke: '#ccc' }}
            labelStyle={{ textAnchor: 'middle', dominantBaseline: 'text-after-edge' }}
            labelAttributes={{ y: 4 }}
          />
          <Ticks
            axis="y"
            ticks={{ maxTicks: 5 }}
            lineLength="100%"
            lineStyle={{ stroke: '#ccc' }}
            labelStyle={{ textAnchor: 'end', dominantBaseline: 'middle' }}
            labelAttributes={{ x: -4 }}
          />
        </Layer>
      </Chart>
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic bar chart with axes and labels.

Understanding the Basics

Rumble Charts provides composable chart components:

Chart: Main chart container
Layer: Container for chart elements
Bars, Lines, Areas: Data series components
Ticks: Axis ticks and labels
Animate: Animation wrapper
Composable: Build charts by composing components

Key concepts:

Chart component: Main container with width, height, and data
Layer component: Groups chart elements with positioning
Data format: Array of objects with x and y properties
Ticks: Configure axes with Ticks component
Styling: Customize through component props

Here's an example with multiple chart types:

// src/MultipleChartsExample.jsx
import React from 'react';
import { Chart, Bars, Lines, Ticks, Layer, Animate } from 'rumble-charts';

function MultipleChartsExample() {
  const barData = [
    { x: 'Product A', y: 120 },
    { x: 'Product B', y: 200 },
    { x: 'Product C', y: 150 }
  ];

  const lineData = [
    { x: 'Mon', y: 120 },
    { x: 'Tue', y: 132 },
    { x: 'Wed', y: 101 },
    { x: 'Thu', y: 134 },
    { x: 'Fri', y: 90 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Multiple Charts Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h3>Bar Chart</h3>
          <Chart width={600} height={300} data={barData}>
            <Layer width="80%" height="70%" position="middle center">
              <Bars />
              <Ticks
                axis="x"
                ticks={{ maxTicks: 3 }}
                lineLength="100%"
                lineStyle={{ stroke: '#ccc' }}
                labelStyle={{ textAnchor: 'middle', dominantBaseline: 'text-after-edge' }}
                labelAttributes={{ y: 4 }}
              />
              <Ticks
                axis="y"
                ticks={{ maxTicks: 5 }}
                lineLength="100%"
                lineStyle={{ stroke: '#ccc' }}
                labelStyle={{ textAnchor: 'end', dominantBaseline: 'middle' }}
                labelAttributes={{ x: -4 }}
              />
            </Layer>
          </Chart>
        </div>
        <div>
          <h3>Line Chart</h3>
          <Chart width={600} height={300} data={lineData}>
            <Layer width="80%" height="70%" position="middle center">
              <Lines />
              <Ticks
                axis="x"
                ticks={{ maxTicks: 5 }}
                lineLength="100%"
                lineStyle={{ stroke: '#ccc' }}
                labelStyle={{ textAnchor: 'middle', dominantBaseline: 'text-after-edge' }}
                labelAttributes={{ y: 4 }}
              />
              <Ticks
                axis="y"
                ticks={{ maxTicks: 5 }}
                lineLength="100%"
                lineStyle={{ stroke: '#ccc' }}
                labelStyle={{ textAnchor: 'end', dominantBaseline: 'middle' }}
                labelAttributes={{ x: -4 }}
              />
            </Layer>
          </Chart>
        </div>
      </div>
    </div>
  );
}

export default MultipleChartsExample;

Practical Example / Building Something Real

Let's build a comprehensive dashboard with multiple charts:

// src/DashboardCharts.jsx
import React from 'react';
import { Chart, Bars, Lines, Ticks, Layer, Animate } from 'rumble-charts';

function DashboardCharts() {
  const salesData = [
    { x: 'Jan', y: 35 },
    { x: 'Feb', y: 28 },
    { x: 'Mar', y: 34 },
    { x: 'Apr', y: 32 },
    { x: 'May', y: 40 },
    { x: 'Jun', y: 32 }
  ];

  const revenueData = [
    { x: 'Q1', y: 12000 },
    { x: 'Q2', y: 15000 },
    { x: 'Q3', y: 18000 },
    { x: 'Q4', y: 20000 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Sales Dashboard</h1>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Monthly Sales</h2>
          <Chart width={800} height={400} data={salesData}>
            <Animate>
              <Layer width="80%" height="70%" position="middle center">
                <Bars />
                <Ticks
                  axis="x"
                  ticks={{ maxTicks: 6 }}
                  lineLength="100%"
                  lineStyle={{ stroke: '#ccc' }}
                  labelStyle={{ textAnchor: 'middle', dominantBaseline: 'text-after-edge' }}
                  labelAttributes={{ y: 4 }}
                />
                <Ticks
                  axis="y"
                  ticks={{ maxTicks: 5 }}
                  lineLength="100%"
                  lineStyle={{ stroke: '#ccc' }}
                  labelStyle={{ textAnchor: 'end', dominantBaseline: 'middle' }}
                  labelAttributes={{ x: -4 }}
                />
              </Layer>
            </Animate>
          </Chart>
        </div>
        <div>
          <h2>Quarterly Revenue</h2>
          <Chart width={800} height={400} data={revenueData}>
            <Animate>
              <Layer width="80%" height="70%" position="middle center">
                <Lines />
                <Ticks
                  axis="x"
                  ticks={{ maxTicks: 4 }}
                  lineLength="100%"
                  lineStyle={{ stroke: '#ccc' }}
                  labelStyle={{ textAnchor: 'middle', dominantBaseline: 'text-after-edge' }}
                  labelAttributes={{ y: 4 }}
                />
                <Ticks
                  axis="y"
                  ticks={{ maxTicks: 5 }}
                  lineLength="100%"
                  lineStyle={{ stroke: '#ccc' }}
                  labelStyle={{ textAnchor: 'end', dominantBaseline: 'middle' }}
                  labelAttributes={{ x: -4 }}
                />
              </Layer>
            </Animate>
          </Chart>
        </div>
      </div>
    </div>
  );
}

export default DashboardCharts;

Now create a product comparison chart:

// src/ProductComparisonChart.jsx
import React from 'react';
import { Chart, Bars, Ticks, Layer, Animate } from 'rumble-charts';

function ProductComparisonChart() {
  const data = [
    { x: 'Product A', y: 120 },
    { x: 'Product B', y: 100 },
    { x: 'Product C', y: 90 },
    { x: 'Product D', y: 110 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Product Sales Comparison</h2>
      <Chart width={700} height={400} data={data}>
        <Animate>
          <Layer width="80%" height="70%" position="middle center">
            <Bars />
            <Ticks
              axis="x"
              ticks={{ maxTicks: 4 }}
              lineLength="100%"
              lineStyle={{ stroke: '#ccc' }}
              labelStyle={{ textAnchor: 'middle', dominantBaseline: 'text-after-edge' }}
              labelAttributes={{ y: 4 }}
            />
            <Ticks
              axis="y"
              ticks={{ maxTicks: 5 }}
              lineLength="100%"
              lineStyle={{ stroke: '#ccc' }}
              labelStyle={{ textAnchor: 'end', dominantBaseline: 'middle' }}
              labelAttributes={{ x: -4 }}
            />
          </Layer>
        </Animate>
      </Chart>
    </div>
  );
}

export default ProductComparisonChart;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import DashboardCharts from './DashboardCharts';
import ProductComparisonChart from './ProductComparisonChart';
import './App.css';

function App() {
  return (
    <div className="App">
      <DashboardCharts />
      <ProductComparisonChart />
    </div>
  );
}

export default App;

This example demonstrates:

Multiple chart types
Dashboard layout
Animated charts
Custom axes
Responsive design

Common Issues / Troubleshooting

Chart not displaying: Make sure you're importing components correctly from 'rumble-charts'. Check that the data array is properly formatted.
Data format error: Ensure data is an array of objects with x and y properties. Both should be present in each object.
Axes not showing: Add Ticks components inside Layer. Configure them with proper axis and styling props.
Styling issues: Customize colors and styles through component props. Use lineStyle and labelStyle for Ticks styling.
Positioning issues: Use Layer component with position prop to control chart element positioning. Use percentage-based widths and heights.
Animation not working: Wrap chart elements in Animate component to enable animations. Check that data changes trigger re-renders.

Next Steps

Now that you have a basic understanding of Rumble Charts:

Explore all available chart types
Learn about advanced configurations
Customize colors and styles
Add interactive features
Create responsive layouts
Learn about other chart libraries
Check the official repository: https://github.com/rumble-charts/rumble-charts

Summary

You've successfully set up Rumble Charts in your React application and created bar charts, line charts, and dashboard visualizations. Rumble Charts provides a composable, flexible solution for creating charts with a simple declarative API.

SEO Keywords

rumble-charts
React Rumble Charts
rumble-charts tutorial
React chart library
rumble-charts installation
React data visualization
rumble-charts example
React composable charts
rumble-charts setup
React bar chart
rumble-charts customization
React chart component
rumble-charts dashboard
React chart visualization
rumble-charts getting started

Advanced Data Visualizations with Recharts

Eric Lewis — Mon, 19 Jan 2026 18:18:15 +0000

Recharts is a popular, composable charting library built on top of React and D3. It provides a declarative API for creating responsive, interactive charts with extensive customization options. This guide walks through advanced usage of Recharts, including complex chart configurations, custom components, and dashboard implementations.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React hooks (useState, useEffect)
Familiarity with JavaScript/TypeScript
Understanding of data visualization concepts

Installation

Install Recharts using your preferred package manager:

npm install recharts

Or with yarn:

yarn add recharts

Or with pnpm:

pnpm add recharts

After installation, your package.json should include:

{
  "dependencies": {
    "recharts": "^2.0.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

Recharts requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple line chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import {
  LineChart,
  Line,
  XAxis,
  YAxis,
  CartesianGrid,
  Tooltip,
  Legend,
  ResponsiveContainer
} from 'recharts';

function ChartExample() {
  const data = [
    { name: 'Jan', sales: 35 },
    { name: 'Feb', sales: 28 },
    { name: 'Mar', sales: 34 },
    { name: 'Apr', sales: 32 },
    { name: 'May', sales: 40 },
    { name: 'Jun', sales: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Recharts Example</h2>
      <ResponsiveContainer width="100%" height={400}>
        <LineChart data={data}>
          <CartesianGrid strokeDasharray="3 3" />
          <XAxis dataKey="name" />
          <YAxis />
          <Tooltip />
          <Legend />
          <Line type="monotone" dataKey="sales" stroke="#8884d8" />
        </LineChart>
      </ResponsiveContainer>
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic responsive line chart with tooltips and legend.

Understanding the Basics

Recharts provides composable chart components:

ResponsiveContainer: Makes charts responsive
LineChart, BarChart, PieChart: Chart type containers
Line, Bar, Pie: Data series components
XAxis, YAxis: Axis components
Tooltip, Legend: Interactive components
CartesianGrid: Grid lines

Key concepts for advanced usage:

Composable API: Build charts by composing components
Data format: Array of objects with consistent keys
Responsive: Use ResponsiveContainer for automatic sizing
Customization: Extensive styling and behavior options
Interactive: Built-in tooltips and legends

Here's an example with multiple chart types:

// src/AdvancedChartExample.jsx
import React from 'react';
import {
  LineChart,
  BarChart,
  PieChart,
  Line,
  Bar,
  Pie,
  XAxis,
  YAxis,
  CartesianGrid,
  Tooltip,
  Legend,
  ResponsiveContainer,
  Cell
} from 'recharts';

function AdvancedChartExample() {
  const lineData = [
    { name: 'Mon', sales: 120, target: 130 },
    { name: 'Tue', sales: 132, target: 135 },
    { name: 'Wed', sales: 101, target: 110 },
    { name: 'Thu', sales: 134, target: 140 },
    { name: 'Fri', sales: 90, target: 100 }
  ];

  const barData = [
    { name: 'Q1', revenue: 12000 },
    { name: 'Q2', revenue: 15000 },
    { name: 'Q3', revenue: 18000 },
    { name: 'Q4', revenue: 20000 }
  ];

  const pieData = [
    { name: 'Product A', value: 35 },
    { name: 'Product B', value: 28 },
    { name: 'Product C', value: 34 }
  ];

  const COLORS = ['#0088FE', '#00C49F', '#FFBB28'];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Advanced Recharts Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h3>Line Chart with Multiple Series</h3>
          <ResponsiveContainer width="100%" height={300}>
            <LineChart data={lineData}>
              <CartesianGrid strokeDasharray="3 3" />
              <XAxis dataKey="name" />
              <YAxis />
              <Tooltip />
              <Legend />
              <Line type="monotone" dataKey="sales" stroke="#8884d8" />
              <Line type="monotone" dataKey="target" stroke="#82ca9d" />
            </LineChart>
          </ResponsiveContainer>
        </div>
        <div>
          <h3>Bar Chart</h3>
          <ResponsiveContainer width="100%" height={300}>
            <BarChart data={barData}>
              <CartesianGrid strokeDasharray="3 3" />
              <XAxis dataKey="name" />
              <YAxis />
              <Tooltip />
              <Legend />
              <Bar dataKey="revenue" fill="#8884d8" />
            </BarChart>
          </ResponsiveContainer>
        </div>
        <div>
          <h3>Pie Chart</h3>
          <ResponsiveContainer width="100%" height={300}>
            <PieChart>
              <Pie
                data={pieData}
                cx="50%"
                cy="50%"
                labelLine={false}
                label={({ name, percent }) => `${name} ${(percent * 100).toFixed(0)}%`}
                outerRadius={80}
                fill="#8884d8"
                dataKey="value"
              >
                {pieData.map((entry, index) => (
                  <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
                ))}
              </Pie>
              <Tooltip />
            </PieChart>
          </ResponsiveContainer>
        </div>
      </div>
    </div>
  );
}

export default AdvancedChartExample;

Practical Example / Building Something Real

Let's build a comprehensive analytics dashboard:

// src/AnalyticsDashboard.jsx
import React, { useState } from 'react';
import {
  LineChart,
  BarChart,
  PieChart,
  Line,
  Bar,
  Pie,
  XAxis,
  YAxis,
  CartesianGrid,
  Tooltip,
  Legend,
  ResponsiveContainer,
  Cell,
  Area,
  AreaChart
} from 'recharts';

function AnalyticsDashboard() {
  const [selectedPeriod, setSelectedPeriod] = useState('monthly');

  const monthlyData = [
    { name: 'Jan', sales: 35, target: 40 },
    { name: 'Feb', sales: 28, target: 35 },
    { name: 'Mar', sales: 34, target: 38 },
    { name: 'Apr', sales: 32, target: 36 },
    { name: 'May', sales: 40, target: 42 },
    { name: 'Jun', sales: 32, target: 38 }
  ];

  const quarterlyData = [
    { name: 'Q1', sales: 97, target: 113 },
    { name: 'Q2', sales: 106, target: 116 },
    { name: 'Q3', sales: 112, target: 120 },
    { name: 'Q4', sales: 120, target: 125 }
  ];

  const revenueData = [
    { name: 'Q1', revenue: 12000 },
    { name: 'Q2', revenue: 15000 },
    { name: 'Q3', revenue: 18000 },
    { name: 'Q4', revenue: 20000 }
  ];

  const categoryData = [
    { name: 'Product A', value: 35 },
    { name: 'Product B', value: 28 },
    { name: 'Product C', value: 34 },
    { name: 'Product D', value: 32 }
  ];

  const currentData = selectedPeriod === 'monthly' ? monthlyData : quarterlyData;
  const COLORS = ['#0088FE', '#00C49F', '#FFBB28', '#FF8042'];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Analytics Dashboard</h1>
      <div style={{ marginBottom: '20px', textAlign: 'center' }}>
        <button
          onClick={() => setSelectedPeriod('monthly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'monthly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Monthly
        </button>
        <button
          onClick={() => setSelectedPeriod('quarterly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'quarterly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Quarterly
        </button>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Sales vs Target</h2>
          <ResponsiveContainer width="100%" height={400}>
            <AreaChart data={currentData}>
              <defs>
                <linearGradient id="colorSales" x1="0" y1="0" x2="0" y2="1">
                  <stop offset="5%" stopColor="#8884d8" stopOpacity={0.8} />
                  <stop offset="95%" stopColor="#8884d8" stopOpacity={0} />
                </linearGradient>
                <linearGradient id="colorTarget" x1="0" y1="0" x2="0" y2="1">
                  <stop offset="5%" stopColor="#82ca9d" stopOpacity={0.8} />
                  <stop offset="95%" stopColor="#82ca9d" stopOpacity={0} />
                </linearGradient>
              </defs>
              <CartesianGrid strokeDasharray="3 3" />
              <XAxis dataKey="name" />
              <YAxis />
              <Tooltip />
              <Legend />
              <Area
                type="monotone"
                dataKey="sales"
                stroke="#8884d8"
                fillOpacity={1}
                fill="url(#colorSales)"
              />
              <Area
                type="monotone"
                dataKey="target"
                stroke="#82ca9d"
                fillOpacity={1}
                fill="url(#colorTarget)"
              />
            </AreaChart>
          </ResponsiveContainer>
        </div>
        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
          <div>
            <h2>Quarterly Revenue</h2>
            <ResponsiveContainer width="100%" height={400}>
              <BarChart data={revenueData}>
                <CartesianGrid strokeDasharray="3 3" />
                <XAxis dataKey="name" />
                <YAxis />
                <Tooltip />
                <Legend />
                <Bar dataKey="revenue" fill="#8884d8" />
              </BarChart>
            </ResponsiveContainer>
          </div>
          <div>
            <h2>Product Distribution</h2>
            <ResponsiveContainer width="100%" height={400}>
              <PieChart>
                <Pie
                  data={categoryData}
                  cx="50%"
                  cy="50%"
                  labelLine={false}
                  label={({ name, percent }) => `${name} ${(percent * 100).toFixed(0)}%`}
                  outerRadius={100}
                  fill="#8884d8"
                  dataKey="value"
                >
                  {categoryData.map((entry, index) => (
                    <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
                  ))}
                </Pie>
                <Tooltip />
                <Legend />
              </PieChart>
            </ResponsiveContainer>
          </div>
        </div>
      </div>
    </div>
  );
}

export default AnalyticsDashboard;

Now create an interactive chart with custom tooltips:

// src/InteractiveChart.jsx
import React, { useState } from 'react';
import {
  LineChart,
  Line,
  XAxis,
  YAxis,
  CartesianGrid,
  Tooltip,
  Legend,
  ResponsiveContainer
} from 'recharts';

const CustomTooltip = ({ active, payload, label }) => {
  if (active && payload && payload.length) {
    return (
      <div style={{
        backgroundColor: '#fff',
        border: '1px solid #ccc',
        borderRadius: '4px',
        padding: '10px'
      }}>
        <p style={{ margin: 0, fontWeight: 'bold' }}>{`${label}`}</p>
        {payload.map((entry, index) => (
          <p key={index} style={{ margin: '5px 0', color: entry.color }}>
            {`${entry.name}: ${entry.value}`}
          </p>
        ))}
      </div>
    );
  }
  return null;
};

function InteractiveChart() {
  const [activeIndex, setActiveIndex] = useState(null);

  const data = [
    { name: 'Jan', sales: 35, target: 40 },
    { name: 'Feb', sales: 28, target: 35 },
    { name: 'Mar', sales: 34, target: 38 },
    { name: 'Apr', sales: 32, target: 36 },
    { name: 'May', sales: 40, target: 42 },
    { name: 'Jun', sales: 32, target: 38 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Interactive Chart with Custom Tooltip</h2>
      <ResponsiveContainer width="100%" height={500}>
        <LineChart
          data={data}
          onMouseMove={(state) => {
            if (state && state.activeTooltipIndex !== undefined) {
              setActiveIndex(state.activeTooltipIndex);
            }
          }}
          onMouseLeave={() => setActiveIndex(null)}
        >
          <CartesianGrid strokeDasharray="3 3" />
          <XAxis dataKey="name" />
          <YAxis />
          <Tooltip content={<CustomTooltip />} />
          <Legend />
          <Line
            type="monotone"
            dataKey="sales"
            stroke="#8884d8"
            strokeWidth={2}
            activeDot={{ r: 8 }}
          />
          <Line
            type="monotone"
            dataKey="target"
            stroke="#82ca9d"
            strokeWidth={2}
            activeDot={{ r: 8 }}
          />
        </LineChart>
      </ResponsiveContainer>
      {activeIndex !== null && (
        <div style={{
          marginTop: '20px',
          padding: '10px',
          backgroundColor: '#f8f9fa',
          borderRadius: '4px'
        }}>
          Selected: {data[activeIndex].name} - Sales: {data[activeIndex].sales}, Target: {data[activeIndex].target}
        </div>
      )}
    </div>
  );
}

export default InteractiveChart;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import AnalyticsDashboard from './AnalyticsDashboard';
import InteractiveChart from './InteractiveChart';
import './App.css';

function App() {
  return (
    <div className="App">
      <AnalyticsDashboard />
      <InteractiveChart />
    </div>
  );
}

export default App;

This example demonstrates:

Analytics dashboard
Multiple chart types
Interactive features
Custom tooltips
Dynamic data updates
Gradient fills
Custom styling

Common Issues / Troubleshooting

Chart not displaying: Make sure you're importing components correctly from 'recharts'. Check that the data array is properly formatted.
Data format error: Ensure data is an array of objects with consistent keys. All objects should have the same property names.
Responsive not working: Use ResponsiveContainer to wrap your charts. Set width and height props on ResponsiveContainer.
Styling issues: Customize colors through component props. Use stroke for line colors and fill for bar/area colors.
Tooltip not showing: Add Tooltip component inside your chart. Customize it with a custom content component if needed.
Performance: For large datasets, consider data sampling or pagination. Recharts handles large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have an advanced understanding of Recharts:

Explore all available chart types
Learn about advanced configurations
Implement custom components
Add animations
Create real-time updating charts
Learn about other chart libraries
Check the official repository: https://github.com/recharts/recharts

Summary

You've successfully integrated Recharts into your React application with advanced features including analytics dashboards, interactive charts, custom tooltips, and gradient visualizations. Recharts provides a powerful, composable solution for creating professional data visualizations with extensive customization options.

SEO Keywords

recharts
React Recharts
recharts tutorial
React data visualization
recharts installation
React chart library
recharts example
React composable charts
recharts setup
React interactive charts
recharts customization
React chart component
recharts dashboard
React D3 charts
recharts getting started

Building Interactive Data Visualizations with React Vis

Eric Lewis — Mon, 19 Jan 2026 18:17:23 +0000

React Vis is a comprehensive visualization library for React developed by Uber. It provides a wide range of chart types and visualization components with built-in interactivity, animations, and responsive design. This guide walks through setting up and creating visualizations using React Vis with React, from installation to a working implementation.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React hooks (useState)
Familiarity with JavaScript/TypeScript
Understanding of data visualization concepts

Installation

Install React Vis and required CSS:

npm install react-vis

Or with yarn:

yarn add react-vis

Or with pnpm:

pnpm add react-vis

After installation, your package.json should include:

{
  "dependencies": {
    "react-vis": "^1.11.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

Import React Vis CSS in your main entry file:

// src/index.js
import React from 'react';
import ReactDOM from 'react-dom/client';
import 'react-vis/dist/style.css';
import App from './App';

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <React.StrictMode>
    <App />
  </React.StrictMode>
);

First Example / Basic Usage

Let's create a simple line chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import {
  XYPlot,
  XAxis,
  YAxis,
  HorizontalGridLines,
  VerticalGridLines,
  LineSeries
} from 'react-vis';

function ChartExample() {
  const data = [
    { x: 0, y: 35 },
    { x: 1, y: 28 },
    { x: 2, y: 34 },
    { x: 3, y: 32 },
    { x: 4, y: 40 },
    { x: 5, y: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic React Vis Example</h2>
      <XYPlot width={600} height={400}>
        <HorizontalGridLines />
        <VerticalGridLines />
        <XAxis />
        <YAxis />
        <LineSeries data={data} />
      </XYPlot>
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic line chart with grid lines and axes.

Understanding the Basics

React Vis provides several chart components:

XYPlot: Main chart container
LineSeries: Line chart series
AreaSeries: Area chart series
BarSeries: Bar chart series
MarkSeries: Scatter plot series
XAxis, YAxis: Axis components
GridLines: Grid line components

Key concepts:

Data format: Array of objects with x and y properties
XYPlot: Container that defines chart dimensions
Series components: Define chart type and data
Axis components: Configure axes
Styling: Customize colors and styles through props

Here's an example with multiple chart types:

// src/MultipleChartsExample.jsx
import React from 'react';
import {
  XYPlot,
  XAxis,
  YAxis,
  HorizontalGridLines,
  LineSeries,
  AreaSeries,
  BarSeries
} from 'react-vis';

function MultipleChartsExample() {
  const lineData = [
    { x: 0, y: 120 },
    { x: 1, y: 132 },
    { x: 2, y: 101 },
    { x: 3, y: 134 },
    { x: 4, y: 90 }
  ];

  const areaData = [
    { x: 0, y: 100 },
    { x: 1, y: 110 },
    { x: 2, y: 105 },
    { x: 3, y: 115 },
    { x: 4, y: 120 }
  ];

  const barData = [
    { x: 0, y: 120 },
    { x: 1, y: 200 },
    { x: 2, y: 150 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Multiple Charts Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h3>Line Chart</h3>
          <XYPlot width={600} height={300}>
            <HorizontalGridLines />
            <XAxis />
            <YAxis />
            <LineSeries data={lineData} />
          </XYPlot>
        </div>
        <div>
          <h3>Area Chart</h3>
          <XYPlot width={600} height={300}>
            <HorizontalGridLines />
            <XAxis />
            <YAxis />
            <AreaSeries data={areaData} />
          </XYPlot>
        </div>
        <div>
          <h3>Bar Chart</h3>
          <XYPlot width={600} height={300} xType="ordinal">
            <XAxis />
            <YAxis />
            <BarSeries data={barData} />
          </XYPlot>
        </div>
      </div>
    </div>
  );
}

export default MultipleChartsExample;

Practical Example / Building Something Real

Let's build a comprehensive dashboard with multiple visualizations:

// src/DashboardCharts.jsx
import React, { useState } from 'react';
import {
  XYPlot,
  XAxis,
  YAxis,
  HorizontalGridLines,
  VerticalGridLines,
  LineSeries,
  AreaSeries,
  MarkSeries,
  Crosshair
} from 'react-vis';

function DashboardCharts() {
  const [crosshairValues, setCrosshairValues] = useState([]);

  const salesData = [
    { x: 0, y: 35 },
    { x: 1, y: 28 },
    { x: 2, y: 34 },
    { x: 3, y: 32 },
    { x: 4, y: 40 },
    { x: 5, y: 32 }
  ];

  const targetData = [
    { x: 0, y: 40 },
    { x: 1, y: 35 },
    { x: 2, y: 38 },
    { x: 3, y: 36 },
    { x: 4, y: 42 },
    { x: 5, y: 38 }
  ];

  const revenueData = [
    { x: 0, y: 12000 },
    { x: 1, y: 15000 },
    { x: 2, y: 18000 },
    { x: 3, y: 20000 }
  ];

  const scatterData = [
    { x: 10, y: 20 },
    { x: 20, y: 30 },
    { x: 30, y: 25 },
    { x: 40, y: 35 },
    { x: 50, y: 40 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Analytics Dashboard</h1>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Sales vs Target</h2>
          <XYPlot
            width={800}
            height={400}
            onMouseLeave={() => setCrosshairValues([])}
          >
            <HorizontalGridLines />
            <VerticalGridLines />
            <XAxis />
            <YAxis />
            <LineSeries
              data={salesData}
              style={{ stroke: '#1f77b4', strokeWidth: 2 }}
              onNearestX={(value) => setCrosshairValues([value])}
            />
            <LineSeries
              data={targetData}
              style={{ stroke: '#ff7f0e', strokeWidth: 2 }}
            />
            <Crosshair values={crosshairValues} />
          </XYPlot>
        </div>
        <div>
          <h2>Quarterly Revenue</h2>
          <XYPlot width={800} height={400}>
            <HorizontalGridLines />
            <XAxis />
            <YAxis />
            <AreaSeries
              data={revenueData}
              style={{ fill: '#2ca02c', fillOpacity: 0.6 }}
            />
          </XYPlot>
        </div>
        <div>
          <h2>Scatter Plot</h2>
          <XYPlot width={800} height={400}>
            <HorizontalGridLines />
            <VerticalGridLines />
            <XAxis />
            <YAxis />
            <MarkSeries data={scatterData} />
          </XYPlot>
        </div>
      </div>
    </div>
  );
}

export default DashboardCharts;

Now create an interactive chart with tooltips:

// src/InteractiveChart.jsx
import React, { useState } from 'react';
import {
  XYPlot,
  XAxis,
  YAxis,
  HorizontalGridLines,
  LineSeries,
  MarkSeries,
  Crosshair
} from 'react-vis';

function InteractiveChart() {
  const [crosshairValues, setCrosshairValues] = useState([]);

  const data = [
    { x: 0, y: 35 },
    { x: 1, y: 28 },
    { x: 2, y: 34 },
    { x: 3, y: 32 },
    { x: 4, y: 40 },
    { x: 5, y: 32 }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Interactive Chart</h2>
      <XYPlot
        width={700}
        height={500}
        onMouseLeave={() => setCrosshairValues([])}
      >
        <HorizontalGridLines />
        <XAxis />
        <YAxis />
        <LineSeries
          data={data}
          style={{ stroke: '#1f77b4', strokeWidth: 2 }}
          onNearestX={(value) => setCrosshairValues([value])}
        />
        <MarkSeries
          data={data}
          style={{ stroke: '#1f77b4', fill: '#1f77b4' }}
        />
        <Crosshair values={crosshairValues} />
      </XYPlot>
    </div>
  );
}

export default InteractiveChart;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import DashboardCharts from './DashboardCharts';
import InteractiveChart from './InteractiveChart';
import './App.css';

function App() {
  return (
    <div className="App">
      <DashboardCharts />
      <InteractiveChart />
    </div>
  );
}

export default App;

This example demonstrates:

Multiple chart types
Dashboard layout
Interactive features
Crosshair tooltips
Custom styling
Responsive design

Common Issues / Troubleshooting

Chart not displaying: Make sure you've imported the CSS file. React Vis requires CSS for proper styling.
Data format error: Ensure data is an array of objects with x and y properties. Both should be numeric values.
Styling issues: Customize colors through the style prop. Use stroke for line color and fill for area/bar colors.
Axis not showing: Add XAxis and YAxis components inside XYPlot. Configure them with labels and formatting.
Interactive not working: Use onNearestX or onNearestY callbacks to handle mouse interactions. Update state to show tooltips.
Performance: For large datasets, consider data sampling or using MarkSeries with optimized rendering. React Vis handles large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have an understanding of React Vis:

Explore all available chart types
Learn about advanced configurations
Implement custom tooltips
Add animations
Create complex visualizations
Learn about other visualization libraries
Check the official repository: https://github.com/uber/react-vis

Summary

You've successfully set up React Vis in your React application and created line charts, area charts, bar charts, and interactive visualizations. React Vis provides a comprehensive solution for creating data visualizations with extensive customization options and built-in interactivity.

SEO Keywords

react-vis
React Vis
react-vis tutorial
React data visualization
react-vis installation
React chart library
react-vis example
React Uber visualization
react-vis setup
React interactive charts
react-vis customization
React chart component
react-vis dashboard
React visualization library
react-vis getting started

Getting Started with React Timeseries Charts: Visualizing Time-Based Data in React

Eric Lewis — Mon, 19 Jan 2026 18:15:50 +0000

React Timeseries Charts is a React library for creating time-series visualizations. It provides components for displaying time-based data with features like zooming, brushing, and interactive tooltips. This guide walks through setting up and creating time-series charts using React Timeseries Charts with React, from installation to a working implementation.

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React components
Familiarity with JavaScript/TypeScript
Understanding of time-series data

Installation

Install React Timeseries Charts and required dependencies:

npm install react-timeseries-charts pondjs

Or with yarn:

yarn add react-timeseries-charts pondjs

Or with pnpm:

pnpm add react-timeseries-charts pondjs

After installation, your package.json should include:

{
  "dependencies": {
    "react-timeseries-charts": "^0.16.0",
    "pondjs": "^0.9.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

React Timeseries Charts requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple time-series chart. Create a new file src/ChartExample.jsx:

// src/ChartExample.jsx
import React from 'react';
import { TimeSeries, ChartContainer, ChartRow, Charts, YAxis, LineChart, Resizable } from 'react-timeseries-charts';
import { TimeRange, Index } from 'pondjs';

function ChartExample() {
  const points = [
    [new Date('2024-01-01'), 35],
    [new Date('2024-01-02'), 28],
    [new Date('2024-01-03'), 34],
    [new Date('2024-01-04'), 32],
    [new Date('2024-01-05'), 40],
    [new Date('2024-01-06'), 32]
  ];

  const series = new TimeSeries({
    name: 'sales',
    columns: ['time', 'value'],
    points: points.map(([time, value]) => [time.getTime(), value])
  });

  const timeRange = series.range();

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Time-Series Chart Example</h2>
      <Resizable>
        <ChartContainer timeRange={timeRange} width={800}>
          <ChartRow height="200">
            <YAxis
              id="sales"
              label="Sales"
              min={0}
              max={50}
              width="60"
            />
            <Charts>
              <LineChart
                axis="sales"
                series={series}
                columns={['value']}
              />
            </Charts>
          </ChartRow>
        </ChartContainer>
      </Resizable>
    </div>
  );
}

export default ChartExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import ChartExample from './ChartExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <ChartExample />
    </div>
  );
}

export default App;

This creates a basic time-series line chart displaying sales data over time.

Understanding the Basics

React Timeseries Charts provides several components:

ChartContainer: Main chart container with time range
ChartRow: Row container for charts
Charts: Container for chart components
LineChart: Line chart component
YAxis: Y-axis component
TimeSeries: Data structure for time-series data
Resizable: Makes chart resizable

Key concepts:

TimeSeries: Create time-series data using pondjs TimeSeries
Time range: Define the time range for the chart
Columns: Specify data columns
Points: Array of [timestamp, value] pairs
Axis configuration: Configure Y-axis with min, max, label

Here's an example with multiple series:

// src/MultipleSeriesExample.jsx
import React from 'react';
import { TimeSeries, ChartContainer, ChartRow, Charts, YAxis, LineChart, Resizable } from 'react-timeseries-charts';
import { TimeRange } from 'pondjs';

function MultipleSeriesExample() {
  const salesPoints = [
    [new Date('2024-01-01'), 35],
    [new Date('2024-01-02'), 28],
    [new Date('2024-01-03'), 34],
    [new Date('2024-01-04'), 32],
    [new Date('2024-01-05'), 40]
  ];

  const targetPoints = [
    [new Date('2024-01-01'), 40],
    [new Date('2024-01-02'), 35],
    [new Date('2024-01-03'), 38],
    [new Date('2024-01-04'), 36],
    [new Date('2024-01-05'), 42]
  ];

  const salesSeries = new TimeSeries({
    name: 'sales',
    columns: ['time', 'value'],
    points: salesPoints.map(([time, value]) => [time.getTime(), value])
  });

  const targetSeries = new TimeSeries({
    name: 'target',
    columns: ['time', 'value'],
    points: targetPoints.map(([time, value]) => [time.getTime(), value])
  });

  const timeRange = salesSeries.range();

  return (
    <div style={{ padding: '20px', maxWidth: '900px', margin: '0 auto' }}>
      <h2>Multiple Series Example</h2>
      <Resizable>
        <ChartContainer timeRange={timeRange} width={800}>
          <ChartRow height="200">
            <YAxis
              id="sales"
              label="Sales"
              min={0}
              max={50}
              width="60"
            />
            <Charts>
              <LineChart
                axis="sales"
                series={salesSeries}
                columns={['value']}
                style={{ value: { stroke: '#1f77b4' } }}
              />
              <LineChart
                axis="sales"
                series={targetSeries}
                columns={['value']}
                style={{ value: { stroke: '#ff7f0e' } }}
              />
            </Charts>
          </ChartRow>
        </ChartContainer>
      </Resizable>
    </div>
  );
}

export default MultipleSeriesExample;

Practical Example / Building Something Real

Let's build a comprehensive dashboard with time-series charts:

// src/DashboardCharts.jsx
import React, { useState } from 'react';
import { TimeSeries, ChartContainer, ChartRow, Charts, YAxis, LineChart, Resizable } from 'react-timeseries-charts';
import { TimeRange } from 'pondjs';

function DashboardCharts() {
  const [selectedPeriod, setSelectedPeriod] = useState('daily');

  const dailyPoints = [
    [new Date('2024-01-01'), 35],
    [new Date('2024-01-02'), 28],
    [new Date('2024-01-03'), 34],
    [new Date('2024-01-04'), 32],
    [new Date('2024-01-05'), 40],
    [new Date('2024-01-06'), 32],
    [new Date('2024-01-07'), 38]
  ];

  const weeklyPoints = [
    [new Date('2024-01-01'), 210],
    [new Date('2024-01-08'), 240],
    [new Date('2024-01-15'), 230],
    [new Date('2024-01-22'), 250]
  ];

  const salesPoints = selectedPeriod === 'daily' ? dailyPoints : weeklyPoints;

  const salesSeries = new TimeSeries({
    name: 'sales',
    columns: ['time', 'value'],
    points: salesPoints.map(([time, value]) => [time.getTime(), value])
  });

  const revenuePoints = [
    [new Date('2024-01-01'), 12000],
    [new Date('2024-01-02'), 9800],
    [new Date('2024-01-03'), 13400],
    [new Date('2024-01-04'), 12800],
    [new Date('2024-01-05'), 16000],
    [new Date('2024-01-06'), 12800]
  ];

  const revenueSeries = new TimeSeries({
    name: 'revenue',
    columns: ['time', 'value'],
    points: revenuePoints.map(([time, value]) => [time.getTime(), value])
  });

  const timeRange = salesSeries.range();

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Time-Series Dashboard</h1>
      <div style={{ marginBottom: '20px', textAlign: 'center' }}>
        <button
          onClick={() => setSelectedPeriod('daily')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'daily' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Daily
        </button>
        <button
          onClick={() => setSelectedPeriod('weekly')}
          style={{
            padding: '8px 16px',
            margin: '0 5px',
            backgroundColor: selectedPeriod === 'weekly' ? '#007bff' : '#6c757d',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Weekly
        </button>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '40px' }}>
        <div>
          <h2>Sales Over Time</h2>
          <Resizable>
            <ChartContainer timeRange={timeRange} width={1000}>
              <ChartRow height="200">
                <YAxis
                  id="sales"
                  label="Sales"
                  min={0}
                  max={50}
                  width="60"
                />
                <Charts>
                  <LineChart
                    axis="sales"
                    series={salesSeries}
                    columns={['value']}
                    style={{ value: { stroke: '#1f77b4', strokeWidth: 2 } }}
                  />
                </Charts>
              </ChartRow>
            </ChartContainer>
          </Resizable>
        </div>
        <div>
          <h2>Revenue Over Time</h2>
          <Resizable>
            <ChartContainer timeRange={revenueSeries.range()} width={1000}>
              <ChartRow height="200">
                <YAxis
                  id="revenue"
                  label="Revenue ($)"
                  min={0}
                  max={20000}
                  width="60"
                />
                <Charts>
                  <LineChart
                    axis="revenue"
                    series={revenueSeries}
                    columns={['value']}
                    style={{ value: { stroke: '#ff7f0e', strokeWidth: 2 } }}
                  />
                </Charts>
              </ChartRow>
            </ChartContainer>
          </Resizable>
        </div>
      </div>
    </div>
  );
}

export default DashboardCharts;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import DashboardCharts from './DashboardCharts';
import './App.css';

function App() {
  return (
    <div className="App">
      <DashboardCharts />
    </div>
  );
}

export default App;

This example demonstrates:

Time-series visualization
Multiple series
Dynamic time ranges
Interactive controls
Custom styling
Responsive design

Common Issues / Troubleshooting

Chart not displaying: Make sure you've installed both react-timeseries-charts and pondjs. The charts require pondjs for data structures.
Data format error: Ensure data is properly formatted as TimeSeries. Use new TimeSeries() with columns and points arrays.
Time range not working: Set the timeRange prop on ChartContainer. Use series.range() to get the time range from your data.
Styling issues: Customize colors and styles through the style prop. Use stroke and strokeWidth for line styling.
Axis not showing: Configure YAxis with proper id, label, min, and max values. The axis id must match the chart axis prop.
Performance: For large datasets, consider data aggregation or sampling. Time-series charts handle large datasets well, but optimization may be needed for very large datasets.

Next Steps

Now that you have a basic understanding of React Timeseries Charts:

Explore all available chart types
Learn about advanced time-series operations
Implement zooming and brushing
Add interactive tooltips
Create real-time updating charts
Learn about other time-series libraries
Check the official repository: https://github.com/esnet/react-timeseries-charts

Summary

You've successfully set up React Timeseries Charts in your React application and created time-series visualizations, dashboards, and interactive charts. React Timeseries Charts provides a powerful solution for visualizing time-based data with extensive customization options.

SEO Keywords

react-timeseries-charts
React time series
react-timeseries-charts tutorial
React time-based charts
react-timeseries-charts installation
React time series visualization
react-timeseries-charts example
React temporal charts
react-timeseries-charts setup
React time data charts
react-timeseries-charts customization
React chart component
react-timeseries-charts dashboard
React time series library
react-timeseries-charts getting started

Advanced Mini Chart Visualizations with React Sparklines

Eric Lewis — Mon, 19 Jan 2026 18:14:26 +0000

React Sparklines is a React component library for creating small, inline sparkline charts. Sparklines are word-sized graphics that can be embedded in text, tables, or dashboards to show data trends at a glance. This guide walks through advanced usage of React Sparklines, including custom styling, interactive features, and dashboard implementations.

Live demos and docs: borisyankov.github.io/react-sparklines/

Prerequisites

Before you begin, make sure you have:

Node.js version 14.0 or higher installed
npm, yarn, or pnpm package manager
A React project (version 16.8 or higher) or create-react-app setup
Basic knowledge of React hooks (useState, useEffect)
Familiarity with JavaScript/TypeScript
Understanding of data visualization concepts

Installation

Install React Sparklines using your preferred package manager:

npm install react-sparklines

Or with yarn:

yarn add react-sparklines

Or with pnpm:

pnpm add react-sparklines

After installation, your package.json should include:

{
  "dependencies": {
    "react-sparklines": "^1.7.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  }
}

Project Setup

React Sparklines requires minimal setup. Import the components and you're ready to use them.

First Example / Basic Usage

Let's create a simple sparkline. Create a new file src/SparklineExample.jsx:

// src/SparklineExample.jsx
import React from 'react';
import { Sparklines, SparklinesLine } from 'react-sparklines';

function SparklineExample() {
  const data = [35, 28, 34, 32, 40, 32, 38, 35, 42, 38, 40, 45];

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h2>Basic Sparkline Example</h2>
      <Sparklines data={data} width={200} height={50}>
        <SparklinesLine color="#1f77b4" />
      </Sparklines>
    </div>
  );
}

export default SparklineExample;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import SparklineExample from './SparklineExample';
import './App.css';

function App() {
  return (
    <div className="App">
      <SparklineExample />
    </div>
  );
}

export default App;

This creates a basic sparkline chart displaying data trends.

Understanding the Basics

React Sparklines provides several components:

Sparklines: Main container component
SparklinesLine: Line chart sparkline
SparklinesBars: Bar chart sparkline
SparklinesSpots: Highlight specific points
SparklinesReferenceLine: Add reference lines
SparklinesNormalBand: Show normal range

Key concepts for advanced usage:

Data array: Array of numeric values
Width and height: Chart dimensions
Color customization: Customize line and fill colors
Interactive features: Tooltips and hover effects
Multiple series: Combine multiple sparklines

Here's an example with multiple sparkline types:

// src/AdvancedSparklineExample.jsx
import React from 'react';
import {
  Sparklines,
  SparklinesLine,
  SparklinesBars,
  SparklinesSpots,
  SparklinesReferenceLine
} from 'react-sparklines';

function AdvancedSparklineExample() {
  const data1 = [35, 28, 34, 32, 40, 32, 38, 35, 42, 38];
  const data2 = [120, 132, 101, 134, 90, 110, 125, 115, 130, 120];
  const data3 = [20, 25, 18, 22, 28, 24, 26, 23, 27, 25];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h2>Advanced Sparkline Example</h2>
      <div style={{ display: 'flex', flexDirection: 'column', gap: '30px' }}>
        <div>
          <h3>Line Sparkline with Spots</h3>
          <Sparklines data={data1} width={300} height={60}>
            <SparklinesLine color="#1f77b4" />
            <SparklinesSpots />
          </Sparklines>
        </div>
        <div>
          <h3>Bar Sparkline</h3>
          <Sparklines data={data2} width={300} height={60}>
            <SparklinesBars color="#ff7f0e" />
          </Sparklines>
        </div>
        <div>
          <h3>Line with Reference Line</h3>
          <Sparklines data={data3} width={300} height={60}>
            <SparklinesLine color="#2ca02c" />
            <SparklinesReferenceLine type="mean" />
          </Sparklines>
        </div>
      </div>
    </div>
  );
}

export default AdvancedSparklineExample;

Practical Example / Building Something Real

Let's build a comprehensive dashboard with sparklines:

// src/DashboardSparklines.jsx
import React, { useState, useEffect } from 'react';
import {
  Sparklines,
  SparklinesLine,
  SparklinesSpots,
  SparklinesReferenceLine
} from 'react-sparklines';

function DashboardSparklines() {
  const [salesData, setSalesData] = useState([35, 28, 34, 32, 40, 32]);
  const [revenueData, setRevenueData] = useState([12000, 15000, 18000, 20000, 22000, 25000]);
  const [usersData, setUsersData] = useState([1200, 1350, 1500, 1650, 1800, 1950]);

  useEffect(() => {
    const interval = setInterval(() => {
      setSalesData(prev => [...prev.slice(1), Math.floor(Math.random() * 50) + 20]);
      setRevenueData(prev => [...prev.slice(1), Math.floor(Math.random() * 10000) + 15000]);
      setUsersData(prev => [...prev.slice(1), Math.floor(Math.random() * 1000) + 1000]);
    }, 2000);

    return () => clearInterval(interval);
  }, []);

  const metrics = [
    {
      title: 'Sales',
      value: salesData[salesData.length - 1],
      data: salesData,
      color: '#1f77b4',
      unit: 'units'
    },
    {
      title: 'Revenue',
      value: revenueData[revenueData.length - 1],
      data: revenueData,
      color: '#ff7f0e',
      unit: '$'
    },
    {
      title: 'Users',
      value: usersData[usersData.length - 1],
      data: usersData,
      color: '#2ca02c',
      unit: ''
    }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1200px', margin: '0 auto' }}>
      <h1>Real-time Metrics Dashboard</h1>
      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '20px' }}>
        {metrics.map((metric, index) => (
          <div
            key={index}
            style={{
              padding: '20px',
              backgroundColor: '#f8f9fa',
              border: '1px solid #ddd',
              borderRadius: '8px'
            }}
          >
            <h3 style={{ margin: '0 0 10px 0' }}>{metric.title}</h3>
            <div style={{ fontSize: '32px', fontWeight: 'bold', marginBottom: '10px' }}>
              {metric.unit}{metric.value.toLocaleString()}
            </div>
            <Sparklines data={metric.data} width={200} height={60}>
              <SparklinesLine color={metric.color} />
              <SparklinesSpots />
              <SparklinesReferenceLine type="mean" />
            </Sparklines>
          </div>
        ))}
      </div>
    </div>
  );
}

export default DashboardSparklines;

Now create a table with inline sparklines:

// src/TableWithSparklines.jsx
import React from 'react';
import {
  Sparklines,
  SparklinesLine,
  SparklinesSpots
} from 'react-sparklines';

function TableWithSparklines() {
  const products = [
    {
      name: 'Product A',
      sales: 1200,
      trend: [100, 110, 105, 115, 120, 125, 130, 128, 132, 130]
    },
    {
      name: 'Product B',
      sales: 980,
      trend: [90, 95, 100, 98, 102, 105, 108, 110, 112, 110]
    },
    {
      name: 'Product C',
      sales: 1500,
      trend: [140, 145, 150, 148, 152, 155, 158, 160, 162, 160]
    },
    {
      name: 'Product D',
      sales: 850,
      trend: [80, 85, 90, 88, 92, 95, 98, 100, 102, 100]
    }
  ];

  return (
    <div style={{ padding: '20px', maxWidth: '1000px', margin: '0 auto' }}>
      <h2>Product Sales with Trends</h2>
      <table style={{ width: '100%', borderCollapse: 'collapse' }}>
        <thead>
          <tr style={{ borderBottom: '2px solid #ddd' }}>
            <th style={{ padding: '12px', textAlign: 'left' }}>Product</th>
            <th style={{ padding: '12px', textAlign: 'right' }}>Sales</th>
            <th style={{ padding: '12px', textAlign: 'center' }}>Trend</th>
          </tr>
        </thead>
        <tbody>
          {products.map((product, index) => (
            <tr key={index} style={{ borderBottom: '1px solid #ddd' }}>
              <td style={{ padding: '12px' }}>{product.name}</td>
              <td style={{ padding: '12px', textAlign: 'right' }}>
                ${product.sales.toLocaleString()}
              </td>
              <td style={{ padding: '12px', textAlign: 'center' }}>
                <Sparklines data={product.trend} width={150} height={40}>
                  <SparklinesLine color="#1f77b4" />
                  <SparklinesSpots />
                </Sparklines>
              </td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

export default TableWithSparklines;

Update your App.jsx:

// src/App.jsx
import React from 'react';
import DashboardSparklines from './DashboardSparklines';
import TableWithSparklines from './TableWithSparklines';
import './App.css';

function App() {
  return (
    <div className="App">
      <DashboardSparklines />
      <TableWithSparklines />
    </div>
  );
}

export default App;

This example demonstrates:

Real-time updating sparklines
Dashboard metrics
Table integration
Multiple sparkline types
Custom styling
Interactive features

Common Issues / Troubleshooting

Sparkline not displaying: Make sure you're importing components correctly from 'react-sparklines'. Check that the data array contains numeric values.
Data format error: Ensure data is an array of numbers. Non-numeric values will cause rendering issues.
Styling issues: Customize colors through component props. Use color prop for line and bar colors.
Size not working: Set width and height props on the Sparklines component. These control the chart dimensions.
Spots not showing: Use SparklinesSpots component inside Sparklines. Spots highlight min/max values by default.
Performance: For frequently updating sparklines, consider data windowing (keeping only recent N values) to maintain performance.

Next Steps

Now that you have an advanced understanding of React Sparklines:

Explore all available components
Learn about advanced styling options
Implement custom tooltips
Create animated sparklines
Integrate with data APIs
Learn about other mini chart libraries
Check the official repository: https://github.com/borisyankov/react-sparklines

Summary

You've successfully integrated React Sparklines into your React application with advanced features including real-time dashboards, table integrations, and interactive mini charts. React Sparklines provides a lightweight solution for creating word-sized graphics that show data trends at a glance.

SEO Keywords

react-sparklines
React Sparklines
react-sparklines tutorial
React mini charts
react-sparklines installation
React inline charts
react-sparklines example
React sparkline component
react-sparklines setup
React data trends
react-sparklines customization
React dashboard sparklines
react-sparklines table
React mini visualization
react-sparklines getting started