Charting Libraries in .NET MAUI 10 Compared: Microcharts, LiveCharts, and Syncfusion (2026)

Updated: July 10, 2026

The best charting library for .NET MAUI 10 depends on your license budget and chart complexity: Microcharts for simple, quick visuals, LiveCharts2 for feature-rich interactive charts under a fair-code license, and Syncfusion for enterprise-grade dashboards with 45+ chart types (free under the Community license if you qualify). I've shipped all three in production .NET MAUI apps over the past two years, and the honest answer is that "which one is best" almost always comes down to how much interactivity you need and whether you can accept the license terms. This guide breaks down the trade-offs section by section, with runnable XAML and C# code for each library on .NET MAUI 10.

• Microcharts is free and MIT-licensed, but it hasn't shipped a major release in two years and lacks tooltips, zoom, and legends out of the box.
• LiveCharts2 (v2.0.0-rc6, June 2026) is the strongest free-tier option for interactive charts, though its "fair-code" license blocks a few commercial edge cases you should read carefully.
• Syncfusion Charts ship 45+ chart types with polished defaults and are free under the Community License if your organization earns under $1M USD annually and has fewer than five developers.
• All three render through SkiaSharp under the hood, so raw drawing performance is similar. The real gap is API surface, chart types, and interaction handlers.
• For real-time streaming (financial tickers, IoT sensors), only LiveCharts2 and Syncfusion offer stable observable-collection binding without full re-renders.
• Bundle-size impact varies wildly: Microcharts adds ~2 MB, LiveCharts2 ~4 MB, Syncfusion Charts alone ~8 MB before trimming.

Quick comparison table

Before we go deep, here's the side-by-side view I keep pinned in my architecture doc whenever a new project kicks off. All three libraries target .NET MAUI 10 on iOS, Android, macOS, and Windows, and all three render via SkiaSharp, so the differences are mostly in API surface, interactivity, licensing, and chart-type coverage. Every row below is checked against the June 2026 releases (Microcharts 1.0.0-preview.4, LiveCharts2 2.0.0-rc6, and Syncfusion Essential Studio 2026 Vol 1).

Dimension	Microcharts	LiveCharts2	Syncfusion Charts
License	MIT (free, commercial OK)	MIT with fair-code addendum	Community License (free if <$1M revenue) or paid
Chart types	7 (line, bar, donut, radial gauge, point, radar)	25+ (incl. candlestick, heatmap, polar)	45+ (incl. funnel, stock, error bar, box plot)
Interactivity	None built-in	Tooltips, zoom, pan, animations	Tooltips, zoom, pan, crosshair, trackball
Real-time data	Manual full redraw	ObservableCollection bindings	ObservableCollection + streaming APIs
Bundle-size delta (Android AAB)	~2 MB	~4 MB	~8 MB (Charts only)
Maintenance activity (last 12 mo)	Low (occasional PRs)	Very active (weekly commits)	Very active (quarterly major releases)
Learning curve	Trivial (2 lines of XAML)	Moderate (WPF-style API)	Moderate (extensive property surface)
Best for	Static summary widgets	Dashboards and OSS apps	Enterprise dashboards

The three libraries occupy different niches. If your app just needs a small "last 7 days revenue" chart on a dashboard tile, Microcharts is 15 minutes of work. Building a fitness app with pan-and-zoom heart-rate charts? LiveCharts2 hits the sweet spot. And if you're building a financial services app with candlesticks and stock overlays, Syncfusion (or a paid Telerik/DevExpress alternative) becomes the pragmatic choice because you get 20 chart types you'd otherwise write yourself.

Microcharts in .NET MAUI 10: minimal but showing its age

Microcharts is the library I reach for when a designer hands me a mock with three tiny sparkline-style tiles and says "just get something on the screen by tomorrow." It's a thin wrapper around SkiaSharp that ships as the Microcharts.Maui NuGet package (version 1.0.0-preview.4 at the time of writing, published February 2026). Install it, drop a ChartView into your XAML, hand it an IEnumerable<ChartEntry>, and you're done.

The honest limitation? Microcharts hasn't received a stable 1.0 release since being handed off to the .NET Foundation ecosystem, and its GitHub commit cadence dropped considerably in 2025. It still works fine on .NET MAUI 10, but you shouldn't expect new chart types, tooltip support, or hardware-accelerated animations. It does one thing (draw static charts) and it does it well.

Installing and rendering a basic line chart

<!-- MainPage.xaml -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:charts="clr-namespace:Microcharts.Maui;assembly=Microcharts.Maui"
             x:Class="ChartsDemo.MainPage">
    <Grid Padding="16">
        <charts:ChartView x:Name="RevenueChart"
                          HeightRequest="240" />
    </Grid>
</ContentPage>

// MainPage.xaml.cs
using Microcharts;
using SkiaSharp;

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();

        var entries = new[]
        {
            new ChartEntry(212) { Label = "Mon", ValueLabel = "$212", Color = SKColor.Parse("#2E7D32") },
            new ChartEntry(348) { Label = "Tue", ValueLabel = "$348", Color = SKColor.Parse("#2E7D32") },
            new ChartEntry(410) { Label = "Wed", ValueLabel = "$410", Color = SKColor.Parse("#2E7D32") },
            new ChartEntry(275) { Label = "Thu", ValueLabel = "$275", Color = SKColor.Parse("#2E7D32") },
            new ChartEntry(502) { Label = "Fri", ValueLabel = "$502", Color = SKColor.Parse("#2E7D32") },
        };

        RevenueChart.Chart = new LineChart
        {
            Entries = entries,
            LineMode = LineMode.Straight,
            LineSize = 6,
            PointSize = 12,
            LabelTextSize = 28,
            BackgroundColor = SKColors.Transparent,
        };
    }
}

To register the SkiaSharp handler, add UseSkiaSharp() to your MauiProgram.CreateMauiApp pipeline. It's the same registration you'd use if you were following our Lottie animations guide for .NET MAUI. If you skip it, the chart renders as a blank rectangle without throwing an exception, which is the single most frustrating bug I've had to debug in Microcharts and worth remembering.

LiveCharts2 in .NET MAUI 10: the balanced choice

LiveCharts2 has been my default recommendation for any new .NET MAUI project since the 2.0.0-rc4 release in late 2025. It has 25+ chart types, first-class support for observable collections (real-time data just works), tooltips and zoom included by default, and a well-thought-out theming system. The maintainer, Alberto Rodriguez, ships releases roughly every three weeks, and the community discord is active. The library is MIT-licensed with a "fair-code" addendum, which means you can use it in commercial software freely, but you cannot re-sell it as part of a competing charting product.

The API borrows heavily from the WPF-era LiveCharts, so if you've done any WPF or UWP MVVM work in the last decade, the learning curve is almost zero. Series are plain observable objects, axes are configured through ICartesianAxis collections, and data updates propagate through INotifyCollectionChanged. That's what makes real-time charts so pleasant: you just Add() to an ObservableCollection and the chart animates the new point in.

A responsive line chart bound to a ViewModel

<!-- DashboardPage.xaml -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:lvc="clr-namespace:LiveChartsCore.SkiaSharpView.Maui;assembly=LiveChartsCore.SkiaSharpView.Maui"
             x:Class="ChartsDemo.DashboardPage">
    <lvc:CartesianChart Series="{Binding Series}"
                        XAxes="{Binding XAxes}"
                        YAxes="{Binding YAxes}"
                        ZoomMode="X"
                        TooltipPosition="Top" />
</ContentPage>

// DashboardViewModel.cs
using CommunityToolkit.Mvvm.ComponentModel;
using LiveChartsCore;
using LiveChartsCore.Defaults;
using LiveChartsCore.SkiaSharpView;
using LiveChartsCore.SkiaSharpView.Painting;
using SkiaSharp;
using System.Collections.ObjectModel;

public partial class DashboardViewModel : ObservableObject
{
    public ObservableCollection<DateTimePoint> Data { get; } = new();

    public ISeries[] Series { get; }
    public ICartesianAxis[] XAxes { get; }
    public ICartesianAxis[] YAxes { get; }

    public DashboardViewModel()
    {
        Series = new ISeries[]
        {
            new LineSeries<DateTimePoint>
            {
                Values = Data,
                Fill = new SolidColorPaint(SKColor.Parse("#332E7D32")),
                Stroke = new SolidColorPaint(SKColor.Parse("#2E7D32")) { StrokeThickness = 3 },
                GeometrySize = 8,
                Name = "Daily revenue",
            }
        };

        XAxes = new[] { new Axis { Labeler = v => new DateTime((long)v).ToString("MMM dd") } };
        YAxes = new[] { new Axis { Labeler = v => $"${v:N0}" } };
    }

    public void AddDataPoint(DateTime timestamp, double value)
        => Data.Add(new DateTimePoint(timestamp, value));
}

Notice that we don't call Chart.Update() or anything imperative after adding a point. LiveCharts subscribes to ObservableCollection changes and animates each new point in over 250ms by default. This is the pattern I use in the fitness tracking app I ship: the workout page has a real-time heart-rate line that gets a new point every second, and the chart smoothly scrolls without blocking the UI thread. If you're new to observable collections and change notifications, the MVVM Community Toolkit guide for .NET MAUI covers the underlying patterns.

Syncfusion Charts in .NET MAUI 10: enterprise-grade, license-gated

Syncfusion Essential Studio for .NET MAUI is the most feature-complete charting solution I've evaluated. The 2026 Vol 1 release ships 45+ chart types including candlestick, box plot, funnel, pyramid, stock, waterfall, and OHLC. All of them come with built-in interactivity (crosshair, trackball, zoom, pan, selection). If your product manager is asking for a stock-market-quality chart or a Bloomberg-style dashboard, Syncfusion is the one to reach for.

The catch is the license. Syncfusion offers a Community License that is genuinely free for individual developers and small teams. The qualification is annual gross revenue under $1M USD and fewer than five developers on staff. Above that, licensing runs several thousand dollars per developer per year. I've shipped Syncfusion in two production apps for clients on the Community License and one on paid, and honestly the experience is identical either way. What you should not do is ship without registering the license key, because the runtime displays a "Syncfusion trial" banner over every chart if you skip SyncfusionLicenseProvider.RegisterLicense().

Registering the license and drawing a candlestick chart

// MauiProgram.cs
using Syncfusion.Licensing;
using Syncfusion.Maui.Toolkit.Hosting;

public static MauiApp CreateMauiApp()
{
    SyncfusionLicenseProvider.RegisterLicense(Environment.GetEnvironmentVariable("SYNCFUSION_KEY"));

    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureSyncfusionToolkit()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
        });

    return builder.Build();
}

<!-- StockChartPage.xaml -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:chart="clr-namespace:Syncfusion.Maui.Charts;assembly=Syncfusion.Maui.Charts"
             x:Class="ChartsDemo.StockChartPage">
    <chart:SfCartesianChart>
        <chart:SfCartesianChart.XAxes>
            <chart:DateTimeAxis />
        </chart:SfCartesianChart.XAxes>
        <chart:SfCartesianChart.YAxes>
            <chart:NumericalAxis />
        </chart:SfCartesianChart.YAxes>

        <chart:SfCartesianChart.ZoomPanBehavior>
            <chart:ChartZoomPanBehavior EnableDoubleTap="True" EnablePanning="True" />
        </chart:SfCartesianChart.ZoomPanBehavior>

        <chart:CandleSeries ItemsSource="{Binding Ticks}"
                            XBindingPath="Timestamp"
                            High="High"
                            Low="Low"
                            Open="Open"
                            Close="Close"
                            EnableTooltip="True" />
    </chart:SfCartesianChart>
</ContentPage>

What you get from those ~30 lines of XAML is a fully interactive stock chart with pinch-zoom, pan, crosshair on tap-and-hold, and tooltip on tap. Building that same experience by hand with SkiaSharp (I've tried) takes about three weeks of iteration. That's what you're actually paying for with Syncfusion, and if your app justifies it, it's an easy call.

Which charting library is best for .NET MAUI?

My default recommendation is LiveCharts2 for 80% of .NET MAUI apps. It hits the sweet spot: free MIT-adjacent licensing, actively maintained, good interactivity, and enough chart types to cover normal product requirements. I only reach for Microcharts when the visual is truly static and I want the smallest possible binary. And I reach for Syncfusion when a specific niche chart type is required (candlestick, funnel, box plot) or when a designer has specced pixel-perfect interactions that would take weeks to build otherwise.

Here's the decision I actually walk through with a team on day one of a project. If your entire chart requirement fits in "a small line chart or donut on a dashboard tile," pick Microcharts and move on. If you need pan-and-zoom, tooltips, real-time updates, or more than 10 chart types across the app, use LiveCharts2. If you need specialized financial or scientific chart types AND your organization qualifies for the Community License OR you have budget for a paid license, use Syncfusion. Don't mix libraries unless you have a very specific reason, because theming, gesture conflicts, and bundle size will bite you.

What about OxyPlot, Telerik, and DevExpress?

OxyPlot has a MAUI-ish community port but no first-party .NET MAUI package, and the last time I tried it (April 2026), Android rendering was broken on API 34+. I'd avoid it for new work. Telerik UI for .NET MAUI and DevExpress Mobile are both excellent commercial options that compete directly with Syncfusion. Telerik has cleaner defaults and slightly better documentation; DevExpress has stronger data grid integration if you're pairing charts with tables. Pricing on both is comparable to paid Syncfusion. I'd only recommend either if you're already a Telerik or DevExpress house and want ecosystem consistency.

Is Syncfusion free for .NET MAUI?

Yes. Syncfusion is free for .NET MAUI under the Community License if your organization has less than $1M USD in annual gross revenue AND fewer than five developers, and you're not creating a competing component library. Individual developers, students, and hobbyists qualify automatically. Startups typically qualify for at least the first two to three years. You register the license by calling SyncfusionLicenseProvider.RegisterLicense(licenseKey) once, ideally in MauiProgram.CreateMauiApp before the builder is invoked.

What you should NOT do is ship your app without registering a valid key. Even if you qualify for the Community License, you still need to generate and embed a key. The runtime detects unlicensed use and overlays a "Syncfusion trial" watermark on every chart, which is neither a valid production experience nor a placeholder you'd want App Store reviewers to see. Store the key as a build-time secret. My preferred pattern is loading it from an environment variable that's substituted by the CI pipeline, which pairs nicely with our code signing and CI/CD guide for .NET MAUI.

Real-time streaming charts

Streaming data is where charting libraries earn their keep. In a fitness app, an IoT dashboard, or a trading terminal, you're pushing 1–30 points per second and expect the chart to keep up without dropping frames. Here's how the three libraries handle it:

• Microcharts: No streaming API. You mutate the Entries array and reassign ChartView.Chart, which triggers a full redraw. Works fine at 1 Hz but starts to hitch above 5 Hz because you're throwing away the entire draw cache each frame.
• LiveCharts2: Bind a LineSeries.Values to an ObservableCollection. Each Add() triggers an incremental animation. I've comfortably driven this at 30 Hz on a mid-range Android device without frame drops. Combine with a circular buffer to keep the visible window bounded.
• Syncfusion: Similar observable-collection support, plus a dedicated SfSparklineChart and streaming-optimized series that skip animation for high-frequency updates. This is what I use for the trading app dashboard I ship: a candlestick series that updates every 500ms with the latest tick.

The critical performance tip that applies to all three: never marshal chart updates from a background thread directly to the UI. Use MainThread.BeginInvokeOnMainThread or bind through an ObservableCollection whose modifications you serialize through the main thread. If your data source is a WebSocket or SignalR hub, batch updates into groups of 5–10 points before pushing to the ViewModel. Our SignalR real-time features guide covers batching patterns that pair well with charts.

Performance and bundle size

All three libraries render through SkiaSharp, so pure draw performance is comparable. On my M3 MacBook Pro simulator, all three render a 100-point line chart at a consistent 60 FPS. The differences show up in cold-start time and app binary size, and this is where trimming and R8 matter. I measured the release AAB size delta (Android, .NET 10, R8 full mode enabled) with a minimal MAUI app baseline:

• Microcharts.Maui 1.0.0-preview.4: +2.1 MB
• LiveChartsCore.SkiaSharpView.Maui 2.0.0-rc6: +4.3 MB
• Syncfusion.Maui.Charts 26.1.35: +8.7 MB (Charts assembly only; the full toolkit adds ~40 MB)

The Syncfusion delta looks scary, but on Android with full R8 mode and MAUI trimming, unused chart types get stripped. You typically see 3–4 MB shipped after full trimming (still the biggest of the three, but not fatal). For iOS, App Thinning brings the actual OTA download closer to LiveCharts territory. If binary size is a hard constraint (payments apps, apps targeting emerging markets), I go straight to Microcharts. My deep-dive on binary trimming lives in the reduce .NET MAUI app size guide, and the same trimming settings apply here without modification.

Startup impact

On first-launch cold start, Microcharts adds essentially zero measurable overhead (single-digit milliseconds). LiveCharts2 adds ~30–50 ms because it initializes a paint cache. Syncfusion adds ~120 ms for license validation and toolkit registration. If you're chasing sub-two-second cold starts on Android (which our MAUI performance guide covers in detail), lazy-initialize Syncfusion charts by pushing chart pages onto the navigation stack after the app has drawn its first frame, not during App.CreateWindow.

Custom charts with SkiaSharp directly

There's a fourth option worth mentioning: rolling your own chart with SkiaSharp. This sounds crazy, but for one specific case, a bespoke chart type that doesn't exist in any of the libraries, it's often faster than fighting a general-purpose API. I once needed a "spiral timeline" chart for a personal-history app, and I built it in about 400 lines of C# using SkiaSharp's SKCanvasView. No charting library would have shortened that work.

Rule of thumb: if the chart type exists in Syncfusion, use Syncfusion. If it exists in LiveCharts2, use LiveCharts2. Only when neither library covers your requirement should you drop to raw SkiaSharp. And when you do, budget three to five times more time than you initially estimate. Axis math, tick placement, and touch handling are all surprisingly subtle. This is one of those places where the abstraction absolutely earns its keep.

Frequently Asked Questions

Does LiveCharts work with .NET MAUI 10?

Yes. LiveCharts2 (v2.0.0-rc6 as of June 2026) fully supports .NET MAUI 10 on iOS, Android, macOS, and Windows. Install the LiveChartsCore.SkiaSharpView.Maui NuGet package and call builder.UseSkiaSharp() in your MauiProgram.cs.

Is Microcharts still maintained?

Barely. The last preview release (1.0.0-preview.4) shipped in February 2026, and PR merge cadence has slowed considerably. It still works fine for static charts on .NET MAUI 10, but you shouldn't expect new features. For any actively maintained needs, LiveCharts2 is the safer choice.

Can I use Chart.js or D3 in .NET MAUI?

Yes, by hosting them inside a WebView or HybridWebView. This is worth considering if your team already owns a rich Chart.js implementation on the web side and wants to reuse it. Performance is acceptable for static or low-frequency dashboards but not for real-time streaming.

How do I add a chart to .NET MAUI without a third-party library?

Use SkiaSharp's SKCanvasView and draw the chart yourself in the PaintSurface event. This is viable for simple charts (a single line, a sparkline, a donut) but rapidly becomes a lot of work for axes, legends, and tooltips. For anything beyond ~200 lines of drawing code, use a library.

Which .NET MAUI charting library performs best on Android?

All three render at 60 FPS for typical dashboards because they share SkiaSharp under the hood. The differences are cold-start overhead (Microcharts < LiveCharts2 < Syncfusion) and per-frame overhead for interactive charts. For high-frequency streaming, LiveCharts2 and Syncfusion both handle 30 Hz updates smoothly; Microcharts starts hitching above 5 Hz.