Skip to content

About

A modern, open-source widget stack for the G.Skill WigiDash 7″ USB touch panel

Resources

Stars

3 stars

Watchers

0 watching

Forks

Latest commit

 

History

882 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

ModernWigiDash

ModernWigiDash

A modern, open-source widget stack for the G.Skill WigiDash 7″ USB touch panel.

.NET 10 C# 14 Tests Platform Release License

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.

Default start page

Architecture

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 shared TouchReport.ToEventType site. No elevation or service installation required.
  • High-Rate SkiaSharp Rendering. The App composites at a steady 30 FPS via SkiaFrameCompositor, using a pooled FrameBufferPool and 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.

Key Features

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

Included Widget Suite

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

Solution Layout

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

Requirements

  • 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

Quick Start

Option A: Download a Release (no .NET install)

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.)

Option B: Build from Source

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.csproj

The 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.


Packaging a Release

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 by setup-telemetry.bat). Use this for fresh installs.
  • ModernWigiDash-vX.Y.Z-app-only.zip. The slim exe + Resources only (~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=false

This 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.


Twitch Widget

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.

  1. Register a Twitch application at the Twitch Developer Console.
  2. Use the app's public Client ID in the widget's Twitch Client ID setting, or set MODERNWIGIDASH_TWITCH_CLIENT_ID in the user environment.
  3. Select Log in with Twitch in the widget inspector and authorize the requested user:read:follows permission.
  4. 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.


Calendar Widget

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 .ics path (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)

Developing Custom Widgets (ModernWigiDash.Sdk)

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.


Acknowledgements

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.


License

Released under the MIT License.

About

A modern, open-source widget stack for the G.Skill WigiDash 7″ USB touch panel

Resources

Stars

3 stars

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages