The software was old. The experience did not have to be.
There was a time when listening to music on a computer meant opening a small, strange-looking window, loading a folder full of MP3 files, and arranging the perfect playlist by hand.
That window was Winamp.
It was fast, personal, skinnable, slightly chaotic, and completely yours. It did not try to become a social network. It did not recommend a podcast while you were listening to an album. It did not hide basic controls behind three layers of navigation.
It played music.
Winamp first appeared in 1997, created by Justin Frankel and Dmitry Boldyrev at Nullsoft. Its combination of MP3 playback, visualizations, plugins, and downloadable skins helped turn it into one of the defining applications of the early digital-music era. Nullsoft was acquired by AOL in 1999, when Winamp already had millions of users.
More than two decades later, Winamp remains instantly recognizable. Its design belongs to another era, but its central idea still works: give the listener direct control over music.
So we asked a simple question:
What if Winamp could search and play YouTube without becoming a web browser?
Not a Winamp-inspired web app. Not a modern player wearing a retro skin. The real Windows desktop application, extended from inside its original plugin architecture.
We wanted to give old software a new power-up.
Why Winamp?
Modern streaming applications are excellent at providing access. They are less interested in giving users a sense of ownership.
Winamp comes from the opposite philosophy.
A playlist is a visible list that can be reordered, saved, shuffled, repeated, or deleted. Playback controls stay on screen. The application does not change shape depending on what it wants to promote. Its plugin system allows new formats and capabilities to be added without rebuilding the entire player around them.
That made Winamp a surprisingly good foundation for an experiment in software revival.
The objective was not to redesign it. The objective was to preserve its behavior while adding a completely new media source.
The finished extension needed to support:
- Native YouTube search inside Winamp
- Audio-only playback
- Video-only playback
- Audio and video playback
- Stable playlist entries with titles and durations
- Pause, seek, stop, next, previous, repeat, and shuffle
- YouTube thumbnails in Winamp's Album Art window
- Right-click actions for search results
- A hidden API-key settings window
- Unicode titles without broken characters
- Winamp Modern colors, fonts, embedded frames, and controls
- Streaming without filling the disk with permanent downloads
The most important requirement was less technical:
It still had to feel like Winamp.
The architecture: three components and one virtual URL
The YouTube integration was divided into three main parts.
1. gen_youtube: search and user interface
The general-purpose Winamp plugin owns the visible YouTube panel. It communicates with the YouTube Data API v3 to search for public videos and retrieve metadata such as video IDs, titles, channels, thumbnails, and durations.
The plugin is responsible for search input and results, playback-mode selection, API-key configuration, adding results to the playlist, context-menu actions, and saving UI state.
2. in_youtube: the Winamp input adapter
Winamp normally recognizes content by file extension or input-plugin ownership. A YouTube video is not a normal local file, and its media URLs expire.
We introduced a stable virtual format:
youtube://VIDEO_IDA playlist stores the YouTube video ID, title, and duration—not the temporary streaming URL. The input plugin claims these virtual URLs and translates them into something Winamp can play. From Winamp's perspective, a YouTube item behaves like any other track.
3. The resolver: translating YouTube into legacy-compatible media
The input plugin launches a bundled resolver built around yt-dlp and FFmpeg. The resolver discovers the current playable YouTube media streams and converts them into a format that Winamp's older playback paths can understand.
Instead of exposing a public network service, it starts a temporary loopback server bound to the local machine. Winamp receives a short-lived, one-use URL protected by a random token. The playlist remains stable (youtube://VIDEO_ID) while the playback URL is temporary.
The first version worked—until we pressed Play
YouTube search was the easy part. The initial plugin could send a query, receive results, and place a selected item in Winamp's playlist. That was enough to make the feature look close to finished.
Then we pressed Play.
Winamp crashed.
At different points in development, we encountered:
- "Resolver returned no playable stream"
- DirectShow failing to open the YouTube stream
- Video playing without audio
- Audio playing only after downloading the entire file
- Duplicate playlist entries appearing at the bottom
- Playlist titles being replaced by proxy URLs
- Every duration appearing as zero seconds
- The Winamp Error Reporter opening the default email client
- Search results rendered as Chinese-looking mojibake
- Album Art loading at the wrong time
- A transparent header after minimizing and restoring Winamp
This became a practical lesson in legacy integration: successful network access does not mean successful media playback.
Making modern YouTube media understandable to DirectShow
For audio-only playback, the resolver produces an MP3 stream that can pass through Winamp's existing audio system.
Video required a more conservative format. For video and audio-plus-video modes, FFmpeg generates an MPEG program stream containing MPEG-1 video and MP2 audio. This is not the most modern encoding combination—and that is precisely why it works.
The objective was not to preserve YouTube's source codec. The objective was to provide a stream compatible with a legacy Windows media graph.
The modes became:
| Mode | Resolver output | Winamp path |
|---|---|---|
| Audio only | MP3 | Normal Winamp audio output |
| Video only | MPEG PS with MPEG-1 video | DirectShow video |
| Audio + video | MPEG PS with MPEG-1 video + MP2 audio | DirectShow audio/video |
This adapter is the bridge that lets 1990s-style desktop software consume media delivered by a modern streaming platform.
Fixing the playlist without breaking Winamp
One of the most frustrating bugs appeared after playback started working. A user could add a YouTube result to the playlist and press Play. The video would begin, but Winamp would add another entry at the bottom. The original item could change its title to a proxy URL.
Playback was technically successful, but the playlist was no longer trustworthy.
The solution was architectural rather than cosmetic: keep youtube://VIDEO_ID as the canonical playlist item, never replace the visible entry with a resolver URL, hand temporary playback URLs to Winamp internally, and marshal playlist changes through Winamp's UI thread.
Once those boundaries were established, a YouTube entry behaved like a real Winamp track instead of a temporary web request pretending to be one.
YouTube thumbnails became Winamp Album Art
When a YouTube item becomes active, the plugin asynchronously fetches its standard thumbnail and exposes it through Winamp's Album Art service as JPEG data. The thumbnail request does not block playback. If it fails, Winamp continues displaying its normal placeholder.
This small feature changed the experience significantly. The YouTube item was no longer just a URL with a title. It had a visual identity inside the existing Winamp interface.
The final 10% was entirely about feeling native
Once audio and video worked, the plugin still looked like a generic Windows dialog attached to a carefully designed media player. That was not acceptable.
The panel was moved into a genuine Winamp Modern embedded frame. It began following the active skin's colors and window behavior.
We added Modern Skin background and text colors, playlist-style blue search and result fields, compact pill-shaped owner-drawn buttons, a matching embedded title bar, a Ctrl+Shift+Y shortcut, saved panel visibility and position, a separate masked API-key settings window, and proper repainting after minimize, restore, resize, and theme changes.
The transparent-header bug was particularly revealing. The fix required the plugin to explicitly erase its client area and redraw the complete child hierarchy on show, resize, embed notification, and skin-theme refresh events. Legacy UI programming is full of details that modern frameworks normally hide.
Building it with Codex and specialist AI agents
This project was developed through a human-directed, AI-assisted engineering workflow. The main orchestration was handled by a GPT-5-class Codex agent. Smaller implementation tasks were delegated to fast GPT-5.6 Luna workers. Final high-risk reviews used a GPT-5.6 Sol reviewer with higher reasoning depth.
The AI did not receive one perfect prompt and return a finished application. The real process was a tight human-AI feedback loop:
- Implement the smallest working search integration
- Install it into the portable Winamp build
- Test it in the real application
- Capture the failure
- Describe the exact visible behavior
- Trace it to a boundary between systems
- Write a focused regression test
- Build and install another DLL
- Repeat
Each observation became a new acceptance criterion. The human supplied taste, frustration, priorities, and real-world judgment. The agents supplied code navigation, implementation speed, test generation, and independent review.
The project by the numbers
| Metric | Result |
|---|---|
| Calendar span | 4 days |
| Relevant Git commits | 46 |
| Changed or created files | 32 |
| Inserted lines | 5,160 |
| Automated tests | 63 |
| Human steering prompts | 45+ |
| Specialist-agent sessions | 9 |
| Estimated active engineering time | 10–14 hours |
What we learned about reviving old software
Legacy software is often described as obsolete because it does not support a modern service or format. But "does not support" is not always the same as "cannot support."
Winamp already had a playlist model, playback controls, input and general-purpose plugins, video integration, Album Art, skins, and menu/hotkey systems. We did not need to replace those parts—we needed adapters.
One adapter translated YouTube search responses into Winamp metadata. Another translated stable virtual playlist entries into temporary media sessions. FFmpeg translated modern media streams into formats DirectShow could understand. The skin adapter translated native Win32 controls into Winamp Modern visual language.
The project succeeded because it respected the old software's architecture instead of fighting it.
Conclusion: old software deserves power-ups
Technology culture often treats replacement as the only form of progress. A new framework replaces the old framework. A new app replaces the old app. But sometimes the better idea is to keep the tool and expand its abilities.
Winamp did not need to become YouTube. It only needed to understand YouTube.
The result is a player from 1997 searching a global video platform, streaming audio and video through a local compatibility layer, displaying modern thumbnails as Album Art, and managing everything through the same playlist people have understood for decades.
It is still compact. It is still skinnable. It still gives the listener direct control.
It is still Winamp—just with a new power-up.
Old software does not always need a replacement. Sometimes it needs someone stubborn enough to teach it a new trick.
