NextHack — a NetHack-inspired roguelike for the ZX Spectrum Next & 128K

A from-scratch NetHack-style roguelike built with Z88DK (the zsdcc/SDCC C compiler). One codebase builds two targets:

• the ZX Spectrum Next (+zxn) — hardware tilemap, full-colour 8×8 tiles, Layer 2 title/victory art; tested on ZEsarUX;
• the plain ZX Spectrum 128K (+zx) — ULA display, 1-bit UDG tiles, an edge-scrolling 32-column viewport over the 80-wide map, and attribute-clash SCR loading screens; tested on ZEsarUX.

The two share all game logic; only the platform/render layer differs, selected at compile time by #ifdef __ZXNEXT. Both are code-banked to break the Z80's 64 KB ceiling (the Next via its MMU, the 128K via port 0x7FFD).

Downloads & history: grab the latest .nex / .tap from the Releases page; see CHANGELOG.md for what changed in each version.

The title screen, on the Next's Layer 2 framebuffer (256×192); the 128K build shows the same art as an attribute-clash SCR.

Strategy

This is a fresh reimplementation of NetHack's design in C, sized for the Z80 — not a recompile of NetHack's source. The design reference is the NetHack 5.0 development version (the branch long known as 3.7; the latest stable release is 3.6.7). You cannot just compile the original: it is ~250k lines of C that assume 32-bit ints and megabytes of flat RAM (5.0 even depends on Lua), while the Z80 only sees 64 KB at a time. So the engine is rebuilt on a platform layer of its own (display, keyboard, sound), reusing NetHack's design, key bindings and feel rather than its code.

One source tree, two machines. The same game logic compiles for the ZX Spectrum Next and for a plain 128K, with #ifdef __ZXNEXT picking the platform layer underneath it. The Next draws on its hardware tilemap — 80×32 colour tiles, with Layer 2 for the title and victory art; the 128K blits 1-bit UDGs into the ULA bitmap through a 32-column viewport that scrolls with the hero, and keeps the whole map in a shadow buffer so it can redraw only the cells that changed. Both break the 64 KB ceiling the same way, by banking cold code out of the resident half — the Next through its MMU, the 128K through the 0x7FFD latch — and the 128K build is careful to stay compatible with a 48K plus a RAM-expansion interface, which is how many people actually have 128 KB.

Features

• Four classes — every game asks who are you? The Valkyrie fights, the Wizard zaps, the Rogue dodges, the Tourist haggles — each with its own attributes (which really matter: St hits harder, Dx lands blows, Co mends, Ch bargains in shops), starting gear, purse and alignment (Lawful, Neutral or Chaotic — the god your offerings answer to). Each also plays its own way: the Wizard's power refills fastest and a force bolt hits for 2d12; the Rogue is born stealthy, so sleepers stay asleep, and backstabs them for extra damage that grows with experience; the Tourist carries an expensive camera whose flash blinds a monster for a few turns. The Valkyrie needs no trick — she is still the easiest start, as in NetHack.
• A 50-level dungeon, generated procedurally and deterministically: each depth regenerates identically from its own seed, while the changes you make (gold taken, monsters killed, items picked up, tunnels dug with a pick-axe through rock and walls) are remembered across revisits — plus the Gnomish Mines, a four-level side branch off Dlvl 2: chambers hewn from rock, winding tunnels, gnomes and dwarves, Minetown's shop in the middle of the caves, and the luck-steadying luckstone at the bottom. Items you drop stay where you left them (the last 8 levels' floors are remembered), so a stash by the stairs is a real strategy.
• Field of view with fog of war — rooms light up on entry, corridors reveal around you, and explored-but-unseen terrain is drawn dimmed from memory.
• Turn-based combat against a depth-scaled bestiary (rats, bats, kobolds, dogs, snakes, orcs, zombies, acid blobs, leprechauns, yellow lights, homunculi, wraiths, floating eyes — and deeper down, trolls that knit their wounds shut, life-draining vampires, mimics posing as items on the floor, the nymph, who steals an item from your pack and blinks away with it, and the apex dragon, which breathes fire down a clear corridor) that chases you with BFS pathfinding. Many bite with a special attack — poison, blindness, sleep, theft, life-drain — and never melee a floating eye with your eyes open. Hidden traps (trap doors, darts, sleeping gas) lurk in the deeper floors. Scratch Elbereth (E) in the dust to keep monsters at bay — or burn it in with a wand of fire, though a blow struck from it rubs out any engraving; experience levels raise your HP.
• A dungeon with NetHack's manners — half the monsters spawn asleep (sneak-attack them: a sleeper can't dodge), an awake enemy at your heel follows you up and down the stairs, kills may leave death drops where the body fell, and Minetown is at peace until you draw first blood — then the whole town comes for you, and the gods dock your luck.
• Corpses: you are what you eat — slain monsters may leave one, and the right flesh teaches the body something: poison resistance, sleep resistance, a floating eye's telepathy (sense every monster while blind), a leprechaun's or a nymph's restless teleportitis — and a wraith's corpse is a whole experience level.
• A loyal pet dog starts at your side, fights monsters for you, follows you through the dungeon — and grows with its kills, biting harder and taking more punishment. Throw (t) a weapon down a corridor for a ranged attack — it lands on the floor to be reclaimed — search (s) the ground for hidden traps, rest (R) to let your wounds close, kick (K) a locked door off its hinges, and pray (p) to your god to haul you out of trouble (best at an altar). Resting is no free lunch: it stops the moment anything wakes and comes into view, and the dungeon keeps sending wanderers while you sit still.
• Items and equipment — weapons, armour worn as a set (body suit, shield, helmet, boots and cloak, each in its own slot; seven grades of suit alone, from leather up to dragon scale), potions, food, scrolls, rings and amulets — ESP, versus poison, and life saving, which spends itself instead of you — each with its own enchantment, erosion and blessed/uncursed/cursed state; potions, scrolls, rings and wands start unidentified, each game with its own shuffle of looks. Wield/wear the best you carry, quaff/eat/read, watch acid blobs corrode your gear, beware cursed items that won't come off — then enchant your gear with the right scroll, lift your curses with another, genocide a monster you are tired of, recharge a wand, map the level's gold, drink a full healing, or bottle a whole experience level — and leave a scroll of scare monster on the floor to stand on where no monster dares strike. Deep down the weapons go on past the long sword the way NetHack's do: the extra damage is in the two-handers (a two-handed sword, a battle-axe, a mattock), paid for with your shield, and a silver saber burns vampires. Nine rings — protection, regeneration, slow digestion, free action, teleport control, stealth, and three cursed pieces of junk that make trying on an unknown one a gamble. Wands (z) zap magic in a chosen direction — a striking bolt, a freezing or burning ray, magic missiles, sleep, teleport-away, a bolt that unlocks doors — or dig straight down a level.
• Tools (a applies them) — a skeleton key for locked doors, a pick-axe that digs down through the floor or through rock and walls (the level remembers your tunnels), a magic whistle that calls your dog from anywhere, a blindfold (no gaze can catch you, and with telepathy you see the whole level's monsters), and a unicorn horn to cure what ails you. Dwarves carry pick-axes.
• Altars and divinity — step onto an altar (_) to reveal the blessings on what you carry; drop an item on one and a flash names it, a potion taking the altar's own touch (holy water — or worse, on an altar of a crossed god). Offer a corpse (d) to a co-aligned god for real boons — even an artifact: Sting, Sunsword, Trollsbane, Dragonbane or Stormbringer, each deadly to what it hunts — and mind your hidden luck: pleased gods steady your sword arm, spurned ones stop hearing your prayers.
• Secrets and furniture — some doors are hidden in the walls and some corridors behind rock, waiting for a search (s) — though never the way from stairs to stairs. Engrave with a wand (E) and its mark gives it away: gravel flies, flames lick, bugs stop moving. Sinks (~) offer a sip of something, rattle when kicked, and swallow a ring — saying, by what they do, which ring it was. Sit on a throne (#): mostly nothing happens, but it may heal you, drain you, shock you, summon a court, grant a genocide or an insight into your pack — and a third of the time it vanishes. Graves carry an epitaph, and a pick-axe digs them up: a corpse, an angry owner or nothing — and a lawful hero has done wrong.
• Spells and fountains — read a spellbook (&) to learn its spell, then cast (Z) from your spell power (Pw): force bolt, healing, sleep, or teleport. Fountains ({) reward a thirsty adventurer with clear water, foul water or coins — and a worthy Valkyrie may draw Excalibur from one.
• Shops with priced goods and a shopkeeper to buy from and sell to — a general store, or one of NetHack's specialists by NetHack's odds (an armour dealer, a liquor emporium, a jeweler, a rare-books shop...), who buys only the shop's own line — plus special levels — the cavernous Big Room, guarded treasure vaults (gold and superior gear behind tough monsters), and hand-drawn maps like a pillared temple, dropped in among the procedural floors.
• Hunger and slow HP regeneration, beeper sound effects, an AY title theme (sixteen bars in D Mixolydian over a walking bass and a kick-and-snare backbeat — a machine with no AY simply shows the title in silence), an attract demo (left alone, the title alternates with fifteen seconds of play: a hero of a random class and his dog walk magic-mapped levels of a random dungeon down to the stairs — any key begins the game), and save & quit to the SD card, NetHack-style (reloaded once on the next boot, then deleted — no save-scumming). The file is checked whole before anything is loaded: a save cut short or damaged on the card is named and left for you to delete or keep, never half-loaded.
• Death and glory — a score screen on death or victory sums up your run (class, depth reached, turns, gold) and weighs it against the best run so far, which persists on disk between games — and it honours your conducts: Pacifist, Vegetarian, Illiterate, Atheist.
• The goal: retrieve the Amulet of Yendor from the bottom of the dungeon — past the high priest who guards it — and climb back out alive, through everything Moloch sends up after you (and he no longer takes your calls).

Dlvl 5 after a scroll of magic mapping — rooms light up on entry, corridors reveal as you go, and the shop in the corner sells tools. The hero has just broken through the room's west wall with a pick-axe: the breach stays open, and the level remembers it on every later visit. 1.7 hangs a real door in every doorway — an arch, two planks and a brass ring — and lends the monsters a second palette: the vampire's purple cape, the nymph's pink gown, the olive snake. Every word is in the game's own gothic hand now, not the ROM's, and the status bar carries the whole character sheet, alignment included.

Minetown (Mine:2): cobblestone caves hewn from the rock with their wooden doors, the shop glowing warm brick, and the hero meeting the townsfolk — a gnome and a dwarf, faces and all — as a magic whistle brings the dog back to heel. Dwarves carry pick-axes; the luckstone waits at the bottom of the branch.

1.8 furnishes the dungeon: the hero, on Dlvl 7 after a blessed scroll of magic mapping, has just stepped onto a grave and read its headstone, beside a throne waiting for someone to sit on it (#) and a sink to drink from, kick, or drop a ring down. The level holds another sink up the corridor, and some of its doors may be secret ones, waiting for s.

Project structure

The code is split into modules with clear responsibilities — the platform (hardware) layer kept separate from the game logic. Because the engine is code-banked, each module is also either resident (hot code that stays mapped in, R) or banked (cold code paged into the 0xC000 window on demand, B). Headers declare the interface; the .c is the R/B half. The source files live in src/; the build scripts, mmap.inc and zpragma.inc stay at the repo root (the build runs from there, where z88dk looks for mmap.inc).

The platform/render layer is dual-target via #ifdef __ZXNEXT: platform.c, platform_init.c and nexthack.c's renderer carry both the Next (tilemap / Layer 2) and the 128K (ULA / UDG / SCR) code paths in one file, and the build picks the right one. The 128K target adds scr.c (SCR blitter), title_scr.c / victory_scr.c (const-banked SCRs) and banked_call.asm (the 0x7FFD trampoline); the Next target adds the titlegfx* / victorygfx* Layer 2 images. The table below describes the Next build; the 128K build's modules are the same minus the Layer 2 images.

File	R/B	Responsibility
mainentry.c	R	main() only: the turn loop / dispatcher (the CRT entry point)
platform.c / .h	R	hot ZX Next hardware: tilemap draw primitives, text/messages, keyboard, file I/O; palette tables
platform_init.c	B	one-time setup: tilemap/font/tile/palette init and the gfx[] graphic-tile table
rng.c / .h	R	random number generator (xorshift16) and the world seed
level.c / .h	R	terrain buffer and the per-cell leaves (terrain / walkable / tile lookup)
levelgen.c	B	procedural generation, special levels, gold/item persistence
levelfov.c	B	field of view (fog of war) and save/restore
leveltmpl.c	B	loader for the hand-drawn special-level templates
monster.c / .h	R	monster arrays, per-monster lookups and the bestiary
monster_ai.c	B	chase pathing (BFS), combat, spawning, kill persistence, the pet
item.c / .h	B	inventory and items (pick up, wield/wear/put-on, the floor and its stashes, drop and sell)
item_use.c	B	the verbs that use an item up: quaff, eat, read, throw, zap, apply, engrave
secret.c	B	secret doors and corridors, and searching for them
feature.c	B	the furniture: where sinks, thrones and graves stand; sinks and graves
throne.c	B	sitting down, and the throne's effects
classes.c / .h	B	the class picker and starting kits
spells.c / .h	B	spellbooks and spellcasting
sfx.c / .h	B	beeper sound effects
attract.c / .h	B	the title's attract demo
nexthack.c / .h	B	game-state globals (resident data), rendering, turn step, level orchestration, screens
save.c	B	save & restore: the file format, its length+sum check, the prompt for a save that cannot be loaded
game.h	—	shared player/run state used across modules

Build

This repository contains only the game source. The toolchain and emulator are external tools you install yourself; the build/run scripts expect them as sibling folders of this one. The game is code-banked (>64 KB), which needs a recent z88dk (the __banked trampoline, build v24836+):

<parent>/
├─ nexthack/        ← this repository
├─ z88dk/           ← z88dk SDK, a recent nightly (https://github.com/z88dk/z88dk)
└─ ZEsarUX/         ← the ZEsarUX emulator        (https://github.com/chernandezba/zesarux)

With that layout in place, build.ps1 is the preferred build — incremental and parallel, so it skips untouched modules and uses all cores (clean ~75 s, a one-module edit ~25 s):

.\build.ps1          # incremental + parallel build -> nexthack.nex
.\build.ps1 -Clean   # force a full rebuild

build.bat is the single-shot fallback (recompiles everything in one pass):

build.bat            REM builds the whole game (all modules) -> nexthack.nex
build.bat foo.c      REM builds a single .c file             -> foo.nex

Equivalent direct invocation of the full build:

set ZCCCFG=..\z88dk\lib\config\
set PATH=..\z88dk\bin;%PATH%
zcc +zxn -subtype=nex -vn -SO3 -clib=sdcc_iy --max-allocs-per-node200000 -startup=1 -pragma-include:zpragma.inc -m src/mainentry.c src/nexthack.c src/platform.c src/platform_init.c src/rng.c src/level.c src/levelgen.c src/levelfov.c src/monster.c src/monster_ai.c src/item.c src/sfx.c src/leveltmpl.c src/classes.c src/spells.c src/titlegfx0.c src/titlegfx1.c src/titlegfx2.c src/titlepal.c src/victorygfx0.c src/victorygfx1.c src/victorygfx2.c src/victorypal.c -o nexthack -create-app

The banking layout is configured by zpragma.inc (stack at 0xBFF0, banking segment 3) and mmap.inc (the PAGE_20/PAGE_22/PAGE_26/PAGE_28 code-page ORGs).

Building the ZX Spectrum 128K target

The plain 128K build uses the classic +zx target with manual 16 KB bank paging (port 0x7FFD). It needs ..\ZEsarUX\ as a sibling folder to run.

.\build-zx128.ps1          # incremental -> nexthack128.tap
.\build-zx128.ps1 -Clean   # force a full rebuild

It compiles the same modules (taking their #else 128K code paths) plus the ULA SCR screens (scr.c, title_scr.c, victory_scr.c — LZ-packed), the vendored 0x7FFD banking trampoline (banked_call.asm), the esxDOS-detection probe (esxdetect.asm) and the hand-written ULA blits (puttile_asm.asm); the 96 KB of Next Layer 2 image modules are dropped. Banking comes from zpragma-zx128.inc (the CRT_ORG_BANK_N far-bank ORGs); tools/png2scr.py regenerates the title/victory SCRs from the PNG art.

Run the Next build

Both targets run in the ZEsarUX emulator (kept one dir up, in ..\ZEsarUX).

run-next.bat         REM runs nexthack.nex in ZEsarUX (Next)

ZEsarUX auto-mounts esxDOS onto the folder holding the .nex, so save/restore works directly: in game, S writes nexthack.sav beside the .nex and the next boot reloads it — no SD card image or hdfmonkey needed.

Run the ZX Spectrum 128K build

nexthack128.tap is the distributable. It is a standard tape that loads on real 128K hardware and any accurate emulator (Spectaculator, Fuse, …): open it on a 128K model and let it load. Its BASIC loader pages each 16 KB bank into place via 0x7FFD, then a small boot stub sets the interrupt mode before starting — so it does not depend on esxDOS just to run.

run-zx128.bat        REM dev convenience: boots nexthack128.tap in ZEsarUX (--machine 128k)

The same game on a plain 128K: 1-bit tiles on the ULA, a 32-column viewport that edge-scrolls over the 80-wide map. 1.7 gives the walls a paper colour — white bricks on blue, a shop's yellow on red — and every door a red plank in a black arch; the hero (sword raised) stands by the breach a pick-axe has just opened, with the dog, a vampire, a nymph and a snake.

run-zx128.bat launches ZEsarUX (sibling ..\ZEsarUX\) for quick local testing; it inserts the tape with --tape, so ZEsarUX auto-loads it straight to the title (no boot-menu key). It also passes --noconfigfile so the shared ZEsarUX config can't force the Next machine over the 128K. Save/restore on the 128K needs an esxDOS/DivMMC interface, which the game probes for at startup: with one, S writes nexthack.sav and it reloads on the next boot; without one the game runs normally but cannot save. The .tap is the only artifact: a snapshot cannot carry the code-banked RAM banks, so a .sna boots the resident title and then crashes on the first banked call — the build used to emit one and no longer does.

Controls

Key	Action
cursor keys / h j k l	move ◄ ▼ ▲ ► (hold to keep moving)
y u b n	move diagonally
> < or Enter	stairs down / up
. or Space	wait a turn
s	search beside you for hidden traps, doors and passages
R	rest until healed, disturbed, or hungry
K	kick a locked door in (or a sink)
#	sit down (on a throne, see what happens)
;	look around the map (a cursor describes whatever it rests on)
,	pick up the item under you
i	show inventory
D	discoveries: which potion/scroll/ring/wand looks you have identified
d	drop an item (sells it in a shop; offers a corpse on an altar)
w / W	wield weapon / wear armor (a two-handed weapon and a shield exclude each other)
P	put on a ring or an amulet (asks which)
q / e / r	quaff a potion (or from a fountain or sink) / eat food / read scroll
t	throw a weapon in a direction
z	zap a wand (strike, freeze, burn, sleep, teleport, unlock, or dig down)
a	apply a tool (unlock a door, dig through rock and walls or > down, call your dog, put on a blindfold, cure with a unicorn horn, flash a camera)
Z	cast a known spell (spends Pw)
p	pray to your god
E	engrave Elbereth (wards off monsters) — with a finger, or with a wand, whose mark may name it
S	save game and quit to the title
?	show the full command list

Walk into a monster to attack it; walk over gold to pick it up.

The inventory screen (i): the weapons past the long sword — the two-handed battle-axe, the silver saber and 1.7's two-handed sword — four of the tools a applies, an amulet versus poison and a scroll of scare monster, beside an armour set worn a piece at a time, enchantment, blessed/cursed state and everything in use flagged. A potion you have not learned yet shows only this game's look: that smoky one is a full healing, and nothing yet says so.

Map & item tiles

The world is drawn as colourful 8×8 pixel-art tiles, not ASCII text — on the 128K, one ink over a paper per cell, so the walls are white bricks on blue, a shop's are yellow on red and a door is a red plank in a black arch. The tiles and the entities they depict (the symbol in parentheses is the internal map code, kept from the roguelike tradition):

• Terrain: floor (.), corridor (#), wall (- |), door (+), stairs up/down (< >), a mine entrance (v), altar (_), fountain ({), sink (~), throne (\), grave (`), a sprung trap (^)
• Items: gold ($), weapon ()), armor ([), potion (!), food (%), scroll (?), ring (=), wand (/), spellbook (&), tool ((), the luckstone (*), the Amulet of Yendor (")
• Creatures: hero and shopkeeper (@), rat (r), bat (B), acid blob (a), kobold (k), dog (d), snake (S), orc (o), zombie (Z), leprechaun (l), yellow light (y), homunculus (i), wraith (W), floating eye (e), troll (T), vampire (V), dragon (D), mimic (m — hidden ones wear an item's tile), nymph (n), gnome (G), dwarf (h), the high priest (M)

Technical notes

• Display: the Next hardware tilemap (80×32). Glyphs are built at runtime by expanding the game's own 1bpp font (src/font_data.h, see Credits) into 4bpp tiles; the 128K copies the same font into Bank 5 and prints from it; per-cell colour comes from the tilemap palette (16 ink colours over a black paper). A text colour uses two of its palette's sixteen entries, so the spare fourteen of one of them carry a second palette for monsters — the purple, pink and olive the first one lacks. The ULA layer is disabled so only the tilemap is shown. Tile data lives in Bank 5 (0x4000 tiles, 0x6000 tilemap) — free because the program is at 0x8000+.
• int is 16-bit in SDCC, so values that can exceed ±32767 (gold, the turn counter, bit flags) need care: long works but is slow, and 16-bit arithmetic must be audited for overflow.
• Memory / code banking: the engine outgrew the 64 KB the Z80 sees at once, so it is code-banked — a resident half (hot code + all data + stack in 0x8000-0xBFF0) plus cold code in 16 KB pages (six on each machine) swapped into the 0xC000 window by z88dk's __banked trampoline. The BFS scratch arrays live in Bank 5's free tail. The resident half — where every module's data and string literals land by default — is the tightest budget; read-once tables and message strings are const-banked next to the code that reads them to stay under it, and the C runtime is z88dk's without its text terminal (-startup=31), which the game never used. Data read once into somewhere that already exists is LZ-packed: the level templates (into the map) and the 128K's title and victory screens (onto the screen).

References

• ZX Spectrum Next dev wiki (primary reference): https://wiki.specnext.dev/Main_Page
  • Memory map (default config has 512 KB RAM): https://wiki.specnext.dev/Memory_map
• ZX Spectrum Next — Tilemap mode: https://www.specnext.com/tilemap-mode/
• ZX Spectrum Next — Sprites: https://www.specnext.com/sprites/
• NetHack: https://www.nethack.org/
• z88dk: https://github.com/z88dk/z88dk
• ZEsarUX emulator: https://github.com/chernandezba/zesarux

Credits

• Font: based on Byteletter by DamienG, from the ZX Origins collection — textura lowercase under capitals redrawn for NextHack so the status line and scroll labels read at a glance, with bolder punctuation for the 128K. The glyphs and the list of changes are in tools/font/nexthack.txt. The font is not under the GPL: its own terms (in the ZX Origins download) allow it in games with this credit and forbid redistributing it as a font.

License

Copyright © 2026 Leonardo Roman da Rosa

NextHack is free software, released under the GNU General Public License, version 3 or (at your option) any later version (SPDX identifier GPL-3.0-or-later). The full text of GPLv3 is in LICENSE; for later versions see https://www.gnu.org/licenses/.

It is an independent, from-scratch engine inspired by NetHack's design. It contains no NetHack source code and is not affiliated with or endorsed by the NetHack DevTeam; "NetHack" is mentioned only to credit the inspiration. Because the codebase shares no code with NetHack, NetHack's own licence (the NGPL) does not apply to it, leaving us free to license NextHack under the GPLv3. The one part that is not ours to license is the font, which keeps DamienG's terms (see Credits).