I Built a Native Windows Music Player with WinUI 3 — Here's What I Learned

AKP — Mon, 11 May 2026 09:27:11 +0000

There's no shortage of music players out there. Spotify, Apple Music, Foobar2000, MusicBee — the list goes on. But if you're like me and live entirely in a local music library, most of them feel like a compromise. Either they're powerful but look like they were designed in 2009, or they look great but treat local files as an afterthought.

So I built my own.

Tunetastic is a native Windows music player built with WinUI 3 and C#. It's available on the Microsoft Store and fully open source on GitHub. This post is about why I built it, how it works, and the more interesting technical corners I had to navigate.

Why WinUI 3?

When I decided to build this, I had the usual suspects to choose from: Electron, WPF, MAUI, WinForms, or WinUI 3. Electron was out immediately — I wanted something that felt native, not a browser in a trenchcoat. WPF is mature and capable, but its design story in 2026 is rough; you're fighting against the framework to get anything that looks modern.

WinUI 3 was the obvious choice for what I wanted. It's Microsoft's current-gen UI framework, and it ships with the design language of Windows 11 out of the box: Mica backgrounds, Acrylic blur, rounded corners, smooth animations. The catch is that it's still relatively young, so documentation gaps are real and you occasionally run into issues that require digging into GitHub issues threads from 2022 to solve.

The payoff is worth it, though. When something works in WinUI 3, it genuinely looks and feels like it belongs on Windows in a way nothing else quite matches.

The Design Philosophy

The main player screen is intentionally full-bleed and immersive. The album art fills the background, blurred and darkened, with the track info and controls layered over it. The blur intensity is adjustable — some people want a subtle wash of color, others want it almost imperceptible.

Every UI material option — Mica, Mica Alt, Acrylic, Acrylic Thin, Transparent — works on both Windows 10 and Windows 11. Getting Mica to behave correctly on Windows 10 (where it isn't natively supported) required some creative workarounds, since Mica normally samples the desktop wallpaper through DWM APIs that aren't available on older builds. The fallback path needed to feel intentional, not broken.

The app also responds to your Windows accent color. Certain player controls pick it up automatically, so Tunetastic feels like it genuinely belongs to your system rather than imposing its own palette on top of it.

Lyrics — More Nuanced Than It Looks

Lyrics support sounds straightforward until you actually implement it.

Tunetastic handles two types:

Synced lyrics (.lrc format) — timestamps paired with lines, scrolling in real time with playback
Unsynced lyrics — plain text embedded in the file's metadata tags

The priority chain matters here. When a track has both embedded synced lyrics and an external .lrc file sitting alongside it, the embedded version wins. This is intentional — if someone has manually embedded corrected lyrics, they probably don't want an external file overriding them.

The .lrc parser handles the usual messiness of real-world files: inconsistent timestamp formatting, lines out of order, extended attributes, and blank lines used as spacers. Getting scroll timing to feel good — not just technically correct — required some tuning around how far ahead the highlighted line jumps and the easing on the scroll animation.

Users can also edit and clear embedded lyrics directly in the app, which writes back to the file's metadata tags via TagLib.

System Integration — The Details That Make It Feel Native

This is where a lot of music players phone it in, and it's the area I spent the most time on.

System Media Transport Controls (SMTC)

SMTC is the Windows API that powers the media flyout in the notification center, the lock screen media widget, and the keyboard media keys. Full SMTC integration means Tunetastic responds correctly to every play/pause/next/previous signal from anywhere in the system — keyboard, Bluetooth headphones, the notification flyout, third-party SMTC clients, all of it.

It also means Tunetastic pushes track metadata (title, artist, album art) back to the system, so whatever's showing in the media flyout is always accurate.

Taskbar Progress

The taskbar icon shows a live progress indicator for the current track using the ITaskbarList3 interface. It's a small thing, but glancing at the taskbar and knowing you're 70% through a song without switching windows is the kind of detail that adds up.

Thumbnail Toolbar

The taskbar thumbnail preview — the popup that appears when you hover over any app in the taskbar — can host up to seven buttons via the thumbnail toolbar API. Tunetastic puts previous, play/pause, and next there, so you can control playback without the app ever coming to the foreground.

System Tray

Minimizing to the tray on close keeps Tunetastic running silently. Click the tray icon to toggle play/pause; hover it to see the current track and artist in the tooltip. The implementation uses a NotifyIcon backed by a WinForms assembly (yes, really — it's still the cleanest way to do system tray in a WinUI app), bridged carefully so it doesn't fight with the WinUI message loop.

Volume Control & the Windows Volume Mixer

The in-app volume slider can operate in two modes:

System Volume — controls the master output, in sync with the Windows volume flyout
App Volume — controls only Tunetastic's audio channel, reflected live in the Windows Volume Mixer

The two-way sync for app volume was the trickier piece. Changes made in the Volume Mixer need to propagate back to the in-app slider, and vice versa, without creating feedback loops. The solution uses the Core Audio APIs (IAudioSessionControl, ISimpleAudioVolume, IAudioSessionEvents) to register as a session listener and selectively ignore change events that originated from within the app itself.

Pause on Mute hooks into the same session listener — when volume hits zero from any source (the slider, a mute keypress, another app changing the mixer), playback pauses automatically. When audio is restored, it resumes.

Library & Playlists

The library scanner walks your configured folders, filters by extension and minimum duration (handy for excluding 2-second sound effect files), and builds an indexed collection organized into songs, artists, albums, genres, and years.

Three smart playlists update automatically: Recently Added, Recently Played, and Most Played. They're backed by a lightweight SQLite database that tracks play counts and timestamps without you having to think about it.

Duplicate detection is configurable — you can choose how aggressively Tunetastic identifies tracks that appear more than once (same title + artist, same file fingerprint, etc.).

What's Next

A few things I'm actively thinking about:

Folder watching — automatically picking up new files added to library folders without a manual rescan
Mini player mode — a compact always-on-top view for when you want music controls without the full UI
Taskbar Control Buttons — Dedicated playback controls pinned to the taskbar itself, so you can play, pause, and skip without hovering or switching windows
ID3 Tag Editing from the Internet — Look up and apply track metadata (title, artist, album art, genre, year) directly from online databases, no manual typing required

Try It / Contribute

Tunetastic is on the Microsoft Store — no sideloading, no certificate trust, just install and play. It runs on Windows 10 (1903+) and Windows 11.

The source is on GitHub under GPL v3. If you run into a bug, have a feature idea, or want to contribute, issues and PRs are open. Just open an issue first to discuss larger changes before putting in the work.

I Got Tired of XML Doc Comments, So I Built My Own Visual Studio Extension

AKP — Fri, 03 Apr 2026 18:24:03 +0000

The Problem

If you've written any serious C# code, you know the pain. Your /// doc comments
are packed with useful information — but reading them in the editor looks like this:

/// <summary>
/// Calculates the total price including <paramref name="taxRate"/> for a given
/// <see cref="Order"/>. Returns <c>0</c> if the order has no items.
/// </summary>
/// <param name="order">The order to calculate.</param>
/// <param name="taxRate">The tax rate as a decimal, e.g. <c>0.2</c> for 20%.</param>
/// <returns>The total price as a <see cref="decimal"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="order"/> is null.</exception>

Raw XML noise everywhere. Every single method.

I tried PrettyDocComments. The concept was right but the aesthetics drove me
crazy — it looked out of place in a modern IDE. So I built Render Doc Comments.

What It Does

Render Doc Comments transforms those cluttered /// tags into clean, formatted
documentation blocks — rendered inline in your editor, not in a separate window
or hover popup.

Before: Raw XML tags cluttering your view

After (Free): Clean, readable documentation with proper formatting, styled parameters,
and clickable cref links

The Interaction Model

Caret-Based Mode (Default — Free)

Click into a comment and it reverts to raw XML for editing. Move your cursor away
and the polished render returns. Zero friction.

Margin Glyph Mode (Premium)

A glyph in the editor margin lets you toggle between raw and rendered manually,
regardless of cursor position.

Language Support

C# — /// XML doc comments
F# — /// XML doc comments
C++ — Doxygen-style /// comments
VB.NET — ''' XML doc comments

Free vs Premium

Feature	Free Edition	Premium License
Multi-Language Support (C#, F#, C++, VB.NET)	✅	✅
High-Fidelity Rendering	✅	✅
Interactive `cref` Links	✅	✅
Caret-Based Auto-Hide	✅ (Always On)	🔘 Selectable
Margin Glyph Toggle	❌	🔘 Selectable
Theme Synchronization	Manual (Reopen)	Instant Auto-Sync
Typography	Segoe UI (Fixed)	Fully Custom
Accent Bars	Left Side Only	Multi-side Layout
Color Profiles	Default	Full Customization

The core rendering engine is free and open source (GNU GPL v3). Premium features
fund continued development.

Why I Built This

Documentation should aid readability — not add to the noise. Every other part of
the modern IDE has been polished. Doc comments were stuck in 2005. This is my
attempt to fix that.

Get It

Search "Render Doc Comments" in the Visual Studio Marketplace, or go to
Extensions → Manage Extensions inside VS.

Direct Links

Github
Visual Studio Marketplace

Would love feedback — especially from C#, F#, C++ and VB.NET users!

Forem: AKP