Theming - Flowery.Uno

Flowery.Uno includes 35+ pre-built DaisyUI themes with full support for runtime theme switching, persistence, and customization.

Quick Start

Switch Themes in Code

using Flowery.Controls;

// One-liner to switch themes
DaisyThemeManager.ApplyTheme("Synthwave");

Switch Themes in XAML

xmlns:daisy="using:Flowery.Controls"

<!-- Drop-in theme switcher - no code-behind needed -->
<daisy:DaisyThemeDropdown MinWidth="220" />

<!-- Or a simple toggle -->
<daisy:DaisyThemeController Mode="Swap" />

Available Themes

Flowery.Uno includes all 36 official DaisyUI themes:

Light Themes
Dark Themes

Light
Acid
Autumn
Bumblebee
Caramellatte
Cmyk
Corporate
Cupcake
Cyberpunk
Emerald
Fantasy
Garden
Lemonade
Lofi
Nord
Pastel
Retro
Silk
Valentine
Winter
Wireframe

DaisyThemeManager API

The centralized static class for theme management.

Core Methods

using Flowery.Controls;

// Apply a theme
DaisyThemeManager.ApplyTheme("Synthwave");

// Get current theme
var current = DaisyThemeManager.CurrentThemeName;

// List all themes
foreach (var theme in DaisyThemeManager.AvailableThemes)
    Console.WriteLine($"{theme.Name} (Dark: {theme.IsDark})");

// Listen for changes
DaisyThemeManager.ThemeChanged += (sender, themeName) =>
    Console.WriteLine($"Theme changed to: {themeName}");

// Check if dark
bool isDark = DaisyThemeManager.IsDarkTheme("Dracula");

Key Members

Member	Description
`ApplyTheme(string)`	Loads and applies a theme by name
`CurrentThemeName`	Currently applied theme name
`AvailableThemes`	Read-only list of all theme info
`ThemeChanged`	Event fired after theme changes
`IsDarkTheme(string)`	Returns whether a theme is dark

The ApplyTheme method is thread-safe and can be called from any thread. The UI will automatically update when the theme changes.

Theme Controls

DaisyThemeDropdown

Dropdown listing all 36 themes with color previews. Automatically syncs with DaisyThemeManager.CurrentThemeName.

<daisy:DaisyThemeDropdown MinWidth="220" />
<daisy:DaisyThemeDropdown SelectedTheme="{x:Bind ViewModel.CurrentTheme, Mode=TwoWay}" />

DaisyThemeController

Flexible toggle between two themes with multiple presentation modes:

Toggle
Checkbox
Swap (Animated)
With Text
With Icons

<daisy:DaisyThemeController Mode="Toggle" />

<daisy:DaisyThemeController Mode="Checkbox" />

<daisy:DaisyThemeController Mode="Swap" />

<daisy:DaisyThemeController Mode="ToggleWithText"
    UncheckedTheme="Light" CheckedTheme="Synthwave"
    UncheckedLabel="Light" CheckedLabel="Synthwave" />

<daisy:DaisyThemeController Mode="ToggleWithIcons" />

DaisyThemeRadio

Radio button for selecting a specific theme. Use GroupName across multiple radios for a theme picker.

<daisy:DaisyThemeRadio ThemeName="Light" GroupName="themes" />
<daisy:DaisyThemeRadio ThemeName="Dark" GroupName="themes" />
<daisy:DaisyThemeRadio ThemeName="Synthwave" GroupName="themes" />

Theme Persistence

When your app persists theme preferences, apply the saved theme before UI construction:

DaisyThemeManager.cs:136-145

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
    // Apply saved theme FIRST - controls will sync to it
    var savedTheme = LoadThemeFromSettings() ?? "Dark";
    DaisyThemeManager.ApplyTheme(savedTheme);

    // Then create the main window
    MainWindow = new MainWindow();
    MainWindow.Activate();
}

Always apply the theme before creating your main window. Controls automatically sync to the current theme on load.

Palette Architecture

Flowery.Uno uses a palette-based architecture for dynamic theme switching:

DaisyPaletteFactory produces per-theme resources with semantic color names
Themes are applied by updating Application.Current.Resources
Stable brush instances are mutated (Color property) to ensure UI updates correctly
Controls use ThemeResource bindings to automatically update when themes change

Key Palette Resources

Base Colors

DaisyBase100Brush - Page/window background
DaisyBase200Brush - Elevated surfaces (cards, sidebar)
DaisyBase300Brush - Borders
DaisyBaseContentBrush - Default text/icon color

Semantic Colors

DaisyPrimaryBrush - Primary accent color
DaisySecondaryBrush - Secondary accent
DaisyAccentBrush - Tertiary accent

Status Colors

DaisyInfoBrush - Info status color
DaisySuccessBrush - Success status color
DaisyWarningBrush - Warning status color
DaisyErrorBrush - Error status color

Content Colors

DaisyPrimaryContentBrush - Text on primary
DaisySecondaryContentBrush - Text on secondary
DaisyAccentContentBrush - Text on accent

Using Resources in XAML

<!-- Prefer ThemeResource for runtime theme updates -->
<Border Background="{ThemeResource DaisyBase200Brush}"
        BorderBrush="{ThemeResource DaisyBase300Brush}">
    <TextBlock Foreground="{ThemeResource DaisyBaseContentBrush}" Text="Hello"/>
</Border>

Always use ThemeResource instead of StaticResource for colors that should update when themes change.

Uno Platform Considerations

StaticResource vs ThemeResource

StaticResource resolves once at load time. If you swap theme resources later, the UI will not update. Always use ThemeResource for any Daisy palette brushes in XAML:

<!-- ✅ DO: Updates when theme changes -->
<Border Background="{ThemeResource DaisyBase100Brush}" />

<!-- ❌ DON'T: Won't update when theme changes -->
<Border Background="{StaticResource DaisyBase100Brush}" />

ThemeResource Limitations

ThemeResource updates most reliably when the app theme flips Light↔Dark. Switching between two dark themes (e.g., Dracula → Forest) may not trigger updates if you only replace a MergedDictionaries entry. Solution: Flowery.Uno keeps brush instances stable and mutates their Color property when themes change. This is handled internally by DaisyThemeManager.

Critical detail: Do NOT remove and replace the palette ResourceDictionary at runtime. Replacing the dictionary leaves existing ThemeResource bindings pointing at old brush instances.

Lightweight Styling

WinUI/Uno supports “lightweight styling” - overriding theme resources for individual controls without creating full custom styles.

Override a Single Control’s Colors

Place a ResourceDictionary with ThemeDictionaries inside the control’s Resources:

<Button Content="Custom Purple Button">
    <Button.Resources>
        <ResourceDictionary>
            <ResourceDictionary.ThemeDictionaries>
                <ResourceDictionary x:Key="Light">
                    <SolidColorBrush x:Key="ButtonBackground" Color="Transparent"/>
                    <SolidColorBrush x:Key="ButtonForeground" Color="MediumSlateBlue"/>
                    <SolidColorBrush x:Key="ButtonBorderBrush" Color="MediumSlateBlue"/>
                </ResourceDictionary>
                <ResourceDictionary x:Key="Dark">
                    <SolidColorBrush x:Key="ButtonBackground" Color="Transparent"/>
                    <SolidColorBrush x:Key="ButtonForeground" Color="Coral"/>
                    <SolidColorBrush x:Key="ButtonBorderBrush" Color="Coral"/>
                </ResourceDictionary>
            </ResourceDictionary.ThemeDictionaries>
        </ResourceDictionary>
    </Button.Resources>
</Button>

Handle Pointer States

Override state-specific resources using standard suffixes:

State	Suffix Example
Hover	`ButtonBackgroundPointerOver`
Pressed	`ButtonForegroundPressed`
Disabled	`ButtonBorderBrushDisabled`

Daisy Control Styling Resources

Flowery.Uno controls support lightweight styling through control-specific resource keys.

Resource Naming Convention

All Daisy styling resources follow this pattern:

Daisy{ControlName}{Part?}{State?}{Property}

Examples:

DaisyButtonBackground – Button background
DaisyToggleKnobBrush – Toggle switch knob color
DaisyTableRowHoverBackground – Table row hover state
DaisyInputPrimaryBorderBrush – Primary variant border

Lookup Priority

Resources are resolved in this order:

Control.Resources – Instance-level override (highest priority)
Application.Current.Resources – App-wide override
Fallback – Control’s internal palette logic

Application-Level Styling

Override in App.xaml to affect all instances of a control:

<Application.Resources>
    <ResourceDictionary>
        <SolidColorBrush x:Key="DaisyButtonBackground" Color="MediumSlateBlue"/>
        <SolidColorBrush x:Key="DaisyCardBackground" Color="#2A2A3A"/>
    </ResourceDictionary>
</Application.Resources>

Instance-Level Styling

Override on a single control instance:

<daisy:DaisyButton Content="Custom Button">
    <daisy:DaisyButton.Resources>
        <SolidColorBrush x:Key="DaisyButtonBackground" Color="Coral"/>
        <SolidColorBrush x:Key="DaisyButtonForeground" Color="White"/>
    </daisy:DaisyButton.Resources>
</daisy:DaisyButton>

Control Development Guidelines

When creating custom controls that need to respect themes: Always subscribe in Loaded and unsubscribe in Unloaded to prevent memory leaks:

DaisyThemeManager.cs:522-555

public MyControl()
{
    InitializeComponent();
    Loaded += OnLoaded;
    Unloaded += OnUnloaded;
}

private void OnLoaded(object sender, RoutedEventArgs e)
{
    DaisyThemeManager.ThemeChanged += OnThemeChanged;
    ApplyTheme();
}

private void OnUnloaded(object sender, RoutedEventArgs e)
{
    DaisyThemeManager.ThemeChanged -= OnThemeChanged;
}

private void OnThemeChanged(object? sender, string themeName)
{
    ApplyTheme();
}

private void ApplyTheme()
{
    Background = DaisyResourceLookup.GetBrush("DaisyBase200Brush");
    Foreground = DaisyResourceLookup.GetBrush("DaisyBaseContentBrush");
}

The DaisyThemeManager.ApplyTheme() method mutates brush colors in-place, which works for code-behind lookups. However, XAML {ThemeResource} bindings do not automatically update when switching between themes of the same Light/Dark category (e.g., Dark → Dracula). Always use code-behind for controls that must update between same-category theme switches.

Use the Right Tokens

Surface Type	Token
Page/window background	`DaisyBase100Brush`
Card/elevated surface	`DaisyBase200Brush`
Borders	`DaisyBase300Brush`
Text/icons	`DaisyBaseContentBrush`
Primary actions	`DaisyPrimaryBrush`
Success states	`DaisySuccessBrush`
Error states	`DaisyErrorBrush`

Debugging Theme Issues

If theme switching appears “dead”:

Check if ThemeChanged fires - persistence depends on this event
Look for exceptions - RequestedTheme can throw silently

Common Issues

UI doesn't update on theme change

Cause: Using StaticResource instead of ThemeResourceFix: Switch to ThemeResource for all Daisy palette brushes

Text stays white on light themes

Cause: Missing Foreground bindingFix: Explicitly bind to DaisyBaseContentBrush

Theme change works once then stops

Cause: Exception in theme applyFix: Check debug log for errors

Code-behind controls don't update

Cause: Brushes cached at creationFix: Re-apply brushes on ThemeChanged event

Get Started

Core Concepts

Components

Advanced Features

Guides

​Quick Start

​Switch Themes in Code

​Switch Themes in XAML

​Available Themes

​DaisyThemeManager API

​Core Methods

​Key Members

​Theme Controls

​DaisyThemeDropdown

​DaisyThemeController

​DaisyThemeRadio

​Theme Persistence

​Palette Architecture

​Key Palette Resources

Base Colors

Semantic Colors

Status Colors

Content Colors

​Using Resources in XAML

​Uno Platform Considerations

​StaticResource vs ThemeResource

​ThemeResource Limitations

​Lightweight Styling

​Override a Single Control’s Colors

​Handle Pointer States

​Daisy Control Styling Resources

​Resource Naming Convention

​Lookup Priority

​Application-Level Styling

​Instance-Level Styling

​Control Development Guidelines

​Subscribe to ThemeChanged (with proper lifecycle)

​Use the Right Tokens

​Debugging Theme Issues

​Common Issues

Build docs developers (and LLMs) love

Quick Start

Switch Themes in Code

Switch Themes in XAML

Available Themes

DaisyThemeManager API

Core Methods

Key Members

Theme Controls

DaisyThemeDropdown

DaisyThemeController

DaisyThemeRadio

Theme Persistence

Palette Architecture

Key Palette Resources

Using Resources in XAML

Uno Platform Considerations

StaticResource vs ThemeResource

ThemeResource Limitations

Lightweight Styling

Override a Single Control’s Colors

Handle Pointer States

Daisy Control Styling Resources

Resource Naming Convention

Lookup Priority

Application-Level Styling

Instance-Level Styling

Control Development Guidelines

Subscribe to ThemeChanged (with proper lifecycle)

Use the Right Tokens

Debugging Theme Issues

Common Issues