Demonstrates handling realtime big data with different chart types using SciChart.js, High Performance JavaScript Charts
import { io } from "socket.io-client";
import { appTheme } from "./appTheme";
import {
IBaseDataSeriesOptions,
TSciChart,
ESeriesType,
BaseDataSeries,
BaseRenderableSeries,
XyDataSeries,
FastLineRenderableSeries,
AUTO_COLOR,
XyyDataSeries,
FastBandRenderableSeries,
FastColumnRenderableSeries,
StackedMountainRenderableSeries,
XyCustomFilter,
EDataSeriesField,
XyScatterRenderableSeries,
EllipsePointMarker,
OhlcDataSeries,
FastCandlestickRenderableSeries,
XyTextDataSeries,
FastTextRenderableSeries,
EDataSeriesType,
XyzDataSeries,
INumericAxisOptions,
ENumericFormat,
SciChartSurface,
NumericAxis,
LayoutManager,
IRenderableSeries,
StackedColumnCollection,
StackedColumnRenderableSeries,
StackedMountainCollection,
RightAlignedOuterVerticallyStackedAxisLayoutStrategy,
MouseWheelZoomModifier,
ZoomPanModifier,
ZoomExtentsModifier,
NumberRange,
} from "scichart";
export type TMessage = {
title: string;
detail: string;
};
export interface ISettings {
seriesCount?: number;
pointsOnChart?: number;
pointsPerUpdate?: number;
sendEvery?: number;
initialPoints?: number;
}
let loadCount: number = 0;
let loadTimes: number[];
let avgLoadTime: number = 0;
let avgRenderTime: number = 0;
function GetRandomData(xValues: number[], positive: boolean) {
let prevYValue = Math.random();
const length = xValues.length;
const yValues: number[] = new Array(length); // Pre-allocate array
// tslint:disable-next-line: prefer-for-of
for (let j = 0; j < length; j++) {
const change = Math.random() * 10 - 5;
prevYValue = positive ? Math.abs(prevYValue + change) : prevYValue + change;
yValues[j] = prevYValue;
}
return yValues;
}
const extendRandom = (val: number, max: number) => val + Math.random() * max;
const generateCandleData = (xValues: number[]) => {
let open = 10;
const length = xValues.length;
const openValues = new Array(length);
const highValues = new Array(length);
const lowValues = new Array(length);
const closeValues = new Array(length);
for (let i = 0; i < length; i++) {
const close = open + Math.random() * 10 - 5;
const high = Math.max(open, close);
highValues[i] = extendRandom(high, 5);
const low = Math.min(open, close);
lowValues[i] = extendRandom(low, -5);
closeValues[i] = close;
openValues[i] = open;
open = close;
}
return { openValues, highValues, lowValues, closeValues };
};
const generateCandleDataForAppendRange = (open: number, closeValues: number[]) => {
const length = closeValues.length;
const openValues = new Array(length);
const highValues = new Array(length);
const lowValues = new Array(length);
for (let i = 0; i < length; i++) {
const close = closeValues[i];
openValues[i] = open;
const high = Math.max(open, close);
highValues[i] = extendRandom(high, 5);
const low = Math.min(open, close);
lowValues[i] = extendRandom(low, -5);
open = close;
}
return { openValues, highValues, lowValues, closeValues };
};
const dsOptions: IBaseDataSeriesOptions = {
isSorted: true,
containsNaN: false,
};
const createRenderableSeries = (
wasmContext: TSciChart,
seriesType: ESeriesType
): { dataSeries: BaseDataSeries; rendSeries: BaseRenderableSeries } => {
if (seriesType === ESeriesType.LineSeries) {
const dataSeries: XyDataSeries = new XyDataSeries(wasmContext, dsOptions);
const rendSeries: FastLineRenderableSeries = new FastLineRenderableSeries(wasmContext, {
dataSeries,
stroke: AUTO_COLOR,
strokeThickness: 3,
opacity: 0.8,
});
return { dataSeries, rendSeries };
} else if (seriesType === ESeriesType.BandSeries) {
const dataSeries: XyyDataSeries = new XyyDataSeries(wasmContext, dsOptions);
const rendSeries: FastBandRenderableSeries = new FastBandRenderableSeries(wasmContext, {
stroke: AUTO_COLOR,
strokeY1: AUTO_COLOR,
fill: AUTO_COLOR,
fillY1: AUTO_COLOR,
dataSeries,
strokeThickness: 2,
opacity: 0.8,
});
return { dataSeries, rendSeries };
} else if (seriesType === ESeriesType.ColumnSeries) {
const dataSeries: XyDataSeries = new XyDataSeries(wasmContext, dsOptions);
const rendSeries: FastColumnRenderableSeries = new FastColumnRenderableSeries(wasmContext, {
fill: AUTO_COLOR,
stroke: AUTO_COLOR,
dataSeries,
strokeThickness: 1,
});
return { dataSeries, rendSeries };
} else if (seriesType === ESeriesType.StackedMountainSeries) {
const dataSeries: XyDataSeries = new XyDataSeries(wasmContext, dsOptions);
const rendSeries: StackedMountainRenderableSeries = new StackedMountainRenderableSeries(wasmContext, {
stroke: AUTO_COLOR,
fill: AUTO_COLOR,
dataSeries,
});
return { dataSeries, rendSeries };
} else if (seriesType === ESeriesType.ScatterSeries) {
const dataSeries: XyyDataSeries = new XyyDataSeries(wasmContext, { containsNaN: false });
// Use Y and Y1 as X and Y for scatter
const filteredSeries: XyDataSeries = new XyCustomFilter(dataSeries, {
xField: EDataSeriesField.Y,
field: EDataSeriesField.Y1,
});
const rendSeries: XyScatterRenderableSeries = new XyScatterRenderableSeries(wasmContext, {
pointMarker: new EllipsePointMarker(wasmContext, {
width: 9,
height: 9,
strokeThickness: 2,
fill: AUTO_COLOR,
stroke: AUTO_COLOR,
opacity: 0.8,
}),
dataSeries: filteredSeries,
});
// return the unfiltered xyy series as that is the one we want to append to
return { dataSeries, rendSeries };
} else if (seriesType === ESeriesType.CandlestickSeries) {
const dataSeries: OhlcDataSeries = new OhlcDataSeries(wasmContext, dsOptions);
const rendSeries: FastCandlestickRenderableSeries = new FastCandlestickRenderableSeries(wasmContext, {
strokeThickness: 1,
dataSeries,
dataPointWidth: 0.9,
opacity: 0.75,
strokeUp: AUTO_COLOR,
brushUp: AUTO_COLOR,
strokeDown: AUTO_COLOR,
brushDown: AUTO_COLOR,
});
return { dataSeries, rendSeries };
} else if (seriesType === ESeriesType.TextSeries) {
const dataSeries: XyTextDataSeries = new XyTextDataSeries(wasmContext, dsOptions);
const rendSeries: FastTextRenderableSeries = new FastTextRenderableSeries(wasmContext, {
dataSeries,
dataLabels: {
style: {
fontFamily: "Arial",
fontSize: 6,
},
color: AUTO_COLOR,
calculateTextBounds: false,
},
});
return { dataSeries, rendSeries };
}
return { dataSeries: undefined, rendSeries: undefined };
};
const prePopulateData = (
dataSeries: BaseDataSeries,
dataSeriesType: EDataSeriesType,
xValues: number[],
positive: boolean
) => {
const yValues: number[] = GetRandomData(xValues, positive);
switch (dataSeriesType) {
case EDataSeriesType.Xy:
(dataSeries as XyDataSeries).appendRange(xValues, yValues);
break;
case EDataSeriesType.Xyy:
(dataSeries as XyyDataSeries).appendRange(xValues, yValues, GetRandomData(xValues, positive));
break;
case EDataSeriesType.Xyz:
(dataSeries as XyzDataSeries).appendRange(
xValues,
yValues,
GetRandomData(xValues, positive).map((z) => Math.abs(z / 5))
);
break;
case EDataSeriesType.Ohlc:
const { openValues, highValues, lowValues, closeValues } = generateCandleData(xValues);
(dataSeries as OhlcDataSeries).appendRange(xValues, openValues, highValues, lowValues, closeValues);
break;
case EDataSeriesType.XyText:
(dataSeries as XyTextDataSeries).appendRange(
xValues,
yValues,
yValues.map((textval) => textval.toFixed())
);
break;
default:
break;
}
};
const appendData = (
dataSeries: BaseDataSeries,
dataSeriesType: EDataSeriesType,
index: number,
xValues: number[],
yArray: number[][],
pointsOnChart: number,
pointsPerUpdate: number
) => {
switch (dataSeriesType) {
case EDataSeriesType.Xy:
const xySeries = dataSeries as XyDataSeries;
xySeries.appendRange(xValues, yArray[index]);
if (xySeries.count() > pointsOnChart) {
xySeries.removeRange(0, pointsPerUpdate);
}
break;
case EDataSeriesType.Xyy:
const xyySeries = dataSeries as XyyDataSeries;
xyySeries.appendRange(xValues, yArray[2 * index], yArray[2 * index + 1]);
if (xyySeries.count() > pointsOnChart) {
xyySeries.removeRange(0, pointsPerUpdate);
}
break;
case EDataSeriesType.Xyz:
const xyzSeries = dataSeries as XyzDataSeries;
xyzSeries.appendRange(
xValues,
yArray[2 * index],
yArray[2 * index + 1].map((z) => Math.abs(z / 5))
);
if (xyzSeries.count() > pointsOnChart) {
xyzSeries.removeRange(0, pointsPerUpdate);
}
break;
case EDataSeriesType.Ohlc:
const ohlcSeries = dataSeries as OhlcDataSeries;
const { openValues, highValues, lowValues, closeValues } = generateCandleDataForAppendRange(
ohlcSeries.getNativeCloseValues().get(ohlcSeries.count() - 1),
yArray[index]
);
ohlcSeries.appendRange(xValues, openValues, highValues, lowValues, closeValues);
if (ohlcSeries.count() > pointsOnChart) {
ohlcSeries.removeRange(0, pointsPerUpdate);
}
break;
case EDataSeriesType.XyText:
const xytextSeries = dataSeries as XyTextDataSeries;
xytextSeries.appendRange(
xValues,
yArray[index],
yArray[index].map((obj) => obj.toFixed())
);
if (xytextSeries.count() > pointsOnChart) {
xytextSeries.removeRange(0, pointsPerUpdate);
}
break;
default:
break;
}
};
const axisOptions: INumericAxisOptions = {
drawMajorBands: false,
drawMinorGridLines: false,
drawMinorTickLines: false,
labelFormat: ENumericFormat.Decimal,
labelPrecision: 0,
};
export const drawExample =
(updateMessages: (newMessages: TMessage[]) => void, seriesType: ESeriesType) =>
async (rootElement: string | HTMLDivElement) => {
let seriesCount = 10;
let pointsOnChart = 1000;
let pointsPerUpdate = 100;
let sendEvery = 30;
let initialPoints: number = 0;
const { wasmContext, sciChartSurface } = await SciChartSurface.create(rootElement, {
theme: appTheme.SciChartJsTheme,
});
const xAxis = new NumericAxis(wasmContext, axisOptions);
sciChartSurface.xAxes.add(xAxis);
let yAxis = new NumericAxis(wasmContext, { ...axisOptions });
sciChartSurface.yAxes.add(yAxis);
let dataSeriesArray: BaseDataSeries[];
let dataSeriesType = EDataSeriesType.Xy;
if (seriesType === ESeriesType.BubbleSeries) {
dataSeriesType = EDataSeriesType.Xyz;
} else if (seriesType === ESeriesType.BandSeries || seriesType === ESeriesType.ScatterSeries) {
dataSeriesType = EDataSeriesType.Xyy;
} else if (seriesType === ESeriesType.CandlestickSeries) {
dataSeriesType = EDataSeriesType.Ohlc;
} else if (seriesType === ESeriesType.TextSeries) {
dataSeriesType = EDataSeriesType.XyText;
}
const initChart = () => {
sciChartSurface.renderableSeries.asArray().forEach((rs) => rs.delete());
sciChartSurface.renderableSeries.clear();
sciChartSurface.chartModifiers.asArray().forEach((cm) => cm.delete());
sciChartSurface.chartModifiers.clear();
sciChartSurface.yAxes.asArray().forEach((ya) => ya.delete());
sciChartSurface.yAxes.clear();
sciChartSurface.layoutManager = new LayoutManager();
yAxis = new NumericAxis(wasmContext, { ...axisOptions });
sciChartSurface.yAxes.add(yAxis);
dataSeriesArray = new Array<BaseDataSeries>(seriesCount);
let stackedCollection: IRenderableSeries;
let xValues: number[];
const positive = [ESeriesType.StackedColumnSeries, ESeriesType.StackedMountainSeries].includes(seriesType);
for (let i = 0; i < seriesCount; i++) {
const { dataSeries, rendSeries } = createRenderableSeries(wasmContext, seriesType);
dataSeriesArray[i] = dataSeries;
if (seriesType === ESeriesType.StackedColumnSeries) {
if (i === 0) {
stackedCollection = new StackedColumnCollection(wasmContext, { dataPointWidth: 1 });
sciChartSurface.renderableSeries.add(stackedCollection);
}
(rendSeries as StackedColumnRenderableSeries).stackedGroupId = i.toString();
(stackedCollection as StackedColumnCollection).add(rendSeries as StackedColumnRenderableSeries);
} else if (seriesType === ESeriesType.StackedMountainSeries) {
if (i === 0) {
stackedCollection = new StackedMountainCollection(wasmContext);
sciChartSurface.renderableSeries.add(stackedCollection);
}
(stackedCollection as StackedMountainCollection).add(rendSeries as StackedMountainRenderableSeries);
} else if (seriesType === ESeriesType.ColumnSeries) {
// create stacked y axis
if (i === 0) {
// tslint:disable-next-line: max-line-length
sciChartSurface.layoutManager.rightOuterAxesLayoutStrategy =
new RightAlignedOuterVerticallyStackedAxisLayoutStrategy();
yAxis = new NumericAxis(wasmContext, { id: "0", ...axisOptions });
} else {
sciChartSurface.yAxes.add(
new NumericAxis(wasmContext, {
id: i.toString(),
...axisOptions,
})
);
}
rendSeries.yAxisId = i.toString();
sciChartSurface.renderableSeries.add(rendSeries);
} else {
sciChartSurface.renderableSeries.add(rendSeries);
}
if (i === 0) {
xValues = Array.from(Array(initialPoints).keys());
}
// Generate points
prePopulateData(dataSeries, dataSeriesType, xValues, positive);
sciChartSurface.zoomExtents(0);
}
return positive;
};
const dataBuffer: { x: number[]; ys: number[][]; sendTime: number }[] = [];
const maxBufferSize = 20; // Limit buffer size to prevent memory issues
let isRunning: boolean = false;
const newMessages: TMessage[] = [];
let loadStart = 0;
let loadTime = 0;
let renderStart = 0;
let renderTime = 0;
let droppedPackets = 0;
const loadData = (data: { x: number[]; ys: number[][]; sendTime: number }) => {
for (let i = 0; i < seriesCount; i++) {
appendData(dataSeriesArray[i], dataSeriesType, i, data.x, data.ys, pointsOnChart, pointsPerUpdate);
}
if (dataSeriesArray[0].count() < pointsOnChart) {
xAxis.visibleRange = new NumberRange(xAxis.visibleRange.min, xAxis.visibleRange.max + pointsPerUpdate);
} else {
xAxis.visibleRange = new NumberRange(
xAxis.visibleRange.min + pointsPerUpdate,
xAxis.visibleRange.max + pointsPerUpdate
);
}
loadTime = new Date().getTime() - loadStart;
};
sciChartSurface.preRender.subscribe(() => {
renderStart = new Date().getTime();
});
let messageUpdateCounter = 0;
sciChartSurface.rendered.subscribe(() => {
if (!isRunning || loadStart === 0) return;
avgLoadTime = (avgLoadTime * loadCount + loadTime) / (loadCount + 1);
renderTime = new Date().getTime() - renderStart;
avgRenderTime = (avgRenderTime * loadCount + renderTime) / (loadCount + 1);
loadCount++;
// Only update messages every 10 renders to reduce DOM overhead
messageUpdateCounter++;
if (messageUpdateCounter >= 10) {
newMessages.push({
title: `Avg Load Time`,
detail: `${avgLoadTime.toFixed(2)}ms`,
});
newMessages.push({
title: `Avg Render Time`,
detail: `${avgRenderTime.toFixed(2)}ms`,
});
newMessages.push({
title: `Max FPS`,
detail: `${Math.min(60, 1000 / (avgLoadTime + avgRenderTime)).toFixed(1)}`,
});
if (droppedPackets > 0) {
newMessages.push({
title: `Dropped Packets`,
detail: `${droppedPackets}`,
});
}
updateMessages(newMessages);
newMessages.length = 0;
messageUpdateCounter = 0;
}
});
const loadFromBuffer = () => {
if (dataBuffer.length > 0) {
loadStart = new Date().getTime();
// Process multiple buffered items more efficiently
const batchSize = Math.min(dataBuffer.length, 5); // Limit batch processing
let totalXLength = 0;
let totalYsLength = 0;
// Calculate total lengths to pre-allocate arrays
for (let i = 0; i < batchSize; i++) {
totalXLength += dataBuffer[i].x.length;
if (i === 0) totalYsLength = dataBuffer[i].ys.length;
}
// Pre-allocate arrays for better performance
const x = new Array(totalXLength);
const ys: number[][] = new Array(totalYsLength);
for (let j = 0; j < totalYsLength; j++) {
ys[j] = new Array(totalXLength);
}
let xIndex = 0;
let yIndex = 0;
// Copy data efficiently without spread operator
for (let i = 0; i < batchSize; i++) {
const el = dataBuffer[i];
const elXLength = el.x.length;
// Copy x values
for (let k = 0; k < elXLength; k++) {
x[xIndex++] = el.x[k];
}
// Copy y values
for (let y = 0; y < el.ys.length; y++) {
for (let k = 0; k < elXLength; k++) {
ys[y][yIndex + k] = el.ys[y][k];
}
}
yIndex += elXLength;
}
loadData({ x, ys, sendTime: dataBuffer[0].sendTime });
dataBuffer.splice(0, batchSize);
}
if (isRunning) {
requestAnimationFrame(loadFromBuffer);
}
};
let socket: ReturnType<typeof io>;
const initWebSocket = (positive: boolean) => {
if (socket) {
socket.disconnect();
socket.connect();
} else {
const hostedFromLocalhost = window.location.hostname.includes("localhost");
const hostedFromSandbox = !hostedFromLocalhost && !window.location.hostname.includes("scichart.com");
// TODO this check probably could be improved
// consider the app is running locally in dev mode
const isDevMode = hostedFromLocalhost && Number.parseInt(window.location.port) > 8000;
if (isDevMode || hostedFromSandbox) {
socket = io("https://www.scichart.com", { path: "/demo/socket.io" });
} else {
socket = io({ path: "/demo/socket.io" });
}
socket.on("data", (message: any) => {
// Throttle data to prevent buffer overflow with extreme update rates
if (dataBuffer.length < maxBufferSize) {
dataBuffer.push(message);
} else {
// Drop oldest packets when buffer is full (FIFO)
dataBuffer.shift();
dataBuffer.push(message);
droppedPackets++;
}
});
socket.on("finished", () => {
socket.disconnect();
});
}
// If initial data has been generated, this should be an array of the last y values of each series
const index = dataSeriesArray[0].count() - 1;
let series: number[];
if (
dataSeriesType === EDataSeriesType.Xy ||
dataSeriesType === EDataSeriesType.Ohlc ||
dataSeriesType === EDataSeriesType.XyText
) {
if (index >= 0) {
series = dataSeriesArray.map((d) => d.getNativeYValues().get(index));
} else {
series = Array.from(Array(seriesCount)).fill(0);
}
} else if (dataSeriesType === EDataSeriesType.Xyy) {
if (index >= 0) {
series = [];
for (const dataSeries of dataSeriesArray) {
const xyy = dataSeries as XyyDataSeries;
series.push(xyy.getNativeYValues().get(index));
series.push(xyy.getNativeY1Values().get(index));
}
} else {
series = Array.from(Array(seriesCount * 2)).fill(0);
}
} else if (dataSeriesType === EDataSeriesType.Xyz) {
if (index >= 0) {
series = [];
for (const dataSeries of dataSeriesArray) {
const xyy = dataSeries as XyzDataSeries;
series.push(xyy.getNativeYValues().get(index));
series.push(xyy.getNativeZValues().get(index));
}
} else {
series = Array.from(Array(seriesCount * 2)).fill(0);
}
}
socket.emit("getData", { series, startX: index + 1, pointsPerUpdate, sendEvery, positive, scale: 10 });
isRunning = true;
loadFromBuffer();
};
const settings = {
seriesCount: 10,
pointsOnChart: 5000,
pointsPerUpdate: 10,
sendEvery: 100,
initialPoints: 5000,
};
const updateSettings = (newValues: ISettings) => {
Object.assign(settings, newValues);
};
// Buttons for chart
const startUpdate = () => {
console.log("start streaming");
loadCount = 0;
avgLoadTime = 0;
avgRenderTime = 0;
loadTimes = [];
loadStart = 0;
droppedPackets = 0;
messageUpdateCounter = 0;
seriesCount = settings.seriesCount;
initialPoints = settings.initialPoints;
pointsOnChart = settings.pointsOnChart;
pointsPerUpdate = settings.pointsPerUpdate;
sendEvery = settings.sendEvery;
const positive = initChart();
initWebSocket(positive);
};
const stopUpdate = () => {
console.log("stop streaming");
socket?.disconnect();
isRunning = false;
if (sciChartSurface.chartModifiers.size() === 0) {
sciChartSurface.chartModifiers.add(
new MouseWheelZoomModifier(),
new ZoomPanModifier({ enableZoom: true }),
new ZoomExtentsModifier()
);
}
};
return { wasmContext, sciChartSurface, controls: { startUpdate, stopUpdate, updateSettings } };
};
This example demonstrates a high-performance real-time charting application using SciChart.js in a React environment. The demo handles massive streaming datasets via a WebSocket connection and dynamically updates charts with millions of data points. It is designed to showcase the capabilities of SciChart.js when integrated as a React component, providing a robust solution for real-time data visualization.
The implementation leverages the <SciChartReact/> component from the scichart-react package to create and render the chart. Key parts of the implementation include initializing the chart with custom axes, dynamically updating settings via React state, and handling data streaming from a WebSocket. Chart updates are efficiently managed by invoking methods to appendRange() and removeRange() to manage chart data on the fly. This technique could be further improved by using fifoCapacity - where XyDataSeries are implemented with a First-In-First-Out (FIFO) circular buffer, for automatic discarding of old data. For a deeper understanding of how to integrate SciChartSurface with React, developers can refer to the React Charts with SciChart.js blog post.
The demo implements several advanced features including real-time updates, dynamic series type selection of Line, Column, Band, Candlestick, Stacked Mountain or Scatter Chart via dropdown controls, and performance monitoring (load times, render times, and maximum FPS calculations). Real-time data streaming is managed through socket.io, where incoming data is batched and processed to update the chart continuously. This efficient handling of large data streams helps illustrate best practices for real-time charting with WebGL rendering.
The example makes extensive use of React hooks such as useState and useRef to manage state and access imperative chart control methods. Dynamic configuration of the chart is achieved with shared CSS controls sliders that incorporate logarithmic scaling for precise control over parameters like series count and data point limits. This approach follows best practices for managing real-time chart updates in React and illustrates how to integrate complex chart control logic seamlessly into a React component. Performance optimization is also a key focus, ensuring that heavy data loads do not hamper the user experience. Developers looking to deepen their understanding of these techniques can consult resources on performance optimization for React Chart applications.











