UraniumUI

Documentation | NuGet | Templates | Demo App | Discord

UraniumUI is a free and open-source presentation layer for .NET MAUI. It fills the UI gaps plain MAUI leaves to every team: Material-styled inputs and buttons, generated forms, validation mapping, keyboard-friendly selection controls, focus-aware custom surfaces, data grids, tree views, tab views, dialogs, bottom sheets, backdrops, icons, blur effects, code views, templates, and app-ready presentation patterns.

You keep writing regular .NET MAUI: XAML, ContentPage, Shell, bindings, styles, resources, handlers, dependency injection, MVVM, and platform APIs. UraniumUI attaches to that model instead of replacing it.

It is not just a collection of styled controls and it is not only an AutoFormView package. UraniumUI provides the building blocks for real app screens: form workflows, data-heavy views, hierarchical navigation, app surfaces, visual system resources, native-MAUI handlers, and extensibility points for your own controls.

Who It Is For

• .NET MAUI teams building production line-of-business, admin, data-entry, or internal tools.
• Teams that want a Material presentation layer without moving away from XAML, MVVM, resources, or MAUI handlers.
• Apps that need more than basic controls: validation-aware fields, data grids, tree views, tabs, dialogs, bottom sheets, and reusable page surfaces.
• Developers who want incremental adoption: use one control, add one package, or start from a full template.
• Teams that need accessible interactions: visible focus states, keyboard navigation, semantic hints, and custom clickable areas that behave like real controls.

No Framework Tax

Some UI stacks ask you to move your app into their way of building software. UraniumUI does not.

There is no required base ViewModel, proprietary navigation model, custom application layer, generated project structure, or new UI DSL. Adopt one control, a validation-aware field set, or a full Material presentation layer. Your app remains a MAUI app.

Plain MAUI in, better UI out.

The Mental Model

.NET MAUI gives you the platform foundation. UraniumUI adds the presentation architecture that most production apps end up rebuilding.

Accessibility

Accessibility is a first-class concern in UraniumUI. The library keeps MAUI primitives available while adding focus-aware Material inputs, keyboard-activated custom surfaces, generated semantic hints in selection controls, and guidance for building custom cards, rows, and icon actions without losing accessibility.

Start with the accessibility docs when building these areas: popups, dialogs, bottom sheets, TabView, DataGrid, date pickers, combo/autocomplete fields, validation messages, masked or formatted inputs, and custom clickable cards.

Learn more: Accessibility best practices and Clickable areas.

Quick Start

Start a New App

Install the templates and create a ready-to-run UraniumUI project:

dotnet new install UraniumUI.Templates
dotnet new uraniumui-app -n MyMauiApp

For a lighter starter project:

dotnet new uraniumui-blank-app -n MyMauiApp

You can also generate a UraniumContentPage item:

dotnet new uraniumcontentpage -n CustomerPage -na MyMauiApp

Templates can configure icon packages, dialog integration, and blur support during project creation.

Add UraniumUI to an Existing App

Install the Material package. It references the core UraniumUI package and configures Material controls and AutoFormView editor mappings.

dotnet add package UraniumUI.Material

Register UraniumUI in MauiProgram.cs:

using UraniumUI;

builder
    .UseMauiApp<App>()
    .UseUraniumUI()
    .UseUraniumUIMaterial();

Add Material resources in App.xaml:

…

Read the full onboarding guide: Getting Started.

What You Can Build

UraniumUI is useful when you need to ship complete MAUI screens, not just one-off controls. These are common places where it removes repeated UI plumbing.

Forms Without Boilerplate

Instead of hand-writing every field, binding, validation message, and layout row, describe the form with your model and let UraniumUI generate the editable UI.

using System.ComponentModel.DataAnnotations;

public class RegisterViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; } = string.Empty;

    [Required]
    public string FullName { get; set; } = string.Empty;

    [Range(1, 10)]
    public int NumberOfSeats { get; set; }

    [Display(Name = "I accept the terms and conditions")]
    public bool AcceptedTerms { get; set; }
}

<uranium:AutoFormView Source="{Binding .}" />

Enable DataAnnotations validation once:

dotnet add package UraniumUI.Validations.DataAnnotations

using UraniumUI.Options;
using UraniumUI.Validations;

builder.Services.Configure<AutoFormViewOptions>(options =>
{
    options.ValidationFactory = DataAnnotationValidation.CreateValidations;
});

The same model can now drive generated editors, display names, and validation messages. If a screen needs custom behavior, override the editor mapping, change the generated layout, or replace a generated field with your own MAUI view.

Learn more: AutoFormView and DataAnnotations validation.

Data Screens Without Rebuilding Tables

Bind a collection and let DataGrid render rows, headers, empty states, selection columns, templates, and auto-generated columns when you want them.

<material:DataGrid ItemsSource="{Binding Customers}" UseAutoColumns="True" />

When the screen needs more control, define explicit DataGridColumn items, cell templates, header templates, selection columns, and pair the grid with Paginator.

Learn more: DataGrid and Paginator.

Navigation, Hierarchies, And Multi-Section UI

Use higher-level controls for the patterns that show up in real apps: hierarchical data, tabbed content, searchable/selectable lists, calendars, expanders, and dropdowns.

<material:TreeView ItemsSource="{Binding Nodes}" SelectionMode="Multiple" />

<material:TabView>
    <material:TabItem Title="Overview">
        <material:TabItem.ContentTemplate>
            <DataTemplate>
                <Label Text="Overview content" />
            </DataTemplate>
        </material:TabItem.ContentTemplate>
    </material:TabItem>
</material:TabView>

TreeView supports custom item templates, expansion state binding, lazy loading, single/multiple selection, and hierarchical checkbox selection. TabView supports lazy content templates, custom headers, dynamic tabs, placement options, and caching strategies.

Learn more: TreeView, TabView, Select, and CalendarView.

App Surfaces, Dialogs, And Visual Polish

Use UraniumContentPage attachments for surfaces that belong to the page instead of manually layering grids and overlays.

<uranium:UraniumContentPage.Attachments>
    <material:BottomSheetView IsPresented="{Binding IsFiltersOpen}">
        <VerticalStackLayout Padding="24" Spacing="16">
            <Label Text="Filters" FontAttributes="Bold" />
            <material:TextField Title="Search" Text="{Binding SearchText}" />
        </VerticalStackLayout>
    </material:BottomSheetView>
</uranium:UraniumContentPage.Attachments>

The same presentation layer includes BackdropView, IDialogService, form dialogs, prompt dialogs, progress dialogs, optional Mopups and CommunityToolkit providers, Material color/style resources, icon packages, and blur effects.

Learn more: Bottom Sheet, Backdrop, Dialogs, and Blurs.

Feature Map