A good idea.
A place to start.

Meet Whoopi

Whoopi is a UI framework and retained composition engine for .NET. Its specification describes compiled XAML, asynchronous rendering, configurable GPU resource budgets, and support for desktop, mobile, and browser applications.

Review the current repository license and the license attached to the package you install. Licensing information can differ between distributions.

Start with a rendering profile

The documented package targets net8.0. Begin with a Whoopi application that already defines its App class and has the required framework references. The following example configures the desktop entry point; it is not a complete standalone project.

1. Install from NuGet

Whoopi 12.3.0 is available on NuGet for .NET 8. Run this command in your existing project directory:

dotnet add package Whoopi --version 12.3.0

The optional Whoopi UI extension adds XAML highlighting, snippets and project templates to VS Code.

2. Configure Program.cs

using System;
using Whoopi;
using Whoopi.Rendering;

namespace MyWhoopiApp
{
    internal class Program
    {
        [STAThread]
        public static void Main(string[] args)
            => BuildWhoopiApp()
                .StartWithClassicDesktopLifetime(args);

        public static AppBuilder BuildWhoopiApp()
            => AppBuilder.Configure<App>()
                .UsePlatformDetect()
                .UseWhoopiRenderEngine(
                    WhoopiRenderProfile.UltraPerformance)
                .WithInterFont()
                .LogToTrace();
    }
}

3. Choose a suitable starting point

Use Balanced for general desktop interfaces, HighFidelity for image focused work, UltraPerformance for high refresh scenarios, or PowerSaver for a smaller configured GPU cache. Test the selection against your own hardware and workload.

From XAML to the GPU

The documented pipeline separates application state changes from rendering using a retained visual tree, batched updates, and a server compositor.

Dirty region tracking

ServerCompositionTarget tracks changed areas so rendering can focus on those regions. The documented UltraPerformance profile supports up to 16 independent regions and specifies MergeEagerness = 600. Other profiles use different region counts.

Resource cache

GPU cache budgets vary by profile, from 64 MB to 768 MB. Cached resources include vector paths, glyph atlases, shaders, and bitmaps. These numbers are configured cache budgets, not measurements of total application memory.

Four rendering profiles

Configure the profile through UseWhoopiRenderEngine() at startup, or change it through WhoopiRenderEngine.SetProfile() while the application runs.

WhoopiRenderEngine.SetProfile(
    WhoopiRenderProfile.HighFidelity);

Make the interface your own

The specification describes Fluent themes, Windows Mica and Acrylic transparency, and style classes including accent, glass, and pill.

<Window xmlns="https://github.com/whoopiui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Hello, Whoopi"
        TransparencyLevelHint="Mica,AcrylicBlur"
        Background="#0B0E14">
    <StackPanel Spacing="16" Margin="32">
        <Button Classes="accent"
                Content="Make something great" />
        <Button Classes="pill glass"
                Content="A little more expressive" />
        <ToggleSwitch Content="Enable visual option"
                      IsChecked="True" />
    </StackPanel>
</Window>

Make sure the corresponding theme and class styles are loaded in your application. Transparency hints depend on the operating system and compositor. The toggle above demonstrates a control only; engine behavior requires application logic.

Whoopi Studio Pro

The documentation describes a visual UI builder with a property inspector, a stress benchmark suite, and XAML generation. It identifies WhoopiWindowsApp.exe as the designer executable and ControlCatalog.Desktop.exe as the control gallery.

Read the engine’s telemetry

Use WhoopiRenderEngine.GetStats() to access compositor statistics. The specification describes frame rate, smoothed frame time, total frames, active targets, and visual counts.

using Whoopi.Rendering;

WhoopiRenderStats stats = WhoopiRenderEngine.GetStats();
Console.WriteLine($"Engine: {stats.EngineName}");
Console.WriteLine($"FPS: {stats.CurrentFps:F1}");

The source PDF truncates part of its telemetry example. Only the complete property names visible in that example are used here. Consult the package’s actual type definitions for the remaining fields.

When measuring, record the hardware, operating system, display refresh rate, renderer, profile, and workload. A compositor statistic and end to end interaction latency measure different things.

Platform reference

The following platform paths are listed in the supplied specification. Validate the exact target, graphics backend, and feature support in the distribution you use.

Application ideas

The documentation suggests live telemetry dashboards, trading terminals, creative editors, and industrial HMI panels. These are proposed use cases, not verified customer deployments or safety certifications.

Assemblies & distribution

The framework package is published on NuGet, editor tooling is available through Visual Studio Marketplace, and the source is on GitHub. Assembly descriptions above come from the supplied v12.2.999 specification.