August 17th, 2026 ChipMachine 2.1 Now on App Store!	May 22nd, 2026 ChipMachineAS 1.0 Released on GitHub Latest version: September 6th, 2026 ChipMachinePlus 2.1.1

---

MINI FAQ — READ THIS FIRST!

Q: What is "ChipMachineAS"?

A: AS stands for Apple Silicon. It's a fork of the original, Intel-only ChipMachine, rebuilt and enhanced by me to run natively on Apple Silicon — including future ARM-only versions of macOS. The build distributed here on GitHub is now called ChipMachinePlus.

Q: What's the difference between ChipMachine (on the Mac App Store) and ChipMachinePlus (here on GitHub)?

A: App Store policy required removing a few features, so the app ships in two variants:

• ChipMachine — the Mac App Store build.
• ChipMachinePlus — the full build, distributed here.

ChipMachinePlus includes YouTube audio playback, which the App Store doesn't permit, and support for some exotic formats whose only available players are GPL-licensed and therefore cannot ship through the App Store. Everything else is identical.

Q: You said they're identical, but their version numbers differ!

A: They diverge only when a fix applies to just one distribution. ChipMachinePlus 2.1.1, for example, fixes a YouTube playback bug — and YouTube playback isn't part of the App Store build anyway. The intent is for both to stay level on every feature each one is allowed to ship.

Q: OK. So, which one should I download?

A: Both are code-signed and verified by Apple — the App Store build through App Store review, ChipMachinePlus through Apple's notarization service — so macOS won't warn you about an unidentified developer.

• Pick ChipMachine if you'd rather install from the App Store and don't need YouTube playback or those extra formats. Updates arrive automatically.
• Pick ChipMachinePlus if you want every feature. You'll need to download, unzip, and move it to your Applications folder yourself. It will tell you when a new version is available, but you'll have to install it manually.
• And of course, you can install both.

---

Port of ChipMachine for Apple Silicon

But this is far more than a simple port!

While ensuring the player runs on modern Apple hardware, my passion for it has expanded its compatibility and scale:

• 60+ plugins supporting 350+ music formats
• ~770,000 indexed songs (~100,000 annotaded with screenshots) and counting

The mission statement: support every single format and index all retro/chip music databases.

Despite the massive expansion under the hood, the core experience remains untouched: instant, incremental autocomplete search across the entire global library, delivering instant zero-latency (for cached songs) playback from a single, simple, unified interface.

(Screenshots might show features from dev in progress (not released) code.)

Intro

A demoscene/retro Jukebox/spotify-like music player with Amiga-intro-like effects style

Installing

1. Download the latest release and unzip it into your Applications folder
2. Double-click ChipMachinePlus.app

(The app is signed with an Apple Developer ID and notarized by Apple, so it opens like any other Mac application.)

Quick Start

• Simply start typing for incremental auto-complete search of the aggregated database
• UP/DOWN keys = select a song from search results
• ENTER key = play
• TAB key = Cycle various filter screens
• CTRL+H = show the help screen
• Things in progress / to come
• Ultimate goal: every chiptune ever made searchable and instantly playable!

Binaries

Binaries for macOS are available under Releases

Requires macOS 26 (Tahoe) or later. The shipped build declares a minimum system version of 26.0, so earlier releases of macOS will refuse to launch it. (I have no means to test / support older MacOS versions.)

Opening local music files

Once installed, ChipMachinePlus registers with macOS as a player for the hundreds of formats it supports, and you can open a local song three ways:

• Right-click a file → Open With → ChipMachinePlus (or double-click a file you've made it the default for)
• Drag and drop a file onto the ChipMachinePlus icon (Dock or Finder)
• Drag and drop a file straight into the running ChipMachinePlus window

All three play the track immediately.

This is deliberately polite — ChipMachinePlus advertises itself as an alternate handler and never hijacks files from a player you already use:

• For common audio types (.mp3, .wav, .flac, …) it appears as an option in Open With but never becomes the default unless you explicitly choose it via Get Info → Open with → Change All.
• For obscure chip/tracker formats that nothing else on your Mac opens, it becomes the de-facto player and shows its own document icon in Finder.

Prerequisites for development (Tested on macOS 26 / Tahoe only)

• Make sure you have Homebrew installed (Apple Silicon homebrew in /opt/homebrew/ , make sure you are not using Intel legacy /usr/local tools)
• brew install git cmake ninja freetype glew glfw3 lua fftw mpg123 python ffmpeg boost
• (if some packages are reported missing later install then via brew and let me know -- I missed them in the line above!)

Building for Apple Silicon

All third-party dependencies are vendored inside the repo under external/, so a single clone is all you need. Provenance (each vendored fork's upstream URL and commit) is recorded in external/VENDORED.md.

git clone https://github.com/mihailod/chipmachine.git
mkdir build && cd build
cmake ../chipmachine -GNinja -DCMAKE_BUILD_TYPE=Release
ninja
./chipmachine

Build variants: Plus vs Mac App Store

The default build/ above produces the full ChipMachinePlus variant — everything included (YouTube, self-update), distributed via GitHub with a Developer ID signature. A second Mac App Store variant — ChipMachine — is built from its own directory by passing -DCM_VARIANT=mas (from the workspace root, i.e. the parent of chipmachine/):

cmake -S chipmachine -B build-mas -GNinja -DCMAKE_BUILD_TYPE=Release -DCM_VARIANT=mas
cd build-mas
ninja
./chipmachine

The two are independent build trees (each has its own objects and binary) sharing one source — pass -GNinja for build-mas too, or ninja there will have no build.ninja. The mas variant compiles out everything the App Store disallows or that has no in-sandbox form:

• the YouTube plugin and its ~32k catalog rows (yt-dlp is a spawned executable — App Store §2.5.2),
• the bundled yt-dlp helper,
• UADE, VICE, GoatTracker v2, Furnace (the multi-system DefleMask .dmf engine — its SEGA Genesis and Master System modules are reclaimed by the clean-room dmfcr plugin, the rest stay hidden), mdxmini (the Sharp X68000 .mdx player), SC68, ASAP/PokeyNoise, AOSDK, Highly Theoretical, vio2sf, USF, Ayfly and ZXTune, together with the data/uade, data/c64 and data/sc68 payloads that go with them — dropping Furnace is also what clears reSIDfp from the build, and dropping VICE is what removes Commodore's copyrighted KERNAL/BASIC/chargen ROM images (Compute!'s Sidplayer .mus/.str survives regardless, via the ChipMachine Clean Room SIDPlayer plugin),
• the GitHub self-update check (updates come through the App Store).

Why each of those is excluded — the exact terms, what it costs, and whether a replacement exists — is documented per component in LEGAL-PLUS. The build gates themselves are CM_HAVE_* in CMakeLists.txt.

Dropping those engines costs formats, so the catalog hides what the build cannot play (songHasNoPlayer() / songFormatHasNoPlayer()) — you never see a song that will not start. Where an extension covers several unrelated formats, only the affected one is hidden, because the gate keys on the format name rather than the extension. Which formats each gate costs, and what (if anything) replaces them, is documented in the per-plugin READMEs.

The C64 formats are almost unaffected: the ~6.5k Compute!'s Sidplayer .mus/.str tunes play via the clean-room ChipMachine Clean Room SIDPlayer, and ~59.9k of the ~62k .sid tunes via the permissively-licensed cSID engine — whose README lists the measured set of SIDs it cannot voice, and why that list is measured rather than inferred.

DefleMask is being reclaimed the same way, one chip target at a time. dmfcrplugin is a clean-room .dmf parser and sequencer written from DefleMask's own published format specs and manual — never from Furnace — driving BSD-licensed ymfm for the YM2612 and an SN76489 written against the documented hardware. It covers SEGA Genesis and SEGA Master System so far, which brings 696 of the 2,071 hidden DefleMask rows back into the MAS index; Game Boy, PC Engine, Neo Geo, NES and C64 remain hidden. It ships in both variants but only claims files in MAS: Plus registers Furnace first and is byte-for-byte unchanged, which keeps a reference implementation on hand for A/B listening. Which rows survive is decided by the measured list in data/misc/dmfcr_playable.txt, because the format column says "Deflemask" without saying which of the eight DefleMask systems a file targets.

It runs App-Sandboxed, with a distinct bundle id (org.mihailod.chipmachine) and its own cache/database/index, so Plus and MAS never share state. Per-variant product identity (name, bundle id, artifact) is the single source of truth in variants.conf; the compile-time switch is CM_VARIANT / the CM_MAS define.

• Running the app (from the build folder): ./chipmachine (-h for all options)
• Running the tests (from the build folder): ./cmtest
• Packaging the app: package_app.sh --buildapponly — rebuilds the chipmachine target (incremental), bundles the runtime assets, generates the Info.plist with file associations, ad-hoc code-signs and zips the .app. Run with no args for full usage; add --applesign to produce a Developer ID / notarized build (see Signing & distribution below). Defaults to the Plus variant; add --mas to package the Mac App Store build (ChipMachine.app / .pkg from build-mas/ — see Mac App Store build).
• AI tools used to help with the porting: Claude, Gemini, Antigravity, Codex

macOS file associations (developer notes)

The .app advertises the formats it can play as macOS file associations (see the user-facing note above). All the platform-native macOS glue lives under src/macnative/:

• gen_info_plist.sh — the single source of the bundle's Info.plist. It builds the file-association document types from three inputs: extensions.txt (the playable-extension union — package_app.sh dumps the real, variant-specific list from the freshly-built binary into $BUILD_DIR/extensions.txt and passes it with --exts; the copy checked in under src/macnative/ is the plus superset, used by dev_update_doctypes.sh and as a fallback, and is refreshed by hand), MacOSSystemTypeExtensions.txt (formats with an existing system UTI — referenced politely at LSHandlerRank=Alternate, never redefined) and MacOSHandlerDenyList.txt (non-extension junk / dangerous tokens to drop). Everything else is exported under one umbrella UTI (org.mihailod.chipmachineplus.chiptune) with the app's document icon. The last two .txt files are hand-editable.
• FileOpenHandler.mm — patches GLFW's app delegate (GLFWApplicationDelegate) at runtime to implement application:openURLs:, so double-click / "Open With" / icon drag-and-drop actually play the file (Finder does not pass files on argv, and this must win the race against GLFW's own [NSApp run] inside glfwInit()). Dropping a file into the running window instead goes through GLFW's native glfwSetDropCallback (wired in the vendored external/apone/mods/grappix) — cross-platform, no Apple Event involved. Both paths feed the same play queue.
• dev_update_doctypes.sh — fast, no-recompile test loop: rewrites the Info.plist in an existing bundle, re-signs it and re-registers it with LaunchServices in a couple of seconds. Pass --with-binary to also swap in the freshly-built executable and test double-click playback end-to-end. Run with --help for full usage.

package_app.sh invokes the generator automatically, so a normal release needs no extra steps.

Signing & distribution (Developer ID)

package_app.sh requires an explicit action flag (run it with no arguments to see full usage):

Command	Result
./package_app.sh --buildapponly	Build .app + zip, ad-hoc self-signed (local/dev; Gatekeeper blocks it on other Macs).
./package_app.sh --applesign --signid="Developer ID Application: Name (TEAMID)"	Build, then Developer ID sign with Hardened Runtime + entitlements.
… --notaryprofile=NAME	Additionally notarize with Apple and staple the ticket.
… --reusebuiltapp	Skip the build and (re)sign the .app already on disk — the fast re-sign / re-notarize loop. Requires --applesign; can't combine with --buildapponly.
… --releaseit	After packaging, interactively publish the GitHub release. Requires --applesign + --notaryprofile — see below.

Flags accept a single or double dash and are case-insensitive; value flags use --key=value.

Signing and notarizing both come from the same Apple Developer Program membership and use the free notarytool — neither involves Mac App Store review. The certificate and credential setup is a one-time job, documented in RELEASE_PROCESS.txt.

Full distributable build:

./package_app.sh --applesign --signid="Developer ID Application: Your Name (ABCDE12345)" --notaryprofile=chipmachine-notary

Publishing the official release

Every published release is Developer ID signed and notarized. --releaseit enforces that: an ad-hoc or un-notarized build is refused before the build even starts, and there is no override flag. Before uploading, a release gate extracts the finished zip and re-verifies the copy a user would receive, aborting on any failure.

./package_app.sh --applesign --signid="Developer ID Application: Your Name (ABCDE12345)" --notaryprofile=chipmachine-notary --releaseit

Full checklist in RELEASE_PROCESS.txt — one-time signing setup, version bump, what the gate checks, post-publish verification, and how to recall a bad release.

In-app update check

src/macnative/CheckForUpdate.mm polls api.github.com/repos/mihailod/chipmachine/releases/latest at startup and reads only tag_name, comparing it against VERSION_STR. It never inspects assets, so renaming or re-signing the download is invisible to it — but it does constrain how releases are tagged and recalled, which RELEASE_PROCESS.txt spells out.

The MAS build compiles none of this — CM_MAS reduces the entry point to a no-op, since the App Store delivers its updates and steering users to a GitHub download would violate App Store guidelines.

Entitlements live in src/macnative/ and are documented in entitlements-README.md: the main executable and the bundled yt-dlp helper each get com.apple.security.cs.disable-library-validation (the helper is a PyInstaller Python freeze that fails library validation under Hardened Runtime otherwise). No JIT entitlements are needed — the app links vanilla Lua, not LuaJIT. The entitlements plists are intentionally comment-free: macOS's kernel entitlement parser (AMFI) rejects XML comments.

Mac App Store build (MAS variant)

The Mac App Store variant is packaged with --mas, which builds from build-mas/ (configure it once with -DCM_VARIANT=mas, see Build variants), skips the yt-dlp helper, applies the App-Sandbox entitlements, and produces a signed .pkg instead of a zip.

Command	Result
./package_app.sh --mas --buildapponly	Build ChipMachine.app, ad-hoc-signed but sandboxed — a local test build. No certificates needed.
./package_app.sh --mas --applesign --distribid="Apple Distribution: Name (TEAMID)" --installerid="3rd Party Mac Developer Installer: Name (TEAMID)" --provision=/path/to/ChipMachine.provisionprofile	Build, sign for the App Store, embed the provisioning profile, and emit a signed .pkg for upload.

The three signing inputs (--distribid, --installerid, --provision) require the paid Apple Developer Program plus an App Store Connect record for the bundle id org.mihailod.chipmachine. Upload the resulting .pkg with Transporter.app or xcrun altool --upload-app. There is no zip and no notarization for this variant — the App Store handles review and signing.

MAS entitlements are in entitlements-app-mas.plist: com.apple.security.app-sandbox + com.apple.security.network.client (outbound only — the app runs no listening server; it deliberately does not declare network.server). No disable-library-validation and no yt-dlp helper, since the MAS build ships neither.

Not yet wired for a live submission: the app still needs file-access sandbox entitlements (com.apple.security.files.user-selected.read-only plus security-scoped bookmarks) for the double-click / "Open With" path to work under the sandbox. --mas --buildapponly is fully usable for local testing today.

Using the application

• Type words separated by spaces for incremental search
• ENTER to play, SHIFT-ENTER to enque
• F1 = Player screen, F2 = Search screen
• F5 = Play/Pause
• F9 = Advanced search: set/reset search filter by platform (ie. Amiga)
• F6 = Next Song (or ENTER from Player Screen)
• ESC = Clear search field
• SHIFT-ESC = Quit
• F7 = Toggle Favorite
• Type shoutcast to see the radio-stations
• Things in progress / to come

Data Sources

Chip Music Collections

Metadata from these databases is ingested, normalized, deduped and cross-checked for screenshots.

• Modland - https://ftp.modland.com
• High Voltage SID collection - https://www.hvsc.c64.org
• Gamebase64 - http://www.gb64.com
• AMP (Amiga Music Preservation) - http://amp.dascene.net
• RKO - http://remix.kwed.org
• Atari ST (SNDH) - http://sndh.atari.org
• SNES Music - http://snesmusic.org
• Atari SAP (ASMA) - http://asma.atari.org
• HVTC (High Voltage TED Collection) - http://plus4world.powweb.com
• NSFE (Famicompo mini NSFE archive of 1,228 songs from https://forums.nesdev.org/viewtopic.php?t=21128)
• Mod Archive - https://modarchive.org
• Bitworld - http://janeway.exotica.org.uk
• Exotica - https://www.exotica.org.uk
• CSDb - https://csdb.dk
• ZX Art - https://zxart.ee/eng/music
• CPC-Power - https://www.cpc-power.com
• Zophar's Domain - https://www.zophar.net
• Vampi's MDX Collection (Sharp X68000) - https://mdx.vampi.tech
• Demozoo - https://demozoo.org
• Scene.org - https://scene.org
• OPL Archive - https://opl.wafflenet.com
• Bulba's ZX Spectrum & Amstrad CPC AY/YM Music Archives - https://bulba.untergrund.net/music_e.htm
• VGMRips - https://vgmrips.net
• ZX TUNES - https://zxtunes.com
• SMS POWER! - https://www.smspower.org
• MirSoft - http://www.mirsoft.info
• Chipmusic - https://chipmusic.org
• Battle of the Bits - https://battleofthebits.org
• keygenmusic (Internet Archive) - https://archive.org/details/keygen-music-2020-03-pack

Remixes / Recordings / Streaming (mp2/mp3/ogg/flac/wav/aif/aiff/opus)

• Pouët.net - https://www.pouet.net
• Amiga Remix (MP3) - http://amigaremix.com
• OverClocked ReMix (MP3) - https://ocremix.org
• Sounds of Scenesat - https://scenesat.com
• Demozoo -- https://demozoo.org

Youtube Audio

• Pouet - https://www.pouet.net

Podcasts

Press F9 and pick Podcasts to browse/filter only podcast episodes. Shows backed by a live RSS feed ship with a snapshot of their back catalogue and are refreshed from the feed in the background at startup (throttled to roughly once a day), so newly published episodes are merged in automatically without a full re-index.

• C64 Take-away — Commodore 64 remixes & original SID (complete, ended 2025) - https://c64takeaway.com
• This Week in Chiptune — chiptune mixes (Dj CUTMAN, 2013–2017 archive) - https://thisweekinchiptune.com
• Pixelated Audio — video game music & interviews - https://pixelatedaudio.com
• GameFuel — video game music (KNGI Network) - https://kngi.org
• Nitro Game Injection — video game music & remixes (KNGI Network) - https://kngi.org
• Demovibes — demoscene music - https://www.demovibes.org
• AmigaVibes — Amiga & demoscene music - http://www.amigavibes.org
• Syntax Error — game & demoscene music (Sol) - http://www.syntaxerror.nu

And one not related to retro music but dear to my heart so here it is:

• Completely Unnecessary Podcast — retro gaming (Pat "The NES Punk" Contri & Ian Ferguson) - https://cupodcast.podbean.com

Shoutcast Radio Streams

• Scenesat - https://scenesat.com
• SLAY Radio - https://www.slayradio.org
• Nectarine - https://scenestream.net
• VGM Radio - http://vgmradio.com
• NoLife-Radio - https://www.nolife-radio.com
• Rainwave - https://rainwave.cc
• The Sid Station - https://c64radio.com
• Radio PARALAX - https://www.radio-paralax.de
• CVGM Radio - https://radio.cvgm.net
• Kohina - https://kohina.com
• Gyusyabu NEC PC-98/Sharp X68000 - http://gyusyabu.ddo.jp

What it plays

350+ music formats, decoded by 60+ plugins. Everything is played back natively — no external players, no command-line helpers.

Every plugin has its own README covering the engine behind it, how shared extensions are routed, licensing and known gaps. Start at the plugin index; the table below is the short version.

PC & Amiga trackers

Plays	Extensions	Plugin
ProTracker, FastTracker II, Impulse Tracker, ScreamTracker, OctaMED, OpenMPT, Symphonie, Digital Symphony, Graoumf Tracker and ~30 more	.mod .xm .it .s3m .mptm .med .okt .symmod .dsym …	openmpt
Amiga "exotic" custom replayers (TFMX, Future Composer, SidMon, Hippel, Sonic Arranger, David Whittaker, Rob Hubbard …) — the original 68k code, ~180 replayers	~400 extensions, matched as a filename prefix or suffix	uade (Plus only)
AHX / HivelyTracker	.ahx .hvl .thx	hively
MikMod UNITRK / UNIMOD	.uni	mikmod
Old (pre-OctaMED) MED	.med	med
MaxTrax	.mxtx	maxtrax (Plus only)
JayTrax / Syntrax	.jxs	jxs
Ixalance	.ixs	ixs
ProTrekkr / NoiseTrekker	.ptk .ntk	ptk
Quartet	(companion .set banks)	quartet
Farbrausch V2 Synthesizer System	.v2 .v2m	v2

Commodore

Plays	Extensions	Plugin
C64 SID (6581/8580, incl. 2SID/3SID)	.sid .rsid	csid
Compute!'s Sidplayer (clean-room sequencer — what lets the App Store build play these ~6.5k songs)	.mus .str	mus
Compute!'s Sidplayer via VICE	.mus .str	vicebridge (Plus only)
GoatTracker	.sng	goattracker (Plus only)
Commodore 264 series (16 / 116 / Plus/4) TED	.prg	tedcr
VIC-20 VIC-TRACKER	.vt	victracker

ZX Spectrum, Amstrad CPC, Sam Coupé

Plays	Extensions	Plugin
ZX Spectrum AY-3-8912 trackers — 67,305 songs, the largest format family here	.pt1 .pt2 .pt3 .stc .asc .psc .sqt .stp .vtx .vt2 .psg .ftc .psm .gtr .st11 .fxm .amad …	zxay
TFM Music Maker and Chip Tracker (the two ZX formats that are not AY music)	.tfe .chi	zxtune (Plus only)
ZX Spectrum 1-bit beeper music (Beepola: SFX, Phaser1, Music Box, Music Studio)	.bbsong	bbsong
STarKos / Arkos Tracker (Amstrad CPC)	.sks .aks	sks
Sam Coupé SAA1099 music	.cop	cop

Atari

Plays	Extensions	Plugin
Atari ST/STE SNDH	.sndh .snd	sndh
Atari ST YM2149 register dumps	.ym .mix	stsound
Atari 16-bit SC68 container	.sc68	sc68 (Plus only)
Megatracker (Atari ST)	.mgt	mgt
Atari XL/XE POKEY (PokeyNoise)	.pn	pokeynoise (Plus only)
Atari 8-bit SAP (the ASMA corpus)	.sap	gme

MSX and Japanese computers

Plays	Extensions	Plugin
MSX drivers + FAC SoundTracker	.mgs .bgm .opx .mpk .mbm .mus	kss
SCC-Musixx (Konami SCC)	.SNG	sccmusixx
NEC PC-98 FMP (incl. OPNA hardware-rhythm drums)	.opi .ovi .ozi	fmp
S98 FM register logs (incl. OPNA rhythm drums)	.s98	s98
FM Towns / PC-98 Euphony	.eup	eup
Sharp X68000 MDX	.mdx (+ .pdx banks)	mdx (Plus only)

Consoles

Plays	Extensions	Plugin
NES/Famicom, Game Boy, SNES, Master System, Genesis/Mega Drive, PC Engine, MSX, ZX, CPC, BBC Micro, POKEY	.nsf .nsfe .gbs .gbr .spc .sgc .gym .hes .kss .ay .vgm .vgz .sap .emul	gme
VGM/VGZ on the libvgm cores (incl. OPL2/OPL3, 32X PWM, Virtual Boy VSU)	.vgm .vgz	libvgm
FamiTracker (NES + VRC6/VRC7/MMC5/FDS)	.ftm	famitracker (Plus only)
NerdTracker II (NES)	.ned	ned
DefleMask / Furnace chiptunes	.dmf	dmf (Plus only)
DefleMask, SEGA Genesis / Master System (clean room)	.dmf	dmfcr
Game Boy Advance	.gsf .minigsf	gsf
Nintendo DS	.2sf .mini2sf	nds (Plus only)
Nintendo 64	.usf .miniusf	usf (Plus only)
PlayStation 1 & 2, Sega Saturn, Capcom QSound	.psf .minipsf .psf2 .minipsf2 .ssf .qsf	ao (Plus only)
Dreamcast & Saturn	.ssf .dsf .minissf .minidsf	ht (Plus only)
Bandai WonderSwan / Color	.wsr	wsr
RAR-packed SNES sets	.rsn .rps .rdc .rds .rgs .r64	rsn
Streamed in-game audio — CRI ADX/HCA, FMOD FSB, XWB/XMA, Nintendo DSP, PS VAG, AT3/AT9 and ~700 more	.adx .hca .fsb .xwb .dsp .vag …	vgmstream

Acorn, Apple, Macintosh, MS-DOS

Plays	Extensions	Plugin
Acorn Archimedes Tracker (!Tracker, 8 channels)	.musx	musx
Coconizer (Archimedes)	.coco	coco
Apple IIgs SoundSmith (Ensoniq 5503)	song name + .W wavebank	soundsmith
PlayerPRO (classic Macintosh)	.mad	playerpro
AdLib / Sound Blaster OPL formats — ~50 of them	.a2m .cmf .d00 .dro .hsc .imf .laa .rad .rol .sci …	adplug
Funktracker (FunktrackerGOLD / DOS32)	.fnk	fnk
SBStudio	.pac	sbstudio
MONOTONE (IBM PC speaker)	.mon	monotone

Softsynths, modern trackers, streaming audio

Plays	Extensions	Plugin
SunVox	.sunvox	sunvox
klystrack	.kt	klystrack
PxTone Collage	.ptcop .pttune	pxtone
Organya (Cave Story)	.org	org
MP3, AAC, M4A/MP4, Ogg/Vorbis, Opus, FLAC, WAV, AIFF, AC3, MP2, WMA, IFF-8SVX — local files, downloads and radio streams	.mp3 .m4a .ogg .opus .flac .wav .aif …	ffmpeg
YouTube links (youtube.com / youtu.be) — how the Pouët database plays demoscene soundtracks	—	(Plus only)

(Plus only) marks a decoder that ships in ChipMachinePlus but not in the Mac App Store build — see Build variants. The catalog hides anything the running build cannot play, so you never see a song that will not start.

Formats we deliberately skip

The collections we index are not curated for us: they carry files that no player in this stack can turn into sound. If those were indexed they would look like ordinary songs, download on ENTER, and then dead-end — so the indexer drops them up front, and the format simply never appears in search. That is why a handful of directories you can see on modland (or a scene.org compo dir) have no entries here.

Broadly: formats with no open replayer (Renoise, Psycle, Jeskola Buzz, Sound Club, BeRoTracker, StoneTracker), files that are not music at all (archives, DAW projects, ROMs and disk images — we play the ripped chip logs, never the parent ROM), companion files that belong to a tune rather than being one, and a few formats where an engine looked like it would work and measurably did not.

The list, with the evidence for each entry, is data/misc/not_supported_extensions.txt.

---

Credits

ChipMachine is my favorite Mac retro chiptune player and I have been using it forever. However, when opening it on my Mac after a recent macOS update, I saw this annoying popup above. It upset me and I channeled that anger into this project.

This is mostly a preservation effort. I am making this project for myself so I am able to continue enjoying listening to my favorite music in a clean and inspirational way the original Chipmachine was providing to me over many many years.

My work here is mostly based around:

• Porting: from Intel to ARM
• Integration: with / adding of various new plugins that did not exist in the Intel version
• Content curation: updating / adding more songs and fixing their metadata from various databases
• Administration: maintenance, releasing, PR merging, support, promoting

I don't take or imply any credit for the original idea and implementation and actual players development (the hardest part IMO).

Attribution for the individual emulators, audio players, plugins and core sub-routines used across this project is maintained as a single source of truth in the licence notices, not here — see Licensing below.

---

Licensing

• ChipMachinePlus: Copyright (c) 2026 Mihailo Despotovic. Licensed under PolyForm Noncommercial License 1.0.0.

• 🟢 Free to use for personal, educational, research, and non-commercial projects.
• 🔴 Commercial use prohibited. If you intend to use my code in any way in any revenue-generating product, contact me for a commercial license.

• Original ChipMachine Program: Copyright (c) 2022 Jonas Minnberg. Licensed under the MIT License.
• Third-party components: see LEGAL — the standalone notice covering everything in the app, and the single source of truth for attribution.
• ChipMachinePlus extras: see LEGAL-PLUS — an addendum to LEGAL covering only the copyleft engines the Plus build links and the Mac App Store build does not.

package_app.sh assembles the in-app About panel (Credits.rtf) from those same two files, so the app, the repo and the release always agree: the Mac App Store bundle gets LEGAL, the Plus bundle gets LEGAL + LEGAL-PLUS.