dotnet/maui-samples: What the Official .NET MAUI Sample Repository Contains

What dotnet/maui-samples Is For, and Who It Is Not For

This repository is a collection of sample applications built with .NET Multi-platform App UI, not a framework, template pack or NuGet package. The README describes .NET MAUI as a cross-platform framework for creating mobile and desktop apps with C# and XAML, targeting Android, iOS, iPadOS, macOS and Windows from a single shared codebase. The samples exist to show that codebase in practice: a calculator, a point-of-sale app, a weather app, navigation patterns, and two AI chat clients.

The audience is developers who already decided to write C# and XAML for multiple platforms and now want a working reference. If you are evaluating whether to choose .NET MAUI at all, this repository will not answer that question, because every sample assumes the decision has been made. The README points elsewhere for that context: the .NET MAUI website at dot.net/maui and the documentation at docs.microsoft.com/dotnet/maui.

It is also not a starter kit. There is no scaffolding command here that generates your application. You copy patterns, not a project skeleton.

How the Repository Is Split Across 9.0, 10.0 and 11.0

The top-level layout is the first thing to understand, because picking the wrong folder wastes time. Three version folders sit side by side. The 10.0 folder is labelled .NET MAUI 10 (current stable) and holds the full set of samples targeting the latest supported release. The 11.0 folder is labelled .NET MAUI 11 (preview) and holds samples for features specific to .NET 11, with a pointer to a safe preview testing note in 11.0/README.md. The 9.0 folder is marked Deprecated, with the README stating that .NET 9 is out of support and linking a deprecation notice in 9.0/README.md.

A fourth folder, Upgrading/, holds migration guides from Xamarin.Forms to .NET MAUI. That is a different kind of content from the runnable samples, and it matters if you are porting an existing app rather than starting fresh.

The version split is a deliberate maintenance choice rather than an accident of history. Because MAUI ships on the .NET release cadence, samples that target an out-of-support runtime would otherwise mislead readers. Marking 9.0 as deprecated and quarantining preview-only work in 11.0 keeps the stable folder honest. The cost is duplication: a sample that exists in more than one version folder has to be maintained in each, and the README does not describe how that duplication is managed.

The Sample Highlights: Calculator, Point of Sale, Weather and Two AI Clients

The README lists sample highlights rather than documenting each one in depth, so the descriptions below are as specific as the repository gets.

SimpleChatClient sits under 10.0/AI/ChatClient and is described as a minimal .NET MAUI sample that wires Microsoft.Extensions.AI into a chat UI. ChatClientWithTools, under 10.0/AI/ChatClientWithTools, goes further: the README says it shows how to enhance using an LLM via Microsoft.Extensions.AI with tool function calling, which the description says can improve reliability and repeatability of responses and enable the LLM to answer queries it otherwise could not. Those two are the most interesting entries for anyone building AI features into a mobile app, because they show the integration layer rather than the model itself.

Point of Sale, under 10.0/Apps/PointOfSale, is described as demonstrating techniques for building a desktop and mobile application that takes advantage of native platform features and adapts to a wide range of device needs from a single codebase. Weather '21 App, under 10.0/Apps/WeatherTwentyOne, is described as showcasing responsive UI that adapts to desktop and mobile and integrates with native platform features. Calculator, under 10.0/Apps/Calculator, is the smallest of the group and is described as demonstrating span and spacing features of a Grid layout.

Navigation Samples under 10.0/Navigation cover navigation in different scenarios, and the Beginner's Series Task App under 10.0/Beginners-Series accompanies a Microsoft Learn video series. The range is deliberate: one sample per concept, not one large app.

Getting the Samples: Clone the Repository and Open a Sample

There is no installer here and the README gives no build or run commands. What it does give is the repository layout, so the practical starting point is cloning the repository and opening one of the sample folders in your editor or IDE. The README names the Calculator sample as 10.0/Apps/Calculator, so that path is the one to follow for a first look:

git clone https://github.com/dotnet/maui-samples.git

After the clone finishes, the 10.0/Apps/Calculator folder should contain a .NET project you can open directly. From that point the README is silent: it does not list a build command, a target framework moniker, a workload installation step or a run command for any sample. Anyone who needs those should read the sample's own project file and the .NET MAUI documentation the README links, because guessing a framework moniker from the folder name is not something the repository supports.

The same applies to the AI samples. They depend on Microsoft.Extensions.AI, which the README links to its Microsoft Learn page, but the README does not describe how an LLM backend or credentials are supplied. Read the sample source before assuming either chat client runs without configuration.

Centralized Package Versions and What That Means for Copying Code

The 10.0 and 11.0 folders use centralized version management through Directory.Build.props, and the README points to 10.0/PACKAGE-VERSIONS.md for details. This is the detail most likely to trip up someone who copies a sample into their own solution.

In a centralized setup, individual project files do not carry version numbers for shared packages. The versions live in one props file at the folder root. If you lift a .csproj out of the repository and drop it into a solution that has no equivalent Directory.Build.props, the build fails on missing versions, and the error will point at package references rather than at the missing props file. The fix is to copy the version entries as well as the project.

This is a reasonable structure for a repository that maintains several samples across two active version folders, because bumping a package once updates every sample. It is a poor structure for copy-paste reuse, which is exactly how most people use a samples repository. The README acknowledges the mechanism but not the friction.

Where the Samples Stop Being Useful

The clearest limitation is that samples are not maintained as production code. Nothing in the README states a support commitment for individual samples, and the version folders exist precisely because samples go stale when the runtime moves. The 9.0 folder is the proof: it is marked deprecated because .NET 9 is out of support, which means a sample that worked when written can be dead weight now.

The second limitation is coverage. The highlights list is short. If you need a specific control, a specific platform API, or a specific architecture pattern that is not among Calculator, Point of Sale, Weather '21, Navigation, the Beginner's Series app or the two AI clients, this repository does not have it. The README points to community collections for that reason: the .NET MAUI Showcase and Awesome .NET MAUI, both maintained outside Microsoft.

The third is that the samples do not teach you the framework. They show one way to do a thing. There is no discussion of why a layout was chosen over another, and no performance guidance. If you need to understand the trade-offs, the documentation site is the place, not the sample source.

Finally, the 11.0 folder is preview content. The README explicitly frames it as samples for features specific to .NET 11 and links a safe preview testing note. Building against it means building against something that can change.

How This Differs From Telerik's MAUI Samples and Other Sample Sets

The natural comparison is a commercial control vendor's sample set, such as the Telerik MAUI samples. The difference is what the samples are demonstrating. Microsoft's repository demonstrates the framework itself: layout, navigation, platform integration, and now Microsoft.Extensions.AI integration. A vendor sample set demonstrates that vendor's controls inside a MAUI app, so it assumes you have licensed and referenced those controls.

That changes what you can copy. Code from dotnet/maui-samples depends on the .NET SDK and the packages listed in Directory.Build.props. Code from a vendor sample set depends on that vendor's NuGet packages, which carry their own licensing terms. Both are useful, but for different questions: one answers "how does MAUI do this", the other answers "how does this control work in MAUI".

There is also a framework-level comparison worth naming. Flutter and .NET MAUI both target multiple platforms from one codebase, but they differ in language and rendering approach, and this repository contains nothing that will help you evaluate that choice. It starts after the choice is made.

Licence, Maintenance and the Cost of Upgrading

The repository is licensed under MIT, and the README states that .NET, including the maui-samples repo, is licensed under MIT, with the licence file at LICENSE. MIT is permissive: you can reuse the sample code in your own projects, including commercial ones, provided you keep the copyright and licence notice. That is the general shape of the licence, not legal advice, and if you are copying substantial portions into a product you should read LICENSE yourself rather than rely on a summary.

The maintenance signal is straightforward. The repository is not archived, and the last push was on 2026-09-01. The most recent tagged releases listed are previews from 2021 (6.0.1xx-preview4 through 6.0.1xx-preview6), which means the release tags do not track the current state of the samples. Treat the folder contents and the commit history as the current state, not the release list.

Upgrade cost falls on you, not on the repository. Because samples are versioned by folder, moving your own app from one .NET version to the next means finding the corresponding folder and diffing against what you copied. The Upgrading/ folder covers Xamarin.Forms to .NET MAUI migration specifically, which is a one-time move rather than an ongoing upgrade path.

Editorial conclusion

Adopt dotnet/maui-samples if you are learning .NET MAUI or need a working reference for a specific control, navigation pattern or AI integration, and start with the 10.0 folder because it is described as the current stable set while the 9.0 folder carries a deprecation notice. Do not treat it as a production dependency or as a substitute for the dotnet/maui framework repository itself. Before you copy anything, open the sample's project file to confirm which target frameworks it declares, and read 10.0/PACKAGE-VERSIONS.md to see how package versions are pinned through Directory.Build.props.

Frequently asked questions

Official sources

1. dotnet/maui-samples on GitHub
2. License: MIT
3. Project website
4. README
5. Releases