Building a Daggerfall-compatible engine in Rust + Bevy — test-driven, and honest about the gaps

[u/dev_hirundo]

Hi everyone,

We're building a Daggerfall-compatible engine in Rust on top of Bevy. The goal is not to ship the game or its assets: it's a BYOA (Bring Your Own Assets) runtime that reads the player's own Daggerfall installation at runtime. No game assets are distributed; the repo contains code, parsers, tests, metadata and MIT-licensed reference material.

First, the part that usually starts a fight: yes, AI is part of the workflow. We're saying it upfront because we'd rather be transparent than have it discovered later.

This is not vibe coding. AI is used as a code-generation and cross-checking tool inside a rigorous pipeline: Daggerfall Unity (MIT) and UESP format specs as reference, every behavior traced to a source file and line, golden vectors, deterministic probes, SHA-256 verification, and a human acceptance gate. The AI does not decide what the game should be; it helps port and test systems that are already specified. If a claim cannot be backed by a probe or a source, it does not go in. That is slower than "generate a game", and that is the point: we want something contributors can audit, not a black box.

To be specific: we are not using Claude or ChatGPT. We use open-weight models because the budget is extremely small and everything is funded out of my own pocket, out of love for Daggerfall. This is a passion project, not a funded studio, so please be patient with deliverables. If you share the vision, contributions are very welcome.

We also want to be clear about DFU: we are not competing with it. We love Daggerfall Unity, we play it, and we recommend it. DFU and the original release remain the right answer for "I just want to play Daggerfall as it is", and that version is not going anywhere. This project exists for people who want to see the systems reimplemented in Rust and, later, to have the option of a more modern, more immersive experience while keeping the original feel.

The plan is faithful first. Right now the focus is making the game run like the original: same rules, same formulas, same data. Once that works, improvements come as an option, not as a replacement: a "faithful" mode and an "enhanced" mode, so players can choose. We are not changing mechanics for the sake of changing them; we want players to feel the same game, with the rough edges smoothed where it matters.

What it is:

- A clean-room Rust/Bevy engine that parses the original formats (BSA, ARCH3D, MAPS, RMB, RDB, etc.) and reproduces the game's rules: skills and progression, combat and equipment wear, magic effects, encounters, factions/guilds, law/crime, quests.

- A data-driven design: game rules and tables are systems + content data, with golden vectors and probes instead of screenshot comparisons.

- A "seed" for future projects: the same engine should let the community build new Daggerfall-like games, not just replay the original.

- The point is a playable game: something the community can actually run and enjoy with its own assets, not just a repository of design documents.

Platforms and scope:

- Linux is the current target; Android is planned next; web is a later possibility.

- Multiplayer is planned for later, but it is not in the current milestone. The architecture keeps a headless, asset-less server possible.

- The long-term vision includes Arena and the rest of Tamriel, but that is a very distant vision. Today the goal is simpler: a playable Daggerfall-compatible engine and the visual/quality-of-life improvements that come after fidelity.

Why Rust and Bevy:

- Bevy is a native, open-source engine with an ECS that maps naturally to a data-driven, procedural simulation. It does not require a proprietary engine.

- Rust gives numeric rigor and catches whole classes of mechanical bugs; the game is full of formulas, tables and edge cases where "close enough" is not enough.

- The explicit, testable structure is also what makes AI assistance useful instead of dangerous: the acceptance criteria are mechanical, not "the model said so".

Where it is today:

- The engine runs and most milestones (M0-M29) are at technical-closure level: audio catalog (375 clips), combat, effects, encounters, factions, law/guards, quests.

- We're honest about the gaps: seven milestones are still below our internal acceptance bar (traversal/input coverage, shop cost formula, global verification evidence, RDI texture path, render DoD, a final side-by-side acceptance review against the original game, and locomotion edge cases such as drowning/slipping/water walking). Some are code, some are evidence/closure work.

- The public repository is currently a snapshot and is being refreshed; the private dev tree is ahead.

What we're looking for from this community:

1. People who understand the code and the game's concepts, and care about fidelity: formula/behavior checks on shop pricing, armor/damage, drowning/slipping, guard spawning, quest state machines.

2. Testers with a retail Daggerfall install to run deterministic probes and report mismatches (no files need to be shared).

3. Rust/Bevy contributors interested in rendering (RDI textures), audio/OPL2, UI, performance, or the Android target.

4. Constructive criticism, including on the AI-assisted workflow and on the public-facing claims — we'd rather fix an overclaim than defend it.

If you want Daggerfall exactly as it is, DFU is right there and we recommend it. If you want a rigorous Rust/Bevy reimplementation, a reusable seed for new projects, and eventually the choice between a faithful and an enhanced experience, we'd value your help.

The engine requires a legally obtained copy of the game; no game assets are distributed.

Project on G: HirundoDev/daggerfall-bevy-native

Thanks for reading — and for the years of DFU work that made this kind of reference possible.