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.
