RSS Feed
Comparison of SciChart vs. Open Source Chart controls
Posted by Andrew on 13 March 2019 09:00 AM

At SciChart we are big fans of open source! We use open source in some of our chart controls, such as SharpDX (a managed wrapper around DirectX), Rene Schulte’s brilliant WriteableBitmapEx (for line drawing in WPF), WordPress/PhP on the website and more. We’ve even written some open source components such as the popular, free WPF Transitionz library. So, we don’t want to disparage the hard work of any open source chart component developers.

However, we do often get asked the questions ‘is your software free?’ and ‘why should I buy SciChart vs. using a free open source chart component?’

In this article we compare our software vs. a few popular free WPF, iOS & Android chart libraries and present reasons & benefits when it may be better to choose SciChart over open source, free charts for your WPF, iOS, Android & Xamarin applications.

Reason #1: Enterprise Tech Support

This first reason almost goes without saying. One of the biggest value-adds of using a commercial WPF, iOS or Android chart control is the insurance of knowing you have Enterprise technical support. If charts are mission critical to your project, and resolving any issues, should they occur, is important to you, it’s a very strong reason to consider a commercial chart control such as SciChart.

The following table shows the reported open issues on four major open source chart projects: OxyPlot (WPF Charts), LiveCharts (WPF Charts), MPAndroidChart (Android Charts) and Charts (iOS). New questions are asked every day on the github repositories for these libraries, and many are unanswered.

Open source project Number of open issues
OxyPlot (WPF Charts) 404 open issues
LiveCharts (WPF Charts) 316 open issues
MPAndroidChart (Android Charts) 1345 open issues
Charts (iOS Charts) 374 open issues
SciChart (WPF, iOS, Android, Xamarin Charts) Over 7,500 support incidents resolved.

Table 1: Open issues on popular open source chart components

We’re not surprised! One twitter influencer described the flood of open source help requests as ‘the fire-hose of open source’: When your open source chart library becomes popular you will be flooded with requests from users asking for help, demanding bug fixes and features, and it can quickly become unsustainable to handle them. So, the open source developers (some of whom have done a great job writing software!) quite rightly stop answering. Even we find it hard work sometimes to answer as many support requests as we do: over 7,500 requests for help, technical support or forum questions to date, and its our job! I can’t imagine having to do this level of work in spare time.

Figure 1: Issues outstanding on the MPAndroidChart open source chart library

What this means for you is, if you use an open source chart control in your business-critical project and one day you need help, and stackoverflow or the community is unable to provide it, you will be stuck… This could cost your business time and money if your application development is delayed if your productivity is affected while trying to find a solution.

SciChart’s 5-star rated Enterprise tech support is an insurance policy against problems you might encounter during your project. Our tech support is not meant to be a replacement for google, or research, but if WPF, iOS, Android or Xamarin charts in your project are mission critical to your business, at some point you may encounter a problem or issue that needs our team to help you. This can save you time and money to get back to what you are supposed to do: developing your application.

Reason #2: Ease of Use & Productivity

Technical support isn’t the only reason to choose SciChart vs. an open source chart component. We think you’ll find that if an API or library is productive and easy to use, it can lead to bigger cost saving than those provided by tech support.

  • Consider how much is your time worth per hour or per day?
  • How much time might you save in a year of using SciChart vs. an open source chart?

Think about the time to get started, learn the API, to find information you need on the web. If you have a requirement that is not simple, you might need to do some research to find the answers. With SciChart, you won’t need to save much time for the license to pay for itself entirely.


  • Cost of developer time: $60 / hour ($480 per day)
  • Cost of SciChart License: approx ~$1100 for SciChart WPF 2D Professional
  • Only 2.3 developer days need to be saved in a year before SciChart pays for itself.

It’s quite reasonable to assume you might save an hour per week when using SciChart vs. an Open Source chart component. More if your project is chart heavy. An hour per week adds up to 48 working hours per year, or 5 days of developer time: much more than the cost of the license.

One of our customers left us a great review, which said this:

We wrestled with a few free chart alternatives for several weeks; but after trying SciChart, we realized that we'd ultimately save money and ship our software faster by investing in such an easy-to-use library

This is really an incredible review and we’re grateful, but did you notice that the author spent several weeks evaluating free alternatives to SciChart? Free software can come with a cost of your time, and although SciChart is a commercial control meaning initial cost to your team, the care and attention that has gone into the API, examples, documentation and online help resources such as tutorials and forums will lead to faster development of the application & cost savings in the long run.

Reason #3: Developer activity & Speed of Bug Fixes

This reason is closely linked to #1. We have noticed that the development activity of many of the popular open source chart controls has declined over time, however, the demand for features and improvements has increased with their popularity.

Github activity for OxyPlot, an open source WPF Chart control

Github Activity for MPAndroidChart, open source Android charts

Github activity for LiveCharts Open Source WPF Chart control

Github activity for Charts, an Open Source iOS Chart control

Above you can see the Github activity of the four main open source chart components.

Below you can see our github activity. In contrast to the open source projects listed above, our development activity has increased; actually in the past two years it has really heated up since every day at SciChart we get new feature requests and demand for more improvements, better performance, compatibility with a new framework etc…

Github activity for SciChart, our enterprise WPF, iOS & Android Chart control

Figure 2: Development Activity on the SciChart Github repository

SciChart started as a project in 2012 and seven years later, we now have 14 developers now working full time on our WPF, iOS & Android charts. I cannot tell you how surprised I am (probably more surprised than you!) that charts (just X,Y values … on a screen … ) would take decades of effort…

So what does this mean for you?

If a new .NET Framework is released (Windows), new version of XCode, iOS, or Swift, a new Android SDK or Xamarin SDK is released then both commercial and open source charts have to be updated to be compatible. Sometimes a new device comes along and an application doesn’t work. Sometimes a critical bug occurs since an operating system or framework update and the chart component has to be fixed.

There is a risk you take when using any free open source or commercial chart control that the developer ceases to update their software, however, with SciChart that risk is minimized since our developer activity and popularity has been increasing over time.

When bugs are reported in our WPF Charts, iOS & Android Charts or Xamarin Charts we will aim to fix the serious ones as fast as possible, because they directly affect our customers, and therefore us!

That’s why we are charge a fee for what we do – we love free software and we think the open source chart developers do a great job, but in order to provide excellent software to you that is always up to date, fixed fast when there’s a problem and incorporating the latest features that you ask for then we must charge. We aren’t perfect, but this is our job and our livelihood and we have a strong incentive to work hard for you so that your projects are a success, plus, a good reputation to maintain!

Reason #4: Depth of Features

At SciChart, we only focus on charts. As a result, we strive to create a depth of features beyond when open source chart components are able to achieve and even beyond what many commercial vendors do too!

Take a look at the features matrix below to see what features SciChart can bring which open source components do not.

Feature SciChart MPAndroidChart iOS-Charts OxyPlot LiveCharts
2D Plots  
3D Plots  

Active, searchable forums  

Animation of Data  

Annotations on Chart  


Custom Series  

Custom Zoom or Pan behaviours  

Export / Print  

Fully Documented  

Hardware Acceleration  

High Performance & Realtime  

Link Multiple Charts  

Legend Customization  

Logarithmic Axis  

Multiple X-Axis  

Multiple Y-Axis  

Per-point colouring  

Programmatically Change Viewport  
Technical Support  

Theme or template customization  

Touch Interaction  
Zoom and Pan  

Table 2: Feature comparison of SciChart vs. popular Open Source Chart components such as OxyPlot (WPF), LiveCharts (WPF), MPAndroidChart (Android) and Charts (iOS). *3D Support coming soon to Mobile


  • Means the feature is supported by the open source chart
  • Means the feature is not supported by the open source chart
  • Means there is limited support (requires workaround, or limited compared to SciChart)

The open source charts are in many cases, good enough for simple applications. If you want to just add a few low point-count 2D charts to your application, they can do the job. However, it’s the depth of features where SciChart really shines.

More on this below …

Reason #5: Flexibility

Most open source or commercial chart controls for WPF, iOS, Android provide the following standard features:

  • Many chart types (e.g. Line Charts, Scatter charts, Column Charts, Pie Charts)
  • Axis types (e.g. Date Axis, Time Axis, Numeric Axis)
  • Basic customisation features (e.g. TextFormatting, Themeing)
  • Inspection support (e.g. Tooltips, Legends)
  • Built-in zooming and panning

It would be easy to compare two chart libraries and see that they all support the above features and conclude ‘They’re the same’. Far from it.

With SciChart, you will find our API allows for complex customization is possible on nearly everything, and if we can’t support something, we will give a workaround, or, accept a feature-request for future development.

Here’s a selection of some of the deep features that SciChart supports which allow greater flexibility when creating charting applications for business.

  1. Series Selection
  2. Data-point Selection
  3. Axis label programmatic string-formatting
  4. Overriding of Axis gridline, label frequency
  5. Custom UIElement or UIView annotations and markers
  6. Per point colouring
  7. Custom interaction behaviours such as custom zooming, panning
  8. Custom Series
  9. Vertical charts
  10. Vertically Stacked Axis
  11. Central Axis
  12. Programmatically change zoom or pan
  13. Undo Redo of zoom
  14. Add Trendlines, best-fit curves, moving averages and splines
  15. Scrollbars on X,Y axis with preview of the chart behind

Its really hard to get these hidden features which provide excellent flexibility of our chart controls into a short list! These are just some of the flexibility options that SciChart has that open source chart controls and even commercial chart vendors do not have. Deeper features and more flexibility means you can get more complex requirements done quickly, which adds up to big cost savings over time, and ROI for your team.

Watch the video below to learn about 15 hidden features in our WPF Chart component to find out more:

Reason #6: Chart Performance

There are plenty of reasons why to choose and consider SciChart even if your application only needs to show modest dataset sizes. However, some of our users have very demanding performance requirements, and SciChart is capable of drawing many millions of points, update charts in realtime and with a low memory and CPU footprint on all the platforms that we support (iOS, Android, Windows/WPF).

We have created the fastest iOS charts & Android charts in the world (by a long way!), and one of the fastest, high-performance charts for WPF and Windows applications. Our charts are based on a hardware-accelerated rendering engine using DirectX (Windows), OpenGL ES (Android) and Metal (iOS) so that you get the fastest charting possible in your applications.

What does this mean to you? It means that SciChart makes impossible projects, possible.

We compared the performance of SciChart vs. some well known open source chart components, and discovered that our iOS & Android charts performed an order of magnitude faster than open source libraries (See iOS Chart Benchmarks and Android Chart Benchmarks). This means more data can be shown in your apps and previously impossible app ideas can now be realised. Our WPF Charts are also similarly fast compared to open source WPF charts. We are also working continually to make better gains in this area of performance and ensure that our charts are smooth and realtime in your applications.

When to choose SciChart vs. Open Source?

So given all of the above, when should you choose SciChart vs. an Open Source Chart component? There are some good arguments above, but you will find some more in the article seven reasons not to use Open Source. Some which are cited include:

  1. When proprietary software is easier to use
  2. When proprietary software offers technical support
  3. When proprietary software works better with your hardware
  4. When you need a vendor to stick around

In the article Open Source: What they’re not telling you there is further discussion to decide when to choose open source vs. a proprietary vendor.

In conclusion: when the requirement complexity is large, or the application is business critical, when features or performance matters and you need a component which is actively developed, you should definitely consider choosing SciChart for the charts in your enterprise applications!

SciChart vs. Open Source ROI Calculations

We’ve created some simple ROI calculations below to help you get an idea of the return on investment when purchasing SciChart. Some assumptions are made and no calculator is perfect!

If you consider the number of developers on your team, and the developer rate, you can get an idea of cost for your team’s time.

Next, estimate the time saved per developer per month. For example, conservatively estimating 1-hour a week saved from productivity, you might arrive at a figure of 4-hours per month. The actual figure could be higher in applications which are charting-heavy.

Finally, estimate the number of support incidents per year. Support incidents which are serious are rare, perhaps you will only get one or two a year, but each one might block your team for a long time if not resolved. So for example, estimate 2 days per year, but 16 hours of time lost per incident.

The calculator will output the return on investment for your purchase.

These are the results:

Number of developers on team 5
Developer rate / hour $60.00
Time saved (general productivity) per dev per month 4 hours
Time saved (general productivity) entire team per year 240 hours
Cost saved getting started / finding information / Year $14,400.00
Number of critical support incidents / year 2
Time saved for each critical support incident 16 hours
Cost saved for critical support incidents $1,920.00
Number of minor support incidents / year 10
Time saved for each minor support incident 4 hours
Cost saved for minor support incidents $2,400.00
Single SciChart License Cost $1099
Multi-Purchase Discount 30.00%
Cost of 5x SciChart Licenses for your team -$3,846.50
Total productivity costs saved $18,720.00
ROI ($) $14,873.50
ROI (%) 387%

Table 3: Estimated cost savings for a 5-developer team using SciChart

Of course, cost savings depend on many factors and the above doesn’t include the time you will spend learning the SciChart API, however we believe it will be quicker to learn SciChart than an alternative charting API.

Download the ROI Calculator here as an Excel Spreadsheet if you want to play around with the numbers. We have included both single-developer licensing costs vs. ROI as well as site-license costs vs. ROI.

SciChart licensing costs decrease over time

Please note, SciChart is licensed as a perpetual license with royalty free redistribution rights (see Licensing FAQ) and a support and updates subscription. The subscription is not mandatory after 1-year – you can still use SciChart after the support subscription ends, but you won’t be ale to access technical support or updates / bug fixes to the chart (see Renewals FAQ).

Our costs decrease over time as a 2nd year renewal of a support subscription costs just 50% of the 1st year. Your ROI for year two may be even greater.

Finally, you can, if you want, purchase the source-code to SciChart. If you want to modify it, then you have one of the main benefits of open source: ability to inspect, modify and develop the source-code of the chart control.

Best regards,
[SciChart Team]

About SciChart: High Performance Realtime Charts.

SciChart provides high performance realtime chart components on the WPF (Windows), iOS, Android and Xamarin platforms. It is our goal to create the best cross-platform WPF, iOS & Android 2D & 3D charts in the world, focusing on performance, developer productivity, ease of use, depth of features and enterprise-grade tech support.

If you have a question about what SciChart can offer you, or if you would like to get a quote, please contact us. Our friendly, helpful support team will be glad to help!


The post Comparison of SciChart vs. Open Source Chart controls appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.

Read more »

The Best WPF Chart! SciChart Seventh Anniversary
Posted by Andrew on 06 March 2019 09:53 AM

It’s hard to believe, but this month in March 2019, SciChart WPF is 7 years old!

Version 1.0 of SciChart WPF was coded in a spare room, first released in March 2012, and was the first WPF Chart control in the world to incorporate fast, immediate-mode drawing (bitmaps) into XAML based WPF Chart controls. This literally changed the market & made previously impossible projects become possible, because at the time existing WPF charts were not able to draw large datasets, or update fast or in realtime.

A performance comparison published in 2012 by Scott Logic showed how far SciChart and one other competitor at the time (Visiblox, now discontinued) outpaced the market in terms of chart performance: both competing for the title of ‘fastest WPF Chart’ with high drawing speed and efficient memory usage.

Fast forward to 2019, SciChart is now a feature-rich, XAML/MVVM capable WPF Chart control, capable of drawing many millions of points in realtime, with dynamically updating charts, and used by thousands of developers worldwide.

Our users consistently rate us 5-stars and report that they believe we provide the Best WPF Chart control on the market.

So, for our seventh anniversary we would love to share with you: reasons why SciChart makes the Best WPF Charts.

Please read more at the article below!

Read: Why SciChart, the Best WPF Chart

Finally, a huge thank you to our customers for making SciChart what it is today! We wouldn’t have done it without your feedback, trust in our company and support.

Best regards,
[SciChart Team]

The post The Best WPF Chart! SciChart Seventh Anniversary appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.

Read more »

SciChart WPF v5.3 Released
Posted by Julia Skorobogata on 20 February 2019 12:32 AM

We are pleased to announce the release of SciChart WPF v5.3, build 11899 . This is a minor update which includes a number of bug fixes, improvements, and new features. It is strongly advised for users of SciChart v5.x to upgrade to this version, which is a drop-in replacement. 

What’s New in SciChart WPF v5.3?

New features

WPF Chart Animation Functions

SciChart’s WPF Chart now features a new WPF Chart Animation API. Animated WPF charts will make your applications more appealing to you and your customers.

There are four standard animation types introduced in SciChart WPF:

  1. Fade Animation
  2. Wave Animation
  3. Sweep Animation
  4. Scale Animation

Animations have been included in several of our WPF Chart Examples. You may see them in the video below.

SciChart’s WPF Chart Animations API is made flexible so that you can control when an animation starts and stops, the animation start delay and animation duration. There are also several predefined EasingFunctions available in WPF, that would allow to further adjust the animation behaviour.

For more information, please have a look at WPF Chart Animations Documentation.

Polar Chart Rotation:

This is a new feature added to the polar chart, which will allow you to set the rotation of the Xaxis so that the zero is at any angle. This often requested feature will allow you to have polar Charts with the 0,360 degree mark at the top of the chart.

Show tooltips as popup option:

If you have lots of charts on the screen, or a small chart size, it was often reported that the tooltips would be clipped at the edge of the chart. With this new feature, you will be able to place a tooltip in a WPF popup, which will allow the tooltip to behave more like a standard WPF tooltip.

To enable tooltips to show up as popups just use the property: RolloverModifier/CursorModifier/TooltipModifier.TooltipUsageMode=”TooltipControl, Popup”.

For more information, please have a look at Popups vs. Canvas for WPF Chart Tooltips Documentation.

An ON/OFF option to show tick labels only on chosen planes in 3D Charts: 

You may now choose which planes would be showing the tick labels in the WPF 3D charts. For examples by setting the following properties on the SciChart3DSurfcae:

<s3D:SciChart3DSurface s3D:XyAxisPlane.DrawLabelsMode="AxisPlaneDrawLabelsBoth"

For more information, please see the documentation for Showing Axis Labels on one side of the 3D Chart.

Bug Fixes 

Almost 50 bugs and minor issues have been addressed in v5.3 since the last stable release. Bug fixes are shipped first in our nightly builds and are bundled up and tested for stable releases.

  1. Fixed the issue with scrolling when DiscontinuousAxis is used
  2. Fixed Static axes with changed Minor\Major delta takes no effect and no re-drawing.
  3. Fixed SC-4747 BorderThickness and BorderBrush missed when export with clone
  4. Fixed the issue when a Scrollbar would jitter if the track dragged when stuck at either end of the scroll area
  5. Removed TypeMarkupExtension and FasterRandom has been moved to SciChart.ExternalDependencies. This removes all CPOL code from the commercial SciChart library
  6. Removed class LayoutTransformer due to CPOL Open Source license objection by one of our customers. Have used default WPF ‘LayoutTransform’ instead
  7. Removed s:Static markup extension (CPOL) Open Source license objection by one of our customers. Have used default WPF x:Static instead
  8. Changed DataContext of child annotations in TradeAnnotations
  9. Fixed annotations not exported when VerticalSliceModifier added
  10. Fixed SC-4759 where VerticalLineAnnotation with String LabelValue would throw with a TimeSpanAxis
  11. Fixed SC-4758 duplicate AnnotationLabels when removing and then add same annotation instance in MVVM
  12. Fixed Directx 2D Bubbles when they are big, refactor to use just one TEX Coords
  13. Fixed broken touch for ZoomPan, DragAxisModifier, HeatmapColormap drag CustomModifiers derived ChartModifierBase.
  14. Fixed the DirectX Bubbles quality issue
  15. Fixed missed Axis properties not exported due to custom bindings.
  16. RotationAngle property added to PolarXAxis
  17. Fixed SC-4766 issue when resampling didn’t consider whether the chart is vertical the or not when reducing points
  18. Added missing properties (MaxBubbleSizeInPixels and ApplyAreaSizingInsteadOfRadius) to BubbleRenderableSeriesViewModel
  19. Fixed wrong XRange calculation inside StackedColumnsWrapper
  20. Fixed the issue in MouseManager to make events propagated to Master first
  21. Fixed for ZoomExtents when CategoryAxis and one RenderableSeries is hidden
  22. Added scaling functionality for Major\Minor Grid\Tick lines of an axes
  23. Fixed Grid and Tick lines of axes not scaled after Export
  24. Fixed PointMarkers not scaled after Export
  25. Added quick fix for SC-4775 crash in ExtremeResamplers with FifoBuffer;
  26. Fixed ZoomPanModifier not worked without PinchZoomModifier enabled with touch;
  27. Fixed AxisDrag modifiers not working without PinchZoomModifier or ZoomPanModifier with touch;
  28. Fixed HeatmapColorMap dragging not worked with touch;
  29. Fixed VerticalSliceModifier
  30. Made BaseRenderableSeries.DrawLines method virtual and protected
  31. Fixed SC-4770 TimeSpanLabelProvider throws with ‘Input string was not in the correct format’
  32. Fixed shader compile error
  33. Fixed for 1 px lines,
  34. Fixed SC-4782 StackedColumns shrinking when one series is hidden
  35. Added an option to ON/OFF presenting tick labels on the single side of an Axis 3D
  36. Fixed ChartTitleStyle for SciChartSurfaceBase.Export
  37. Fixed SC-4783 issue when changing Opacity on a series wouldn’t have any impact on filled series
  38. Changed the template of SciChartSurface so that ChartTitleStyle can be used to style a title
  39. Made UpdatePosition method virtual in AnnotationBase
  40. Fixed SC-4800 issue when hit-test would work incorrectly before gaps with DiscontinuousAxis
  41. Added Popup mode for Modifier Tooltips
  42. Added OnAttached, OnDetached methods to IRenderableSeries;
  43. Removed reference on Charting.DrawingTools.dll from ExternalDependencies
  44. Fixed SC-4741 issue with blinking and redrawing modifier popups
  45. Fixed SC-4809 AxesCollection memory leak (MVVM)
  46. Fixed SC-4803 CategoryAxis regression – Rollover works incorrectly when interpolated
  47. Fixed Selected PointMarkers for ExtremeRenderableSeries

Where to Get SciChart WPF v5.3?

SciChart WPF v5.3 is available from:

Please ensure you uninstall the previous version(s) of SciChart before installing v5.3 as this can prevent some issues in the upgrade process!



Best regards,
SciChart team

The post SciChart WPF v5.3 Released appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.

Read more »


Recently one of our customers has given us to post a case-study about SciChart in their application. This is now viewable at our page. Thank you to the customer! We love working with you! – SciChart Team

Customer Case Study – Quantitative Trading Application

“In the past we experienced a lot of pain with other third party chart controls, which failed to deliver over time”

“SciChart looks to be a great product, and has proven to us that a general-purpose chart control can be used within a specific scenario to create high performance, big data analytics applications.”

SciChart has recently carried out a licensing + consultancy project alongside a customer, a highly successful Quantitative Trading firm and global private investor. The Client’s focus is on technology and financial sector opportunities. Leveraging the unique understanding of risk management, they utilize complex quantitative research methods and leading-edge technology to develop world-class trading strategies.

The Client had a need for a powerful, general-purpose charting control, which any of the client’s application in the Windows environment should be able to use. In addition, there was a need for an application that will allow visualization of key trading related metrics using charts.

SciChart has provided our turnkey WPF Chart Software as well as developer hours as part of a licensing & consultancy deal, spanning more than a year and currently ongoing.

Read the full PDF below to find out more about how SciChart can be used in Quantitative Finance & Big Data applications, as well as the features achieved by our best-in-class WPF charts.

Read more in full PDF

Find out more

If you have a requirement for a charting application, and would like to hire our world class consultants, or, if you would like more information about our turnkey WPF, iOS or Android Chart components, please get in touch by contacting Sales.

Contact Us

The post New Customer Case Study – Quantitative Trading Data Mining application in WPF appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.

Read more »

SciChart WPF v5.2.1.11757 Released
Posted by Andrew on 24 November 2018 03:04 PM

We are pleased to announce the release of SciChart v5.2.1. Build 11757 . This is maintenance version which includes a number of  bug fixes and improvements. It is strongly advised for users of SciChart v5.x to upgrade to this version, which is a drop-in replacement. 

What’s New in SciChart WPF v5.2.1?

Bug Fixes and Improvements
  • SC-4730 Fixes SciChart WPF Licensing Wizard not found in Start menu after installation
  • SC-4742 AccessViolationException in WriteableBitmapExtensions.FillRectangle
  • SC-4740 Heatmap crash with export and colormap defined inside of series
  • SC-4738 Huge font for superscript axis labels for certain regions
  • SC-4736 SciChart.ExternalDependencies resources don’t work from NuGet
  • SC-4721 When AxisBinding MVVM API used, and HorizontalGroupHelper.HorizontalGroup, XAxis is blank
  • SC-4687 Rarely broken bindings due to ElementName bindings
  • SC-4728 ExportToStream ignores size parameter,
  • SC-4724 Add handling of SetBasePoint nullreference exception
  • SC-4725 Fixed Fix SetBasePoint for DrawingTools
  • SC-4654 Fixed DrawingTools: PitchFork fill outside the annotation
  • SC-4653 Fixed DrawingTools: PitchFork disappearing fill
  • SC-4652 Fixed DrawingTools: Head & Shoulders disappearing fill
  • SC-4663 Fixed DrawingTools: FreeDraw – quite hard to hit-test for dragging
  • SC-4678 Fixed FreeDraw DrawingTool – cannot delete or change it when selected second ime
  • SC-4661 DrawingTools: add FontSize to PaletteControl for Fibonacci annotations
  • SC-4680 Contours With Heatmap – tooltip always report ZValue as NaN
  • SC-4658 DrawingTools: hit-test should work when clicked on a filled area of an annotation
  • SC-4668 Realtime Waterfall 3D crash
  • SC-4677 Fixed CursorModifier SnappingMode stopped working
  • SC-4060 Application crash after multiple load & export
  • SC-4607 always pass in texture width and height of sprites, wo when sampling the offsets are taken properly
  • Fixed the issue when RenderableSeries.GetXRange() would throw if the DataSeries wasn’t assigned
  • SC3D-481 ColumnRenderableSeries3D won’t draw if PointMetadata is not provided and XyzDataSeries3D used
  • SC3D-480 PointLineRenderableSeries3D line color does not respond to PaletteProvider
  • SC3D-479 Camera3D properties have DependencyProperty Precidence issue and cannot be bound when SciChart3DSurface inside a control template
  • SC3D-478 When Theme Changes series are sometimes removed in SciChart 3D
  • Fixed incorrect 3D text rendering, where string contains characters from different Unicode pages
  • Added ContextMenu binding from internal annotations to DrawingTools annotations
  • VHN-744-33548 Fixes PointLine 3D line color
  • Made the GetIndicesRange method virtual
  • In WaterfallSceneEntity switched coordinates calculation from float type to double, to increase a precision
  • [SVW-595-49808] Error in Gradient Fill Direction Along Y Axis
  • [QTL-387-74220] 3D charts with DateTime Z axis issues
  • Fixed the issue when an OHLC data series has all data points as NaNs and AutoRange would not work correctly for all other series
  • Improved SciScrollBar when with DiscontinuousAxis
  • Added missing XML comments on AnnotationCreationModifierForMVVM
  • Fixes binding errors in DefaultAxisTitle in some systems which use SciChart with MVVM API. Improves performance of SeriesBinding MVVM API
  • Added MVVM Series Performance Test to TestSuite
  • [VTL-700-11872] Assertion Failed – Matrix Stack overflow
  • [SKX-960-39374] Waterfall _heightsTexture wasn’t recreating on data series dimensions change
  • Avoided using ElementName in data binding that causes some issues in the Simple Waterfall Example (known WPF bug)

Where to Get SciChart WPF v5.2.1?

SciChart WPF v5.2.1 is available from:

Please ensure you uninstall the previous version(s) of SciChart before installing v5.2.1 as this can prevent some issues in the upgrade process!



Best regards,
SciChart team

The post SciChart WPF v5.2.1.11757 Released appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.

Read more »


A while ago we announced we had open sourced the small but useful WPF Transitionz library for Metro Style Animation effects in WPF applications. To our surprise this now has over 5,000 downloads on and even received a couple of questions & bug reports via the Github repository!

We’re using the four libraries in SciChart.Wpf.Ui in our SciChart WPF Examples Suite, and also starting to use them in consultancy projects, so we’ve updated them for 2018 to be compatible with .NET Standard 2.0 and .NET 4.6.1, plus fixed a number of bugs & added other improvements.

What’s in SciChart.Wpf.UI ?

So what’s in this mysterious collection of open source libraries? A quick run-down below.


Supporting .NET Standard 2.0 / .NET Framework 4.6.1 and above, this library includes bootstrapper classes for WPF Applications using Unity and allowing automatic dependency discovery across a range of assemblies.

See the Bootstrap Library Overview page at SciChart.Wpf.UI.

To use it,

  1. Decorate your types with the [ExportType] attribute
    	public interface IFoo
    	// This type is automatically registered with the Unity Container
    	// Every time IFoo is resolved, you get a new instance
    	public class Foo : IFoo
    		// Any other registered dependency can go in the constructor
    		public Foo(IUnityContainer container)
  2. Create a Bootstrapper and initialize public partial class App : Application
        public partial class App : Application
            private AbtBootstrapper _bootstrapper;
            public App()
                _bootstrapper = new AbtBootstrapper(new UnityContainer(), new AttributedTypeDiscoveryService(new AutoAssemblyDiscovery()));
                 // At this point, your container now contains all the types decorated with [ExportType] attribute
                 // You may resolve them as normal in Unity 
  3. Now your application has UnityContainer powered dependency injection in just a few lines of code!



The SciChart.UI.Reactive library supports .NET Standard 2.0 / .NET Framework 4.6.1 and above provides observable viewmodels which combine INotifyPropertyChanged event notifications for WPF, and Reactive IObservable streams for observing individual, or combinations of properties.

See Reactive Library Overview and Reactive Library WhenPropertyChanged wiki pages.

The main benefit of this library is that it brings the incredible power of Reactive Extensions to MVVM in WPF applications. You declare a class like this:

public class WhenPropertyChangedTests : ObservableObjectBase
    public string SearchText
        get => GetDynamicValue();
        set => SetDynamicValue(value);

    public SearchOptions SearchOptions
        get => GetDynamicValue();
        set => SetDynamicValue(value);

and now any of these properties raise both PropertyChanged events as well as a reactive stream (IObservable<T>). You also don’t have to create a backing field making all your properties, these are stored in the base class (ObservableObjectBase) in a dictionary.

Properties may now be observed using Reactive Extensions as follows:

void Foo()
	// Create the ViewModel
	WhenPropertyChangedTests vm = new WhenPropertyChangedTests();

	// Observe properties
	var observable1 = vm.WhenPropertyChanged(x => x.SearchText);
	var observable2 = vm.WhenPropertyChanged(x => x.SearchOptions);

	// Subscribe 
	var disposable = observable1.Subscribe(t => Console.WriteLine($"Search Text = '{t}'"));

	// Set properties 
	vm.SearchText = "Hello"; // -> Should output 'Search Text = 'Hello'' to console
	vm.SearchText = "World"; // -> Should output 'Search Text = 'World'' to console


	vm.SearchText = "Not observed"; // nothing happens 

and multiple properties may be observed using Observable.CombineLatest

void Foo()
    // Create the ViewModel
    WhenPropertyChangedTests vm = new WhenPropertyChangedTests();

    // Observe properties
    var observable1 = vm.WhenPropertyChanged(x => x.SearchText);
    var observable2 = vm.WhenPropertyChanged(x => x.SearchOptions);

    // Subscribe 
    var disposable = Observable.CombineLatest(observable1, observable2, Tuple.Create)
        .Subscribe(t => Console.WriteLine($"Search Text = '{t.Item1}', Options = '{t.Item2}'"));

    // Set properties 

    // -> Should output 'Search Text = 'Hello', Options = 'AnOption'' to console
    vm.SearchText = "Hello";
    // -> Should output 'Search Text = 'Hello', Options = 'AnotherOption'' to console 
    vm.SearchOptions = SearchOptions.AnotherOption;
    // -> Should output 'Search Text = 'World', Options = 'AnotherOption'' to console
    vm.SearchText = "World";


    vm.SearchText = "Not observed"; // nothing happens 

If you haven’t checked out Reactive Extensions yet and seen what it can do for your WPF applications, or even server-side applications, then do so. It’s brilliant!

Learning resources:


The Transitionz library seems pretty popular with WPF developers as it provides a very simple way to animate elements on the UI with just Xaml attached properties.

Transitionz supports WPF / .NET 4.6.1 and above and allows the following effects in your application:

  1. Fade / Animate Opacity
  2. Translate / Animate position
  3. Scale / Animate size
  4. Blur / Animate blur factor

All Transitionz animations may be triggered on:

  1. On Visibility (e.g. Animate opacity on visibility changed)
  2. On DataContextChanged (e.g. trigger an animation when new DataContext attached)
  3. On Loaded (e.g. when the control.Loaded event fires)
  4. or .. Once (e.g. consider OnLoaded will fire each time the control is loaded, wheareas once ensures just one-time operation)
  5. Explicity, by binding to or setting Transition Params

Head over to the Transitionz Library wiki page for more information. We also have a small test-app bundled with SciChart.WPF.UI which demonstrates this functionality.

Transitionz WPF Animation Library



The SciChart.Wpf.UI assembly supports WPF / .NET 4.6.1 and above, and brings a number of useful controls to WPF applications, and metro styles based on MahApps.Metro. Controls include:

  • BusyPanelA panel which displays a spinner / hides content while BusyMessage is not null, shows the content when BusyMessage is null.
  • PopupHostA control to host popups which can be shown inside a WPF app with animated show & hide. The background can be blurred out or made darker, similar to a web popup.
  • WarningDialogA Metro-style warning dialog which pops up to prompt the user, and provides some Yes/No/Ok/Cancel buttons
  • Miscellaneous controls and classes, such as the LabelControl, ExceptionViewer,


SciChart.WPF.UI BusyPanel and Popups


Where to Get it

The SciChart.WPF.UI libraries are free & open source and may be used in commercial projects under the Apache 2.0 license. Packages are published to and source code is available on Github.


About Us

SciChart is a self-funded and profitable startup based in London, U.K., which specialises in High Performance, Realtime Chart controls as well as expert consultancy in complex .NET UI / Server applications.

Connect with me on LinkedIn to find out more about our background and capabilities. If you have a bespoke requirement and want to hire our world-class consultants, then get in touch!



The post Open Source SciChart.UI.Reactive and SciChart.WPF.UI.Transitionz v2.1 Released appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.

Read more »


Not sure where to start? Contact us, we are happy to help!


SciChart Ltd, 16 Beaufort Court, Admirals Way, Docklands, London, E14 9XL. Email: Legal Company Number: 07430048, VAT Number: 101957725