Welcome to this new LightningChart .NET article. In this project, we’ll create a multi-channel chart where each channel runs as an independent object (or multiple threads) and add a process with a volume of up to 1 trillion points. We’ll use several UI controls that will allow us to manipulate the process in real time. About LightningChart .NET, the library is a highly optimized charting tool for .NET, especially useful when working with large volumes of data or real-time updates. Unlike more generic charting solutions, LightningChart .NET can smoothly handle millions of data points.

Threads and Concurrency

In programming, a thread is the basic unit of execution within a process. A single program can have multiple threads running in parallel, each tasked with performing specific tasks independently.

Why use threads?

Imagine an application that needs to process huge volumes of information (for example, up to 1 trillion data points in real time) and at the same time respond fluidly to user actions (such as clicks, scrolling, or window resizing). If all this load falls on a single thread, the interface can become slow, unresponsive, or even crash completely. To avoid this, secondary or “background” threads are used, which can handle intensive tasks without compromising the user’s experience.

What is concurrency?

Concurrency allows multiple tasks to be executed simultaneously or alternated between tasks efficiently. In the context of workload-intensive applications, it is common to have a main thread for the graphical interface, while other threads handle operations such as complex calculations, data analysis, or generating large volumes of information. In this project, we used a separate thread dedicated exclusively to generating and processing real-time data, capable of handling up to a trillion data points. This ensures that, even under a massive load of information, the graphical interface remains agile, fluid, and fully interactive.

Sampling Rate

The sampling rate indicates how many samples per second are taken from a continuous signal to convert it into digital data. For example, if you have a temperature sensor and want to record its value 100 times per second, then your sampling rate is 100 Hz (100 samples per second).

Why is it important?
An appropriate sampling rate is essential to accurately represent a signal. If you sample too slowly, you risk missing critical changes or generating imprecise data. On the other hand, sampling too fast may result in an overwhelming amount of data that can strain system resources.

In large-scale data environments (such as those processing up to 1 trillion (1,000,000,000,000) data points), choosing the right sampling rate becomes even more crucial. Efficient sampling ensures meaningful information is captured without overwhelming memory or computing capacity.

In this project, we use the sampling rate to simulate how many samples should have been generated based on the time elapsed, helping maintain a smooth and consistent chart update rhythm. This approach is designed to remain efficient and responsive, even when handling extremely high data volumes.

Well, with this brief introduction, I think we’re ready to move on with the project. Let’s get started!

To follow this project, download the ZIP file with all the necessary resources.

1. OS: 32-bit or 64-bit Windows Vista or later, Windows Server 2008 R2 or later.
2. DirectX: 9.0c (Shader model 3 and higher) or 11.0 compatible graphics adapter.
3. Visual Studio: 2022 for development, not required for deployment.
4. Platform .NET Framework: installed version 8.0 or newer.

Now go to the next URL and download LightningChart .NET. You’ll then be redirected to a sign-in form where you’ll have to complete a simple sign-up process to get access to your LightningChart account.

After signing in to your account, you can download the SDK “free trial” version that allows you to use important features for this tutorial. When you download the SDK, you’ll have a .exe file like this:

The installation will be a typical Windows process, so please continue with it until it is finished. After the installation, you will see the following programs:

License Manager

In this application, you will see the purchase options. All the projects that you will create with this trial SDK will be available for future developments with all features enabled.

Once you run the example in the “interactive examples” application, you will see the following option

Lightning Chart can generate a project for the current selected chart, using Windows Presentation Foundation (WPF), WinForms, and their NET6 versions. 

Once you select the extract option, you will have to create a new folder for the project

Once the project is saved, Visual Studio will open by itself, and you’ll see a project like this

This CreateChart() code creates and configures a high-performance real-time chart using LightningChart, optimized to display massive datasets (up to a trillion points or more). It sets up:

• Smooth rendering and layout for fast updates.
• A scrolling X-axis for live data monitoring.
• Gradient effects to visually distinguish old vs. new data.
• Performance tweaks like memory cleanup and fixed margins.
• Then it adds the chart to the UI and starts data visualization.

Initialize and Configure the Chart

A new LightningChart object is created and updated within a BeginUpdate block for performance.

It sets a title, rendering options like anti-aliasing, and DirectX rendering preferences to optimize performance for huge datasets (like 1 trillion points).

Set Up X-Axis for Real-Time Data Scrolling

The X-axis is configured for scrolling, meaning it moves automatically with incoming data. Label formatting, titles, and range are adjusted for clarity. Enables high-performance handling of continuous data by disabling label auto-formatting and setting a fixed range.

Optimize View Layout and Performance

Enables real-time cleanup of old data (DropOldSeriesData = true) to save memory.

The Y-axis layout is stacked with custom spacing and positioning to make multiple series readable.

Margins are fixed to prevent layout recalculations, which are expensive with large datasets.

Add Visual Sweep Effects for Data Movement

Two gradient bands (dark and bright) are created and bound to the X-axis. These bands visually show the sweep or movement of data. One represents “old” data fading out (dark), and the other highlights “new” incoming data (bright).

UI and Final Touches

The legend box is hidden to declutter the UI. The chart update ends with EndUpdate() to render everything in one go, improving efficiency.

Add Chart to UI and Start Rendering

The chart is added to a UI grid layout at a specific row and column. Finally, it is called Start(), which is a method that begins the live data feed or simulation.

Start()

The Start() method initializes the chart with a new digital line series, based on user inputs. It ensures a clean setup, generates all necessary data, configures axes and series, and optionally preloads data. It’s designed for high-speed, real-time plotting of binary-style signals across multiple channels.

Reset State and Hook Up Rendering Event

It resets counters for rounds, points, and renders frames. Stops a stopwatch used for performance tracking. Detaches and reattaches the CompositionTarget.Rendering event (this ensures a clean start for rendering). Updates the Start/Stop button text to say “Restart”.

Read and Validate User Inputs

Retrieves values from input fields for Number of data series to show, Points to append per update round, X-axis length (range of time or point count). If any input is invalid, a message box is shown, and the method exits early.

Generate Input Data Before Charting

Calls CreateInputData() to pre-generate all the data that will be used. This avoids on-the-fly data generation, keeping the real-time charting smooth and fast.

Clear Existing Chart Content

Calls helper methods to dispose of old series and Y-axes before drawing new ones. This prevents memory leaks or overlapping visuals from previous runs.

Create New Y-Axes and Data Series

For each series (based on user input), a new Y-axis is created with a custom color, title, and layout. A new digital line series is added, representing binary-like high/low signal lines. Sampling rate and initial timestamps are set for consistent data spacing. The final Y-axis includes a mini scale (small overview window) for better context when zooming or hiding axes.

Finalize Setup and Optionally Prefill Data

The X-axis is set to span the user-defined length. If the “Prefill” checkbox is checked, it preloads the chart with data, which may take a few seconds but gives immediate visual results. Finally, ends the update block with _chart.EndUpdate() to render everything in one go.

CreateInputData()

The CreateInputData() method pre-generates all data points for each series in advance. It builds a 2D array of random digital-like patterns, ensuring that data can be added to the chart quickly and smoothly during real-time visualization.

PrefillChartWithData()

The method PrefillChartWithData() fills the chart with pre-generated digital data before live updates begin. It uses parallel processing for speed, efficiently appends binary-style data, and sets the X-axis to the correct scroll position (so the chart looks active and responsive from the start).

FeedData()

FeedData() pushes the next chunk of data to the chart, advances the view, and adjusts visual effects to match the scroll behavior, making the chart look alive and in motion.

Append New Data to Each Series

For every series, it copies a slice of pre-generated data and appends it using AddBits(). This is done in parallel for speed, simulating a new “frame” of incoming digital signal data.

Scroll the X-Axis to Show New Data

It updates the scroll position of the X-axis based on how many points have been added so far. It also keeps the chart moving forward in real-time.

Update Sweep Bands Based on Scroll Mode

If the X-axis is in sweeping mode, it shows two gradient bands: 1) one for old data fading out (dark), and 2) one for new data (bright).

If not sweeping, it hides the bands to match the display mode.

Working with massive data volumes, especially when they involve millions or even trillions of points across multiple real-time channels, is notoriously difficult. But LightningChart .NET transforms this complex challenge into a surprisingly simple and high-performance experience.

From the first steps, such as setting up charts and axes, to real-time data feeds and visual effects, the framework is designed for speed, scalability, and developer convenience. It can dynamically generate dozens (or even hundreds) of digital line series, each with its own Y-axis, style, and layout, all in just a few lines of code.

The library handles axis stacking, label placement, and even optimizations like pre-allocating space to avoid UI resizing delays when plotting large datasets. What LightningChart truly excels at is internal performance tuning.

Features such as bit-packed digital data (AddBits()), parallel data appending, GPU acceleration, and real-time memory management (e.g., automatically removing old data points) allow dozens of series to be updated simultaneously, seamlessly.

Another highlight is its support for visual continuity and responsiveness. Tools like sweeping gradient bands help users visually separate old and new data, while real-time scrolling and customizable prefill options ensure the chart looks real from the moment it appears. It not only displays data but presents it with clarity, fluidity, and context.

LightningChart .NET not only prioritizes performance but also respects the developer’s time and workflow. Whether you’re developing for scientific monitoring, industrial systems, financial indicators, or multi-channel diagnostics, the API is designed to adapt to your needs without overburdening you with complexity.