📻 GNOME Radio 82.0

News

• July 29, 2026: GNOME Radio 82.0 released, bringing a redesigned Radio Studio panel, an interactive Audio Map built on Leaflet and OpenStreetMap, and a lighter, faster canvas visualizer.
• June 14, 2026: GNOME Radio 80.2 patch release fixes a crackling issue on some Bluetooth output devices and restores volume persistence between sessions.
• April 2, 2026: GNOME Radio 80.0 introduces station favoriting, a searchable station directory, and initial support for Icecast metadata (now-playing titles).
• January 18, 2026: GNOME Radio joins the GNOME Circle, recognizing projects that meet GNOME's standards for usability, accessibility, and integration.

Download

• https://www.gnomeradio.org/src/gnome-radio-82.0.tar.xz

Overview

GNOME Radio is a free internet radio application for GNOME featuring international radio stations, audio visualization and interactive maps.

At its core, GNOME Radio does one thing well: it turns a list of internet radio streams into something that feels native to the GNOME desktop. Rather than asking people to dig through a browser tab, remember a stream URL, or run a separate media server, GNOME Radio presents stations the way GNOME presents everything else — a clean list, a single primary action, and no more controls than the moment calls for. Pick a station, press play, adjust the volume, and the rest of the interface gets out of the way.

The project began as a small weekend experiment: a GTK wrapper around GStreamer's playbin element, pointed at a handful of Norwegian and international Icecast streams. Over successive releases it grew a station directory, a canvas-based audio visualizer, and — new in this release — an interactive Audio Map that plots each station's broadcast origin on OpenStreetMap tiles using Leaflet. The guiding principle has stayed the same throughout: internet radio is a simple idea, and the software around it should stay simple too, even as capabilities are added.

GNOME Radio is written to be a good citizen of the GNOME platform. It follows the GNOME Human Interface Guidelines, respects the system's light and dark style preference, exposes its window state to GNOME Shell's activity tracking, and ships a standard .desktop entry and AppStream metadata so it shows up properly in GNOME Software and other app centers. It has no telemetry, no accounts, and no advertising: streams play directly from each broadcaster's own server to the listener's machine, and nothing about a listening session is logged, stored, or transmitted anywhere else.

Because GNOME Radio is free software released under the GNU General Public License, anyone can read the source, modify it, package it for a different distribution, or fold pieces of it into their own project. That openness is not incidental to the project — it is the reason the project exists in the current form. Internet radio, unlike most streaming media today, is built on open, unencrypted protocols that any client can speak. GNOME Radio tries to honor that openness in its own architecture: no proprietary SDKs, no closed dependencies, and no feature that requires trusting a server the user does not control.

None of this makes GNOME Radio ambitious in scope, and that is by design. It is not trying to become a media hub, a podcast client, or a music-discovery platform. It is trying to be the smallest, most reliable possible answer to "I want to listen to this radio station right now," and to stay that way even as small, useful features accumulate around the edges. Everything documented on this page — the Radio Studio panel, the station directory, the visualizer, the Audio Map — exists in service of that one job.

Features

Radio Studio

The Radio Studio panel on the left of this page is a working preview of the desktop application's main window, rebuilt in HTML5 for the web. It streams directly from each broadcaster's Icecast or Shoutcast endpoint using the browser's native <audio> element, so there is no transcoding step and no added latency beyond what the broadcaster's own server introduces.

Curated station directory

GNOME Radio ships with a small, hand-checked directory of stations rather than an enormous, frequently-broken list. Norwegian public and commercial broadcasters (NRK, P4) sit alongside international services (BBC World Service, NPR), chosen because their streams have proven stable over long periods and because they represent a useful cross-section of news, sport, and general programming. The desktop application allows adding arbitrary stream URLs; this web preview intentionally keeps the list short.

Canvas audio visualizer

A lightweight visualizer renders directly on an HTML5 <canvas> element, driven by the Web Audio API's analyser node where the browser and stream's CORS policy allow it. On the desktop, the equivalent visualizer reads frequency data from GStreamer's spectrum element and draws with Cairo, giving a smoother, lower-latency result than is possible purely in the browser.

Interactive Audio Map

New in 82.0, the Audio Map plots the geographic origin of the currently selected station on an OpenStreetMap base layer rendered with Leaflet. Selecting a station flies the map to its broadcast location and drops a marker with a popup naming the station. It is a small feature, but it changes how stations feel: a stream stops being an anonymous URL and becomes a place on a map, which matters for an application whose entire purpose is listening to somewhere else.

Keyboard-first and accessible

Every control in GNOME Radio's desktop build is reachable by keyboard, works correctly with screen readers via GTK's accessibility layer, and respects the system's reduced-motion setting for anyone who finds map flyovers or visualizer motion distracting. High-contrast and dark styles are both supported without a separate theme.

Radio at War, Computers on the Wire

How one technology carried a war on invisible waves, and how another built the network that now carries almost everything.

Why this history matters to a radio application

It might seem like a long way round to talk about Bletchley Park and Tim Berners-Lee in the documentation for a small internet radio player, but the two eras genuinely explain what GNOME Radio is doing under the hood. Icecast, the protocol most internet radio stations still use, is a nearly direct descendant of the broadcast-radio model: one transmitter, many receivers, no acknowledgment required from the listener, no return channel. It rides on top of the World Wide Web's transport — HTTP, over TCP/IP — but it deliberately keeps radio's one-to-many shape rather than adopting the Web's request-and-response pattern for every piece of content.

That hybrid is why GNOME Radio's architecture looks the way it does. The player opens a long-lived HTTP connection to a station's stream endpoint, the same way a browser would open a connection to fetch a web page, but instead of downloading a finite document, it reads an effectively endless sequence of audio frames, decodes them as they arrive, and discards them once played. There is no seeking, no buffering ahead by more than a few seconds, and no way to "rewind" a live stream, because there is nothing on the server keeping a record for one listener to rewind into. Wartime radio had the same constraint for a different reason: a broadcast, once sent, was gone, and every listener had to be tuned in at the moment it happened.

Computers changed what a network could carry, but they did not retire the older idea of broadcast; they gave it a new transport layer to run on. GNOME Radio, in a small way, sits at exactly that junction: a broadcast-shaped stream of audio, carried over the general-purpose, packet-switched network that computers built. Every time someone presses play in the Radio Studio panel, both halves of that history are doing quiet, necessary work at the same time.

Screenshot

How GNOME Radio Compares

Internet radio has no shortage of players, from browser extensions to full media-center suites. GNOME Radio occupies a fairly specific niche: a small, native, single-purpose application, rather than a general media hub that happens to support radio as one input among many. That trade-off is worth being explicit about.

Versus general media players

Applications like VLC or a full media center can play internet radio streams perfectly well, alongside local video, DVDs, and network shares. GNOME Radio deliberately does none of that. The narrower scope means a simpler interface with fewer menus to search through when the only goal is "play a station," at the cost of not being a one-stop media application for everything else on a system. If you already reach for a general media player for everything, GNOME Radio probably won't replace it; it's aimed at people who want a dedicated, low-friction radio launcher instead.

Versus web-based radio directories

Large web radio directories offer enormous station catalogs — tens of thousands of stations worldwide — and are a reasonable choice if breadth is the priority. GNOME Radio's directory is a few dozen stations, verified by hand, because the project's priority is reliability and a consistent listening experience over sheer catalog size. It also runs as a native application with system integration (media keys, GNOME Shell notifications, offline-friendly startup) that a browser tab can't fully replicate.

Versus proprietary streaming apps

Commercial music-streaming applications solve a different problem: on-demand, licensed, algorithmically-curated music, usually behind a subscription and a closed client. Internet radio, and GNOME Radio along with it, is closer to traditional broadcast: whatever a station is playing right now, for free, over an open protocol, with no account required. Neither model replaces the other; they answer different questions about how someone wants to listen.

Architecture

GNOME Radio's desktop application is written in C using GTK4 and libadwaita for the interface, and GStreamer for media handling. This is a deliberate, fairly conservative stack: it is the same toolkit and media framework used by most of the rest of the GNOME application ecosystem, which keeps GNOME Radio's look, feel, and packaging story consistent with everything around it rather than introducing a one-off dependency chain.

Playback pipeline

At the center of the application is a single GStreamer playbin3 element, pointed at whichever stream URL is currently selected. playbin3 handles protocol negotiation, demuxing, and decoding automatically, which means GNOME Radio itself does not need to know or care whether a given station serves MP3, AAC, or Ogg Vorbis; it delegates that decision to whichever GStreamer plugins are installed on the system. This is also why some distributions require an extra plugin package (see Installation, below) to unlock every stream in the default station list — codec licensing means not every distribution ships every decoder by default.

Interface layer

The interface itself is built from standard GTK4 widgets composed with libadwaita's AdwApplicationWindow and AdwToastOverlay, which is what gives GNOME Radio its adaptive behavior on narrow windows and its automatic light/dark style switching. State — the selected station, the volume level, and the play/pause state — is held in a small, explicit application-state object rather than scattered across widget properties, which keeps the persistence logic (writing volume and last-station to GSettings) in one place and easy to audit.

This web preview

The page you're reading is a separate, browser-native implementation of the same interface ideas, built with plain HTML5, CSS, and JavaScript, using the browser's <audio> element for playback and Leaflet for the Audio Map. It exists so that people can try the interaction model before installing anything, and so the project's design decisions are visible to anyone with a browser, not just people already running GNOME. It is not a full reimplementation: features that depend on GSettings, MPRIS, or GStreamer plugin negotiation are specific to the desktop build and are not present here.

Supported codecs and protocols

Because decoding is delegated to GStreamer, the practical answer to "what formats does GNOME Radio support" is "whatever GStreamer plugins are installed." In practice this covers the formats internet radio actually uses in the wild: MP3, AAC (including HE-AAC, common on higher-bitrate European streams), and Ogg Vorbis. Streams are typically served over plain Icecast or Shoutcast, both of which are simple HTTP-based protocols with a small header carrying station metadata ahead of the raw audio bytes. GNOME Radio reads that metadata when present to populate now-playing information, and falls back gracefully to just the station name from its own directory when a stream doesn't provide any.

Privacy & Data

GNOME Radio is built on the assumption that a radio player does not need to know anything about the person using it. There is no account system, no analytics SDK, no crash reporter that phones home by default, and no advertising of any kind, in either the desktop application or this web preview.

What actually leaves your machine

When you press play, your machine opens a direct HTTP connection to the broadcaster's own streaming server (or, in some cases, a content delivery network acting on the broadcaster's behalf) and requests the audio stream. That connection necessarily reveals your IP address to the broadcaster, the same way it would if you opened the stream URL directly in a browser — this is a property of how internet radio works, not something GNOME Radio adds. Beyond that one connection, GNOME Radio makes no other network requests: it does not check for updates automatically, does not fetch remote configuration, and does not report usage statistics anywhere.

The Audio Map and location

The Audio Map might look like it is aware of your location, since it shows markers on a world map, but it is not. Every coordinate shown is the fixed, pre-recorded broadcast origin of a station, stored in the station list that ships with the application. GNOME Radio never requests your device's location, and the map tiles are fetched from OpenStreetMap's standard tile servers the same way they would be for any website that embeds a Leaflet map, with no additional tracking parameters attached.

Local storage

The desktop application stores your last-selected station and volume level locally using GSettings, GNOME's standard configuration store; nothing is written anywhere outside your own machine. This web preview keeps equivalent state only in memory for the current page session and does not use cookies, localStorage, or any other persistent browser storage.

Accessibility

Accessibility is treated as a baseline requirement rather than an add-on feature, in keeping with GNOME's broader platform commitments.

Keyboard navigation

Every interactive element — the station selector, the play/pause button, the volume slider, and the map's zoom controls — is reachable and operable using only the keyboard, with a visible focus indicator at every step. No functionality in GNOME Radio requires a pointing device.

Screen readers

The desktop application exposes standard GTK accessibility metadata for every control, so screen readers announce the current station, playback state, and volume level correctly. This web preview uses semantic HTML elements ( <select>, <button>, <input type="range">) with associated <label> elements for the same reason, rather than building custom controls that would need additional ARIA work to reach the same baseline.

Reduced motion

Both the audio visualizer and the Audio Map's fly-to animation respect the operating system's or browser's reduced-motion preference. When that preference is set, the visualizer holds a static waveform instead of animating, and the map jumps directly to a station's location instead of flying there.

Color and contrast

The interface's color palette, in both light and dark variants, is checked against WCAG AA contrast requirements for text and interactive elements. Station selection, playback state, and errors are never communicated by color alone; each is paired with text or an icon change as well.

Installation

GNOME Radio is packaged for most major distributions. Pick whichever matches your system below; if your distribution isn't listed, the Flatpak build works everywhere a Flatpak-capable desktop is set up.

Fedora

sudo dnf install gnome-radio

Debian / Ubuntu

sudo apt update
sudo apt install gnome-radio

On older Ubuntu LTS releases the package may lag behind upstream; the GNOME Radio stable PPA tracks current releases more closely.

openSUSE

sudo zypper install gnome-radio

Arch Linux

sudo pacman -S gnome-radio

A more current, community-maintained package is also available in the AUR as gnome-radio-git.

Flatpak (any distribution)

flatpak install flathub org.gnome.Radio
flatpak run org.gnome.Radio

System requirements

GNOME Radio requires GTK 4.10 or newer, GStreamer 1.22 or newer with the good and bad plugin sets installed for MP3 and AAC stream decoding, and an active internet connection. It runs comfortably on modest hardware: a Raspberry Pi 4 or an older laptop with 2 GB of RAM is more than sufficient, since the application itself does no local transcoding or heavy processing beyond decoding the incoming audio stream.

Source Code

GNOME Radio is licensed under the GNU General Public License, version 3 or later. The full source tree, build files, translations, and AppStream metadata are available from the links below.

Fedora Source Dependencies

sudo dnf builddep gnome-radio

Debian / Ubuntu Source Dependencies

sudo apt build-dep gnome-radio

Or, on a system without an existing gnome-radio package to derive dependencies from:

sudo apt install meson ninja-build pkg-config \
    libgtk-4-dev libgstreamer1.0-dev \
    libgstreamer-plugins-base1.0-dev libjson-glib-dev

Tarball

https://www.gnomeradio.org/src/gnome-radio-82.0.tar.xz

Git Repository

git clone https://github.com/oleaamot-dev/radio.git
cd radio
./configure
make
sudo make install
gnome-radio

Meson build (recommended for development)

git clone https://github.com/oleaamot-dev/radio.git
cd radio
meson setup build
ninja -C build
sudo ninja -C build install

Project layout

The tree is organized the way most GNOME applications are: src/ holds the GTK4/C application code, data/ holds the .desktop entry, AppStream metainfo, and GSettings schema, po/ holds translation catalogs managed through GNOME's standard gettext workflow, and docs/ holds the user and developer documentation source. Contributions are welcome as merge requests; small, focused patches with a clear commit message are easiest to review and land quickly.

Running the test suite

meson test -C build

Help

See the GNOME Radio documentation and user guide for the full manual. A few common questions are answered below.

A station won't play. What's wrong?

Most silent-station reports trace back to one of three causes: the broadcaster's stream is temporarily offline (try again in a few minutes), a firewall or VPN is blocking the outbound port the stream uses, or the stream's codec isn't supported by the GStreamer plugins installed on your system. Installing the gstreamer1-plugins-bad-free (or distribution equivalent) package resolves most AAC playback issues on Fedora-based systems.

Can I add my own stations?

Yes. The desktop application includes an "Add Station" dialog that accepts any direct Icecast or Shoutcast stream URL along with a display name. This web preview keeps a fixed, curated list, but the underlying station format (a URL, a name, and optional latitude/longitude for the Audio Map) is documented in the user guide if you want to build your own station list file.

Does GNOME Radio record streams?

No. GNOME Radio is a player, not a recorder, and has no built-in capture feature. This is a deliberate choice: many broadcasters' terms of service restrict recording and redistribution of their streams, and GNOME Radio does not want to make that decision on a listener's behalf.

Why does the volume reset between sessions?

This was a known issue in 80.0 and 80.1, fixed in 80.2. If you still see it after upgrading, check that GNOME Radio has permission to write to its GSettings schema (this can be blocked by some sandboxing setups, notably certain Flatpak permission overrides).

Does GNOME Radio work offline?

No, and it isn't meant to. Internet radio streams are live by nature; there is no local file to fall back to when the network is unavailable. If you lose connectivity mid-stream, GNOME Radio will show a brief error and stop playback rather than retry indefinitely, so you aren't left wondering whether audio is about to resume unexpectedly.

Why isn't station X in the list?

The default station list is intentionally small and hand-verified rather than exhaustive. Stations are added when their stream has proven reliable over an extended period and when a maintainer or contributor has personally checked that the URL, codec, and metadata all work correctly. This keeps the out-of-the-box experience free of dead links, at the cost of not including every station a given listener might want. Adding your own station via the "Add Station" dialog takes a few seconds and doesn't require a rebuild or an upstream contribution.

Does GNOME Radio support podcasts?

Not directly. Podcasts are typically delivered as discrete, on-demand episode files described by an RSS feed, which is a fundamentally different delivery model from a continuous live stream, and supporting it well would mean building out episode lists, download management, and playback position tracking — a substantial feature set that would pull the application away from its narrow focus on live radio. GNOME's separate podcast application, GNOME Podcasts, is a better fit for that use case.

Can I run GNOME Radio outside of GNOME?

Yes. It depends only on GTK4, libadwaita, and GStreamer, all of which are available on most Linux desktop environments, and the Flatpak build in particular carries its own runtime so it works consistently regardless of which desktop environment it's launched from. It will look most at home inside GNOME, since that's the design language it follows, but nothing about it hard-requires GNOME Shell specifically.

Where do I report a bug?

File issues against the GitHub issue tracker. Include your distribution, GNOME Radio version, and, for playback issues, the specific station and any error text shown in the terminal when running gnome-radio directly from a shell.

World Wide Web Visualize

See GNOME Radio Studio for World Wide Web Visualize.

The Web Visualize is the browser-based counterpart to the desktop application's Cairo-drawn spectrum display. Where the desktop version reads raw frequency bins from GStreamer's spectrum element, the web version draws from the Web Audio API's AnalyserNode, which most browsers make available for any audio element that isn't cross-origin restricted. In practice this means visualization quality can vary by station: streams served with permissive CORS headers animate smoothly, while streams that don't expose those headers fall back to a simpler, idle animation rather than failing outright.

The visualizer is intentionally understated: a single band of motion rather than a dense equalizer grid, matching GNOME's general preference for calm, legible interfaces over dense dashboards. It resizes automatically with the browser window and respects the operating system's reduced-motion accessibility setting, holding a static waveform instead of animating when that preference is set.

Audio Maps

See GNOME Radio Audio Maps for Free Audio Maps.

Audio Maps pair each station in the directory with the geographic coordinates of its broadcast origin, then render that pairing on an OpenStreetMap base layer using the Leaflet JavaScript library. Selecting a station in the Radio Studio panel flies the map to that station's location and opens a popup naming it — a small piece of context that turns an anonymous stream URL into a place.

The map data itself comes entirely from OpenStreetMap, a free, editable map of the world built and maintained by volunteers. GNOME Radio uses only the standard raster tile layer and adds no additional tracking, geolocation requests, or third-party map services. No location data about the listener is collected or transmitted; only the fixed, pre-recorded coordinates of each station are used.

Station coordinates are maintained by hand in the project's station list and are, by necessity, approximate — most broadcasters transmit from a studio or transmitter location that differs from their nominal city of record, and some streams are relayed through content delivery networks with no fixed physical origin at all. Where a precise broadcast origin isn't publicly documented, GNOME Radio uses the broadcaster's most commonly cited home city instead.

Roadmap

GNOME Radio follows GNOME's approximate six-month release cadence, with point releases in between for fixes. The items below are directions under active discussion rather than firm commitments; anything can move depending on maintainer time and contributor interest.

Planned for 82.0

• Now-playing metadata (track title/artist) surfaced from Icecast StreamTitle tags where broadcasters provide them
• A compact mode for the main window, suited to narrow tiling layouts and small displays
• Per-station volume memory, so switching stations restores the last volume used for that station

Under consideration

• Optional MPRIS integration, so GNOME Shell's media controls and keyboard media keys can control playback
• A community-submitted station directory, moderated and reviewed before merging, as an alternative to hand-editing a local station list
• Sleep-timer and alarm-clock style scheduled playback

Feature requests and design discussion happen in the open on the issue tracker; there is no private roadmap beyond what is listed here.

Community

GNOME Radio is developed in the open, in the same spirit as the rest of the GNOME project. Contributions of code, translations, documentation, bug reports, and station suggestions are all welcome, and none of them require prior arrangement — open an issue or a merge request and it will get a response.

Translations

GNOME Radio's interface strings are translated through the standard GNOME translation workflow using gettext catalogs in po/. Norwegian Bokmål and Nynorsk translations are maintained alongside the upstream project; additional languages are welcome and don't require any special tooling beyond a text editor and a working knowledge of the target language's conventions for technical software.

Reporting issues responsibly

When filing a playback bug, the most useful thing to include is the exact stream URL and the output of running gnome-radio from a terminal, since GStreamer's error messages usually point directly at the missing codec or network problem. Screenshots help for layout or rendering issues but rarely help for playback issues, since the failure is almost always in the audio pipeline rather than the interface.

Project history

GNOME Radio began as a small side project alongside other GNOME-adjacent tools, built out of a simple frustration: there was no lightweight, native way to listen to a handful of Norwegian and international stations without opening a browser tab and leaving it running in the background. Early versions were little more than a GTK window wrapping GStreamer's playbin element and a hardcoded list of five stream URLs. The station directory, the visualizer, and the Audio Map were all added incrementally, each in response to a specific, concrete want rather than as part of a grand feature plan drawn up in advance.

That incremental approach is still how the project is run. Releases ship when a small, coherent set of changes is ready, not on a fixed calendar beyond the general rhythm GNOME's own release schedule sets. Version numbers follow GNOME's convention of tracking the platform's release series rather than resetting to 1.0 and counting up independently, which is why the current release is numbered 82.0 rather than something like 3.4.

Code of conduct

GNOME Radio follows the GNOME Code of Conduct in all project spaces, including the issue tracker, merge requests, and any associated chat channels. The short version: be respectful, assume good faith, and remember that behind every bug report and every patch is a person volunteering their time.