Creating a New Patch Forge for Assassin's Creed Shadows or later - Kamzik123/AnvilToolkit-Resources GitHub Wiki

This tutorial shows you how to create a brand-new patch forge (e.g. DataPC_boot_patch_03.forge) for Assassin's Creed Shadows or Black Flag Resynced (BFR) that the game will load and boot without crashing. A new patch forge lets you mod boot data by adding a thin forge on top of the chain instead of repacking the existing multi-gigabyte patch forges.

The easy way (AnvilToolkit 1.3.7+): You no longer have to do any of this by hand. AnvilToolkit 1.3.7 adds a Game Explorer → right-click → New → Patch Forge command for Shadows and BFR that builds a correct, boot-safe patch forge for you in one step. See The automatic way (recommended) below. The manual steps further down are kept for reference and for anyone on an older toolkit version.

Game compatibility: Written for and tested on Assassin's Creed Shadows and Black Flag Resynced (BFR) after the Ubisoft update that expanded the PrefetchInfoOverrides and DeletedFilesManifest formats. Automatic creation requires AnvilToolkit 1.3.7, the manual process was documented against 1.3.6. Not tested on other Anvil titles.

Why the manual process is so involved: After that update, simply dropping in a new patch forge, even an empty one, crashes the game during boot, before the main menu, with no error message. The fix is one specific, non-obvious step (Step 3 of the manual method). The 1.3.7 automatic command performs that step for you.

• The automatic way (recommended)
• Background: the boot patch chain
• The one rule that matters
• The manual way (obsolete in 1.3.7+)
  • Overview: what you edit
  • What you need before starting
  • Step 1: Create the new forge and copy the meta files
  • Step 2: Edit the DeletedFilesManifest
  • Step 3: Edit the PrefetchInfoOverrides
  • Step 4: Repack and test the empty shell
• Adding your actual mod content on top
• How it works (why Step 3 is required)
• Common mistakes and the crashes they cause

AnvilToolkit 1.3.7 and newer can create a boot-safe patch forge for you. This is the recommended method for both Assassin's Creed Shadows and Black Flag Resynced, it performs every edit described in the manual section below (including the critical prefetch carry-forward in Step 3) automatically and correctly.

1. In the Game Explorer, right-click to open the context menu.
2. Open the New submenu and choose Patch Forge. (This entry only appears for games that support it, currently Shadows and BFR.)
3. When prompted, choose the forge that will be used as the base, i.e. the current head of the chain you want to patch (for the boot chain, the highest-numbered existing patch, such as DataPC_boot_patch_02.forge).
4. AnvilToolkit creates the new patch forge for you, with the next number in the chain, the copied meta files, and the carried-forward prefetch graph already in place.

The result is the same valid, empty patch forge shell the manual method produces, one that loads cleanly and changes nothing, ready for you to add your mod content on top. You can skip straight from here to that section.

Tip: If the Patch Forge entry is missing from the New submenu, confirm you are on AnvilToolkit 1.3.7 or newer and that the selected game is Shadows or BFR.

The boot data loads as a layered chain of forges, each patching the one below it:

DataPC_boot.forge            (base)
  └─ DataPC_boot_patch_01.forge
       └─ DataPC_boot_patch_02.forge   ← current "head" of the chain
            └─ DataPC_boot_patch_03.forge   ← the new forge you are creating

The head forge (the highest-numbered patch present) is special: the engine treats it as the authority for the cumulative view of the chain. When you add patch_03, it becomes the new head, and it inherits responsibility for describing the merged state below it. That responsibility is what Step 3 satisfies.

Throughout this tutorial:

• Current head = the highest existing patch forge (here, DataPC_boot_patch_02.forge).
• New patch = the forge you are creating (here, DataPC_boot_patch_03.forge).

Adjust the numbers to your situation (if the highest existing patch is patch_05, your new one is patch_06 and its parent is patch_05).

When a new forge becomes the head of the boot patch chain, its PrefetchInfoOverrides must carry the prefetch graph forward. Concretely: copy the entire PrefetchingFileInfos object list into a new PrefetchInfoOverrides set that targets the previous head as its parent.

If you skip this, the boot prefetch graph is starved and the game crashes during early boot (see Common mistakes). Everything else in this tutorial is just making a valid, correctly-named empty shell.

⚠️ This section is obsolete as of AnvilToolkit 1.3.7. The automatic command does all of this for you. These steps are kept for reference — to understand what the toolkit does under the hood, to troubleshoot, or for anyone working with an older toolkit version. If you are on 1.3.7+, use the automatic method instead.

Copy 5 meta files from the current head patch, then edit only 2 of them.

• AnvilToolkit 1.3.6 (or newer) that can unpack/repack AC Shadows .forge files and round-trip the meta files to/from XML.
• The current head patch forge unpacked (e.g. DataPC_boot_patch_02.forge), so you can copy its meta files.
• A text/XML editor. The PrefetchInfoOverrides.xml is large (tens of MB); use an editor that handles big files.

The meta files inside a boot patch forge, as AnvilToolkit exposes them:

PrefetchingManifest.PrefetchingManifest   (43 bytes, empty in all forges)
DeletedFilesManifest.DeletedFilesManifest
PrefetchInfoOverrides.PrefetchInfoOverrides
PrefetchingFileInfos.PrefetchInfo
GlobalMetaFile.MetaFile

1. Create your new forge folder in the extracted folder named for the next number in the chain — e.g. DataPC_boot_patch_03.forge.
2. Copy these five meta files from the current head (DataPC_boot_patch_02) into your new forge, unchanged:
   • PrefetchingManifest
   • DeletedFilesManifest
   • PrefetchInfoOverrides
   • PrefetchingFileInfos
   • GlobalMetaFile

At this point your new patch is a byte-for-byte clone of the current head's metadata. You will make exactly two edits below.

Export the DeletedFilesManifest to XML by double clicking on it in the toolkit and open it. It contains a Version and a list of Sets, one per ancestor forge. Copied from patch_02, it currently has sets targeting patch_01 and boot:

<DeletedFilesManifest>
    <Value Name="Version" Type="Int16">1</Value>
    <List Name="Sets">
        <DeletedFilesManifestSet>
            <Value Name="ParentForgeName" Type="String">DataPC_boot_patch_01.forge</Value>
            ...
            <List Name="DeletedFiles"> ... </List>
        </DeletedFilesManifestSet>
        <DeletedFilesManifestSet>
            <Value Name="ParentForgeName" Type="String">DataPC_boot.forge</Value>
            ...
            <List Name="DeletedFiles"> ... </List>
        </DeletedFilesManifestSet>
    </List>
</DeletedFilesManifest>

Add one new set at the top of the Sets list, making sure to edit the ParentForgeName value to target the current head (patch_02) as its parent, with an empty DeletedFiles list (your new patch deletes nothing):

    <List Name="Sets">
        <DeletedFilesManifestSet>
            <Value Name="ParentForgeName" Type="String">DataPC_boot_patch_02.forge</Value>
            <List Name="DeletedFiles" />
        </DeletedFilesManifestSet>
        <!-- the existing patch_01 and boot sets stay below, unchanged -->

This is the step that makes the game boot. Export the PrefetchInfoOverrides to XML by double clicking on it in the toolkit and open it. Like the deleted-files manifest, it has a Version and a list of OverrideSets targeting ancestor forges.

Then, export and open the PrefetchingFileInfos file in another window. It looks like this:

<PrefetchingFileInfos>
    <List Name="Objects">
        <PrefetchFileInfoObject ID="..." Path="...">
            <List Name="FilterTables" />
            <List Name="PrefetchFileInfos"> ... </List>
        </PrefetchFileInfoObject>
        <!-- ... thousands of these ... -->
    </List>
</PrefetchingFileInfos>

In the PrefetchInfoOverrides, add one new PrefetchInfoOverrideSet at the top, targeting the current head (patch_02), and set its Objects list to a copy of the entire Objects list from PrefetchingFileInfos:

    <List Name="OverrideSets">
        <PrefetchInfoOverrideSet>
            <Value Name="ParentForgeName" Type="String">DataPC_boot_patch_02.forge</Value>
            <List Name="Objects">
                <!-- PASTE the full contents of PrefetchingFileInfos > List Name="Objects" here -->
                <PrefetchFileInfoObject ID="..." Path="...">
                    <List Name="FilterTables" />
                    <List Name="PrefetchFileInfos"> ... </List>
                </PrefetchFileInfoObject>
                <!-- ... all of them ... -->
            </List>
        </PrefetchInfoOverrideSet>
        <!-- the existing patch_01 and boot override sets stay below, unchanged -->

Compile the XML, your new PrefetchInfoOverrides has three sets — the new patch_02 set whose Objects equals the PrefetchingFileInfos objects, plus the inherited patch_01 and boot sets.

Sanity check: the number of <PrefetchFileInfoObject entries in your new override set must equal the number in PrefetchingFileInfos. If they differ, you pasted the wrong list or truncated it.

1. Repack the DataPC_boot_patch_03.forge file with AnvilToolkit.
2. Launch the game.

Expected result: the game boots to the main menu normally. You now have a valid, empty patch forge — a shell that changes nothing but loads cleanly. This is your foundation.

If it crashes before the menu, jump to Common mistakes.

Once you have an empty shell that boots cleanly — whether created by the automatic command or by hand — add your real content. (The automatic command produces the same head patch_02 sets the manual Steps 2 and 3 describe below.)

1. Add your .data resource(s) to the forge (your new/modified objects).
2. Add each new object's prefetch entry to PrefetchingFileInfos (its PrefetchFileInfoObject with the dependency list), the same way any object declares its prefetch dependencies.
3. If your patch removes a file that exists lower in the chain, list it in the patch_02 DeletedFilesManifest set (the one you left empty in Step 2). If you delete nothing, leave it empty.

The golden rule stays the same: whatever is in PrefetchingFileInfos must also be in the head (patch_02) PrefetchInfoOverrides set.

PrefetchingFileInfos describes the prefetch dependency graph for objects the forge is responsible for. PrefetchInfoOverrides re-expresses that graph relative to a parent forge, and the engine reads the head forge's overrides as the authoritative prefetch plan for boot.

When patch_02 was the head, its own PrefetchInfoOverrides (against patch_01 and boot) drove boot prefetch, and the game booted. The moment you add patch_03, it becomes the head — and if its overrides don't re-assert the graph relative to patch_02, the engine's boot prefetch comes up empty. Boot-time subsystems then fail to load in the right order and slightly later a graphics resource handle resolves to null. Both are just symptoms of the same starved prefetch. Copying PrefetchingFileInfos into the new head-relative override set restores the graph.

A single-parent DLC patch (e.g. a ..._dlc_sound_patch_01.forge) has an empty PrefetchInfoOverrides and does fine — which is misleading. That works because a shallow patch overrides nothing and doesn't sit at the head of a deep boot chain. Deep boot-chain patches have the opposite requirement. Don't copy the DLC pattern here.