qtamp · the reference player for qtWasabi, rendering Winamp Modern skins faithfully

#What is qtWasabi?

In 2002, Winamp3 introduced Wasabi: a skinnable UI engine where a skin is not a bitmap theme but a program. XML declares the widget tree, and compiled Maki bytecode drives its behaviour. Drawers slide, tabs switch, windows reshape, tickers scroll, all scripted by the skin itself. Winamp 5 carried this engine forward as “Modern skins” (.wal), and thousands of them were built.

qtWasabi reimplements that engine faithfully on Qt6, and it executes each skin's own original Maki bytecode on the original Maki VM. The goal is absolute: every skin ever built for the original Winamp, and every skin yet to be built for it, must render correctly. No per-skin hacks; the engine is fixed, never the skin. qtamp is the reference media player proving it: a real player (FLAC/MP3/OGG/Opus, 10-band EQ DSP, playlists, a DuckDB-indexed media library, projectM visualization, MPRIS2) whose entire UI is whatever skin you load.

The original VM

Skins ship compiled .maki binaries. qtWasabi runs them on the original interpreter, so the skin's own logic drives the UI exactly as it did in 2002.

Engine, not clone

qtamp doesn't imitate Winamp's look. It embeds qtWasabi behind one small Host interface; any app can do the same and get every Modern skin for free.

Honest fidelity

Thousands of shipped skins are the spec and the test corpus. What renders wrong is an engine bug, tracked openly in the fidelity audit.

#It actually works

Live renders of the QTAMP-branded WinampModernPP skin (MIT, by Eris Lund). The drawers open and close, the EQ is a real 10-band DSP, the playlist editor is the skin's own.

Config drawer open with the equalizer tab active — **Drawer open, EQ live.** The config drawer, its EQUALIZER / OPTIONS / COLOR THEMES tabs, and the 10-band equalizer feeding a real biquad DSP chain.

Player with the config drawer closed — **Drawer closed.** Same skin with the drawer tucked away. The window resizes with it, exactly like the original engine.

The skin's playlist editor window — **The real playlist editor.** Not a lookalike widget: the skin's own PLEDIT window rendered by the engine, playing an actual playlist.

The Media Library window listing real artists, albums and tracks — **The Media Library, with your actual music.** Artist → album → track drill-down, live filtering, double-click to play. Behind it sits a DuckDB + Parquet index qtamp builds from your music folder's tags.

macOS screenshots are coming. qtamp already builds and runs on Apple Silicon Macs (the installer below does it end-to-end); press shots from macOS, plus the visualizer and preferences windows, will join this gallery soon. More skins join as they pass the fidelity corpus. We only show what already renders exactly as its author intended.

#Color themes, real and synthetic

Modern skins ship color presets: gammaset tables that re-tint every element group of the skin's art at runtime. qtWasabi implements the original engine's gamma pipeline byte-for-byte, with the same integer math Winamp's GammaFilter used, so a skin's presets look exactly as authored. One skin, many faces:

WinampModernPP in the Good Ol' Winamp color theme — **“Good Ol' Winamp”**: the skin's classic silver-blue preset.

WinampModernPP in the Blues color theme — **“Blues”**: the same art, re-tinted live by the gammaset engine.

WinampModernPP in the Halloween color theme — **“Halloween”**: every element group follows its own gamma curve, exactly as the skin author tuned it.

And for skins that ship no presets at all, qtWasabi can go further: it analyzes the skin's structure, assigns color roles to its element groups, and synthesizes color themes the author never shipped. This is an engine feature, applied generically, never baked per skin. Skins with their own presets are always rendered exactly as authored; synthesis is strictly opt-in for the ones without.

#Install

One line on either platform. It builds everything from source and tells you what it's doing. Prefer to read first? The script is right here.

Linux (Fedora · Debian/Ubuntu · Arch · openSUSE)

curl https://qtamp.sh | sh

Installs the toolchain + Qt6 via your distro's package manager (dnf / apt / pacman / zypper). This is the only step that asks for sudo.
Clones qtamp/qtamp with the qtWasabi engine submodule into ~/.cache/qtamp-build.
Fetches the Wasabi source tree from the public archive.org mirror (your own copy, see licensing).
Builds with CMake/Ninja and installs to /usr/local. Run it with qtamp.

Manual build instead: git clone --recursive https://github.com/qtamp/qtamp && cd qtamp && deps/qtWasabi/scripts/fetch-wasabi.sh && cmake -B build -DQTAMP_USE_QTWASABI=ON && cmake --build build

macOS (Apple Silicon)

curl https://qtamp.sh | sh

Detects macOS and hands off to the .app installer.
Provisions Xcode Command Line Tools and Homebrew (cmake, ninja, Qt6) if missing.
Clones the repos, fetches the Wasabi tree from archive.org, builds, and bundles a proper qtamp.app with macdeployqt.
Installs into /Applications, so you can launch qtamp from Spotlight like any app.

Browser (Chromium, WebAssembly)

curl https://qtamp.sh | sh -s -- --wasm

Nothing to install for listening: the hero of this page runs the real player, compiled to WebAssembly, in Chromium-based browsers.
The one-liner above builds it yourself: same script, same checkout, built inside the published qtamp-wasm-builder toolchain image (needs Docker). The deployable player lands in build-wasm/dist.

Windows

Coming sometime in the future. The engine is plain Qt6/C++ with no platform tricks, so a port is a matter of build plumbing, not architecture. We'd rather nail fidelity first. Follow the issue tracker.

#Roadmap

One goal governs everything: every skin ever built for the original Winamp, and every skin yet to be built, rendered correctly by the original Maki VM. The full audited plan lives in the qtWasabi OKF bundle; this is the shape of it, in priority order.

Maki object model & dispatch

Restore the typed class layer around the original interpreter: real object construction, per-class method dispatch, safe arity. The keystone every other workstream leans on.

Full event surface

Every mouse, keyboard, and lifecycle event a real Wasabi engine dispatches reaches the skin's scripts, so script-driven skins are fully interactive with zero engine-side imitations.

One state store + real Config service

Skins' own scripts decide drawer, tab, and preference state; the last hardcoded assumptions about specific skins get deleted.

Containers, layouts & window sizing

Multi-window and multi-layout skins (shade modes included) navigate exactly as authored; window size comes from the skin's scripts, not heuristics.

Geometry & paint fidelity

The reference frame-constraint model, exact coordinate semantics, exact font metrics and color/gamma theming, verified pixel-for-pixel against original Winamp.

Widget completion

Every placeholder becomes a faithful interpretation: scrollbars, popup menus, dropdowns, text entry, animated layers, the full media library.

Corpus verification, continuous

Real skins are the regression suite, diffed against their authors' own reference screenshots. Today 1 of 5 corpus skins renders pixel-faithfully (WinampModernPP); the other four are open engine bugs, tracked per skin in corpus-status. This gate never closes.

#Licensing & provenance

Everything we wrote is MIT. What we didn't write, we don't ship.

qtamp & qtWasabi: MIT

Both repositories (qtamp/qtamp, qtWasabi/qtWasabi) are MIT-licensed, with no Winamp-licensed source in the repos or their git history.

Original Winamp files: user-supplied

A small set of original Wasabi engine sources is required at build time. The installer fetches them from the public archive.org mirror of the official source release into a gitignored directory, on your machine, under the Winamp Collaborative License v1.0 (§3 permits using covered works you do not convey). They are never redistributed by us. It is the same pattern emulators use for a user-supplied BIOS.

Showcase skins: MIT

Every skin shown on this site is MIT-licensed by its author and forked with credit into github.com/qtamp (only titlebar branding strings changed). We deliberately don't showcase proprietary Nullsoft skins.

#Thanks

qtamp stands on the shoulders of people who cared about this software long before us.

Kristopher Craig (lord3nd3r) Author of winamp-linux, the native Qt port qtamp grew out of, and the person who said “make the Modern skins work”. This project is that issue, taken seriously.

Eris Lund (0x5066) Skin author and Wasabi archaeologist whose MIT-licensed skins (WinampModernPP and family) make an honest showcase possible, and whose skinning documentation keeps this knowledge alive.

#Contributors

Florian Kleber (kleberbaum)qtWasabi engine & qtamp · github.com/kleberbaum

Kristopher Craig (lord3nd3r)winamp-linux foundation · github.com/lord3nd3r

Want your face here? The engine has one rule, fix the engine, never the skin, and a very honest list of what's left to do. Bugs, skins that render wrong, and PRs: github.com/qtamp/qtamp/issues.