Save Files

This is Dead Cells' specific binary save file format. It stores multiple serialised objects in a compressed format along with hashes to prevent corruption or tampering.

note

All this information was obtained from f@34927 static tool.$Save.genSave (User, Bool) -> haxe.io.Bytes - if you'd like to help out, try looking at this function yourself!

warning

This is not complete! Although a partial reimplementation of hxbit is available in hxbit.py, this can only read - not write - save file data.

A working example of reading and writing a Dead Cells save file is available in alivecells as savetool.py.

Format

File

Size (bytes)	Name	Struct
59	Header	Header
Variable	Payload	Payload

Header (PC version)

Size (bytes)	Name	Description	Struct
4	Magic	0xDEADCE11	None
1	Version	Current format version, usually 1	Unsigned 8-bit integer
20	Checksum	SHA-1 raw hex digest of the file's contents, assuming these 20 bytes are 0x0 while taking the hash	None
20	Git hash	Current long commit hash of the game, as a hex digest	None
10	Build date	Build date of the game version creating this save file	UTF-8 string
4	Flags	Flags and metadata about the save file - mostly unknown	Flags

Header (mobile version)

Size (bytes)	Name	Description	Struct
4	Magic	0x20DEAD19	None
1	Version	Current format version, usually 2	Unsigned 8-bit integer
20	Checksum	SHA-1 raw hex digest of the file's contents, assuming these 20 bytes are 0x0 while taking the hash	None
20	Git hash	A value for each major version of the game, currently 0000DEADCE110000000000000000000300500000	None
10	Build date	Build date of the game version creating this save file	UTF-8 string
4	Flags	Flags and metadata about the save file - mostly unknown	Flags

Flags

Bit	Value (Dec)	Value (Hex)	Name	Type	Description
0	1	0x1	S_User	Data Chunk	If set, a chunk containing persistent user progress (unlocks, cells, gold) exists.
1	2	0x2	S_Game	Data Chunk	If set, a chunk containing an in-progress run exists. If clear, the save was made from the main menu.
2	4	0x4	S_UserAndGameData	Data Chunk	If set, a chunk containing general game metadata exists.
3	8	0x8	S_Date	Data Chunk	If set, a chunk containing the 8-byte save timestamp exists.
4	16	0x10	S_Experimental	Feature Flag	If set, the save was made while the game's experimental/beta features were enabled.
5	32	0x20	S_UsesMods	Feature Flag	If set, the save was made with mods active. This is determined by checking if user.activeMods is populated.
6	64	0x40	S_HaveLore	Feature Flag	If set, indicates the save supports lore rooms. This flag is unconditionally set on all modern saves.
7	128	0x80	S_VersionNumber	Data Chunk	If set, a chunk containing the 4-byte float game version exists.
8	256	0x100	S_DLCMask	Data Chunk	If set, a chunk containing the 4-byte integer bitmask of installed DLCs exists.
9-31	-	-	Unused	-	These bits are currently unused but reserved for future expansion (which is unlikely). They are always 0.

Payload

The payload is a Zlib-compressed blob that contains the actual save file - some of them are hxbit serialised data, and others are just raw bits and pieces. They follow the order of the data chunk flags that were set previously - basically, if a data chunk flag was 1, then the chunk is present in the save file. The game writes saves with Zlib level 9 (maximum) compression, but will read saves compressed at any level. To manipulate it, read it as follows:

• Decompress the payload (it has headers, so any stock zlib implementation can handle it)
• Figure out how many data chunks are enabled
• For each of those data chunks that's enabled, read a Chunk from the payload blob, seeking forward in it as you do.

Chunk

Size (bytes)	Name	Description	Struct
4	Size	Size of the contents	Unsigned 32-bit integer
Variable	Contents	Raw bytes of the save file chunk contents	Varies, see Chunk Formats

Chunk Formats

Depending on what kind of data chunk you're reading, the format of its chunk in the save file changes. Here's a basic map:

Bit	Name	Type
0	S_User	hxbit Data
1	S_Game	hxbit Data
2	S_UserAndGameData	hxbit Data
3	S_Date	Date Chunk
7	S_VersionNumber	VersionNumber Chunk

Date Chunk

Size (bytes)	Name	Description	Struct
8	Date	Date of save file creation as a unix timestamp	Double

VersionNumber Chunk

Size (bytes)	Name	Description	Struct
4	Version	Major game version for this save file, eg 34 or 35	32-bit float

hxbit Data

This data is serialised with help from hxbit - a Haxe library that enables serialisation of arbitrary objects to binary representations. This format has been partially reversed in hxbit.py.

See the full page for format specs.

Cross-platform save conversion

The chunks S_Game and S_UserAndGameData cannot be copied from a PC save to a save for other platforms, because they have no implementation of the Twitch integration features; those Twitch features are always referenced in those two chunks on a PC save even when they have not been activated, leading to a crash when trying to parse them on to other versions.

However, the S_User chunk, which contains the meta progress of the save (including unlocked items), can always be passed. A simple technique to convert a save file from one platform to another is to:

1. unpack the source save file and isolate the S_User chunk;
2. unpack a save file from the destination platform, which will provide the right header information;
3. replace the destination S_User chunk with the source one;
4. optional: delete both the S_Game and S_UserAndGameData chunks in the destination save to force a new run;
5. repack the destination save.

This method requires starting a new run from the menu, since the in-progress run data is not transferred and thus out of sync.

An online implementation can be found here, which is mirrored in the CLI version of savetool in alivecells.

Obtaining save files on different platforms

PC (Steam/GOG)

Steam

First, check whether Steam Cloud sync is enabled for Dead Cells:

1. In your Steam Library, right-click Dead Cells → Properties → General tab.
2. Check the Steam Cloud setting (this is also sometimes shown under the game's in-game Gameplay settings).

If Steam Cloud is disabled: Right-click Dead Cells → Manage → Browse local files. Your save files are in the local save folder shown there.

If Steam Cloud is enabled: The local save folder shown by Browse local files is only a local backup and may be stale. Instead, use the Steam Cloud sync directory:

1. From the game's local files folder, go up three directories to reach your Steam installation root.
2. Navigate to userdata/<your Steam ID3>/588650/remote/.

GOG

The GOG release stores saves under your installation directory in GOG Galaxy/Games/Dead Cells/save/. GOG Galaxy's own cloud sync (if enabled) is not currently confirmed to use a different path - check both the install directory and your GOG Galaxy cloud sync settings if your save doesn't appear up to date.

Mobile (iOS)

caution

These instructions rely on third-party software (iMazing) that isn't affiliated with this project. We can't test or endorse it - use your own judgment before installing anything on your device.

Credit to Demianeen for working out this process; see the original Reddit comment. Fair warning: These instructions may be outdated, as the comment is a year or so old and things have supposedly moved around in the app.

1. Download iMazing. The free version is sufficient for this process.
2. Open iMazing and connect your iPhone with a cable. Unlock your device and tap Trust if prompted.
3. In iMazing's sidebar, click Apps (near the top), then click Manage Apps at the bottom right.
4. Use the search bar to find Dead Cells. Right-click it (or click the gear icon) and choose Back Up App Data.... When prompted, select Only App Data. This may take a few minutes.
5. iMazing produces a file named Dead Cells.imazingapp. This is actually a ZIP archive.
6. Rename Dead Cells.imazingapp to Dead Cells.zip, then extract it with your OS's built-in unzip tool or any archive utility.
7. Inside the extracted archive, navigate to Container/Documents/save/. This is your save data.

Mobile (Android)

important

This is under the device's root /data/data/ directory - not the Android/data/ external storage path. Accessing this location requires a rooted device, since it's part of the app's private storage and isn't exposed to normal file managers or USB file transfer.

If your device is rooted, you can access this path with a root-capable file manager (e.g. via a root shell, ADB with root access, or a file manager app granted root permissions).

The Netflix Games release of Dead Cells uses a different package name and storage layout, which has not been documented yet. If you've located the save path for the Netflix version, contributions to this doc are welcome.

Console (Switch)

Emulator users

If you're running Dead Cells in Ryujinx, this is trivial: right-click the game in your game list and select Open Save Data Location (or View user save folder, depending on your Ryujinx version). The save files will be loose on disk and ready to use however you need.

Real hardware

Nintendo does not provide any official, user-facing way to export save data as files.

This means that getting a raw save file off a real Switch requires custom firmware (CFW). There is currently no homebrew-free method that produces a parseable file.

If your Switch is already set up with a CFW like Atmosphere, the rest of this process is quick. If it isn't, setting up CFW is outside the scope of this doc - there are many existing guides for this depending on your console's hardware revision and firmware version, and the process changes often enough that reproducing it here would go stale quickly.

1. Install a save manager homebrew app. JKSV is the standard tool for this and is actively maintained. Checkpoint is a similar alternative if JKSV doesn't work for you.
2. Launch JKSV from the Homebrew Menu.
3. Find Dead Cells in the title list (it's sorted by icon/name, so just scroll to it).
4. Export the save. Select the title, then choose to back up / export the save data. JKSV will write the save folder contents to your SD card, typically under /JKSV/<game title>/<backup name>/.
5. Copy the exported folder off the SD card to your PC.

Console (PS4/PS5)

Emulator users

If you're running Dead Cells in shadPS4, your save file is stored under the emulator's data directory at home/<user-id>/savedata/<title-id>/SAVEDATA00/ (on Linux this is typically ~/.local/share/shadPS4/home/1000/savedata/CUSA10484/SAVEDATA00/; on Windows, look under %appdata%/shadPS4/). Inside, user_0.dat is the actual save data, alongside options.json and the sce_sys/sce_backup directories that real PS4 hardware also produces.

note

CUSA10484 is the title ID observed for one regional release of Dead Cells - other regions may use a different CUSA***** ID. If your save isn't under that folder, check for other CUSA* directories under savedata/.

Real hardware

On real PS4/PS5 hardware, save data lives in the same layout as above: /user/home/<user-id>/savedata/<title-id>/<savedata-dir>/, with the encrypted save container under that folder's sce_sys/ directory.

Official method (no jailbreak required): In the system Settings, go to Application Saved Data Management → Saved Data in System Storage → select Dead Cells → Copy to USB Storage Device. This writes the save to PS4/SAVEDATA/<user-id>/<title-id>/ on the USB drive, but the files are encrypted and signed to your account/console - they can't be read or edited directly without further decryption.

Jailbroken console (CFW like GoldHEN): Enable the FTP server (Settings → GoldHEN → Enable FTP server) and connect to browse /user/home/<user-id>/savedata/<title-id>/ directly - this mirrors the same folder layout as the shadPS4 save above. Homebrew tools like Apollo Save Tool can also export already-decrypted save files directly on-console.

PS5 jailbreaks are much more limited and firmware-dependent; if you've confirmed an equivalent process there, contributions to this doc are welcome.