I built a lightweight Windows internet radio player with C#, WebView2

jemontenis — Fri, 17 Apr 2026 04:51:39 +0000

I built a small Windows app called Tunexori.

It is a lightweight internet radio player for direct stream URLs. The idea is simple: you add your own radio streams,
press play, and the app keeps running quietly in the system tray.

GitHub Releases page:

https://github.com/jemontenis/Tunexori/releases

Why I made it

I wanted a simple radio player for Windows without extra accounts, catalogs, ads, or complicated menus.

Most of the time I only need a few direct radio stream links. I do not need a full media center. I just want to open
the app, choose a stream, and keep it playing while I work.

So I made Tunexori around that workflow:

add your own stream URLs
switch between them quickly
minimize the app to the tray
keep playback running in the background
use a sleep timer or alarm when needed

What the app does

Tunexori supports:

custom internet radio stream URLs
play, pause, previous, and next controls
volume control
Windows system tray menu
minimizing to tray without stopping playback
audio level visualization
alarm for starting the current station at a selected time
sleep timer for pausing playback later
track history for streams that provide ICY metadata
export of track history to a text file
update checks through GitHub Releases
manual language selection: automatic, English, or Russian

The app starts with no predefined stations. The user adds their own streams manually.

Tech stack

Tunexori is built with:

C#
.NET 9
Windows Forms
Microsoft Edge WebView2
HTML / CSS / JavaScript
NAudio
PowerShell
GitHub Releases

The main desktop shell is WinForms. The interface inside the app is rendered with WebView2. Audio playback is handled
with NAudio.

Why WinForms and WebView2?

I wanted the app to feel like a real Windows desktop application, but I also wanted a flexible UI.

WinForms gives me:

native window
tray icon
context menus
file dialogs
simple installer UI
easy Windows integration

WebView2 gives me:

modern layout
CSS styling
easier UI iteration
a cleaner visual design than classic WinForms controls

So the app uses WinForms as the native host and WebView2 for the main interface.

The result is still a normal Windows app, but the main UI can be designed with HTML, CSS, and JavaScript.

Audio playback

For playback I used NAudio.

The app accepts direct HTTP or HTTPS stream URLs. When the user starts a station, the app opens the stream and sends
the audio to the system output.

I also added a simple connection watchdog. If the stream stops sending data or fails, the app can show a status and
try to reconnect.

This is useful because internet radio streams are not always stable.

Track metadata

Some radio streams send ICY metadata. This can include the current track title.

Tunexori reads that metadata when it is available and shows the current track in the interface. It also keeps a local
track history.

The history can be exported as a text file.

Not every stream provides metadata, so this feature depends on the station.

Settings

Settings are stored locally in JSON.

On Windows, the settings file is stored here:

%APPDATA%\Tunexori\settings.json

The WebView2 profile is stored here:

%LOCALAPPDATA%\Tunexori\WebView2

The app saves things like:

station list
selected station
volume
alarm settings
startup settings
language preference

System tray behavior

One of the important parts of the app is tray behavior.

When the user closes or minimizes the window, the radio can continue playing. The tray icon gives quick access to:

play / pause
previous station
next station
station list
stream settings
show or hide the window
exit

This makes the app useful as a background player instead of something that always needs to stay open on the desktop.

GitHub Releases for update checks

I did not want to build a complex update server.

Instead, Tunexori checks the latest GitHub Release.

The app calls the GitHub API endpoint:

https://api.github.com/repos/jemontenis/Tunexori/releases/latest

Then it compares the latest release tag with the current app version.

For example:

Installed version: 1.0.1
Latest GitHub tag: v1.0.2

If the GitHub version is newer, the app shows that a new version is available.

I kept the update flow manual for now. If an update is found, the app shows a button to open the download page:

https://github.com/jemontenis/Tunexori/releases/latest

This is simpler and safer than automatically downloading and running an installer.

Installer

The app has a Windows installer.

The current public installer is an app-only installer. It installs Tunexori into:

%LOCALAPPDATA%\Programs\Tunexori

It also creates shortcuts and adds the app to the Windows uninstall list.

The installer window also shows the app version, so users can see what version they are installing.

Requirements

Tunexori is made for:

Windows 10 x64
Windows 11 x64

For direct app execution, the app uses:

.NET Desktop Runtime 9 x64
Microsoft Edge WebView2 Runtime x64

WebView2 is usually already available on modern Windows 10 and Windows 11 systems. A fallback download link can be
provided if it is missing.

What I learned

This project was a good reminder that small desktop apps still have value.

A few things that were interesting:

WebView2 works well when you want a modern UI inside a native Windows app.
GitHub Releases can be enough for a simple update system.
Tray behavior matters a lot for background apps.
Internet radio streams are inconsistent, so reconnect and status messages are important.
Simple local JSON settings are enough for this kind of tool.

I also learned that small UI details matter. For example, when selecting a station in a long stream list, the list
should not jump back to the top. That kind of small behavior can make the app feel much better.

Download

You can download Tunexori from GitHub Releases:

https://github.com/jemontenis/Tunexori/releases

If you try it and find a problem, you can open an issue here:

https://github.com/jemontenis/Tunexori/issues

Thanks for reading.

DEV Community: jemontenis

I built a lightweight Windows internet radio player with C#, WebView2