Demonstrates handling realtime big data with different chart types using SciChart.js, High Performance JavaScript Charts
index.tsx
containerSizeHooks.ts
theme.ts
after-all-charts-init.ts
chart-configurations.ts
chart-types.ts
data-generation.ts
GridLayoutModifier.ts
main-chart-config.ts
ModifierGroup.ts
Overview.tsx
page-statistics-chart-config.ts
region-statistic-charts.ts
server-load-chart-config.ts
ThresholdSlider.tsx
VisibleRangeSynchronizationManager.ts
1import { IThemeProvider, SciChartJsNavyTheme } from "scichart";
2
3const getCssColor = (cssVar: string, fallback: string): string => {
4 if (typeof document === "undefined") {
5 return fallback;
6 }
7 const cssValue = getComputedStyle(document.documentElement).getPropertyValue(cssVar).trim();
8 return cssValue || fallback;
9};
10
11type TRgbColor = { r: number; g: number; b: number };
12
13const parseCssColorToRgb = (color: string): TRgbColor | undefined => {
14 const trimmed = color.trim();
15
16 if (trimmed.startsWith("#")) {
17 let hex = trimmed.slice(1);
18 if (hex.length === 3 || hex.length === 4) {
19 hex = hex
20 .slice(0, 3)
21 .split("")
22 .map((channel) => channel + channel)
23 .join("");
24 } else if (hex.length === 6 || hex.length === 8) {
25 hex = hex.slice(0, 6);
26 } else {
27 return undefined;
28 }
29
30 if (!/^[0-9a-fA-F]{6}$/.test(hex)) {
31 return undefined;
32 }
33
34 return {
35 r: Number.parseInt(hex.slice(0, 2), 16),
36 g: Number.parseInt(hex.slice(2, 4), 16),
37 b: Number.parseInt(hex.slice(4, 6), 16),
38 };
39 }
40
41 const rgbMatch = trimmed.match(/^rgba?\((.+)\)$/i);
42 if (!rgbMatch) {
43 return undefined;
44 }
45
46 const channels = rgbMatch[1]
47 .split(",")
48 .slice(0, 3)
49 .map((channel) => Number.parseFloat(channel.trim()));
50
51 if (channels.length !== 3 || channels.some((channel) => !Number.isFinite(channel))) {
52 return undefined;
53 }
54
55 const clamp = (value: number) => Math.max(0, Math.min(255, value));
56
57 return {
58 r: clamp(channels[0]),
59 g: clamp(channels[1]),
60 b: clamp(channels[2]),
61 };
62};
63
64const getPerceivedBrightness = (color: string): number | undefined => {
65 const rgb = parseCssColorToRgb(color);
66 if (!rgb) return undefined;
67
68 // WCAG-adjacent perceptual weighting for quick dark/light detection.
69 return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
70};
71
72export interface AppThemeBase {
73 SciChartJsTheme: IThemeProvider;
74
75 // general colors
76 isDark: boolean;
77 ForegroundColor: string;
78 Background: string;
79
80 // Series colors
81 VividSkyBlue: string;
82 VividPink: string;
83 VividTeal: string;
84 VividOrange: string;
85 VividBlue: string;
86 VividPurple: string;
87 VividGreen: string;
88 VividRed: string;
89
90 MutedSkyBlue: string;
91 MutedPink: string;
92 MutedTeal: string;
93 MutedOrange: string;
94 MutedBlue: string;
95 MutedPurple: string;
96 MutedRed: string;
97
98 PaleSkyBlue: string;
99 PalePink: string;
100 PaleTeal: string;
101 PaleOrange: string;
102 PaleBlue: string;
103 PalePurple: string;
104}
105
106export class SciChart2022AppTheme implements AppThemeBase {
107 SciChartJsTheme = new SciChartJsNavyTheme();
108
109 // Dynamic colors
110 get isDark() {
111 const brightness = getPerceivedBrightness(this.Background);
112 return brightness === undefined || brightness < 128;
113 }
114 get TextColor() {
115 return this.ForegroundColor;
116 }
117 get ForegroundColor() {
118 return getCssColor("--text", "#F5F5F5");
119 }
120 get Background() {
121 return getCssColor("--bg-chart", this.SciChartJsTheme.sciChartBackground);
122 }
123
124 // Series colors
125 VividSkyBlue = "#50C7E0";
126 VividPink = "#EC0F6C";
127 VividTeal = "#30BC9A";
128 VividOrange = "#F48420";
129 VividBlue = "#364BA0";
130 VividPurple = "#882B91";
131 VividGreen = "#67BDAF";
132 VividRed = "#C52E60";
133
134 DarkIndigo = "#14233C";
135 Indigo = "#264B93";
136
137 MutedSkyBlue = "#83D2F5";
138 MutedPink = "#DF69A8";
139 MutedTeal = "#7BCAAB";
140 MutedOrange = "#E7C565";
141 MutedBlue = "#537ABD";
142 MutedPurple = "#A16DAE";
143 MutedRed = "#DC7969";
144
145 PaleSkyBlue = "#E4F5FC";
146 PalePink = "#EEB3D2";
147 PaleTeal = "#B9E0D4";
148 PaleOrange = "#F1CFB5";
149 PaleBlue = "#B5BEDF";
150 PalePurple = "#CFB4D5";
151}
152
153export const appTheme = new SciChart2022AppTheme();
154This React-based example, "Server Traffic Dashboard," demonstrates how to build a complex, interactive dashboard using SciChart.js within a React application. The dashboard brings together multiple charts—including a main time series chart, a page statistics chart, a server load chart, and region-based charts (both column and pie charts)—to provide a comprehensive view of server traffic and performance data.
The example is structured around React hooks and <SciChartReact/> components to manage lifecycle events and context. It uses a custom VisibleRangeSynchronizationManager to coordinate zooming and panning across different chart surfaces; see the Synchronizing Multiple Charts documentation for more details. Custom tooltip templates are implemented via option functions registered with the ChartBuilder API, as described in the Complex Options guide. Dynamic styling is achieved through a CustomPaletteProvider that adjusts point markers based on metadata, following the guidelines in the PaletteProvider API. Additionally, a specialized GridLayoutModifier enables the transformation of the server load chart into a grid of sub-charts with smooth animations, which is in line with techniques presented in the SubCharts Worked Example.
Key features include real-time data updates, interactive data filtering, and advanced tooltips that display aggregated statistics (such as average request duration). The dashboard also supports a 100% stacked column view for URL statistics, which aggregates data across different pages as detailed in our Stacked Column Chart resources. Interactive animations and hover effects are implemented using the GenericAnimation framework (Generic Animations), and mouse event synchronization across chart modifiers is managed by a custom ModifierGroup class.
The implementation demonstrates excellent integration with React by encapsulating individual charts into <SciChartReact/> components and coordinating them through a shared context and a chart group loader. Techniques for real-time updates are implemented to ensure efficient rendering and smooth performance, as recommended in Realtime Updates. Additionally, advanced synchronization of mouse events across multiple charts highlights best practices for interactive dashboards; more details can be found in the Synchronizing ChartModifier Mouse Events article. For further insights into integrating SciChart.js with React, developers are encouraged to review the React Charts with SciChart.js blog post.

This demo showcases the incredible realtime performance of our React charts by updating the series with millions of data-points!

This demo showcases the incredible performance of our React Chart by loading 500 series with 500 points (250k points) instantly!

This demo showcases the incredible performance of our JavaScript Chart by loading a million points instantly.

This demo showcases the realtime performance of our React Chart by animating several series with thousands of data-points at 60 FPS

See the frequency of recordings with the React audio spectrum analyzer example from SciChart. This real-time audio visualizer demo uses a Fourier Transform.

Demonstrates how to create Oil and Gas Dashboard

This demo showcases the incredible realtime performance of our JavaScript charts by updating the series with millions of data-points!

This demo showcases the incredible realtime performance of our React charts by updating the series with millions of data-points!

Demonstrates a custom modifier which can convert from single chart to grid layout and back.

Demonstrates how to repurpose a Candlestick Series into dragabble, labled, event markers

Population Pyramid of Europe and Africa

Demonstrates how to use the SVG render layer in SciChart.js to maintain smooth cursor interaction on heavy charts with millions of points.