ModernWigiDash replaces vendor dashboard software with a zero-allocation SkiaSharp frame compositor, an extensible widget plugin architecture, direct USB access, and in-app auto-updates, all built on .NET 10 with current C# idioms. Frames stream to the display over direct USB HID / WinUSB transport, with hardware telemetry (via LibreHardwareService), frame-time analytics (via PresentMon Service), HWiNFO/AIDA64 vendor readings and panels, Twitch chat, media controls, market tickers, and a calendar at your fingertips.
ModernWigiDash is a single WPF app that owns the USB display directly, no background service to install:
┌───────────────────────────────────────────────────────────────────────────┐
│ ModernWigiDash.App │
│ (WPF Configuration UI · Layout Editor · Inspector) │
│ │
│ ┌──────────────────┐ ┌──────────────────┐ ┌────────────────────┐ │
│ │ WidgetPlugin │ │ SkiaFrame │ │ Gesture │ │
│ │ Loader │ │ Compositor │ │ Interpreter │ │
│ │ (catalog) │ │ (30 FPS · │ │ (swipe only) │ │
│ │ │ │ zero-alloc) │ │ │ │
│ └──────────────────┘ └──────────────────┘ └────────────────────┘ │
│ │
│ LhmSharedMemoryReader ── LHS shared memory ──► LibreHardwareService │
│ PresentMonFrameTimeProducer ── named pipe ──► PresentMon Service │
└──────────────────────────────────┬───────────────────────────────────────┘
│ Direct USB / HID Transport (WinUSB)
│ frames → · touch ←
┌──────────────────────────────────▼───────────────────────────────────────┐
│ G.Skill WigiDash 7″ Display │
│ (1024×600 panel · 1016×592 framebuffer) │
└───────────────────────────────────────────────────────────────────────────┘
- Direct-USB Transport. The App owns the device via
DisplayDeviceEngine/DisplayHidTransport: frames stream over bulk writes and touch is polled at 16 ms, normalized once through the sharedTouchReport.ToEventTypesite. No elevation or service installation required. - High-Rate SkiaSharp Rendering. The App composites at a steady 30 FPS via
SkiaFrameCompositor, using a pooledFrameBufferPooland zero-allocation hot paths (stack-allocated Z-order sorting, span-based sparklines, array-reuse frame delivery) to keep GC pressure minimal. - In-App Auto-Update. An amber update arrow appears in the header when a newer release exists; click it to download the slim app-only payload (SHA-256 verified), then click the green Restart to apply button and choose OK to swap in place (if installed in
Program Files, Windows prompts for UAC elevation after close). Profile and theme are preserved. - Power Lifecycle. On Windows sleep the frame pump pauses; on resume it restarts and the USB transport reconnects, so the display resumes streaming cleanly.
- Standby on Exit. The display returns to its vendor Welcome screen and is put to sleep (backlight off) whenever the app closes; starting the app again wakes it.
| Area | Detail |
|---|---|
| Hardware Abstraction | Direct USB HID control via DisplayHidTransport, native WinUSB P/Invoke with LibUsbDotNet fallback |
| Hardware Telemetry | Live CPU, GPU, VRAM, RAM, and thermal readouts read from LibreHardwareService's shared-memory maps (ADR-0004), no elevation required. Default 500ms cadence eliminates Nyquist phase-beat aliasing; machine-local configurable from 250ms to 2000ms |
| Frame-Time Analyst | Real-time FPS and frame-time graphs driven by Intel's PresentMon Service (ADR-0003). The app connects non-elevated and polls a rolling 1s dynamic query for FPS, frame times, and GPU busy. The readout drops to zero when the tracked target isn't actually displayed (e.g. a backgrounded fullscreen game) instead of showing its hidden render rate |
| Vendor Integration | The HWiNFO Sensor widget reads any HWiNFO sensor G.SKILL's WigiDash service exposes (over its WCF endpoint, served to the UI from a background-refreshed cache so the render tick never does I/O; the connection self-heals when the service starts or restarts). The AIDA64 Panel widget renders your AIDA64 sensor panel live from the vendor's shared map, playing the vendor master role itself (ADR-0026) so AIDA64 publishes frames with the vendor Manager closed. The inspector's Sensor row is a live dropdown with an automatic first-sensor fallback, and it explains itself when the vendor service is unavailable; the AIDA64 frame path never blocks the UI on a slow vendor call |
| Telemetry Display Modes | Every reading widget draws in Gauge / Bar / Value / Graph modes with auto-scaling, a sparkline history, and a shrink-to-fit layout that keeps the value inside the widget at any placement size |
| In-App Auto-Update | Checks GitHub once at startup; downloads a slim app-only zip (~110 MB, SHA-256 verified) and swaps the executable in place on restart, no manual zip juggling. The download only stages; the restart confirmation launches the swap once, with a guarded restore if the copy fails |
| Power Lifecycle | Windows sleep/resume handling: the 30 FPS pump pauses on suspend and restarts with a forced USB reconnect on wake |
| Titanium Amber Theme | Dark titanium finish with amber accents, high-contrast indicators, and rounded container cards. Persisted to app_theme.json in %LocalAppData%\ModernWigiDash (a pre-release copy next to the exe migrates automatically, one time); the profile export carries the theme and import offers a one-click restore |
| Profile Persistence | Auto-saved profile (profile.json in %LocalAppData%\ModernWigiDash). Widget placements, pages, and property values survive restarts via debounced save + flush-on-close; display_device.log and crash.log live in the same folder, never next to the exe. The log names why the app closed (reason=user-close, tray-quit, update-restart, session-end, second-launch) and records a hard managed fault, so a support report can be triaged from the log alone |
| Profile Import / Export | Manual JSON profile round-trip with import sanitization: widget/page count caps, ActionCommand stripping, and path checks against malicious profiles. The export bundle carries an optional theme section; a restore offer on import is declined safely (the profile import itself never touches the theme file) |
| Tray & Settings Hub | Per-profile opt-in hide to tray on close or minimize, with a system tray icon (Show / Quit) and a single-instance guard (a second launch activates the first window). The ⚙️ Settings hub groups Appearance (theme colors, page background), Behavior (close behavior, start with Windows, hotkey kill switch, telemetry polling rate), and Profile (export / import) |
| Start with Windows | Per-user autostart (HKCU, no elevation) with a Settings checkbox; the autostarted instance opens minimized and keeps streaming frames to the display |
| Minimize to Tray on Startup | Machine-local opt-in (Behavior group): the next launch opens hidden to the tray instead of showing the window, while the display keeps streaming. Composes with Start with Windows (the --startup + flag combination hides rather than minimizes) |
| Global Hotkeys | The Hotkey widget binds an OS-level chord (Ctrl/Alt/Shift/Win + key) that fires even while the app is hidden to the tray, including a Flip page action and a Run AHK Script action that spawns your own AutoHotkey script. A machine-local kill switch in Settings vetoes the global registration and the AHK spawn (the anti-cheat off-switch) |
| Typography & Icons | Dynamic font fallback engine with embedded Geist variable fonts and generated vector icon paths (GriddyIcons) |
| UIA AutomationIds | Every interactive control carries a stable AutomationId, so UI automation harnesses can address widgets, inspector fields, and dialog controls by name instead of by visual-tree position |
| Memory Floor | Usage-gated managed heap: the frame pipeline, bounded caches, and interop surfaces are allocation-clean; the idle tail (cached-font cap, tray-hidden repaint skip, streaming price parsers) keeps the steady-state footprint flat at ~440 MB working set |
| Extensible Plugin SDK | Build isolated C# widget assemblies targeting ModernWigiDash.Sdk |
| Widget | Description |
|---|---|
| Hardware Monitor | Multi-gauge readouts for CPU, GPU, VRAM, memory, and storage utilization (via LibreHardwareService) |
| HWiNFO Sensor | Any HWiNFO sensor the vendor WigiDash service exposes (CPU/GPU temperatures, clocks, memory), with Gauge / Bar / Value / Graph modes and a name-based sensor picker (automatic first-sensor fallback, plus an in-app hint when the vendor service is unavailable) |
| AIDA64 Panel | Your AIDA64 sensor panel, rendered live and full-screen on the display, read straight from the vendor's shared map; the render path never waits on the vendor service, so a slow or missing service cannot freeze the app |
| FPS / Frame Time | Real-time FPS, 1% / 0.1% lows, and GPU-busy metrics with an overlay-style readout (via PresentMon Service); reads zero when the tracked app isn't on screen |
| Audio Visualizer | Real-time multi-band spectrum and oscilloscope visualization from WASAPI loopback capture |
| Now Playing | Windows System Media Transport Controls integration with album artwork and transport buttons |
| Twitch | Real-time channel chat viewer and live-channel status with Device-Authorization login |
| Hotkey | Customizable macro buttons with vector icon support, global hotkey chords (tray-aware), and user AutoHotkey script actions |
| Stock & Crypto | Real-time crypto, stock, and FX price feeds (Binance, Finnhub, Yahoo, CoinGecko) |
| Clock | Analog and digital clocks (optional seconds display) |
| Stopwatch & Timer | Stopwatch and countdown timer |
| Picture & GIF Viewer | Static image and animated GIF playback |
| Weather Forecast | Multi-day weather conditions with live refresh (optional hide-location) |
| Calendar | Month grid + agenda view fed by ICS and CalDAV sources. Adaptive layout scales to placement size; Swiss-poster styling with week numbers and accent colors; scrollable detail page with tap-to-open meeting links; word-wrapped long URLs; feed inspector editor with password capture; notable-dates footer shows holidays for the viewed day |
| Steam Library | Local Steam game discovery via ACF manifests and VDF tokenizer, Hero Deck, Showcase, and Poster Grid views with a 24-slot LRU cached poster pipeline, live process tracking, playtime logging, one-touch launch/terminate, and Steam Community persona avatar |
| To-Do Companion | Interactive desktop companion dragon with an affection/XP engine, local and SuperProductivity task syncing, Pomodoro focus timer, touch checkmarks, and streak tracking |
| Text | Static or animated text banners |
| Project | Description |
|---|---|
ModernWigiDash.App |
WPF layout editor, theme customizer, inspector, frame compositing host, and direct-USB engine owner |
ModernWigiDash.Hardware |
Low-level USB HID transport, RGB565 frame encoder, WinUSB P/Invoke, touch report normalization, device engine |
ModernWigiDash.Core |
Page-layout domain models, profile ops (page/widget CRUD, sanitized import/export), font catalog, SkiaSharp compositor, plugin loader |
ModernWigiDash.Sdk |
Widget contracts (IModernWidget, IModernWigiDashContext), attributes, frame delivery/pooling, poll-loop primitives, telemetry DTOs |
ModernWigiDash.Widgets |
Built-in widget implementations (telemetry, Twitch, media, tickers, system controls) |
ModernWigiDash.Tests |
MSTest suite covering protocols, encoding, stores, frame delivery, profile sanitization, and widget lifecycle |
- OS: Windows 10 or Windows 11 (x64)
- Runtime: none for release builds (self-contained single-file EXE); the .NET 10 SDK is required only to build from source
- Hardware: G.Skill WigiDash 7″ USB touch panel (
USB\VID_28DA&PID_EF01) - Optional: LibreHardwareService (hardware sensors), PresentMon Service (frame-time analytics), and G.SKILL's WigiDash Manager (its service backs the HWiNFO Sensor and AIDA64 Panel widgets). The AIDA64 Panel also needs AIDA64 running with its LCD output set to the WigiDash. The app runs without them; the related widgets show an unavailable state
Grab the latest ModernWigiDash-vX.Y.Z-win-x64.zip from the Releases page and extract the ModernWigiDash-win-x64 folder anywhere on your PC (it already includes ModernWigiDash.App.exe, Resources, and setup-telemetry.bat). Plug in the WigiDash over USB first, then run ModernWigiDash.App.exe. No .NET runtime or SDK is required. To enable Hardware Monitor and FPS / Frame Time, right-click setup-telemetry.bat and choose Run as administrator.
First launch: the release executable is unsigned (open source, no code-signing certificate), so Windows SmartScreen may show "Windows protected your PC" once per machine. Click More info → Run anyway.
Updating: the app checks for new releases at startup. When one is available, an amber update arrow appears in the header. Click it to download, then click the green Restart to apply button and choose OK to close and swap in place (if you placed the app in a protected folder such as Program Files, Windows prompts for administrator permission via UAC right after close; declining leaves the previous version in place). Your profile and theme are preserved. (Dev builds and older release versions without the updater use the manual zip flow.)
git clone https://github.com/headpiece747/ModernWigiDash.git
cd ModernWigiDash
dotnet build ModernWigiDash.slnx -c Release
dotnet test ModernWigiDash.slnx -c Release
dotnet run --project ModernWigiDash.App\ModernWigiDash.App.csprojThe app connects to the display directly over USB. Frames and touch work with no service installation. Hardware telemetry requires LibreHardwareService to be installed; frame-time widgets require PresentMon Service; the HWiNFO Sensor and AIDA64 Panel widgets require G.SKILL's WigiDash service (and AIDA64 with its LCD output set to the WigiDash, for the panel). Each degrades gracefully to an "unavailable" state when absent.
Release zips are built and published automatically by CI: push a v* tag (e.g. v0.9.6) and the Release workflow runs scripts/build-release.ps1 -Version 0.9.6, then creates a GitHub Release with the two versioned assets attached. You can also trigger it manually from the Actions tab with a tag input.
Each release ships two zips:
ModernWigiDash-vX.Y.Z-win-x64.zip. The full bundle: the single-file exe +Resources+ bundled LibreHardwareService and PresentMon installers (used bysetup-telemetry.bat). Use this for fresh installs.ModernWigiDash-vX.Y.Z-app-only.zip. The slim exe +Resourcesonly (~110 MB). This is the in-app updater's payload, never use it for a fresh install (it has no telemetry installers).
The build stamps the exe with the release version (InformationalVersion for the updater, FileVersion for Explorer's Details tab), auto-resolves the latest upstream telemetry versions (recorded in telemetry/third-party-licenses/telemetry-versions.txt), and asserts the stamp before zipping. To build by hand:
dotnet publish ModernWigiDash.App\ModernWigiDash.App.csproj -c Release -r win-x64 --self-contained `
-o ./publish `
-p:PublishSingleFile=true -p:PublishReadyToRun=true `
-p:IncludeNativeLibrariesForSelfExtract=true -p:EnableCompressionInSingleFile=true `
-p:DebugType=None -p:DebugSymbols=falseThis produces ModernWigiDash.App.exe plus the Resources folder (bundled fonts, theme, icons). Native (SkiaSharp) PDBs are stripped automatically by the shared build target. WPF does not support NativeAOT, so ReadyToRun provides the precompiled-IL speedup.
The Twitch widget authenticates via Twitch's Device Authorization Grant, no OAuth token pasting. Access and refresh tokens are stored DPAPI-encrypted in the current user's local application data.
- Register a Twitch application at the Twitch Developer Console.
- Use the app's public Client ID in the widget's Twitch Client ID setting, or set
MODERNWIGIDASH_TWITCH_CLIENT_IDin the user environment. - Select Log in with Twitch in the widget inspector and authorize the requested
user:read:followspermission. - Pick a live channel from the populated Channel Name list and keep Auto Connect enabled.
The Client ID is public and is not a user token or secret. The widget uses anonymous, read-only IRC chat and never requests chat-writing permissions.
The Calendar widget shows a month grid with an agenda list of upcoming events, fed by one or more calendar sources configured via Feeds in WIDGET SETTINGS.
Supported sources:
- ICS file – a local
.icspath (e.g. a Google Calendar export) - CalDAV – a remote CalDAV server URL + username + password (Google Calendar, Fastmail, iCloud, Nextcloud, etc.)
Features:
- Adaptive layout – the month grid, agenda rows, and detail page all scale to the widget's placement size; at 1×1 the widget collapses to a compact date card
- Swiss-poster styling – clean typography, week numbers, and accent colors that adapt to the theme
- Scrollable detail page – tap an event row to open a full-detail view inside the widget; drag to scroll long events; tap the meeting link (if present) to open it in your browser
- Word-wrapped URLs – long meeting links and run-on sentences break at word boundaries instead of clipping
- Notable-dates footer – shows holidays for the currently viewed day only
- Feed management – add, edit, and remove calendar feeds directly via Feeds in WIDGET SETTINGS; CalDAV passwords are captured via a secure prompt and stored DPAPI-encrypted alongside the profile
- Security hardening – the CalDAV fetcher validates redirect targets against the expected origin, refuses credentials over cleartext HTTP, and the iCalendar parser rejects hostile input (oversized payloads, malformed VCALENDAR blocks, entity-injection attempts)
Custom widgets compile into assemblies referencing ModernWigiDash.Sdk, derive from ModernWidgetBase, and are discovered by the attribute-driven catalog:
using ModernWigiDash.Sdk;
using SkiaSharp;
[WidgetMetadata(
"custom.clock",
"Minimal Clock",
Description = "A minimal amber digital clock.",
Author = "You",
Version = "1.0.0",
Category = "Utilities",
DefaultGridSize = GridSizePreset.Size2x1)]
public class MinimalClockWidget : ModernWidgetBase
{
public override void Render(SKCanvas canvas, SKRect bounds)
{
canvas.Clear(SKColors.Transparent);
using var paint = new SKPaint
{
Color = SKColor.Parse("#FFB000"), // Amber accent
TextSize = 26,
IsAntialias = true,
TextAlign = SKTextAlign.Center
};
string time = TimeProvider.System.GetLocalNow().ToString("HH:mm:ss");
canvas.DrawText(time, bounds.MidX, bounds.MidY + 8, paint);
}
}Widgets also override InitializeAsync(IModernWigiDashContext, CancellationToken), OnTouch(SKPoint, TouchEventType), and DisposeAsync() from ModernWidgetBase. See ModernWigiDash.Widgets for full implementations.
The HWiNFO Sensor and AIDA64 Panel widgets integrate with the WigiDash
service, which is ElmorLabs' work. We are grateful both for permission to use it
and for their help with the two integrations: the HWiNFO sensor catalog, the
background-refreshed read path, and the AIDA64 shared-map handshake (the master
role AidaPanelMaster plays, ADR-0022 / ADR-0024 / ADR-0026) were worked out
with them.
ElmorLabs publishes the WigiDash widget framework and sample widgets at github.com/ElmorLabs-WigiDash.
Released under the MIT License.

