DSTSSE: Save Editor for Digimon Story: Time Stranger

Who hasn't played a game, edited their save, then watched the save file corrupt and lose every last hour of progress? If you haven't, you're one of the lucky ones. If you have — welcome to the miserable club.

That's exactly the pain point behind why DSTSSE (Digimon Story: Time Stranger Save Editor) was built. Not because building a save editor is easy or fun — but because the sting of losing 100+ hours of progress is real, and there has to be a safer way to edit save files without holding your breath every time you hit Save.

This time I want to walk through DSTSSE from a different angle: not just what was built, but why it was built, how it works under the hood, and what sets it apart from most save editors.

What Is DSTSSE?

DSTSSE is a desktop save editor for Digimon Story: Time Stranger — the RPG from Bandai Namco released on PC and consoles. If you've ever played Digimon Story: Cyber Sleuth or any other Digimon game, you know the feeling of having a roster you've spent hundreds of hours nurturing. Sometimes you want to tweak a stat, swap an item, or just peek at what's inside your save file — without risking corruption.

In short: DSTSSE reads your save file from disk, displays all the editable data, and when you're ready to save your changes — it backs up first, then writes. No uploads, no network calls, no accounts to create. Everything happens locally on your machine.

The tagline nails it: "Edit your save. Keep your save."

DSTSSE is currently at version 0.1.0 — meaning it's ready for everyday use but still in early development. The existing feature set is already comprehensive for basic save editing needs, and the development team actively welcomes community feedback.

Why Was It Built?

A real problem players face

If you play Digimon Story: Time Stranger on Steam, your save file lives in the savedata folder. The file is large — roughly 3 MB with an AES-128-ECB format. There's a tremendous amount of data packed inside: Digimon roster, inventory, skills, scan data, field guide, and much more.

Interestingly, there are seven regions mapped within the save file. All seven sit in the first third of the file — while the remaining 85.3% (roughly 2.6 million bytes) is gap and tail data that no editor has ever mapped. DSTSSE reads all of this data, copies it byte-for-byte as-is, and writes it back without touching anything it doesn't understand.

The problem is, existing save editors had several shortcomings:

• No automatic backups. Edit something wrong, and your save is gone.
• Many save editors use web apps or Python scripts. You need to install dependencies, sometimes decrypt manually.
• No change validation. Set a stat to an invalid value and the game can crash or the save can corrupt.
• Some save editors need the internet. A few upload save files to a server for decryption. For some people, that's a dealbreaker.
• None show the impact of an edit. You don't know how many records will be affected before you hit save.

DSTSSE was designed to solve all of these problems at once.

The safety-first philosophy

The most compelling thing about DSTSSE isn't its features — it's its philosophy. Every design decision answers the same question:

"What if the user hits Ctrl+S while eating chicken noodle soup and their laptop suddenly dies?"

The answer: your save file stays safe. This isn't hyperbole — this is literally how it works.

Tech Stack: Rust + Tauri 2 + React 19

DSTSSE isn't just another save editor. The tech stack choices are very deliberate, and each one has a strong rationale.

Rust (Backend)

Rust was chosen for three reasons: speed, memory safety, and small binaries.

For a save editor, Rust provides:

• Zero-cost abstractions — parse save files as fast as C but without the risk of buffer overflows
• Type safety — if a field is wrong, you catch it at compile time, not runtime
• No garbage collector — the app starts instantly, no GC pauses breaking the UX
• Single binary — the compiled output is a single executable, no runtime or dependencies needed

The save file itself is decrypted from AES-128-ECB and parsed into Rust data structures. Key offsets are read from save/layout.rs at build time — so the save file layout is known before the app even runs. This ensures all known offsets and regions are compiled into the binary, not hardcoded at runtime.

Tauri 2 (Desktop Framework)

If you're familiar with Electron, Tauri is similar but far more lightweight. The key differences:

Tauri 2 enables:

• Secure IPC — safe, structured communication between the frontend (React) and backend (Rust)
• Controlled file system access — no need for full disk access
• Native window management — feels like a real app, not a web page wrapped in a shell
• Built-in auto-updates
• Cross-platform — Windows, macOS, and Linux from a single codebase

Most importantly: Tauri 2 disallows network requests by default unless you explicitly opt in. DSTSSE takes advantage of this — the app has no bundled HTTP client whatsoever. There is no way to send data out, even if you wanted to. This isn't just a feature — it's an architectural guarantee.

React 19 (Frontend)

React 19 powers the UI. With features like the React Compiler, Actions, and Server Components (though Server Components aren't relevant in a desktop context), React 19 delivers:

• Faster rendering — the React Compiler automatically optimizes re-renders
• Better form handling — a save editor has tons of form inputs (stat edits, bulk actions), and React 19 makes this smoother
• Type safety with TypeScript — all UI components are strictly typed

The UI itself is designed to be responsive and informative. Every screen shows relevant information — from save slot cards displaying your party trio to per-Digimon detail panes. All screenshots on the website use direct captures from the app at 1280×800 resolution — no mockups, no fake data. What you see on the site is what you get.

Why this stack?

The Rust + Tauri 2 + React 19 combination produces an app that is:

1. Lightweight — small binary, low RAM usage
2. Fast — instant startup, fast save file parsing
3. Safe — memory-safe backend, network disabled by default
4. Beautiful — modern, responsive UI without the bloat

Key Features

Save Slot Browser

When you first open DSTSSE, you'll be asked to point it to your Steam savedata folder. After that, all save slots appear as cards — each displaying:

• Party trio (3 main Digimon), just like the game's load screen
• Playtime
• In-game money
• Roster size
• Last modified timestamp

The folder you last opened is remembered, so next time it's just one click away. No more browsing around. You can instantly tell which slot you want to edit without opening them one by one.

Roster Editor

This is the core feature. DSTSSE can display and edit your entire Digimon roster — party, box, and farm included. Features include:

• Individual stat editing — level, EXP, bond, talent, all base stats
• Evolution counters — edit evolution counters per Digimon
• Detail pane — view a single Digimon's full details while seeing the roster list alongside. You can scroll the roster and the detail pane updates instantly
• Scope selector — choose whether changes apply to a single Digimon, one party, or the entire roster

Agent & Inventory Editor

Beyond the roster, DSTSSE can also edit:

• Agent skills — progress bars and levels for each agent skill
• Inventory — items you own, their quantities, and where they're used
• Scan data — scan data you've collected

Field Guide & Digidex

DSTSSE displays the field guide and digidex as a read-only summary — so you can check your completion progress without any risk of accidentally changing data that shouldn't be changed. Progress bars show how complete your collection is, and the numbers include unsaved changes.

Bulk Actions

A seriously powerful feature: you can apply changes to many Digimon at once. For example:

• Set the entire roster's level to a specific value (automatically calculates the corresponding EXP)
• Set bond to a specific value
• Set talent to a specific value
• Add or set stat blocks across the entire roster

The best part: every bulk action button shows the number of records it will touch before you click it. So you know exactly what the impact will be — whether you're about to change 3 Digimon or 300. No surprises.

Overview Dashboard

A read-only summary of the currently open save file:

• Tamer name
• Roster breakdown (party, box, farm)
• Party trio
• Progress bars for agent skills, inventory, scans, and field guide
• Numbers that include unsaved changes (with dot markers to distinguish them from the file on disk)

This dashboard is great for simply "checking the state of your save without editing anything."

The Safety-First Approach: Five Security Steps

This is the most compelling part of DSTSSE. Every time you press Ctrl+S, here's what happens:

Step 1: Batch Confirmation

The app shows you every change that will be written to the save file. Not just "Are you sure?" — but a complete list of every change, how many records are affected, which file it's going to, and what the backup file will be named.

For example: if you've edited 49 fields, the dialog will say "49 changes will be written to 0001.bin, with the backup it will make named beneath the list." The button reads "Back up & save" — because that's exactly the order of operations.

If you click "Cancel," not a single byte moves. That's the promise.

Step 2: Batch Validation

Before anything is written, the entire batch of changes is validated first. If even one edit is invalid — say a stat is out of range or a field is corrupt — the entire batch is rejected. The save file remains exactly as it was before.

This is different from many save editors that write changes one at a time. If edit number 15 out of 50 is bad, another editor may have already written the first 14 — leaving you with a save file that's half old, half new. DSTSSE never puts you in that situation.

Step 3: Backup File

The backup happens AFTER validation passes, BEFORE any writing occurs. If the backup fails — say the disk is full or the file is locked — the write is cancelled. There is no "save anyway." There is no option to skip the backup.

Step 4: Write-Beside-Rename

DSTSSE never writes directly to the save file. Here's what actually happens:

1. Write to a new file beside the original (e.g., 0001_new.bin next to 0001.bin)
2. Once the new file is 100% written, rename the original to the backup name
3. Rename the new file to the original's name

Why does this matter? Because if your laptop dies mid-write — you still have an intact file, not a half-finished one. The old backup is still there, and the partially written new file will never replace a valid file. This is the same pattern used by production databases and professional text editors — atomic write via rename.

Step 5: Restore

Any backup that was created can be restored at any time. If you realize your edit was wrong after saving, you can restore the backup and return to the previous state.

Safety Flow Summary

Edit → Batch Confirm → Validate → Backup → Write Beside → Rename → Done
         ↓ Cancel         ↓ Fail      ↓ Fail       ↓ Fail
      Nothing changes   Batch rejected  Write cancelled  File stays intact

"Nothing is uploaded, ever." — That sentence appears on the website, and it's serious. No network calls, no telemetry, no accounts. The app is built without an HTTP client entirely. Everything stays on your disk.

How to Use It

Requirements

• Operating system: Windows (primary support)
• Game: Digimon Story: Time Stranger (Steam)
• Save file: Already on your disk (typically in Steam/userdata/[your-id]/)

Steps

1. Download DSTSSE from the official website — it's a .zip file, just unzip it
2. Run the executable — no installation required, no dependencies, no .NET or Java needed
3. Point it to your Steam savedata folder — usually Steam/userdata/[your-id]/
4. Select a save slot from the card list that appears
5. Edit whatever you want — roster, agent, inventory, etc.
6. Press Ctrl+S to save — the batch confirmation dialog will appear, review your changes, then click "Back up & save"

That's it. No login, no setup wizard, no restart needed. Unzip, run, edit, save.

Tips

• Read the changelog in About — all available features are listed there with full details
• Watch the numbers on bulk actions — buttons show how many records will be touched before you click
• Use the Overview to check for unsaved changes — dot markers highlight differences from the file on disk
• The last folder is remembered — no need to browse again every time you open the app

Why Rust, Not Python or Electron?

This is a question that comes up if you're familiar with tool development.

vs Python

Most save editors are built with Python because it's fast to develop with. But for a desktop app that truly aims for zero dependencies and zero network, Python falls short:

• Python requires a runtime to be installed
• PyInstaller can bundle it, but the binary is large (~50-100 MB)
• Memory usage is higher
• No compile-time type safety
• Slower startup time

vs Electron

Electron is popular for cross-platform desktop apps. But:

• The bundled Chromium creates a massive binary
• High RAM usage even for simple apps
• Network access is available by default
• Slower startup time
• Overkill for an app focused on file manipulation

Rust + Tauri gives you the best of both worlds: React's ease of use for the UI, Rust's speed and safety for the backend, and a small binary footprint.

Use Cases

1. Recovering Lost Progress

If your save file gets corrupted from a crash or game bug, and you have a DSTSSE backup — you can restore it. Even if you didn't have a backup before, DSTSSE creates one every time you save, so you always have a restore point.

2. Exploring Save Data

Curious what's actually stored in your save file? DSTSSE displays the data structure visually — from offsets to field-by-field contents. Even unmapped sections are read and copied correctly.

3. Testing Build Strategies

Want to try building a specific Digimon without risking your progress? Clone the save, edit it in DSTSSE, test it in-game — if it doesn't work out, restore the backup.

4. Save Format Research

DSTSSE uses a save format that was mapped by the ANAMNESIS Save Editor by DotingDavid. The save format, reference database, and icons all come from that project. DSTSSE acknowledges this clearly in the website footer — and it shows the importance of open source collaboration in the gaming community.

5. Speedrunning & Challenge Runs

For speedrunners who need to reset progress or set up specific save files for challenge runs, DSTSSE provides a safe way to manipulate data.

6. Debugging

If the game crashes or there's a bug, you can inspect the save file with DSTSSE to check whether the data is valid or corrupt — without needing to wrestle with a hex editor.

Contributing & Open Source

DSTSSE is built with an open source spirit. The save format, reference database, and icons come from the ANAMNESIS Save Editor by DotingDavid — a project that mapped where the roster lives, what each field means, and how values are scaled on disk.

If you find a bug or have a suggestion, you can open an issue on GitHub. No account needed, no complicated approval process.

This project demonstrates how a save editor can build on top of others' work in an ethical way — giving proper attribution, using already-mapped data, and contributing back to the ecosystem.

FAQ

Is DSTSSE free? Yes, completely free. There's no paid version, no locked premium features.

Can DSTSSE corrupt my save file? Technically it could — but with its 5-step safety system, the odds are extremely slim. Backups are always created before writing, and write-by-rename ensures the file is never left half-finished.

Do I need to decrypt the save file before editing it? No. DSTSSE handles decryption automatically. The file you edit is the same file the game reads.

Are there macOS or Linux versions? Currently primary support is Windows. Since Tauri 2 supports cross-platform, macOS and Linux versions could be made in the future.

How do I get it? Download from dstsse.antwacode.com. It always resolves to the latest version.

Conclusion

DSTSSE proves that a save editor doesn't have to be a fragile Python script or a web app that requires uploading files to a server. With the right approach — Rust for the backend, Tauri 2 for the desktop framework, React 19 for the UI — you can build an app that's lightweight, safe, and genuinely respectful of user privacy.

Most importantly: safety-first isn't a feature, it's an architecture. The five security steps in DSTSSE weren't tacked on as an afterthought — they were designed from the ground up as the only path from edit to save.

If you play Digimon Story: Time Stranger and need a save editor that takes data safety seriously, DSTSSE is worth a look. Free, open source, and it will never send your data anywhere.

Download: dstsse.antwacode.com

Disclaimer: DSTSSE is not affiliated with, sponsored by, or connected to Bandai Namco Entertainment or Media Vision. Digimon Story: Time Stranger is a trademark of Bandai Namco Entertainment Inc.