DockHub 1.0

The Modern Glassy Dock for Windows & macOS

Start menu, running apps, system status, and 30+ live interactive widgets in one unified floating dock.
Zero administrator privileges required. 100% native architecture on both platforms.

Download Windows (.exe)  ·  Download macOS (.dmg)  ·  Live Interactive Demo  ·  Features  ·  Widgets  ·  Build from Source

• Highlights
• Screenshots
• Installation
• Features
• Widgets
• How the taskbar replacement works
• Build from source
• Command line
• Configuration and data
• Permissions and privacy
• Project structure
• Web widgets (SDK 1.0)
• Writing a native widget
• Performance
• Known limitations
• FAQ
• Contributing
• License and credits

• Replaces the taskbar, keeps Windows intact. The Start button opens the real Windows Start menu, and the Windows key, search, notification center and quick settings work exactly as before.
• 32 widgets, many layouts each. Clocks, timers, reminders, your calendar, a to-do list with Todoist, clipboard history, a Downloads stack, exchange rates, stocks, sticky notes, screenshots, now playing, audio, brightness, Wi-Fi and Bluetooth, power mode, Do Not Disturb, CPU, GPU and network monitors, ping, AI usage (Claude Code, Codex, Gemini CLI) and weather. Add the same widget as many times as you like; every copy keeps its own settings.
• Every battery at a glance. Bluetooth headsets, mice, keyboards and controllers, Xbox and PlayStation controllers, and Logitech, Razer, HyperX, SteelSeries and LAMZU receivers, with a warning before one runs flat.
• Build your own widgets. Web widgets in HTML and JavaScript install from a .dockwidget file, a link or the community list in the gallery.
• Live app buttons. Hover for a real window thumbnail, right-click for a Jump List, watch badge counts and progress, and drag apps together into a folder.
• Fluent to the core. Blurred glass, Acrylic or solid backgrounds, light and dark themes, and your Windows accent color. Popups, folders and widgets animate with macOS-inspired genie, zoom and fan effects, all at your display's refresh rate.
• Any edge, any shape. Bottom, top, left or right; floating or attached; small, medium or large. On vertical docks, widgets collapse into compact tiles.
• Safe by design. No admin rights. When DockHub exits, crashes, or the session ends, the Windows taskbar and its tray icons come back. After a crash Windows starts DockHub again, and the next start tells you what happened.
• Starts with Windows. The installer enables autostart by default, and you can turn it off at any time.
• In your language. English, Turkish, German and Spanish.
• Keyboard first. Win+1…9 open and switch dock apps like on the Windows taskbar, a Spotlight-style quick launcher (Win+Alt+Space) finds apps, settings and commands, and every DockHub action can get its own global shortcut.

Folders. Drag items together, then click to fan them out. Rename and recolor from the popup.	Live window previews. Hover a running app for a real thumbnail with a close button.
Jump Lists. Right-click an app for its recent items and tasks.	Widget panels. Click any widget for the full view.
Start menu. The real Windows Start menu, opened from the dock.	Light theme, vertical dock. Widgets become compact tiles.
Widget gallery. Live previews; press + and the widget grows into the dock.	Settings. A Mica window for every option.
Pin from File Explorer. Right-click any .exe or shortcut.	Dock menu. Right-click empty space for widgets, groups and position.

1. Download DockHub-Setup-1.0.0-x64.exe from the latest release (-arm64.exe for Windows 11 on Snapdragon / ARM laptops).
2. Run the setup executable. DockHub installs purely into the user profile without requiring administrator privileges.
3. Keep "Start DockHub automatically when I sign in to Windows" enabled (the default) to have your dock ready on boot.

The installer bundles the .NET 10 runtime, making it 100% self-contained. Fully localized in English, Turkish, German, and Spanish.

winget install SametGurtuna.DockHub

Uninstalling: Removing DockHub via Windows Settings › Installed apps cleanly restores the standard Windows taskbar, unregisters the shell context menu verbs, and cleans up autostart entries while safely preserving your configuration in %AppData%\DockHub.

1. Download DockHub-1.0.0.dmg from the latest release.
2. Open the .dmg disk image and drag DockHub.app to your /Applications folder.
3. Launch DockHub from Applications or Spotlight. DockHub can run as a floating companion or automatically conceal the native macOS Dock (Settings › General) while active.

• Start button opens the Windows Start menu (IImmersiveLauncher); a second click closes it. Right-click opens the Win+X menu.

• The Windows key works as usual. Start, search, the notification center and quick settings open in Windows' own panels.

• Search and Task View buttons, each of which can be toggled. The search button can open Windows Search or DockHub's quick launcher (Settings › Taskbar › Search button opens).

• Quick launcher (Win+Alt+Space, or the search button): type to find apps, open windows, DockHub and Windows settings pages, dock commands (auto-hide, mute, lock, new virtual desktop, switch profile...), recent files, quick math (200*15%, sqrt(2)) and a web search. Enter opens the first result, arrow keys move, Esc closes.

  • Files: files and folders in your user folder, by name or content, from the Windows Search index (AppData is left out). Enter opens one, Ctrl+Enter shows it in its folder. Turn it off in Settings › Taskbar › Files in the quick launcher; nothing is searched while Windows Search is turned off.
  • Units: 10 km to mi, 20 c in f, 5 GB in MB, also in Turkish, German and Spanish (10 km kaç mil, 10 km in Meilen, 10 km a millas). Length, weight, temperature, volume, speed and data sizes; Enter copies the result.
  • Currencies: 100 usd to try, 50 € in $, 0.5 btc to eur, at the same rates as the Exchange rates widget (ECB, CoinGecko for coins).
  • Emoji: type : and a name, :heart or :kalp, in your language or English; Enter copies the emoji.

• Virtual desktops. A number next to Task View shows which desktop you are on; scroll it to switch desktops, right-click to add or close one. Apps from all desktops lists windows of every desktop on the dock, and clicking one switches to its desktop.

• Running apps

  • Pinned apps are matched with their open windows, and windows of the same app are grouped into one button.
  • Other open apps are listed after a separator.
  • Active, attention-requesting and progress states (for example, download bars) are shown, along with taskbar-style badge counts.
  • Hovering a button shows a live thumbnail preview of its window(s), like the Windows taskbar. Resting the pointer on a thumbnail peeks at that window (Aero Peek), scrolling over the preview cycles through the app's windows, and apps that play media get a play/pause button in the preview.
  • Starting an app bounces its icon until the first window appears.
  • Right-click shows the window list, the app's Jump List (recent files and tasks, when the app provides one), plus Run as administrator, Open file location, Pin/Unpin and Close all windows.
  • Clicking brings a window to the front, minimizes it, or cycles through the app's windows. Shift+click or middle-click opens a new window.
  • Pin a running app by dragging it into the dock or with the Pin to DockHub command.
  • One button per window: set Settings › Taskbar › Combine app buttons to Never, like Windows' "Combine taskbar buttons: Never". Every window then gets a button of its own with its icon and title (just the icon on a side dock), and an app's windows stay side by side: a pinned app's button becomes its first window's, and its other windows follow right after it. Clicking a window's button brings that window forward or minimizes it, middle-click closes it, and its preview shows that window only. The icons don't grow under the pointer in this mode.
  • Pin from File Explorer: right-click an .exe or shortcut and choose Pin to DockHub. On Windows 11 the command appears under Show more options (or Shift+right-click), because the new compact menu only lists commands from packaged apps.
  • Groups (folders): drag an app or widget onto another to create a folder. Folders can be renamed, given a custom accent color, and open with a staggered fan animation.

• System tray. App icons live in the dock and receive clicks, right-clicks and hover. Hidden icons sit in the overflow menu, and you choose which icons are always visible. Your Windows tray preferences are imported on first launch.

• Network, volume and battery icons. DockHub draws its own status icons next to the tray (Windows 11 keeps its real ones inside Explorer). Scroll the volume icon to change the volume, middle-click to mute, right-click to switch the output device; the battery icon only appears on devices with a battery.

• Input language. With more than one keyboard language installed, a short code (TUR, ENG...) sits next to the tray. Click or scroll it to switch, right-click for the list and language settings.

• Microphone. A microphone icon appears while an app records (like Windows), or always if you prefer; click it to mute or unmute, and give it a global shortcut. It lists which apps use the microphone.

• Notifications and Do Not Disturb. The clock shows how many notifications wait in the notification center, and a moon while Do Not Disturb or Focus is on.

• Win+1…9 and Win+0 open, switch to or minimize the dock's first ten apps. Add Shift for a new window, Ctrl+Shift to run as administrator, Alt for the jump list. Hold Win to see the numbers on the dock. With one button per window, the numbers follow the buttons, so each window has its own number.

  

• Clock. Clicking it opens the notification center. Its context menu offers quick settings, date and time settings, and seconds and date options. A thin strip at the far end shows the desktop.

• Reserved screen space. Like the Windows taskbar, the dock keeps its band of the screen to itself: maximized windows stop at the dock instead of sliding under it, at any display scaling and on every display that has a dock.

• Look: blurred glass, Acrylic, transparent or solid background with adjustable tint; dark, light or system theme; Windows accent color.
• Size: small (48 DIP, the same height as the Windows taskbar), medium (56 DIP) or large (66 DIP).
• Shape: floating (inset from the screen edges with rounded corners) or attached (a classic taskbar).
• Width and alignment: full width or fit to content; items centered or aligned to the start.
• Position: bottom, top, left or right. On vertical docks, widgets become compact tiles showing an icon or ring with a short value. Clicking a tile opens the full widget in a side panel, and timers, the water tracker and reminders run their main action directly.
• Scrolling: when items don't fit, the edge where more items wait fades out. The mouse wheel or touchpad scrolls smoothly and stops where an item begins, so nothing at the leading edge is cut in half; an item you drag to a faded edge scrolls the dock that way.
• Auto-hide: the dock slides off the edge and returns when the pointer reaches it. With Only hide when a window overlaps, it stays up over the desktop and small windows and slides away only while the active window covers it.
• Profiles: save your setup as a profile (Work, Gaming, Laptop...) with its own items and look, switch from the dock menu or a shortcut, or let a profile switch in by itself: when a given number of displays is connected, while an app runs (for example steam or cs2), or during set hours (weekdays only if you like). When the app closes or the hours end, DockHub goes back to the profile you had. Rules live in Settings › Profiles.
• Open app indicator: a line that widens for the active app and several windows, one dot per window, or none.
• Hide in full screen: the dock steps aside for games, videos and F11 mode.
• Top bar: a second, thin bar on the main display for widgets and a clock, like the menu bar on a Mac, for example widgets on top and apps below. Turn it on in Settings › Appearance › Top bar (or on the Overview), then move widgets there from their right-click menu (Show on › Top bar), by dragging them over in edit mode or from the gallery, or in Settings › Dock items. It has its own edge (never the dock's), size, shape, backdrop, auto-hide and clock, reserves its own screen space, and steps aside in full screen like the dock. Turning it off brings its widgets back to the dock. Profiles keep the bar; presets and theme files leave it alone.
• Multi-monitor and DPI: choose the monitor for the dock; per-monitor DPI (PerMonitorV2) is supported. With Show on all displays, every other display gets a dock too, with its own size; move a widget to one of them from its right-click menu (Show on) or in Settings › Dock items.
• Drag and drop: reorder apps, widgets and separators on the dock. Dropping an .exe or .lnk from File Explorer pins it.
• Edit mode: right-click an empty area of the dock (or any widget) and choose Edit dock, press the Edit the dock shortcut, or use Settings › Dock items › Edit on the dock. The items wiggle; drag them to reorder, press × to remove one, and drag the handle on a widget's edge to switch it to a narrower or wider layout. The + tile at the end adds a widget, a separator or an app. Press Done, Esc or Enter, or click outside DockHub (or on another dock) to finish. Everything you changed is one step that Undo reverts; leaving without a change leaves no step behind. With the keyboard, the arrow keys move the focus, Ctrl+arrow keys move the item, Delete removes it and + or - resize it. Start, search, the tray and the clock stay put, and with reduced motion the items don't wiggle.
• Smooth motion: scrolling, auto-hide and flyouts use frame-synchronized transitions at your display's refresh rate, including above 60 Hz. Hover highlights fade in, app icons grow slightly under the pointer, new items grow into place, and widget/folder popups open with macOS-style genie, zoom and shrink animations.
• Accessibility: Settings › Appearance › Animations reduces motion to short fades (or turns it off), following Windows' animation effects by default. Windows contrast themes are picked up automatically. Screen readers get names and states for every dock item, and Move focus to the dock (Win+Alt+T) lets you use the dock with the arrow keys, Enter, Shift+Enter (new window), the menu key and Esc.
• Global shortcuts: show the dock (Ctrl+Alt+D by default), open the quick launcher (Win+Alt+Space), open settings, edit the dock, pin an app, toggle auto-hide, mute the sound or the microphone, change the volume, switch profile, all configurable in Settings › Keyboard shortcuts. Shortcuts another app already uses are flagged there.
• Text size: Settings › Appearance › Text size scales the text of settings, widget panels and menus (System follows Windows' text size).
• Widget style: Cards puts every widget on a card of its own; Seamless sets widgets right on the dock with a thin line between two of them (sticky notes and the water tracker keep a fainter color). Settings › Appearance › Widget style; theme files, saved presets and profiles keep it.
• Even widget widths: widget cards round their width up to a common grid and are at least a tile, a standard card or a wide card wide, depending on the layout, so the dock keeps an even rhythm. The widget sits centered in its card; nothing is cut off (on by default, Settings › Appearance).
• Theme files: Settings › Appearance › Theme file exports your dock's look (colors, glass, size, shape) to a .dockhub-theme file that anyone can import. Save current layout as a preset keeps your look and widgets as a preset you can apply again later. Presets and themes never move the dock: the screen edge stays where you put it.
• Menus: context menus and widget panels always open outside the dock, next to the pointer or the item.
• Settings window: a grouped menu (Dock, Widgets, System, About) that opens on an Overview: a live preview of your dock, the settings you change most (theme, backdrop, size, edge, widget style), shortcuts to add a widget, edit the dock, undo or switch profile, and the state of updates, backups and profiles. Ctrl+F searches every setting and widget.
• Dock menu (right-click an empty area): Undo, Edit dock, Add widget, Pin app, Add separator, Task Manager, Quick settings, Auto-hide, Hide Windows taskbar, Position, Settings, Exit.

Every widget can be added more than once, and each copy has its own settings. Change a widget's layout from its right-click Layout menu or in Settings › Dock items.

To add a widget, open Settings › Widget gallery and press Add on its card or drag the card onto the dock (to a spot between items, into a folder, or onto the tray area to pin it to the right edge). Each widget has one card with its layouts to pick from, its width and how many are already on the dock; search by name in any language or filter by category. You can also right-click an empty area of the dock and choose Add widget, or press the + tile in edit mode. Right-clicking a widget on the dock gives it its own actions, layouts and settings.

No administrator rights are needed. DockHub runs asInvoker. Running it elevated is not recommended, because File Explorer cannot drag and drop into an elevated window (UIPI). Explorer is never closed; DockHub runs alongside it.

With Settings › General › Replace the taskbar set to DockHub (the default):

1. ManagedShell's task service tracks open windows, and its tray service takes over Shell_TrayWnd notifications so apps register their tray icons with the dock.
2. Explorer's "taskman" window is handed back, so the Windows key keeps opening Start.
3. The Windows taskbar state (ABM_GETSTATE) is written to %AppData%\DockHub\session.json. The taskbar is then switched to auto-hide and the Shell_TrayWnd / Shell_SecondaryTrayWnd windows are hidden.
4. A lightweight watcher running every 250 ms hides the Explorer taskbar again if it reappears on its own. It stays out of the way while Start, search or a shell menu is open.
5. An invisible, click-through AppBar reserves the dock's thickness at the screen edge, sized with the DPI of the dock's display. It registers again when Explorer restarts, and if Windows still leaves the dock's band in the work area, DockHub trims the work area itself (and undoes that when it exits).

In Both mode, the Windows taskbar is left untouched and the tray is not taken over; the dock sits above the taskbar. Switching modes restarts the app.

The taskbar is restored automatically when:

• the mode is switched to Both,
• DockHub exits normally (dock menu, tray menu, --exit),
• the Windows session ends (SessionEnding),
• an unhandled error occurs (UnhandledException / ProcessExit),
• DockHub is uninstalled.

If DockHub is killed (Task Manager, power loss), the taskbar stays in auto-hide mode and still appears when the pointer reaches the bottom edge. On the next launch, or with --restore-taskbar, session.json is read and the original state is restored. A TaskbarCreated broadcast makes apps register their tray icons with Explorer again.

In an emergency, use any of these:

DockHub.exe --restore-taskbar

• Settings › General › Restore the Windows taskbar
• Tray menu › Restore taskbar
• Last resort: restart explorer.exe and turn off Settings › Personalization › Taskbar › Automatically hide the taskbar in Windows.

• Windows starts it again. DockHub asks Windows Error Reporting to restart it after a crash or a hang. Windows only does this for a process that has run for at least a minute, and never after an update or a restart of the PC.
• No endless loop. If Windows has to restart DockHub a third time within 10 minutes, DockHub stops instead, gives the taskbar back and turns the automatic restart off (a notification says so). Starting DockHub yourself still works; turn the restart back on in Settings › Backup and troubleshooting. Ending DockHub in Task Manager does not count as a crash here.
• You hear about it. When the previous session did not end cleanly (a crash, or ending it in Task Manager), the next start shows a notification with Report a problem and Open log. A PC that restarted in the meantime (shutdown, power loss) is not reported.
• The report says where, nothing personal. DockHub reads what Windows recorded in the Application event log: the faulting module, exception code and offset, the .NET exception type and the first stack frames. Exception messages, file paths and window titles are left out. Report a problem adds this to the bug report, and Settings › About › Last crash shows it.

• Windows 10 1809 or later (x64 or ARM64)
• .NET 10 SDK or newer
• Optional: Inno Setup 6 to build the installer (winget install JRSoftware.InnoSetup)

NuGet dependencies are restored automatically:

• ManagedShell 0.0.372: task list, system tray, AppBar and full screen detection (Apache-2.0)
• Microsoft.Toolkit.Uwp.Notifications 7.1.3: toast notifications (MIT)

git clone https://github.com/sametgurtuna/DockHub.git
cd DockHub
dotnet build CustomDock.sln -c Release
dotnet run --project src/CustomDock -c Release

You can also open CustomDock.sln in Visual Studio 2026 and press F5.

dotnet test CustomDock.sln

The unit tests (tests/CustomDock.Tests) cover config loading and migration, dock item operations, app matching and pin repair, and parsing. They use a throwaway DOCKHUB_HOME, so your own settings are never touched.

dotnet publish src/CustomDock -c Release -r win-x64 --self-contained false -o publish

publish\DockHub.exe runs as is. Use --self-contained true to bundle the .NET runtime.

pwsh installer/build.ps1                     # x64
pwsh installer/build.ps1 -Runtime win-arm64  # ARM64

The script publishes a self-contained ReadyToRun build to artifacts/publish/win-x64 (or win-arm64) and compiles installer/DockHub.iss into installer/Output/DockHub-Setup-<version>-x64.exe (or -arm64.exe). The version comes from src/CustomDock/CustomDock.csproj.

• macOS 15.0 Sequoia or newer
• Xcode 16.0+ or Command Line Tools with Swift 6.0+

cd macos
swift build -c release
.build/release/DockHub

cd macos
swift test

The macOS test suite (macos/Tests/DockHubCoreTests) runs 88 tests covering cross-platform config.json serialization, widget data models, SDK 1.0 bridge validation, and dock editing commands with full Swift 6 strict concurrency checks.

cd macos
./Scripts/package-dmg.sh release

This compiles the release binary, creates the standalone DockHub.app bundle, sets up the volume styling and /Applications symlink, and generates DockHub-1.0.0.dmg.

The DOCKHUB_HOME environment variable changes the settings and data folder, which is useful for portable use or testing, for example set DOCKHUB_HOME=D:\DockTest.

• Files are written to a temporary file first and then moved into place, so an interrupted write never corrupts them.
• A corrupt config.json is backed up as config.json.corrupt-<date> and DockHub loads the newest daily backup (and tells you); only without one does it start with defaults.
• Settings › Backup and troubleshooting exports everything (dock, widgets, notes, reminders) to a .zip and imports it again.
• Sync between PCs: in Settings › Backup and troubleshooting, choose a folder that syncs itself between your PCs (OneDrive, Dropbox, a network share). DockHub writes DockHub-sync.json there two seconds after you change something and takes the file when another PC wrote a newer one; the last change wins, and taking another PC's settings is one step that Undo reverts. Shared: the look, dock items and widget settings, profiles, presets and shortcuts. Kept on each PC: the display the dock is on and display sizes, the tray, starting with Windows, how the taskbar is replaced, the language, and which display each widget is on. Saved tokens (such as Todoist's, stored encrypted) are never written to the folder. Notes, reminders and other widget data aren't synced. It is off by default, and nothing is written anywhere while it is off.
• Removing items, deleting folders and applying a layout preset can be undone for a few seconds from the toast next to the dock, from the dock's right-click menu, or with Ctrl+Z in Settings.
• Settings from the project's previous name (%AppData%\CustomDock, CUSTOMDOCK_HOME) are migrated automatically on first launch.
• Version 1 config.json files are upgraded to version 2 automatically.

{
  "version": 2,
  "taskbarMode": "Replace",
  "hideOnFullscreen": true,
  "startWithWindows": true,
  "showStartButton": true,
  "showSearchButton": true,
  "showRunningApps": true,
  "showTray": true,
  "pinnedTrayIcons": ["c:\\program files\\spotify\\spotify.exe"],
  "edge": "Bottom",
  "autoHide": false,
  "theme": "Dark",
  "backdrop": "Blur",
  "tintOpacity": 0.35,
  "size": "Small",
  "layout": "Floating",
  "widthMode": "Full",
  "alignment": "Center",
  "edgeMargin": 6,
  "items": [
    { "id": "e0e4424de2", "kind": "App", "path": "C:\\WINDOWS\\explorer.exe" },
    { "id": "d09f6ec024", "kind": "Separator" },
    { "id": "521927ad3f", "kind": "Widget", "widget": "clock", "variant": "analog",
      "settings": { "use24Hour": true, "showSeconds": false, "dateFormat": "Short" } },
    { "id": "2f50f40ec4", "kind": "Widget", "widget": "weather", "variant": "hourly",
      "settings": { "locationMode": "City", "cityName": "Istanbul", "latitude": 41.0138, "longitude": 28.9497 } }
  ]
}

• File Explorer command. Pin to DockHub is registered under HKCU\Software\Classes\exefile\shell and lnkfile\shell. No admin rights are needed, turning the setting off removes the keys, and the path is updated if the app moves.
• Autostart. HKCU\Software\Microsoft\Windows\CurrentVersion\Run\DockHub, toggled from Settings › General.
• Location (weather set to Automatic). Both location services and Let desktop apps access your location must be on in Windows Settings › Privacy & security › Location. Otherwise the widget asks for a city.
• Notifications. No extra permission. The app registers its AUMID under HKCU on first use. With Do not disturb on, notifications collect in the notification center; if a toast cannot be shown, a tray balloon is used instead.
• Media (SMTC). No permission or account. The player only needs to support Windows media controls.
• Microphone indicator. DockHub reads which apps use the microphone from the same Windows privacy records as the Windows microphone icon; it never opens the microphone itself.
• Notification count. Read from the Windows notification database of your account (read-only), only while the option is on.
• Wi-Fi and Bluetooth widget. Uses the Windows radio API; if Windows doesn't allow it, the buttons open the matching Settings page instead.
• Network. DockHub itself only contacts api.open-meteo.com (weather), geocoding-api.open-meteo.com (city search), api.frankfurter.dev and, for crypto symbols, api.coingecko.com (only with the Exchange rates widget, or when you convert a currency in the quick launcher), stooq.com (only with the Stocks widget), the server the Ping widget pings (1.1.1.1 unless you choose another), the calendar links you enter (Calendar widget) and, once a day unless you turn it off, api.github.com to look for a newer release. The AI usage widget, if you add it, runs your locally installed Claude CLI (claude -p /usage) at the interval you choose, and that CLI talks to Anthropic with your own login; for Codex and Gemini CLI it only reads the logs those tools keep in your user folder (~/.codex/sessions, ~/.gemini/tmp). The To do widget talks to api.todoist.com only when you set it to Todoist, installing a web widget from a link downloads it from that link, and while Settings › Widget gallery is open DockHub fetches the community widget list from raw.githubusercontent.com (at most once a day). Web widgets reach only the hosts they declare, or a server address you enter in their settings. There is no telemetry.

CustomDock.sln                   Visual Studio solution for Windows .NET 10 build
installer/
├── DockHub.iss                  Inno Setup script (per-user install, autostart, clean uninstall)
└── build.ps1                    Publishes the app and compiles the installer
macos/                           Native macOS 15 Sequoia AppKit & SwiftUI implementation (Swift 6)
├── Package.swift                Swift Package Manager definition (DockHubCore, DockHubApp, tests)
├── Sources/
│   ├── DockHub/                 Application entry point (main.swift, AppDelegate, AppState, DockConcealer)
│   └── DockHubCore/             Business logic, Config, Native bridge, Services, Widgets, Web host
├── Tests/
│   ├── DockHubCoreTests/        Unit & integration test suites (88 tests covering config, widgets, SDK)
│   └── DockHubAppTests/         App lifecycle tests
└── Scripts/
    └── package-dmg.sh           DMG packaging automation script
src/CustomDock/                  Produces DockHub.exe (Windows WPF / Win32)
├── App.xaml(.cs)                Entry point: single instance, --exit / --restore-taskbar, crash safety, shell and dock setup
├── app.manifest                 PerMonitorV2 DPI, asInvoker
├── Assets/DockHub.ico           App and tray icon (generated by tools/generate-icon.ps1)
├── Core/                        AppConfig (v2 item model), ConfigService (v1 to v2 migration), JSON storage, theme, log
├── Native/                      P/Invoke, DWM and glass effects, monitors, high resolution shell icons
├── Shell/                       ManagedShell integration
│   ├── ShellHost.cs             Tasks, tray, Start, search and notification center commands
│   ├── TaskbarController.cs     Hiding and restoring the Windows taskbar, crash recovery
│   ├── StartMenuLauncher.cs     Start menu through IImmersiveLauncher
│   ├── RunningAppsService.cs    Grouping windows by app
│   ├── JumpListService.cs       Reads an app's Jump List (recent/pinned tasks) for the right-click menu
│   └── AppKeys.cs, TrayPreferences.cs, DefaultItems.cs
├── Services/                    Clock, system, GPU and network monitors, media (SMTC), weather (with WeatherHub cache),
│                                notifications, reminders, hydration, app launcher, keyboard layouts, microphone,
│                                notification center, virtual desktops, brightness, radios, AI usage, Todoist,
│                                Battery/ (device batteries: Bluetooth, HID protocols, device catalog)
├── Dock/                        DockWindow (zones, scrolling, drag and drop, position, auto-hide), AppButton,
│                                WidgetItemView (card, vertical tile and panel), GroupItemView (folders),
│                                WindowPreviewWindow (live thumbnails), GenieEffectHelper, PopupAnimationHelper,
│                                TrayIconView, SpaceReserver, EdgeTriggerWindow, TrayIconManager, LauncherWindow
│                                (quick launcher), keyboard language, microphone and virtual desktop indicators
├── Controls/                    WidgetCard, DockZonesPanel, RingGauge, AnalogClock, WeatherIcon, TickBar, Sparkline,
│                                Glyphs, SettingRow
├── Settings/                    Settings window (Mica), widget gallery, app picker, widget settings templates
├── Themes/                      Dark.xaml, Light.xaml (colors), Controls.xaml (styles)
└── Widgets/                     WidgetBase, WidgetRegistry, CompactTile and one folder per widget
    ├── Clock/  WorldClock/  Timers/ (stopwatch, focus, countdown, alarm)  TimeProgress/
    ├── Hydration/  Reminders/  Notes/  Media/  Audio/
    ├── System/ (CPU and memory, network, status)  Gpu/  Display/ (brightness)  Radios/  RecycleBin/  BatteryDevices/
    ├── Calendar/  Clipboard/  Stack/  Currency/  Todo/  Screenshot/
    └── AI/ (AI usage)  Weather/  Web/ (HTML/JavaScript widgets, link installs)
packaging/winget/                winget manifest templates (submitted by .github/workflows/winget.yml)
packaging/signing/               Optional code signing of releases (Azure Artifact Signing) and how to set it up
samples/widgets/                 Web widget examples (hello-world, github-stars, github-pulls, github-actions, home-assistant)
                                 and index.json, the community list shown in the gallery
sdk/                             Widget SDK: TypeScript types (types/dockhub.d.ts) and the samples' type check
tools/dockhub-widget/            Widget developer tool: create, validate and pack (Node.js, no dependencies)
tools/generate-icon.ps1          Renders Assets/DockHub.ico
tools/measure-idle.ps1           Idle CPU, memory and start-up measurement
docs/                            Widget SDK and supported battery devices; images/ holds the README artwork

Anyone can build a widget with HTML, CSS and JavaScript, no C# or Swift needed. Web widgets run in Microsoft Edge WebView2 on Windows and WKWebView on macOS, follow the dock theme, and use a small window.dockhub API for settings, storage, notifications and their right-click menu. Each widget only reaches the internet hosts its manifest lists, and users see those permissions before installing a .dockwidget package (open the file, or use Settings › Widget gallery › Install widget…) or a link (a manifest.json, a .dockwidget file or a GitHub folder) with Install from link…. The gallery also lists community widgets from a list kept in this repository (GitHub pull requests, GitHub Actions, Home Assistant and more) that install with one click; anyone can add one with a pull request.

With "debugLogging": true, a widget reloads by itself whenever you save one of its files. See the widget SDK guide and the examples in samples/widgets.

• SDK 1.0. The API (apiVersion 2) and the manifest format are stable: nothing is removed within DockHub 1.x, and anything deprecated keeps working for at least one more major version.
• TypeScript types in sdk/types/dockhub.d.ts give completion and type checks, even in plain JavaScript with // @ts-check.
• Developer tool: tools/dockhub-widget (Node.js, no dependencies) creates a widget from a template, checks it the way DockHub does and packs it into a .dockwidget.
• Updates: widgets installed from a manifest.json or GitHub folder link are checked for a newer version once a day. DockHub shows a notification and an Update button in the gallery, keeps the widget's settings and data, and asks first when the new version wants more permissions.

1. Add Widgets/Sample/SampleWidget.xaml. The root element must be w:WidgetBase. Use elements named Layout_<variant> for different layouts:

   <w:WidgetBase x:Class="CustomDock.Widgets.SampleWidget"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:w="clr-namespace:CustomDock.Widgets">
       <Grid>
           <TextBlock x:Name="Layout_big" Style="{StaticResource ValueText}" VerticalAlignment="Center" />
           <TextBlock x:Name="Layout_small" Style="{StaticResource TitleText}" VerticalAlignment="Center" />
       </Grid>
   </w:WidgetBase>

2. Implement the lifecycle in code-behind. Subscribe to services in OnAttached, unsubscribe in OnDetached, and fill in UpdateCompact for vertical docks:

   public sealed class SampleSettings : ObservableObject
   {
       private string _text = "Hello";
       public string Text { get => _text; set => Set(ref _text, value); }
   }
   
   public partial class SampleWidget : WidgetBase
   {
       private SampleSettings _settings = new();
   
       public SampleWidget() => InitializeComponent();
   
       protected override void OnAttached()
       {
           _settings = GetSettings<SampleSettings>();     // per-item settings in config.json, saved on change
           _settings.PropertyChanged += (_, _) => Render();
           AppServices.Clock.MinuteTick += OnTick;       // shared, aligned timer
       }
   
       protected override void OnDetached() => AppServices.Clock.MinuteTick -= OnTick;
   
       protected override void OnVariantChanged()        // on first attach and whenever the layout changes
       {
           ShowLayout(Layout_big, Layout_small);
           Render();
       }
   
       private void OnTick(object? s, DateTime now) => Render();
   
       private void Render()
       {
           Layout_big.Text = Layout_small.Text = _settings.Text;
           RefreshCompact();                             // keep the vertical tile in sync
       }
   
       protected override void UpdateCompact(CompactTile tile)
       {
           tile.ShowGlyph(Descriptor.Icon, Descriptor.AccentKey);
           tile.Text = _settings.Text[..Math.Min(4, _settings.Text.Length)];
       }
   }

3. Register the widget in Widgets/WidgetRegistry.cs:

   new()
   {
       Id = "sample", Name = "Sample", Category = WidgetCategories.Notes, Description = "...",
       IconPath = "M4,4 H20 V20 H4 Z", AccentKey = "AccentGreenBrush",
       Variants = new[] { new WidgetVariant("big", "Big"), new WidgetVariant("small", "Small") },
       Factory = () => new SampleWidget(), SettingsType = typeof(SampleSettings),
   },

4. Optionally, add a DataTemplate with DataType="{x:Type w:SampleSettings}" to Settings/WidgetSettingsTemplates.xaml for its settings UI. For richer UIs, return a UserControl from SettingsViewFactory (see WeatherSettingsView).

The widget then shows up in the gallery automatically. Other helpers:

• Popups: OpenPopup(popup) opens a popup on the correct side of the dock, pauses auto-hide while it is open, and aligns to the tile on vertical docks.
• Hiding: a widget that sets its own Visibility to Collapsed is removed from the dock as well.
• Tile clicks: if OnCompactClick returns true, clicking the tile on a vertical dock runs that action instead of opening the panel.

• Timers. Clock-based widgets share a single timer aligned to seconds or minutes. It ticks once a minute when no widget needs seconds and stops when nothing is subscribed. No timer runs more often than once per second, except the taskbar watcher (event driven, with a 2-second safety check that runs every 250 ms for 5 seconds after Explorer shows its taskbar) and the Start menu visibility poll (200 ms).
• Only what's on the dock. Services start the first time something uses them: without a Device batteries widget nothing scans for devices, without a Brightness widget nothing asks the monitors.
• Monitoring. System monitoring uses GetSystemTimes and GlobalMemoryStatusEx; disk usage is sampled once a minute. Network measurement runs only while a network widget is on the dock.
• Event driven. The window list and full screen detection update through ManagedShell's shell hooks. Media updates through SMTC events, and the progress bar ticks once per second only while playing.
• Weather. Widgets that share a location share one request and cache. Data refreshes every 30 minutes and retries after 3 minutes on failure.
• Scrolling. The scroll animation runs only while scrolling.
• Start-up. The dock is drawn first; the first weather, device battery and AI usage requests follow 2 to 8 seconds later instead of all at once. log.txt and Settings › About › Copy diagnostics show the time from launch to the first dock frame.
• Measuring. tools/measure-idle.ps1 records DockHub's CPU, memory and garbage collector counters while the computer is idle (it needs dotnet-counters) and compares them with the targets: under 0.1% CPU and under 10% memory growth.

• Window effects. The blurred glass effect uses SetWindowCompositionAttribute, so it works even when the window is inactive. Corner rounding comes from DWM (about 8 px); corners stay square on Windows 10.
• Shell integration. Windows 11's XAML tray items (network, volume and battery quick settings, language bar) belong to Explorer, so the dock shows its own network, volume and battery icons and opens Windows' quick settings panel from them. The per-app taskbar progress indicator may not appear for some apps, because the Windows key stays with Explorer.
• Multiple monitors. The tray icons live on the main dock. With Show on all displays the other displays get a dock with apps, and any widget can be moved to one of them; each widget sits on one dock only, and a widget whose display is disconnected waits on the main dock until it is back. The Windows taskbar is hidden on every display.
• Language. The interface is available in English, Turkish, German and Spanish (Settings › General › Language; System follows your Windows display language). Dates and numbers follow your Windows locale. Text that has no translation yet appears in English. Translations live in src/CustomDock/Resources/Strings_<code>.json, with the English text as the key; a test checks that every language has the same keys and placeholders.

Bug reports, widget ideas and pull requests are welcome. Please open an issue first for larger changes so the approach can be discussed. When filing a bug, attach %AppData%\DockHub\log.txt if possible.

This repository does not include a license file yet. Until one is added, all rights are reserved by the author.

• Special thanks to @farukolmez22 for invaluable support, testing, and contributions toward native macOS support.

DockHub builds on excellent open source work:

• ManagedShell (Apache-2.0)
• The Start menu (IImmersiveLauncher), tray icon mouse forwarding and "show desktop" techniques are adapted from RetroBar (Apache-2.0)
• Microsoft.Toolkit.Uwp.Notifications (MIT)
• Weather data by Open-Meteo (CC BY 4.0)
• Emoji names from the Unicode CLDR (Unicode License v3); the emoji list from Emojibase (MIT)

Windows is a trademark of Microsoft Corporation. DockHub is not affiliated with Microsoft.