DEV Community: Andrew Bt

Best Tools for Creating Trading Platform Charts

Andrew Bt — Wed, 28 Oct 2026 15:21:21 +0000

Building software for modern financial markets requires selecting the best tools for creating trading platform charts to ensure optimal user experiences. Developers must handle massive data pipelines without freezing UI threads. Selecting the wrong toolkit early on leads to complete structural rewrites down the line.

What Are the Challenges When Developing Finance & Trading Applications?

Financial application development presents its fair share of technical hurdles as you’re dealing with data streams updating multiple times per second.

Unreliable Rendering Speeds

The primary bottleneck, and perhaps something you’re looking to overcome, is rendering performance. When a market moves fast, your charting interface cannot lag for your end users, even if they’re using a lower-grade device. Millisecond delays can cost traders real money. Mainstream, open-source libraries can stumble when rendering millions of historical bars alongside real-time ticks.

Lack of Customization

A lack of customization presents another hurdle. Out-of-the-box templates lead to brand sameness. If your application looks identical to every competitor, you lose market edge. Dev teams often waste months fighting rigid rendering frameworks just to add custom technical indicators. Surely there’s a better way to achieve this outcome, and truly white-label your application (without costing astronomical prices)?

Poor UX on Mobile

Mobile deployment adds further complexity. Hardware constraints on smartphones make smooth rendering difficult. Delivering a fluid experience across desktop and mobile devices requires specialized engineering. Bithumb, one of South Korea’s largest crypto platforms, used SciChart to deliver a smoother experience on mobile and to fully white-label their design. Moving averages, Bollinger Bands, and volume indicators all updated in real time and with a smooth appearance on the screen.

Insufficient Technical Support

Poor technical support from open-source maintainers also slows down launch timelines. When complex charting bugs surface, waiting weeks for a community fix is frustrating.

Pricing that Scales out of Budget

Deceptive pricing at scale can also leave project budgets at risk of going over. Free tiers often become expensive when your user base grows or when you require advanced commercial features.

Best JavaScript Charting Libraries for Financial Data & Trading Platforms

Choosing the best JavaScript charting libraries for financial data and trading platforms depends heavily on your tech stack and performance needs. Let us look at how the popular options stack up for financial applications.

TradingView

TradingView is popular for consumer-facing market portals. They offer pre-built financial features that users instantly recognize.

The charting library is ideal if you need a standard look and feel out of the box. It includes standard technical indicators and drawing tools.

The problem is that deep custom modifications can prove difficult. You are largely locked into their ecosystem and visual style. For proprietary trading dashboards requiring completely unique interfaces, the rigid structure is limiting.

Highcharts

Highcharts offers a dedicated financial package called Highcharts Stock.

The library works for standard financial dashboards and reporting tools. It provides decent documentation and broad browser compatibility.

However, performance suffers when you push it to the limit. It relies heavily on SVG rendering, which slows down significantly when rendering hundreds of thousands of data points simultaneously.

Apache Echarts

Apache Echarts is a free, open-source visualization tool maintained by the Apache Software Foundation. It handles basic rendering tasks via Canvas or SVG.

The tool works perfectly fine for simple crypto tickers or basic portfolio overviews and costs nothing to implement initially.

The downside is the lack of specialized financial tooling. You must build complex trading features, like order book depth charts or custom indicators, completely from scratch.

D3

D3 gives you full control over the Document Object Model.

You can build absolutely anything with D3 if you have enough time, making it a flexible choice.

The cost is development velocity. D3 provides no pre-built financial charting components. You must write every line of math for candlestick rendering and zoom behaviors by hand. This slows down your product launch significantly.

SciChart

When you require extreme performance and native speed, SciChart serves as a specialized finance and trading chart library. It handles hundreds of millions of data points in real time.

The architecture uses hardware acceleration to handle intense data loads. This makes it an ideal option for heavy corporate applications, algorithmic trading desks, and complex crypto exchanges.

It fully supports modern web frameworks, allowing you to build reactive React charts or fast JavaScript charts. The library ensures your complex web dashboards remain responsive under heavy market volatility.

SciChart also offers native SDKs for iOS, Android, WPF, and other desktop platforms. This means trading firms can deliver the same low-latency charting experience across mobile apps and native desktop terminals.

The library also closes the support gap raised earlier. Every commercial license includes 5-star technical support, with SciChart aiming to respond to tickets within one business day - a sharp contrast to the multi-week waits common with community-maintained open-source libraries.

How to Evaluate Tools Based on Your Project Scope?

You must balance your performance requirements against your available development timeline. Do not choose a tool simply because it’s popular on forums.

Look closely at your platform requirements. If your product needs to run everywhere, verify the library supports native Android charts and native iOS and macOS charts efficiently. Cross-platform consistency reduces your overall engineering overhead (something that SciChart supports as standard).

Test the rendering engine with realistic simulated data loads before committing. Run stress tests with millions of data points to find where the frame rate drops. With SciChart, you can easily run your own benchmark tests in GitHub.

What Are the Best Tools & Features for Building Trading Apps with SciChart?

This hardware-accelerated engine provides specific sub-features designed specifically for professional financial software engineers.

Drawing Tools

Traders rely heavily on visual analysis to execute orders. The platform includes native drawing tools right out of the box.

Users can instantly apply trendlines, Fibonacci retracements, and custom annotations. This means you don’t need to code these interactive vector overlays from scratch.

SciTrader

For teams wanting to accelerate their launch, the SciTrader app and SDK provide a pre-built reference architecture.

This package gives you a functional trading interface layout immediately. You can modify the underlying code to match your specific data feeds and business logic. This cuts out months of foundational design work.

SciTrader is also where we're quietly working on the next layer of SciChart's real-time data architecture (more to be revealed on that soon).

White-labeling

The entire interface supports complete white-labeling. You can strip out default branding and match your exact corporate styling guidelines.

This flexibility prevents brand sameness. Your end users will experience a completely bespoke application that feels built entirely in-house.

Between hardware-accelerated rendering, native SDKs across mobile and desktop, and a licensing model that doesn't punish growth, SciChart gives trading platform teams a foundation built specifically for the speed and reliability financial markets demand.

Get Started with SciChart

If you want to build a truly high-performance trading application, you need to see the technology in action. You can easily view demos and examples on the official website to test the rendering speeds yourself.

Take the next step for your development project. Try SciChart today to experience less lagging and more data rendering. If you’re building an end-user platform, try SciTrader today to jumpstart your interface design. It’s easy to get started with SciChart using their extensive developer documentation.

Try SciChart Today

Data Visualization in the Oil & Gas Industry Using SciChart

Andrew Bt — Wed, 28 Oct 2026 15:18:21 +0000

At SciChart, we serve customers in many industries and sectors. One sector that keeps coming back to use our chart software again and again is the oil and gas industry. In this blog post, we deep dive into how SciChart can help solve data visualization problems in the oil and gas industry, and what chart types and features make us a great fit for explorers or producers who need to visualize complex or big data.

What is SciChart?

First up, what is SciChart, and more importantly, what isn’t it?

SciChart is a software library for adding charts and graphs to applications. Our chart library supports JavaScript, TypeScript in browser or electron apps, C# WPF on Windows, Swift on macOS and iOS and Kotlin on Android.

Our customers are software development teams that are building apps that need to visualize data in 2D or 3D WPF charts and graphs. We don’t sell an off-the-shelf SaaS app for oil and gas prospecting. Instead, we sell chart libraries that help you build the best prospecting or exploration tools for internal or external teams. If that’s you, and you’d like to find out how, read on.

Data Visualization in the Oil & Gas Industry: Most Popular Chart Types

We asked our customers to name the most important chart types or features for oil and gas data visualization. This is what they told us:

Big Data: The ability to display millions of data points without slowdown is a must.
Vertical charts: The ability to rotate a chart to view vertical drill depth.
Synchronizing several charts: The ability to zoom, pan and show tooltips on several charts with the same horizontal or vertical scale.
Dashboarding charts: The ability to create oil and gas dashboards with several charts. Some call this a Trellis chart. We simply call it a dashboard.
Popular chart types are supported: This includes line, mountain, and scatter charts.
Oil and gas-specific chart types: This includes formation charts.
Sonogram charts: We call this a heatmap, but it can also be used to visualize a sonogram, ultrasound or other data from well and drill sensors.
3D charts: Visualizing surface meshes, topology data or point clouds in 3D is possible with SciChart, both in browser and on desktop and mobile devices.
High Performance: We already mentioned Big Data, but high performance and realtime charts are central to what we do and crucial for scientific industries.

SciChart can handle all these scenarios and more.

Let’s dig into the features and showcase some demos below:

How to Build Oil & Gas Dashboard Demos with SciChart

We’ve created some oil and gas dashboard demos showing you how to configure SciChart for oil and gas applications below. These have been created in both JavaScript for browser apps and WPF / C# for Windows desktop apps.

We’ve created a JavaScript demo showcasing SciChart’s capabilities for the oil and gas industry. Download the source code here.

Above is our oil and gas dashboard demo, which we’ve created in JavaScript as well as WPF (Windows).

Find the Source Code for the Oil & Gas Dashboard Demos Here:

SciChart’s Vertical Chart Feature

We’re using the vertical chart features in SciChart to arrange numerous drill depth charts. These have synchronized zooming, panning, and tooltips using a feature we call the RolloverModifier. Each vertical chart has a different visualization to showcase the flexibility and power of SciChart.

We’ve created a WPF (Windows) demo showcasing SciChart’s capabilities for the oil and gas industry. Download the WPF Source code and JavaScript Source code.

3D Charts, Sonograms & Heatmaps

3D charts and heatmaps (sonogram/spectrogram) are supported. Our JavaScript heatmaps are high-performing and update in realtime to show ultrasound or spectrogram data from oilwell sensors.

3D charts are supported in SciChart.js as well as SciChart WPF.

Contact Us to Find Out More

To find out more about SciChart or enquire about how we can help with your data visualization for the oil and gas industry, including prospecting, exploration or management applications, get in touch using the contact form.

Start using SciChart.js Today

SciChart.js is now available with a FREE community edition (no trial, sign-up or credit card required) where you can try out the library commercially or use it in a non-commercial application. You can also get a free trial of our WPF chart library. If you have a question or would like to give feedback, contact us.

Get SciChart.JS Free

Get SciChart WPF Free

React Charts with SciChart.js: Introducing scichart-react

Andrew Bt — Sun, 25 Oct 2026 19:17:05 +0000

TLDR: In this blog post we introduce a brand new open source library called scichart-react (npm, GitHub). This makes it easy to create stunning high-performance charts and data visualizations in React.

SciChart-React has now been released and is on npm as scichart-react. Examples, samples, documentation & tutorials are coming soon.

The official SciChart / React package solves the problem of component lifecycle with SciChart.js and avoids common pitfalls when creating charts in React. Code examples are given below of how to create React Charts, as well as where to find further information about this new React chart component.

Why Choose React JS for Chart Creation?

React JS has become the preferred choice for enterprises seeking robust and efficient application development, largely due to its component-based architecture, high performance, and rich ecosystem. Unlike other frameworks like Angular, React stands out for its virtual DOM, which ensures faster rendering and smooth handling of complex, data-intensive visualizations. Its modular nature allows for the creation of reusable, maintainable chart components, streamlining development and scalability. Additionally, React's vast library of tools and strong community support offers a wealth of resources, making it more adaptable to various charting requirements. The combination of flexibility, efficient data handling, and cross-platform compatibility positions React as a dominant force in the realm of enterprise-level data visualization, outpacing competitors in terms of performance and versatility.

Why Choose SciChart.js for React Charts?

SciChart.js is an advanced react chart library for use in complex and advanced mission critical applications. SciChart's key features include extremely high performance for big-data sets, a wide set of chart types, deep features and customisability.

For a full run-down of SciChart.js' features and why you should consider it for enterprise apps with complex requirements, read the following post:

https://www.scichart.com/blog/the-best-javascript-chart-10-reasons/

Create React Charts easily with SciChart-React

Earlier in the year, we published an article titled How to create a re-usable react component for SciChart.js. This demonstrated how to create charts in React by applying a few criteria for creation of a React Chart component:

The component should be reusable for different chart configurations
It should be possible to safely create several instances of the component
It should be easy to add custom functionality to the component
When chart instantiation is an async function, this should be properly handled
When the chart requires a root <div> element in the DOM it should exist before chart instantiation
Finally, the chart should be properly disposed and memory deleted after the component is unmounted.

As background reading it's worth reading the article. Problems which occurred in the past when creating React Charts with SciChart.js included double re-render, and potential memory leaks if your code improperly disposed of a chart surface by failing to call .delete().

We've created a new library called scichart-react which is open sourced and available on Github and npm. This solves the problems above and ensures that you have good quality code managing your react components and provides a clean, neat way to instantiate charts in react using simple props.

Step-by-Step Guide: Building Your First Chart in React with SciChart.js

SciChartReact provides an easy solution for using the SciChart core library for charts in React.

In the next sections, we will demonstrate a basic usage of the component.

Basic React Chart Example

Follow the prerequisites and installation sections from https://www.npmjs.com/package/scichart-react.

And just with few lines of code, you can set up a chart in React.

Create a Chart with Config (Builder) API

The Builder API in SciChart allows you to create charts in JavaScript with JS objects or JSON. This can be translated into React using scichart-react as follows.

The example uses the config property which accepts a configuration object of the chart. You can also pass a string with serialized chart configuration.

import { SciChartReact } from "scichart-react";
import { ESeriesType, EThemeProviderType } from "scichart";

/**
 * The chart configuration object acceptable by the Builder API
 * @type {import("scichart").TSurfaceDefinition}
 */
const chartConfig = {
  surface: {
    theme: { type: EThemeProviderType.Dark },
    title: "Basic Chart via Config",
    titleStyle: {
      fontSize: 20,
    },
  },
  series: {
    type: ESeriesType.SplineMountainSeries,
    options: {
      strokeThickness: 4,
      stroke: "#216939",
      fillLinearGradient: {
        startPoint: { x: 0, y: 0 },
        endPoint: { x: 1, y: 1 },
        gradientStops: [
          { offset: 0.3, color: "#2d2169" },
          { offset: 1, color: "transparent" },
        ],
      },
    },
    xyData: { xValues: [0, 1, 2, 3, 4], yValues: [3, 6, 1, 5, 2] },
  },
};

export const BasicChart = () => (
  <SciChartReact style={{ width: 400, height: 300 }} config={chartConfig} />
);

Here's the output

**Note* SciChartReact extends properties of the HTMLDivElement and propagates them to the underlying div element.*

Create a React Chart with Programmatic API

Alternatively, SciChartReact accepts an initialization function. This allows the creation of a chart with the usual SciChart.js API. In this case the chartInitializationFunction below must be async and accepts the <div> rootElement created by scichart-react as a parameter. This can be passed straight to SciChartSurface.create().

import { SciChartReact } from "scichart-react";
import {
  EThemeProviderType,
  NumericAxis,
  SciChartSurface,
  SplineMountainRenderableSeries,
  XyDataSeries,
} from "scichart";
/**
 * A function executed within SciChartReact with provided chart root element,
 * creates a SciChartSurface instance and returns a reference to it.
 *
 * @param {string | HTMLDivElement} rootElement
 * @returns {Promise<{sciChartSurface: SciChartSurface}>}
 */
const chartInitializationFunction = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: { type: EThemeProviderType.Dark },
      title: "Basic Chart via Init Function",
      titleStyle: {
        fontSize: 20,
      },
    }
  );

  sciChartSurface.xAxes.add(new NumericAxis(wasmContext));
  sciChartSurface.yAxes.add(new NumericAxis(wasmContext));
  sciChartSurface.renderableSeries.add(
    new SplineMountainRenderableSeries(wasmContext, {
      dataSeries: new XyDataSeries(wasmContext, {
        xValues: [0, 1, 2, 3, 4],
        yValues: [3, 6, 1, 5, 2],
      }),
      strokeThickness: 4,
      stroke: "#216939",
      fillLinearGradient: {
        startPoint: { x: 0, y: 0 },
        endPoint: { x: 1, y: 1 },
        gradientStops: [
          { offset: 0.3, color: "#2d2169" },
          { offset: 1, color: "transparent" },
        ],
      },
    })
  );

  return { sciChartSurface };
};

export const BasicChartWithInitFunction = () => (
  <SciChartReact
    style={{ width: 400, height: 300 }}
    initChart={chartInitializationFunction}
  />
);

Additionally, it is possible to easily add more customizations and functionality by providing arguments to other props:

fallback - a JSX element to render while the chart initialization is in progress
onInit - a callback that is executed after the chart initialization has been completed
onDelete - a callback executed when a fully initialized chart is unmounted

Advanced React Chart example - Selection and Synchronization with a DataGrid

Let’s look at another more complex example:

For this case, we will take a setup with a Scatter Chart that fetches data asynchronously.
The points on the chart could be selected by click and drag action.
Upon selection, the point info appears within a grid at the side of the chart

Step 1 - Fetching Data Asynchronously and loading the Chart

Considering that the data fetching as well as a chart initialization potentially can take a noticeable amount of time, let’s make sure to set a custom loading UI with fallback property.

/**
 * @param {string | HTMLDivElement} rootElement
 * @returns {Promise<{sciChartSurface: SciChartSurface}>}
 */
const chartInitializationFunction = async (rootElement) => {
  const createChart = async () => {
    // for demonstration purposes, here we have used Builder API explicitly
    const { sciChartSurface } = await chartBuilder.build2DChart(rootElement, {
      xAxes: {
        type: EAxisType.NumericAxis,
        options: {
          autoRange: EAutoRange.Once,
          growBy: new NumberRange(0.2, 0.2),
        },
      },
      yAxes: {
        type: EAxisType.NumericAxis,
        options: { autoRange: EAutoRange.Never },
      },
      surface: {
        theme: { type: EThemeProviderType.Dark },
        title: "Scatter Chart",
        titleStyle: {
          fontSize: 20,
        },
      },
    });

    return sciChartSurface;
  };

  // a function that simulates an async data fetching
  const getData = async () => {
    await new Promise((resolve) => {
      setTimeout(() => resolve({}), 1500);
    });

    return { xValues: [0, 1, 2, 3, 4], yValues: [3, 6, 1, 5, 2] };
  };

  const [sciChartSurface, data] = await Promise.all([createChart(), getData()]);

  const wasmContext = sciChartSurface.webAssemblyContext2D;

  sciChartSurface.renderableSeries.add(
    new XyScatterRenderableSeries(wasmContext, {
      dataSeries: new XyDataSeries(wasmContext, {
        ...data,
      }),
      strokeThickness: 4,
      stroke: "#216939",
    })
  );
  return { sciChartSurface };
};

// ...
// then in JSX
// ...

<SciChartReact
  style={{ width: "50%", height: 300 }}
  fallback={
    <div className="fallback">
      <div>Data fetching & Chart Initialization in progress</div>
    </div>
  }
  initChart={chartInitializationFunction}
/>

Step 2 - Adding in Selection Behavior to the Chart

To achieve this behavior we can use DataPointSelectionModifier, which is a built-in behaviour in SciChart to allow selection, and multi-selection of data-points on a chart.

  // ...

  /**  
   * @param {{sciChartSurface: SciChartSurface}} initResult 
   *    - a resolved object returned by the initialization function 
   */
  const onChartInitializationComplete = (initResult) => {
    const dataPointSelectionModifier = new DataPointSelectionModifier({
      allowClickSelect: true,
      allowDragSelect: true,
      selectionStroke: "lime",
      selectionFill: "#ff879f33",
      onSelectionChanged: (args) =>
        setSelectedPoints([...(args?.selectedDataPoints || [])]),
    });

    initResult.sciChartSurface.chartModifiers.add(dataPointSelectionModifier);
  };

  const onChartCleanup = () => setSelectedPoints([]);

  // ...

  <SciChartReact
    style={{ width: "50%", height: 300 }}
    fallback={
      <div className="fallback">
        <div>Data fetching & Chart Initialization in progress</div>
      </div>
    }
    initChart={chartInitializationFunction}
    onInit={onChartInitializationComplete}
    onDelete={onChartCleanup}
  />

Step 3 - Synchronising Selection Data from a Chart to a DataGrid

Now to bind the point selection to a grid, we are adding an appropriate callback to the DataPointSelectionModifier - onSelectionChanged.

It can be used to get the list of the selected points and then we should be able to easily put them into a grid.

// ...

<div className="flex-container">
  <SciChartReact
    style={{ width: "50%", height: 300 }}
    fallback={
      <div className="fallback">
      <div>Data fetching & Chart Initialization in progress</div>
      </div>
    }
    initChart={chartInitializationFunction}
    onInit={onChartInitializationComplete}
    onDelete={onChartCleanup}
  />

  <div className="data-grid">
    <div className="grid-cell grid-header">
      <div>Selected Points</div>
    </div>
    <div className="grid-cell column-header">
      <div>X Value</div>
    </div>
    <div className="grid-cell column-header">
      <div>Y Value</div>
    </div>

    {selectedPoints.map((point) => (
      <>
        <div key={`x-val-${point.index}`} className="grid-cell">
          <div>{point.xValue}</div>
        </div>
        <div key={`y-val-${point.index}`} className="grid-cell">
           <div>{point.yValue}</div>
        </div>
      </>
    ))}
  </div>
</div>

Further Examples of React Charts with scichart-react

The full source-code for all three examples in this blog post, showing how to create a Basic React Chart with config, a Basic Chart with programmatic API, as well as the DataGrid sync example are included in the Codesandbox here.

Additional resources can be found below.

Simple Examples: SciChart-react code examples - Github Pages
Source: SciChart-React source-code on Github
npm: SciChart-React package on npm
Advanced examples: we're working through the SciChart.js Demo to update all our examples to use scichart-react.

Conclusion

Integrating SciChart with React for Powerful Charting

It has always been possible to use SciChart's JavaScript Charts within React. We previously documented how to create a reusable react component talking about some of the issues such as correct component lifecycle and handling SciChart's async initialisation.

We've now wrapped this up into an open source library called scichart-react to make creating React Charts easy.

Try out SciChart-React!

We encourage you to try out scichart-react: our React Chart component and see if it helps you simplify the development of charts with SciChart.js.Internally we've handled a lot of the problems associated with React such as double-render, component unmount and proper deletion of SciChart charts, wrapping it all up neatly in a small package which adds only 3kb of JavaScript to your application.

We'll be talking about further examples and utilities in the future, so do watch our blog for further updates!

Also see

See our related posts comparing JavaScript chart libraries, plus a showcase of the best React Charts and Graphs

https://www.scichart.com/blog/showcase-of-the-best-react-charts-and-graphs/

https://www.scichart.com/blog/alternatives-to-chart-js/

Fastest Chart Libraries for Quantitative Analysis

Andrew Bt — Sun, 25 Oct 2026 19:15:30 +0000

Developers with experience building trading architecture know that quantitative finance runs on instantaneous data rendering. While open-source tools, such as uPlot and Apache ECharts, offer lightweight solutions for basic applications, advanced financial chart developers require rendering engines with a little more power behind them. SciChart leads the market in performance, providing the most comprehensive, customizable ecosystem for visualizing over 100 million data points in real time.

What Are the Fastest Chart Libraries for Quantitative Analysis?

The fastest chart libraries for quantitative analysis are high-performance rendering engines engineered to process multi-million point, real-time financial datasets. By using hardware-accelerated WebGL or WebAssembly frameworks, these specialized libraries, such as SciChart, bypass standard browser main-thread bottlenecks to ensure fluid visual execution during periods of high market volatility.

Your underlying architecture dictates how efficiently an application handles large data throughput, so it’s wise to invest a little time in choosing it. To help you get started in your research, we’re reviewing the most prominent rendering libraries used across the quantitative finance sector in 2026.

The context behind where the data outlined in this article, can be replicated using our GitHub performance benchmark test suite.

uPlot

For developers seeking an exceptionally lightweight footprint, uPlot is a trusty open-source option. It delivers fast initial load times and decent basic performance by focusing solely on core charting features.

Strengths: It has a tiny library size and memory footprint.
Weaknesses: The library lacks advanced financial charting features and complex interactivity out of the box. uPlot drops to 6 FPS for 100k OHLC candles, and while it can render a million-point line, it can’t do that for candles.

From an advanced perspective, uPlot achieves its speed by sticking to a highly optimized, synchronous canvas rendering path.

However, it handles data updates sequentially on the main UI thread. When you try to push structured order book depths or concurrent multi-asset tick streams into it, the main thread locks up immediately, making live interaction impossible during high volatility.

Highcharts

Highcharts is widely adopted in corporate environments for its out-of-the-box visual polish, feature set, and accessibility features.
However, because it processes graphics on the CPU thread and forces browser repaints for every data change, it’s ill-suited for live market tick feeds, high-frequency backtesting loops, or complex multi-pane trading layouts.

Strengths: It features a Highstock package designed for standard financial and timeline charts.
Weaknesses: Highcharts isn’t designed for high-frequency workloads. Its core architectural reliance on the DOM via an SVG creates a bottleneck for performance-intensive quant workflows. The software struggles with high data volumes, showing lag or freezing during rendering when a single dataset reaches 20,000 data points.

Plotly.js

Plotly.js is an open-source library used by data scientists for its native integration with Python, R, and Julia. While it introduces WebGL acceleration for certain chart types (like 3D point clouds and scatter plots), its underlying architecture remains heavily anchored to D3.js and SVG wrappers, limiting its efficiency.

Strengths: Plotly is an out-of-the-box library for scientific charting, subplots, and 3D surface meshes, making it ideal for static options risk modeling.
Weaknesses: Plotly can't do more than 10k candles. It hits WebGL context limits, meaning it cannot render more than 8 WebGL charts on a single page, making multi-chart trading screens difficult.

Perspective

Perspective is an interactive analytics component designed for large-stream datasets rather than just standard charting.

Strengths: It excels at handling live data pivoting and data grid manipulation.
Weaknesses: The visualization components are less mature than dedicated charting engines.

Perspective handles the heavy lifting by compiling its core C++ analytical engine to WebAssembly. This allows it to perform complex data reductions, aggregations, and delta-updates completely off the main thread. While its ability to manipulate huge data arrays in real time is phenomenal, its visualization layer is essentially a wrapper for other chart renderers.

Our verdict? It’s an excellent analytical tool, but it lacks the explicit visual control required for complex financial graphics.

Apache ECharts

Apache ECharts is a highly versatile, feature-rich visualization library widely adopted across various web industries.

Strengths: It delivers an extensive array of chart types and beautiful default configurations.
Weaknesses: It relies heavily on SVGs and standard canvas rendering, which slows down drastically when pushed past a few hundred thousand data points. ECharts can do 23 FPS at 100k, which is fine, but not quite a match for the 60 FPS required for high-performance data visualization projects.

ECharts uses a declarative option-cloning system that is highly intuitive for standard web apps. But for high-frequency quantitative dashboards, that abstraction can be a disaster. Every dynamic data change triggers massive object instantiation and garbage collection spikes.

Once you cross into historical backtesting scales or volatile order book depths, the canvas layout engine struggles on path recalculations. This ultimately causes frame drop rates to plummet.

SciChart

When the sheer scale of your data becomes a bottleneck, SciChart represents the industry standard for enterprise financial systems. Built on a proprietary C++ rendering engine called Visual Xccelerator™, it bridges the gap between raw native speed and web applications via WebAssembly, WebGL, and an alpha version of WebGPU.

Strengths: SciChart easily supports over 100 million data points, offering deep customization and unparalleled real-time performance. SciChart can do 10M candles, which is enough to display the entire history of bitcoin as a 1-minute chart. SciChart is used by the likes of Bithumb, one of South Korea’s most popular crypto apps.
Weaknesses: It’s a commercial, premium software product rather than a free open-source tool.

What sets SciChart apart for senior systems architects is how it manages the hardware interface. By compiling its core C++ graphics engine straight to WebAssembly, it implements WASM-SIMD vectorization and direct manual memory management.

This means you’re completely bypassing the browser's volatile garbage collector. It handles incoming market feeds using highly efficient native FIFO memory structures and lossless adaptive resampling algorithms. This guarantees zero memory growth and reliable 60 FPS performance, even when rendering hundreds of technical indicators over multi-million point historical datasets.

Performance Comparison Table

The following matrix provides a clear breakdown of how these libraries stack up under heavy data stress – an inevitable part of quantitative analysis applications.

Chart Library	Rendering Tech	Max Data Points	Financial Customization	Tech Support Type
uPlot	Canvas 2D	~1 million	Low	GitHub Community
Highcharts	SVG + WebGL via its Boost module	~50,000 points	High	Commercial
Plotly	Hybrid SVG + WebGL	~20,000	High	Community & Tiered Commercial
Perspective	WebAssembly / WebGL	~10 million	Medium	Open-Source Community
Apache ECharts	Canvas / SVG	< 500,000	High	Open-Source Community
SciChart	Visual Xccelerator™ (C++/WebGL)	100 million+	Unmatched	Enterprise & AI Assistant

How to Ensure You Don’t Experience System Failures?

To prevent system failures, we recommend GPU hardware acceleration. At our level of application design, raw painting speed isn’t your only bottleneck. You also want to know how the library manages memory, garbage collection overhead, and cross-runtime serialization.

If you’re a financial chart developer, you’ve probably seen your fair share of charting shortcuts blow up in production. When tracking high-frequency trading feeds or running complex risk models, a delayed UI chart is insufficient for real-time risk assessment.

This often stems from choosing the wrong rendering engine. If performance degradation, sudden browser tab crashes, and unresponsive user interfaces are all banned phrases for your application development, then we recommend choosing a fast chart library that is specifically engineered for quantitative analysis.

Build High-Performance Charts for Quantitative Analysis With SciChart

Building institutional-grade trading platforms requires tools that render your data, even when pushed to the limits. SciChart offers the most advanced chart library support for financial chart developers. It provides native-grade speed across JavaScript, React, and WPF platforms, backed by a dedicated engineering team and an AI support assistant.

SciChart offers all the tools you need to build top-spec quant finance apps, including advanced drawing tools that help you trade in your current static drawings for interactive, editable annotations.

Get started with SciChart’s financial chart library today to eliminate rendering bottlenecks.

Explore the Code: Check out the JavaScript chart performance benchmark on GitHub.
Build Now: Get started with SciChart.js and deploy your first high-performance dashboard today.

Frequently Asked Questions

Which chart library is best for real-time quantitative trading dashboards?

SciChart is considered by financial chart developers to be one of the best choices for real-time trading dashboards due to its hybrid C++ and WebAssembly engine. SciChart.js charts easily display more than 100 million data points.

Why do standard open-source chart libraries crash with large financial datasets?

Most open-source chart libraries rely on standard HTML Canvas or SVG rendering which present their own limitations. With SVG, for instance, every data point gets its own DOM node which can overload a browser when you're handling larger datasets. This can result in lag or memory leaks when handling rapid market feeds.

Does SciChart support modern web frameworks like React?

Yes, SciChart features deep native integration for modern web development, allowing you to build reactive, high-performance interfaces using specialized wrappers for React charts, Vue, and Angular.

How to Build Real-Time JavaScript React Maps with GeoJSON – No SVG Bottlenecks

Andrew Bt — Tue, 20 Oct 2026 10:29:49 +0000

High-performance real-time GeoJSON maps with SciChart.js v4 support fast, customizable choropleth maps and spatial visualizations.

If you're processing GeoJSON and rendering triangle meshes in the browser, you've likely hit the ceiling with SVG or Canvas. SciChart.js v4 breaks through that bottleneck and unlocks a new layer of performance for teams building data-intensive visualizations.

At launch, the first examples we've implemented are all variations of choropleth maps, where geographic regions are shaded or colored based on a data value such as population density, signal strength, or sensor readings. Choropleth maps are ideal for spatial dashboards, and with SciChart's WebGL-based rendering, you get a fluid, high-performance experience even with complex geometries or large datasets.

🚀 What's New in SciChart.js v4

With SciChart.js v4, there are plenty of new features we're excited to share with our community of developers that enable you to break through the SVG bottleneck. From a new TriangleRenderableSeries to smarter render batching for redrawing, explore the latest updates that SciChart has to offer, and how they can help you build complex GeoJSON maps faster and better.

👉 See the SciChart.js v4 announcement on LinkedIn

TriangleRenderableSeries

Our GPU-accelerated TriangleRenderableSeries lets you render arbitrary triangle meshes (e.g. triangulated GeoJSON) via WebGL, with support for:

Direct vertex/index buffer input
Native speed display
Custom projections, including polar, stereographic, orthographic and custom, without a rendering penalty
Hundreds of thousands of triangles at 60+ FPS

We're not accelerating the parsing or triangulation. We're accelerating the rendering of arbitrary triangles.

RectangleRenderableSeries

Using the RectangleRenderableSeries, you can render layout-driven visuals like treemaps, allocations and spatial grids, all GPU-accelerated and interactive.

Performance + API Upgrades

With SciChart.js v4, you'll benefit from smarter render batching for redraw-intensive scenes, dynamic z-ordering for layered charting, and full control over colors, vertex transforms, and coordinate space.

Advanced Dashboards

With advanced dashboards, you can effortlessly create treemaps, data tiling layouts, and spatial relationship charts. Developers can also merge geometric and business data into highly customized, renderable layers.

The examples below, including a triangulated USA map, showcase choropleth-style visualizations rendered via SciChart's GPU engine. While they resemble traditional maps, each is built on WebGL with real-time rendering performance and deep extensibility, ideal for interactive dashboards, spatial analytics, and high-volume geospatial data.

Real-World Use Cases (Where It Shines)

Now that you know what is being added to our repertoire of expansive, customizable and high-performance features, it's worth showcasing where these new features were designed to shine. While this is not an exhaustive list, it covers some of the core sectors that can benefit from these new features and upgrades.

Oil & Gas

Overlay seismic data, survey zones, and projected well locations over triangulated maps
Visualize intricate geological structures by integrating seismic interpretations, precisely delineated survey boundaries, and future well paths directly onto dynamic triangulated maps. This gives a comprehensive understanding of subsurface conditions, aiding exploration and development decisions. The triangulated maps provide a robust foundation for accurate spatial referencing, so all overlaid data is rendered with high precision and clarity.
Use polar or UTM projections without rendering lag
Switch between polar and Universal Transverse Mercator (UTM) projections with no noticeable rendering lag, keeping the user experience smooth and responsive. This is vital for applications requiring global coverage or highly localized precision.
Animate telemetry on top of spatial regions
Bring your data to life by animating real-time telemetry feeds directly onto predefined spatial regions. This lets you track moving assets, environmental changes, or operational progress in a geographical context. Whether monitoring vehicle movements, sensor readings, or natural phenomena, animated telemetry provides valuable insight into temporal patterns and spatial relationships.

Aerospace & Defense

Render live positional data, terrain overlays, or mission planning visuals

Imagine a fleet management system where the exact location of vehicles needs to be displayed instantly on a map. As each vehicle transmits its updated coordinates, the GeoJSON data changes, and the map must reflect these changes in real time, giving an accurate, up-to-the-minute overview of the entire fleet's movements.

Beyond simple points, real-time rendering also supports complex terrain overlays. This could mean displaying dynamic weather patterns that update in real time to show precipitation, wind speeds, or temperature changes. Overlaying this constantly changing data onto a base map provides critical insight and situational awareness.

Another significant area is mission planning. In defense, logistics, or drone operations, real-time map updates are essential for dynamic mission planning: visualizing changing no-fly zones, updating routes based on new intelligence, or displaying the live progress of ground or airborne assets. Instant feedback on the map allows for rapid adjustments and better decisions during critical operations.

Display vector-based operational maps that update in real time

Unlike static raster images, vector maps are made of geometric primitives like points, lines, and polygons, which gives crisp rendering at any zoom level and easier manipulation of individual features. In operational contexts, boundaries, infrastructure, or strategic points can be added, modified, or removed instantly as circumstances change, so users always have the most accurate and actionable view of their operational environment.

Climate & Remote Sensing

▶️ Watch the demo: real-time GeoJSON climate map in SciChart.js v4

Visualize Temperature Gradients, Radiation Models, or Global Sensor Coverage

Real-time GeoJSON map rendering makes it possible to visualize intricate climate and remote sensing datasets with clarity and responsiveness. For example:

Temperature gradients: Observe subtle shifts in thermal energy across vast areas, enabling analysis of climate patterns, urban heat islands, or the spread of wildfires. The map becomes a living thermometer, giving immediate feedback on environmental change.
Radiation models: Track the distribution of radiation from natural sources, industrial emissions, or emergency situations. This is crucial for public safety, environmental monitoring, and disaster response, allowing real-time assessment of potential risks.
Global sensor coverage: Get a full overview of sensor networks, identify coverage gaps, monitor device health, and optimize data collection. From environmental sensors to traffic monitoring systems, the map becomes an interactive dashboard for interconnected systems.

Use Polar Projection with Tens of Thousands of Triangles from MODIS-Style Datasets

Combining the precision of GeoJSON with advanced rendering lets users explore and analyze complex geospatial information dynamically, across fields from scientific research and environmental monitoring to logistics and urban planning. Capabilities we're unlocking for developers include:

Polar projection: Represent global phenomena accurately in polar regions. This is particularly important for the Arctic and Antarctic, where traditional Mercator projections distort heavily.
Tens of thousands of triangles: Render detailed topographical features, atmospheric conditions, or scientific models made of vast numbers of data points, with the granularity to show intricate geometries and nuanced data.
MODIS-style datasets: Incorporate data from sources like the Moderate Resolution Imaging Spectroradiometer (MODIS), a key instrument aboard NASA's Terra and Aqua satellites. These datasets, known for extensive coverage and high temporal resolution, can show processes from vegetation health to sea surface temperature.

Telecom & Smart Cities

Display infrastructure coverage, signal strength, or failure overlays by geographic zone

For telecoms companies, utilities, and emergency services, understanding the real-time status of infrastructure is crucial. Picture cellular signal strength mapped across neighborhoods to pinpoint weak coverage, or a power grid operator instantly identifying zones affected by outages for rapid response. Civil engineering firms can overlay structural integrity or environmental impact data across specific building zones. This supports proactive maintenance, efficient resource deployment, and improved public safety through an immediate visual view of operational status.

Integrate Real-Time Sensor Data with Geographic Awareness

The Internet of Things (IoT) has led to an explosion of sensor data, much of it with a geographic component. Integrating this data with GeoJSON maps enables powerful spatial analysis and real-time monitoring. For instance:

Environmental agencies can track air quality or water pollution from distributed sensors and identify pollution hotspots in real time.
In agriculture, sensors monitoring soil moisture or crop health can be visualized geographically, enabling precision farming.
Urban planners can track traffic flow or pedestrian movement to inform infrastructure development or event management.

This moves beyond static maps, turning them into dynamic dashboards that reflect real-world activity and give decision-makers actionable insight.

Transport & Logistics

Show dynamic fleet locations, congestion heatmaps, and route planning overlays
Real-time fleet locations, congestion heatmaps, and route planning overlays can all be built with GeoJSON charts in SciChart.js v4. This supports optimized logistics, better delivery times, and proactive responses to unexpected delays.
Combine static base layers with real-time, triangle-driven data overlays
With SciChart.js v4, you can combine static base layers with real-time, triangle-driven data overlays to visualize complex transport and logistics data such as vehicle movements, supply chain routes, and delivery statuses.

TL;DR: How SciChart.js Supports Complex GeoJSON Maps in Real Time

Using SciChart's JavaScript chart library means you can stop pushing SVG to its limits:

Feed your triangles into TriangleRenderableSeries
Render on the GPU with native performance
Apply custom projections without writing rendering logic
Build real-time, scalable, interactive visuals that respond instantly

Traditional rendering techniques can struggle with performance and cause lag. Rich, geographically aware visualizations need to be not only accurate but also responsive and accessible for critical operational and analytical tasks.

SciChart.js v4 isn't just faster. It's built for the next generation of data-driven apps.

Building on this, the SciChart React Chart Library brings the same next-generation performance to modern web apps. With seamless React integration, it makes it easy to create fast, interactive, and visually rich charts for any data-driven experience.

Try SciChart.js Today →

Creating a React Drag & Drop Chart Dashboard Performance Demo with 100 Charts

Andrew Bt — Tue, 20 Oct 2026 10:27:50 +0000

When building real-time data visualization applications, performance is often a critical factor, especially when dealing with large datasets and frequent updates. SciChart.js, our high-performance JavaScript Chart Library, is designed to handle demanding use cases, and with the help of SciChart React chart library, an open-source React component wrapper for SciChart, integrating charts into React applications becomes even easier.

To showcase the power of SciChart.js in a React environment, we've created a performance demo featuring 100 interactive charts in a drag-and-drop, rearrangeable and resizable dashboard. This demo allows users to test various SciChart features in real time, measuring their impact on rendering speed and interactivity. A built-in toolbar provides controls to toggle effects, animations, and data updates, as well as report chart stats such as FPS, demonstrating how SciChart maintains smooth performance under different configurations.

Individual chart panels in the Dashboard can be dragged to reposition them, resized, maximised or minimised.

With the right settings, this dashboard achieves 60 FPS rendering of 100 JavaScript / React charts containing a total of up to 10,000,000 (ten million) data points, making it an excellent benchmark for high-performance web applications. This blog post walks through the key aspects of the demo, the optimizations used, and how SciChart.js ensures seamless visualization, even at scale.

Let's get started.

▶️ Watch the demo video: 100 React charts, 10 million points

Downloading the Drag & Drop Dashboard Source-Code

The source-code for this tutorial can be found in our SciChart.JS.Examples GitHub repository. Go ahead and clone the repo and navigate to the Sandbox/CustomerExamples/DragDropDashboardPerformanceDemo folder. From there, simply npm install and npm start and the application will start up in a browser.

What can you do with the demo?

This demo shows you how to create a drag & drop chart dashboard in React. It creates 100 charts and arranges them in a grid of 4x25 and allows you to scroll up/down to view all the charts.

Charts are updated in real-time and scrolled to simulate a real-time telemetry monitoring application. You can turn on/off various elements or features to see the effect on optimisation and performance in SciChart.js.

Architecture of the Drag & Drop React Chart Dashboard

Here's how the demo is architected:

App.tsx

At the top level we have App.tsx. This component contains a number of components:

DraggableProvider - a React Component to provide a drag & drop panel, as well as context object to store panel state
AppHeader - Contains checkboxes to enable/disable optimization features, as well as reporting on chart count, total point count and FPS (frames per second)
SciChartGroup - part of the scichart-react library, groups charts into one with a single shared context.
DraggablePanel - Provides a single drag & drop panel that can contain a chart, allowing the user to reposition it by dragging the mouse.
ChartPanel - all logic for rendering a single chart and its settings is encapsulated here.

// App.tsx excerpt
  return (
    <DraggableProvider
      style={{ height: "100vh", display: "flex", flexDirection: "column" }}
    >
      <AppHeader />
      <div
        className="App"
        style={{
          position: "relative",
          height: "calc(100vh - 40px)",
          overflowY: "auto",
          overflowX: "hidden",
        }}
      >
        <SciChartGroup>
          {charts.map((spec, index) => (
            <DraggablePanel key={index} positionable={spec} width="25%">
              <ChartPanel
                chartSpec={spec}
                style={{
                  width: "100%",
                  height: "200px",
                }}
              />
            </DraggablePanel>
          ))}
        </SciChartGroup>
      </div>
    </DraggableProvider>
  );
}

1..N ChartPanel components are created according to the charts array in App.tsx. This array is initialized with 100 ChartSpec objects, each one representing a JavaScript chart panel, with various options to configure the chart. Look at the code at the top of App.tsx to see how this initialization and setup works.

// App.tsx - 100 charts specification and state initialization
function AppContent() {
  const { chartState, chartCount, pointCount, dataUpdateRate } =
    useChartState();

  // Initialize chart specs. 100 charts of varying types
  const [charts, setCharts] = useState<ChartSpec[]>(() => {
    const chartTypes = Object.values(ChartType);
    const cols = 4;
    return Array.from({ length: chartCount }, (_, index) => ({
      chartType: chartTypes[index % chartTypes.length],
      pointCount,
      dataUpdateRate: dataUpdateRate,
      chartTitle: `Chart ${index + 1}`,
      position: {
        left: `${(index % cols) * 25}%`,
        top: Math.floor(index / cols) * 200,
      },
      drawLabels: chartState.drawLabels,
      useNativeText: chartState.useNativeText,
      reduceAxisElements: chartState.reduceAxisElements,
      cacheLabels: chartState.cacheLabels,
      hideOutOfView: chartState.hideOutOfView,
    }));
  });

How DraggablePanel.tsx Works

DraggablePanel provides a <div> which can be dragged to reposition around the screen. This code handles onMouseDown, onMouseMove, onMouseUp and onMouseLeave to record when the user drags the chart panel, and allows repositioning anywhere in the parent DraggableProvider. Code here could be extended to provide more complex layout and docking operations, but for a proof of concept of drag-and-drop charts, it does the job!

// DraggablePanel.tsx excerpt
 return (
    <div
      style={{
        position: "absolute",
        left: isDragged ? `${position.left}px` : position.left,
        top: `${position.top}px`,
        width,
        cursor: isDragging ? "grabbing" : "grab",
        zIndex,
        border: "1px solid SteelBlue",
      }}
      onMouseDown={handleMouseDown}
      onMouseMove={handleMouseMove}
      onMouseUp={handleMouseUp}
      onMouseLeave={handleMouseUp}
    >
      {children}
    </div>
  );

How ChartPanel.tsx Works

ChartPanel is a React component which provides a single SciChart.js chart, hosted by <SciChartReact/> which handles full component lifecycle, initialization of the chart and deletion (teardown) on component unmount. The ChartPanel code is simple, it accepts props which are passed to an initChart function that sets up the SciChart chart.

export const ChartPanel: React.FC<ChartPanelProps> = ({ chartSpec, style }) => {
  // Use chartSpec properties as part of the key to force re-creation when they change
  const chartKey = `${chartSpec.drawLabels}-${chartSpec.useNativeText}-` +
     `${chartSpec.reduceAxisElements}-${chartSpec.cacheLabels}-` +
     `${chartSpec.hideOutOfView}`;

  return (
    <SciChartReact
      key={chartKey}
      initChart={async (rootElement) => initChart(rootElement, chartSpec)}
      onDelete={(initResult) => initResult.onDeleteChart()}
      style={style}
    />
  );
};

Initializing the SciChart.js Charts

SciChart chart instantiation and configuration occurs in initChart.ts. This performs the following operations:

Creates a JavaScript chart using SciChartSurface.create(). One is created for each DraggablePanel, with 100 charts total in the demo app.
X and Y axis are created, with axis options with varying features that are enabled/disabled in order to demonstrate the performance impact of axis elements in multi-chart dashboards.

// initChart.ts excerpt, settings for optimal axis rendering
// Depending on optimization flags, create optimal xAxis settings
const axisOptions = {
  // When useNativeText, also use label Caching
  useNativeText: spec.useNativeText,
  useSharedCache: spec.cacheLabels,

  // Hide elements which add to the draw time, but are barely visible due to chart size
  drawMinorTickLines: !spec.reduceAxisElements,
  drawMinorGridLines: !spec.reduceAxisElements,
  drawMajorTickLines: !spec.reduceAxisElements,
  drawMajorGridLines: !spec.reduceAxisElements,
  drawMajorBands: !spec.reduceAxisElements,
  maxAutoTicks: spec.reduceAxisElements ? 5 : undefined, // Reduce number of labels on screen

  // Hide labels if specified
  drawLabels: spec.drawLabels,
};

// Create X Axis
sciChartSurface.xAxes.add(
  new NumericAxis(wasmContext, {
    ...axisOptions,
    labelPrecision: 0,
  })
);

// Create Y Axis
const yAxis = new NumericAxis(wasmContext, {
  ...axisOptions,
  // Depending on optimized flag, create optimal xAxis settings
  growBy: new NumberRange(0.1, 0.1),
  axisAlignment: EAxisAlignment.Left,
});

Series creation is provided by createRenderableSeries, where the chartSpec.chartType is used to determine which series or chart type to create: Line, Mountain, Scatter or Column.
The brand new freezeWhenOutOfView flag (new to SciChart.js v3.5.727) is set when chartSpec.hideOutOfView is true, allowing SciChart to pause/resume rendering of charts which are not currently in the viewport. This uses the IntersectionObserver API to suspend/resume updates on a SciChartSurface when it is not visible.

// initChart.ts excerpt - using freezeWhenOutOfView flag
// Create the SciChartSurface
const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, {
    theme: new SciChartJsNavyTheme(),
    // NEW to SciChart.js 3.5.727!
    // Freezes drawing (but not data updates) on charts which are
    // outside the viewport. Drawing will be resumed when a chart
    // is scrolled into view. This is handled automatically internally and may
    // be enabled/disabled on a per-chart basis
    freezeWhenOutOfView: spec.hideOutOfView,
  }
);

Finally, for realtime, dynamic updates to the chart we subscribe to DataManager.getInstance().subscribeDataUpdate(). This simulates a real-time incoming data feed with new data-points sent every ~16 ms, for a total maximum frame rate of 60 FPS. New data-points are added to SciChart using dataSeries.append and the chart xAxis is scrolled to show the latest N datapoints.

// initChart.ts excerpt. Subscribe to data updates and scroll the chart
const unsubscribeDataUpdates = DataManager.getInstance(
  spec.dataUpdateRate
).subscribeDataUpdate((timestamp, xValues, yValues) => {
  // Append data to the chart
  if (xValues.length === 1) {
    dataSeries.append(xValues[0], yValues[0]);
  } else {
    dataSeries.appendRange(xValues, yValues);
  }

  // Scroll the xAxis
  sciChartSurface.xAxes.get(0).visibleRange = new NumberRange(
    xValues[xValues.length - 1] - spec.pointCount,
    xValues[xValues.length - 1]
  );
});

Tweaking the Chart Count Parameters

Chart count and state parameters are found in ChartStateContext.tsx. Adjusting any of these variables will modify the app startup parameters. For example, if you wanted to try 300 charts you can update chartCount. Or for 30 charts with 2,000 points each, modify pointCount. dataUpdateRate modifies the number of points appended per timer tick (1/60th second) to every chart.

// ChartStateContext.tsx excerpt - showing initial state
export function ChartStateProvider({
  children,
}: {
  children: React.ReactNode;
}) {
  const [chartState, setChartState] = useState<ChartState>({
    reduceAxisElements: true,
    drawLabels: false,
    useNativeText: true,
    cacheLabels: true,
    hideOutOfView: true,
  });
  const [pointCount] = useState(100); // pointcount per chart
  const [chartCount] = useState(100); // number of charts
  const [dataUpdateRate] = useState(10); // number of points per 1/60th second per chart

  const handlePropertyChange = useCallback(
    (propertyName: string, value: boolean) => {
      setChartState((prev) => ({ ...prev, [propertyName]: value }));
    },
    []
  );

We incorporated modifying the pointCount and dataUpdateRate into a slider in the top of the app which is declared in AppHeader.tsx. This lets you slide from 100 points per chart (total 10k data-points), to 1,000 to 10,000 and finally 100,000 (total of 10 million datapoints across 100 charts, with 60k new datapoints per second).

Yes, SciChart.js is powerful enough to render 100 charts, each with 100,000 points, for a total of 10 million data-points and 60k new points per second at an FPS of 50-60 in the browser.

Drag the DataRate Slider to change from 100 points to 1k, 10k or 100k per chart, for a total of 10 million datapoints across all charts

Optimizing the App and Measuring Performance

OK so what can the React dashboard performance demo do?

First up, it creates 100 charts and arranges them in a grid of 4x25. These have varying chart types such as Line, Scatter plot, Mountain (Area) plot and Column chart.

Data is updated in real-time and the charts scroll as new data arrives. FPS is outputted to the top right of the browser, and you can toggle various options to measure the impact of performance optimizations on SciChart.js in a multi-chart dashboard scenario.

Optimization #1 - Freezing Charts that are out of View

You can scroll down or up in the browser to view all 100 charts. Charts out of view are automatically paused/resumed when the Freeze Charts out of View option is checked, which enables the IntersectionObserver and sciChartSurface.suspendUpdates() behaviour in initChart.ts.

With 100 charts in the dashboard, only 20-30 are visible at any one time, so setting or unchecking Freeze Charts out of View has the following impact on performance:

With Freeze Charts out of View: 57-60 FPS
Without Freeze Charts out of View: 13 FPS

Wow! A huge difference. This goes to show that you should always optimize your rendering to pause drawing for charts outside of the viewport. Note that data updates are not paused, these will continue to stream into the chart and the chart will redraw the dataset once you bring it into view.

Using IntersectionObserver to suspend/resume charts that are out of the viewport has a dramatic effect on performance in large multi-chart scenarios. We are working on including this functionality into the library, with a new flag which will allow suspending of charts outside the viewport.

Optimization #2 - Axis Labels

In this example there are 100 charts in a React Dashboard, each chart has 2 axes, and each axis by default will have up to 10 labels, or a total of up to 2,000 axis labels for 100 charts.

By default, SciChart.js renders labels using HTML5, which allows for a lot of customization, but not the best performance out of the box. This can be changed with a few simple tweaks.

Select the option Draw Labels. This will reload the app and show yAxis and xAxis labels on each chart panel.

Now, experiment with the Native Text and Cache Labels options. These parameters are passed through to initChart and affect the setup or initialization of SciChart. These options dramatically change the performance when many charts are on the screen. Here is the impact on performance:

Draw Labels	Native Text	Cache Labels	FPS
False	-	-	60
True	True	True	60
True	True	False	55
True	False	True	10
True	False	False	5.5

For multi-chart dashboards, or for where many labels are drawn, enabling SciChartDefaults.useNativeText and SciChartDefaults.useSharedCache dramatically speeds up the rendering of SciChart. These properties are not enabled by default, so you will need to set them in your app. For single chart cases, or for few charts, they may not make much difference.

Optimization #3 - Reducing Axis Elements

The next optimization to cover is Reduce Axis Elements. With this option checked, the following options are passed to axis creation.

Each chart has 2 axes, and each axis could have 10 major gridlines, 50 minor gridlines, as well as 10 major and 50 minor ticks (small 2 pixel lines drawn outside of the chart). While aesthetically pleasing, using the defaults can result in up to 12,000 extra elements being drawn to the chart surfaces across 100 charts.

// initChart.ts excerpt. Reducing axis elements to improve performance
// Depending on optimization flags, create optimal xAxis settings
const axisOptions = {
  // When useNativeText, also use label Caching
  useNativeText: spec.useNativeText,
  useSharedCache: spec.cacheLabels,

  // Hide elements which add to the draw time, but are barely visible due to chart size
  drawMinorTickLines: !spec.reduceAxisElements,
  drawMinorGridLines: !spec.reduceAxisElements,
  drawMajorTickLines: !spec.reduceAxisElements,
  drawMajorGridLines: !spec.reduceAxisElements,
  drawMajorBands: !spec.reduceAxisElements,
  maxAutoTicks: spec.reduceAxisElements ? 5 : undefined, // Reduce number of labels on screen

  // Hide labels if specified
  drawLabels: spec.drawLabels,
};

// Create X Axis
sciChartSurface.xAxes.add(
  new NumericAxis(wasmContext, {
    ...axisOptions,
    labelPrecision: 0,
  })
);

// Create Y Axis
const yAxis = new NumericAxis(wasmContext, {
  ...axisOptions,
  // Depending on optimized flag, create optimal xAxis settings
  growBy: new NumberRange(0.1, 0.1),
  axisAlignment: EAxisAlignment.Left,
});

Select / unselect the Reduce Axis Elements option to see the effect on performance:

With Reduce Axis Elements: 60 FPS
Without Reduce Axis Elements: 30-40 FPS

When many charts are on screen, consider reducing the frequency of labels, axis gridlines, or even disabling elements by setting axis.drawMinorGridLines, axis.drawMinorTickLines, axis.drawMajorTickLines and axis.drawMajorBands equal to false.

Conclusion

This performance demo highlights just how powerful SciChart.js is when handling large-scale real-time data visualization in a React drag-and-drop dashboard. By leveraging scichart-react, an open-source React wrapper for SciChart, we were able to render 100 interactive charts, update thousands or even millions of data-points, and maintain 60 FPS under optimal conditions, all within the browser.

Through this experiment, we explored various performance optimizations, including freezing off-screen charts, enabling native text rendering, caching labels, and reducing axis elements. Each of these techniques significantly improves performance when dealing with large datasets and multiple charts in a single application.

If you're interested in pushing SciChart.js further, check out these resources:

SciChart.js Performance Tips: Learn best practices to optimize rendering performance.
Getting Started with SciChart.js: A step-by-step guide to building high-performance charts.
React Chart Tutorials: Learn how to integrate SciChart.js into React applications with scichart-react.

The source code for this demo is available in the SciChart.JS.Examples GitHub repository under Sandbox/CustomerExamples/DragDropDashboardPerformanceDemo. Clone the repo, experiment with different optimizations, and explore how SciChart.js can elevate your real-time data visualization projects.

For any questions or to share your own SciChart-powered dashboards, join the discussion in the SciChart Forums or reach out to us directly.

Happy coding!

Creating a React Dashboard with SciChart.js, SciChart-React and Deepseek AI

Andrew Bt — Thu, 15 Oct 2026 20:06:32 +0000

In this tutorial, we'll walk through creating a fully interactive, dynamic dashboard in React with SciChart.js in 20 minutes, coding almost entirely with AI. The dashboard features five chart types: a React Line Chart, React Scatter Chart, React Stacked Column Chart, React Mountain Chart and React Pie Chart, arranged in a grid layout. We'll cover how to integrate SciChart.js into a React dashboard using scichart-react, apply a custom theme and position the charts in a consistent layout. By the end, you'll have a fully functional React dashboard you can customise for data visualisation in any domain.

Introduction

Data visualisation is a critical part of modern web applications, helping users understand complex data at a glance. With a powerful React chart library like SciChart.js, developers can create stunning, high-performance visualisations with ease. Combined with React, a popular JavaScript library for building user interfaces and interactive dashboards, the possibilities are endless.

In this tutorial, we'll build a dynamic dashboard that showcases five chart types in a single view. The dashboard is interactive, with tooltips, legends, and zooming and panning so you can inspect data on the fly. We'll also apply SciChart.js's Navy theme for a sleek, professional look.

We'll show the power of generative AI for building this React dashboard layout using Deepseek R1, an open-source competitor to ChatGPT, including the prompts we used and the changes needed to get the dashboard working. The whole tutorial is coded in CodeSandbox.

Key Takeaways

How to integrate SciChart.js into a React application
Creating and customising five chart types: React Line Chart, React Scatter Chart, React Stacked Column Chart, React Mountain Chart and React Pie Chart
Applying a custom theme (Navy theme) to all charts for a cohesive look
Adding legends, zooming, panning and tooltips
The limitations, pros and cons of using AI such as ChatGPT or Deepseek to create React dashboards, and where this technology could go next

Who Is This For?

Frontend developers looking to improve their data visualisation skills
React developers interested in integrating advanced charting libraries
Data enthusiasts who want to build interactive dashboards for data analysis

Getting Started

Creating the Input Prompt

We start by using Deepseek, an open-source competitor to ChatGPT that scores highly in coding benchmarks and runs at a fraction of the cost of OpenAI's solutions.

Here's our first prompt:

Create a dashboard in react with 5 charts using SciChart.js and scichart-react. Each chart should be hosted in a <SciChartReact/> component. initChart should not be inline but be a separate function.

The charts should be arranged in two rows. The first row should have two charts: a line chart (top left) and a scatter chart (top right).

The second row should have three charts: A stacked column chart (bottom left), a Mountain chart (bottom middle) and a pie chart (bottom right). Create some dummy data to upload to the charts and create the dashboard.

Choose the theme SciChartJsNavyTheme to apply to each chart. Do not set any Series Colors or Fill/Stroke on the chart series, as these will be applied automatically by the theme.

Ensure all SciChart type imports are import { A, B, C } from 'scichart'

Deepseek gets straight to work, correctly recommending npm install scichart scichart-react. It then provides JSX output to include in your application.

The first output from Deepseek was good, but slightly incorrect. We'll correct it later. Here's the initial draft of dashboard.jsx in full:

dashboard.jsx version #1 (with errors)

import React from "react";
import {
  SciChartSurface,
  NumericAxis,
  FastLineRenderableSeries,
  XyDataSeries,
  EllipsePointMarker,
  FastScatterRenderableSeries,
  StackedColumnCollection,
  StackedColumnRenderableSeries,
  FastMountainRenderableSeries,
  PieChart,
  PieSegment,
  SciChartJsNavyTheme,
} from "scichart";
import { SciChartReact } from "scichart-react";

// Initialize the line chart
const initLineChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const lineSeries = new FastLineRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 4, 6, 8, 10],
    }),
  });
  sciChartSurface.renderableSeries.add(lineSeries);
  return sciChartSurface;
};

// Initialize the scatter chart
const initScatterChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement,
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const scatterSeries = new FastScatterRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [3, 5, 7, 9, 11],
    }),
    pointMarker: new EllipsePointMarker(wasmContext, { width: 10, height: 10 }),
  });
  sciChartSurface.renderableSeries.add(scatterSeries);
  return sciChartSurface;
};

// Initialize the stacked column chart
const initStackedColumnChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const stackedColumnCollection = new StackedColumnCollection(wasmContext);
  const series1 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 3, 4, 5, 6],
    }),
  });
  const series2 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [1, 2, 3, 4, 5],
    }),
  });
  stackedColumnCollection.add(series1, series2);
  sciChartSurface.renderableSeries.add(stackedColumnCollection);
  return sciChartSurface;
};

// Initialize the mountain chart
const initMountainChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const mountainSeries = new FastMountainRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [5, 4, 3, 2, 1],
    }),
  });
  sciChartSurface.renderableSeries.add(mountainSeries);
  return sciChartSurface;
};

// Initialize the pie chart
const initPieChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const pieChart = new PieChart(wasmContext, {
    segments: [
      new PieSegment({ value: 30, title: "Segment 1" }),
      new PieSegment({ value: 20, title: "Segment 2" }),
      new PieSegment({ value: 50, title: "Segment 3" }),
    ],
  });
  sciChartSurface.renderableSeries.add(pieChart);
  return sciChartSurface;
};

// Dashboard component
const Dashboard = () => {
  return (
    <div style={{ display: "flex", flexDirection: "column", gap: "20px" }}>
      {/* First row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact initChart={initLineChart} 
                 style={{ width: "100%", height: "400px" }} />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact initChart={initScatterChart} 
                 style={{ width: "100%", height: "400px" }} />
        </div>
      </div>

      {/* Second row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact initChart={initStackedColumnChart} 
                 style={{ width: "100%", height: "400px" }} />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact initChart={initMountainChart} 
                 style={{ width: "100%", height: "400px" }} />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact initChart={initPieChart} 
                 style={{ width: "100%", height: "400px" }} />
        </div>
      </div>
    </div>
  );
};

export default Dashboard;

Creating a Project in CodeSandbox

Let's move this into an IDE. For this tutorial we'll use CodeSandbox, which provides a ready-made in-browser IDE with full npm, JavaScript and React support.

On the CodeSandbox homepage, click Create to create a new sandbox.

Choose React (TS) as the template. This creates a new React project with npm and TypeScript or JavaScript support.

In the dependencies section, add scichart and scichart-react. This is equivalent to running npm install scichart scichart-react in your IDE. Your package.json should update as follows:

Next, create a file called dashboard.jsx and paste in the code from the prompt above. Note that the code is incorrect, as AI isn't perfect yet, but we'll make some minor changes to get it compiling.

Now, modify the default App.tsx to contain a <Dashboard/> component:

import "./styles.css";
import Dashboard from "./dashboard";

export default function App() {
  return (
    <div className="App">
      <Dashboard />
    </div>
  );
}

You should see something like this. Promising, but not quite working yet. In the next section we'll work through the errors to get a working React dashboard.

Getting the Dashboard Working

Let's work through the errors.

Error #1: Check types are correct

AI tools such as ChatGPT or Deepseek often make subtle syntax errors. They're trained on the whole internet but may not have specific knowledge of a particular library like SciChart. These are easily fixed with a little knowledge of the library and the SciChart.js documentation.

For example, in dashboard.jsx, FastScatterRenderableSeries is incorrect and should be XyScatterRenderableSeries. Check for other badly imported types or type errors. CodeSandbox highlights syntax errors and offers autocomplete (IntelliSense) for types in the SciChart library.

Error #2: Could not load SciChart WebAssembly module

Could not load SciChart WebAssembly module. Check your build process and ensure that your scichart2d.wasm, scichart2d.data and scichart2d.js files are from the same version

This error occurs because you need to either package the wasm and data files or load them from a CDN. You can find out how in the documentation on deploying Wasm and data files.

Add a call to SciChartSurface.loadWasmFromCDN() at the start of your Dashboard React component:

// Dashboard component
const Dashboard = () => {

  SciChartSurface.loadWasmFromCDN(); // Add this call
  return (
    <div style={{ display: "flex", flexDirection: "column", gap: "20px" }}>
      {/* First row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
        ...

Error #3: _scichart.PieChart is not a constructor

Deepseek got this one completely wrong, but no worries. We can find the real syntax for creating a pie chart in the SciChart JavaScript Pie Chart demo.

Here's the incorrect code from the AI:

// Initialize the pie chart
const initPieChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const pieChart = new PieChart(wasmContext, {
    segments: [
      new PieSegment({ value: 30, title: "Segment 1" }),
      new PieSegment({ value: 20, title: "Segment 2" }),
      new PieSegment({ value: 50, title: "Segment 3" }),
    ],
  });
  sciChartSurface.renderableSeries.add(pieChart);
  return sciChartSurface;
};

And here's the correct code:

const initPieChart = async (rootElement) => {
  const sciChartSurface = await SciChartPieSurface.create(rootElement, {
    theme: new SciChartJsNavyTheme(),
  });
  const pieChartData = [
    { value: 40, text: "Segment 1" },
    { value: 30, text: "Segment 2" },
    { value: 20, text: "Segment 3" },
    { value: 10, text: "Segment 4" },
  ];

  pieChartData.forEach((segment) =>
    sciChartSurface.pieSegments.add(new PieSegment(segment))
  );
  return sciChartSurface;
};

Error #4: "initChart" function should resolve to an object with "sciChartSurface" property ({ sciChartSurface })

This error relates to scichart-react, which expects an initialisation function <SciChartReact initChart={function}/> that returns { sciChartSurface }.

Here's the incorrect code the AI generated for each chart:

// Initialize the line chart
const initLineChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, {
      theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const lineSeries = new FastLineRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 4, 6, 8, 10],
    }),
  });
  sciChartSurface.renderableSeries.add(lineSeries);
  return sciChartSurface; // this line is incorrect, 
  // modify to return { sciChartSurface }
};

And here's how to correct it:

// Initialize the line chart
const initLineChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, {
      theme: new SciChartJsNavyTheme(),
  });
  // ... 
  return { sciChartSurface }; // This is the correct return value
};

Do this for each of the charts.

The Complete React Dashboard

Hurrah! You should now have a working dashboard. It looks a bit bland, but we'll improve it in the next sections.

Here's the working code for dashboard.jsx:

dashboard.jsx version #2 (working dashboard)

import React from "react";
import {
  SciChartSurface,
  NumericAxis,
  FastLineRenderableSeries,
  XyDataSeries,
  EllipsePointMarker,
  XyScatterRenderableSeries,
  StackedColumnCollection,
  StackedColumnRenderableSeries,
  FastMountainRenderableSeries,
  SciChartPieSurface,
  PieSegment,
  SciChartJsNavyTheme,
} from "scichart";
import { SciChartReact } from "scichart-react";

// Initialize the line chart
const initLineChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const lineSeries = new FastLineRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 4, 6, 8, 10],
    }),
  });
  sciChartSurface.renderableSeries.add(lineSeries);
  return { sciChartSurface };
};

// Initialize the scatter chart
const initScatterChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const scatterSeries = new XyScatterRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [3, 5, 7, 9, 11],
    }),
    pointMarker: new EllipsePointMarker(wasmContext, { width: 10, height: 10 }),
  });
  sciChartSurface.renderableSeries.add(scatterSeries);
  return { sciChartSurface };
};

// Initialize the stacked column chart
const initStackedColumnChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const stackedColumnCollection = new StackedColumnCollection(wasmContext);
  const series1 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 3, 4, 5, 6],
    }),
  });
  const series2 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [1, 2, 3, 4, 5],
    }),
  });
  stackedColumnCollection.add(series1, series2);
  sciChartSurface.renderableSeries.add(stackedColumnCollection);
  return { sciChartSurface };
};

// Initialize the mountain chart
const initMountainChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const mountainSeries = new FastMountainRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [5, 4, 3, 2, 1],
    }),
  });
  sciChartSurface.renderableSeries.add(mountainSeries);
  return { sciChartSurface };
};

// Initialize the pie chart
const initPieChart = async (rootElement) => {
  const sciChartSurface = await SciChartPieSurface.create(rootElement, {
    theme: new SciChartJsNavyTheme(),
  });
  const pieChartData = [
    { value: 40, text: "Segment 1" },
    { value: 30, text: "Segment 2" },
    { value: 20, text: "Segment 3" },
    { value: 10, text: "Segment 4" },
  ];

  pieChartData.forEach((segment) =>
    sciChartSurface.pieSegments.add(new PieSegment(segment))
  );
  return { sciChartSurface };
};

// Dashboard component
const Dashboard = () => {
  SciChartSurface.loadWasmFromCDN();
  return (
    <div style={{ display: "flex", flexDirection: "column", gap: "20px" }}>
      {/* First row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initLineChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initScatterChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
      </div>

      {/* Second row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initStackedColumnChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initMountainChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initPieChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
      </div>
    </div>
  );
};

export default Dashboard;

Adding Styles to the React Dashboard

SciChart themes are pretty powerful. SciChartJsNavyTheme contains a set of predefined series colours that look good against the chart background. However, some series default to an unimaginative grey when no colours are set.

Let's use Deepseek again with a new prompt, passing in the working code and requesting the changes:

I've modified the code you created to correct some errors. Namely, FastScatterRenderableSeries should be XyScatterRenderableSeries. initChart functions should return { sciChartSurface }. Pie charts should be created using 'SciChartPieSurface.create'.

Here is my working code which renders a dashboard without errors
// PASTE THE WORKING DASHBOARD.JSX CODE IN HERE
I would like you to modify this code using pleasing pastel colors which work with the background color which is #22365B.

Choose stroke colors from the list #274b92, #47bde6, #ae418d, #e97064, #68bcae

Choose fill colors from the list #274b9288, #47bde688, #ae418d88, #e9706488, #68bcae88

Apply these to the following properties: FastLineRenderableSeries.stroke, FastMountainRenderableSeries.fill, StackedColumnRenderableSeries.stroke and fill, EllipsePointMarker.stroke and fill, PieSegment pass color to the object in the constructor.

Set the background to the body equal a darker shade which matches #22365B.

Because we gave the AI working code, it modifies it straight away without errors. Here's the output dashboard.jsx with styles and colours:

dashboard.jsx version #3 (with styles)

import React from "react";
import {
  SciChartSurface,
  NumericAxis,
  FastLineRenderableSeries,
  XyDataSeries,
  EllipsePointMarker,
  XyScatterRenderableSeries,
  StackedColumnCollection,
  StackedColumnRenderableSeries,
  FastMountainRenderableSeries,
  SciChartPieSurface,
  PieSegment,
  SciChartJsNavyTheme,
} from "scichart";
import { SciChartReact } from "scichart-react";

// Define pastel colors
const strokeColors = ["#274b92", "#47bde6", "#ae418d", "#e97064", "#68bcae"];
const fillColors = ["#274b9288", "#47bde688", "#ae418d88", "#e9706488", "#68bcae88"];

// Initialize the line chart
const initLineChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const lineSeries = new FastLineRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 4, 6, 8, 10],
    }),
    stroke: strokeColors[0], // Apply stroke color
  });
  sciChartSurface.renderableSeries.add(lineSeries);
  return { sciChartSurface };
};

// Initialize the scatter chart
const initScatterChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const scatterSeries = new XyScatterRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [3, 5, 7, 9, 11],
    }),
    pointMarker: new EllipsePointMarker(wasmContext, {
      width: 10,
      height: 10,
      stroke: strokeColors[1], // Apply stroke color
      fill: fillColors[1], // Apply fill color
    }),
  });
  sciChartSurface.renderableSeries.add(scatterSeries);
  return { sciChartSurface };
};

// Initialize the stacked column chart
const initStackedColumnChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const stackedColumnCollection = new StackedColumnCollection(wasmContext);
  const series1 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 3, 4, 5, 6],
    }),
    stroke: strokeColors[2], // Apply stroke color
    fill: fillColors[2], // Apply fill color
  });
  const series2 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [1, 2, 3, 4, 5],
    }),
    stroke: strokeColors[3], // Apply stroke color
    fill: fillColors[3], // Apply fill color
  });
  stackedColumnCollection.add(series1, series2);
  sciChartSurface.renderableSeries.add(stackedColumnCollection);
  return { sciChartSurface };
};

// Initialize the mountain chart
const initMountainChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, 
  {
    theme: new SciChartJsNavyTheme(),
  });
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const mountainSeries = new FastMountainRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [5, 4, 3, 2, 1],
    }),
    fill: fillColors[4], // Apply fill color
  });
  sciChartSurface.renderableSeries.add(mountainSeries);
  return { sciChartSurface };
};

// Initialize the pie chart
const initPieChart = async (rootElement) => {
  const sciChartSurface = await SciChartPieSurface.create(rootElement, {
    theme: new SciChartJsNavyTheme(),
  });
  const pieChartData = [
    { value: 40, text: "Segment 1", color: strokeColors[0] },
    { value: 30, text: "Segment 2", color: strokeColors[1] },
    { value: 20, text: "Segment 3", color: strokeColors[2] },
    { value: 10, text: "Segment 4", color: strokeColors[3] },
  ];

  pieChartData.forEach((segment) =>
    sciChartSurface.pieSegments.add(new PieSegment(segment))
  );
  return { sciChartSurface };
};

// Dashboard component
const Dashboard = () => {
  SciChartSurface.loadWasmFromCDN();
  return (
    <div style={{ display: "flex", flexDirection: "column", gap: "20px", 
               backgroundColor: "#1a2a4a", padding: "20px" }}>
      {/* First row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initLineChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initScatterChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
      </div>

      {/* Second row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initStackedColumnChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initMountainChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initPieChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
      </div>
    </div>
  );
};

export default Dashboard;

This is looking a lot better!

Adding a Legend and Tooltips

The AI chat history should now contain working code. If it doesn't, fix the code and include it in your prompt.

Next, we'll add a legend and tooltips to the charts. This is actually pretty easy to do by hand, but it's a good way to show the power of generative AI tools like ChatGPT or Deepseek for modifying code.

Start a new prompt:

Here is my current working code which renders a dashboard without errors:
// PASTE YOUR CURRENT WORKING CODE HERE
Modify this code as follows.

For each SciChartSurface which is not a SciChartPieSurface, add a Legend using the LegendModifier

For each XyDataSeries, set the dataSeriesName property to a dummy string.

For each SciChartSurface which is not a SciChartPieSurface, add a Tooltip using the RolloverModifier. set showRolloverLine: true and showTooltip: true

For each SciChartSurface which is not a SciChartPieSurface, add mouse wheel, zoompan and zoom extents modifiers

Deepseek gets straight to work and outputs some new code:

Let's update dashboard.jsx with the new code:

Final dashboard.jsx version #4 (with tooltips, legends and zooming)

import React from "react";
import {
  SciChartSurface,
  NumericAxis,
  FastLineRenderableSeries,
  XyDataSeries,
  EllipsePointMarker,
  XyScatterRenderableSeries,
  StackedColumnCollection,
  StackedColumnRenderableSeries,
  FastMountainRenderableSeries,
  SciChartPieSurface,
  PieSegment,
  SciChartJsNavyTheme,
  LegendModifier,
  RolloverModifier,
  MouseWheelZoomModifier,
  ZoomPanModifier,
  ZoomExtentsModifier,
} from "scichart";
import { SciChartReact } from "scichart-react";

// Define pastel colors
const strokeColors = ["#274b92", "#47bde6", "#ae418d", "#e97064", "#68bcae"];
const fillColors = [
  "#274b9288",
  "#47bde688",
  "#ae418d88",
  "#e9706488",
  "#68bcae88",
];

// Initialize the line chart
const initLineChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const lineSeries = new FastLineRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 4, 6, 8, 10],
      dataSeriesName: "Line Series", // Set dataSeriesName
    }),
    stroke: strokeColors[0], // Apply stroke color
  });
  sciChartSurface.renderableSeries.add(lineSeries);

  // Add modifiers
  sciChartSurface.chartModifiers.add(new LegendModifier());
  sciChartSurface.chartModifiers.add(
    new RolloverModifier({ showRolloverLine: true, showTooltip: true })
  );
  sciChartSurface.chartModifiers.add(new MouseWheelZoomModifier());
  sciChartSurface.chartModifiers.add(new ZoomPanModifier());
  sciChartSurface.chartModifiers.add(new ZoomExtentsModifier());

  return { sciChartSurface };
};

// Initialize the scatter chart
const initScatterChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const scatterSeries = new XyScatterRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [3, 5, 7, 9, 11],
      dataSeriesName: "Scatter Series", // Set dataSeriesName
    }),
    pointMarker: new EllipsePointMarker(wasmContext, {
      width: 10,
      height: 10,
      stroke: strokeColors[1], // Apply stroke color
      fill: fillColors[1], // Apply fill color
    }),
  });
  sciChartSurface.renderableSeries.add(scatterSeries);

  // Add modifiers
  sciChartSurface.chartModifiers.add(new LegendModifier());
  sciChartSurface.chartModifiers.add(
    new RolloverModifier({ showRolloverLine: true, showTooltip: true })
  );
  sciChartSurface.chartModifiers.add(new MouseWheelZoomModifier());
  sciChartSurface.chartModifiers.add(new ZoomPanModifier());
  sciChartSurface.chartModifiers.add(new ZoomExtentsModifier());

  return { sciChartSurface };
};

// Initialize the stacked column chart
const initStackedColumnChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const stackedColumnCollection = new StackedColumnCollection(wasmContext);
  const series1 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [2, 3, 4, 5, 6],
      dataSeriesName: "Stacked Column Series 1", // Set dataSeriesName
    }),
    stroke: strokeColors[2], // Apply stroke color
    fill: fillColors[2], // Apply fill color
  });
  const series2 = new StackedColumnRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [1, 2, 3, 4, 5],
      dataSeriesName: "Stacked Column Series 2", // Set dataSeriesName
    }),
    stroke: strokeColors[3], // Apply stroke color
    fill: fillColors[3], // Apply fill color
  });
  stackedColumnCollection.add(series1, series2);
  sciChartSurface.renderableSeries.add(stackedColumnCollection);

  // Add modifiers
  sciChartSurface.chartModifiers.add(new LegendModifier());
  sciChartSurface.chartModifiers.add(
    new RolloverModifier({ showRolloverLine: true, showTooltip: true })
  );
  sciChartSurface.chartModifiers.add(new MouseWheelZoomModifier());
  sciChartSurface.chartModifiers.add(new ZoomPanModifier());
  sciChartSurface.chartModifiers.add(new ZoomExtentsModifier());

  return { sciChartSurface };
};

// Initialize the mountain chart
const initMountainChart = async (rootElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(
    rootElement,
    {
      theme: new SciChartJsNavyTheme(),
    }
  );
  const xAxis = new NumericAxis(wasmContext);
  const yAxis = new NumericAxis(wasmContext);
  sciChartSurface.xAxes.add(xAxis);
  sciChartSurface.yAxes.add(yAxis);

  const mountainSeries = new FastMountainRenderableSeries(wasmContext, {
    dataSeries: new XyDataSeries(wasmContext, {
      xValues: [1, 2, 3, 4, 5],
      yValues: [5, 4, 3, 2, 1],
      dataSeriesName: "Mountain Series", // Set dataSeriesName
    }),
    fill: fillColors[4], // Apply fill color
  });
  sciChartSurface.renderableSeries.add(mountainSeries);

  // Add modifiers
  sciChartSurface.chartModifiers.add(new LegendModifier());
  sciChartSurface.chartModifiers.add(
    new RolloverModifier({ showRolloverLine: true, showTooltip: true })
  );
  sciChartSurface.chartModifiers.add(new MouseWheelZoomModifier());
  sciChartSurface.chartModifiers.add(new ZoomPanModifier());
  sciChartSurface.chartModifiers.add(new ZoomExtentsModifier());

  return { sciChartSurface };
};

// Initialize the pie chart
const initPieChart = async (rootElement) => {
  const sciChartSurface = await SciChartPieSurface.create(rootElement, {
    theme: new SciChartJsNavyTheme(),
  });
  const pieChartData = [
    { value: 40, text: "Segment 1", color: strokeColors[0] },
    { value: 30, text: "Segment 2", color: strokeColors[1] },
    { value: 20, text: "Segment 3", color: strokeColors[2] },
    { value: 10, text: "Segment 4", color: strokeColors[3] },
  ];

  pieChartData.forEach((segment) =>
    sciChartSurface.pieSegments.add(new PieSegment(segment))
  );

  return { sciChartSurface };
};

// Dashboard component
const Dashboard = () => {
  SciChartSurface.loadWasmFromCDN();
  return (
    <div
      style={{
        display: "flex",
        flexDirection: "column",
        gap: "20px",
        backgroundColor: "#1a2a4a",
        padding: "20px",
      }}
    >
      {/* First row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initLineChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initScatterChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
      </div>

      {/* Second row */}
      <div style={{ display: "flex", gap: "20px" }}>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initStackedColumnChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initMountainChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
        <div style={{ flex: 1 }}>
          <SciChartReact
            initChart={initPieChart}
            style={{ width: "100%", height: "400px" }}
          />
        </div>
      </div>
    </div>
  );
};

export default Dashboard;

Here's the (almost final) dashboard with legends, tooltips and zooming interactions:

Final Tweaks to the Dashboard

There's a little tweaking left, but the code works. If you hover over the charts, you'll notice some tooltips are very bright with white text that can't be read.

This is because the RolloverModifier uses RenderableSeries.stroke as the tooltip container colour by default, and the container text is always white.

You can change this with the RenderableSeries.rolloverModifierProps property, which lets you set tooltip styles per series.

Adjust the code one last time:

// Initialize the scatter chart
const initScatterChart = async (rootElement) => {
  // ... 
  // after the declaration of scatterSeries, set rollover props

  scatterSeries.rolloverModifierProps.tooltipTextColor = "#333";
  // ...
}


// Initialize the mountain chart
const initMountainChart = async (rootElement) => {
  // ... 
  // after the declaration of mountainSeries, set rollover props

  mountainSeries.rolloverModifierProps.tooltipTextColor = "#333";
  // ...
}

That should be it! Here's the final working dashboard with a React line chart, scatter chart, stacked column chart, mountain chart and pie chart:

And here's the CodeSandbox. To edit it in your browser, click Open Sandbox and create your own fork.

Conclusion

How the Final React Dashboard Works

The code in this tutorial creates a dashboard with multiple SciChart visualisations using React. Here's how it breaks down:

Imports & setup
- Imports the necessary SciChart components (chart types, axes, series, modifiers)
- Defines colour palettes for consistent styling
- Uses the SciChartReact wrapper component for React integration and correct component lifecycle
Chart initialisation functions. Each chart type has its own initialisation function that:
- Creates a SciChartSurface with a dark theme
- Adds X/Y axes
- Configures data series and visual styling
- Adds interactive features (zoom, pan, legend, tooltips)
- Returns the chart surface for React to manage
Chart types demonstrated
- Line chart: a simple line graph with FastLineRenderableSeries
- Scatter plot: uses XyScatterRenderableSeries with circular markers
- Stacked columns: multiple column series combined in a StackedColumnCollection
- Mountain chart: an area chart using FastMountainRenderableSeries
- Pie chart: created with SciChartPieSurface and PieSegment
Interactive features (via chart modifiers)
- LegendModifier: shows the data series legend
- RolloverModifier: tooltips on hover
- MouseWheelZoomModifier: zoom with the scroll wheel
- ZoomPanModifier: drag to pan
- ZoomExtentsModifier: double-click to reset zoom
Dashboard layout
- Uses flexbox for a responsive grid layout
- The first row has 2 charts (line and scatter)
- The second row has 3 charts (stacked columns, mountain and pie)
- Each chart is wrapped in a SciChartReact component with its initialisation function
Key React-SciChart integration
- SciChartReact handles the component lifecycle (mount/unmount)
- The initChart prop passes in the initialisation function
- The WASM library is loaded once from CDN using loadWasmFromCDN()
Styling
- A consistent navy theme across all charts
- A pastel colour palette defined at the top
- Responsive sizing using percentage-based dimensions
- A dark background container for the dashboard

The result is a responsive dashboard with five chart types, interactive features (zoom, tooltips, panning), consistent theming and styling, and efficient React integration with SciChart's WebAssembly rendering.

From here, you can modify the data series values and format, adjust styling through the colour arrays and chart properties, rearrange the layout, add or remove chart modifiers, or create new chart types using different renderable series.

Remember that SciChart requires WebAssembly (WASM), which is why we use async initialisation and the loadWasmFromCDN() call.

Further Work

What else could you do with this? Here are some ideas to explore, both with generative AI and by working through the SciChart documentation:

Experiment with hover behaviours and on-select drilldowns using the SeriesSelectionModifier
Add grid splitters between the charts and enable dynamic, responsive dashboards for mobile as well as web
Experiment with dynamic data and real-time updates, an area where SciChart excels

Final Comments on Deepseek and Generative AI

Generative AI has come a long way since ChatGPT first launched in late 2022. It's now a competent coder that understands complex concepts and can develop dashboards rapidly with libraries like SciChart.js and scichart-react.

While the code it produces isn't perfect and does contain errors, a competent developer combined with SciChart's solid documentation and examples can write code quickly and make rapid progress on applications.

Where to Learn More

React Charts (TanStack) vs. SciChart: Which Is the Best React Chart Library?

Andrew Bt — Thu, 15 Oct 2026 20:02:46 +0000

Choosing the right chart library is crucial for modern data-driven applications. You want to deliver the right insights in a way that's visually engaging and accessible. You also want your developers to be able to navigate the platform effortlessly to support faster implementation. From real-time performance to responsive debugging support and security updates, all of this should feed into your decision when choosing the best React chart library for your use case.

An effective way to choose is to compare the market leaders and popular chart libraries.

Two popular solutions are React Charts (TanStack) and SciChart. This guide compares the features, performance and support that both React chart libraries offer, so you can choose the right one for your developers and data visualisation projects. We'll also share a direct visualisation comparison with our developer's insights into the differences in usability and performance.

Let's start with a look at the rendering engine, performance, chart types and suitable use cases for each library.

Feature Comparison of SciChart & TanStack

The table below compares features, performance, customisation capabilities and use cases.

	React Charts (TanStack)	SciChart
Rendering Engine	D3	In-house developed, GPU-accelerated
Performance	Handles between 1,000 and 10,000 data points with 60 fps interactions	Displays millions of data points in real time
Chart Types	Many variations of X/Y charts, including line, area, bar, column and bubble charts	Over 100 React chart examples covering variations of over 30 2D and 3D chart types
Customisation	Simple customisations such as tooltips, labels and annotations	The PaletteProvider API and CustomModifier give almost endless customisation and interactivity options
Use Cases	Simpler charts that don't need huge, complex datasets processed in real time	The most demanding data projects, from complex big data across multiple streams to real-time visualisation of millions of data points. Used by all the top F1 racing teams, 90% of the leading MedTech companies and over half of Fortune 500 companies in aerospace and defence

TanStack's main selling point is the ability to create React charts with zero SVG knowledge required. They describe themselves as a solution for simple, immersive and interactive charts for React.

TanStack uses the D3 rendering engine to provide some styling customisations, whereas SciChart uses a custom-built, GPU-accelerated rendering engine for superior real-time performance.

Performance & Scalability

▶️ Watch the JavaScript Chart Library Performance Demo

For applications that require real-time updates (e.g. stock trading apps), performance is non-negotiable. SciChart delivers exceptional real-time performance for thousands, or even millions, of data points. In comparison, because TanStack is powered by D3, it comfortably handles far less data.

Using SVG charts with TanStack, you can expect to process around 1,000 data points. You can boost this to 10,000 data points with Canvas, but that still falls well short of what SciChart can process.

Security of Your Data

Security is another consideration. An open-source React chart library may not be updated as often as a paid one such as SciChart. This can leave open-source solutions vulnerable to bugs or incompatibility issues, and it reduces the competitiveness of what you're offering end users.

Many user questions go unanswered on open-source libraries, whereas SciChart offers a responsive support service. A ticket-based system means issues are better organised and prioritised, and they won't get lost. By SciChart's standards, responsive means you should receive a reply within one business day, or even faster. This service is available to paying customers and helps developers work through issues with big data visualisations while accelerating development.

Ease of Use & Developer Experience

TanStack offers a "try in 60 seconds" feature that lets developers quickly trial a code example to see how it runs.

SciChart has a little more to the installation process, as it isn't open-source. But there are straightforward step-by-step guides, APIs and examples. In fact, we offer hundreds of demos and documentation pages that make building the chart you need much easier, along with actively updated community forums.

Pricing & Licensing

TanStack is open-source, meaning it's free.

SciChart offers a free community version that includes all the functionality, features and performance for non-commercial use, though charts will carry a watermark. To get a taste of what SciChart offers and compare it with open-source chart libraries, it's worth trialling SciChart for free.

If there's an ROI consideration or a specific outcome to achieve, you may find SciChart is the only one of the two that can deliver.

Paid users can use SciChart in commercial applications, and all charts are free of watermarks.

The price of a SciChart licence depends on how many developers you need to supply and which platforms and additional support you'd like to include.

This might look like a significant upfront cost, but developer time is also worth a lot of money. That's where ROI comes in:

Cost of developer time: $75/hour ($600 per day)
Cost of a SciChart licence: approx. $1,699 for SciChart WPF 2D Professional
Only 3 developer days need to be saved in a year before SciChart pays for itself

Use Case Recommendations

TanStack React Charts, being relatively simple, is well suited to use cases that don't demand high interactivity or complex data visualisation, such as basic dashboards and reporting tools.

SciChart's high-performance capabilities make it ideal for complex visualisations and large datasets. It's particularly suited to applications that need real-time updates or have demanding performance needs, such as financial applications, scientific data analysis and engineering simulations.

The choice ultimately depends on your project's requirements. Simpler applications may only need TanStack React Charts, while more complex ones with higher performance needs will benefit from SciChart.

Creating a Real-Time JavaScript Chart with SciChart.js and React Charts TanStack

To show the difference, we created a simple real-time performance demo using both SciChart.js and React Charts TanStack, and shared our verdict.

Setting Up a New React Project

First, we set up a new project. A recommended setup is React, Webpack and TypeScript.

package.json

{
  "name": "scichart-reactcharts",
  "version": "1.0.0",
  "description": "scichart vs react charts tanstack",
  "main": "src/index.tsx",
  "scripts": {
    "build": "webpack --mode production",
    "start": "ts-node server",
    "dev": "webpack-dev-server --mode development"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "react": "^19.0.0",
    "react-charts": "^3.0.0-beta.57",
    "react-dom": "^19.0.0",
    "scichart": "^3.5.742",
    "ts-node": "^10.9.2"
  },
  "devDependencies": {
    "@types/react": "^19.0.10",
    "@types/react-dom": "^19.0.4",
    "copy-webpack-plugin": "^13.0.0",
    "prettier": "^3.5.3",
    "ts-loader": "^9.5.2",
    "typescript": "^5.8.2",
    "webpack": "^5.98.0",
    "webpack-cli": "^6.0.1",
    "webpack-dev-server": "^5.2.0"
  }
}

webpack.config.js

const path = require("path");
const CopyPlugin = require("copy-webpack-plugin");

module.exports = {
  entry: "./src/index.tsx",
  performance: {
    hints: false,
  },
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        use: "ts-loader",
        exclude: /node_modules/,
      },
    ],
  },
  resolve: {
    extensions: [".js", ".ts", ".tsx"],
  },
  output: {
    filename: "bundle.js",
    path: path.resolve(__dirname, "build"),
  },
  plugins: [
    new CopyPlugin({
      patterns: [
        { from: "src/index.html", to: "" },
        { from: "node_modules/scichart/_wasm/scichart2d.data", to: "" },
        { from: "node_modules/scichart/_wasm/scichart2d.wasm", to: "" },
        { from: "node_modules/scichart/_wasm/scichart3d.data", to: "" },
        { from: "node_modules/scichart/_wasm/scichart3d.wasm", to: "" },
      ],
    }),
  ],
};

tsconfig.json

{
  "compilerOptions": {
    "outDir": "./build",
    "sourceMap": true,
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": false,
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "strictPropertyInitialization": false,
    "noImplicitThis": true,
    "alwaysStrict": true,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "module": "commonjs",
    "target": "es6",
    "jsx": "react-jsx",
    "allowJs": true,
    "typeRoots": ["./src/types", "./node_modules/@types"],
    "esModuleInterop": true,
    "skipLibCheck": false,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

index.html

<html lang="en-us">
  <head>
    <meta charset="utf-8" />
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
    <title>SciChart and React Charts Tanstack</title>
    <script async type="text/javascript" src="bundle.js"></script>
  </head>
  <body></body>
</html>

index.tsx

import { createRoot } from "react-dom/client";
import App from "./App";

// Clear the existing HTML content
document.body.innerHTML = '<div id="app"></div>';

const root = createRoot(document.getElementById("app"));
root.render(<App />);

Create a Real-Time Demo with React Charts TanStack

Let's create a demo that draws three random walk line charts in real time. For random walk generation, we'll use this class:

RandomWalkGenerator.ts

export class RandomWalkGenerator {
  private readonly bias: number;
  private last: number;
  private i: number;
  private _seed: number;

  constructor(bias: number = 0.01) {
    this.bias = bias;
    this.reset();
  }

  public Seed(seed: number) {
    this._seed = seed % 2147483647;
    if (this._seed <= 0) this._seed += 2147483646;
    return this;
  }

  public reset() {
    this.i = 0;
    this.last = 0;
  }

  public getRandomWalkSeries(count: number): { xValues: number[]; yValues: number[] } {
    const xValues: number[] = [];
    const yValues: number[] = [];
    const random = () =>
      this._seed === undefined ? Math.random() : (this.nextSeeded() - 1) / 2147483646;
    for (let i = 0; i < count; i++) {
      const next: number = this.last + (random() - 0.5 + this.bias);
      xValues.push(this.i++);
      yValues.push(next);
      this.last = next;
    }

    return { xValues, yValues };
  }

  private nextSeeded() {
    return (this._seed = (this._seed * 16807) % 2147483647);
  }
}

We'll append 100 data points to each data series every 20 milliseconds, which makes the charts render at 50 frames per second (FPS). We'll keep appending until we reach 10,000 points, and measure how long it takes to render them all.

This is the ReactChartsDemo component we'll use to render the real-time demo with the React Charts TanStack JavaScript library. The React Charts TanStack API is very intuitive and supports TypeScript, which makes the demo easy to build.

ReactChartsDemo.tsx

import { useMemo, useState, useEffect, useRef } from "react";
import { AxisOptions, Chart } from "react-charts";
import { RandomWalkGenerator } from "../RandomWalkGenerator";

type TDataPoint = {
  x: number;
  y: number;
};

type TSeries = {
  label: string;
  data: TDataPoint[];
};

const initialDataSeries: TSeries[] = [
  { label: "Series 1", data: [] },
  { label: "Series 2", data: [] },
  { label: "Series 3", data: [] },
];

const numberOfPointsPerTimerTick = 100; // 100 points are appended every timer tick
const timerInterval = 20; // the timer ticks every 20 milliseconds (equivalent to 50 FPS)
const maxPoints = 10000; // max points for a single series before the demo stops

let perfStart: number;
let perfEnd: number;

export default function ReactChartsDemo() {
  const timerIdRef = useRef<NodeJS.Timeout>(null);
  const [dataSeries, setDataSeries] = useState(initialDataSeries);
  const [timeElapsed, setTimeElapsed] = useState("");

  const primaryAxis = useMemo(
    (): AxisOptions<TDataPoint> => ({
      getValue: (datum) => datum.x,
      scaleType: "linear",
    }),
    []
  );

  const secondaryAxes = useMemo(
    (): AxisOptions<TDataPoint>[] => [
      {
        getValue: (datum) => datum.y,
        scaleType: "linear",
      },
    ],
    []
  );

  useEffect(() => {
    const randomWalkGenerators = [1, 2, 3].map((_) => {
      return new RandomWalkGenerator(0);
    });
    const stopUpdate = () => {
      clearTimeout(timerIdRef.current);
      timerIdRef.current = undefined;
      randomWalkGenerators.forEach((rw) => rw.reset());
    };
    const updateFunc = () => {
      if (initialDataSeries[0].data.length >= maxPoints) {
        perfEnd = performance.now();
        setTimeElapsed(`${((perfEnd - perfStart) / 1000).toFixed(2)} seconds`);

        stopUpdate();
        return;
      }

      randomWalkGenerators.forEach((randomWalk, index) => {
        // Get the next N random walk x,y values
        const { xValues, yValues } = randomWalk.getRandomWalkSeries(numberOfPointsPerTimerTick);
        for (let i = 0; i < numberOfPointsPerTimerTick; i++) {
          const x = xValues[i];
          const y = yValues[i];
          initialDataSeries[index].data.push({ x, y });
        }
      });
      setDataSeries([...dataSeries]);
      timerIdRef.current = setTimeout(updateFunc, timerInterval);
    };
    const startUpdate = () => {
      if (timerIdRef.current) {
        stopUpdate();
      }
      perfStart = performance.now();
      timerIdRef.current = setTimeout(updateFunc, timerInterval);
    };
    startUpdate();
  }, []);

  return (
    <div>
      <div style={{ width: 800, height: 533 }}>
        <Chart
          options={{
            data: dataSeries,
            primaryAxis,
            secondaryAxes,
            initialWidth: 800,
            initialHeight: 533.33,
          }}
        />
      </div>
      <p>Time elapsed: {timeElapsed}</p>
    </div>
  );
}

The result is a chart that works fine for the first 1,000 points. After that it slows down, taking 53 seconds to render the full 10,000-point dataset, when the expected time at 50 FPS with 100 points per tick is 2 seconds.

React Charts TanStack 10,000 Points Demo

Create the Real-Time Demo with SciChart.js

Now we'll create the same chart using the hardware-accelerated SciChart.js data visualisation library, with the same random walk generator class.

We'll create two files: createChart.ts with the charting code, and SciChartDemo.tsx with the React code.

createChart.ts

import {
  EAutoRange,
  EAxisAlignment,
  EColor,
  EDragMode,
  FastLineRenderableSeries,
  MouseWheelZoomModifier,
  NumericAxis,
  RubberBandXyZoomModifier,
  SciChartSurface,
  XAxisDragModifier,
  XyDataSeries,
  YAxisDragModifier,
  ZoomExtentsModifier,
} from "scichart";
import { RandomWalkGenerator } from "../RandomWalkGenerator";

const numberOfPointsPerTimerTick = 100; // 100 points are appended every timer tick
const timerInterval = 20; // the timer ticks every 20 milliseconds (equivalent to 50 FPS)
const maxPoints = 10000; // max points for a single series before the demo stops

let perfStart: number;
let perfEnd: number;

export const createChart = async (rootElement: string | HTMLDivElement) => {
  const { wasmContext, sciChartSurface } = await SciChartSurface.createSingle(rootElement);

  // Create an XAxis and YAxis with autoRange=Always
  const xAxis = new NumericAxis(wasmContext, { autoRange: EAutoRange.Always });
  sciChartSurface.xAxes.add(xAxis);
  const yAxis = new NumericAxis(wasmContext, {
    autoRange: EAutoRange.Always,
    axisAlignment: EAxisAlignment.Left,
  });
  sciChartSurface.yAxes.add(yAxis);

  // Create some DataSeries
  const dataSeries: XyDataSeries[] = [
    new XyDataSeries(wasmContext, { containsNaN: false, isSorted: true }),
    new XyDataSeries(wasmContext, { containsNaN: false, isSorted: true }),
    new XyDataSeries(wasmContext, { containsNaN: false, isSorted: true }),
  ];

  const seriesColors = [EColor.Blue, EColor.Orange, EColor.Purple];

  // Create some FastLineRenderableSeries bound to each dataSeries and add to the chart
  dataSeries.map((ds, index) => {
    sciChartSurface.renderableSeries.add(
      new FastLineRenderableSeries(wasmContext, {
        dataSeries: ds,
        strokeThickness: 2,
        stroke: seriesColors[index],
      })
    );
  });

  // Add some interactivity modifiers. These are only operational when the demo is paused
  // as interactivity conflicts with AutoRange.Always
  sciChartSurface.chartModifiers.add(
    new RubberBandXyZoomModifier(),
    new MouseWheelZoomModifier(),
    new XAxisDragModifier({ dragMode: EDragMode.Panning }),
    new YAxisDragModifier({ dragMode: EDragMode.Panning }),
    new ZoomExtentsModifier()
  );

  // This class generates some data for our example
  // It generates a random walk, which is a line which increases or decreases by a random value
  // each data-point
  const randomWalkGenerators = [1, 2, 3].map((_) => {
    return new RandomWalkGenerator(0);
  });

  let timerId: NodeJS.Timeout;

  // Function called when the user clicks stopUpdate button
  const stopUpdate = () => {
    clearTimeout(timerId);
    timerId = undefined;
    randomWalkGenerators.forEach((rw) => rw.reset());
    // Disable autoranging on X when the demo is paused. This allows zooming and panning
    xAxis.autoRange = EAutoRange.Once;
  };

  const updateFunc = (setTimeElapsedFn: (v: string) => void) => {
    if (dataSeries[0].count() >= maxPoints) {
      perfEnd = performance.now();
      setTimeElapsedFn(`${((perfEnd - perfStart) / 1000).toFixed(2)} seconds`);
      stopUpdate();
      return;
    }

    randomWalkGenerators.forEach((randomWalk, index) => {
      // Get the next N random walk x,y values
      const { xValues, yValues } = randomWalk.getRandomWalkSeries(numberOfPointsPerTimerTick);

      // Append these to the dataSeries. This will cause the chart to redraw
      dataSeries[index].appendRange(xValues, yValues);
    });

    timerId = setTimeout(() => updateFunc(setTimeElapsedFn), timerInterval);
  };

  // Function called when the user clicks startUpdate button
  const startUpdate = (setTimeElapsedFn: (v: string) => void) => {
    if (timerId) {
      stopUpdate();
    }

    // Enable autoranging on X when running the demo
    xAxis.autoRange = EAutoRange.Always;
    dataSeries.forEach((ds) => ds.clear());
    perfStart = performance.now();
    timerId = setTimeout(() => updateFunc(setTimeElapsedFn), timerInterval);
  };

  let lastRendered = Date.now();
  sciChartSurface.rendered.subscribe(() => {
    const currentTime = Date.now();
    const timeDiffSeconds = new Date(currentTime - lastRendered).getTime() / 1000;
    lastRendered = currentTime;
    const fps = 1 / timeDiffSeconds;
    const renderStats = {
      numberPoints:
        sciChartSurface.renderableSeries.size() *
        sciChartSurface.renderableSeries.get(0).dataSeries.count(),
      fps,
    };
  });

  return { wasmContext, sciChartSurface, controls: { startUpdate, stopUpdate } };
};

SciChartDemo.tsx

import { useEffect, useState, useRef } from "react";
import { SciChartSurface } from "scichart";
import { createChart } from "./createChart";

export default function SciChartDemo() {
  const chartId = "chartId";
  const chartRef = useRef<SciChartSurface>(undefined);
  const [timeElapsed, setTimeElapsed] = useState("");

  useEffect(() => {
    (async () => {
      const { sciChartSurface, controls } = await createChart(chartId);
      chartRef.current = sciChartSurface;
      controls.startUpdate(setTimeElapsed);
    })();
    return () => chartRef.current?.delete();
  }, []);

  return (
    <div>
      <div id={chartId} />
      <p>Time elapsed: {timeElapsed}</p>
    </div>
  );
}

As you can see, the SciChart.js example contains more code than the React Charts TanStack one. But on top of the basic functionality, we added chart modifiers so the chart is interactive once the demo finishes, letting you zoom in, zoom out and pan:

sciChartSurface.chartModifiers.add(
  new RubberBandXyZoomModifier(),
  new MouseWheelZoomModifier(),
  new XAxisDragModifier({ dragMode: EDragMode.Panning }),
  new YAxisDragModifier({ dragMode: EDragMode.Panning }),
  new ZoomExtentsModifier()
);

We also made some performance optimisations. Setting containsNaN: false and isSorted: true tells the engine it can use binary search and skip null checks:

const dataSeries: XyDataSeries[] = [
  new XyDataSeries(wasmContext, { containsNaN: false, isSorted: true }),
  new XyDataSeries(wasmContext, { containsNaN: false, isSorted: true }),
  new XyDataSeries(wasmContext, { containsNaN: false, isSorted: true }),
];

The result is a real-time chart that renders at almost 50 FPS. To be precise, we got 100 frames / 2.28 seconds = 43.85 FPS.

SciChart 10,000 Points Demo

SciChart.js vs React Charts TanStack: The Final Verdict

We created a real-time performance demo with both React Charts TanStack and SciChart.js. React Charts TanStack achieved about 2 FPS, while SciChart.js reached more than 40 FPS. That's no surprise, given React Charts TanStack uses SVG and SciChart.js uses a WebGL canvas.

React Charts TanStack has a nice API and is a good solution if you don't need real-time charts or to visualise large numbers of data points. SciChart.js is a little more verbose, but it allows fine-tuning and stands out for performance.

When working with large numbers of data points or needing real-time performance, the right choice is a hardware-accelerated charting library like SciChart.js.

Developer note: Don't run both examples on the same page at once. Because JavaScript is single-threaded, you'll get the worst of both results.

👉 View the source code on GitHub

Which React Chart Library Is Best for You?

For simpler applications, React Charts are suitable. For big data handling, demanding performance requirements, pioneering insights and enhanced customisation, SciChart is the one you want.

Remember, SciChart provides a free community version that gives you all the performance and visual customisation of the paid version. It's a great way to see what SciChart offers and compare it with open-source chart libraries.

Find out how we can help your development team build exceptional, high-performance React data visualisations from scratch. Our hardware-accelerated graphics engine renders tens of millions of data points with real-time updates, with plenty of customisation options to create exactly the visualisations your React charting project needs.

👉 Discover the SciChart React Chart Library

How to Create a Donut Chart in React: A Step-by-Step Guide with SciChart

Andrew Bt — Thu, 15 Oct 2026 19:50:43 +0000

Donut charts are a well-known, accessible and visually appealing way to visualise data insights. They may be considered a more basic chart, but they can fuel top-level business and marketing decisions, making them an integral feature for data dashboards.

If you want to know how to create a donut chart in React that's suitable for high-level decision-makers, we'll show you how to do exactly that using SciChart.js. We'll also focus on how to customise and add interactive elements to engage your end users and tailor the design to your branding.

Business Benefits of a React Donut Chart

Some prefer the donut chart over the pie chart thanks to its more minimal, less crowded data visualisation. You also have the option to overlay one chart on top of the other for the ultimate space-saving solution on your data dashboard.

With a responsive React chart library, the data will automatically update the React donut chart whenever new information is received. That means your dashboard will always be up to date and won't need to be manually tweaked every time the numbers change.

React donut charts are best suited to small datasets. They are ideal for comparing between two and six categories to avoid overloading the display. With the right chart library, you can tap into the true power of a React donut chart with minimal development time.

The high-level insights you can gain with minimal effort go a long way, so here is a sample of business use cases to help visualise the possibilities.

Example Business Use Cases of Donut Charts

Customer Demographics: By visualising the number of customers per country, businesses can better understand where their main customer base is and where to target their marketing efforts.

Customer Segmentation: By separating customers based on whether they are new or returning, your marketing team can be informed on how best to split their marketing budget.

Sales Distribution: A go-to chart for business and marketing reports, it's a quick way to show directors and stakeholders in a board meeting which product categories are driving the most sales and which are lagging behind.

Budget Allocation Overview: Beyond marketing, a donut chart can show how a department or company allocates its budget (e.g. marketing, R&D, operations). This helps facilitate budget reviews and informed reallocation discussions.

Setting Up Your React Project

Using our open-source library, scichart-react, we make it easy to create donut charts (and a plethora of other charts) in React. We have a step-by-step walkthrough that makes it easy for your developers to set up their first React project.

Creating a Basic Donut Chart in React with SciChart

To create a donut chart, create PieSegment instances and add them to the SciChartPieSurface.pieSegments collection.

Set sciChartPieSurface.pieType = EPieType.Donut to enable a donut chart. The sciChartPieSurface.holeRadius property then sets the size of the donut hole.

Each PieSegment has properties for value, text and color, or colorLinearGradient if you want a gradient fill. The isSelected property denotes whether the PieSegment is in the selected state.

const sciChartPieSurface = await SciChartPieSurface.create(divElementId);

const theme = { ...new SciChartJSLightTheme() };
theme.sciChartBackground = "Transparent";
sciChartPieSurface.applyTheme(theme);
sciChartPieSurface.pieType = EPieType.Donut;
sciChartPieSurface.holeRadius = 0.6;
sciChartPieSurface.legend.showLegend = true;
sciChartPieSurface.animationFrames = 60;
sciChartPieSurface.labelStyle = { fontSize: 14, color: EColor.White };

const pieSegment1 = new PieSegment({
  color: EColor.Green,
  value: 10,
  text: "Green",
  delta: 10,
});

const pieSegment2 = new PieSegment({
  color: EColor.Red,
  value: 20,
  text: "Red",
  delta: 20,
});

const pieSegment3 = new PieSegment({
  color: EColor.Blue,
  value: 30,
  text: "Blue",
  delta: 30,
});

const pieSegment4 = new PieSegment({
  color: EColor.Orange,
  value: 40,
  text: "Orange",
  delta: 40,
});

sciChartPieSurface.pieSegments.add(pieSegment1, pieSegment2, pieSegment3, pieSegment4);

Helpful Links

🔗 Set Up with React

🔗 React Donut Chart Demo

🔗 GitHub Donut Chart

How to Style a Donut Chart with SciChart

With SciChart, you can tailor the design of the segments to suit your needs. This includes support for dynamic theming to create custom, on-brand experiences, and dark mode to make the data accessible to more users.

Detailed documentation on styling donut chart segments and formatting labels can be found on the Pie Chart documentation page.

Examples of Styling Options

To add a gradient: Set PieSegment.colorLinearGradient

const pieSegment1 = new PieSegment({
  color: EColor.Green,
  value: 10,
  text: "Green",
  delta: 10,
  colorLinearGradient: new GradientParams(new Point(0, 0), new Point(0, 1), [
    { color: "#1D976C", offset: 0 },
    { color: "#93F9B9", offset: 1 },
  ]),
});

const pieSegment2 = new PieSegment({
  color: EColor.Red,
  value: 20,
  text: "Red",
  delta: 20,
  colorLinearGradient: new GradientParams(new Point(0, 0), new Point(0, 1), [
    { color: "#DD5E89", offset: 0 },
    { color: "#F7BB97", offset: 1 },
  ]),
});

const pieSegment3 = new PieSegment({
  color: EColor.Blue,
  value: 30,
  text: "Blue",
  delta: 30,
  colorLinearGradient: new GradientParams(new Point(0, 0), new Point(0, 1), [
    { color: "#2b2828", offset: 0 },
    { color: "#656565", offset: 1 },
  ]),
});

const pieSegment4 = new PieSegment({
  color: EColor.Yellow,
  value: 40,
  text: "Yellow",
  delta: 40,
  colorLinearGradient: new GradientParams(new Point(0, 0), new Point(0, 1), [
    { color: "#F09819", offset: 0 },
    { color: "#EDDE5D", offset: 1 },
  ]),
});

To add padding between pie segments: Set SciChartPieSurface.seriesSpacing

sciChartPieSurface.seriesSpacing = 10;

To set a global label font size, colour and family: Set SciChartPieSurface.labelStyle

sciChartPieSurface.labelStyle = { fontFamily: "Arial", fontSize: 20, color: EColor.White };

To set a general label text override: Use SciChartPieSurface.labelProvider.getSegmentText

const labelProvider = new PieLabelProvider();
labelProvider.getSegmentText = (segment: IPieSegment, total: number) =>
  `<span>${segment.text}</span><br/><span>${segment.value.toFixed(1)} (${(
    (100 * segment.value) / total
  ).toFixed(1)}%)</span>`;
sciChartPieSurface.labelProvider = labelProvider;

To move labels further away from the pie segment: Set PieSegment.labelOffset

pieSegment1.labelOffset = new Point(10, 10);

To set an individual pie segment's font and colour: Set PieSegment.labelStyle

pieSegment1.labelStyle = { fontFamily: "Arial", fontSize: 20, color: EColor.White };

To make a pie segment larger or smaller: Set PieSegment.radiusAdjustment

pieSegment1.radiusAdjustment = 0.3;

LabelProviders are also available on each segment via the PieSegment.labelProvider property:

pieSegment1.labelProvider.formatLabel = (value: number) =>
  `<span style="color: purple; font-family: Arial, sans-serif; font-size: 2em;">${value.toFixed(
    3
  )}</span><span style="font-size: 2em;">$</span>`;

How to Change the Size of Your Donut Chart in React

Working with SciChart puts you in the driving seat when building your chart. You start with the basic elements, then level them up and customise them to match your exact design requirements. This includes the size of the donut hole (holeRadius) and the segments (radiusAdjustment).

Making the Donut Chart Dynamic

If you want to add more dynamic elements, you can add tooltips and customisable labels. The beauty of tooltips is that you can add more information without cluttering the display, so users can engage with the data that matters to them. For instance, you could add exact percentages and amounts, or more context behind each segment, which only displays when a user hovers over or clicks that segment.

Donut charts can be dynamically updated by setting the PieSegment.value property. When SciChartPieSurface.animate is true, updates to the chart will be animated.

Why Use SciChart for Donut Charts in React?

SciChart's exceptional customisation abilities and easy-to-use interface are two reasons it's the library of choice for developers. We offer hundreds of documentation pages and a 64-bit library that can handle millions of data points in real time. With cross-platform performance, it's also easy to make your data visualisations compatible across various systems and hardware devices.

Our flexible chart library lets you tailor designs to the exact finish you want to present to your end users. This gives you more control than the basic out-of-the-box designs that most open-source chart libraries restrict you to.

Create Your React Donut Chart with SciChart

We're known for high-performance charting software that renders huge volumes of data in real time (think millions of data points). But that's not all we're known for. When it comes to developer support, we offer exemplary customer service and advice. From extensive documentation, examples and demos to responsive community forums and support from our development team, SciChart is designed to be as intuitive and user-friendly as possible, while blowing the competition out of the water when it comes to design customisation.

👉 Discover the SciChart React Chart Library

How to Create a Line Chart in React with SciChart

Andrew Bt — Thu, 15 Oct 2026 19:47:53 +0000

When building a line chart, your brief may require more than just conveying the information in a graphical format. There may be a requirement for the data to be displayed with custom colours, as part of a dashboard, or to ensure dynamic rendering to keep up with the input of a 24/7 data source.

We'll guide you through the process of creating dynamic and insightful line charts using React and SciChart. Learn how to set up, customise and add interactivity to your charts for a richer user experience that helps users effortlessly find the insights they're searching for.

Why a React Line Chart?

From prices to vital signs, line charts make visualising trends across time series and sequential data accessible for many sectors and use cases.

Financial dashboards commonly use React-powered line charts to plot time-series market data and performance metrics.

In the oil and gas industry, React line charts support the monitoring of well data, process variables and IoT sensor streams. It's not uncommon for a React-based Oil & Gas Explorer demo to display multiple line charts of well log curves (gamma-ray, resistivity, porosity logs, etc.) in a synchronised dashboard.

Line charts are also at the forefront of healthcare. Line charts in hospital analytics dashboards are an effective way to communicate daily hospital admissions over time and clearly display changes in demand for hospital beds. With the rise of wearable tech, fitness app users also want to view their step count or heart rate over a period of time.

This information has many applications, such as improving patient experiences in hospitals and making health conditions easier to manage.

Setting Up Your Project

Your true north should always be to read the documentation first. However, if you prefer to get started with visual support, we recommend looking at the examples and demos.

Whichever sector you're building your React line chart for, we'll show you how to set up a project with SciChart-React. This sets the foundation for building your chart. From there, you can add the more fun elements that make the look and feel of the chart both fully customised and high-performance.

Initialising an npm project

npm init -y
npm install scichart scichart-react
npm install --save-dev webpack
npm install --save-dev webpack-dev-server
npm install --save-dev webpack-cli
npm install --save-dev copy-webpack-plugin

Creating a Line Chart with SciChart

Use the SciChart component to render your first chart. The code below demonstrates how to create a line chart using an initChart function. This function initialises a SciChart surface, sets up X and Y axes, generates sample data and associates it with a line series. The chart is then added to the SciChart surface.

import { SciChartReact } from "scichart-react";
import {
  SciChartSurface,
  NumericAxis,
  FastLineRenderableSeries,
  XyDataSeries,
} from "scichart";

const initChart = async (rootElement: string | HTMLDivElement) => {
  const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement);

  sciChartSurface.xAxes.add(new NumericAxis(wasmContext));
  sciChartSurface.yAxes.add(new NumericAxis(wasmContext));

  const xValues = Array.from({ length: 100 }, (_, i) => i);
  const yValues = xValues.map((x) => Math.sin(x * 0.1));

  sciChartSurface.renderableSeries.add(
    new FastLineRenderableSeries(wasmContext, {
      dataSeries: new XyDataSeries(wasmContext, { xValues, yValues }),
      stroke: "#50C7E0",
      strokeThickness: 2,
    })
  );

  return { sciChartSurface };
};

export const LineChart = () => (
  <SciChartReact initChart={initChart} style={{ width: 800, height: 400 }} />
);

As your first port of call, we recommend reading through Tutorial 01 and Tutorial 02 (linked below), as these show you how to get set up and add your data.

Useful Resources

Available modifications of line charts include:

What Language Should You Use to Build Your React Line Chart?

Our top tip for building React line charts is to use TypeScript rather than JavaScript. For example, when setting a property on an X axis in the code editor, TypeScript support makes it easier to see documentation and catch typos. With JavaScript, typos may not be noticed until much later. This makes the project harder to maintain and can take more time to get over the line.

If you want to create a simple chart, you can use JSON with our Builder API. This is similar to other JavaScript chart libraries, so if you're new to SciChart, the learning curve will be negligible.

SciChart React Line Chart Demo

Useful Resources

Customising Your React Line Chart

When creating a line chart, there are several APIs you should refer to, including the Axis API, Annotations API and ChartModifier API. The latter is required to add interactions. In GitHub, you can easily work your way down the list of properties, covering everything from styling and theming to accessibility, which shows you how to add voiceovers, keyboard accessibility and colour contrast. See what is possible with SciChart React charts by exploring our APIs.

SciChart supports tens of thousands of properties for customisation. These cover visual design as well as interactivity and annotations that help end users engage more with the finished React line chart. Below are some of the more common customisations, including adding multiple axes and applying zooming and panning.

Multi-Axis Line Chart

Supporting unlimited axes opens up plenty of possibilities. Adding a second axis to a SciChartSurface works much the same as adding one, with one difference: you must assign a unique string ID to every axis via the axis.id property when there is more than one. In version 4, this behaviour changes and IDs are auto-generated.

After adding an axis, you can use axis.id to link it to series, annotations and chart modifiers. To place an axis on either side of a chart, set axis.axisAlignment to a value of EAxisAlignment (for example EAxisAlignment.Left or EAxisAlignment.Right).

👉 View the tutorial

Zooming and Panning

In SciChart, chart interactions are defined by ChartModifiers. As well as the built-in modifiers, you can write custom modifiers or extend existing ones.

The provided modifiers include RubberBandXyZoomModifier, ZoomPanModifier, ZoomExtentsModifier, MouseWheelZoomModifier and more.

Tooltips and Hover Effects

Tooltips and hover effects offer a better user experience. Discover how to add them by watching the step-by-step video tutorial above. Annotation options include an onHover callback and a hover modifier, which let you add tooltips or get notified when a user hovers over an annotation.

This helps your organisation understand how end users interact with your data visualisation and see what interests them versus what gets ignored. Try it for yourself with our Hover Annotations Documentation.

Reliable Performance for Large Datasets

Line charts are not complex. The problem comes when you're trying to draw 100,000 or 1 million lines. Most libraries without hardware acceleration will fail to support this many.

For smoother performance, we recommend WebGL rendering over 2D canvas rendering. The beauty of WebGL is that computationally intensive tasks, such as rendering 3D charts or matrix transformations, are processed on the GPU instead of the CPU, which is much faster thanks to parallel computing.

The result is a more performant and reliable React line chart. With a responsive, GPU-based React chart library, data populates in real time and the chart updates automatically whenever the data source collects new material, so end users always see the most up-to-date information.

A cross-platform chart library also ensures charts work across platforms and devices without lag or slowdown. This is useful for organisations that rely on multiple devices to communicate the same information, giving a consistent experience and reducing user frustration.

Getting the Support You Need as Quickly as Possible

Building basic line charts shouldn't require much of a learning curve. However, if you hit an obstacle with chart creation or rendering performance, you'll want support quickly.

SciChart offers a responsive support service, and there are ways to speed things up. Create a minimal project that reproduces the problem and share it with our developer team. A runnable source project or CodePen example is far more useful than isolated snippets of code, leading to quicker diagnosis and fewer back-and-forth iterations.

Next Steps for Building High-Performance Line Charts

scichart-react is a free, open-source React chart component for use with SciChart.js. It simplifies the development of React charts by handling initialisation, deletion and the lifecycle of the chart, and supports multiple approaches from simple to advanced setups.

Unlock the power of data visualisation in your React applications with SciChart, a high-performance charting library. For further customisation, we recommend exploring our documentation.

Fastest Chart Libraries Compatible with React & Angular in 2026

Andrew Bt — Fri, 09 Oct 2026 15:21:55 +0000

Picking Chart libraries compatible with React and Angular can be a make-or-break moment for your project. The sheer mountain of data we shove into browsers can quickly snowball, and if your rendering engine chokes, your whole application feels broken. Perhaps that’s why you’re researching your options for the fastest chart libraries. As well as the fastest, you're likely also looking for the most reliable solution – one that keeps rendering even when throwing in extra layers of interaction, behaviors, and customizations into your charts.

Choosing Angular, React or Both

Modern dev teams often find themselves juggling different ecosystems simultaneously. Maybe you're deep in the component-based world of React, or perhaps the structured world of Angular is more your speed. Either way, you likely need Chart libraries compatible with React and Angular to keep things looking sharp and consistent across your whole product line.

Why it is Important to Get the Right Performance for Your Charts

For those of us building advanced big data visualizations, speed is a functional requirement, not a nice-to-have. Laggy charts or low frame rates? That’s a fast track to a miserable user experience. When dealing with real-time data, the stakes get higher. Application crashes or delayed insights can be genuine disasters in time-sensitive fields. You need fluid zooming and panning, even when you're throwing millions of points at the screen.

Fastest React Chart Libraries Comparison

When you look at React options, the engine and real-time capabilities make all the difference.

Library	Primary Engine	Maximum FPS	Real-Time Data Points	Flexibility Rating
SciChart	Visual Xccelerator™	60+	100 million+	Very High
Highcharts	SVG (WebGL via Boost module)	Variable	Hundreds of thousands (with Boost)	Very High
Plotly	SVG or WebGL	Variable	Moderate	High
Apache ECharts	Canvas or SVG	Variable	High	Moderate
CanvasJS	Canvas	Variable	High	Moderate

Highcharts

Highcharts is a well-established name in the industry. While it offers a vast array of chart types and excellent documentation, its reliance on SVG for many features can lead to performance bottlenecks when handling extremely large datasets. However, it offers WebGL via its Boost module which improves the performance capabilities by disabling some features.

Plotly

Built on top of D3.js and stack.gl, Plotly is used for financial and scientific charts. With its WebGL-enabled chart types, it provides a balance between ease of use and performance. You can find out more about how this library stacks up against the competition in our alternatives to Plotly.js guide.

Apache ECharts

Apache ECharts is a powerful, free, open-source visualization library. It provides varied customization options and handles reasonably large datasets through its Canvas-based rendering engine. For a detailed breakdown of how this chart library compares with other chart libraries, read our alternatives to ECharts guide.

CanvasJS

As the name suggests, this library relies on the HTML5 Canvas element. It’s known for being lightweight and fast, making it a solid contender for dashboards that require quick rendering.

Fastest Angular Chart Libraries Comparison

Angular developers have a similar range of high performance options, each with specific strengths in data handling.

Library	Primary Engine	Maximum FPS	Real-Time Data Points	Flexibility Rating
SciChart	Visual Xccelerator™	60+	100 million+	Very High
Highcharts	SVG (WebGL via Boost module)	Variable	Hundreds of thousands (with Boost)	Very High
Plotly	SVG or WebGL	Variable	Moderate	High
amCharts 5	Canvas	60	High	Very High
Syncfusion	Canvas or SVG	Variable	Moderate	High
AG Charts	Canvas	Variable	High	High

amCharts 5

This version moved to a Canvas based engine, significantly improving its performance over previous SVG based iterations. It offers highly interactive and visually polished charts.

Syncfusion

Syncfusion provides a comprehensive suite of UI components. Their charting library is reliable and integrates deeply with Angular, though it may require more optimization for extreme big data use cases.

AG Charts

Known for its integration with AG Grid, this library is highly optimized for business applications. It offers a fast Canvas rendering engine that works well with rapidly changing data.

How SciChart Achieves Such Impressive Performance

SciChart stands out as the fastest library for both React and Angular, especially for real-time rendering. Most competitors use standard browser tech, but SciChart uses a proprietary WebAssembly and WebGL engine called Visual Xccelerator™. This lets the GPU do the hard work. It’s built for complex scenarios where you need countless customizations and interactive elements. Even with annotations and heavy zooming, it stays locked at 60 FPS. Whether you’re handling over 100 million data points or even billions in real-time, the UI stays snappy.

Want to Give SciChart a Try?

If you are building an application that requires the absolute limit of browser performance, SciChart is the solution. You can explore the capabilities of the library through the following resources:

View our extensive range of React charts
Check out React chart examples and demos to see the speed in action
We also have dedicated Angular chart demos
Review our transparent chart benchmark on GitHub

Get started with SciChart React today.

React Financial Charts: Building a High-Performance Trading App with SciChart.js

Andrew Bt — Fri, 09 Oct 2026 15:11:46 +0000

Building professional React financial charts is about much more than putting a candlestick chart on a screen. Whether you're building a crypto exchange, a stock trading app or an institutional terminal, you need to handle large historical datasets, real-time updates, technical indicators, drawing tools and synchronized chart panes, all without the UI slowing down.

That is exactly what we wanted to explore with SciTrader.

SciTrader is a high-performance financial charting and trading application that we’ve built using React, TypeScript and SciChart.js. Alongside the application itself, we’re also working on a SciTrader SDK for JavaScript and React, designed to make it easier for developers to build sophisticated financial applications on top of SciChart. This will complement the SciTrader SDK in iOS / Android which is already used in exchange applications around the world.

In this article, I want to walk through what we’ve built, how the architecture works and why we made some of the decisions we did.

What is SciTrader? A React Financial Charting App

SciTrader is a web-based financial trading application built in React, designed to demonstrate what can be achieved with SciChart.js in a realistic financial application.

You can currently view the SciTrader demo application at https://scitrader.io -> click on Web App.

The front-end is built entirely in React and TypeScript, using SciChart.js v6 for the charting layer. On the backend, we’ve built a data server in C# and .NET, using QuestDB to cache and serve market data. What we wanted to create was not just another isolated financial chart demo.

We wanted something that behaved much more like a real trading application. That means combining:

Large historical datasets with Real-time market data
Multiple timeframes down to 1-second charts, up to 1-week charts
Watchlists with sparklines and, Market-depth panels
Financial chart types: Candlestick, Heiken Ashi, OHLC and more
Technical indicators including oscillators, averages, and volume-based analysis
Multi-pane layouts
Drawing and annotation tools: fibonacci retramcenets, channels, pitchforks and more.
Exchange integrations: starting with Coinbase & Binance plus extensibility for more.
Browser-side caching of historical data.
Extensible APIs for developers such as custom studies/indicators, custom data sources.

The result is SciTrader.

Above: Deep dive walkthrough the SciTrader application and SDK for creating React financial charts

Handling Large Datasets in React Stock Charts

One of the first things we wanted to demonstrate was how the application behaves with a genuinely large amount of financial data.

For example, in SciTrader we can open BTC/USD on a one-hour timeframe and go all the way back to 2015. That data is loaded from the server and then cached locally in the browser. This is important because once the browser already has the data, we don’t necessarily want to hit the server again every time the user refreshes the page or revisits the same market. By caching locally, we can reduce unnecessary network requests and make subsequent interactions much faster.

For a financial application, this becomes especially important when users are constantly moving between instruments and timeframes.

Multiple Timeframes, Down to One Second

SciTrader supports a range of timeframes. You can move between one-hour, 15-minute, five-minute, one-minute and even one-second candles.

The one-second timeframe is particularly interesting. In the current implementation, we serve approximately two days of one-second bars, which works out at around 170,000 candles. That is a substantial amount of data to render interactively in a browser. You can zoom right down to the latest second and watch the chart update as new trades arrive.

This is exactly the kind of scenario where rendering performance really matters. It is not enough for a chart to display a lot of data. It also needs to remain responsive while the user zooms, pans, switches timeframes and interacts with the rest of the application.

Progressive Historical Data Loading

Another part of the architecture is how we load historical data. We don’t necessarily want to load every possible historical candle before the user sees anything. Instead, as you scroll backwards in time, SciTrader can fetch more data from the server. This gives us a much more scalable model.

The user sees the chart quickly, and additional history is requested when it is actually needed. Combined with local caching, this allows us to manage large historical datasets without placing unnecessary pressure on the server or the browser.

Watchlists and Instrument Switching

A trading application needs more than charts. Users also need a quick way to navigate between markets.

In the SciTrader demo, we’ve included watchlists containing some of the highest-volume cryptocurrency pairs. We have markets denominated in USD as well as BTC.

When you switch between watchlists, we fetch the 24-hour history for each instrument and render that information as a sparkline together with its 24-hour change. Clicking on an instrument immediately brings up that chart while keeping the timeframe you were already using.

One thing I particularly wanted to demonstrate here is responsiveness. You can move rapidly between instruments and the application remains extremely fast. There is very little noticeable latency when loading the candles and updating the chart. That is the result of the architecture we’ve put underneath the application, rather than simply the visual layer.

Candlestick, OHLC, and Heikin Ashi Charts in React

Different traders prefer different ways of looking at the market, so we’ve included several common financial chart types.

In SciTrader, you can switch between:

Candlestick charts
OHLC bars
Line charts
Mountain charts
Heikin Ashi charts

Heikin Ashi is calculated dynamically on the client. That gives us a nice example of how derived financial data can be calculated inside the application and fed directly into the visualization layer. The chart representation can change without requiring an entirely different backend data source.

Technical Indicators and Studies

We’ve also built a range of technical indicators into SciTrader.

These include familiar indicators such as:

Volume bars, Volume Profile
Relative Strength Index, or RSI
MACD
Simple Moving Average
Exponential Moving Average
Weighted Moving Average

We’ve also included some more advanced studies such as:

Donchian Channels
Keltner Bands
Ichimoku Cloud
Average True Range
On-Balance Volume
Money Flow Index

The important thing here is that these indicators are not simply painted onto one chart. Some belong on the main price chart, others need their own pane.

RSI and MACD, for example, are generally displayed in separate panels with their own Y axes. SciTrader handles this dynamically.

Managing Multiple Chart Panes

When you add studies to the application, you can resize the panes, reorder them, maximize them and remove them. That flexibility is important in a real trading environment.

Different users will want to organize their workspace differently. Some may care more about RSI. Others may want MACD, volume or several proprietary indicators visible at once.

What we want is for the application to remain responsive even as the number of studies and chart panes increases. This is one area where SciChart’s rendering performance becomes particularly valuable.

Managing and Customizing Studies

If you open the Manage Studies panel, you can see the indicators currently attached to the chart.

From there, you can remove studies you no longer need or modify the properties of the ones you want to keep. This is where the architecture starts to become particularly interesting from a developer perspective.

A study in SciTrader is not simply a line on a chart. It represents the calculation, configuration, data dependencies and rendering behaviour of that indicator. That same concept is carried through into the SciTrader SDK.

Drawing and Annotation Tools

We’ve also added a set of financial drawing tools.

These include:

Channels
Fibonacci retracements
Pitchforks & Fans
Trend lines, Rays
Take-profit & Stop-loss annotations
Elliot waves and patterns e.g. XABCD

These drawings can be edited after they are placed on the chart. They are also persistent when you change timeframe. That behaviour sounds simple, but it is important.

A trend line should remain connected to the same time and price relationship when the chart changes. It should not simply stay at the same screen coordinates. For a trading application, the annotations need to remain meaningful as the user changes the view.

Custom L2 Order Book Microstructure Visualisation in React

As wel as technical indicators that operate on Open High Low Close + Volume market data, we've included some demos of using L2 (Level-2) order book data in the SciTrader application, to show how you could built microstructure visualisation in React.

Historical Order Book Heatmap in React

A historical order book heatmap is built by aggregating Level 2 Order Book data into candle-sized buckets with a fixed price increment depending on zoom level. The historical order book levels are rendered in the front-end as a heatmap, showing buy/sell walls or major liquidity levels on the chart. Hovering the heatmap shows the cumulative bid/ask at that level (amount of funds required to move the market to that level).

Book Imbalance Indicator in React

A second indicator using L2 data is the Book Imbalance indicator in SciTrader. This uses the historical L2 book data to compute the relative imbalance between bids & asks, and is rendered as a mountain chart in a separate pane.

You can see an example of both L2 indicators below:

From the Application to the SciTrader SDK

The SciTrader application is one part of what we’re building to showcase Financial Charts in React. The other part is the SciTrader SDK.

We already have SciTrader SDKs for iOS and Android, and we’re now bringing that concept to JavaScript and React.

The idea is to give developers a higher-level financial framework built on top of SciChart.js.

What is SciFinanceChart?

SciFinanceChart acts as the core financial chart abstraction in the SciTrader SDK.

It brings together: financial chart rendering, studies (indicators), chart panes, market data, exchange integrations and data routing. You can create a SciFinanceChart directly or create one with a collection of predefined studies. For example, you might want candlesticks, volume and moving averages on the main chart, while RSI and MACD to sit in separate chart panes.

Rather than developers having to manually wire all of these components together every time, the SciTrader SDK is designed to understand how these elements relate to one another.

Designing the SDK for Extensibility

A financial SDK cannot assume that everyone uses the same exchange or the same indicators. We've designed the SciTrader SDK for extensibility, allowing you to build your own exchange integrations by implementing IRemoteExchange.

Similarly, you will be able to develop custom studies (indicators calculations plus rendering plus chart pane placement) by implementing IStudy.

With these two, and combined with our rich and powerful DataManager that routes OHLCV data and L2 data from the exhange through to studies, you can completely customise your financial trading apps using the SciTrader SDK.

Why We Built SciTrader

At SciChart, we’ve always focused heavily on performance. But performance is only one part of building a great financial application.

Developers also need architecture. They need sensible ways to manage data, coordinate multiple charts, connect to exchanges, create indicators and expose configuration to users. SciTrader is our attempt to bring those pieces together.

SciChart.js provides the high-performance visualization layer, the SciTrader architecture adds concepts specifically designed around financial applications, significantly shortening the development time of building trading apps, exchange applications and financial apps by 6-12 months.

The SciTrader SDK will give developers the foundation for building sophisticated trading platforms without having to re-invent every part of the stack.

Who is SciTrader For?

SciTrader is relevant to developers building applications such as:

Cryptocurrency trading platforms
Stock trading applications
Brokerage interfaces
Institutional trading terminals
Financial dashboards
Market data platforms
Portfolio analytics applications
Quantitative analysis tools
Proprietary fintech products

The common requirement across all of these applications is that they need to handle large quantities of data while remaining responsive.

The user should be able to zoom, pan, switch markets, change timeframes, add indicators and modify studies without the interface feeling slow.

Try SciTrader

You can try the current SciTrader web application at: https://scitrader.io -> click on Web App.

The staging application lets you explore the market data, different timeframes, technical indicators, drawing tools, watchlists and other functionality I’ve described here.

We are also working towards making the SciTrader SDK available as an NPM package, so developers will be able to start building their own React and TypeScript applications using the same architecture.

There is much more we want to do with SciTrader, but I think the current application already gives a good indication of where we are heading.

If you are building a trading platform or financial application and performance matters, I’d encourage you to take a look.