Deskband11Lib.Core 1.5.1

🌐 English | 한국어

Deskband11Lib is a library for building always-visible taskbar companions on Windows 11. It lets your app place real UI content directly inside the taskbar, so compact dashboards, quick controls, status indicators, media widgets, launchers, and productivity tools appear as part of the taskbar. It is available for C# apps built with WinUI 3 or WPF, and for apps written in Python, Node.js and Electron, or Rust and Tauri.

Packages

Deskband11Lib comes in packages for several languages and UI frameworks, all built on the same taskbar hosting engine, Deskband11Lib.Core. The .NET packages reference the engine directly. The Python, Node.js, and Rust packages call it through deskband11lib.dll, a native library compiled from the engine, and include that library for x64 and ARM64.

More .NET UI frameworks, such as Avalonia, can be added as facade packages on top of Deskband11Lib.Core.

Highlights

• Build taskbar-resident widgets with your own UI stack: WinUI 3 or WPF controls in C#, Qt widgets in Python, or web content in Electron and Tauri.
• Show live information where users can see it at a glance without opening a full window.
• Add compact controls for actions such as timers, media playback, account switching, build status, device monitoring, or quick launch workflows.
• Automatically fit content into the available taskbar space without overlapping pinned apps or the notification area.
• Work on every taskbar position, including the top, left, and right positions available from Windows 11 26H2. Content follows the taskbar when it moves.
• Run multiple instances side by side in the same taskbar area with automatic slot coordination. Each instance gets its fair share of the available space.
• Built-in easing functions (Linear, Sine, Quadratic, Cubic, Quartic, Quintic, Exponential, Circle) for smooth layout animations.
• High refresh rate mode, on by default, matches the layout animation timer to the target monitor's current refresh rate for smoother motion on high refresh rate displays.
• Recover cleanly when Explorer restarts by letting the application rebuild its hosted window. The Qt, Electron, and Tauri controllers rebuild it for you.
• WinUI facade supports Windows App SDK apps and NativeAOT publishing.

Install

Choose the package that matches your language and UI framework.

.NET

# WinUI 3
dotnet add package Deskband11Lib.WinUI

# WPF
dotnet add package Deskband11Lib.Wpf

The Deskband11Lib.Core package is pulled in automatically as a transitive dependency.

Python

pip install deskband11lib

# With PySide6
pip install "deskband11lib[pyside6]"

Node.js and Electron

npm install deskband11lib

Rust and Tauri

# Tauri v2 apps, from the src-tauri folder
cargo add tauri-plugin-deskband11lib --target "cfg(windows)"

# Other Rust apps
cargo add deskband11lib

Basic Usage

WinUI 3

Create a WinUI window, create a TaskbarContentHost, attach it after the initial taskbar layout is ready, then activate the window.

using Deskband11Lib.Core;
using Deskband11Lib.WinUI;

var window = new MainWindow();
var host = new TaskbarContentHost(window, rootElement, new TaskbarContentHostOptions
{
    PreferredWidth = 360,
    PreferredHeight = 48
});

await host.AttachWhenLayoutReadyAsync();
window.Activate();

WPF

The WPF API is identical. The only difference is the UI framework namespace used for Window and FrameworkElement.

using Deskband11Lib.Core;
using Deskband11Lib.Wpf;

var window = new MainWindow();
var host = new TaskbarContentHost(window, rootElement, new TaskbarContentHostOptions
{
    PreferredWidth = 360,
    PreferredHeight = 48
});

await host.AttachWhenLayoutReadyAsync();
window.Show();

Python and Qt

QtTaskbarWidgetController creates your widget through a factory, removes its frame, attaches it to the taskbar, and shows it once it is in place. It works with PySide6 and PyQt6.

import sys

from PySide6.QtWidgets import QApplication, QLabel

from deskband11lib import TaskbarContentHostOptions
from deskband11lib.qt import QtTaskbarWidgetController

application = QApplication(sys.argv)
controller = QtTaskbarWidgetController(lambda: QLabel("Hello"), TaskbarContentHostOptions(preferred_width=360, preferred_height=48))
controller.start()
sys.exit(application.exec())

Windows from other toolkits, such as Tk or wxPython, are hosted by passing their handle to TaskbarContentHost from the same package. See the Python README.

Electron

ElectronTaskbarWindowController creates your BrowserWindow through a factory, attaches it to the taskbar, and creates it again whenever the taskbar requires it. Use it from the main process.

const { app, BrowserWindow } = require('electron');
const { ElectronTaskbarWindowController, createTaskbarWindowOptions } = require('deskband11lib/electron');

app.whenReady().then(() => {
    const controller = new ElectronTaskbarWindowController(() => {
        const window = new BrowserWindow(createTaskbarWindowOptions({ transparent: true, backgroundColor: '#00000000' }));
        window.loadFile('widget.html');
        return window;
    }, { preferredWidth: 360, preferredHeight: 48 });

    controller.start();
});

createTaskbarWindowOptions() adds the window settings a taskbar window needs. For packaging with asar and hosting a window by its handle, see the Node.js README.

Tauri

Register the plugin, then start a TaskbarWindowController from the setup hook. taskbar_window_builder() returns a webview window builder with the settings a taskbar window needs.

use tauri::WebviewUrl;
use tauri_plugin_deskband11lib::{TaskbarContentHostOptions, TaskbarWindowController, taskbar_window_builder};

tauri::Builder::default()
    .plugin(tauri_plugin_deskband11lib::init())
    .setup(|app| {
        TaskbarWindowController::new(app.handle(), |app| {
            taskbar_window_builder(app, "widget", WebviewUrl::App("index.html".into()))
                .transparent(true)
                .build()
        })
        .options(TaskbarContentHostOptions { preferred_width: Some(360.0), preferred_height: Some(48.0), ..Default::default() })
        .start()?;
        Ok(())
    })
    .run(tauri::generate_context!())
    .expect("The application failed to run.");

To include deskband11lib.dll in the installer and to receive taskbar events in the frontend, see the Tauri plugin README. Rust apps without Tauri can host any window by its handle with the deskband11lib crate.

Names in Python, Node.js, and Rust

The rest of this README uses the .NET names. The Python, Node.js, and Rust packages expose the same options and events in the naming style of their language:

Every package can pick one of the built-in easing functions for the layout animation. Only .NET also accepts a custom easing delegate.

Window Recreation

The hosted window can be torn down for a few different reasons: Explorer restarts, the monitor you pinned the widget to gets disconnected, or the system DPI changes. Whatever the cause, the fix is the same: recreate the window and let the new host attach. TaskbarWindowRecreationRequired covers all of them, so one handler is enough for most apps:

host.TaskbarWindowRecreationRequired += async (_, _) =>
{
    await RecreateMainWindowAsync();
};

The Qt, Electron, and Tauri controllers already handle it by destroying the window and calling your window factory again. If you need to tell the cases apart, the individual events below are raised alongside it as well.

Explorer Restart

When Explorer restarts, the taskbar destroys the hosted child window. TaskbarWindowRecreated fires and the window needs to be recreated:

host.TaskbarWindowRecreated += async (_, _) =>
{
    await RecreateMainWindowAsync();
};

DPI Change

When the system DPI changes, the taskbar moves to the new DPI but the hosted window can keep its old one, leaving the widget misaligned. Deskband11Lib polls the taskbar and hosted window DPI values. On mismatch, it hides and detaches the hosted window and raises TaskbarDpiChanged, so the application can rebuild it with the new DPI:

host.TaskbarDpiChanged += async (_, _) =>
{
    await RecreateMainWindowAsync();
};

Secondary Monitor Disconnection

If the monitor you pinned the widget to is disconnected, the taskbar destroys the hosted child window and the library raises TaskbarWindowDisappeared. Recreate the window in that handler, the same way you would for TaskbarWindowRecreated. The new host attaches to the primary taskbar until the preferred monitor is back:

host.TaskbarWindowDisappeared += async (_, _) =>
{
    await RecreateMainWindowAsync();
};

On reconnect, TaskbarWindowRecreated fires again and the recreated window attaches to the secondary taskbar.

Multi-Instance Slot Coordination

Deskband11Lib supports running multiple instances in the same taskbar area simultaneously. When several instances target the same placement area on the same monitor, they automatically coordinate via a shared memory slot registry and divide the available space without overlapping each other.

Slot Allocation

Each registered instance is called a slot. Slots are ordered by (ManualSlotPriority, SlotIndex): lower ManualSlotPriority values place the instance earlier (further from the notification area in left-aligned mode). Among slots with the same ManualSlotPriority, arrival order (SlotIndex) breaks the tie.

Width allocation follows a Fixed-then-Stretch model. Width here is the length along the taskbar, which is the height on a left or right taskbar (see Taskbar Position).

• Fixed slots: instances with a finite PreferredWidth get their requested width, in priority order, until available space runs out. Lower-priority Fixed slots that do not fit receive whatever remains (which may be zero).
• Stretch slots: instances with PreferredWidth = double.MaxValue split the remaining space equally after all Fixed slots are served.

When AllowFixedSlotResize is true (the default) and the available space is too small to serve every resizable Fixed slot at its requested width, those slots shrink proportionally to their PreferredWidth instead of being starved to zero. Non-resizable Fixed slots (AllowFixedSlotResize = false) keep priority-ordered first-served behavior and are served before resizable Fixed slots. Stretch slots always split whatever remains after all Fixed slots are served.

Empty slots leave gaps. The remaining instances do not reflow to fill them.

Manual Slot Priority

By default, all instances have ManualSlotPriority = 65535, which means they are ordered purely by arrival time. Set a lower value to pin an instance ahead of auto-ordered instances:

var host = new TaskbarContentHost(window, rootElement, new TaskbarContentHostOptions
{
    PreferredWidth = 200,
    ManualSlotPriority = 100
});

Stretch Mode

Set PreferredWidth to double.MaxValue to make an instance stretch to fill whatever space remains after Fixed slots are allocated:

var host = new TaskbarContentHost(window, rootElement, new TaskbarContentHostOptions
{
    PreferredWidth = double.MaxValue
});

When all instances in an area are Stretch, they share the space equally.

Taskbar Position

Starting with Windows 11 26H2, the taskbar can sit on any edge of the screen. Deskband11Lib supports all four positions. A top taskbar works the same way as a bottom one. A left or right taskbar is vertical, so content is laid out from top to bottom.

Sizes Follow the Taskbar

PreferredWidth and PreferredHeight keep their names on every taskbar, but they describe directions relative to the taskbar, not to the screen:

Everything built on PreferredWidth follows the same rule. Stretch mode (double.MaxValue), AllowFixedSlotResize, ManualSlotPriority, and multi-instance slot allocation all work along the taskbar, so they need no changes for a vertical taskbar.

Your content element, on the other hand, receives its real on-screen size. On a left or right taskbar, the library sets FrameworkElement.Width to the thickness the content was given and FrameworkElement.Height to the allocated length. With the default options (PreferredWidth = 360, PreferredHeight = 48), content on a 48 epx wide vertical taskbar is 48 epx wide and up to 360 epx tall.

A vertical taskbar becomes much wider when taskbar buttons are never combined and show labels. Content still keeps PreferredHeight across the taskbar. To fill the full thickness on every taskbar, set PreferredHeight = double.MaxValue; on a bottom or top taskbar, the height is still capped by the taskbar.

Free space is usually shorter on a vertical taskbar, because the notification area stacks its icons vertically and takes up a large part of the taskbar. Design the vertical layout for a compact length.

Placement and Alignment

Placement and TaskbarAlignment values keep their names as well, and are read along the taskbar:

Reacting to Position Changes

Moving the taskbar does not recreate the taskbar window, so the hosted window stays attached and the layout follows the taskbar on the next refresh. Use these members to switch your content between a horizontal and a vertical layout:

• TaskbarEdge: the edge the taskbar sits on (Left, Top, Right, or Bottom). It is Unknown until the first layout.
• IsTaskbarVertical: true when the taskbar is on the left or right edge.
• TaskbarEdgeChanged: raised on the UI thread right before the bounds for a new position are applied, including the first layout after attaching.

host.TaskbarEdgeChanged += (_, _) =>
{
    // Switch the content between its horizontal and vertical layouts.
    content.ApplyTaskbarOrientation(host.IsTaskbarVertical);
};

ApplyTaskbarOrientation stands for a method in your own content. The sample projects implement it by keeping one horizontal and one vertical layout and toggling their visibility.

Layout animation is skipped when the taskbar switches between horizontal and vertical.

How It Works

Deskband11Lib gives your app a taskbar-sized surface and keeps that surface aligned with the real taskbar layout. Internally, it uses regular Win32 window parenting:

• Finds the primary taskbar window, Shell_TrayWnd, or a secondary monitor's taskbar window, Shell_SecondaryTrayWnd, based on PreferredMonitorIdentity.
• Creates or receives a normal framework Window from the application.
• Changes the window style from popup-style top-level window to child window.
• Calls SetParent to place the window under the taskbar.
• Detects which screen edge the taskbar sits on by comparing the taskbar window with its monitor.
• Calculates the available space along the taskbar between the taskbar buttons and the notification area, taking taskbar alignment (left or top, or center) into account.
• Moves and clips the hosted window to that rectangle with SetWindowPos and SetWindowRgn.

On current Windows 11 builds, the taskbar child HWND hierarchy alone does not expose reliable button widths, and the taskbar content may be left-aligned or centered. Deskband11Lib solves this with UI Automation:

• Button detection. UI Automation precisely targets the Start button (AutomationId = StartButton), the optional Widgets button, and the contiguous taskbar app button group.
• Alignment detection. The library reads the TaskbarAl registry value and falls back to inferring alignment from the Start button position.
• Gap selection. When centered, it picks the more spacious of the two free gaps around the Start button group, so content never overlaps the Start button, app buttons, Widgets button, or the notification area.
• Secondary monitors. Where the notification area has no dedicated HWND, UI Automation also locates the clock and notification cluster (AutomationId = SystemTrayIcon / NotifyItemIcon) to find where the free space ends.

Options

All options live in Deskband11Lib.Core.TaskbarContentHostOptions and are shared across all facades. The Python, Node.js, and Rust packages take the same options under the names described in Names in Python, Node.js, and Rust.

Taskbar Alignment

Deskband11Lib detects whether the Windows 11 taskbar is left-aligned or centered by reading the TaskbarAl registry value, falling back to inferring the alignment from the Start button position. Call GetTaskbarAlignment() on a TaskbarContentHost to get a TaskbarAlignment (Left, Center, or Unknown). The detected alignment drives Placement = Auto. On a left or right taskbar, Left means the icons are aligned to the top.

Built-in Easing Functions

Deskband11Lib.Core.EasingFunctions provides these easing functions for LayoutAnimationEasing:

• EasingFunctions.Linear
• EasingFunctions.SineIn / SineOut / SineInOut
• EasingFunctions.QuadraticIn / QuadraticOut / QuadraticInOut
• EasingFunctions.CubicIn / CubicOut / CubicInOut
• EasingFunctions.QuarticIn / QuarticOut / QuarticInOut
• EasingFunctions.QuinticIn / QuinticOut / QuinticInOut
• EasingFunctions.ExponentialIn / ExponentialOut / ExponentialInOut
• EasingFunctions.CircleIn / CircleOut / CircleInOut

You can also pass any Func<double, double> delegate for custom easing.

Sample Projects

The snippets above show the core API shape, but a real taskbar companion should follow the sample projects for window lifetime, startup ordering, Explorer restart recovery, and framework-specific hosting details. Start from the sample that matches your UI stack:

• Deskband11Lib.WinUI.Sample for WinUI 3 and Windows App SDK apps.
• Deskband11Lib.Wpf.Sample for WPF apps, including the transparent borderless host window setup.
• bindings/python/samples/pyside6_clock.py for PySide6.
• bindings/node/samples/electron-clock for Electron.
• bindings/rust/samples/tauri-clock for Tauri.

The Python, Electron, and Tauri samples are clocks that follow the taskbar theme and switch between horizontal and vertical layouts.

Requirements

• Windows 11.
• .NET packages: .NET 10. The packages target net10.0-windows10.0.26100.0. WinUI 3 requires the Windows App SDK, and WPF requires UseWPF=true in the project file.
• Python package: Python 3.10 or later, x64 or ARM64.
• Node.js package: Node.js 22 or later, x64 or ARM64. In Electron, use the package from the main process.
• Rust crates: Rust 1.90 or later, x64 or ARM64. The Tauri plugin requires Tauri 2.12 or later.

Project Development

dotnet restore
dotnet build Deskband11Lib.slnx -c Debug
dotnet publish Deskband11Lib.WinUI.Sample\Deskband11Lib.WinUI.Sample.csproj -c Release -r win-x64

The Python, Node.js, and Rust packages live in bindings/ and load the native library built from Deskband11Lib.Native. Each package README describes how to build that library and run the tests.

Acknowledgements

Special thanks to zadjii and Deskband11. The core idea of bringing application content into the Windows 11 taskbar comes from that project, which inspired Deskband11Lib.

Deskband11Lib is supported by the FOSS for All Microgrants 2026 program. Thanks to FOSS for All and every donor who helps sustain the free and open source ecosystem.

License

Deskband11Lib is licensed under the MIT License.

Author

Created by Howon Lee (airtaxi).