xEdit-rust

Rebuild of the xEdit project in Rust. Additionally features CLI control of all xEdit features and native support for AI agents to control it.

The build plan is in docs/PLAN.md.

Progress

Overall: 7 of 10 phases merged.

[##############......] 70%   phases 0-6 of 0-9 merged into main

Phase	Scope	Progress	State
0	Foundations	[##########]	Merged
1	Read path for the first games	[##########]	Merged
2	All games and saves	[##########]	Merged
3	Write path and daemon	[##########]	Merged (PR #12)
4	Analysis and tool modes	[##########] 10 of 10 steps	Merged (PR #13)
5	Archives, assets and LOD	[##########]	Merged (PR #14)
6	Scripting	[##########] 11 of 11 steps	Merged (PR #20)
7	GUI	[..........]	Not started
8	Performance	[..........]	Not started
9	Release and cutover	[..........]	Not started

The overall bar counts merged phases only: 2 cells per phase out of 20. A phase on a draft pull request counts once it merges. Per-phase bars have 10 cells and show completed steps as a share of the phase's steps, as listed in docs/PLAN.md.

Keep this section current. Update it in the same pull request whenever a step lands, a phase starts or a phase merges: redraw the bars, change the step counts and the state column, and update the overall percentage.

Goals

• Port xEdit to Rust with 1:1 functionality*
  • Morrowind and Enderal are loaded but not verified against the oracle yet (it can not dump or save Morrowind plugins, and Enderal is not installed); verified support comes later
• Match the upstream release build exactly
  • The official binaries of the baseline tag (xedit-4.1.5q) are the oracle; a differential harness compares the port's output with theirs on the real game files, and each phase closes only when its parity gate holds. Upstream quirks are reproduced, not corrected.
• Keep existing scripts, plugins and workflows working. Compatibility with xEdit behaviour, its Pascal scripts and the files it writes wins over every other concern.
• Be easier to contribute to than the Delphi original: a modern toolchain (cargo build, cargo test, clippy, one command for the parity check), no proprietary compiler, typed interfaces instead of 103 COM-style interfaces in one 50,000-line unit, and a module per upstream unit so the Pascal source stays a readable map of the Rust.
• Expose every operation through the xedit CLI as a typed command with --json output, stable error codes and a printable schema (xedit schema), so that an AI agent can discover and drive the whole tool without the GUI.
  • Make mutation safe for agents: an explicit edit flag, --dry-run, structured outcomes, atomic saves with a backup, and a long-lived session (xedit batch, xedit serve, xedit mcp) that runs the same commands.
• Stay mergeable with upstream. One Rust module per Pascal unit with matching names, and upstream-map.toml records the last upstream commit merged into each, so upstream changes map onto the port line by line.
• Get faster than upstream once parity holds

Non-goals

• No new file formats, record definitions or game support beyond what the baseline tag ships. New upstream releases are taken in through the sync procedure, not ahead of it.
• No redesign of the data model, the scripting language or the GUI. JvInterpreter Pascal stays the script language; the GUI reproduces the upstream forms on top of the same commands.
• No separate agent API. Agents use the same command layer as the CLI and the GUI; there is no second surface to keep in step.
• No dependence on a Delphi compiler. The oracle is the released binary, never a rebuild.
• No non-Windows platform before the Windows port is complete. Linux and macOS follow, behind thin platform modules.
• No game files in the repository. The parity corpus comes from local installs through environment variables.

Status

• Phases 0 to 2 of the plan are done: every game mode from Morrowind to Starfield and every save format load and dump like the release build, verified file by file against it on the local game installs (Morrowind's masters and Enderal are not verified: the oracle cannot dump Morrowind plugins and Enderal is not installed on the development machine).
• Phase 3 (write path and daemon) is done (merged in PR #12). A loaded plugin can be edited, saved and served to a long-running session, and the saved bytes are xEdit's. cargo xtask parity oracle-save drives the xEdit GUI release build headlessly to save every plugin of the corpus and compares the port's save with it: 239 of 249 plugins are byte-identical, 7 are refused with the same message by both, and the 3 Morrowind masters have no oracle save because the 4.1.5q GUI cannot save Morrowind plugins; cargo xtask parity roundtrip loads and saves the corpus and agrees. cargo xtask parity oracle-edit replays scripted edit sequences on both: the 4 of phase 3 give the oracle's bytes since phase 4 (the master update of a plugin with unchanged sorted arrays differed at the end of phase 3).
• The write commands are xedit elements set|add|remove (any element by path, a member, an array entry or a child record such as a reference of a cell), xedit records copy|delete (as an override or a new record, deep, with the masters it needs added), xedit masters add|sort|clean (with every FormID of the plugin rewritten to follow them), xedit formids change|renumber (updating the records that refer to the changed FormIDs), xedit files flags (ESM, ESL, medium, update, blueprint, localized) and xedit save. Every mutating command takes --dry-run, refuses to run without the global --edit flag otherwise, and changes memory only until xedit save. The AfterSet and AfterLoad callbacks of the definitions run, as in xEdit.
• xedit batch runs several commands in one session, so an edit and its save go together. xedit serve keeps a session loaded and answers every registry command as a JSON-RPC method over stdio or a Windows named pipe, and xedit mcp serves the same commands as MCP tools over stdio; both are built from the registry at run time, keep the --edit gate and dry_run, and leave saving to an explicit files.save. The skills using-xedit-cli and adding-a-command under .claude/skills describe how to drive the tool safely and how to add a command.
• Loading reads the groups of a plugin on all CPUs and xedit dump builds and writes the records on all CPUs (--threads N; about five times faster on Skyrim.esm than on one thread), with output that does not depend on the thread count.
• Known gaps of the write path, all listed in docs/PLAN.md under "Owed from phase 3": copying over an existing override and partial forms, the order of the responses of a topic after a master update in the games that sort them by their PNAM, the identity FormID of a Morrowind record, and one session per process.
• Phase 4 (analysis and tool modes) is done (merged in PR #13). Conflict detection is done: xedit conflicts gives the conflict status of every record of the loaded plugins as xEdit colours it (master, override, identical to master, conflict winner and loser, critical conflicts of injected records, game settings compared by editor ID), with per-file counts and filters, and xedit compare shows the records of a FormID side by side, row by row, as the view tab does. cargo xtask parity conflicts has the xEdit GUI classify every record of the vanilla plugins of each game and compares: 23.4 million records of 10 games equal (Morrowind has no oracle: the GUI runs it in view mode only). The comparison runs on all CPUs with the same output for every thread count. A session now reads plugins with the editor's settings (simple records, hidden unused fields, the contained-in elements, the sorted responses of a topic), as xEdit does; xedit dump keeps xDump's. The reference index is done: xedit refs get lists the records that refer to a record (xEdit's "Referenced By" tab) and the records it refers to, xedit refs build builds the index of the loaded files on all CPUs or loads it from xEdit's reference cache files, which the CLI reads and writes in xEdit's format, and edits keep it right; formids change|renumber use it. cargo xtask parity refs has the xEdit GUI build the index of the vanilla plugins of each game and compares every referenced-by list and every cache file: 33.2 million entries of 5.8 million records of 9 games equal, built and loaded from the cache, with every cache file of those games equal after decompression; Starfield differs in 18 entries, from perk activities whose JSON the port does not read yet.
• Error checks are done (phase 4 step 3): xedit check is xEdit's "Check for Errors" (mniNavCheckForErrorsClick, the registry's files.check): it loads the plugins with that mode's settings and checks the records on all CPUs, printing what xEdit's message log prints (the record, the element -> error of every error, Above errors were found in: after the elements of a container with errors), and --json gives the records and their errors; xedit dump --check is xDump's -check. cargo xtask parity check runs the xEdit GUI's own check mode on the vanilla plugins of every game and compares the log lines, the counts and the exit code: 245 of the 249 plugins equal (1 equal-log-loss, a Fallout 76 file whose oracle log lost lines under load, with every line it kept and the counts equal; 3 oracle-unsupported, the Morrowind masters, which the GUI runs in view mode only; 0 different), and cargo xtask parity check-dump compares xDump's -check with xedit dump --check over the same corpus, the files whose dump the oracle crashes on compared as prefixes.
• Plugin cleaning is done (phase 4 step 5): xedit clean --quick is xEdit's quick auto clean mode (undelete and disable the deleted references, remove the records identical to their master, save, repeat), loading the plugins with that mode's settings as xEdit does, and --itm, --udr and --dry-run run the steps alone or count them; xedit records cleanup-injected is "Cleanup injected records". cargo xtask parity clean runs xEdit's own quick auto clean mode headlessly on every corpus plugin that has masters and compares the saved bytes, the counts and the cleaned records with the port's (results in docs/PLAN.md).
• Mod groups are done (phase 4 step 6): xedit modgroups list|show|select|create|edit|delete|update-crcs reads and writes xEdit's .modgroups files and its saved selection as xEdit does, and xedit conflicts --modgroups NAME, --all-modgroups or --saved-modgroups leaves the records the active groups hide out of the comparison (ctHiddenByModGroup). cargo xtask parity modgroups has the xEdit GUI activate, edit, delete and update mod groups from its menus, answering its dialogs headlessly, and compares the conflict status of every record, the files it writes and its validation messages: 9 of 9 scenarios on Skyrim SE and Fallout 4 equal.
• Localization is done (phase 4 step 7): a localized string of a localized plugin can be set and copied (the text goes into the plugin's string tables, a new string takes the next free ID), xedit save writes the changed .STRINGS, .DLSTRINGS and .ILSTRINGS tables next to the plugin as xEdit writes them, xedit localization localize|delocalize is xEdit's "Localize plugin" (with its translation from other tables) and "Delocalize plugin", and xedit localization files|strings|get|set|export|languages|language are the localization editor and the Language menu; --language picks the tables' language and --translate loads in xEdit's translate mode. cargo xtask parity oracle-edit gives the xEdit GUI the game's string tables, has it save its own tables and compares them: the edits, localizations and delocalizations of Skyrim SE, Fallout 4 and Starfield plugins give xEdit's bytes for 26 of 27 saved plugins and tables (results in docs/PLAN.md).
• Merged patches are done (phase 4 step 8): xedit patch merged <name> [--dry-run] [--no-save] [--output] [--no-backup] is xEdit's "Create Merged Patch" — the leveled lists, containers, faction relations, races, form lists (the ordered form lists whose editor ID ends in OrderedList take appends only, and a faulty one is reported and left out), actor items, factions, effects, perks and keywords, and the keywords of the items and effects of the newer games, merged into one new plugin so that no plugin's changes are lost to the one that loads last; xedit files new is its AddNewFile. cargo xtask parity merged makes the scenario's plugins with the port, has the xEdit GUI create its merged patch with the same files (clicking the menu items that activate mod groups and answering its dialogs headlessly) and compares the patches byte for byte: 12 of 12 scenarios on Fallout New Vegas, Skyrim SE, Fallout 4 and Oblivion equal, the faulty ordered list's message included (results in docs/PLAN.md).
• The filter of the navigation tree is done (phase 4 step 4): xedit filter apply runs every option of xEdit's filter dialog over the loaded plugins and reports what it keeps (the two passes, the nodes left and the records taken out of each file), either from the options in the request or from a [Filter <name>] preset of xEdit's settings file, which xedit filter presets|save|delete manage; xedit filter remove takes the filter off, and xedit refs build-reachable is "Build Reachable Info", which the not-reachable option reads. The view filter of the view tab is the --view-filter-name|value options (with --keep-children, --keep-siblings, --keep-parents-siblings) of xedit compare, and the referenced-by filter is the --filter-name|signature|file options of xedit refs get. cargo xtask parity filter has the xEdit GUI apply filters from its script API and compares the counts it logs (results in docs/PLAN.md).
• Tool modes are done (phase 4 step 9): xedit tool modes lists the seventeen modes of xeInit.pas with the switch of each, and xedit tool run <mode> runs one over the loaded plugins — setesm, clearesm, masterupdate, masterrestore, onamupdate, sortandcleanmasters, generateseq (the .seq files of the start-game-enabled quests a plugin adds), checkforerrors, checkforitm, checkfordr (which count and exit with the count, at most 127, as xEdit does) and export (xDump's -export RAW: the profile of the game's record definitions, written as a file and printed as the structure of the definitions). Each mode loads with the settings xeInit.pas gives it (the internal edits, the reference information, the translate mode, the ONAM filter and the rest). The command line of xEdit itself is read too: parse_legacy (the port of wbCommandLine's wbFindCmdLineParam and of DetectAppMode) accepts the switches a mod manager passes — -quickautoclean -qac -quickclean -checkforitm -checkfordr -CheckForErrors -translate -setesm -clearesm -masterupdate -masterrestore -onamupdate -sortandcleanmasters -generateseq -export -lodgen -script -D: -P: -l: -autoexit -autoload -IKnowWhatImDoing and the rest, including the executable names (SSEEditQuickAutoClean.exe) and the game switches (-SSE). cargo xtask parity tool-modes has the xEdit GUI run each mode it has on the corpus plugins and compares the saved bytes, the message log lines and the exit codes (results in docs/PLAN.md); -CheckForErrors is parity check, -dump is parity dump and -quickautoclean is parity clean.
• The phase-4 agent workflow skills are under .claude/skills: auditing-conflicts (which override of a FormID wins and what the conflict statuses mean, narrowing the list to the records a plugin wins or loses, the side-by-side compare of a record, the mod groups that hide records and the reference index that shows what a record is used by), cleaning-plugins (the ITM and UDR steps, the quick auto clean mode and the injection cleanup, with what the oracle check showed) and building-patches (xEdit's merged patch and purpose-built override patches made from files new and records copy). They are the native replacements for the xEdit-llm daemon's comparison, cleaning and patch routes.
• Phase 4 (analysis and tool modes) is done and its gate is met: the conflict status of the vanilla plugins of 10 games (23,383,514 records) equals the oracle, so does the reference index of 9 games (5,829,130 records with 33,228,829 entries, every cache file equal after decompression; Starfield is short by the 18 entries of the perk activities whose JSON the port does not read), the cleaning result of 231 of 238 corpus plugins (every pass's counts and every cleaned record line the oracle's; the 4 files that differ do so in the bytes of records the clean did not touch) and the error check output of 245 of 249 plugins (and, through xDump, 246 of 246 files). The phase's other oracle checks are in as well: the filter (37 of 37 and 8 of 8 configurations and the reachable-information scenario, results and what is owed in docs/PLAN.md under phase 4), 9 of 9 mod group scenarios, 12 of 12 merged-patch scenarios, the localization sequences (26 of 27 saved plugins and tables in the ten step-7 sequences, 31 of 32 saved files over all 15 since step 8, the one difference the known Starfield delocalize emulation limit) and 24 of 31 tool-mode cases (4 known-difference in the export, 3 oracle-unsupported). What is still owed, with the numbers, is in docs/PLAN.md under phase 4.
• Archives (phase 5 step 1): xedit archive list|extract|pack and the bsarch binary read, unpack and write BSA (Morrowind, Oblivion, Fallout 3, New Vegas, Skyrim LE and SE) and general BA2 (Fallout 4, Fallout 76, Starfield) archives. bsarch takes the arguments of BSArch.exe and prints its text. Packing runs on all CPUs, and the archives are byte for byte the ones BSArch.exe -mt:no writes, for every thread count: cargo xtask parity bsarch compares the listings, the unpacked files and the packed archives of the game archives with the oracle. The texture archives (DX10, Fallout 4 and Starfield) pack and unpack too (phase 5 step 2): a DDS file is stored as chunks of mipmaps and written again with the header xEdit makes, byte for byte as BSArch.exe does for the 125 texture archives of the corpus and for generated DDS folders, with the pixel conversion and the half-float array conversions on vector instructions where the machine has them (a scalar version gives the same bytes; XEDIT_SIMD=off forces it).
• NIF meshes and materials (phase 5 step 3): xedit assets dump|blocks|save|set|from-json read, dump, edit and write the NIF and KF files of every game from Morrowind to Fallout 4, Fallout 4 BGSM and BGEM materials, the LOD settings and tree LOD files, FUZ voice files and DDS headers, loose or inside an archive. A file loaded and saved gives xEdit's bytes, and the dump is the JSON of Sniff's converter or xEdit's text dump: cargo xtask parity nif compares the port with Sniff.exe and with the xEdit GUI's script adapter on every mesh and material of the game archives. Fallout 76 and Starfield meshes are refused with xEdit's own message, as the 4.1.5q release does; optimizing and stripifying a mesh is the Sniff operation Optimize mesh (step 6), the SpellOptimize, SpellStripify and SpellTriangulate functions themselves having no command of their own.
• Sniff (phase 5 steps 4 and 5): xedit sniff list|run and the sniff binary (which takes the arguments of Sniff.exe's automation mode) run 49 of Sniff's 50 batch operations on the meshes, animations and textures of a folder or an archive, on all CPUs: updating tangents and bounds, applying and adjusting transforms, the universal tweaker and fixer, the JSON converter, replacing asset paths, copying and merging geometry and shapes, painting vertex colours, copying and adding animation blocks (headtracking, facial, transform data, controlled blocks, skeleton bones), the Havok, shader flag and animation operations, optimizing and analysing meshes, and the reports (check for errors over meshes and textures, find textures, draw calls, UVs, transforms, Havok info). cargo xtask parity sniff compares each operation's output files and log with Sniff.exe on the game archives, the texture operations on the DDS files of the texture archives and of the unpacked samples of the others. Update MOPP code stays unported (it calls NifMopp.dll, a Havok library the port does not have) and ProcCollapseLinksArrays is not registered in the 4.1.5q form.
• LOD generation (phase 5 step 6): xedit lodgen runs xEdit's LODGen mode on the loaded plugins, Oblivion's distant LOD (.lod and .cmp), the trees LOD (billboards, .lst list, .btt and .dtl blocks, the atlas and its split) and the objects LOD of Skyrim and the Fallouts, with the form's options (--set, the settings file), a recoverable tree-rotation seed and the export files LODGenx64.exe consumes. cargo xtask parity lodgen compares every output file, export file and log line with the GUI's LODGen mode: 20 of 20 cases equal (Fallout 4, Skyrim SE, New Vegas, Fallout 3 and Oblivion worldspaces, the atlas formats and sizes, trees LOD with billboards and with 3D trees, the splits of the atlases).
• Phase 5 (archives, assets and LOD) is done and its gate is met: packed archives are byte-identical to BSArch.exe -mt:no (cargo xtask parity bsarch: 1553 of 1553 checks equal, 0 different, over the archives of the 11 games and the synthetic folders), and the Sniff and LODGen outputs equal the oracle (cargo xtask parity nif: 542505 files equal, 0 different; cargo xtask parity sniff: every case run on the full corpus equal, the per-case numbers and the cases still owed in docs/PLAN.md; cargo xtask parity lodgen: 20 of 20 cases equal). The skills handling-archives and nif-batch-operations under .claude/skills describe the asset commands.
• Phase 6 (scripting) has started (draft pull request #20, branch phase-6-scripting): the CLI is xedit script list|check|run (the registry's script.list, script.check and script.run, the last mutating with the --edit gate, --dry-run, --no-save and --scripts), and the tmScript tool mode and the legacy -script: switch run the same path. The interpreter (crates/xedit-script) is the JvInterpreterParser.pas tokenizer and the JvInterpreter.pas front end as an AST builder (step 2), the Variant value model, the registration model of TJvInterpreterAdapter with the sorted identifier dispatch and the for/case 64-bit dialect quirk (step 3), and the host of xejviScriptHost.pas (the uses namespace stripping, the unit sources of the scripts folder with the compiled-in stubs, FunctionExists, FunctionIsEmpty and CallFunction, step 4). xedit script check compiles as TJvInterpreterUnit.Compile does: a routine body is only scanned for its balanced end, so a statement-level error surfaces when the script runs. It parses all 150 .pas of the 4.1.5q Edit Scripts (150 of 150, 0 fail). The corpus and its classification (150 scripts, 32 form, 11 dialogs, 110 headless, xEditAPI.pas the declaration-only API the scripts uses) are crates/xtask/oracle/scripts/corpus.json; the run cases are crates/xtask/oracle/scripts/runs.json.
• The run loop of xeMainForm.pas's DoRunScript/ApplyScript (step 4, crates/xedit-session/src/script.rs) runs Initialize, Process over the navigation-tree selection (every loaded file, each file's elements from the last back to the file node) through the ScriptProcessElements, ScriptProcessSignatures and filter hooks, then Finalize, and saves the plugins the run changed as the GUI's close does. A missing or FunctionIsEmpty routine is skipped, a non-zero result stops the run with Script terminated itself, Result=<n>, and a failure prints the interpreter's Exception in unit <u> line <n>: [<class>] <message> and Aborted: Applying script "<name>", exits non-zero and still saves what the script changed before the failure. The message log is the output (stdout with the [mm:ss] prefixes of xEdit's log, messages in the --json response), and a Mode: Silent script logs the closing line alone. The session-side script API of xejviScriptAdapterHost.pas (the message log, the loaded files, the paths, ApplyFilter) is bound on top.
• The script API landed step by step and is bound from the host down (steps 5 to 9): the five element-level units (crates/xedit-session/src/script_units/: element, record, file, container and resource, 203 of their 207 ledger entries covered), the data format unit (script_df.rs, 173 of 174, the TdfDef/TdfElement classes over the phase-5 NIF, material, LOD, FUZ and DDS code), the misc family (script_misc*.rs, script_strings.rs, script_adapter.rs: TStringList/TEncoding, the StrUtils/SysUtils/Math/Variants helpers, TPerlRegEx, JsonDataObjects), the JVCL RTL (script_rtl/: System, SysUtils's IntToStr/Format/Pos, Math, the Classes unit's TStringList/TList/TStream family and JvInterpreterFm's four registrations; all 548 live ledger entries of the five units bound) and the VCL surface (script_vcl/: the ten VCL-backed JVCL units and xejviScriptAdapterMiscVcl.pas, whose generated tables carry the class hierarchy and the 782 constants captured from the 4.1.5q oracle). The fixup pass of p6-step5b reconciled FullPath with upstream, dispatched the indexed TStrings property and accepted SetESL.pas's multi-statement on handler; the Record Header/ElementCount and single-precision findings were refuted against the oracle's own script output. cargo xtask check counts the phase at 3,663 script entries, 30 pending (29 functions of xejviScriptAdapterHost.pas -- the file selection, settings, record lookup, conflict, form handle and LOD/atlas helpers -- and one JvInterpreter entry), so a script that calls one aborts with Undeclared Identifier '<name>'. Headless, a form, dialog or control call refuses through the Vcl seam with [EVclUnavailable] <class>.<member> is not available without a GUI (script "<name>"), the seam the GUI phase fills, with the 1,210 window-bound members excluded in the ledger; the Windows records, the Controls hint, cursor and accel helpers, the Menus shortcut codec and the IniFiles/IOUtils classes answer; the corpus scripts that stop on such a call are the ones cargo xtask parity script classes form/interactive.
• The phase gate harness is cargo xtask parity script (step 10, crates/xtask/src/parity/script.rs), which drives the oracle GUI hidden. Parse, over all 150 .pas: 150 of 150 equal (149 equal and 1 known-difference, exit 0; the oracle's 4.1.5q compiler faults on the declaration-only xEditAPI.pas, which parse.json accepts with its reason). Run, over the 117 form-free cases of runs.json: 107 of the 117 cases in the first full comparison (12m03s at --jobs 3; the seven slowest skipped with --skip and 2 Fallout New Vegas cases skipped for an emptied data folder), 0 equal, 78 different and 29 oracle-interactive, the differences being names the host had not registered yet, the filter scripts' log lines and the abort text's shape. With steps 5 to 9 in, Bookmark1.pas and Bookmark2.pas are equal (2 of 2: the Bookmark.ini bytes and a Mode: Silent script's whole log is the closing line), the phase's first equal run cases. The run-parity fixups (branch p6-rp-fix, 2026-10-10) then fixed the walk's over-delivery -- the port now reports the oracle's Processed Records: 869712 for the all-records scripts over Skyrim.esm (single-case runs at the fixup tip), the script-visible short names (EditorID "Full Name" [SIG:FormID]), the abort line's shape (Exception in unit line -1: ... for interpreter errors) and the RemoveNode / zero-argument registrations; the fresh full comparison at this tip was stopped by the system (low memory) before it produced case counts, so its class counts are owed, with the regression tests and the single-case runs as the evidence. The second run-parity fixup (branch p6-rp2, 2026-10-10) fixed the filter's Start:/Done: Applying Filter log lines (the filter scripts compare equal), the executable pseudo-file's [00] <exe>.exe name and its game-master entry, the OS-error texts (Delphi's shape, without Rust's (os error N)), the interpreter's Inc/Dec by-reference write-back, the TwbFastStringList.Create object model and TDirectory's missing-folder raise; it wired the run's private folders into the harness recipe (the port's run folder as ScriptsPath(), the plugins as private Data copies whose folder the port's data path follows, --program-path, --allow-edit-game-master, --build-refs), made the port save the changed plugins in the GUI's shapes (Saving: <name>.save.<timestamp>, Queued renaming of save ... on shutdown., Done saving.), mapped each side's run folder to <root> and the save clock to <time> in the comparison, and added the equal-log-loss class for the oracle memo's lost lines. Verification at this tip: the 14-case targeted rerun 11 of 14 equal, the other three traced (two fixed and probe-verified at the binary, one for the loss class), the parity mode's unit tests 7/7, clippy and the release build green; the fresh full comparison at this tip and the cargo fmt --all --check / cargo test --workspace / cargo xtask check gates were started and stopped by the system (low memory) before producing results, so its class counts are owed, with the regression tests and the single-case runs as the evidence. The gates it was waiting on are green (fmt, clippy, 669 workspace tests, cargo xtask check), and the last complete full comparison (tip a1c2f22, 2026-10-11, canonical cache) gives 64 of the 117 cases equal, 20 different, 31 oracle-interactive and 3 oracle-failed (oracle timeouts); the third fixup round (p6-rp3) then fixed and witnessed DDS - Find textures, Remove invalid entries from from lists, List perk entry points usage and List used meshes from references to equal and List used meshes to equal-log-loss, and the systemic <Warning: Unused data in: ...> load lines now emit identically. The fresh re-classification at the merged tip was started and stopped by the system (low memory) and is owed, together with the phase's other owed items in docs/PLAN.md.
• The phase's skill is writing-xedit-scripts under .claude/skills (choosing a script over xedit batch, running one, the API of xEditAPI.pas and the coverage ledger as the source of truth, the dialect, the headless limits, the output and log conventions, the divergences), and using-xedit-cli gained the xedit script run|list|check surface.
• Later phases (GUI, performance, release) have not started; phases 0 to 5 are done, merged and their gates met.

License

xEdit-rust is a port of xEdit by ElminsterAU and the xEdit contributors. xEdit is licensed under the Mozilla Public License 2.0, and ported files are Modifications that must stay under it, so this whole repository is licensed under MPL-2.0. See NOTICE for attribution and third-party terms.

Rules for contributions:

• Every source file starts with the MPL-2.0 notice shown in NOTICE.
• A file ported from upstream names its upstream origin below that notice.
• Every crate sets license.workspace = true.
• Dependencies must pass cargo deny check licenses against deny.toml.