NetHack 4 homepage
About this document: Last modified by Alex Smith, 2021-12-29
Copyright (C) 2013 Alex Smith.
This FAQ is licensed under the NetHack General Public License. See libnethack/dat/license for details.
"FAQ" stands for "Frequently Asked Questions". However, giving a list of the questions I've been asked a lot seems mostly useless by itself. So here are some questions I've been asked a lot, and some questions that have been asked less often but I expect to be asked and thus need to be answered pre-emptively, together with their answers.
A long time ago, back before the use of graphics for computer games played on actual computers (rather than games consoles) caught on, there was a game called Rogue. Previous games were mostly text adventures (think Zork or Colossal Cave Adventure); the game would describe a situation using text, and the player would respond to that. Instead of describing the game world, Rogue visualised it, placing letters on specific screen locations in order to show where the player was relative to enemies. It was also notable for having a randomly generated map, and deleting the save file upon the character's death; there was no way to go back and try again.
NetHack is a "roguelike" game following in the same tradition; the player controls an adventurer delving into a randomly generated dungeon to retrieve the Amulet of Yendor from its depths. The earliest versions were based quite heavily on Dungeons & Dragons, although it has diverged somewhat since (although there are still many obvious ties between them, such as the presence of surprisingly many types of polearm). As such, it allows unusual levels of flexibility in its gameplay; if it seems like you should be able to do something, you probably can, and unlike many roguelikes, the emphasis is on allowing you to build the character you want to play, rather than on trying to make do with a limited number of tools.
NetHack (and its predecessor Hack) were kept in development for many many years; NetHack dates from 1987 (and as such, is older than many people who play it). The development team who worked on versions 1 to 3 of NetHack (the DevTeam) are still working on it (although there was no real evidence of this until 2014), but they don't release their progress, meaning that the situation is effectively the same as if they'd been doing nothing. This means that NetHack is still stuck in 2003, with the world moving on in the meantime. It's a testament to the game's quality that it can still be enjoyed after staying stagnant for this long, but the situation is far from what it could be.
As expected for a game popular among programmers, there were many people willing to take the game forwards who weren't members of the DevTeam; an ecosystem of first patches, and later on full "variants", sprang up. After a long time with no useful activity from the DevTeam, though, it became clear that a replacement would be needed; this was exacerbated somewhat by the tendency of variants to be created and guided by players who were significantly above average at the game (and as such, noticeably harder), leading to variants being dismissed by many players. NetHack 4 was originally created by merging two resonably conservative variants (NitroHack by Daniel Thaler, which focused on modernizing the codebase, and AceHack by Alex Smith, which focused on interface improvements), although many other people have worked on it since, or contributed patches to the variants it is based on. The result is, hopefully, a more modern NetHack that still has gameplay familiar to fans of previous versions.
NetHack seems liable to die if nobody tries to take it forwards. If the DevTeam can't or won't take it forwards, someone else will have to. NetHack 4 aims to be a direct successor to NetHack 3.4.3, rather than a "challenge patch", and it felt like the most appropriate name for a project that aims at continuing the legacy of NetHack.
Basically, we like NetHack too much to want to let it die. Using only a minor modification to the name (adding the "4") lets us signify that we're trying to keep it alive, rather than abandoning it in favour of an alternative.
(Incidentally, the DevTeam are aware of the variant, and have not objected to the name; they've even been known to copy the occasional patch from NetHack 4 into their own development version. They spell it "NetHack4", with no space; sometimes, we do too. This helps to be unambiguous if you want to distinguish NetHack 4 from DevTeam-released versions of NetHack.)
We'll merge as many of their changes as we think are good ideas into NetHack 4, hopefully producing a game with the advantages of most versions. There's already been some progress in this respect; although we don't have access to all the DevTeam's internal development code, they've been willing to share large amounts of it with us (mostly bugfixes), which is incidentally how we know they're working on it in the first place. We haven't made much use of it yet, in favour of getting 4.3.0 released, but are likely to merge in most of the bugfixes for 4.3.1.
NetHack 4's development can be followed from its git repository; active
development is typically in branch "master". (That repository also contains
(often out-of-date) versions of some related variants.) There is also a
bug tracker, where you can read or report bugs, or submit patches; the
bug tracker also contains a web-based view of the repository, which may be
more convenient for browsing it (the official repository can only reasonably
be read using
Sometimes, interim development projects take place on other branches, because the "master" branch is expected to be at least somewhat playable. In particular, we often use a "savebreak" branch for development that is expected to break the save system (either because the save system itself does not work, or because the save format changes so often that a saved game might not be loadable on the next day). Sometimes there are also branches for development planned to go into a future version, which normally have numerical names indicating the version the changes will go into.
You can also send emails to ais523. The email address is not written here directly in the hope of confusing spambots, but it's the most obvious one that can be formed from the username "ais523" and the domain name "nethack4.org".
If you want to discuss the game or its development, we also have an IRC channel, #nethack4 on irc.freenode.net; many of the developers idle there, and many discussions are made there too. There is also now a #nethack-dev channel for NetHack development generally (mostly aimed at variants with fewer changes from the 3.4.3 codebase).
Finally, you can comment on Usenet, at rec.games.roguelikes.nethack. Make sure your subject line clearly refers to NetHack 4 if you don't want to cause confusion as to which version you're talking about.
You can. One way any NetHack player can help out is in playtesting; connect to the server (following the instructions below) and start playing the most recent version. If you encounter a bug, or if the game tells you that something is wrong and asks you to make a bug report, file it at the bug tracker. (You will need a bug tracker account; we give these out freely on request by email. There's no automated way to create them because we couldn't stop spambots using it.)
NetHack 4 is one of the games featured in the annual Junethack tournament, which looks at the future of NetHack by allowing competition on the various forks and variants (as well as 3.4.3). As the name might suggest, it runs in June every year. See the tournament site for more details.
Just like previous versions of NetHack, NetHack 4 is licensed under the NetHack General Public License (which is similar to old versions of the GNU General Public License). Some of the newer files are dual-licensed and also allow other licensing options in addition to the NGPL. (The build system, aimake version 3, is licensed under version 3 of the GNU GPL, rather than under the NGPL; however, its license does not extend onto the license of the code it compiles, leaving the resulting executables as purely NGPL.)
Several of the libraries on which NetHack 4 depends have other licenses; for
instance, libjansson (which ships with the NetHack 4 source, nowadays) is
licensed under the Expat license, and SDL2 (which does not ship with the
source, but which does ship with the binaries) is licensed under the zlib
license. Likewise, the tilesets mostly have licenses of their own. The file
copyright in the root of the source distribution gives a machine-readable
explanation of the copyright status of the source files in the distribution.
For binary distributions, full copyright information will be installed with
Please note that there is no warranty for NetHack 4.
There are two ways to play NetHack 4: you can either run it locally on your own computer, or use telnet or ssh to connect to a public server and play on the server. Server play has the advantage that your save file is available no matter which computer you play on, and that you can (on Linux or Mac OS X) use standard software that comes with the operating system rather than having to install a separate binary; it's also much easier to prove that you aren't cheating, because you cannot modify the game's code. Local play works even without an Internet connection, and allows you to experiment with patches to the code and otherwise modify the game as you like.
The official public server is nethack4.org. Open a terminal in your favourite terminal emulator, and use telnet (default settings) to connect. At the command prompt:
You'll be asked to give a username and password upon connecting; if you use a currently unknown username, you'll be prompted to create an account.
If you're using Windows, this is rather harder to do than on Linux or Mac OS X, because Windows doesn't come with ssh, its telnet client (when it even exists at all) is buried in an obscure corner of the menus and is disabled by default, and its default terminal emulator is woefully inadequate for pretty much anything (and probably doesn't run NetHack 4 over telnet correctly; I'm not sure if anyone has tried). As such, it is probably best to install a separate terminal emulator / telnet / ssh package. The most commonly used is PuTTY. Note that PuTTY's defaults are somewhat dubious (e.g. the cursor looks a little out of place), so it may need some amount of configuration in order to provide the best play experience. Note also that it has something called "NetHack mode"; this is a workaround for keybinding issues in considerably older (pre-3.4.3) versions of NetHack, and is more harmful than useful with NetHack 4, so try to get things working with it turned off first, and use it only as a last resort.
NetHack 4 is also playable on hardfought.org. You can connect there via ssh (username "nethack"), so the command is:
or play via the website at https://www.hardfought.org/nethack/hterm/. The site supports a number of NetHack variants, including NetHack 4.
NetHack 4 can be compiled on most commonly used systems; we've tested Linux, OS X, and Windows. Linux and Mac OS X work out of the box. Windows is a little harder but still relatively easy to compile on, if you don't mind downloading several extra tools to do the compilation with.
In order to compile NetHack 4 locally, you can get a copy of the source from the repository, and follow the instructions in the README file (if you're on Mac OS X, follow the instructions for UNIX/Linux, because OS X is a UNIX derivative). You'll need some dependencies in addition to NetHack 4 itself: a working C toolchain and zlib. (You'll also need postgresql, pgcrypto and inetd if you're planning to run your own server, but you probably aren't; for local play, the game works just fine without a server to connect to.) Previous versions of NetHack 4 depended on the libjansson library. You can still use your own copy of libjansson, but the source to this library is now shipped with NetHack 4 in order to reduce library dependency issues, and you can tell the build system to use that copy instead. Previous versions of NetHack 4 also depended on libncursesw, but that dependency no longer exists (NetHack 4 now uses its own rendering library, named libuncursed).
To build a binary capable of tiles play, you will also need version 2 of the Simple DirectMedia Layer library (and its development headers and (on Windows) import libraries). On Linux, you might have to compile it yourself; some older distributions only offer version 1, which is not sufficient to compile a tiles port.
You'll additionally need a copy of Perl in order to run the build system: this
will likely come with your system on Linux and Mac OS X. If you're on
Windows, get Strawberry Perl; it comes with a working C toolchain and all
the libraries required (except for SDL), meaning that you can avoid the usual
problems of trying to set up a C toolchain on Windows. On Mac OS X, the usual
C toolchain is Xcode, which is available from Apple; most Linux systems come
with a C toolchain, but if you're on Debian or a derivative (such as Ubuntu or
Linux Mint), you'll need to install the
build-essential package (and also
Currently, precompiled binaries are available from the NetHack 4 website, but only for Windows and Debian-based Linux distributions, and they are not regularly updated. If you can, we recommend you compile your own binaries from source.
NetHack 4 inherits a server API from NitroHack that should theoretically allow a local executable (even tiles) to play on a remote system. This mode works fine in testing, but there are no publically available servers right now to connect to, so it's not that useful in practice.
We don't host such a server on nethack4.org because there are known security problems in the implementation (which do not affect local play).
Not any more; it used to, but that dependency has since been removed. (Likewise, it does not use the "curses interface patch" seen in some NetHack variants, such as the one running on nethack.alt.org, despite some visual similarities.)
Options you may want to consider changing include
border (especially if
you're playing in an 80x24 terminal), the various
NetHack 4 does its rendering via the libuncursed rendering library. By
default, it will use a terminal for rendering, using its
interface (depending on your platform). In order to use other interfaces, you
will need a plugin for libuncursed; for instance,
with the Windows executables (and the sources for that plugin ship with the
NetHack 4 source, meaning that it will be built when you compile the source on
other operating systems, too).
In order to load the
sdl rather than
wincon interface, you will
need to make this request known to libuncursed via either of the following
--interface sdlcommand line option when starting NetHack 4; or
-sdl(the build system will create an executable or symlink
nethack4-sdlfor this purpose if building in tiles mode).
sdl interface is a "fake terminal" port that simulates a terminal
itself, rather than using an actual terminal; this allows you to avoid any
problems that the terminals provided with your platform might have. (For
instance, the Windows console is rather slow.) Unlike the other interfaces,
it is also capable of displaying tiles.
Yes. For tiles play, you will need to be playing on a graphical interface
(not a terminal interface; thus tiles play on a server won't work); and you
will also need to change the "tileset" option in-game to specify a graphical,
rather than text-based, tileset. The
libuncursed_sdl interface is currently
recommended for tiles play (being the only current graphical interface plugin
There are currently five tilesets available:
Note that as libuncursed plugins do not currently work correctly on Mac OS X, graphical tilesets will not work there either.
These are the same questions: you customize the map display via creating and
using a custom tileset. You can create and edit tilesets using the
tilecompile tool, which can be optionally installed along with NetHack 4
--with=tilecompile if building manually, or enable the option in the
installer if you're using a precompiled build). See its manual for
man tilecompile on Linux, or look in the documentation folder
on Windows; the documentation folder itself will be linked from your Start
menu, if you're using the precopmiled installer). The easiest way to start is
to decompile an existing tileset using
tilecompile, make changes, and then
recompile your changed version.
Once you've created a tileset, or obtained one from someone else, you can
place it in the
tilesets subdirectory (alongside your
~/.config/NetHack4/tilesets on Linux), and it should automatically show
up on the options menu in-game.
There are two main causes of this. If your problem is that it's building shared libraries repeatedly, this is because a shared library is used for two different purposes on some OSes: being loaded at runtime, and being read at compile time to determine how to link against it. There are a bunch of circular dependencies between libraries in NetHack 4, so the build system sometimes creates one or more provisional copies of a library in order to get all the dependencies correctly figured out.
Alternatively, if your problem is that it seems to be building the tiles code and you're not running a graphical install, this is because tilesets are now used even for text-based play (the "tiles images" are character/styling combinations rather than images).
500 MB should be plenty for the build, but if you're trying to build on a
particularly small system, let us know. The problem is that
trying to do a huge amount of work (more than most build systems do), and that
Perl is very memory-inefficient.
We hope that the game is pretty fun both ways, both with spoilers and without. A large number of people enjoy playing NetHack even after reading all the spoilers about it that they can; it's quite hard to get information on the number of people who enjoy it without, because they tend to not mingle with the NetHack-playing community at large, but many people have reported enjoying it before they became spoiled.
Note that without spoilers, it is likely to take a very long time before you win (most likely years); there's a lot to learn, and even more to figure out. Of course, another way to look at that is that you can have years of exciting gameplay discovery ahead of you! One interesting middle ground might be to find other players unspoiled on external sources, and share your findings among yourselves; this is the way that NetHack was played for many years, in UNIX computer labs all over the world, and it still works today.
If you're interested in reading spoilers, good resources include IRC (#acehack and #nethack on irc.freenode.net), and the NetHack wiki. NetHack 4 has some deviations from 3.4.3, but the changes are relatively conservative, so spoilers for 3.4.3 will still be mostly applicable.
Whatever you enjoy playing with. Try a few playstyles out, and note that trying the more difficult characters is often good practice for eventually winning with the easier ones.
There's widespread disagreement about role difficulty (some people think Wizards are the easiest role, others one of the hardest; they do seem to be good for unusual challenge runs, though), but if you're just looking for a win, dwarven Valkyries seem to have the easiest time overall. (Not that any role is particularly easy; NetHack is much harder than typical modern games are, and only the most experienced players can get anything like a consistent win rate at it.)
The interface has many improvements; we don't consider things like warning the character that a corpse is dangerously old to be gameplay-related, as it's information that should be theoretically available anyway, but maybe you do. Apart from that, some of the largest changes were added as compensation to balance gameplay elements that were balanced via means of perverse interface in 3.4.3; for instance, amnesia now drains skill points, and floating eyes can protect themselves from melee attacks. There are also noticeable improvements to the monster AI, especially where pets are involved.
NetHack is a game where you play as an adventurer trying to survive in a
dungeon as they retrieve an amulet. As such, it doesn't make a lot of sense
to give the player less information than the character would have. In real
life, nobody (well, hardly anybody over the age of 3) eats something by
mistake when they were merely trying to hold it in their hands; dungeoneers
shouldn't become more likely to just because
w are next to each
other on their keyboard. Likewise, it can be assumed that an adventurer who
wasn't blind or otherwise impaired would notice a sea of lava right next to
them, and not accidentally walk into it because they'd pressed a key on a
keyboard too many times.
It's certainly possible to imagine an interesting game whose main challenge comes from a hostile interface. It shouldn't, however, be a tactical game about dungeon exploration. (Probably a minigame collection would work better.)
? while playing for a list of commands. As is common with roguelike
interfaces, there are a lot of commands for specific purposes, because there
are a lot of possible actions. Note that if you want to do something with an
item, you can press
i to view your inventory, then the item's inventory
letter, in order to see a list of possible actions with that item.
If you expand your terminal very, very high vertically (at least 37 rows, but more will give more space for information), the spare space will be used to show reminders of game commands. New players may want to do this while they are learning the game. (This also works when using a graphical tileset, but you will need to expand the window still higher, as the graphics take up more space than a character-based view would: 40 rows on the smallest tile size, or 64 rows with 32x32 tiles.)
The answer to this question is a little unusual, for two reasons. NetHack is a "roguelike" game, and one common feature of roguelikes is that they have permadeath; when you die, that's it for that character, and there is no way to reload a save and carry on. Likewise, you cannot go back to an earlier save even while your character is alive; any actions you do have permanent effects.
In most roguelikes, including earlier versions of NetHack, and both NitroHack and AceHack (NetHack 4's predecessors), this is implemented via a "save-and-exit" command that saves the game, and a game load command that also deletes the save file. Thus, saving would exit the game, and quitting the game would lose you your character (because the save file was deleted when it was loaded).
In NetHack 4, we take a different approach: the save file always exists on
disk, and is saved continuously with almost every key you press. Thus, the
equivalent of saving is to just close the game (which is why the
which traditionally saves and exits NetHack, has its confirm option described
as "close the game"). You can use the
S command to do this, or you can just
outright close the game window and it'll have the same effect. (This should
greatly reduce the risk of losing a game to a network disconnection.) You can
even save in the middle of a turn this way (although note that this is a
relatively new feature that has not been fully tested, so paranoid players
might want to restrict themselves to the
S command); opening the menu with
Ctrl-C is another way to save in the middle of a turn.
If you actually did want to delete your save file and effectively kill your
character in the process, there's a new
! option to the
S command to do
that. I'm not sure why you would (perhaps because it doesn't carry as large a
score penalty as dying?), but the option's there.
On Linux and UNIX, by default,
~/.config/NetHack4/dumps respectively. (If
misconfigured, it's possible that the game will put dump files in your home
directory.) The dump files record details of games that have ended, whether
in victory or defeat.
Windows works the same way, except that instead of
~/.config, it uses
CSIDL_APPDATA refers to. This is normally something like
C:\Users\username\AppData\Roaming, although it depends on how Windows is
There's often a
save folder in the NetHack 4 install directory (depending on
how it was installed), but this is used for save information common to all
users: bones files, xlogfiles, that sort of thing.
,. (In general, 3.4.3 keybindings work unchanged in Nethack 4;
this is one of the major differences. The 3.4.3 keybindings were
ey meant different things depending on
whether you were standing on an edible item or not; this was a common cause of
nasty interface deaths. Changing commands to be less context-sensitive was
thus a priority.)
In theory, the number keys on the numeric keypad should work for movement, and
the number keys on the main keyboard for command repeat; on a few terminal
emulators, you may have to turn NumLock off for this to work. Hopefully, the
longstanding roguelike flamewar between using
movement should no longer be something the game has to be aware of. On a very
few terminal emulators, this may not work correctly, in which case you might
have to rebind the keys in-game. (Rebinding the keys is also useful if you
have a German keyboard and want to move using
If you're feeling particularly heretical, you can move orthogonally with the cursor keys (Up/Left/Down/Right) and diagonally using Home/End/PgDn/PgUp. This adds a new dimension to the movement command Holy War whose implications have not yet been discovered in practice.
See also the
keymap option, that lets you replace blocks of keys
hjklyubn to game commands rather than movement), or to make
more fine-tuned adjustments.
Alt and Esc have almost identical terminal codes; the only difference between them is the timings. Sometimes, if you're playing on a server over a laggy connection, network lag can make it impossible for NetHack (or any other program) to distinguish between the two keys.
You can work around this via setting the
alt_is_esc option; the downside is
that instead of an unreliable Esc key, your Alt key will no longer function.
You can work around that problem, in turn, by configuring your terminal to
interpret your Alt key as Meta, rather than as Alt; instructions for doing
this will depend on your terminal, and it may not be possible on every
terminal. This will in turn lead to ambiguities between Alt and certain
non-ASCII characters; Nethack 4 does not yet support Unicode input, so the
problem doesn't come up here, but it's something to watch out for. Terminal
codes can be badly designed sometimes.
Hints that you can meaningfully press
Return, respectively, to
cancel or accept the dialog box. They're also used for NetHack 4's
rudimentary mouse support – the game is not fully playable with the mouse yet
(in particular, we're thinking about how the mouse should best interact with
the game map) – but you can use them to close windows with the mouse. Several
other things are clickable too (e.g. menus and items in the inventory
sidebar). Mouse support is something that is likely to evolve through future
If you dislike the decorations, you can turn them off by disabling mouse
support in the options (option
NitroHack changed the options file to not be human-editable (we're not 100%
sure why); rather, if you change the option settings using the
o entry of
the main menu, changes will persist into future games. (Changes to game
options using the
O command last for only the current game, although will
survive past a save and reload.)
There's also a new sort of option called a "birth option", which changes settings for newly started games; for instance, you can play with Elbereth not existing without needing to recompile the code. (So now if, like many people, you think it's a cheap tactic, nothing's forcing you to allow yourself access to it. It was always intended to be optional in NetHack 3.4.3 as a difficulty setting, but the method of changing it was too obscure for most people.)
Because it comes at a point in the game at which you've already achieved most of your main goals, and have been given the means to achieve the rest of them easily. So it's basically a bunch of filler levels, with no challenge (mostly because the damage formula doesn't scale into the late game), with repetitive and tedious maps, with nothing much to aim for.
We're aware of this problem, and are currently looking for fixes. A new map generator would solve one of the problems, at least, but larger changes are needed to solve the others, and there's no easy fix to solve its problems as a whole.
NitroHack's save system kept a log of user-entered commands, and replayed these upon reloading a game. However, this turned out to be too unreliable for practical use, and many people lost their save games as a result.
NetHack 4.3's save system is loosely inspired by NetHack 4.2's save system, which was a hybrid of the NitroHack and AceHack systems; the command log still exists, but in addition to the log of commands, there is a (delta-compressed) log of gamestates. As such, the state of the game at any point during the game can be recreated, even if the game binary is modified in ways that change the meaning of commands; and this can allow saves to be reconstructed even in the case of a power failure or similar situation.
NetHack 4.3 improves on this model by removing all the famously buggy NitroHack save code, using the gamestate log in order to recover the state of the game between turns, and a log of user input in order to recover the state of the game within a turn. Thus, changes to the engine that alter the effect of a command will only cause you to lose a turn of progress, and only if you were in the middle of an affected command at the time. This save system also enables some other fun tricks, such as reconnecting to a game and continuing to play it before your original connection to the game times out.
The interface is completely decoupled from the gameplay (actually, it is in 3.4.3 as well; the main innovation in NitroHack was exposing this over a network and adding a separate server daemon). As such, there is no reason why the server and client should be on the same system. It's possible to get some of the benefits of online play by using a local executable that connects to a remote server (which is necessary to play tiles on a server); the code for making connections is in the client by default, and at the moment, the only obstacle to doing this is that there are no servers that accept connections from remote clients (nethack4.org firewalls them out, because the server has not been security audited yet, and we have reason to believe that there are several security bugs in the API). The server/client code is used internally on nethack4.org; connecting to it via telnet or ssh spawns a client, which then spawns a matching server process and connects to it. When playing locally, there's normally no need to do this; the interface will just use the game engine directly.
There are nine separate directories in the distribution, which handle the
libnethack_common for information common to both the
server and client,
libnethack for the game logic,
allow clients to connect to the server,
nethack for the interface code (that
calculates what to draw on screen),
libuncursed for the rendering code (that
actually draws it),
testbench for test code,
tilesets for the
libjansson for the JSON encoding between the
client and the server, and
nethack_server for the server-specific logic
(creating accounts, keeping separate save games for separate user accounts,
that sort of thing). Various executables are built out of code from various
directories (but not with a 1:1 correspondence; most of them use code from
An experimental project, that's nowhere near finished, to give NetHack 4 an understanding of the grammatical structure of the messages it outputs. This should hopefully allow us to eventually output combined messages to heavily reduce message spam, such as "Ten fire elementals step on fire traps! They don't seem harmed.". As a nice side effect, this should make the game much easier to internationalize. The project is mostly stalled, because it ended up with design-by-committee problems, and then was put on hold so that we could actually get other changes done rather than spending all our time trying to get the design behind grammartree perfect; we do plan to start it up again someday, though.
If you're interested in our progress on grammartree, or want to help out, look
grammartree branch in the repository to see how far we've got.