We’ve moved over to a new format for communicating our releases and updates of our high performance JavaScript Charts library, by publishing a rolling changelog of every fix or enhancement in SciChart. You can find the changelogs in the top menu at Developers -> Changelogs -> SciChart JS ChangeLog

What’s New in v3.3 of SciChart’s JS Charts?

Today we have released v3.3.560 of SciChart.js. This is a cumulative update which contains very important fixes and features since our last announced release, version 3.2.

Version 3.3 contains important fixes including one fix to licensing which can affect production apps. It is backward compatible to v3.x, and it is highly recommended for all users to update. More details below.

Changes since version 3.2

Critical Fixes

IMPORTANT! Licensing issue in version range 3.2.446 to 3.2.555 By far the most important issue we’ve fixed is a licensing issue in SciChart.js, which affected version range 3.2.446 to 3.2.555. These versions have been marked as deprecated in npm.

This issue is expressed as a license expired error where you can see the error message “Sorry! This version of SciChart is too old to be used for the community edition. Please update to the latest version” even if a license key has been applied.

The resolution to this is as follows:

Update your application to using SciChart.js v3.3 or greater

If you are unable to update SciChart.js to v3.3 there is a workaround in code which can also be applied. Contact tech support if you require more information.

New Features

A number of new features & enhancements to the API have been included since version 3.2, these include:

1. VerticalSliceModifier Feature

We’ve added a new modifier type, the VerticalSliceModifier plus an example showing how to use it. The VerticalSliceModifier example demonstrates our newest modifier, which allows you to place vertical lines on the chart with tooltips. Lines are draggable, selectable and can be added/removed. More than one line may be added to the chart.

VerticalSliceModifier Multiple Tooltip Line Example

Learn how to use the VerticalSliceModifier, a new feature in SciChart.js which allows you to place one or more vertical lines on the chart, which slice the time-series and display a tooltip. Lines can be added, removed, selected or dragged. Multiple lines can be added to a single chart. … Continue reading VerticalSliceModifier Multiple Tooltip Line Example

demo.scichart.com

2. IAdvancedPaletteProvider Feature

We made multiple improvements to the PaletteProvider API to allow better performance. The PaletteProvider is the API which allows per-point colouring on data-points (bars, line segments, scatter points, bubbles) in SciChart.js. Currently this is a function which is run once per render allowing you to modify the data-point colour dynamically. IAdvancedPaletteProvider interface allows you to create a PaletteProvider with optionally cached outputs for all data-points. Rather than calling a function point-by-point to evaluate data-point color, the IAdvancedPaletteProvider allows you to return an array of colors for data-points. This is significantly faster for cases which require frequent color changes on the chart or graph. Official documentation for the IAdvancedPaletteProvider will be added shortly. Typedoc API docs can be found here.

3. Axis.isStaticAxis Feature

We’ve added a property to AxisBase.isStaticAxis. When set to true:

• Gridlines and labels always appear at fixed positions on the chart
• For example, if you have AxisBase.isStaticAxis = true then ten labels / major gridlines will be placed on the chart, always at the same position
• When in this mode, Axis.MaxAutoTicks defines the number of labels. E.g. when set to 10, you will get 10 labels / major gridlines equally spaced over the chart
• If you update the Axis.visibleRange programmatically, or by zooming, the labels / gridlines will stay in the same place, however, label values will update
• This type of chart can be used to create oscilloscope or reporting charts where fixed labels at specific locations are important.

Official documentation for the Static Axis feature will be added shortly. Typedoc API docs can be found here.

4. RenderDataTransforms Feature

RenderDataTransforms is a new low level api that allows you to transform your data just before it is drawn. SciChart currently uses it this internally to do spline interpolation, but it has the potential to support all kinds of cool features, like changing the color of a line between data points (by adding extra geometry), and applying multiple different line styles and pointMarkers to a single series. Official documentation for RenderDataTransforms plus demos will be added shortly. Typedoc API docs can be found here.

5. New Demos

In addition, a number of new demos have been created since the v3.2 release of SciChart.js. These include:

React / JavaScript Server Traffic Monitoring Dashboard demo

Shows how to create a rich interactive 'Grafana style' server traffic dashboard in React JS using SciChart. Several charts are linked together with synchronized zooming and panning. The demo features drilldowns, hover styling events, hoverable tooltips and more … Continue reading React / JavaScript Server Traffic Monitoring Dashboard demo

demo.scichart.com

Draggable Range Bar Event Markers with Labels in JavaScript

Range bars can be added to a JavaScript chart with optional labels. In this demo, we show how to use a combination of custom rendering and the chart modifier API to enable click selection and dragging of these range bars … Continue reading Draggable Range Bar Event Markers with Labels in JavaScript

demo.scichart.com

VerticalSliceModifier Multiple Tooltip Line Example

Learn how to use the VerticalSliceModifier, a new feature in SciChart.js which allows you to place one or more vertical lines on the chart, which slice the time-series and display a tooltip. Lines can be added, removed, selected or dragged. Multiple lines can be added to a single chart. … Continue reading VerticalSliceModifier Multiple Tooltip Line Example

demo.scichart.com

Synchronize Multiple Charts in React & JavaScript

Using SciChart.js APIs shows how to dynamically add and remove charts to a synchronized group. All charts zoom, pan together. Tooltips synchronize across charts. Chart panes may be removed from the sync individually. This allows for highly dynamic charts with multiple panes … Continue reading Synchronize Multiple Charts in React & JavaScript

demo.scichart.com

Bug Fixes

Since version 3.2 was released in July 2028 there are also lots of bug fixes which have been deployed to SciChart.js. These have been rolled into v3.3. You can see a full breakdown of bug fixes and their dates/version in the ChangeLog.

• (3.3.560, 29th Jan 2024)
  • This release fixes an critical licensing issue affecting any application deployed with a 3.2 version of SciChart. All users need to update.
• (3.2.555, 18th Jan 2024)
  • Small release mainly to fix a bug with rollover/hittest when using FIFO sweeping mode.
  • We are starting a process of trying to reduce the webassembly data file size. Minor changes initially, but expect significant improvements in v4 coming soon.
  • Removed some unnecessary assets from data file
  • SCJS 1596 expose dataSeries.FindIndex and fix some minor bugs there.
  • SCJS 1701 – HitTest is wrong for fifo sweeping
• 3.2.549 (8th Jan 2024)
  • Modifiers with multiple subcharts are now slightly easier thanks to isActiveSubChartEvent added to ModifierMouseArgs. This is useful for Sub Charts with a modifier group.
  • DefaultPaletteProvider still had shouldUpdatePalette false. Default false until v4
  • Js/scjs 1628 Fixed candlestick charts crashing on safari iOS 17
  • Auto cleanup subscriptions in DataPointSelectionModifier
  • SCRTDoubleVector does not push_pack correctly for capacity 1
• 3.2.543 (21 December 2023)
  • A final release for the year to fix a performance edge case and also to make the default behaviour of PaletteProvider consistent with what it was before the change in 5.3.8, which is to recalculate the palette on every render. To get the performance benefit of reuse on a static palette you need to add the shouldUpdatePalette method to your PaletteProvider and return false if the palette can be reused. We will be changing this default in version 4 to reuse if at all possible.
  • SCJS-1685 Improve performance when series is panned out of view.
• 3.2.538 (24th November 2023)
  • As well as some more fixes, this release includes the new RenderDataTransforms. This is a low level api that allows you to transform your data just before it is drawn. SciChart currently uses it to do spline interpolation, but it has the potential to support all kinds of cool features, like changing the color of a line between data points (by adding extra geometry), and applying multiple different line styles and pointMarkers to a single series. Expect more documentation, demos and features using this in 2024.
  • The PaletteProvider api has also been improved. Palettes can now be reused, with a property isRangeIndependant and a function shouldUpdatePalette to control when palette recalculation should occur. You can now even take full control of the palette by implementing IAdvancedPaletteProvider, which gives you a single function call for all the data rather than a call per point.
  • Added RenderDataTransform api and used it for spline series
  • Allow palettes to be reused if nothing has changed
  • Added isRangeIndependant and shouldUpdatePalette to IPaletteProvider to control palette reuse
  • New IAdvancedPaletteProvider interface. This is a single method called instead of the per-point overrides. Its parameters give you access to the full data and palette
  • SCJS-1768 Added yRangeMode property to renderableSeries and set the default on this to revert to previous behaviour where the points just outside the visibleRange will be included in autoRange. This fixes issues where digital lines were escaping the axis when used on stacked axes.
  • SCJS-1683 Annotation coordinateMode Relative now works correctly on a stacked axis
  • SCJS-1682 Fixed hitTest could be offset when using CategoryAxis
  • Fixes for recently reported bugs and a new demo. Check out Draggable Event Markers
  • SCJS-1669 Make rollover work for stacked charts with multiple axes
  • SCJS-1670 Fix digital line being interpolated at the left edge of the chart
  • SCJS-1673 Fix errors if a RolloverModifier is removed and readded
  • SCJS-1764 VerticalSliceModifier should not be able to be dragged off the chart
  • Add showAxisLabel property for rollover and vertical slice
  • SCJS-1527 Fix setting series.isVisible does not update legend visibility checkbox
  • Fix TypeScript Content Security Policy (CSP) style-arc error for RubberBandZoomModifier
  • Remove a console.log
• 3.2.525 (21 November 2023)
  • Bugfixes, performance improvements and a few little features.
  • SCJS-1661 background and padding for TextAnnotation
  • SCJS-1655 shadowEffectColor on theme now applies to tooltips. To set individually use tooltipShadow for CursorModifier or renderableSeries.rolloverModifierProps.shadowColor for RolloverModifier AFTER the modifier has been added
  • SCJS-1660 Improve tooltip performance and positioning with many series
  • SCJS-1278 Rename useWasmFromCDN to loadWasmFromCDN to avoid eslint errors
  • SCJS-1612 Fix Rollover tooltip positioning for vertical charts
  • Subcharts do not receive mousemove events when cursor is off the chart
• 3.2.516 (13 November 2023)
  • Some quick fixes for issues reported on our forums.
  • SCJS-1656 fix External Legend positioning
  • SCJS-1657 DataLabels do not show properly for resampled data in some cases
  • axisTitleStyle option type should include rotation
• 3.2.509
  • A couple of small axis features in this release. We’ve also been working on a big new demo showcasing multiple synchronised charts called the Server Traffic Dashboard
  • SCJS-1637 cliptoYRange on renderableSeries allowing clipping to vertically stacked axis range
  • SCJS-1629 Add isStaticAxis property to axis which causes the labels and major gridlines to keep their initial positions when the visible range changes
  • SCJS-1634 SciChartVerticalGroup now synchronises axis widths
  • removed some unnecessary memory warnings
  • labelRadiusAdjustment should be a constructor option for SciChartPieSurface
  • SCJS-1633 Fix log axis slows the chart badly when zoomed far in
  • Fix datalabels not displaying when pointGap is 0, ie for single point, or vertically aligned data
• 3.2.491 (18th October 2023)
  • SciChart.JS now supports running in secure contexts using the “Content-Security-Policy” header set to “wasm-unsafe-eval”
  • Content-Security-Policy header wasm-unsafe-eval now fully supported
  • Clarified documentation on Observable.asArray
  • Legend appeared offset when using vertically stacked subcharts
  • Cursor tooltip not showing correctly for unsorted scatter data if hitTestRadius 0
• 3.2.481 (5th October 2023)
  • See the demo of the new VerticalSliceModifier at demo.scichart.com/javascript-chart-vertical-slice-modifier
  • New Feature – VerticalSliceModifier. Looks like the RolloverModifier, but programatically placed at a particular data or pixel position
  • Handle cases where pie segments have 0 value
• 3.2.477 (29th September 2023)
  • fix OHLC data series serialization
• 3.2.476 (28th September 2023)
  • SCJS-1603 Add remove method to Vertical Group and automatically remove surface from group when it is deleted
  • SCJS-1602 Mark all series unhovered when cursor leaves the seriesViewRect
  • SCJS-1601 Toggling axis.isVisible no longer breaks labels
  • SCJS-1548 Fix Data Series serialization. Improvements to NaN/null handling and metadata
  • SCJS-1611 Fix rollover error if invisible series is made visible
  • Fix parseColorToHexStringArgb with zero opacity override
• 3.2.470 (26th September 2023)
  • This release (hopefully) marks the completion of changes required to enable SciChart.JS to be used with TypeScript strict mode enabled.
  • SCJS-1604 Added isEnabled for DataLabelProviders
  • SCJS-1608 Fix datalabels not showing for single point
  • SCJS-1609 Fix datalabels not generating properly with vertical chart
  • SCJS-1605 Fix Rollover could not find registered tooltip template
  • Fix Insert for XyText inserted text in the wrong place
  • Fixed type mismatch in getters and setters allowing for strict mode
• 3.2.464 (7th September 2023)
  • SCJS-1958 Fix palette not indexed correctly when zoom/pan a mountain or band series
• 3.2.463 (5th September 2023)
  • Progress on strict mode support
  • Fix types mismatch in getters and setters
• 3.2.461 (28th August 2023)
  • Now that we have optional automatic webassembly disposal, deleting and creating a new chart could result in the creation of a new webassembly context. These fixes mean this will automatically get the license applied.
  • Make extra sure that the license will be applied if a new wasmcontext is being created
  • Fix license not reapplied if wasmcontext has been disposed
• 3.2.457 (17th August 2023)
  • In 3.2 by default we clip the data that is sent to be drawn to what is actually visible. In some edge cases this might lead to undesired behaviour, so we’ve added axis.clipToXRange which allows you to disable this.
  • SCJS-1579 clipToXRange property to allow for disabling the new clipping to visibleRange for x axis
  • SCJS-1592 Partial fix for ring around pointmarkers with paletteProvider
  • SCJS-1591 AutoRange should use acutally visible data
  • Remove unnecessary logging

Where to get it

SciChart.js v3.3 is available by:

Developers – Node/WebPack

Check npm for the latest version.

npm install scichart

Don’t forget to see our Tutorials on setting up Npm projects with Webpack!

Developers – Browser Script

For developers using vanilla JavaScript (no Node Package Manager), you can load SciChart.js directly in browser. Add this script to your Html head and away you go.  

// Add this script to head. For Prod we recommend setting a specific version number
// Include script from https://www.jsdelivr.com/package/npm/scichart
<script src="https://cdn.jsdelivr.net/npm/scichart@3/index.min.js" crossorigin="anonymous"></script>

// Import your types
const { SciChartSurface, NumericAxis, FastLineRenderableSeries } = SciChart;

// Now Configure SciChartSurface in code to load the wasm file from CDN
SciChartSurface.useWasmFromCDN();

// Now create a SciChartSurface as you would normally!
const { sciChartSurface, wasmContext } = await SciChartSurface.create("div-id");

The post SciChart.js v3.3 Released! Cumulative Update and Important Issue patched appeared first on SciChart.

We’ve moved over to a new format for communicating our releases and updates of our popular WPF Charts library, by publishing a rolling changelog of every fix or enhancement in SciChart.

You can find the changelogs in the top menu at Developers -> Changelogs -> SciChart WPF ChangeLog

What’s New in v8.3 of SciChart’s WPF Charts?

This release is a cumulative update with fixes and minor enhancements which is backward compatible to version 8.0 of SciChart WPF. It’s recommended for all users on v8.x to upgrade.

Changes since v8.2 include:

The post SciChart WPF v8.3 Released! appeared first on SciChart.

What’s changing?

We’ve updated and integrated our renewals system for a new pricing model, updated our headline pricing on bundle products & formally introduced Standard & Advanced Licensing.

Renewals System & New Pricing Model

Under the old renewals and pricing model customers could purchase single year licenses off our store & renew annually with a 50% discount, losing this discount 30 days after license expiration with pricing subject to change.

We’ve updated and modernised our renewals and pricing system integrating renewal discounts into headline pricing and offering multi-year licenses as standard.

You’ll now be able to benefit from the 50% renewal discount from day 1, when choosing a 2-year or 3-year license and a further 10% discount on 3-year licenses taken upfront.

As an added bonus, you can now reduce your project costs and fix pricing for the long term.

Orders are now set to auto-renew as standard at the rate conveyed by the original order term. Customers who ordered a one-year upfront order can be renewed into a 3-year renewal to lock in preferential rates.

Customers who commit to auto-renew at purchase can lock pricing in today, for up to 6 years.

Pricing is now shown as standard on a per developer, per month basis to give a better understanding of per head costs, with the option to access payment terms, subject to agreement, including monthly, quarterly or annually for larger orders. Contact sales for more information.

Grandfathering in existing customers

SciChart continues to respect existing agreements with customers meaning that any customer on the legacy system can continue to renew as they did, or switch to the new system – whichever they prefer.

If a customer on the legacy system has their license expire and loses the renewal discount, they will be automatically ported onto the new system when they try to renew or get started again with SciChart.

What happens if my subscription expires?

Under either system, legacy or new, when your subscription expires you will lose access to technical support, updates, bug fixes, new features, new platforms (if applicable), nightly builds, as well as any test domains you have. Under Advanced Licensing (More below) your agreement will be cancelled.

By maintaining an active subscription you will lock in pricing that may change over a multi year term and ensure that your project continues to receive any fixes, support or test environment it needs.

Pricing

Pricing for Bundle products has remained static since 2020, prices for our Bundle products will increase by 10%. This decision reflects a combination of factors including global inflationary pressures as well as continuous investment in the product and systems in line with feedback from our customers.

Why the price increase?

Since 2020, we’ve embarked on significant enhancements across all supported platforms, including JavaScript, WPF, iOS, Android and MacOS. These enhancements include new features, performance improvements and upcoming support for gauges, polar charts and even Linux. In addition, we’ve expanded our team to bolster our world class support and accelerate product development to meet and exceed our customers evolving needs.

We’ve also invested heavily in our support infrastructure, launching a new support desk, a new customer portal, licensing management and enhancing our documentation with smart search functionality. These improvements are designed to make your experience with SciChart as seamless and productive as possible.

Commitment to value

Despite these changes, SciChart remains committed to providing unparallel value. Our solution remains competitively priced whilst offering best in class performance and flexibility compared to all other charting libraries. Our ongoing investment and exploration of new platforms and features is part of our commitment to ensuring SciChart remains the best tool for your development needs. We’re confident there isn’t a better solution out there, even for 5 times the price!

Formally introducing Standard & Advanced Licensing

Working with our customers across sectors, the feedback has continually been for a more permissive license type on certain platforms as well as extra levels of support for enterprise customers.
We have been supplying Permissive Licensing for non-domain locked licensing, small scale OEM and large scale deployments for some time and have now formalised this into the store making it clearer and easier to buy these products from the website. Our new Standard licensing allows more complex deployments as standard including SaaS, Trading Platforms, and even domain locked on-premise deployments on JavaScript. Our Advanced Licensing will enable non-domain locked licensing and give a route to have more permissive licensing and large-scale deployments.

What is the difference between SciChart Standard & Advanced Licensing?

Standard Licensing (Individual products only)

SciChart Standard Licensing conveys the right to use SciChart in up to 5 applications on the platform purchased, per license. On JavaScript, standard licensing supports up to 5 websites, internal or external, SaaS, trading platforms or up to 5 domain locked on-premise applications like electron. All Standard Licenses enable up to 15,000 users or deployments, across applications.

SciChart Advanced Licensing (Bundle products only)

SciChart Advanced Licensing conveys the right to use SciChart in unlimited applications, on all platforms that SciChart supports.

SciChart Advanced Licensing can be activated and used for non-domain locked on-premise permissive licensing on JavaScript, small scale OEM licensing and scaled to millions of end users.

Advanced licensing activation only requires one license to be maintained at the headline price, converting a single license into a subscription. For large scale use cases (over 15,000 end users), there are then scalable tiers adding in tens of thousands of users or implementations starting at less than $50 a month.

This permissive license type eliminates the need to register every domain or AppID with SciChart helping to reduce administrative burden, enable truly offline deployments, and ensures that your project can scale.

Simply put, to access the wide range of Advanced Licensing features, you only need to renew one license at the headline rate per project where this licensing is needed.

How does Advanced Licensing work?

The Advanced Licensing module where needed is a permissive license type which means in complex installations like localhost on JavaScript, or situations where the hostname is unknown, your clients can install without oversight from yourself, or SciChart.

Advanced licensing links your project to your license and where necessary a custom license permissive license key is provided to you. You’ll need Advanced Licensing for certain JS deployments, deployments with over 15,000 users, or certain OEM deployments.

The post We’ve updated our pricing model appeared first on SciChart.

Canadian virtual casinos are very famous. There are many providers, which suggest interesting games. Some of them, generally are posted on US and EU links. If you desire to play in the best gambling portals in Canada, you must test different slots.

If you hope, that different games provide an option to win – you are on the right route. If you see something wrong with diverse games, must be honest and say, that the best method – is to use other vender. In diverse casinos, there are different opportunities to play:

1. In Competitions;

2. In card games;

3. In venders;

One of the essential types of spending time in casino – is using vendors. How to discover the best websites, where you can play slots?

Casinos Zeus expert Olexiy Ivanov made a lot of useful reviews, which ensure for guys. That is why to play in various and interesting games is easier, than 6 or 16 years ago. With the support of various reviews, you could test modern games, different gambling methods, and tournaments.

During the game process clients have an option to select new methods, and some game opportunities and use new options in the best online casino in Canada. However, Casino Zeus expert Olexiy Ivanov supports with their significant advice.

Bonuses in virtual casino

Do you desire to know, which best bonuses grant gambling links? Should to item, there is a main bonus:

No Deposit bonus

With the support of the “No Deposit Bonus” you could win coins. That means, that a player have a chance to play without real money.

Referral bonus

All are beneficial. A referral bonus is a very significant bonus, which you may usually get. The referral deposit can be emended.

Welcome bonus

Significant bonus, which could be used by all new clients. Welcome bonuses are important, that is why most digital casinos in Canada grant it.

VIP Bonus

One of the most prominent is the VIP bonus. If you obtain a VIP bonus, you have an option to use a personal assistant specialist. He supports to solve varied problems and often answers different questions during the game.

How we analyze the best online casinos in Canada

You could choose more than 120 websites in Canada, which procure an opportunity to have an interesting time. Select the best slots on Canadian links for clients. Casinos Zeus specialist Olexiy Ivanov makes analyze, where touches attention to various types of games. Also, he pays attention to separate deposits, which are very importants.

If a client likes regular actions, it is very nice. With the support of regular actions, members could participate time in different casinos. Safety is however a very main factor. That is why a team of managers inspects these items.

One of the most basis items – is responsible gambling. Nowadays a lot of players desire to play in thematic safe virtual casinos, where people have a chance to play in responsible games. More men know this type of game like as safer gambling process. Operators ensure a chance to play without coins, where clients could set individual limits. In 2024 responsible slots were very popular.

The list of the best Canadian web casinos

In EU, there are many online casinos. But in Canada, there are however many of unusual internet casinos:

Lucky Nugget

You have the chance to obtain 30 spins for $1 and use comfortable payment methods. Plus, access your account easily with the Lucky Nugget Casino login https://casinozeus.net/lucky-nugget.

Ruby Fortune

Ruby Fortune obtains a chance to use interesting venders in demo style. You may use more than 400 games in the demo version. Some of them are interesting and unique.

King Billy

Ready to play in an virtual casino King Billy? It is a very safety online Canadian casino, where men could select live blackjack for real money.

Jackpotcity

Do you search free casinos, where not necessary to download software or register a profile? In Jackpotcity guys may use the website and select new venders. The page has 180 games, which are produced in 2024.

Royal Vegas

Important online casino, where guys have an option to play in various tournaments. As you know, internet casino Canada’s list of the best web casinos with tournaments is not very big. But at Royal Vegas guys have an option to spend interesting time. Tournaments are very interesting and you could make a first-rate for $10.

Games in virtual casino

Despite, which type of games you are interested in, there are a lot of various slots. For example, one of the most significant are venders. More and more people every year choose slots. You may use them from a mobile OS. Any guys like to play in slots, which are possible to upload from Google Market. Another likes to use venders, which are probable to upload from the Apple Store.

However need to say, that in online casinos there are the best venders from NetEnt, IgroSoft, and ELK. If you like to play in Canadian slots, you need to test Big Bass Splash, where you could get a bonus of $1600. Any men like to use Wolf Gold. It is however a very important game, where you can take 60 free spins.

The post Top of the best virtual casinos in Canada: bonuses, security, and unique games appeared first on SciChart.

JavaScript charts enable digital application owners to tell stories with data.

Humans engage with and interpret visual information much more easily than written content. Spreadsheets and data reports aren’t always the most effective way to get your story across. If you want to get to the heart of a set of data, it’s important not to bore your audience with too much information and small print. JavaScript Charts and Graphs powered by SciChart.js can transform the way you present and engage with data.

You can make complex information more accessible and digestible. It works for a wide range of industry sectors, including health, finance, sport and more. In this guide, we’re looking at some of the best examples of JavaScript charts to help you visualise the possibilities.

With SciChart.js, the world’s fastest JavaScript chart library, you can create exceptional graphs with little effort. Customisable options ensure you can stay on brand and deliver a unique content experience that gives you the edge over the competition.

It’s just one of the many ways you can make your website more appealing for potential customers or clients. Showcase statistics and data in a professional way.

Explore Our Advanced JavaScript Chart Examples for Various Applications

Real-time Data Charts in JS

Real-time data is ideal for financial, stock and trading charts as well as medical and scientific applications. It’s an effective way to demonstrate your expertise and that you’re an authority on your subject.

Real-time JavaScript Chart Performance Demo

Discover the speed and power of SciChart.js in a real-time example. The Real-time JavaScript Chart Performance Demo creates a timer and pushes 300,000 points per second!

Stock Charts

JavaScript Multi-Pane Stock Charts

Create static multi-pane stock charts in JavaScript with price data as Candlesticks, Volume bars behind the chart and moving averages, plus link several charts together to draw Macd and RSI indicators. All charts can be synchronised together. We recommend using TA-Lib to add more complex indicators to SciChart.js.

Scientific and Medical Charts

LiDAR 3D Point Cloud of Geospatial Data

3D Point Cloud presents data points in a 3D space and is collected through sensors such as lidar. The sensors emit light and calculate the time it takes to be reflected back into the sensor to create each dot. They can be used to display geospatial data.

The example below demonstrates the capability of SciChart.js to create JavaScript 3D Point Cloud charts and visualize Lidar data from the UK Defra Survey.

JavaScript Vital Signs ECG/EKG Medical Demo

SciChart.js can help you short-cut your development by providing rich, real-time high performance and reliable charts for JavaScript medical and healthcare applications. Monitor heart rate, body temperature, blood pressure, pulse rate, SPO2 blood oxygen, volumetric flow and more with the Vital Signs JavaScript ECG/EKG chart.

More 3D Charts

JavaScript 3D Bubble Chart

This 3D Bubble Chart supports up to a million points, enabling the visualisation of large statistical datasets. Bubbles can also be colored individually and tagged. Interactive elements enable users to zoom and tilt the graph.

The demo pcitured above plots Gapminder.org JSON data in three dimensions, comparing GDP per capita of countries vs. Life expectancy vs. Year. The size of the bubble and the colour are determined by the life-expectancy, showing how you can plot four or even five dimensions on a single chart by using X, Y, Z, Scale, Colour.

JavaScript Surface Mesh 3D Chart

The Surface Mesh chart can be used to represent 2D data in a 3D map. It looks like a topographical map where values in a 2D array are drawn as heights and mapped to a color. The Surface Mesh 3D chart type in SciChart.js is highly dynamic and allows for large volumes of data to be plotted.

Basic Charts

JavaScript Line Chart

It’s not just complex 3D charts that can bring a new lease of life to your data visualizations. Variations in JavaScript Line Chart include a wide range of different line styles, such as simple lines, digital lines, tooltips, dashes, gaps, labels, hovering lines and more.

Pie & Donut Charts

SciChart can help you make the Pie and Donut Chart a bit more exciting to look at. The visualization example above displays the market share of internet browsers in 2022.

Column Charts

With SciChart, you can even make beautiful Column Charts. With just a click, you can switch between stacked column and 100% stacked.

SciChart.js is an award-winning graphics engine that enables you to plot millions of data-points in real time. It’s designed for innovative data presentation for updating financial, medical, scientific and big-data business applications. See our demos now.

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. If you have a question, or would like to give feedback, contact us.

CONTACT USGET SCICHART.JS FREE

The post Discover the Best Examples of JavaScript Charts for Dynamic Data Visualization appeared first on SciChart.

We’ve moved over to a new format for communicating our releases and updates of our popular WPF Charts library, by publishing a rolling changelog of every fix or enhancement in SciChart.

You can find the changelogs in the top menu at Developers -> Changelogs -> SciChart WPF ChangeLog

What’s New in v8.5 of SciChart’s WPF Charts?

This release (v8.5.0 build 28148) is a cumulative update with fixes and minor enhancements which is backward compatible to version 8.0 of SciChart WPF. It’s recommended for all users on v8.x to upgrade.

To find out what is new since v8.3, read on below:

1. Features & Improvements
2. Bug Fixes
3. Breaking Changes

Features & Improvements

The post SciChart WPF v8.5 Released! appeared first on SciChart.

We’ve moved over to a new format for communicating our releases and updates of our popular WPF Charts library, by publishing a rolling changelog of every fix or enhancement in SciChart.

You can find the changelogs in the top menu at Developers -> Changelogs -> SciChart WPF ChangeLog

What’s New in v8.6 of SciChart’s WPF Charts?

This release (v8.6.0 build 28199) is a cumulative update with fixes and minor enhancements which is backward compatible to version 8.0 of SciChart WPF. It’s recommended for all users on v8.x to upgrade.

To find out what is new since v8.5, read on below:

1. Features & Improvements
2. Bug Fixes

Features & Improvements

The post SciChart WPF v8.6 Released! appeared first on SciChart.

We’ve moved over to a new format for communicating our releases and updates of our high performance JavaScript Charts library, by publishing a rolling changelog of every fix or enhancement in SciChart. You can find the changelogs in the top menu at Developers -> Changelogs -> SciChart JS ChangeLog

What’s New in v3.4 of SciChart’s JS Charts?

Today we have finalised the release of v3.4.662 of SciChart.js. This is a cumulative update which contains very important fixes and features since our last announced release, version 3.3.

Changes since version 3.3

There are a HUGE number of changes in this release. Find them detailed below with links to documentation, examples and more. 

New Features

1. Hoverable Annotations
2. DataLabels support for Stacked Column Series
3. Smooth Stacked Mountain Series
4. Alternative line smoothing
5. Animations improvements
6. Engineering Formatting for Axis
7. Disable Loader animations
8. CursorModifier support for Non-Uniform Heatmap and Contour Series
9. Helper method for creating paletteProviders that depend on y value
10. SVG Annotations can now be placed behind the chart
11. SS.ms format and use of this in SmartDateLabelProvider
12. createSuspended and nextStateRender for visual testing an export improvements
13. Gradient fill for band series
14. Sync Vertical Chart Axis sizes with SciChartHorizontalGroup
15. Sensible Column widths for Columns, Error Bars, Candles using dataPointWidthMode
16. ColumnSeries can draw different styles in the same series
17. Improvements to Splitting Line Charts by Thresholds
18. Added MemoryTests project to Github to allow testing & debugging memory related issues
19. New React / JavaScript Chart Demos
20. Improvements to Documentation, Examples
21. Bug fixes, improvements

1. Hoverable Annotations with Tooltips

Annotations now have an onHover callback which is enabled by adding an AnnotationHoverModifier to the sciChartSurface.chartModifiers collection. The modifier controls which annotations are checked for hovering, and also allow you to specify general onHover behaviour in one place. This feature now allows you to easily add configurable tooltips to annotations in a JavaScript or React chart.

Hoverable Buy Sell Marker Annotations

Learn how to use the AnnotationHoverModifier, a new feature in SciChart.js which allows you to enable the onHover callback to show tooltips on annotations in a JavaScript chart … Continue reading Hoverable Buy Sell Marker Annotations

demo.scichart.com

Here’s a quick sample how to add an onHover callback to a single annotation:

const boxAnnotation = new BoxAnnotation({
  xCoordinateMode: ECoordinateMode.Relative,
  yCoordinateMode: ECoordinateMode.Relative,
  fill: "#3d34eb",
  strokeThickness: 1,
  x1: 0.1,
  x2: 0.4,
  y1: 0.4,
  y2: 0.6,
  onHover: (args) => {
    const { sender, mouseArgs, isHovered } = args;
    if (mouseArgs && isHovered) {
      const relativeCoordinates = args.getRelativeCoordinates();
      console.log("The annotation is hovered at", relativeCoordinates);
    }
  },
});

This requires the AnnotationHoverModifier to be added to the chart, which also has a onHover callback:

// Add AnnotationHoverModifier to enable hover behaviour
const annotationHoverModifier = new AnnotationHoverModifier({
  enableHover: true,
  targets: [boxAnnotation],
  hoverMode: EHoverMode.AbsoluteTopmost,
  notifyOutEvent: true,
  notifyPositionUpdate: true,
  onHover: (args) => {
    const hoveredAnnotations = args.hoveredEntities;
    const unhoveredAnnotations = args.unhoveredEntities;
    hoveredAnnotations.forEach((annotation) => {
      annotation.fill = "#34eb8c";
      annotation.strokeThickness = 3;
    });
    unhoveredAnnotations.forEach((annotation) => {
      annotation.fill = "#3d34eb";
      annotation.strokeThickness = 1;
    });
  },
});
sciChartSurface.chartModifiers.add(annotationHoverModifier);

Official documentation for the AnnotationHoverModifier can be found here. Typedoc API docs can be found here.

2. DataLabels support for Stacked Column Series

We’ve added DataLabels support to stacked column series, allowing you to put labels inside, outside, above or below columns.

React Stacked Column Chart

The JavaScript / React Stacked Column chart now supports data-labels! … Continue reading React Stacked Column Chart

demo.scichart.com

To enable dataLabels on a StackedColumnRenderableSeries set the fontFamily and fontSize on the dataLabels options as normal. Additional properties to configure the label position can be found in EColumnDataLabelPosition enum.

    const dataLabels = {
        color: "#FFfFFF",
        style: { fontSize: 12, fontFamily: "Arial", padding: new Thickness(0, 0, 2, 0) },
        precision: 0,
        positionMode: EColumnDataLabelPosition.Outside,
        verticalTextPosition: EVerticalTextPosition.Center,
    };
    // Create some RenderableSeries - for each part of the stacked column
    // Notice the stackedGroupId. This defines if series are stacked (same), or grouped side by side (different)
    const rendSeries1 = new StackedColumnRenderableSeries(wasmContext, {
        dataSeries: new XyDataSeries(wasmContext, { xValues, yValues: yValues1, dataSeriesName: "EU" }),
        fill: appTheme.VividPurple,
        stroke: appTheme.PaleSkyBlue,
        opacity: 0.8,
        stackedGroupId: "StackedGroupId",
        dataLabels,
    });

You can read more about the DataLabels API Documentation here. The StackedColumnRenderableSeries documentation can be found here. 

3. Smoothed Stacked Mountain Series

A new chart type has been added to SciChart.js – a Smoothed Stacked Mountain chart. This has an adjusted bezier line smoothing algorithm that works with stacked, and 100% stacked mountain series. 

Find a demo of the new chart type and how to use it below. 

React Smoothed Stacked Mountain Chart

The JavaScript / React Smoothed Stacked Mountain chart now supports bezier line smoothing … Continue reading React Smoothed Stacked Mountain Chart

demo.scichart.com

Official documentation for the new Bezier (Smoothed) Stacked Mountain Series can be found here.

4. Alternative Line Smoothing

Bezier line smoothing has been added to SciChart.js, which can be applied to line, band and mountain series. Further demos of this can be found below:

React Spline Line Chart

The JavaScript / React Spline Line chart shows how to add custom Bezier smoothing to a line chart in SciChart.js … Continue reading React Spline Line Chart

demo.scichart.com

The JavaScript / React Spline Line chart shows how to add custom Bezier smoothing to a line chart in SciChart.js. In the example above, drag the axis marker to change the smoothing coefficient and see the impact on the final rendered output.

The output is controlled by a BezierRenderDataTransform. This is based on the new RenderDataTransforms API in SciChart.js v3.3, which allows you to modify the final rendered output data immediately before draw.

const bezierDataSeries = new XyDataSeries(wasmContext, {
	dataSeriesName: "Bezier (Range Restricted)",
	xValues,
	yValues,
});

const bezierSeries = new FastLineRenderableSeries(wasmContext, {
	stroke: appTheme.VividPurple,
	strokeThickness: 4,
	dataSeries: bezierDataSeries,
	pointMarker: new EllipsePointMarker(wasmContext, {
		width: 11,
		height: 11,
		fill: appTheme.ForegroundColor,
		stroke: appTheme.VividSkyBlue,
	}),
	animation: new WaveAnimation({ zeroLine: 10, pointDurationFraction: 0.5, duration: 1000, fadeEffect: true }),
});
const bezierTransform = new BezierRenderDataTransform(bezierSeries, wasmContext, [
	bezierSeries.drawingProviders[0],
]);
bezierSeries.renderDataTransform = bezierTransform;
sciChartSurface.renderableSeries.add(bezierSeries);

Another example which has been updated to use the BezierRenderDataTransform is the Spline Band Chart. Check out both examples to see how to use this new feature in SciChart.js.

5. Animations Improvements

Startup animations (see documentation) now have a flag reversible: true and an onComplete callback. This allows you to create more complex and composite animations on chart series using SciChart.js.

See the Pen SciChart.js documentation snippet for Animations – AnimateInOut by SciChart.js Official (@scichart) on CodePen.

Official documentation for the Animations API can be found here.

6. Engineering Format for Axis

We’ve added a new ENumericFormat value of ENumericFormat.Engineering. When enabled, this displays axis labels and data labels in the format 1K, 1M, 1B as opposed to 1,000 1,000,000 and 1,000,000.

A further property has been added to customize the prefix on LabelProvider.engineeringPrefix 

Gets or sets the engineering prefixes to use when formatting values to text.
Default - ['K','M','B,'T'] for "large" prefixes, ['m','u','n','p'] for small prefixes.
Only works when ENumericFormat.Engineering is selected 

This is demonstrated in the Population Pyramid example which makes use of the concise compact labels provided by Engineering formatting.

React Population Pyramid Chart

The JavaScript / React Population Pyramid chart with data-labels! … Continue reading React Population Pyramid Chart

demo.scichart.com

AxisLabels ENumericFormats have been documented here, showing the new ENumericFormat.Engineering mode in action.

7. Disable Loader Animations

We’ve updated the parameters passed to sciChartSurface.create to allow you to entirely disable a loader animation when the chart starts. 

Simply pass loader: false to turn the loader off for this SciChartSurface

SciChartSurface.create({ loader: false });

Documentation on how to style, theme or disable the wait-loader can be found here.

8. CursorModifier support for Non-Uniform Heatmap and Contour Series

We’ve added support for the CursorModifier to the NonUniformHeatmapRenderableSeries

In addition, the UniformContoursRenderableSeries is now compatible with the CursorModifier.

Documentation on the CursorModifier can be found here, and Non-Uniform heatmap series can be found here.

9. Helper method for creating PaletteProviders dependent on y-Value

We’ve added helper function PaletteFactory.createYGradient which allows you to create a PaletteProvider that colours data-points in chart series depending on Y-value.

We’ve updated the Line Chart example to use the createYGradient function in the centre panel. We’ve also added new documentation for the PaletteFactory helper class here.

To use the PaletteFactory.createYGradient function, use the following code. 

const yGradientPalette = PaletteFactory.createYGradient(
    wasmContext,
    new GradientParams(new Point(0, 0), new Point(0, 1), [
        { offset: 0, color: "#3333FF" },
        { offset: 0.5, color: "#33FFAA" },
        { offset: 1, color: "#FF6600" },
    ]),
    // the range of y-values to apply the gradient to
    new NumberRange(0, 1.5),
    // Optional parameters to control which elements of the palette are enabled
    {
        enableFill: false, // Applies to fills on mountain, column
        enableStroke: true, // Applies to stroke on all series
        enablePointMarkers: true, // Applies to pointmarkers if present
        strokeOpacity: 1.0,
        pointMarkerOpacity: 0.7,
        fillOpacity: 0.0,
    }
);

sciChartSurface.renderableSeries.add(
    new FastLineRenderableSeries(wasmContext, {
        strokeThickness: 5,
        dataSeries: new XyDataSeries(wasmContext, { xValues, yValues }),
        pointMarker: new EllipsePointMarker(wasmContext, { width: 20, height: 20, strokeThickness: 0 }),
        paletteProvider: yGradientPalette,
    })
);

This results in the following output: 

Official PaletteFactory documentation can be found here.

10. SVG Annotations can now be placed behind the chart

SciChart.js features two types of Annotations: RenderContext annotations which use WebGL to draw, and SVG based Annotations.

Until now, SVG annotations could only be placed over the chart, but we’ve now added support to place SVG Annotations below the chart, allowing you to place images, text watermarks or custom shapes/SVG behind the chart series and gridlines.

You can see the modes of placement of annotations in the following demo.

React Chart Annotation Layers

Demonstrates how Annotation layering a JavaScript / React Chart using SciChart.js … Continue reading React Chart Annotation Layers

demo.scichart.com

Documentation for the Annotations API can be found here

11. SS.mm format and use of this in SmartDateLabelProvider

The SmartDateLabelProvider type has been updated to include SS.mm format automatically, so that when deep zooming a chart with a DateTimeNumericAxis you will automatically now see seconds and milliseconds on the chart axis. 

Documentation for the DateTimeNumericAxis can be found here. When this axis type is used, the SmartDateLabelProvider is automatically activated. 

12. createSuspended and nextStateRender for visual testing and export improvements

When exporting a chart to an image for visual testing, or for chart export, we’ve added two new functions to allow a SciChartSurface to be created in a suspended state and to force a single render.

• createSuspended: Defines if newly created charts should be rendered as soon as possible after initialization. Setting to true will require surfaces to be “resumed” in order to perform actual rendering.
• nextStateRender: Creates a promise which resolves when the chart is updated to the next fully rendered state. 

These allow you to control the rendering state and are used in the server-side-chart-export example in our Github repository.

13. Gradient fill for Band Series

The Band Series, a type of chart series which displays a polygon fill between upper & lower lines, now supports gradient fills and not just solid colours. This is demonstrated in the React/JavaScript Band Chart Example below.

React Band Chart Example

Demonstrates how to create a React Band Chart or High-Low Fill using SciChart.js … Continue reading React Band Chart Example

demo.scichart.com

Updated documentation for the Band Series showing how to apply gradient fills can be found here.

14. Sync Vertical Chart Axis sizes with SciChartHorizontalGroup

Charts can be synchronized in SciChart.js so that zooming, panning and tooltips/cursors act across multiple chart surfaces. 

In SciChart.js v3.4 we’ve enabled this chart synchronization in vertical (rotated) charts by use of a new SciChartHorizontalGroup type. 

Documentation has also been written for synchronizing vertical and horizontal charts and several examples can be found in the links below:

Documentation for Synchronizing Multiple Charts can be found here. 
New Documentation for Synchronizing Vertical Charts can also be found here.

15. Sensible Column widths for Columns, Error Bars, Candles using dataPointWidthMode

We’ve added a new property to Column, ErrorBars, Candlestick and OHLC series called dataPointWidthMode. 

This allows you to space columns and bars according to pixels, relative values or data-values. This improves the scenario where column series with sparse datasets would overlap. 

Find a demo below in the documentation:

Documentation for dataPointWidthMode and a live codepen demo can be found here.

16. ColumnSeries can draw different styles in the same series 

We’ve added a new example showing how you can use the RenderDataTransforms API to inject multiple styles into a single series. This is different from the PaletteProvider API that allows you to override colours of columns, line segments and pointmarkers but only supports solid colours. The RenderDataTransforms API allows you to insert, modify or remove data-points immediately before draw, or inject full styles such as changing point-marker mid-series, or changing gradient fill colour mid-series. Find an example of this powerful API below:

React Column Chart with Multiple Styles

Demonstrates how to use multiple styles on a single series in React/JavaScript Charts using SciChart.js … Continue reading React Column Chart with Multiple Styles

demo.scichart.com

The RenderDataTransforms documentation can be seen here. The Multi Series Style demo which uses this technique to inject styles into a column series can be found here.

17. Improvements to Splitting Line Charts by Thresholds

Using the PaletteProvider you can colour line segments depending on a Y-value, allowing you to create thresholded series. However this technique suffers from a limitation, whereby the entire segment is coloured. For example, line series coloured by paletteprovider with a Y-threshold can look like this.

The RenderDataTransforms API allows you to insert, remove or modify extra data-points in a series immediately before draw. This API can be used to create perfect thresholded series by inserted the extra data-point which bisects the threshold line. 

We’ve created an example showing how to do this:

React Chart with lines split by thresholds

Demonstrates how to split lines into multiple segments so they can be individually colored according to thresholds, using the RenderDataTransforms API in SciChart.js … Continue reading React Chart with lines split by thresholds

demo.scichart.com

The RenderDataTransforms documentation can be seen here. The PaletteProvider API documentation can be found here.

18. Added MemoryTests project to Github to allow testing & debugging memory related issues

In previous releases of SciChart.js, we published memory leak debugging tools to allow you to detect and eliminate memory leaks in your JavaScript charting applications. 

In this release, we’ve added a set of Memory Test examples, to help you to debug issues in your application. The purpose of these is to give you some working examples that are tested to show best practices to ensure no leaking of memory when creating/initializing charts, when dynamically updating data, or when updated dataseries in FIFO mode.

For more information, see the readme at MemoryTests over at Github

19. New React / JavaScript Demos & Examples

We’ve released almost 100 new examples of how to use SciChart.js with scichart-react, our open source 

1. Population Pyramid: Population Pyramid of Europe and Africa using SciChart.js High Performance JavaScript Charts. This also demonstrates the use of DataLabelLayoutManager to Modify the positions of data labels from different series to prevent overlap
2. Editable Annotations: Demonstrates how to edit annotations and get callbacks on mouse-hover for different annotation types
3. Annotation Layers: Demonstrates how to place annotations above chart series, below chart series, or below chart gridlines and axis in SciChart.js
4. User Annotated Stock Chart: Demonstrates how to add click to annotation or draw trendlines or shapes on a stock chart using SciChart.js
5. Bezier Smooth Stacked Mountain Chart: Using a Bezier Transform to create a smoothed stacked mountain chart in SciChart.js
6. Hoverable Buy Sell Markers: Shows how to add hover / tooltips to annotations in SciChart.js
7. Multi-Series Style: Shows how to use RenderTransforms API to have multiple different styles in the same series
8. Line Splitting by Thresholds: Shows how to use the RenderTransforms API to inject points mid-way into series to create perfect thresholds in line series bisected by a y-value

20. Improvements to Documentation, Example

Multiple updates to the documentation have been made, to cover previous topics that were undocumented, as well as new features in this release. 

Topics include:

• VerticalSliceModifier documentation
• Annotation Hover modifier documentation
• SmoothedStackedRenderableSeries documentation
• Engineering Format on axis labels documentation
• Render Data Transforms documentation plus worked examples
• Synchronizing Multiple Charts documentation

We’ve also added a small change to signify when a link in the docs refers to TypeDoc API docs, or documentation page. 

21. Bug Fixes

A cumulative list of bug fixes since v3.3 was released can be found below. Further detail at the SciChart.js Changelog!

• (3.4.662, 11 Sept 2024)
  • Canvas border was off by 1 pixel if the canvas had fractional width or height
  • Added TypeDoc and non-abstract base class for RenderDataTransform
  • Ensure RenderDataTransforms run if resampled data changes
• (3.4.659, 27 August 2024)
  • Fixed xRange calculation when using dataPointWidthMode.range
  • SCJS-1797 Fixed a rendering issue on AMD GPU when using extreme zeroLineY
  • SCJS-1793 Fixed a memory leak in label text cache
  • SCJS-1793 Fixed a memory leak in WebGL buffers
• (3.4.652, 2nd August 2024)
  • Added dataPointWidthMode range for columns, candlesticks and errorbars. This makes it much easier to get sensible widths for bar-based series if your data has gaps
  • Added getProperties function to ColumnSeriesDrawingProvider so multiple can be added to draw different styles
  • Improved label caching pruning to improve memory behaviour, particularly when using native text
  • Fixed a memory leak when using SciChartOverview
  • Data-point selection did not select all points in the shown area when using xyDirection: EXyDirection.XDirection
  • Fixed SmoothStackedMountainSeries builder API support
• (3.4.644, 12th July 2024)
  • Added SciChartHorizontalGroup which synchronizes top/bottom axis sizes
  • Fixed Heatmap yAxisId option was setting xAxisId instead
  • Fixed DataLabel positioning for Band Series when using singleLabel: true
  • Allow setting partial styles for ticks and gridlines in axis options
  • Fixed an error if legend is forced to update before chart is drawn
• (3.4.636, 27th June 2024)
  • Pie chart was not showing if only one segment was defined
  • Fix error when calling sciChart3DSurface.renderableSeries.clear(true)
  • PointMarkerPaletteProvider was affecting the stroke of a mountain or band series
  • Fix smooth stacked mountain series missing a point when the lower series contains NaN
  • Fix bezier transform not recalculating when visibleRange changes
  • SCJS-1370 CursorModifier axis labels sometimes in the wrong chart when using subcharts
  • SCJS-1394 CursorModifier should not add extra labels on stacked axis
• (3.4.623, 20th June 2024)
  • rah
• (3.4.617, 13th June 2024)
  • ContourSeries now uses stroke color and thickness properly
  • Startup animations on spline series again properly apply the smoothing during the animation
  • SCJS-1693 Fixed that trying to render some extended characters would break native text rendering
  • SCJS-1754 workaround a browser issue where a canvas could be cleared when switching tabs
• (3.3.592, 20th May 2024)
  • Several NaN related issues fixed in this release. We do our best to support them, but still advise you to avoid them if possible. If you need gaps in a series, consider using a paletteProvider and setting the color transparent.
  • Added PaletteFactory.createYGradient which takes a set of gradient stops and returns a paletteProvider which colours based on y value
  • You can now set indivdual parts of the sciChartSurface.padding and the chart will automatically redraw
  • Setting EAnnotationLayer.BelowChart on an svgAnnotation will now behave as foreground (the old behaviour) rather than throw an error
  • SCJS-1749 Fix seriesInfo equality check when data contains NaN, fixing continuous render when using rollover or cursor with NaNs
  • SCJS-1750 Add support for negative z values in Heatmap series
  • SCJS-1752 Fix line palleting is off by one if the dataSeries contains NaN
• (3.3.577, 9th April 2024)
  • axis.visibleRange (0,10) is no longer a magic range that would cause autoRange: once to fire.
  • SCJS-1722 Charts with startup animations no longer display one frame of the final state at the start
• (3.3.570, 28th Feb 2024)
  • Experimental – bundle files built as ESM modules
  • Fix a potential error when navigating away from a page with a pie chart
  • Fixed a licensing issue where multiple wilddard domains were not handled properly
• (3.3.567, 12th Feb 2024)
  • More licensing flexibility for applications using IP addresses as host name
  • SCJS-1718 fix crash when using paletteProvider with spline series
  • SCJS-1717 Rollover and Cursor modifiers using modifierGroup did not work correctly with subcharts
  • rendered event now fires once chart image is copied to target canvas, so performance measurements based on prerender to rendered are more accurate
  • PerformanceDebugHelper and performance monitoring points
  • createSuspended option on SciChartSurface and nextStateRender to enable callbacks on first chart draw

     

Where to get it

SciChart.js v3.4 is available by:

Developers – Node/WebPack

Check npm for the latest version.

npm install scichart

Don’t forget to see our Tutorials on setting up Npm projects with Webpack!

Developers – Browser Script

For developers using vanilla JavaScript (no Node Package Manager), you can load SciChart.js directly in browser. Add this script to your Html head and away you go.

// Add this script to head. For Prod we recommend setting a specific version number
// Include script from https://www.jsdelivr.com/package/npm/scichart
<script src="https://cdn.jsdelivr.net/npm/scichart@3/index.min.js" crossorigin="anonymous"></script>

// Import your types
const { SciChartSurface, NumericAxis, FastLineRenderableSeries } = SciChart;

// Now Configure SciChartSurface in code to load the wasm file from CDN
SciChartSurface.useWasmFromCDN();

// Now create a SciChartSurface as you would normally!
const { sciChartSurface, wasmContext } = await SciChartSurface.create("div-id");

The post SciChart.js v3.4 Released! appeared first on SciChart.

SciChart selected for German Pegasus Billion Dollar SIGINT program

SciChart, a proud supplier to NATO allies and trusted by over half of Fortune 500 companies in the Aerospace & Defence Sector is to be implemented the German Pegasus electronic signals (SIGINT) intelligence program.

The program, a tight collaboration between Hensoldt, Lufthansa Technik Defence, Bombardier and the German Government will bolster Germanys’ military with a new airborne surveillance capability. The Pegasus project will offer unique capabilities for the reconnaissance of radio and radar signals, visualized and analyzed through SciChart.

Selected due to SciCharts’ position as the world’s fastest and most accurate charting solution, SciChart will be implemented to handle real-time frequency analysis, complex data layering and signal strength monitoring.

Control the Spectrum, Control the Threat

Employed by Governments and the private sector alike, SciChart is essential for ELINT/SIGINT platforms, specializing in RF analysis, Radar testing, and FMCW training systems across EW scenarios.

Our advanced rendering engine enables LIDAR, multi-channel RF spectral analysis, and linked heatmaps on any device, including embedded and custom hardware.

SciChart ensures you never miss a threat, offering unparalleled synchronized channels and complex multi-chart pane dashboards designed for enhanced sensitivity. Trust a proven solution for your defense strategy’s data analysis needs.

What is SIGINT?

SIGINT (Signals Intelligence) involves intercepting and analyzing electronic signals for intelligence purposes. It plays a critical role in both military and cybersecurity operations by monitoring communication networks, radar systems, and electronic devices. SIGINT is divided into two key areas:

• COMINT (Communications Intelligence): Focused on intercepting human communications, such as radio, voice, or email transmissions.
• ELINT (Electronic Intelligence): Deals with non-communication signals, like radar or weapon systems.

SIGINT projects focus on gathering intelligence to:

• Identify communication networks: Understand adversaries’ command and control structures.
• Track military assets: Detect and monitor radar and weapon systems.
• Decrypt encrypted communications: Extract information from encrypted or encoded signals.
• Provide real-time data: For decision-making in military operations, including targeting and countermeasures.

SIGINT is challenging due to the enormous volume of data, signal clutter, encrypted transmissions, and evolving technologies like frequency-hopping and low-probability-of-intercept (LPI) radar. Successful SIGINT requires sophisticated software to filter, process, and visualize data in real time.

How is SciChart enabling SIGINT?

SIGINT systems collect massive amounts of data, which is often complex and difficult to interpret. Advanced SIGINT visualization tools are essential for turning raw data into usable intelligence. SciChart provides key visualizations such as:

• Spectrograms: Show signal frequencies over time, helping to identify patterns.
• Waveform displays: Analyze the amplitude and modulation of intercepted signals.
• Heatmaps: Indicate signal strength or density, highlighting areas of interest.
• Radar signal visualizations: Allow for detection and identification of radar systems.

SciChart’s high performance, accuracy, and customizability make it ideal for addressing the complex demands of advanced SIGINT.

1. Performance: SIGINT involves analyzing vast amounts of real-time signal data. SciChart’s powerful rendering engine can process millions of data points in real time without lag, enabling swift decision-making in critical situations.
2. Accuracy: Precision is vital in SIGINT, where small variations in signals can be crucial. SciChart’s high-precision charting ensures that signal details, such as frequency or amplitude variations, are captured accurately, aiding in the detection of anomalies or encrypted communications.
3. Customization: SIGINT operations often require bespoke visualizations like spectrograms, radar plots, or waveform displays. SciChart offers extensive customization, allowing users to tailor charts and integrate specific signal-processing algorithms, providing flexibility across diverse SIGINT scenarios.
4. Real-Time Interaction: SciChart provides real-time updates and interactive features, allowing analysts to zoom, filter, and examine signal data on the fly, a critical capability in fast-paced SIGINT environments.
5. Scalability: Whether in the field or in command centers, SciChart’s cross-platform support enables seamless deployment across desktop, mobile, and web applications, making it highly adaptable for various SIGINT missions.

Advanced Charting for Aerospace and Defence

Whether you’re looking for SIGINT software, visualization tools, or advanced analytics, a robust SIGINT platform is key to transforming complex signal data into actionable intelligence. SciChart caters to a wide range of Aerospace and Defence projects from signals intelligence to telemetry. Our high performance rendering engine and proprietary technology can help you deliver your next military contract.

Learn more 

The post Announcement: SciChart selected for German Billion Dollar SIGINT program ‘Pegasus’ appeared first on SciChart.

We’ve moved over to a new format for communicating our releases and updates of our high performance JavaScript Charts library, by publishing a rolling changelog of every fix or enhancement in SciChart. You can find the changelogs in the top menu at Developers -> Changelogs -> SciChart JS ChangeLog

What’s New in v3.5 of SciChart’s JS Charts?

It’s only been a month since our last feature-packed release, and we have more good news for users of SciChart.js today. v3.5.687 contains new features & fixes. Read on to find out what’s new, and where to get it!

New Features since v3.4

1. 3D Column Charts
2. Breaking change: Updated SciChartDefaults.enableResampling to debugDisableResampling
3. Significant performance improvements when yAxis.AutoRange enabled
4. Spline series and RenderDataTransforms now support FIFO
5. Updated documentation pages & tutorials

1. 3D Column Charts

Requested multiple times on the forums, JavaScript 3D Column Charts have been ported from our WPF (Windows) charts to JavaScript.

The 3D Column or Bar chart type allows placing an arrays of columns/bars at discrete Xyz values on a chart. Each column can be uniquely coloured using vertex colors. Column heights can be animated or updated dynamically.

Try out the live demo below!

Above: The JavaScript / React 3D Column Chart example in the SciChart.js demo

Official documentation for the ColumnRenderableSeries3D can be found here. Typedoc API docs can be found here.

2. Breaking change: Updated SciChartDefaults.enableResampling to debugDisableResampling

A naughty competitor to SciChart has published a set of performance tests disabling our resampling algorithms and using this to claim that they have the fastest JavaScript chart! So, we’ve updated the property SciChartDefaults.enableResampling to SciChartDefaults.debugDisableResampling.

You must now specifically set this property to true to disable our visually lossless, sophisticated time-series compression algorithms application wide.

We’ve also published a documentation page talking about resampling, before/after images and adjusting precision here, plus updated the typedoc comments for this property. There is no need to disable resampling in production apps or performance tests, and should only be used in debug mode.

Documentation on what is data-resampling, the before/after results and how to tune precision can be found here.

3. Significant performance improvements when yAxis.AutoRange enabled

Thanks to competitor performance comparisons we’ve identified that yAxis.autoRange was a bottleneck in big-data real-time charts, so we’ve enabled an optimisation to re-use the result of other data operations and cache yAxis ranges where necessary.

The result is a 30-50% performance improvement for rendering of big-data charts with frequent updates.

No changes need to be applied in your code to benefit from this enhancement, just update the SciChart.js version to v3.5.

Official documentation for SciChart.js autorange modes can be found here.

3. Spline series and RenderDataTransforms now support FIFO

Finally, we’ve enabled FIFO (first-in-first-out) mode for series which use RenderDataTransforms – and this includes our SplineLineRenderableSeries.

FIFO (first-in-first-out) mode is a special mode of the DataSeries in SciChart which allows you to efficiently scroll a chart and discard old data, specifically useful in the case of real-time sensor monitoring applications.

Until now SplineLineRenderableSeries did not support this mode. Just update the SciChart.js library to enable this feature in your app.

You can learn more about DataSeries realtime updates, FIFO modes including scrolling & sweeping at the documentation page here. SplineLineRenderableSeries is covered in the docs here.

5. Updated Documentation Pages

In an ongoing commitment to provide the Best JavaScript Charts – we are continually updating our documentation, code examples and developer resources.

The following documentation pages have been added/updated since the last release:

• DataResampling documentation has been updated to include info about resamplingPrecision, and before/after images of resampling applied to various datasets. 
• Column 3D Chart documentation has been added.
• Updated all Tutorials – to use SciChart.js v3.x and updated tutorial text and code-samples throughout.
• Updated Tutorial – how to include SciChart.js from CDN using JSDelivr
• New Tutorial – how to include SciChart.js index.min.js and wasm files locally (without package manager)

Where to get it

SciChart.js v3.5 is available by:

Developers – Node/WebPack

Check npm for the latest version.

npm install scichart

Don’t forget to see our Tutorials on setting up Npm projects with Webpack!

Developers – Browser Script

For developers using vanilla JavaScript (no Node Package Manager), you can load SciChart.js directly in browser from JSDelivr CDN. Add this script to your Html head and away you go.

// Add this script to head.
// For Prod we recommend setting a specific version number
// Include script from https://www.jsdelivr.com/package/npm/scichart
<script src="https://cdn.jsdelivr.net/npm/scichart@3/index.min.js"
   crossorigin="anonymous"></script>

// Import your types
const { SciChartSurface, NumericAxis, FastLineRenderableSeries } = SciChart;

// Now Configure SciChartSurface in code to load the wasm file from CDN
SciChartSurface.useWasmFromCDN();

// Now create a SciChartSurface as you would normally!
const { sciChartSurface, wasmContext } = await SciChartSurface.create("div-id");

The post SciChart.js v3.5 Released! appeared first on SciChart.

SciChart Selected to Power Telehealth Medical Dashboards for Philips ‘Capsule Surveillance’ in Major North American Rollout

SciChart, the world leader in high-performance precision data visualization software, has been chosen by Philips to deliver advanced charting solutions for its innovative Telehealth ‘Capsule Surveillance’ system. 

The collaboration aims to support Philips’ mission of improving patient outcomes through easy, secure access to data and mobile notifications.

The platform, set to roll out across up to 50 hospitals in North America, will enable healthcare teams to enhance patient care through real-time monitoring and tailored, condition-specific alerts. With advanced JavaScript and Android healthcare dashboards, Philips will develop distributed healthcare analytics in clinical settings across disciplines.

Capsule Surveillance will live-stream patient data, detailed trends, and real-time alerts, allowing healthcare professionals to detect emergent conditions early and respond rapidly. This approach shifts healthcare to a more proactive service, improving clinical outcomes.

Clinicians will be able to view complex data at dedicated workstations, embedded hardware via remote browsers, on rounds with tablets, or on the move with smartphones. This supports a flexible healthcare service, where both clinicians and patients have access to the data they need to monitor and respond to health conditions more efficiently. 

About SciChart: SciChart is the world’s fastest, precision data visualization software, used by top global companies in sectors ranging from healthcare and engineering to aerospace and scientific research. Offering cross-platform compatibility, precision rendering, and unparalleled performance, SciChart is trusted for applications that demand speed and accuracy in real-time data analysis. SciChart is found everywhere from the F1 race track, to NASA mission command centers and pioneering research.

What Are Telehealth Platforms?

Telehealth platforms are digital systems enabling remote patient monitoring, virtual consultations, and real-time data analysis, used in settings like virtual ICUs and clinics to improve accessibility and patient care efficiency.

Telehealth platforms are transforming healthcare by enabling remote patient monitoring, virtual consultations, and real-time collaboration. They rely on data visualization to convert complex datasets—such as heart rates, oxygen levels (SPO2), and ECG/EKG charts—into clear Medical Dashboards. These visual tools help clinicians quickly assess patient conditions, identify trends, and make timely decisions.

In settings like virtual ICUs, continuous monitoring allows data to be accessed on mobile, tablet, or desktop devices, giving healthcare providers the flexibility to react swiftly. The use of JavaScript, WPF, and Android chart libraries is critical for creating responsive and reliable dashboards, while cross-platform support ensures consistent and accurate data presentation, ultimately improving patient outcomes.

Continuous Analysis of Live, Streaming Clinical Data with SciChart Healthcare Dashboards

SciChart’s unparalleled speed, accuracy, and cross-platform capabilities as a medical charting library made it the clear choice for Philips Capsule Surveillance, a system that brings together detailed patient data, ECG/EKG waveforms, and device alarms into a single, unified view.

It was important for Philips to ensure both the accuracy and integrity of the data, even when processing large volumes in real-time. Using the world’s only high-performance, precision 64-bit data visualization library, they could be confident that their medical dashboards support the needs of their ambitious application.

Philips liked the fact that clinicians can access this data from a virtual ICU screen, tablet, or mobile device. They will also benefit from SciChart’s responsive, precise visualizations, overlays, and annotations, ensuring clarity and reliability in critical situations.

With a client base that includes 90% of the world’s leading MedTech companies, SciChart continues to solidify its position as a key player in the healthcare sector, where performance and accuracy are paramount. This integration with Philips further underscores SciChart’s commitment to supporting groundbreaking projects that make a significant impact in critical industries.

Benefits of Data Visualization in Telehealth

There are a multitude of benefits of using telehealth, and more and more healthcare organizations around the world are choosing to implement this into their systems. 

• Improved Decision-Making: Clear and concise visualizations help healthcare professionals make quick, informed decisions that improve patient outcomes.
• Anywhere Access: Visual data can be accessed on various devices, including smartphones, tablets, and desktops, ensuring that critical information is available wherever it’s needed.
• Proactive Care: With real-time data streams, healthcare providers can anticipate problems before they escalate, offering a proactive approach to patient care.

Challenges Telehealth Platforms Face in Data Visualization—and How SciChart Solves Them

Telehealth platforms face several challenges when it comes to data visualization, particularly given the complexity of the data and the need for rapid, real-time processing. 

These challenges include:

• Handling Large Volumes of Data: Telehealth platforms often collect data from multiple medical devices, resulting in massive amounts of information that must be processed and displayed in real-time without delay. SciChart’s multi-award-winning Visual Xccelerator (Vx™) engine ensures fast and accurate data insights on any device. Millions of data points can be rendered in real-time with no lag, even on lower-quality hardware and mobile devices. A low memory and CPU footprint also maintains healthy battery life and performance on devices.

• Cross-Platform Consistency: Clinicians access telehealth platforms from various devices, meaning that visualizations must be responsive, clear, and consistent across different screen sizes and operating systems. SciChart is the only cross-platform charting library, meaning its data visualizations perform seamlessly on any device—whether it’s a mobile phone, tablet, embedded hardware or desktop computer. 
  
• Accuracy and Precision: In healthcare, even the slightest error or delay in data visualization can have serious consequences. Telehealth systems need highly accurate and precise visual representations of data to ensure the best possible patient outcomes. SciChart’s 64-bit precision ensures that complex data sets are visualized with the highest level of accuracy, providing healthcare professionals with reliable insights at every moment.
  
• Scalability: As healthcare organizations expand their use of telehealth, data visualization systems must scale to accommodate growing numbers of patients and devices without sacrificing performance. SciChart effortlessly handles the increasing data demands of large telehealth networks, supporting a growing number of patients and devices while maintaining top performance. Through advanced rendering techniques and optimizations, SciChart enables low-cost embedded hardware and complex functionality on smartphones.
• Flexibility: With various data sources, medical dashboards need to incorporate numerous chart types, annotations and overlays all in single-view screens or with the ability to drill down, review over time and interact with the data. Built for demanding scientific, medical and engineering applications, SciChart is designed for bespoke product creation when off-the-shelf solutions don’t exist. The versatile and expansive API allows deep configuration and customisation of charts, detailed dashboard creation and continuous improvement.

How SciChart Meets These Challenges:

• Unmatched Performance: SciChart’s proprietary Visual Xccelerator (Vx™) engine is designed for high-performance environments, rendering millions to billions of data points in real-time, ensuring clinicians can access and interact with data without lag or delay.
• Cross-Platform Capability: SciChart is the only cross-platform charting library, meaning its data visualizations perform seamlessly on any device—whether it’s a mobile phone, tablet, embedded hardware or desktop computer. This ensures that healthcare providers always have consistent, clear data displays, no matter where they are or what device they use without sacrificing native performance.
• Precision and Accuracy: SciChart’s 64-bit precision ensures that complex data sets are visualized with the highest level of accuracy, providing healthcare professionals with reliable insights at every moment.
• Scalability and Efficiency: SciChart is engineered for scalability, effortlessly handling the increasing data demands of large telehealth networks, supporting a growing number of patients and devices while maintaining top performance. Through advanced rendering techniques and optimizations, SciChart enables low-cost embedded hardware and complex functionality on smartphones.
• Flexibility: Built for demanding scientific, medical and engineering applications, SciChart is designed for bespoke product creation when off the shelf solutions don’t exist. The versatile and expansive API allows deep configuration and customisation of charts, detailed dashboard creation and continuous improvement.

By addressing these critical challenges, SciChart empowers telehealth and healthcare analytics platforms to provide medical teams with the accurate, real-time data they need to make faster, smarter decisions—ultimately leading to improved patient outcomes across the board.

Medical Dashboards for ECG/EKGs and Telehealth platforms

Whether you’re looking for ECG Charts, EKG visualization tools, or custom medical dashboards, SciChart enables clients to pioneer life-changing medical devices and push the boundaries of research. Our high performance rendering engine, designed with medical applications and research in mind can help you bring your next project to life on anything from mobile devices, to embedded hardware or remotely accessible browsers. SciChart is the only high-performance precision 64-bit library built for data accuracy and integrity available on WPF, JavaScript, iOS, Android and MacOS with support for Linux.

Learn More

The post Announcement: SciChart Selected to Power Telehealth Dashboards for Philips ‘Capsule Surveillance’ in Major North American Rollout appeared first on SciChart.

SciChart, a supplier to all leading Formula One teams, has been selected for a novel wind tunnel data visualization project to deliver the next generation of aerodynamic changes to the upcoming season’s vehicles. 

F1 technical regulations in 2022 emphasized downforce and airflow, making aerodynamics a vital part of technology evolution. As a result, wind tunnel testing became the most important development tool in the sector.

Cross-platform solutions, including JavaScript and WPF, will be leveraged to undertake deep data analysis in controlled environments to evaluate design changes and atmospheric impacts on vehicular performance.

Wind tunnel use is restricted in Formula 1 by the FIA regulations. Under the new sliding scale model, teams are restricted to the number of wind tunnel testing runs and computational fluid dynamics (CFD) hours they can do, based on their current performance. It’s thought this will help level the playing field and provide less predictability for racing teams. However, even with these new restrictions, teams can build resilience with the right systems. 

SciChart was selected from a complete market analysis based on interactivity and performance to deliver on a complex real-time aerodynamics requirement. Due to the restricted use model, SciChart will be leveraged to build novel high-performance precision interfaces. The data extracted will provide exciting insights to fuel vehicle design on the track.

About SciChart: SciChart is the world’s fastest, precision data visualization software, used by top global companies in sectors ranging from healthcare and engineering to aerospace and scientific research. Offering cross-platform compatibility, precision rendering, and unparalleled performance, SciChart is trusted for applications that demand speed and accuracy in real-time data analysis. SciChart is found everywhere from the F1 race track, to NASA mission command centers and pioneering research.

How SciChart is Enabling Wind Tunnel and Aerodynamic Projects

Used by all leading F1 teams, Nascar, and automotive market leaders, SciChart is a data visualization solution for real-time telemetry, lap analysis, aerodynamics, and signal processing. SciChart specializes in charting for pit strategy software, powertrain optimization, ECU, and engine design across design, emulation, and test undertaking consultancy projects in this sector.

SciChart is specifically designed to handle these complexities, making it an ideal solution for visualizing and analyzing wind tunnel and aerodynamic data.

Why is Wind Tunnel Data Complex?

Wind tunnel testing is essential in industries like motorsport, aerospace, and automotive, where optimizing aerodynamic performance is critical. 

Projects that utilize wind tunnels face unique challenges due to the complex nature of the data involved. Wind tunnel testing generates vast and intricate datasets. This includes:

• Aerodynamic forces (lift, drag, and side force) that help optimize speed and handling.
• Pressure distribution data across the vehicle’s surface to visualize airflow patterns.
• Force and moment coefficients (CL, CD, and CM) that measure lift, drag, pitch, roll, and yaw moments.
• Wheel and tire data that captures the impact of rotating elements on aerodynamics.
• Environmental conditions like wind speed, temperature, and density that affect aerodynamic forces.

Handling and visualizing this data in real-time is critical for making quick, informed adjustments to improve vehicle performance in motorsport aerodynamics, but also aircraft aerodynamics and military wind tunnels. 

The datasets are often large and must be rendered without lag, making performance and accuracy essential. SciCharts proprietary 64-bit rendering engine means that accuracy and performance are guaranteed.

The Charts Powering Aerodynamics Dashboards across Motorsport, Automotive & Aerospace

SciChart offers a range of chart types specifically tailored to visualize wind tunnel data, including:

• Force vs. speed graphs to track aerodynamic forces like downforce and drag.
• Coefficient graphs to plot variables like lift and drag coefficients against yaw or pitch.
• Contour plots and heatmaps for real-time pressure distribution visualization.

• 3D surface plots to view airflow around the vehicle in 3D.

• Polar plots to demonstrate the trade-offs between drag and downforce in real-time.

Data Customization with SciChart

SciChart’s advanced rendering engine enables multi-chart type dashboards, detailed annotations, bespoke overlays, and heatmaps for aerodynamics all in real-time from multiple data sources. Our expansive API puts you in the driver’s seat of your data sets, providing unmatched flexibility and customizations.  

The extensive customization options enable engineers to:

• Synchronize multiple charts for a comprehensive view of data.
• Customize axes, data streams, and chart surfaces.
• Integrate real-time data feeds, allowing engineers to interact with live datasets during testing.

SciChart’s high-performance GPU-accelerated rendering ensures smooth, real-time visualization of millions of data points. For aerodynamic projects, where large datasets need to be processed instantly, this is crucial. Thanks to its support for both 2D and 3D visualization, teams can flexibly analyze everything from pressure gradients to airflow dynamics. Our cross-platform solution allows deployments across hardware, meaning decentralized teams can still offer their expertise remotely.

Data Visualization solution for Aerodynamic Dashboards

SciChart powers aerodynamics and wind tunnel projects in the aerospace, defense, and automotive sectors by offering high-performance data visualization solutions. With real-time analysis of wind tunnel data such as pressure distribution, drag reduction, and downforce optimization, SciChart provides advanced tools for simulation integration and aerodynamic modeling. 

Whether it’s enhancing aerodynamic performance in Formula 1, improving aircraft stability in aerospace, or conducting defense wind tunnel testing for military vehicles such as UAVs, SciChart enables fast, accurate insights through multi-channel visualization and customizable charts. This ensures critical data from aerodynamic testing is handled efficiently, driving innovation across all sectors

F1/Automotive Defence/Aerospace

The post Announcement: SciChart Selected for Next-Generation F1 Wind Tunnel Dashboard Project appeared first on SciChart.

SciChart, a leading supplier for 80% of top US and UK banking institutes, has been selected to power Commerzbank’s data visualizations across their entire mobile retail banking suite. This integration of SciChart’s native iOS and Android chart library will deliver faster, more accurate, and highly customizable data insights for millions of Commerzbank customers in Europe.

Commerzbank’s retail banking app will support interactive charting across devices, leading the bank’s digital first strategy. The bank will join J.P. Morgan as the next major financial institute to leverage SciChart in their customer-facing mobile products. 

SciChart’s unique positioning as the only high-performance, hardware-accelerated native iOS and Android chart library will enable dynamic data visualization across generations of mobile phone technology. Customers can expect a seamless experience, whether viewing stock market trends, monitoring spending history, or analyzing personal finances.

Commerzbank clients will benefit from standardization across devices without slowdown, alongside enhanced data access. Native iOS (Swift) and Android (Android SDK, Kotlin) were chosen over JavaScript for mobile due to the inherent performance benefits and UX. This and more will help separate Commerzbank’s mobile offering from its competitors. 

About SciChart: SciChart is the world’s fastest, precision data visualization charting library, used by top global companies in sectors ranging from healthcare and engineering to aerospace and finance. Offering cross-platform compatibility and full native support across WPF, JavaScript, iOS, Android and MacOS. SciChart is trusted for applications that demand speed and accuracy in real-time data analysis or performance across low-end devices and embedded hardware. SciChart is found everywhere, from the F1 racetrack, to NASA mission command centers and low-cost medical devices.

What Are Retail Banking Applications?

Retail banking applications provide consumers with easy access to their personal finances via smartphones or tablets. Essential banking tasks, like checking balances, transferring money, and paying bills, can be done at any time without needing to visit a physical branch. They also support advanced features like managing loans, investments, and personal finance tools.

What Are the Key Benefits of Retail Banking Applications?

There are plenty of benefits of retail banking applications, and as more and more banks and financial institutions explore this avenue for their customers, it’s good to consider why and how these apps will improve the consumer experience while simultaneously supporting business goals.

1. Convenience: Apps offer 24/7 access to banking services, making it easier for users to manage their finances on the go.
2. Real-Time Access: Users receive up-to-the-minute data on their transactions and account balances, facilitating better financial oversight.
3. Data Visualization: Visual tools, such as charts and graphs, play a critical role in helping users understand spending patterns, monitor investments, and track financial goals. This enhances decision-making by simplifying complex data into intuitive, digestible formats.
4. Security: With advanced features like two-factor authentication and biometric logins, banking apps ensure secure transactions.
5. Personal Finance Management: Many apps include visual aids to categorize spending, create budgets, and monitor savings goals, further empowering consumers to manage their finances efficiently.

By incorporating data visualization, retail banking apps transform financial information into easily understandable visuals, helping users interpret trends and make informed financial decisions. 

These apps deliver an all-in-one solution that combines convenience, security, and clarity for users’ financial management needs. Linked products include cryptocurrency trading apps, such as Binomo, and stocks and shares applications, such as Robin Hood.

Challenges Faced by Mobile Banking Applications in Data Visualization

As consumers become more demanding, expecting a digital-first, mobile solution, banking applications become more complex and data-rich, requiring efficient, accurate and user-friendly data visualizations. The sector faces unique challenges in UX to differentiate product offerings from competitors and provide value to consumers while working within the confines of the mobile technology environment.

1. Compatibility Across a Wide Range of Devices

• Diverse Hardware: Mobile banking apps need to function across a broad spectrum of devices, from high-end smartphones with powerful processors to older, lower-spec models. This makes it difficult to ensure that charts render consistently and perform well across devices.
• Operating System Fragmentation: With various versions of Android and iOS in use, ensuring that charting libraries and data visualizations behave uniformly across different OS versions is a constant challenge. Features that work on newer OS versions might fail on older ones, requiring additional testing and optimizations.
• Screen Sizes and Resolutions: Mobile devices come in a wide range of screen sizes and resolutions, making it necessary to create responsive, scalable charts that provide a seamless experience, whether viewed on a compact smartphone or a tablet.

2. Performance Constraints

• Touch and Gesture Support: Mobile devices rely on touch interactions like tapping, swiping, pinching, and zooming, which require different charting behaviors compared to desktop applications that rely on keyboard and mouse input. Ensuring that charts respond intuitively to these gestures while maintaining accuracy and fluidity is a core challenge.
• Limited Input Space: Due to the smaller screen size, the interactive elements of charts, such as tooltips, legends, and buttons, need to be carefully designed so they don’t overwhelm the user interface but remain accessible and user-friendly.

3. Interaction Complexity

• Touch and Gesture Support: Mobile devices rely on touch interactions like tapping, swiping, pinching, and zooming, which require different charting behaviors compared to desktop applications that rely on keyboard and mouse input. Ensuring that charts respond intuitively to these gestures while maintaining accuracy and fluidity is a core challenge.
• Limited Input Space: Due to the smaller screen size, the interactive elements of charts, such as tooltips, legends, and buttons, need to be carefully designed so they don’t overwhelm the user interface but remain accessible and user-friendly.

4. Theming and Accessibility

• Dark Mode and Theming: Many mobile users prefer dark mode, but switching between light and dark themes while ensuring that charts remain legible and aesthetically pleasing can be a challenge. Charts often contain fine details, and certain colors may lose contrast in dark mode, requiring custom adjustments.
• Accessibility for Users with Disabilities: Ensuring charts are accessible for users with visual impairments or motor disabilities is vital. Features such as voice-over narration, zooming for clarity, and high-contrast mode need to be supported to meet accessibility guidelines like WCAG (Web Content Accessibility Guidelines).

5. Real-Time Data and Complexity

• High-Frequency Data Updates: Although more aligned to commercial solutions instead of the retail market, financial applications often require real-time or near-real-time data updates, especially for market data and investment tracking. Managing these updates on mobile devices, especially with limited network bandwidth or unstable connections, poses significant technical hurdles.
• Complex Data Sets: Users might expect to visualize large or complex datasets, such as historical financial data or detailed spending analysis. Rendering this data efficiently without sacrificing clarity or detail is challenging on mobile devices with limited resources.

How SciChart’s Native iOS and Android Solutions Address These Challenges

From cross-platform integration to fast, real-time chart rendering, banking app providers can achieve a seamless experience for their end user while tackling the challenges of finance big data projects head-on.

1. Cross-Platform Compatibility

• Optimized for iOS and Android: Native libraries are specifically designed for the nuances of each platform, ensuring seamless integration with both iOS and Android environments. This reduces the fragmentation issues often faced in mobile development and guarantees that charts function consistently across different OS versions and device types.
• Responsive Design: SciChart supports automatic scaling and responsive layouts, ensuring charts render optimally on all screen sizes and resolutions. Whether on a compact smartphone or a tablet, charts are always clear and readable, making them ideal for the diverse devices used by banking customers.

2. High-Performance Rendering

• Visual Xccelerator Rendering Engine: The proprietary engine ensures fast, GPU-accelerated chart rendering, reducing the load on the CPU and improving performance, even on lower-end devices. It can handle real-time updates, processing millions of data points per second in WPF. This makes it suitable for financial applications that require up-to-date visualizations of live stock prices, transaction histories, currency exchange rates, or spending patterns.
• Efficient Resource Management: SciChart is engineered to be memory-efficient, ensuring charts run smoothly without consuming excessive battery life or memory. This optimization makes it suitable for complex banking applications that need to balance performance with user experience.

3. Intuitive Mobile Interactions

• Touch Gesture Support: Includes built-in support for touch gestures, such as pinch-to-zoom, drag-to-pan, and tap-to-select. These gestures are responsive and intuitive, allowing users to interact with financial data in a fluid and seamless manner. For example, users can zoom in on specific parts of a stock chart or tap to see more detailed data points.
• Customizable Interactions: Developers have flexibility to create custom interactions, ensuring that user interfaces are optimized for mobile and can be tailored to the specific needs of the banking application.

4. Theming and Accessibility

• Dynamic Theming Support: SciChart natively supports dark mode and custom themes, allowing developers to easily switch between light and dark with optimum visual clarity and contrast. Gridlines and labels can be modified dynamically to suit any color scheme.
• Accessibility Features: Charts can be configured to meet accessibility standards, with options for larger labels, tooltips, and high-contrast settings, ensuring users with disabilities can interact with charts without difficulty. Custom tooltips and labels can also be designed to work with screen readers for users who rely on voice-over technology.

5. Real-Time Data Handling

• Efficient Real-Time Updates: SciChart is designed to handle real-time data feeds efficiently, making it ideal for financial applications that require frequent updates, such as live market data or currency exchange rates. SciChart’s rendering engine ensures that these updates are processed smoothly, without freezing or slowing down the app, even when dealing with large datasets.
• Large Dataset Support: Whether displaying years of transaction history or detailed investment data, SciChart can manage large datasets—millions of data points and hundreds of series—without losing performance. This makes it well-suited for banking apps that need to visualize vast amounts of financial data in a meaningful way.
• Complex Visualizations: Supported by the bolt-on SciTrader, SciChart supports complex financial charting out of the box, including existing APIs to build detailed financial dashboards on mobile for everything from live trading on mobile to deep dives into financial history data.

Financial Data for Mobile Banking Applications

Whether you’re looking to present simpler retail market financial data on mobile, or build out the next trading platform to rival TradingView, SciChart enables clients to create pioneering data visualizations across devices. Catering from everything from the entire retail banking application for J.P. Morgan and Commerzbank to LSEGs Eikon platform, SciChart has solutions ranging from OHLC charts to live trading indicators all the way to customizable pie charts to visualize personal spend history.

Learn MoreVisit SciTrader

The post Announcement: SciChart selected by Commerzbank for financial charting across multi-million-user retail mobile banking suite appeared first on SciChart.

Onward Medical Secures $50 Million to Advance Paralysis Therapies with SciChart-Enabled Real-Time Dashboards

December 2024 – Onward Medical has secured a $50 million investment from Ottobock, a global leader in medical technology, to accelerate the development and commercialization of its groundbreaking spinal cord stimulation therapies. These therapies, powered by Neurorestore’s cutting-edge research and supported by SciChart’s real-time data visualization technology, are transforming the treatment of spinal cord injuries (SCI). 

Neurorestore Pioneering Breakthroughs in SCI Treatment

Spinal Cord Injury (SCI) disrupts communication between the brain and body, often resulting in paralysis. Complete motor paralysis caused by thoracic and lumbar injuries, historically considered irreversible, are now being tackled through Neurorestore’s groundbreaking Epidural Electrical Stimulation (EES).

Key innovations include: 

• Targeted Dorsal Root Stimulation: Activating motor neurons with precision-placed electrodes. 

• Custom Electrode Design: Advanced 16-electrode leads target multiple nerve groups simultaneously. 

• Activity-Specific Software: Programs replicate natural motor neuron activation, enabling walking, swimming, and more. 

Results speak volumes. Within hours of EES setup, patients regained basic motor functions. Over months of therapy, they achieved mobility independence, improved muscle function, and even voluntary movement without stimulation.

Neurorestore’s innovations, enhanced by SciChart’s real-time visualization, set a new standard in SCI treatment and offer hope for broader applications, including stroke and Parkinson’s rehabilitation.

SciChart’s Powering MedTech Real-Time Dashboards

Neurorestore’s success is underpinned by SciChart’s high-performance WPF charting and data visualization software, which plays a critical role in their research and therapy design.

Key contributions include: 

• Real-Time Visualization and Modulation: Enables clinicians to monitor complex synaptic data and adapt stimulation waveforms on the fly. 

• Custom Overlays for Clinician-Driven Modulation: Provides bespoke interfaces for live simulation and adjustment of therapy protocols. 

• Processing Power for High-Volume Data Streams: Handles simultaneous inputs from multiple sensors without performance slowdowns. 

• GUI Flexibility: Supports tailored dashboards for unique clinical requirements, bridging brain-to-body communication efficiently. 

Charles David Sasportes, from the Department of Clinical Neurosciences at Lausanne University Hospital, noted: 

“SciChart’s speed and thorough documentation have been crucial in advancing our therapy, enabling us to efficiently monitor numerous physiological signals without system slowdowns.” 

Empowering MedTech Innovation

SciChart’s technology is trusted across the MedTech industry, supporting innovations beyond spinal cord injuries. Our software powers breakthroughs in: 

• Breast cancer treatment through advanced imaging visualization.

• Telehealth platforms with custom ECG and EKG dashboards.

• Remote monitoring and data visualization for embedded medical devices.

• Research applications for leading universities like MIT and Imperial College.

With 90% of leading MedTech companies relying on SciChart, our partnership with over 250 universities globally through our Educational, Research and University Licensing Partnership Programme highlights our commitment to advancing life-changing medical research. Talk to us how we can power your next medical breakthrough.

Dashboards for MedTech and Telehealth platforms

Whether you’re looking for ECG Charts, EKG visualization tools, or custom medical dashboards, SciChart enables clients to pioneer life-changing medical devices and push the boundaries of research. Our high performance rendering engine, designed with medical applications and research in mind can help you bring your next project to life on anything from mobile devices, to embedded hardware or remotely accessible browsers. SciChart is the only high-performance precision 64-bit library built for data accuracy and integrity available on WPF, JavaScript, iOS, Android and MacOS with support for Linux.

Learn More

The post Announcement: $50 Million Funding for Novel Paralysis Therapies Leveraging SciChart appeared first on SciChart.

Announcement: US Navy Integrates SciChart React Charts for Enhanced Maritime SIGINT Software

January 2025 – The US Navy has chosen SciChart’s JavaScript and React charts to enhance its Global Reconstruction Analysis and Measurement System (GRAMS), a pivotal platform certified by the Office of Naval Intelligence (ONI). These enhancements strengthen capabilities in underwater acoustic data analysis, aiding in the detection and tracking of submarines, surface ships, and weapons through advanced defense dashboards.

With task orders valued at over $7 million, the Naval Air Systems Command (NAVAIR) and Maritime Surveillance Associates are collaborating with SciChart to enhance and maintain GRAMS and its components. These initiatives include software enhancements, systems engineering, and technical support, ensuring the platform meets evolving mission needs.

Expanding Capabilities in Maritime Surveillance with SciCharts React Chart Library

GRAMS forms a critical component of the Multistatic Active Coherent Enhancements (MAC-E) Post Flight Analysis (PFA) Suite, which supports the Navy’s P-8A Poseidon maritime patrol aircraft.

SciChart’s data visualization capabilities, as the only high-performance, precision rendering solution ensures that operators have access to high-performance, real-time graphical interfaces for evaluating Sound Pressure Levels (SPL) and analyzing data collected during anti-submarine warfare (ASW) missions. Leveraging SciChart Javascript React Charts, the GRAMS cloud solution provides a web-based ecosystem for remote analysis of SIGINT data. SciChart provides a cross-platform ecosystem supporting Javascript (React, Angular, Typescript), WPF, iOS, Android, and Linux through Avalonia XPF.

The MAC system, a primary tool for wide-area acoustic search, benefits from SciChart’s ability to render vast datasets with high accuracy and speed, enabling improved situational awareness and decision-making in complex underwater environments.

Seamless Integration and Tactical Advancements

SciChart’s visualization technology plays a key role in developing a Tactical Situation Display (TSD). This interface integrates seamlessly with the P-8A Acoustic Operational Flight Product (AOFP) and serves as a surrogate for the Tactical Open Mission System (TOMS). The TSD, powered by SciChart, will be deployed in:

• Lab environments for rigorous system testing.
• TACMOBILE for integration into the Tactical Mobile Acoustic Sensor Systems (TACMASS).
• Training centers to enhance operational readiness for naval crews.

Supporting HARBINGER SIGINT and Next-Gen Surveillance

Aligned with the Navy’s HARBINGER SIGINT initiative, these efforts bolster the Navy’s capacity to collect, process, and analyze signals intelligence in real-time. Maritime Surveillance Associates selected SciChart’s Visual Xccelerator rendering engine for GRAMS, providing the precision and processing power required for real-time visualization of SIGINT and acoustic data across diverse maritime environments.

Enabling Strategic Maritime Operations

This collaboration demonstrates SciChart’s role in advancing the Navy’s operational capabilities. Through robust, scalable data visualization technology, SciChart is helping NAVAIR and the broader naval community achieve their mission to safeguard maritime domains. Through these important upgrades, the following goals will be addressed:

• Improve post-mission analysis capabilities
• Enhance real-time tactical situational awareness
• Provide robust tools for training and simulation
• Integrate advanced systems into operation workflows, particularly for P-8A maritime patrol and reconnaissance aircraft.

Whether you’re looking for SIGINT software, visualization tools, or advanced analytics, a robust SIGINT platform is key to transforming complex signal data into actionable intelligence. SciChart caters to a wide range of Aerospace and Defence projects from signals intelligence to telemetry. Our high performance rendering engine and proprietary technology can help you deliver your next military contract.

Learn MoreContact Us

The post Announcement: US Navy Integrates SciChart React Charts for Enhanced Maritime SIGINT Software appeared first on SciChart.

SciChart is proud to announce the integration of its advanced JavaScript React Charts and Android Charts into Sibel Health’s ANNE® One platform, a telehealth system for vital signs monitoring designed for neonatal care.

Securing FDA 510(k) clearance, the platform underscores SciChart’s role in delivering flexible, functional medical dashboards. Its intuitive interface earned the Red Dot Award for Interface Design. The SciChart-enabled platform has since secured $17.5 million in funding, including a grant from the Bill & Melinda Gates Foundation, to advance maternal and neonatal monitoring in low- and middle-income countries.

About Anne One, SciChart & Telehealth

The ANNE® One platform leverages wearable sensors to provide continuous, real-time monitoring of vital physiological parameters. This includes heart rate and respiration, tailored for the unique needs of neonatal patients.

With the integration of SciChart’s JavaScript React healthcare dashboards, clinicians can access precise waveform charts that visualize ECG and respiration waveforms with unparalleled accuracy. These visualizations empower healthcare providers to make critical decisions quickly and effectively in both clinical and telehealth settings.

Supporting Innovation and Securing Funding through Medical Dashboards Performance Optimizations

SciChart’s efficient rendering engine is optimized for low CPU and GPU usage, significantly reducing the computational overhead required to render high-quality, real-time visualizations. These optimizations minimize power consumption and hardware requirements. This means the medical dashboards can be deployed on cost-effective devices without compromising performance or accuracy.

By lowering the barriers associated with high-performance computing, SciChart supports scalable and affordable implementations. This makes it particularly effective for large-scale deployments in low- and middle-income countries, where lower-cost hardware increases accessibility and facilitates widespread adoption. This also minimizes overhead on complex embedded hardware in other markets.

Through these capabilities, SciChart enables organizations to deliver innovative solutions, improve usability, and achieve critical funding benchmarks while maintaining affordability and scalability.

Enhancing Interface Design, Functionality, and Aesthetics with Plugin-Based API Architecture

SciChart’s plugin-based architecture allows developers to create custom layouts, drill down into specific requirements, and design complex, linked charts tailored to enterprise needs. The ChartModifier API provides modular tools for behaviors like zooming, panning, tooltips, and selection.

Developers can use default behaviors to accelerate development or create custom interactions to address unique UX or accessibility needs. This flexibility enables the development of intuitive, user-controlled dashboards that simplify interfaces, reduce training requirements, and support seamless large-scale rollouts.

These capabilities were instrumental in achieving a design that balances clinical precision with usability, contributing to the platform’s recognition with the prestigious Red Dot Award for Interface Design. This combination of extensibility, customization, and user-centric design underscores SciChart’s role in driving innovation in healthcare dashboards.

Supporting FDA Clearance for Medical Applications

SciChart’s architecture and capabilities meet the stringent demands of FDA clearance for medical devices. The platform supports compliance with critical considerations for data handling, accuracy, usability, and data protection.

1. Data Handling

SciChart’s high-performance rendering ensures real-time, low-latency data visualization for clinical applications. Additionally, robust error management will be implemented to detect and handle anomalies, preserving data integrity during processing.

2. Accuracy

High-resolution charts ensure accurate representation of medical data through precise visualizations. Built-in and custom algorithms undergo rigorous testing to ensure consistent outputs through validated algorithms.

3. Usability

The API supports customizable interfaces for the creation of intuitive dashboards that align with user needs and clinical workflows. By integrating human factors, the development of user-friendly and accessible visualizations help minimize errors. Rich interactivity, including zooming, panning, and annotations, further enhances user engagement and data understanding.

4. Data Protection

Support for encryption and protocol ensures that all patient data transmission and storage is handled with the utmost security and confidentiality.

Medical Grade Charting

SciChart is a global leader in high-performance data visualizations, providing solutions trusted by industries requiring precision and reliability. In fact, SciChart’s software is used by 90% of top medical device companies globally.

Built on proprietary rendering technology our medical-grade charts are integrated across sectors and help secure FDA clearance, as well as ISO accreditation.

Learn MoreContact Us

Read More About SciChart’s Support for Pioneering Medical Devices

• The NeuroRestore treatment center in Switzerland used SciChart to help restore mobility in patients with spinal cord injuries, in a world first.
• Philips uses SciChart for cardiac telemetry and patient monitoring applications to simplify vitals acquisition, visualization and interpretation. The result? Faster time-to-diagnosis for at-risk patients.
• SciChart powered the world’s first FDA-cleared contactless monitoring system, providing a HIPAA-compliant platform.

The post Announcement: SciChart-Powered Medical Dashboards for Neonatal Care Receives FDA Clearance, Interface Design Award & $17.5m Funding appeared first on SciChart.

SciChart, a leader in high-performance precision charting, marks a decade of use in Rocket Lab’s Design and Test Suites across WPF and JavaScript. This partnership has enabled Rocket Lab to deliver unparalleled efficiency and reliability in its space-grade solar products, which currently power over 1,100 satellites in orbit. With an additional 500 scheduled for launch, we foresee plenty of development in robust, renewable energy to power advancements in space exploration.

Rocket Lab’s Next-Gen Space Solar Tech Powered by SciChart’s Precision Data Visualization

Rocket Lab’s SolAero solar cells and assemblies are among the most advanced in the world, achieving the highest efficiency commercially available at 34% with more than 4 MW of power delivered for flight missions.

The integration of SciChart’s high-performance visualization tools into their design and testing processes has accelerated the development of next-generation technologies like Next-Gen Z+ and IMM-β, paving the way for even higher-efficiency solar products in future missions.

About SciChart:

SciChart is the world’s fastest, precision data visualization software, used by top global companies in sectors ranging from healthcare, signal processing and engineering to aerospace and scientific research.

With cross-platform compatibility, high-performance rendering, and real-time analysis capabilities, SciChart empowers businesses and research institutions to process complex datasets with unparalleled speed and accuracy. SciChart is used by F1 racing teams, NASA mission command centers and to conduct pioneering healthcare research.

What is Space Solar Design and Test Software?

Space solar design and test software provides tools for developing, verifying, and optimizing engineering components and systems.

In Rocket Lab’s context, this involves rigorous testing of solar cells and solar cell arrays under conditions mimicking space environments. This ensures reliability and performance through the use of custom-developed solutions. Where more typical off-the-shelf solutions lacked flexibility or performance, SciChart excelled.

Data visualization, a critical component of design and test software, transforms raw performance data into clear, interactive visual formats. This allows engineers to:

• Monitor real-time data during tests.
• Identify anomalies or deviations quickly.
• Analyze trends and correlations to optimize design and performance.
• Validate results with intuitive visual reports.

SciChart’s high-performance visualization tools empower Rocket Lab’s engineers to efficiently process and analyze vast datasets. We don’t just provide the precision and quality for engineering space-grade products; we also achieve advanced optimizations leading to sector advances.

Overcoming Challenges in Space Solar Testing with SciChart

The design and testing of space-grade solar technologies, such as Next-Gen Z+ and IMM-β solar cells, present unique challenges. Ensuring performance, precision, and scalability requires specialized tools that surpass generic commercial solutions.

Here’s how SciChart, with our advanced WPF Chart Library and JavaScript Chart Library, powers bespoke dashboards to address these critical issues.

Challenges in Testing Space Solar Technologies

Rocket Lab’s testing environments are intense. Exposure to intense radiation, vacuum chambers, and extreme thermal cycling requires high-performance software. Processing massive datasets with precision under extreme test conditions is critical.

How SciChart Solves These Problems

“SciChart is proud to be an essential part of Rocket Lab’s innovation in space-grade solar technology. Our high-performance data visualization software enables engineers to process and analyze complex test data with speed and accuracy, driving advancements that push the boundaries of what’s possible in space exploration,” said Andrew Burnett-Thompson, CEO of SciChart.

Unmatched Performance:

Powered by the Visual Xccelerator engine, SciChart delivers real-time, high-speed rendering of large datasets, enabling engineers to process high-frequency data streams across platforms without slowdown.

Customizability for Dashboards:

SciChart’s flexible tools allow the creation of tailored dashboards and visualizations to match the diverse test conditions of solar cell technologies, whether in WPF Chart Library or JavaScript Chart Library environments. We also now boast Linux support through our partnership with Avalonia XPF.

Simulate in Real-Time Through the Chart:

Custom Modifiers and an expansive API enable rich interactions out of the box, allowing for real-time modelling, and simulations directly from the GUI, seeing outcomes from engineer-led tweaks in real time.

High-Volume, High-Frequency Data:

Testing solar cells involves collecting immense amounts of performance data, including current, voltage, and efficiency metrics. This data is sampled at high frequencies across multiple test conditions. SciChart ensures real-time visualization without delays.

Diverse Test Conditions:

With solar cells tested under extreme environments, SciChart’s adaptable dashboards provide engineers with clear insights across different scenarios.

Precision and Accuracy:

Space-grade solar cells must achieve stringent efficiency and reliability benchmarks. SciChart’s advanced algorithms ensure the exact representation of test data, critical for meeting rigorous performance standards. Advanced algorithms ensure the exact representation of test data, critical for meeting the rigorous performance standards of space solar technologies.

Scalability:

Rocket Lab’s production pipeline, producing over 4 MW of solar cells annually, demands scalable testing systems. SciChart supports expanding datasets and production needs seamlessly, with the ability to process billions of data points in real-time with WPF and millions of data points with JavaScript. SciChart supports Rocket Lab’s expanding datasets and growing production needs, providing seamless scalability for both small-scale tests and large-scale operations.

Advanced Analysis Features for Complex Data:

Advanced analysis features include multi-series analysis, trend overlays, and interactive visual exploration. All these empower engineers to quickly identify patterns, compare historical performance, and optimize next-generation designs.

Comparing performance across iterations, overlaying historical data, and identifying degradation trends are essential for optimizing solar cell designs. Conventional tools lack the capabilities for such advanced analysis. However, this is yet another feature where SciChart excels, with unparalleled customizations and flexibility.

Developers can leverage out-of-the-box code samples or build from scratch to meet the stakeholder and end user requirements for complex data visualizations.

Data Visualization for Design, Test and Emulation

SciChart enables our clients to create custom, cutting-edge solutions, pushing the boundaries of research and development.

Our high-performance rendering engine, designed with novel requirements and backed by over 20 years of research, helps bring next-generation projects to life on anything from mobile devices and embedded hardware to remotely accessible browsers.

SciChart is the only high-performance precision 64-bit library built for data accuracy and integrity, available on WPF, JavaScript, iOS, Android, and macOS with support for Linux through our partnership with Avalonia XPF.

Learn More

For more information on SciChart’s role in aerospace innovation and high-performance data visualization, contact us or sign up for our free trial.

The post Announcement: SciChart Powers Rocket Lab’s SolAero Test Applications for Space Solar Technology Innovation appeared first on SciChart.

SciChart is excited to announce the official release of SciChart Avalonia XPF, a powerful cross-platform charting solution. This release brings the performance of WPF charting to both Windows and Linux, enabling WPF/C# developers to deploy their real-time, data-intensive applications while reusing 100% of their existing WPF code.

Avalonia XPF combines the powerful performance of WPF charts with the ability to run on multiple platforms—removing a previous limitation to help you build charts and dashboards with the ultimate flexibility. With an increasing number of devices used to view and visualize data, it’s never been more critical to ensure seamless rendering across various platforms.

SciChart Avalonia XPF is designed for industries such as scientific research, industrial monitoring, and embedded systems, where real-time data visualization is critical.

What You Need to Know

For developers already familiar with SciChart’s WPF Charts, the transition to SciChart XPF is seamless. With the same API and high-performance rendering, you can extend your WPF projects to Linux without compromising speed or accuracy.

Why It Matters

• No rewrites, no lost time: Keep using your existing WPF codebase. Just plug it in, and it works on Linux.
• True cross-platform high-performance charts: With DirectX hardware acceleration on Windows and OpenGL hardware acceleration on Linux, SciChart provides a consistent experience with the same C#/WPF codebase on Windows and Linux.
• Low latency, high throughput: Built for real-time data handling, SciChart Avalonia XPF ensures that even with millions of data points, performance remains smooth and fast.

How Avalonia and SciChart Work Together

The Avalonia XPF framework enables developers to write a single WPF C# or VB .NET codebase that runs across multiple platforms. SciChart integrates smoothly with Avalonia’s XPF Framework, providing a consistent user experience across Windows and Linux, enabling efficient development without sacrificing performance.

The Avalonia XPF framework powered by SciChart provides all the essential features for cross-platform 2D and 3D charting in one place. And, of course, you’ll have the accurate, real-time performance that SciChart is known for.

Advanced Charting for Complex Data Visualizations

This release is well suited for mission-critical environments and data-intensive applications that require advanced charting capabilities. Whether working with scientific instruments, industrial automation, or oil and gas systems, SciChart Avalonia XPF supports both 2D and 3D charts, making it ideal for complex data visualizations.

From developing embedded systems to medical devices, SciChart ensures the robust performance you’ve come to expect from its WPF version, now available across platforms.

Where to Get SciChart Avalonia XPF

Interested to get started? SciChart Avalonia XPF is available through the following methods:

⦁ Install via NuGet: Use Install-Package or Update-Package from NuGet to integrate SciChart Avalonia XPF into your project.

⦁ Cloning and compiling examples: Access the full set of SciChart Avalonia XPF examples on our GitHub repository.

⦁ Source code customers: SciChart source code is available for eligible customers on GitHub.

Visit Our Github Repository

Why Partner with SciChart?

Not worked with our charting software before? Here are a handful of ways SciChart elevates your data visualizations while ensuring cost-effectiveness for your data projects.

• High-performance charts that enable you to render 1 billion points in real time without slowdown.
• Unbeatable flexibility ensure you can create the exact data experience required for your end user.
• Our customizations, annotations and interactions make building engaging charts much easier.
• Developers save time on building complex dashboards with responsive tech support and access to hundreds of documentation, examples, demos and forums.
• With frequent updates and new feature releases, we’re the trusted data visualization partner for pioneering research and leading organizations around the world.

Discover SciChart XPF

We Want Your Feedback

We encourage developers to try out SciChart Avalonia XPF and share their feedback on our new features and improvements. Our friendly, expert team is always ready to assist, and we look forward to hearing your thoughts. Contact us at any time for support or to share your experiences with Avalonia XPF. We always welcome feedback from our community—it helps us deliver the best big data dashboard experience imaginable.

Get Started With SciChart XPF Today

The post SciChart Avalonia XPF: High-Performance Charting for Windows & Linux appeared first on SciChart.

We’ve moved over to a new format for communicating our releases and updates of our popular WPF Charts library, by publishing a rolling changelog of every fix or enhancement in SciChart.

You can find the changelogs in the top menu at Developers -> Changelogs -> SciChart WPF ChangeLog

What’s New in v8.7 of SciChart’s WPF Charts?

This release (v8.7.0 build 28455) is a cumulative update with fixes and minor enhancements which is backward compatible to version 8.0 of SciChart WPF. It’s recommended for all users on v8.x to upgrade.

To find out what is new since v8.6, read on below:

1. New Features
2. Axis Type Comparison
3. Key Features of IndexDateTimeAxis
4. Other Improvements
5. Bug Fixes
6. Noteworthy Changes

New Features

SciChart v8.7 introduces two new Category Axis Types: IndexDateTimeAxis and IndexNumericAxis.

The IndexDateTimeAxis is an advanced hybrid axis type specifically designed for financial stock charts, forex, futures, and cryptocurrency markets. It seamlessly integrates the behaviors of both CategoryDateTimeAxis and DateTimeAxis into a single, more efficient solution, simplifying development and eliminating the need for complex workarounds in trading applications. 

IndexNumericAxis functions similarly but supports numeric x-values, allowing for broader use cases beyond time-series data. 

Axis Type Comparison

DateTimeAxis is a value axis, so it uses data values to measure distance. This makes it not suitable for financial markets like forex, stocks, or futures, where trading gaps exist due to overnight sessions and weekends. Using a DateTimeAxis would show gaps at weekends or overnight in trading which is not desirable in financial applcations. 

CategoryDateTimeAxis seeks to solve the problem by using the index of data values to space candles and bars equidistantly. This neatly solves the issue of collapsing gaps in financial data. However, there are some limitations:

• All series must have the same number of points, leading to challenges with Moving Averages, which have fewer points than candlestick series. Users must manually prepend NaN (null points)
• Annotations and Markers must be placed by index, not by date. Simple trade markers require manually calculating the index position 
• Changing timeframes (e.g., switching from a daily to an hourly chart) requires recalculating all indexes and repositioning all annotations 
• Even setting VisibleRange requires manual date-to-index conversions, adding significant overhead to the user application

IndexDateTimeAxis is the new solution. It solves the challenges of financial charts by:

• Internally handling index-based calculations while allowing the user to work with data values (dates) directly
• Allowing utilizing any DataSeries as a reference scale for all other series, or, optionally, an Array of values
• Allowing VisibleRange to be set using dates rather than indexes
• Enabling Annotations to be placed directly using chart coordinates (date values), eliminating the need for index-based placement
• Handling automatic repositioning of Annotations when changing timeframes (e.g., switching from daily to hourly data)
• Allowing multiple series with different numbers of points. This means Moving Averages no longer require additional NaN values, and indicators such as ZigZag or Oscillators can have more or fewer data points than the main OHLC or Candlestick series without issues

All of this happens transparently under the hood, making financial application development easier and more intuitive, as a single axis type can now be used across Forex, Cryptocurrency, Stock Market, and Futures data without unnecessary complexity. 

Other Improvements

The post SciChart WPF v8.7 Released! appeared first on SciChart.

SciChart is to power the next generation of nuclear fusion research at the Institute of Plasma Physics, Hefei Institute of Physical Science in China.

As part of a collaboration with the Chinese government, SciChart will provide advanced signal processing and real-time data visualization capabilities for the Super-X device—an experimental superconductor evaluation platform designed to test and validate high-performance superconducting components critical to future fusion reactors.

SciChart’s integration into the Super-X system supports China’s strategic nuclear fusion initiative by enabling precise monitoring and analysis essential for the development of reliable, large-scale superconducting magnet technologies.

The Importance of Superconductor Technology in Advanced Fusion Research

Superconductors are fundamental to the operation of advanced fusion reactors, enabling the generation of strong magnetic fields required for plasma confinement with minimal energy loss.

High-performance superconducting materials allow for compact, efficient, and stable magnet systems that can sustain the extreme conditions necessary for controlled nuclear fusion.

Devices like the Super-X play a pivotal role by testing and validating these superconductors under realistic operational conditions. This ensures their reliability, guides material and design improvements, and supports the development of scalable, next-generation fusion reactors such as the China Fusion Engineering Test Reactor (CFETR).

Robust superconductor technology is essential to making fusion energy both feasible and economically viable.

SciChart Selected to Power ‘Super-X’ Device Signal Processing for Next-Gen Fusion Research

The Super-X device plays a critical role in evaluating the performance of superconducting components for magnetic confinement fusion reactors.

With its ability to support high-intensity magnetic fields and precise temperature management, the device is an essential step toward the realization of the China Fusion Engineering Test Reactor (CFETR).

The specialized equipment will underpin the next phase of design, emulation and testing in superconducting components. The newly developed platform will assess the capabilities of materials and designs to test their suitability for the extreme conditions of nuclear fusion.

The device’s groundbreaking architecture includes over 800 engineering and experimental signal channels. It’s anticipated that data will be collected from two 60-day cycles each year.

Researchers will be able to access these data sets reliably in real-time, manage emulations, and assess novel design architecture. By leveraging SciChart, they’ll be able to run comparative analyses with previous data and develop new visualizations, all without slowdown.

About SciChart: SciChart is the world’s fastest, precision data visualization software, used by top global companies in sectors ranging from healthcare, signal processing and engineering to aerospace and scientific research. Offering cross-platform compatibility, precision rendering, and unparalleled performance, SciChart is trusted for applications that demand speed and accuracy in real-time data analysis. SciChart is found everywhere, from the F1 racetrack to NASA mission command centers and pioneering research.

What is Signal Processing?

Signal processing is the discipline of capturing, analyzing, and manipulating signals—such as electrical, optical, or acoustic waveforms—that represent varying physical phenomena. It involves techniques like filtering, digitization, and frequency analysis to extract meaningful information from raw data in real-time.

In engineering and scientific applications, signal processing enables accurate monitoring, control, and interpretation of system behavior, especially in environments requiring high-speed, high-fidelity data analysis.

Signal Processing in the Super-X Device

China’s Super-X device is a critical platform for high-precision signal processing in the evaluation of superconducting technologies for future fusion reactors. It enables real-time acquisition and analysis of complex data from numerous engineering and experimental sensors, ensuring accurate, reliable measurements.

Key stages include:

• Acquisition: Capturing data from over 800 channels, including temperature, pressure, current, and quench voltages.
• Filtering: Reducing noise to preserve signal integrity and ensure data accuracy.
• Transmission: Leveraging ZeroMQ middleware with a multi-threaded pub/sub model for high-speed, lossless data transfer.
• Storage: Combining Elasticsearch for fast, short-term queries with PostgreSQL for long-term, scalable data archival.
• Visualization: Real-time display via SciChart, supporting continuous monitoring and rapid diagnostics.
• Analysis: Interpreting processed signals to evaluate superconducting performance and inform experimental design through customized visual interfaces.

The Super-X device’s advanced signal processing capabilities support both real-time monitoring and long-term research, advancing China’s efforts in practical nuclear fusion development.

Challenges in Signal Processing and Fusion Research Met by SciChart

Due to their custom requirements and intense performance and accuracy needs, signal processing faces significant challenges in data visualization.

Below is a summary of the issues faced by the fusion research team, many of which are also faced by MedTech research and development teams:

1. High-Speed, High-Volume Data:
   Super-X handles over 800 distinct signals, many sampled at high frequencies. Managing this data without loss or latency is critical but technically challenging.
2. Signal Diversity and Noise:
   Signals vary widely, from slowly evolving engineering data (e.g., temperature) to rapid changes (e.g., quench detection voltages). Differentiating useful signals from noise requires precision.
3. Scalability and Flexibility:
   The need for customizable setups to accommodate evolving experiments, especially in superconducting conductor research, complicates system design and data processing.
4. Real-Time Requirements:
   Immediate visualization of data is essential for live adjustments and decision-making during experiments—a highly complex field with rapidly adjusting magnetic fields in live fusion reactions.
5. Data Storage and Retrieval:
   Efficiently handling short-term and long-term data storage while maintaining accessibility for analysis.

How SciChart Solves These Problems:

• Unmatched Performance: SciChart’s hardware-accelerated graphics engine ensures real-time, high-speed rendering of complex datasets without compromising accuracy.
• Flexibility and Adaptability: Customizable visualization solutions cater to diverse signal types and experimental setups, providing seamless integration with Super-X’s systems.
• Noise Filtering and Precision: Advanced algorithms ensure clean, reliable signal representation, crucial for analyzing superconducting performance.
• Scalable Solutions: SciChart supports dynamic scaling, meeting the needs of high-volume, high-frequency data acquisition without lag or loss across desktop on WPF, JavaScript for web and remote viewing and now Linux through our Avalonia XPF partnership.
• Efficient Data Handling: With optimized rendering pipelines, SciChart ensures rapid visualization of historical data for analysis while supporting real-time display.

When to Choose SciChart Over Generic Chart Libraries

SciChart excels where generic tools like MathWorks Simulink or non-specialised charting libraries fall short. This is particularly noticeable for high-performance, specialized signal processing applications where advanced scientific research, real-time monitoring, and large-scale data analysis are required.

Unlike generic chart libraries, SciChart offers:

• Tailored Performance: Optimized for high-frequency, high-volume data streams without compromising speed or accuracy—up to 1 billion data points can be reliably rendered in real-time.
• Real-Time Visualization: Outperforms generic scopes by rendering live data with zero lag, essential for dynamic experiments and rapid decision-making.
• Customizability: Provides unparalleled flexibility to adapt to unique project requirements, integrating seamlessly with specialized systems like the Super-X device.
• Scalability: Supports scaling from small-scale tests to large, multi-node experiments with complex signal diversity.
• Advanced Features: Offers enhanced filtering, multi-series analysis, and interactive tools not typically available in standard toolkits.

Signal Processing Data Visualization for Design, Test and Emulation

Whether you’re looking for signal processing or design, emulation and test software solutions, SciChart enables our clients to create custom, cutting-edge solutions pushing the boundaries of research and development.

Our high-performance rendering engine, designed with novel requirements and research in mind, can help you bring your next project to life on anything from mobile devices, to embedded hardware or remotely accessible browsers.

SciChart is the only precision 64-bit library built for data accuracy and integrity available on WPF, JavaScript, iOS, Android and MacOS with support for Linux.

Discover Design, Test & Emulation Software Solutions

The post Announcement: SciChart Selected for Pioneering Nuclear Fusion Project by Chinese Government appeared first on SciChart.