ninety-four 🏒

NHL '94, rebuilt in C.

The greatest hockey game ever made, running natively on your machine, with no emulator in sight. All of the roughly 1,500 routines of EA's 1993 Sega Genesis classic have been rewritten by hand in C and checked against the original, frame by frame, until the two can't be told apart. The same one-timers, the same diving saves, the same organ, the same Gretzky. Smooth 60 frames a second, without the cartridge's slowdown.

And things the cartridge never had:

• Rollback netplay. Two to four machines over the internet or a LAN, up to four players with EA's 4 Way Play, and rollback so no one waits on anyone's connection. Host from the menu, and the others join. Linux, Windows and Mac all play each other.
• Your favourite ROM hack's rosters, playable and editable. Give it a hack made on the 32-team template (NHL 2026 94 Edition, NHL 94 2025, the 30th Anniversary Championship Teams and the like) and it takes the lot: teams, players, ratings, lines, playoff draws, colours and jerseys, logos, banners, centre ice, player photos, title screens and rinks. Out come CSV files a spreadsheet opens and PNGs any paint program edits. Change anything and play it.
• Rosters of your own, up to 32 teams, started from the cartridge's or a hack's, packed into one zip to send to a friend.
• Game rules of your own: the weight bug fixed, plus/minus, more period lengths, skating speed, shot power, how far the puck slides, tiring, penalties, hot and cold streaks, a wide rink view, and presets. Classic, the default, is the original exactly.
• Save states: eight slots with a picture each, the Autosave when you quit, and hold F4 to rewind the goal you just gave up.
• All of it online. The host's rosters and rules go to every machine, so no one else needs a copy. Seasons go online in a save state: anyone saves one, and the host loads it for everyone.

Hold F6 to fast-forward, slow the replay of that one-timer down, step through it a frame at a time, and press F12 to keep it. Scored a beauty? F10 saves the last 20 seconds as a GIF to share.

Download

The latest release has builds ready to run:

• Linux (x86-64, glibc 2.34 or newer): ninety-four-X-linux-x86_64.tar.gz. It needs SDL2 (sudo apt install libsdl2-2.0-0 on Debian and Ubuntu).
• Windows (10 or newer, 64-bit): ninety-four-X-windows-x86_64.zip, with SDL2.dll inside.
• macOS (11 or newer, Apple Silicon or Intel): ninety-four-X-macos-universal.zip, one app. It is not signed by a registered Apple developer, so the first time, Control-click it and choose Open (its README says more).

Unpack it anywhere and run it. The first time, it asks for your ROM in a file browser and remembers it: bring your own dump of the 1 MB retail cartridge (US/Europe). For online play, every machine needs the same release.

Or build it from source and you're on the ice in a minute (what to install first is under Build):

git clone --recursive https://github.com/1nputs/ninety-four.git && cd ninety-four
make nhl94
./build/nhl94          # the first time, it asks for your ROM (or give it with --rom FILE)

	Player 1	Player 2
D-pad	arrows	I J K L
A / B / C	Z / X / C	Q / W / E
Start	Enter	Tab

Game controllers work too (the first two are players 1 and 2).

Key
F1	mute
F2 / F3	volume down / up
F4 (held)	rewind
F5	pause
F6 (held)	fast-forward
F7	slow motion on / off
F8	a frame at a time, while paused
F10	save the replay: the last 20 seconds, as a GIF (in videos/)
F11	start / stop recording a GIF
F12	screenshot (a PNG in screenshots/)
Esc	the menu: save and load states there
Alt+Enter	full screen

Playing

The menu

Esc (or a controller's Back button) opens it; arrows and Enter, or the d-pad, A and B, work it.

• Game ROM: your cartridge dump, in a file browser.
• Reset, and Save state / Load state: eight slots, each with a picture of the moment, in states/ beside the game. States are taken during play (not in the menus or a pause). Quitting saves the Autosave (where you were, in play), first on the Load page: the game always starts fresh, and loads it only when you choose it.
• Video: a pixel-art upscaler (Scale2x, Scale3x or MMPX, which smooth the staircases without blurring or adding colours, or xBR, which blends its edges smooth); sharp, integer or fit scaling; square pixels or 4:3; the colours' levels (standard, full range or the console's own); dithering blended as a television blended it; a picture tube's scanlines and its aperture grille, slot mask or shadow mask; full screen; and Vsync, so nothing tears (on unless you turn it off).
• Capture: the last 20 seconds are always kept; F10 (or this page) saves them, and F11 records until you press it again. They go to videos/ as GIFs (exact colours, 30 frames a second, no sound). The page sets how long the replay is and a GIF's size.
• Sound: volume, and the FM core and chip (hear the difference as you play).
• Players: which controller each player has, a controller's buttons (press the new one), turbo A / B / C, the stick's dead zone, and EA's 4 Way Play for four players (as on the cartridge: set it, Reset, then choose Players: Three or Four in the game's setup screen).
• Rosters: who plays (below).
• Game rules: how the game plays (below).
• Online play: two to four machines, any players at each (below).
• Options and Keys: fast-forward speed, the FPS counter, and every key of the pads and the controls (pick one and press the new key, with Shift, Ctrl or Alt if you like).

All of it is kept in settings.ini, in the folder you run the game from, beside its saves; you can edit it while the game is closed. The macOS app opened from the Finder keeps them in ~/Library/Application Support/ninety-four. On a Mac, hold Fn for the function keys.

Game rules

Things the cartridge never offered, for every player and the whole game. They are set before a game starts (a change made during one shows from the next Reset), and a saved state keeps its game's rules. Classic, the default, is the original exactly.

• Fixes and stats: the weight bug fixed (the original sums a check's weights in a byte that wraps, so a heavy skater checked by a lighter player falls easily), the second assist kept on a give-and-go, and plus/minus with body checks in Player Stats (the sort scrolls on to two more columns; power play goals count for no one's +/-).
• Time: more period lengths in the setup (2, 3, 7 and 15 minutes besides 5, 10 and 20), and the regular season's overtime length.
• How it plays: skating speed, the speed burst, shot power, how far the puck slides, tiring, bench rest, rest in the penalty box, how many penalties are called, and hot and cold streaks.
• Presets set them all: Classic, Simulation (the fixes and stats, a weaker burst, fewer penalties, milder streaks) and Arcade (faster, harder, livelier).
• The rink view: 320 wide instead of the cartridge's 256, showing the whole width of the ice with the camera moving less, the scoreboard and overlays in the middle (the pause screen stays 256 wide, as on the cartridge).

The rules that are amounts are numbers underneath. The page steps through named choices, each showing its number (Skating speed: classic, faster 110%, fastest 125%, slower 90%), and settings.ini takes a name or any number in the rule's range (rules.skating = 115), which the page then shows as "custom (115%)"; the preset line follows what the file holds. --rule takes the same (--rule skating=115; a wrong one says what the rule takes).

Rule	Its number	Named	Range
overtime	minutes of regular season overtime	classic 10, 5min, 3min	1 to 20
skating	% of acceleration and top speed	classic 100, faster 110, fastest 125, slower 90	50 to 150
burst	% of the speed burst's push	classic 100, weaker 50, weakest 25, stronger 150	0 to 200
shot_power	% of a shot's speed	classic 100, harder 115, softer 85	50 to 150
puck_slide	% of the puck's slowing on the ice (less slides farther)	classic 100, farther 67, shorter 150	25 to 200
tiring	% of the energy skating and bursts use	classic 100, less 50, more 150	0 to 200
bench_rest	% of the energy the bench gives back	classic 100, faster 150, slower 67	0 to 200
penalties	% of penalties called (icing and offside always)	classic 100, fewer 50, rare 25	0 to 100
streaks	% of hot and cold streaks' effect on ratings	classic 100, milder 50, off 0	0 to 200

The ranges are what the game's motion takes: headless games at both ends of every one, all at once, play on with every speed well inside what the game keeps. The on / off rules and period lengths are on / off and classic / more; the rink view is classic / wide.

Online play

Two to four machines, over the internet or a LAN, with rollback: each game plays its own players' buttons at once and guesses the others', and when theirs arrive different it plays the last few frames again with them before drawing the next, so no one waits. The menu's Online play page: Name; Role: host, join, or (two machines) both connect at once (most home routers let that through without a forwarded port); the address and the port; this machine's LAN address; the input delay (frames between pressing and the game seeing it, 2 by default: more means fewer rollbacks over a long way); Players here (how many play at this machine: its players 1, 2 and 3); and, for the host, Total players. The host waits until they are all in, then the game powers on everywhere: the host's players on pads 1 onward, then each machine's as it joined. Two machines with a player each, choose Players: Two - Head to Head (or Two - Teammates) on the setup screen; four machines with one each, two with two, three with two and one and one, one and three: with pads 3 or 4 played EA's 4 Way Play is in the ports on every machine (Players: Three or Four). If anyone leaves, the game is over for everyone, each told who left. From the command line: --host [PORT], --join ADDR[:PORT], --peer ADDR[:PORT] (two machines both connecting, --port your own), --delay N, --name NAME, --here N, --players N (the host's).

The game is the host's: its Rosters and Game rules pages' choices go to every other machine before the game starts, rosters as their package (the NHL 2026 edition's, every photo included, is about 1.7 MB), so no one else needs a copy of them. Every game online starts from a new cartridge (default lines, no records): every machine must play the same save RAM, or the games would differ at once, so no one's save file is read for it or written by it, during the session or after it while the game plays on alone. Seasons, lines and records go online in a state instead: anyone's Save state saves one every machine has played (all its buttons known), and the host's Load state loads one for everyone, at the same frame on every machine, the game and its save RAM as they were saved (a state of other rosters than the session's is refused, saying so; a guest's Load state says only the host can). So a season played alone goes online by saving a state, hosting, and loading it; and closing the window in a session saves the Autosave as ever. While the session lasts every machine's Rosters and Game rules pages show the host's choices, greyed (their own come back after it), and the host's rosters stay on the others' Rosters pages until they quit. The window's pause, slow motion, fast-forward and rewind are not to be had while you play together, and only the host can reset: the menu's Reset (chosen twice) powers every machine's console on again at the same frame, the game from its start for everyone and the session going on, the save RAM as it is then (the cartridge's battery keeps it). Every machine needs the same build of the game and the US/Europe cartridge, or it is refused.

Rosters

Play the cartridge's 26 teams (and its two All-Star teams), or rosters of your own of up to 32: teams, players, ratings, lines, colours, logos, banners, centre ice, player photos, and even the title screens, rinks, sprites and fonts every team shares. Rosters are a folder of text files a spreadsheet opens and PNGs any paint program edits, in rosters/ beside the game, or the same packed in one zip.

./build/nhl94 --export-rosters rosters/my-rosters          # the cartridge's rosters, to change as you like
./build/nhl94 --extract-rom "HACK.bin" rosters/2026      # a hack's rosters (read as data, never run)
./build/nhl94 --check-rosters rosters/my-rosters           # what holds, or what is wrong and on which line
./build/nhl94 --pack-rosters rosters/my-rosters my.zip     # one file to keep or send, played as it is

(Each needs the cartridge too: --rom FILE, or your dump in the folder as NHL 94 (UE) [!].gen.)

Choose one on the menu's Rosters page and Reset: those in rosters/ are listed, and its Files line finds one anywhere else (a folder, or a package). The page says what the chosen rosters hold: where their files are, how many teams they have (and how many play for the cup), and sixteen pages of them to step through with left and right: their best skaters, goalies and teams, their fastest skaters, hardest shots, sharpest shooters, passers, stickhandlers and hitters (rated as the game's cards and roster screen rate them), their heaviest and lightest players, the teams' power play, penalty killing, home and road bonuses, and the rosters in numbers. Each set of rosters keeps its own records, and a saved state plays on with the rosters it was saved in. The cartridge's own rosters, exported and built again, play the original frame for frame.

Community hacks made on the 32-team template (NHL 94 2025, NHL 2026 94 Edition, the 30th Anniversary Championship Teams and the like) extract whole: teams, players, ratings, lines, playoff draws, colours and jerseys, and all their art. Their code is not taken, so what a hack changed there (its own gameplay, extra menu lines, its texts) is not either. A known issue: NHL 94 2025 rates its players on a wider scale of its own, which plays here as the cartridge's best at most (docs/ROSTERS.md).

Everything about rosters, file by file and column by column, is in docs/ROSTERS.md: the folder's layout, every CSV column and its range, the art's sizes and colours, what is and is not taken from a hack, packages, records and states.

Build

The hardware side is pulseman, our Mega Drive runtime, included as a git submodule in ext/pulseman: clone with --recursive, or after a plain clone run git submodule update --init. make nhl94 builds it too. Besides that you need GCC (C and C++), make, pkg-config and SDL2. The game builds with Clang as well and plays bit for bit the same: make golden-cross builds it and pulseman with Clang (XCC= and XCXX= name it, or ZIG=path/to/zig takes Zig's) and checks its golden runs against the GCC build's (Clang 22 here: every run identical). The builds made and tested here use GCC. Your saves go to out/ in this repository, and your states to states/.

Linux (built and tested here, Debian 13, GCC 14):

sudo apt install build-essential pkg-config libsdl2-dev          # Debian, Ubuntu
sudo dnf install gcc gcc-c++ make pkgconf-pkg-config SDL2-devel  # Fedora
sudo pacman -S --needed base-devel sdl2                          # Arch
make nhl94
./build/nhl94 --rom "/path/to/NHL 94.gen"

macOS (the download is cross-built here with Zig's Clang for Apple Silicon and Intel, and played on a Mac, online too; building on a Mac itself is not yet tried). To build it there, install GCC from Homebrew and name it (Apple's gcc is really Clang):

brew install gcc sdl2 pkg-config
make CC=gcc-15 CXX=g++-15 nhl94          # the version brew installed: ls $(brew --prefix)/bin/gcc-*
./build/nhl94 --rom "/path/to/NHL 94.gen"

Windows (cross-built here with MinGW-w64 GCC 14 without a warning, and run on Windows), with MSYS2, in its UCRT64 shell:

pacman -S --needed git make mingw-w64-ucrt-x86_64-gcc mingw-w64-ucrt-x86_64-pkgconf mingw-w64-ucrt-x86_64-SDL2
make CC=gcc CXX=g++ nhl94
./build/nhl94.exe --rom "C:/path/to/NHL 94.gen"

The C++ runtime is linked in, so outside the MSYS2 shell build/nhl94.exe needs only SDL2.dll beside it (cp /ucrt64/bin/SDL2.dll build/).

If a compiler newer than these warns about something, make WERROR= nhl94 builds anyway; please tell us what it said.

make release VERSION=X makes the downloads for all three from clean at the commit checked out (tools/release.sh, which says what it needs: MinGW-w64, Zig, SDL2's macOS framework, llvm-lipo, rcodesign): ninety-four-X-linux-x86_64.tar.gz, ninety-four-X-windows-x86_64.zip and ninety-four-X-macos-universal.zip, a ninety-four.app for macOS 11 or newer, signed ad hoc as a whole under its bundle identifier, so macOS can ask it for the local network.

For agents: where this stands (21 October 2026)

• What it is. A hand-written C reimplementation of NHL '94 (Genesis, US/Europe retail, SHA-1 7b1489ab501258133bf03e5f0892b77d04312580). src/ has one C file per asm module of the community's byte-exact rebuild (34 modules, about 1,500 routines, the same names). The Z80's 661-byte sound relay is ported too (src/z80.c). It runs on pulseman (1nputs/pulseman, MIT, the git submodule ext/pulseman; its C API keeps the mdrt_ prefix): the VDP, PSG, YM2612, pads and save RAM as C modules, with an SDL2 platform. There is no 68k or Z80 emulation. A change to pulseman is committed and pushed there, then the submodule's new commit is committed here.
• How it is verified. Genesis Plus GX with a hook (the oracle, a development tool only) records real play. make test replays 10,276 recorded routine calls. make lockstep runs 18 whole sessions against the oracle, checking work RAM and VDP at every vblank. make golden-check compares the native build's own output with a recorded build, bit for bit (20 runs, about 227,000 frames, the rules' and rosters' own among them), plus save-state round trips. make golden-cross builds the game and pulseman with Clang and checks the same runs against it: the game plays bit for bit the same whatever compiles it, as netplay between builds needs; make golden-ubsan checks them with the undefined behaviour sanitizer. make netplay-check plays nine sessions from power on (headless, over the loopback through a simulated network: delay, jitter, loss, duplicates; the host's rosters and rules sent; input delay 0; two to four machines, 4 Way Play: two each, one each on four, two and one and one, one and three; the host's reset; a state with records loaded for everyone), every machine's every frame as a solo run of the same buttons. make rulestest checks the game rules on the game's own routines (and the Rosters page's ratings against the cards' for every player). make rosterstest checks the rosters: the cartridge's exported and built again, its tables and art the cartridge's; a 32-team one; 22 broken ones refused; and with hack ROMs in ../roms (or HACKS=), each extracted, built to its teams, colours and art as the hack has them, played and packed. pulseman is checked on the oracle's vectors (make runtime-check) and on this game's own recordings (make runtime-selfcheck).
• Done. The harness, the game-play core, video and sound, the frame drivers, native running, lockstep, the whole front end (it boots from power on), a cleanup, golden runs, native save states and rewind. Then the game rules (src/rules.h: numbers, Classic the original's, kept in states) and rosters (src/rosters.h's tables; native/rosters.c reads and builds them, native/romsrc.c reads hacks, native/art.c the pictures, docs/ROSTERS.md the format), the Rosters and Game rules pages. Rollback netplay (native/net.c: pulseman's mdrt/netplay.h, resuming at the game loop's wait as a state does; the window's Online play page, or --host, --join, --peer; the host's rosters and rules sent; two to four machines, any players at each, up to four; the host's reset, and states: anyone's saved, the host's loaded for everyone). The downloads (make release, tools/release.sh: Linux, Windows, a universal macOS app). In pulseman: the console's state as a value, a client-owned clock with line-by-line drawing and an H-interrupt hook, a bus map, FM cores and models chosen at run time, a trace recorder, PNG and zip, the client's option pages, and vsync.
• Native state (the owner's direction): the game's state is native structs (the 68000's offsets, the host's byte order, any compiler), generated with the address map by tools/gen_ram.py: the team structs, the night's games, the replay frames, the sound driver's slots, channels and voices, the sort objects and their drawn parts (the pads, the arrows, the replay camera), the menus, the faceoff, the plane maps, the clock and the rest; byte buffers in the machine's own formats (Strings, the sprite table, the DMA list, records) are host bytes (ram_bytes). The console's big-endian view is made on demand (src/mem.h, src/ram.c's map, ram_pack/ram_unpack for the checks and states); what still goes by 68000 address is listed at the top of src/mem.h. The rosters are native tables too (src/rosters.h's roster_team: read off the cartridge for its own rosters, made from the rosters' folder for another); its art stays in the cartridge's formats, read by number (the cartridge's, or the rosters' own past it), and the art map (native/art.c) says what every number is: --art-map prints it, and every golden run checks that each byte the VDP takes by DMA is in a piece of it (--art-check), for texture packs later.
• Deferred by the owner. WebAssembly (the game's code compiles for it now; a browser platform for pulseman is the job) and the cartridge's slowdown (it needs a 68k cost model).
• Read first. ext/pulseman/README.md and docs/API.md there; the comments at the top of tools/oracle/vectors.py, tools/golden.py and tools/hybrid/oracle_shim.c. The working notes (the handoff guide, the plan, the playbook for another game) are kept outside the repository.
• Rules. The ROM and everything made from it (states, traces, captures, screenshots, GIFs such as tools/goal_gif.py makes) stay out of git. Commit after each finished job. Before and after a change: make test, make lockstep, make golden-check; for a runtime change, also make runtime-check and make runtime-selfcheck.

./tools/fetch_refs.sh && tools/asm/build_vasm.sh     # references, the oracle core, the byte-exact rebuild
cp /path/to/rom "NHL 94 (UE) [!].gen"                # your ROM at the repo root
make oracle && make vectors                          # the oracle; every state and vector (tools/oracle/vectors.py)
tools/hybrid/capture_all.sh                          # the 29 capture sessions (~15 min, 3.6 GB)
make test && make lockstep && make golden-check      # the checks

Features

From the least ambitious to the most.

• The whole game from power on: exhibition, playoffs, shootouts, user records, every menu and screen
• FM and PSG music and effects, the Z80 sound relay ported to C
• Keyboard and two game controllers
• Window scaling, full screen, 4:3 aspect
• Battery save (save RAM) kept in a file
• Smooth 60 frames a second (no cartridge slowdown)
• Save states (the menu's slots) and rewind (F4)
• FM core and chip model choice (--fm-core nuked|ymfm, --fm-model ym2612|ym3438)
• Headless runs: screenshots, WAV, scripted input, RAM watch (--watch), trace recording (--record)
• Mute, volume, audio device and latency options
• A settings file (window, scaling, volume, keys), every key rebindable
• A menu: the ROM in a file browser, reset, video, sound and the FM chip live, key rebinding
• Integer and sharp-bilinear scaling, hi-DPI
• Pixel-art upscalers: Scale2x, Scale3x, MMPX 2x and 4x, xBR 2x, 3x and 4x
• Screenshot key (PNG)
• Fast-forward, slow motion, frame step
• Controller remapping, player slots, turbo, dead zones
• Capture: the replay (the last 20 seconds) and recordings, as GIFs
• Save slots with thumbnails; the Autosave on quit (states during play)
• Game rules, the host's for every player (Classic: the original): period lengths, overtime, the weight bug fix, the second assist fix, plus/minus and checks, skating, burst, shots, puck, energy, penalties, streaks, presets, the rink view
• The rules as numbers: any value in a rule's range in settings.ini or --rule, named choices on the page
• Rosters of your own, up to 32 teams: teams, players, lines, colours and pictures in files, name banners drawn for new teams
• Rosters extracted from hacks on the 32-team template (teams, players, ratings, lines, draws, colours and all their art)
• Rosters packages: rosters in one zip, to keep or send, played as it is
• Rosters art as PNGs to draw over: logos, banners, centre ice, photos, and the art every team shares (title screens, rinks, sprites, fonts ...)
• A Rosters page: choose the rosters, and see its files, teams, best players and teams
• Vsync: no tearing
• Downloads for Linux, Windows and macOS (one app for Apple Silicon and Intel)
• Skip the EA screen, boot straight into a game
• Colour options; scanlines, CRT mask, composite dither blending
• IPS and BPS patches, soft-patching, the ROM check as a toggle for data hacks
• Game Genie and Action Replay codes
• Input recording and replay files
• Save states anywhere, menus and pauses included
• Debug overlay: VRAM, palettes, sprites, a RAM watch and cheat search
• Run-ahead for lower input latency
• The cartridge's slowdown as an option, with an "overclock" slider
• Four players with EA's 4 Way Play adaptor
• Play in the browser (WebAssembly)
• A per-game manifest: named RAM, roster and ratings tables to CSV and back, a hack diff tool
• HD sprite, tile and sound packs
• A wide rink view (320 wide, a game rule; true 16:9 widescreen still to come)
• Lua scripting: overlays, stats, bots
• Python bindings: headless training environments, automated tests
• Replays and spectating
• Rollback netplay online: two to four machines, up to four players (4 Way Play), the host's rosters and rules sent to the others
• States online: anyone saves one every machine played, the host loads one for everyone (seasons and records go online so)
• The next game on the same method and runtime

Greets

Big, big greets to everyone whose work this stands on:

• EA Sports and Park Place Productions, who made NHL '94 in 1993. Still the best.
• abdulahmad/NHL94Genesis: the bitwise rebuild of the ROM in assembly, with every label and the module split, built in the style of its sibling NHLPA93Genesis. Every C file here maps to one of its files, and every routine has its name.
• Chaos81/nhl94-disassembly: the IDA database and listing with the names and comments that made the code readable, and Mhopkinsinc/NHLHockey, the NHL Hockey source code it started from.
• The NHL '94 community and its Discord, keeping the game alive for over thirty years.
• Genesis Plus GX by Eke-Eke (after Charles MacDonald's Genesis Plus): the oracle. Every routine and every frame here was checked against it. A development tool only, never shipped.
• Nuked-OPN2 by nukeykt and ymfm by Aaron Giles: the YM2612 cores that make the music.
• vasm by Volker Barthelmann and Frank Wille: the assembler that rebuilds the ROM byte for byte on Linux.
• SDL: the window, the sound and the controllers.
• MMPX by Morgan McGuire and Mara Gagiu ("MMPX Style-Preserving Pixel Art Magnification", JCGT 2021), xBR by Hyllian, and Scale2x / Scale3x by Andrea Mazzoleni after Eric Johnston's EPX: the upscalers in the Video menu.
• libretro: the API the oracle is hosted through.
• The documenters of the hardware: Charles MacDonald (genvdp.txt), Plutiedev, Sega Retro, SMS Power (the SN76489) and the SpritesMind forum (Nemesis's YM2612 and VDP research).
• Zig, whose bundled Clang checks the game and pulseman against a second compiler.
• apple-codesign (rcodesign), which signs the macOS app from Linux.

License

MIT (LICENSE), for the code written for this project. It grants nothing over NHL '94 itself, its name or its data, which belong to Electronic Arts: bring your own copy of the game. pulseman is MIT too; its FM chip cores are Nuked-OPN2 (LGPL-2.1) and ymfm (BSD-3), and its MMPX and xBR upscalers follow their authors' MIT-licensed code.