2026 Scientific Data Visualization Libraries Comparison for Lab Instrument Software

The best scientific charting libraries in 2026 are SciChart, Chart.js, Plotly, VTK and D3.js, but for laboratory instrumentation software the choice is a platform decision, not a widget choice. Instrument makers rarely ship a single application. They ship a suite: acquisition and control software at the instrument, analysis tools on the workstation, and increasingly a browser view so colleagues can review results from another lab, or another country.

The chart library underneath sets how every one of those products looks, behaves and gets validated for years. A scientist analyzing a chromatogram, an IR spectrum or a mass spectrum should be able to zoom, compare and annotate the same way in every tool you ship.

This scientific charting library comparison covers the five scientific data visualization libraries that research labs and instrument teams shortlist most in 2026: SciChart, Chart.js, Plotly, VTK and D3.js. It is written for the product owners and project managers who write the requirements, as well as the developers who build them. We built SciChart, so for every other library we have relied on its own documentation rather than our opinion of it.

Table of Contents:

• What Are the Best Scientific Charting Libraries for JavaScript and WPF in 2026?
• What Do Scientific Instrument Teams Actually Need From a Charting Library?
• Which Charting Library Handles Large Scientific Datasets With Annotations and Overlays?
• How Do You Choose a Cross-Platform Charting Library for JavaScript, WPF, and Mobile Lab Software?
• Which Chart Types Do Chromatography, Spectroscopy and Mass Spectrometry Software Need?
• Why Does Supportability Matter for Regulated Lab and Diagnostic Software?
• What Should Product Owners Put in a Charting Library Requirements Spec?
• What Should Developers Check When Evaluating a Scientific Charting Library?
• Which Instrument Makers and Research Teams Use SciChart?

Key Takeaways

• For instrument software, consistency across a product suite matters as much as speed. Labs standardize on software platforms to cut training and validation effort, and the charts inside those platforms need to behave the same everywhere.
• Performance is the entry ticket, not the deciding factor. Plotly’s documentation flags SVG slowdowns above roughly 15,000 points. SciChart.js can render up to 1 billion data points in browsers that support 64-bit WebAssembly, and SciChart WPF handles billions per dataset.
• Analysis depth decides the shortlist: zooming into peaks, overlaying samples, highlighting bands and annotating results, all on large datasets at the same time.
• Many instrument suites pair a desktop application with browser-based review, so JavaScript and WPF support behind one consistent API is a practical requirement.
• In regulated settings, a supported commercial component with versioned releases and documented limitations is easier to qualify than an unsupported one.
• For developers, the practical tests are framework fit, how the library handles many charts and streaming data, and how quickly you can get answers from documentation and support.
• No neutral benchmark compares all five libraries. Test each one with your own data, annotations and overlays included.

What Are the Best Scientific Charting Libraries for JavaScript and WPF in 2026?

The strongest options in 2026 are SciChart, Chart.js, Plotly, VTK and D3.js. They differ most in how they draw pixels and where they run, and those two facts decide whether one library can cover an entire instrument suite.

For instrumentation teams that need scientific charting libraries for JavaScript and WPF from one vendor, the platforms column matters most. Chart.js and D3.js live in the browser, so a WPF or native desktop application needs a second chart layer with its own behavior, bugs and look. Plotly suits analysts working in Python and R, but it is not a component you embed in a WPF acquisition app.

The best fit column shows how far each library goes before your team starts building features itself. D3.js gives you drawing primitives rather than finished charts. VTK is the specialist for volumetric rendering such as CT and MRI stacks. SciChart is a GPU-accelerated charting library for JavaScript, React, WPF, iOS and Android, built as charting components for laboratory instrumentation, real-time data and large scientific datasets.

What Do Scientific Instrument Teams Actually Need From a Charting Library?

Instrument software teams need three things from a charting library: consistency across their product suite, depth of analysis, and freedom to customize. Performance matters, but only once those three are in place.

Consistency Across an Instrument Suite

Instrument makers typically ship a family of products, and their customers expect that family to feel like one system. The same zoom, the same selection, the same branding, wherever the scientist sits. It works the same way as a family of medical devices: once people learn one, they can use the rest faster and with fewer mistakes.

Lab buyers make this explicit when they choose software. When Waters launched its Empower 3 chromatography data system, it named reduced training and support effort, plus easier software validation as the benefits of standardizing on one platform. Agilent makes the same case: a single data system saves time managing software, training staff and meeting regulations.

The pain is real on the bench: scientists can end up juggling four vendor software tools to complete a single QC run. UX research explains why consistency matters: Nielsen Norman Group defines internal consistency as applying across a family or suite of applications, and links it to learnability and reduced confusion. A chart library with one API across JavaScript, WPF and mobile lets an instrument maker deliver that consistency without writing three chart layers.

Depth of Analysis

In most labs the hard part is not the size of the dataset. Plenty of scientific work, such as chromatography or IR spectroscopy, comes from a single detector. The hard part is what scientists need to do with the data once it is on screen:

• Zoom into peaks and troughs, isolate them and expand specific regions
• Overlay multiple samples and compare them like for like
• Highlight specific bands or regions of interest
• Annotate results, with markers, notes, dates and times
• Color individual points and attach metadata to them
• Use logarithmic axes, scientific notation and multiple axes on one chart
• Run reports and export results

Instrument makers are building exactly these interactions into their own tools: Waters’ browser-based Empower Data Viewer lets users view chromatograms, zoom into peaks, and overlay and compare data. When software cannot support the analysis, scientists export the data and continue somewhere else. A UX study of scientific instrument software found file export is the universal handoff point between tools, a pattern facilities call the workflow seam. Every feature missing from the chart layer widens that seam.

Freedom to Customize

Scientists investigate data in their own ways, and instrument makers need their software to look like their brand. A charting library for this market should support:

• Full theming and white-labeling, including your own colors, fonts and styles
• Dark and light modes, and palettes users can configure themselves
• Accessible color choices for people who read color differently
• Custom workflows and interactions built on top of the standard chart
• An extensible API, so you can build new visualization types when a customer needs one
• A choice between automatic resampling for very large datasets and presenting the raw data exactly as acquired, since some customers have strict requirements about how data is displayed

In SciChart, resampling is on by default and designed to be visually lossless, and it can be switched off per series when data must be shown exactly as acquired, at some cost to performance on very large datasets.

Which Charting Library Handles Large Scientific Datasets With Annotations and Overlays?

GPU-accelerated libraries such as SciChart handle large scientific datasets with annotations and overlays best, because rendering architecture, not point count alone, decides whether a library survives a real workflow. Every annotation, overlay, extra series, extra axis and piece of metadata adds work to each frame. A library that copes with one clean line can stall once a scientist overlays ten samples and marks up the peaks.

The reason is how each approach draws. SVG creates a separate page element for every mark, so the browser slows as marks multiply. Canvas avoids that overhead but still draws on the CPU. GPU engines built on WebGL and WebAssembly hand the drawing to the graphics card, which is why they scale into millions of points and beyond. At 60 FPS, each frame gets about 16.7 milliseconds to take in new data, draw it and respond to the user.

Figures, ours included, come from each vendor’s own documentation and test setups. The Chart.js performance guide suggests decimating data before it reaches the chart and rendering in a web worker with OffscreenCanvas.

Many Charts on One Screen

Scientific dashboards often show many linked views at once. Plotly’s documentation says you will generally fit 4 to 8 WebGL figures on one page before hitting browser context limits. A twelve-panel view needs a workaround such as virtual WebGL, which Plotly notes runs slower. SciChart.js avoids that limit because, by default, it uses a single shared WebGL context for all charts, and its SubCharts API draws large grids of charts in one pass. SciChart publishes a figure of 64+ charts refreshed in under one second.

Long Sessions and Memory

Instrument software often runs for hours or days. SciChart lists continuous 24/7 operation and zero memory growth among its published performance metrics, so long analyses and overnight acquisitions do not degrade. In the browser, SciChart.js holds chart data in WebAssembly memory rather than JavaScript arrays: up to 4 GB in the standard build, and up to 16 GB in 64-bit WebAssembly (wasm64) mode. The same rendering technology now supports most Formula One telemetry, simulation and engineering workflows, directly or indirectly.

Lightweight Enough for Inexpensive Hardware

Efficient rendering also lowers hardware requirements. That matters when an instrument ships with an embedded PC, or when field teams use low-cost tablets. PerkinElmer found SciChart’s lower hardware requirements kept production costs down across its chromatography product range (see the case studies below).

Performance With Real Features Switched on

The most useful benchmark is one that turns on the features your workflow needs. SciChart’s open-source JavaScript chart performance test suite compares libraries across scenarios such as multi-series and multi-axis charts.

How Do You Choose a Cross-Platform Charting Library for JavaScript, WPF, and Mobile Lab Software?

Start with where each product in your suite runs, then pick a cross-platform charting library that covers all of it with the same API. For many instrument makers that means a desktop application at the instrument plus a browser view for review, with mobile for field or portable work.

Why Desktop Plus Web Is Becoming the Norm

Modern science rarely happens in one lab. Teams share data across sites and review results from wherever they are. A typical pattern is an installable desktop application at the instrument, with a web view so a colleague can analyze mass spectrometry data from another location.

Instrument makers are building for this. Anton Paar’s AP Connect lab execution system lets users work with data from any connected client without returning to the lab bench, with multiple users reviewing data at the same time. Field work follows the same logic: a chromatography analysis run on a mobile device can be uploaded and reviewed elsewhere in exactly the same form.

SciChart supports this with SciChart WPF as the WPF scientific charting library on the desktop, SciChart.js in the browser, native iOS and Android SDKs, and Avalonia XPF for Windows and Linux, all sharing one engine and a consistent API. SciChart.js can also run anywhere a modern browser does, including desktop shells such as Electron, so teams can start with JavaScript everywhere and go native where they need to. For embedded instruments, SciChart Android runs on custom hardware as well as phones and tablets, and SciChart.js v5 was optimized for single-board computers in industrial and IoT environments.

Three Problems With Building Your Own Chart Layer per Platform

1. Rendering bottlenecks appear the moment high-frequency or annotation-heavy data outpaces the renderer.
2. Code duplication is the slower burn. Three platforms means three chart layers, three QA passes and three sets of bugs for one feature, and three slightly different user experiences.
3. Memory leaks and thermal throttling hit long sessions. A chart that was fine in a ten-minute test can crawl six hours into an experiment, or overheat a tablet at a hot field station. Fixed-size FIFO buffers help, as old points drop off when new ones arrive.

A shared engine removes all three. A fix or feature written once reaches desktop, web and mobile together, and your users get the same interactions, branding and workflows on every screen.

Which Chart Types Do Chromatography, Spectroscopy and Mass Spectrometry Software Need?

Each analytical technique has its own standard views, and chromatography and mass spectrometry chart software, like spectroscopy tools, should handle them without custom drawing code. Use this list to check each candidate against the techniques your instruments cover, including the ones on your roadmap.

Across these techniques, the building blocks repeat: XY line and scatter charts, logarithmic axes in scientific notation, multiple axes, contour plots, dense heatmaps, spectrograms, 3D surfaces and waterfalls.

General-purpose libraries leave much of this to you. Chart.js focuses on standard business charts, and D3.js gives you primitives to build from. Plotly and VTK each cover parts of the list. SciChart provides these chart types out of the box, and its API is extensible, so when a customer needs a visualization that does not exist yet, you can build it on the same engine rather than starting over.

Why Does Supportability Matter for Regulated Lab and Diagnostic Software?

In regulated settings, the chart library is a component someone has to qualify, so supportability becomes a selection criterion alongside features and speed.

Medical device software is the clearest example. Under IEC 62304, a third-party library is treated as SOUP (software of unknown provenance). Manufacturers must review its known anomalies against the device’s intended use and keep monitoring for new ones. Pharma and analytical labs carry a similar burden: Waters cites easier software validation as a key reason labs standardize on one platform.

That makes some library qualities worth checking before features:

• Versioned releases with release notes, so you can pin and track exactly what you ship
• Documented limitations and known issues
• Direct technical support from the people who build the library
• Active, long-term development, with published changelogs for every platform; SciChart aims to answer support tickets within one business day.

As an example of a documented limitation: in SciChart WPF, annotations are not rendered by the GPU engine, so we recommend keeping to around 1,000 annotations per chart and drawing large marker sets as a series instead.

SciChart is trusted in rigorously assessed environments, from cancer diagnostics research with the Mayo Clinic to clinical neurotechnology at NeuroRestore. A commercial component with direct support, versioned releases and documented behavior is easier to qualify than one with no accountable vendor.

What Should Product Owners Put in a Charting Library Requirements Spec?

A good requirements spec tests a charting library against your whole product suite and its next few years, not just today’s demo. A 2026 library selection guide warns that teams who treat charting as an isolated front-end choice choose well for the demo but poorly for year three. Cover these points:

1. Platforms, now and on the roadmap: desktop (WPF), browser (JavaScript or React), mobile and embedded.
2. API consistency, so the same interactions and styling work on every platform you ship.
3. Worst-case data volume, tested with annotations, overlays, multiple series and multiple axes switched on.
4. Analysis interactions: zoom, pan, peak isolation, sample overlays, band highlighting, cursors and export.
5. Chart types for every technique your instruments cover, including planned ones.
6. Theming, branding, dark and light modes, and accessible color palettes.
7. Data display rules: whether raw data must be shown exactly as acquired, or resampling is acceptable.
8. Long-run stability over a full working day or an overnight acquisition.
9. Hardware requirements, especially for embedded PCs and low-cost field devices.
10. Supportability: versioned releases, documented limitations, direct support and long-term development.
11. Licensing terms for commercial distribution across your product range.

What Should Developers Check When Evaluating a Scientific Charting Library?

Developers building instruments and lab software should test a charting library in their real stack: how it fits their framework, how it handles streaming data and many charts, and how quickly they can get unstuck. A demo with one clean chart answers none of those questions.

Framework and Platform Fit

• Web: SciChart.js supports TypeScript, React, Angular and Vue, with WebAssembly and WebGL acceleration. Chart.js, Plotly and D3.js are browser-only.
• Windows desktop: SciChart WPF supports .NET and .NET Framework applications in C# and VB, rendering on DirectX.
• Mobile and embedded: native iOS and macOS (Swift, Objective-C) and Android (Kotlin, Java) SDKs, including Android on custom hardware.
• Linux desktop: Avalonia XPF, or SciChart.js in a browser or Electron shell.
• Gaps to know about: SciChart has no React Native wrapper (use the native SDKs or SciChart.js in a WebView) and no Python library (Plotly or Matplotlib suit notebook analysis).

Data Handling

• Typed data series with Float64 arrays and FIFO mode for continuous streaming
• Automatic, visually lossless resampling, switchable off per series for raw display
• Up to about 250 million XY points with the standard WebAssembly build (4 GB), and up to 1 billion with the optional 64-bit WebAssembly mode (16 GB) in Chrome, Edge and Firefox

Many Charts on One Page

Browsers allow only a handful of WebGL contexts per page, which is why Plotly’s documentation caps most pages at 4 to 8 WebGL figures. SciChart.js shares one WebGL context across all charts by default, and the SubCharts API handles large dashboard grids.

Habits That Keep Any Chart Library Fast

1. Keep X values sorted: hit-testing, indexing and resampling all depend on it.
2. Batch updates. Pushing more data less often beats a flood of tiny appends.
3. Decimate early if your library does not resample. Chart.js advises reducing data before it reaches the chart.
4. Count your WebGL contexts on multi-chart pages, especially with Plotly.
5. Profile over a full working day or an overnight run. Memory leaks hide in long sessions.

Getting Unstuck

Check the documentation depth, examples and support model before you commit. SciChart offers over 350 chart examples, public forums with thousands of answered questions, an AI assistant trained on its docs, and direct technical support.

Which Instrument Makers and Research Teams Use SciChart?

Four published SciChart stories show what consistency, analysis depth and stability mean in practice, from chromatography and protein analysis to cancer diagnostics and spinal cord injury research.

PerkinElmer: A Chromatography Platform Built on Usability and Flexibility

PerkinElmer’s GC series chromatography platform competes in a crowded sector where usability and flexibility are the differentiators. SciChart’s lower hardware requirements also kept production costs down across the product range. For an instrument maker, that is the suite argument in one sentence: the same capable charts on every product, without raising the hardware bill. SciChart’s customizable charts were used to build PerkinElmer’s SimplicityChrom CDS software, where deep configuration and complex annotation overlays let users tailor report outputs to their needs while keeping the software intuitive.

Find Out More

NanoTemper: Protein Stability Analysis

NanoTemper builds instruments for biophysical characterization of proteins, including protein stability analysis. NanoTemper needed to display multi-parameter information on conformational and colloidal stability from its Prometheus device, so users could spot liabilities or stability enhancements that other technologies missed. SciChart was selected to present the high-resolution data with consistent reliability, backed by 64-bit, double-precision charting.

University of Illinois and Mayo Clinic: Infrared Spectroscopy for Cancer Diagnostics

The University of Illinois and the Mayo Clinic built the first laser-scanned confocal microscope for infrared spectroscopy, using SciChart heatmaps for real-time imaging. The project helped cut tumor biopsy times from weeks to hours. Dense, constantly refreshing heatmaps are where Canvas and SVG tend to buckle first, so the rendering engine carried real weight.

NeuroRestore: Helping Paralyzed Patients Walk Again

NeuroRestore is a Swiss treatment center built on research by neuroscientists Grégoire Courtine and Jocelyne Bloch, aiming to help paralyzed patients walk again. The clinical team needed to watch up to 16 EMG sensors at once, alongside the epidural stimulation being delivered. The stimulation hardware updated frequency, amplitude and timing across up to 10 waveforms in real time, and researchers had to see the waveforms and muscle responses together, with no lag, to tune programs on the spot. EPFL reported that participants took up to 300 independent steps on the first day of stimulation. The real-time display was built on SciChart WPF.

Read Case Study

Which Charting Library Should Your Team Test First?

Match the shortlist to your product suite, your techniques and your data.

• Standard web charts with small datasets suit Chart.js.
• Bespoke one-off graphics suit D3.js.
• Exploratory analysis in Python or R suits Plotly.
• 3D volumes and medical imaging suit VTK.
• If you are building instrument software that needs consistent, deeply interactive scientific charts across desktop, web and mobile, with large datasets, SciChart belongs on your shortlist.

Rankings of the best data visualization tools for scientific research in 2026 tend to compare feature lists, and demos flatter every library. Test each candidate with data close to what your instruments actually produce, with the overlays, annotations and multiple axes your scientists will use, over a full working day.

The free SciChart.js community license lets you test JavaScript and React performance on real data, for non-commercial use or a commercial evaluation. It carries a watermark, which a paid license removes.

Try SciChart with your own data, explore our scientific chart examples, or browse the React chart demos to see GPU rendering running live in the browser. If you would like help matching SciChart to your platforms and instruments, our team is happy to talk it through.

FAQs

What is the best charting library for scientific instrument software?

It depends on your platforms and data. For suites that need the same interactive charts on desktop, web and mobile, with large datasets and rich annotation, SciChart is built for the job. For browser-only reporting, Chart.js is a simpler option.

Does SciChart support JavaScript and WPF?

Yes. SciChart offers SciChart.js for JavaScript and React, SciChart WPF for Windows desktop applications, and native SDKs for iOS and Android, all built on the same engine.

Can SciChart be used for chromatography software?

Yes. SciChart supports HPLC and GC chromatograms, run overlays, peak integration views and calibration curves, and is used in PerkinElmer’s GC chromatography platform.

Can SciChart be used for mass spectrometry?

Yes. SciChart handles mass spectra, TIC and XIC traces and compound comparisons, with zooming, overlays and annotations for peak analysis.

Can SciChart display IR, FTIR, Raman and NMR spectra?

Yes. Spectra, overlays, logarithmic axes in scientific notation and spectrograms are supported. SciChart heatmaps powered real-time infrared spectroscopy imaging at the University of Illinois and the Mayo Clinic.

Can SciChart plot qPCR amplification and melt curves?

Yes. Amplification and melt curves are XY line charts with multiple series, overlays and annotations, all supported out of the box.

Can SciChart be used for flow cytometry and particle analysis?

Yes. SciChart supports scatter and density scatter plots, histograms and size distributions.

Where can SciChart be used in scientific and lab software?

SciChart is used across analytical and life sciences instrumentation, including chromatography (HPLC, GC, LC), mass spectrometry (GC-MS, LC-MS), IR, FTIR, Raman and NMR spectroscopy, proteomics, qPCR, DNA sequencing, flow cytometry, particle analysis, X-ray diffraction, thermal analysis, electrochemistry, birefringence imaging and protein stability analysis. See SciChart for diagnostics and life sciences.

Can SciChart be used for proteomics and protein analysis?

Yes. SciChart supports peptide plots, spectra, overlays and compound comparisons, and is used for protein stability analysis. NanoTemper uses SciChart to present protein stability data from its Prometheus instruments.

Can SciChart be used for X-ray diffraction, thermal analysis and electrochemistry?

Yes. SciChart plots diffraction profiles, temperature sweeps, time-resolved data, voltage and charge-discharge curves and impedance plots, with multiple axes and overlays.

Can SciChart be used for DNA sequencing and birefringence imaging?

Yes. SciChart lists DNA sequencing and birefringence imaging among its diagnostics and life sciences applications, alongside mass spectrometry, gas chromatography, qPCR and spectroscopy.

Can SciChart visualize spectral frequency analysis?

Yes. SciChart displays frequency spectra, spectrograms and heatmaps, so teams can analyze spectral frequencies in real time alongside the raw signal.

Can SciChart zoom and pan through large scientific datasets?

Yes. Zooming and panning, peak isolation, cursors, logarithmic axes in scientific notation and multiple axes work on large datasets out of the box.

Does SciChart support remote viewing of instrument data?

Yes. Teams typically use SciChart WPF in the desktop application at the instrument and SciChart.js for remote viewing in the browser, with consistent chart behavior in both.

Is SciChart a 64-bit charting library?

Yes. SciChart is a true 64-bit library: its charts, series and API functions can use double-precision floating point, with scientific notation and logarithmic scales for demanding analytical work.

Can SciChart.js handle billion-point scientific datasets in the browser?

Yes. Its optional 64-bit WebAssembly mode gives charts up to 16 GB of browser memory, enough for around 1 billion data points, so full-resolution scientific data can be reviewed without server-side downsampling. It runs in Chrome, Edge and Firefox; other browsers use the standard engine, which holds around 250 million points.

What are the best charting components for scientific applications?

The best charting components for scientific applications combine GPU rendering, scientific chart types, rich annotation and a consistent API across platforms. SciChart offers these for JavaScript, React, WPF, iOS and Android; Plotly, Chart.js, VTK and D3.js each cover narrower use cases.

Can SciChart show raw data without resampling?

Yes. Resampling is on by default and designed to be visually lossless, but you can switch it off per series to present data exactly as acquired, with some performance cost on very large datasets.

Can SciChart charts match my company’s branding?

Yes. Themes, colors, fonts, dark and light modes and user-configurable palettes let you white-label the charts across your suite.

Does SciChart support 3D scientific visualization?

Yes. SciChart offers 3D charts such as surfaces, waterfalls and scatter plots, built on the same GPU-accelerated engine as its 2D charts.

SciChart vs Plotly: which is better for scientific applications?

Plotly suits exploratory analysis in Python, R and the browser. SciChart suits shipped instrument software that needs GPU-rendered charts across JavaScript, WPF and mobile, with large datasets and more charts per screen than Plotly’s documented 4 to 8 WebGL figures per page.

What is the best WPF chart control for scientific instruments?

SciChart WPF is built for scientific instrument software, rendering billions of points per dataset on a DirectX engine, with an API consistent with SciChart.js for browser-based review tools.

What is the best JavaScript chart library for scientific data?

For large or real-time scientific datasets, a WebGL and WebAssembly library such as SciChart.js scales furthest; it can render up to 1 billion points in browsers that support 64-bit WebAssembly. For small datasets and standard charts, Chart.js is simpler.

Is there a free version of SciChart?

Yes. The SciChart.js community license is free for non-commercial use and commercial evaluation. It carries a watermark, which a paid license removes.

Is there a SciChart Python library?

No. SciChart does not offer a Python library. Teams working in Python notebooks often use Plotly or Matplotlib for analysis and SciChart in the shipped instrument application.

What are the best data visualization libraries for scientific applications?

For shipped scientific applications with large or real-time datasets, GPU-accelerated charting libraries such as SciChart lead on performance and analysis tooling. Plotly suits exploratory analysis, VTK suits 3D volumes, Chart.js suits small web datasets, and D3.js suits bespoke graphics.

Which scientific visualization tools do research labs use?

Research labs typically combine analysis tools such as Python with Plotly or Matplotlib, instrument software from vendors like Waters, Thermo Fisher and Agilent, and custom applications built on charting libraries such as SciChart for real-time and large-dataset work.

How do I draw a mass spectrum as a stick plot with m/z labels on the major peaks, without labels overlapping?

Use an impulse (stem) series with data labels. SciChart.js data labels can hide overlapping labels, skip points, or appear only when there is room, and a custom label layout manager can resolve overlaps across several overlaid spectra.

How do I link a TIC chromatogram to the mass spectrum at a clicked retention time?

Use the hit-test API on the chromatogram series to find the data point under the click, then load that scan into the spectrum chart’s data series. Linked charts keep zoom and cursors in step, so analysts can move between the TIC, XICs and spectra without losing their place.

How do I plot NMR or FTIR spectra with a reversed x-axis (ppm or wavenumber decreasing left to right)?

Set flippedCoordinates on the X axis. Zoom, pan, annotations and hit-testing all follow the reversed axis, so you do not need to transform the data.

How do I display diode array data (time × wavelength × absorbance) as a heatmap with contour lines?

Plot the matrix as a uniform heatmap with a color map, then overlay a contours series on the same data. Use the non-uniform heatmap when wavelength or time steps are uneven.

How do I let analysts drag integration limits or mark a peak region by hand?

Use editable annotations: vertical line or box annotations with isEditable set can be dragged on the chart at data coordinates. Read their X positions to define the integration window; the integration itself stays in your application code.

How do I keep zoom and cursors synchronized across stacked detector traces, such as UV, MS and pressure?

Link the charts so they share the X range and cursor. SciChart.js has a dedicated tutorial on linking multiple charts, and SciChart WPF supports the same pattern for stacked panels.

How do I stream detector data for hours without memory growth?

Use a data series in FIFO mode with a fixed capacity, so old points drop off as new ones arrive, and append in batches rather than point by point. Declaring that X is sorted and contains no NaN values lets SciChart skip those checks on every append.

How do I show a gap where acquisition paused or a detector dropped out?

Append a NaN value at the gap so the line breaks instead of joining across missing data.

How do I keep full precision for high-resolution m/z values or nanosecond timestamps?

SciChart is a 64-bit library: data series, axes and API functions use double-precision floating point, so values with many significant figures or large offsets are not rounded the way 32-bit GPU pipelines can round them.

How do I render a 96- or 384-well plate of qPCR amplification curves on one screen?

Use the SubCharts API, which places a grid of small charts on one surface sharing a single WebGL context. SciChart’s worked example builds a 10×10 grid, and the same approach scales to plate layouts.

Can I reuse chart code between a WPF acquisition app and a SciChart.js review tool?

Not directly: one is C# and the other is TypeScript. The concepts (series, axes, modifiers, annotations, themes) mirror each other, so you can match behavior and styling across both, and SciChart.js charts can be serialized to JSON to save and restore chart state.

How do I qualify SciChart as SOUP under IEC 62304?

Pin a specific version, record it in your SOUP list, review the published changelog and known issues against your device’s intended use, and monitor new releases for anomalies. SciChart’s versioned releases and direct support make that evidence easier to gather; the qualification itself remains your responsibility.

Can SciChart be used in regulated diagnostic or medical software?

SciChart is used in rigorously assessed environments, including cancer diagnostics research with the Mayo Clinic. As a commercial component with versioned releases, documented limitations and direct support, it is easier to qualify than an unsupported library.