# Cog: An Open Source Audio Player That Plays Almost Every Format

> Cog is a free audio player for macOS, iPhone and iPad, written in C, that treats format support as the point: tracker modules, chiptunes, MIDI through its own synthesizers, playlists, archives and network streams, all served by one engine shared between the Mac and iOS builds.

**losnoco/Cog** — A free and open-source audio player for macOS and iOS

- Repository: https://github.com/losnoco/Cog
- Website: https://cog.losno.co
- Stars: 1,037 · Forks: 68
- Language: C
- License: GPL-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/losnoco-cog

## One Engine, Two Shipped Apps

Cog is a free, open-source audio player for Mac, iPhone and iPad, and the sentence in the README that sets its scope is that every platform is built from this one repository and shares the same audio engine and format plugins.

That is a deliberate architecture. The Mac and iOS apps are released separately, with different capabilities, but the code that decodes a file and renders it is one codebase, so a format added for the Mac is available on the phone.

The two distribution routes are the Mac App Store and a direct download from cog.losno.co, and the direct edition updates itself with Sparkle, which is the updater the macOS project uses for self-updating outside the store. The system requirements are macOS 12 or later, and iOS and iPadOS 18 or later, which is a recent floor and tells you which devices the project is targeting.

The player is written in C, and the repository layout shows the size of the effort. There are directories for the application shell, the audio engine, the playlist model, the file tree browser, the Info Inspector, the equalizer, the lyrics window, the scrobbler, the TagEditor, the Spotlight integration, the preferences, the formatters, the Remote Control and the CogMCP components, alongside the third party libraries, the frameworks and the Plugins directory where each format lives.

## The Format List Is the Feature

Each format is handled by a plugin under the Plugins/ directory, and the list is where the character of the project comes from.

The common formats are MP3, AAC, ALAC, FLAC, Ogg Vorbis, Opus, WavPack, Musepack and Shorten, and then anything else that Core Audio or FFmpeg can decode, which is the general escape hatch for the formats nobody wrote a plugin for.

The tracker modules are libopenmpt, HivelyTracker, Organya and Syntrax. Video game music is covered by Game_Music_Emu, vgmstream, libvgm, sidplay for the Commodore 64 SID, AdPlug for AdLib, and the PSF family through HighlyComplete. That is a much wider console and tracker coverage than any mainstream player offers.

MIDI is handled by Cog's own built-in synthesizers, which are SoundFonts, OPL3 FM, and Roland SC-55 emulation from your own ROM set, and on the Mac you can also use Audio Unit instruments instead.

Then the containers and sources: cue sheets, M3U and PLS playlists, and files inside archives, plus streams over HTTP and HLS. So a tracker file zipped in an archive on a web server is a thing the player can open, which is a strange sentence to write and true of this one.

The plugin architecture is also why the format list is long rather than exhaustive. Each format is a separate piece of code under Plugins/, and the README notes that the libraries under ThirdParty/, Frameworks/ and Plugins/ remain under their own licences and copyrights, with some modified to build inside Cog.

## Synthesis and MIDI Without a Sampler

The MIDI story is the part that distinguishes Cog from a player that merely plays back a MIDI file with whatever the operating system provides.

Cog's built-in synthesizers are SoundFonts, which are sample based, OPL3 FM, which is the Yamaha FM synthesis chip emulation, and Roland SC-55 emulation built from your own ROM set. The Roland part is the notable one, because it is an emulation of a specific hardware sound module, and it needs the ROM image, which you supply.

That last detail is a licensing question rather than a technical one, and the project handles it the sensible way by not shipping the ROM. On the Mac you can also route MIDI through Audio Unit instruments, which is the path if you already have a software instrument setup.

The format plugins are what make the tracker and chiptune support sound like themselves. A tracker module contains the notes and the effects, and it is the player's job to render it, so the quality of the emulation determines whether a chiptune sounds like the original hardware or like a piano roll in a different font. Shipping a set of emulators for the machines the music came from is the way to keep that honest, and it is why the project carries SID, AdLib and PSF support rather than delegating to a generic MIDI synth.

## ReplayGain, Time Stretch and Spatial Audio

The sound features are grouped under a heading called Sound, and the first one is loudness normalisation.

ReplayGain by album or track, with clipping prevention, falls back to Sound Check when no ReplayGain data is present. The album mode is what you want for a mixed album so the tracks sit at a consistent level, and the track mode keeps the relative dynamics of a single track. The clipping prevention is a real constraint here, because boosting a quiet track to the album level can push the peaks into distortion, and the macOS system mechanism handles that by refusing to boost beyond the headroom.

Speed and pitch control uses either the Rubber Band or the Signalsmith Stretch engines, or plain varispeed like a record player. That third option is the one audiophiles ask for, because varispeed changes pitch with speed the way a turntable does, and the two stretch engines are the ones that keep the pitch constant while the tempo changes.

Spatial audio is the third item. Surround tracks are spatialised on headphones and stereo speakers, with head tracking, so a multichannel soundtrack can be rendered to a binaural image that follows the listener's head position. On the Mac there is also an exclusive mode that takes the output device for Cog and runs it at each track's sample rate, which is the audiophile path, since it means the file is played at its native rate with no resampling.

The equalizer with presets, the spectrum visualizer, synced lyrics from the file's own tags or looked up on LRCLIB, and scrobbling to Last.fm and ListenBrainz complete the picture of a player built for a local collection.

## The Sandbox Decides Which Folders You Can Open

Cog runs in the App Sandbox, so it can only open folders you have granted it, and the granting happens in Settings, General. Right-clicking the list there lets you edit it, and it can suggest additions based on the current playlist, and the suggestions cover every path not already granted, so you pick only the few folders that hold most of your music. Your Music, Downloads and Movies folders are granted already.

This is the single most common surprise for a new user, and it is a platform constraint rather than a design choice in the player. A sandboxed Mac app cannot read your disk without an explicit grant, and the grant is per folder.

The suggestion behaviour is the useful part. If you have a playlist with tracks from a dozen directories, the app can offer to add exactly those directories, which is a much better flow than finding each folder in the settings pane by hand.

The iOS side has the analogous constraint in a different shape. The app plays files and folders from the Files app where they are, without importing copies, so there is no library management step on the phone, and the files you open through the Files app are the files that play. The iOS feature set is smaller by design: Now Playing with a scrubbing slider, fast forward and rewind by holding Next and Previous, and lock screen controls.

## Building the Mac App: Submodules, a Team ID and Two Schemes

The build instructions are detailed, and the shape of them tells you what is hard about building this project.

Step one is the submodules, because the third party libraries are not vendored in the tree:

```sh
git submodule update --init --recursive
```

Step two is your Apple developer team ID, in a file called Xcode-config/DEVELOPMENT_TEAM.xcconfig, which is gitignored. The README explains the twist: because the group.org.cogx.cog App Group belongs to the upstream team, you also have to turn off provisioning profiles:

```
DEVELOPMENT_TEAM = YOURTEAMID
PROVISIONING_PROFILE_SUPPORTED = NO
```

Step three installs the git hooks, so that a team ID never ends up committed in a project file:

```sh
git config core.hooksPath .githooks
```

Step four is optional and turns on Last.fm scrobbling, by copying the Secrets template to a real config and adding your API key.

Then the Mac build itself. The prebuilt static and dynamic libraries are unpacked from an archive, and the instruction is to repeat that whenever the archive changes:

```sh
cd ThirdParty
tar xvf libraries.tar.xz
```

Finally you open Cog.xcodeproj and pick one of two schemes, Cog for the App Store edition and Cog Direct for the direct edition, which is a Release-Direct configuration that adds Sparkle and the donation menu.

## The iOS Project Is Generated, and the Project Has Two Histories

The iOS build is different in kind from the Mac one, and the reason is stated in one line: the iOS project is generated, so do not change it in Xcode. There is an iOS/README.md that explains how it is laid out and how to regenerate it.

The procedure is to run iOS/prepare.sh, which applies the patches the iOS build needs to some submodules and builds the third party libraries for iOS, a step that takes a few minutes and needs cmake and ninja installed with brew. The repository also has a workflow that checks whether Cog builds for iOS, and it publishes the built libraries as its ios-libraries artifact, which saves you repeating that step.

Then you open iOS/MobileCog.xcodeproj and build the Cog scheme.

The history is worth knowing because it explains the structure. Vincent Spader wrote Cog and released it under the GPL, and when its development stopped, Christopher Snowhill forked it in 2013 and has maintained it since. The repository still carries the Mercurial artefacts of the earlier era, with.hgignore and.hgtags alongside the git configuration, and the CODE_OF_CONDUCT.md, the Changelog file and the Acknowledgements directory all point to a project with a long history and a large third party surface.

The project is GPL-2.0 licensed with the text in COPYING, the third party libraries keep their own licences, and the maintainer is reachable at the address in the README. The repository is not archived, the last push was on 2026-10-19, and there are no GitHub releases, so the two apps on the App Store and the direct download are the versioning you can rely on.

## Conclusion

Cog fits a Mac or iOS user with an eclectic local music collection, especially one with tracker modules, chiptunes, MIDI or a large archive of lossless files, since no other single player covers that spread and keeps the sound honest with ReplayGain and per-track sample rate output. It is a poor fit for a streaming service substitute, since it has no catalogue and no account, and a poor fit for a user on macOS 11 or older or iOS 17, since it needs macOS 12 or later and iOS and iPadOS 18 or later. Before building it, note that the iOS project is generated and should not be edited in Xcode, that the App Group still belongs to the upstream team so provisioning profiles must be turned off, and that the Mac and iOS apps ship separately. The player is GPL-2.0 licensed, the last push was on 2026-10-19, and the project publishes no GitHub releases.

## FAQ

### What audio formats can Cog play?

Each format is a plugin under the Plugins directory: MP3, AAC, ALAC, FLAC, Ogg Vorbis, Opus, WavPack, Musepack and Shorten plus anything Core Audio or FFmpeg can decode, tracker modules through libopenmpt, HivelyTracker, Organya and Syntrax, video game music through Game_Music_Emu, vgmstream, libvgm, sidplay, AdPlug and the PSF family, MIDI through its own synthesizers, cue sheets, M3U and PLS playlists, files inside archives, and streams over HTTP and HLS.

### Why can Cog not open my music folder?

Because the app runs in the App Sandbox and can only open folders you have granted it. You grant them in Settings, General, where right-clicking the list lets you edit it and suggests additions based on the current playlist. The Music, Downloads and Movies folders are granted already.

### How do I build Cog from source on the Mac?

Initialise the submodules with `git submodule update --init --recursive`, create Xcode-config/DEVELOPMENT_TEAM.xcconfig with your team ID and turn off provisioning profiles, install the hooks with `git config core.hooksPath .githooks`, unpack ThirdParty/libraries.tar.xz, then open Cog.xcodeproj and build either the Cog scheme for the App Store edition or Cog Direct for the direct edition.

### Does Cog play MIDI and chiptune music?

Yes. MIDI is handled by built-in synthesizers, which are SoundFonts, OPL3 FM, and Roland SC-55 emulation from your own ROM set, and on the Mac you can use Audio Unit instruments instead. Tracker and console music is covered by plugins such as libopenmpt, vgmstream, sidplay, AdPlug and libvgm.

### What are the system requirements for Cog?

macOS 12 or later, and iOS and iPadOS 18 or later. It is available on the Mac App Store and as a direct download from cog.losno.co, and the direct edition updates itself with Sparkle. The player is GPL-2.0 licensed.

## Sources

- [Issues](https://github.com/losnoco/Cog/issues)
- [License: GPL-2.0](https://github.com/losnoco/Cog/blob/main/LICENSE)
- [losnoco/Cog on GitHub](https://github.com/losnoco/Cog)
- [Project website](https://cog.losno.co)
- [README](https://github.com/losnoco/Cog/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/losnoco-cog