diff --git a/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/Button.java b/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/Button.java
index 9b7170083..77ad2de69 100644
--- a/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/Button.java
+++ b/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/Button.java
@@ -9,6 +9,7 @@
 import java.nio.ByteBuffer;
 import java.nio.IntBuffer;
 import java.util.List;
+import java.util.function.Supplier;
 import net.neoforged.fml.earlydisplay.render.RenderContext;
 import net.neoforged.fml.earlydisplay.render.SimpleFont;
 import net.neoforged.fml.earlydisplay.render.Texture;
@@ -25,11 +26,15 @@ final class Button {
     private final int width;
     private final int height;
     private final String text;
-    private final boolean active;
+    private final Supplier<Boolean> active;
     private final Runnable onPress;
     private boolean focused;
 
     Button(ErrorDisplayWindow window, int x, int y, int width, int height, String text, boolean active, Runnable onPress) {
+        this(window, x, y, width, height, text, () -> active, onPress);
+    }
+
+    Button(ErrorDisplayWindow window, int x, int y, int width, int height, String text, Supplier<Boolean> active, Runnable onPress) {
         this.window = window;
         this.x = x;
         this.y = y;
@@ -41,13 +46,13 @@ final class Button {
     }
 
     void render(RenderContext ctx, SimpleFont font, double mouseX, double mouseY) {
-        boolean highlighted = active && (focused || isMouseOver(mouseX, mouseY));
-        Texture texture = active ? (highlighted ? window.buttonTextureHover : window.buttonTexture) : window.buttonTextureInactive;
+        boolean highlighted = isActive() && (focused || isMouseOver(mouseX, mouseY));
+        Texture texture = isActive() ? (highlighted ? window.buttonTextureHover : window.buttonTexture) : window.buttonTextureInactive;
         ctx.blitTexture(texture, x, y, width, height);
 
         int w = font.stringWidth(text);
         float tx = x + width / 2F - w / 2F;
-        int textColor = active ? 0xFFFFFFFF : 0xFFA0A0A0;
+        int textColor = isActive() ? 0xFFFFFFFF : 0xFFA0A0A0;
         ctx.renderTextWithShadow(tx, y + 2, font, List.of(new SimpleFont.DisplayText(text, textColor)));
     }
 
@@ -56,7 +61,7 @@ boolean isMouseOver(double mouseX, double mouseY) {
     }
 
     boolean isActive() {
-        return active;
+        return active.get();
     }
 
     boolean isFocused() {
@@ -72,7 +77,7 @@ void unfocus() {
     }
 
     void press() {
-        if (this.active) {
+        if (isActive()) {
             this.onPress.run();
         }
     }
diff --git a/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/ErrorDisplayWindow.java b/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/ErrorDisplayWindow.java
index 76c67511a..7e327706d 100644
--- a/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/ErrorDisplayWindow.java
+++ b/earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/error/ErrorDisplayWindow.java
@@ -5,6 +5,7 @@
 
 package net.neoforged.fml.earlydisplay.error;
 
+import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
@@ -21,6 +22,8 @@
 import net.neoforged.fml.earlydisplay.render.Texture;
 import net.neoforged.fml.earlydisplay.theme.Theme;
 import net.neoforged.fml.i18n.FMLTranslations;
+import net.neoforged.fml.loading.FMLPaths;
+import net.neoforged.fml.loading.cache.CacheUtils;
 import org.jetbrains.annotations.Nullable;
 import org.lwjgl.glfw.GLFW;
 import org.lwjgl.opengl.GL11C;
@@ -28,7 +31,8 @@
 final class ErrorDisplayWindow {
     private static final int DISPLAY_WIDTH = 854;
     private static final int DISPLAY_HEIGHT = 480;
-    private static final int BUTTON_WIDTH = 320;
+    private static final int SMALL_BUTTON_WIDTH = 320;
+    private static final int LARGE_BUTTON_WIDTH = 2 * SMALL_BUTTON_WIDTH + 20;
     private static final int BUTTON_HEIGHT = 40;
     private static final int LIST_BORDER_HEIGHT = 2;
     private static final int SCROLLER_WIDTH = 15;
@@ -36,14 +40,15 @@ final class ErrorDisplayWindow {
     private static final int ENTRY_PADDING = 10;
     private static final int HEADER_Y = 10;
     private static final int HEADER_LINE_HEIGHT = 18;
-    private static final int LEFT_BTN_X = DISPLAY_WIDTH / 2 - 10 - BUTTON_WIDTH;
+    private static final int LEFT_BTN_X = DISPLAY_WIDTH / 2 - 10 - SMALL_BUTTON_WIDTH;
     private static final int RIGHT_BTN_X = DISPLAY_WIDTH / 2 + 10;
-    private static final int TOP_BTN_Y = DISPLAY_HEIGHT - 92;
+    private static final int TOP_BTN_Y = DISPLAY_HEIGHT - 137;
+    private static final int MIDDLE_BTN_Y = DISPLAY_HEIGHT - 92;
     private static final int BOTTOM_BTN_Y = DISPLAY_HEIGHT - 47;
     private static final int LIST_Y_TOP = 70;
-    private static final int LIST_Y_BOTTOM = DISPLAY_HEIGHT - 100;
+    private static final int LIST_Y_BOTTOM = DISPLAY_HEIGHT - 145;
     private static final int LIST_CONTENT_Y_TOP = 74;
-    private static final int LIST_CONTENT_Y_BOTTOM = DISPLAY_HEIGHT - 102;
+    private static final int LIST_CONTENT_Y_BOTTOM = DISPLAY_HEIGHT - 147;
     private static final int LIST_BORDER_TOP_Y2 = LIST_Y_TOP - LIST_BORDER_HEIGHT;
     private static final int LIST_BORDER_TOP_Y1 = LIST_BORDER_TOP_Y2 - LIST_BORDER_HEIGHT;
     private static final int LIST_BORDER_BOTTOM_Y1 = LIST_Y_BOTTOM;
@@ -64,9 +69,9 @@ final class ErrorDisplayWindow {
     final Texture buttonTextureHover;
     final Texture buttonTextureInactive;
     private final List<Button> buttons;
-    private final List<HeaderLine> headerTextLines;
-    private final List<MessageEntry> entries;
-    private final int totalEntryHeight;
+    private List<HeaderLine> headerTextLines;
+    private List<MessageEntry> entries;
+    private int totalEntryHeight;
     private boolean closed = false;
     private int offsetX = 0;
     private int offsetY = 0;
@@ -75,6 +80,11 @@ final class ErrorDisplayWindow {
     private double mouseY = -1;
     private float scrollOffset = 0;
     private boolean draggingScrollbar = false;
+    private boolean purgedCache = false;
+    private List<ModLoadingIssue> issues;
+
+    private final boolean translate;
+    private final BiFunction<String, Object[], String> translator;
 
     ErrorDisplayWindow(
             long windowHandle,
@@ -94,19 +104,26 @@ final class ErrorDisplayWindow {
         this.buttonTexture = Button.loadTexture(true, false);
         this.buttonTextureHover = Button.loadTexture(true, true);
         this.buttonTextureInactive = Button.loadTexture(false, false);
-        boolean translate = mcFont != null;
-        BiFunction<String, Object[], String> translator = translate ? FMLTranslations::parseMessage : FMLTranslations::parseEnglishMessage;
+        this.translate = mcFont != null;
+        this.translator = translate ? FMLTranslations::parseMessage : FMLTranslations::parseEnglishMessage;
         FileOpener opener = FileOpener.get();
         String btnModsText = translator.apply("fml.button.open.mods.folder", new Object[0]);
         String btnReportText = translator.apply("fml.button.open.crashreport", new Object[0]);
         String btnLogText = translator.apply("fml.button.open.log", new Object[0]);
+        String btnPurgeButton = translator.apply("fml.button.purge", new Object[0]);
         String btnQuitText = translator.apply("fml.button.quit", new Object[0]);
         this.buttons = List.of(
-                new Button(this, LEFT_BTN_X, TOP_BTN_Y, BUTTON_WIDTH, BUTTON_HEIGHT, btnModsText, modsFolder != null, () -> opener.open(modsFolder)),
-                new Button(this, LEFT_BTN_X, BOTTOM_BTN_Y, BUTTON_WIDTH, BUTTON_HEIGHT, btnReportText, crashReportFile != null, () -> opener.open(crashReportFile)),
-                new Button(this, RIGHT_BTN_X, TOP_BTN_Y, BUTTON_WIDTH, BUTTON_HEIGHT, btnLogText, logFile != null, () -> opener.open(logFile)),
-                new Button(this, RIGHT_BTN_X, BOTTOM_BTN_Y, BUTTON_WIDTH, BUTTON_HEIGHT, btnQuitText, true, () -> closed = true));
+                new Button(this, LEFT_BTN_X, TOP_BTN_Y, SMALL_BUTTON_WIDTH, BUTTON_HEIGHT, btnModsText, modsFolder != null, () -> opener.open(modsFolder)),
+                new Button(this, LEFT_BTN_X, MIDDLE_BTN_Y, SMALL_BUTTON_WIDTH, BUTTON_HEIGHT, btnReportText, crashReportFile != null, () -> opener.open(crashReportFile)),
+                new Button(this, RIGHT_BTN_X, TOP_BTN_Y, SMALL_BUTTON_WIDTH, BUTTON_HEIGHT, btnLogText, logFile != null, () -> opener.open(logFile)),
+                new Button(this, RIGHT_BTN_X, MIDDLE_BTN_Y, SMALL_BUTTON_WIDTH, BUTTON_HEIGHT, btnPurgeButton, () -> !purgedCache, this::purgeCache),
+                new Button(this, LEFT_BTN_X, BOTTOM_BTN_Y, LARGE_BUTTON_WIDTH, BUTTON_HEIGHT, btnQuitText, true, () -> closed = true));
+
+        updateIssues(issues);
+    }
 
+    private void updateIssues(List<ModLoadingIssue> issues) {
+        this.issues = new ArrayList<>(issues);
         List<ModLoadingIssue> warningEntries = issues.stream()
                 .filter(issue -> issue.severity() != ModLoadingIssue.Severity.ERROR)
                 .toList();
@@ -147,6 +164,16 @@ private static void translateEntries(List<ModLoadingIssue> issues, List<MessageE
         issues.stream().map(translator).map(text -> MessageEntry.of(text, font)).forEach(entries::add);
     }
 
+    private void purgeCache() {
+        this.purgedCache = true;
+        try {
+            CacheUtils.purgeCache();
+        } catch (IOException e) {
+            this.issues.add(ModLoadingIssue.error("fml.modloadingissue.cache.purge.failed").withCause(e).withAffectedPath(FMLPaths.CACHEDIR.get()));
+            updateIssues(this.issues);
+        }
+    }
+
     void render() {
         framebuffer.activate();
 
diff --git a/gradle.properties b/gradle.properties
index fbca1329e..68b79c54b 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,6 +1,6 @@
 gradleutils_version=5.0.1
 
-test_neoforge_version=21.10.20-beta
+test_neoforge_version=21.10.37-beta
 test_minecraft_version=1.21.10
 
 mergetool_version=2.0.0
@@ -19,6 +19,7 @@ jupiter_version=5.13.4
 mockito_version=5.11.0
 assertj_version=3.26.0
 jmh_version=1.37
+installer_tools_version=4.0.16
 
 mojang_logging_version=1.1.1
 log4j_version=2.22.1
diff --git a/loader/build.gradle b/loader/build.gradle
index 7db41e6a4..5171997c3 100644
--- a/loader/build.gradle
+++ b/loader/build.gradle
@@ -30,6 +30,7 @@ dependencies {
     api "net.neoforged:JarJarSelector:${jarjar_version}"
     api "net.neoforged:JarJarMetadata:${jarjar_version}"
     api("net.neoforged:bus:${eventbus_version}")
+    api("net.neoforged.installertools:binarypatch-applier:${installer_tools_version}")
 
     implementation("net.sf.jopt-simple:jopt-simple:${jopt_simple_version}")
     implementation("net.neoforged:accesstransformers:${accesstransformers_version}")
diff --git a/loader/src/main/java/net/neoforged/fml/ModLoadingException.java b/loader/src/main/java/net/neoforged/fml/ModLoadingException.java
index f51990040..f8227e60a 100644
--- a/loader/src/main/java/net/neoforged/fml/ModLoadingException.java
+++ b/loader/src/main/java/net/neoforged/fml/ModLoadingException.java
@@ -17,6 +17,11 @@ public ModLoadingException(ModLoadingIssue issue) {
 
     public ModLoadingException(List<ModLoadingIssue> issues) {
         this.issues = List.copyOf(issues);
+        for (var issue : issues) {
+            if (issue.cause() != null) {
+                addSuppressed(issue.cause());
+            }
+        }
     }
 
     public List<ModLoadingIssue> getIssues() {
diff --git a/loader/src/main/java/net/neoforged/fml/VersionChecker.java b/loader/src/main/java/net/neoforged/fml/VersionChecker.java
index cc3a1cd70..0b45663ff 100644
--- a/loader/src/main/java/net/neoforged/fml/VersionChecker.java
+++ b/loader/src/main/java/net/neoforged/fml/VersionChecker.java
@@ -169,7 +169,7 @@ private void process(IModInfo mod) {
                     Map<String, String> promos = (Map<String, String>) json.get("promos");
                     display_url = (String) json.get("homepage");
 
-                    var mcVersion = FMLLoader.getCurrent().getVersionInfo().mcVersion();
+                    var mcVersion = FMLLoader.getCurrent().getMinecraftVersion();
                     String rec = promos.get(mcVersion + "-recommended");
                     String lat = promos.get(mcVersion + "-latest");
                     ComparableVersion current = new ComparableVersion(mod.getVersion().toString());
diff --git a/loader/src/main/java/net/neoforged/fml/loading/ClassLoaderStack.java b/loader/src/main/java/net/neoforged/fml/loading/ClassLoaderStack.java
new file mode 100644
index 000000000..f5ff7ae8f
--- /dev/null
+++ b/loader/src/main/java/net/neoforged/fml/loading/ClassLoaderStack.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.fml.loading;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import net.neoforged.fml.classloading.JarContentsModule;
+import net.neoforged.fml.classloading.ResourceMaskingClassLoader;
+import net.neoforged.fml.jarcontents.CompositeJarContents;
+import net.neoforged.fml.jarcontents.EmptyJarContents;
+import net.neoforged.fml.jarcontents.FolderJarContents;
+import net.neoforged.fml.jarcontents.JarContents;
+import net.neoforged.fml.jarcontents.JarFileContents;
+import net.neoforged.fml.util.ClasspathResourceUtils;
+import net.neoforged.fml.util.PathPrettyPrinting;
+import net.neoforged.neoforgespi.LocatedPaths;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class ClassLoaderStack implements AutoCloseable {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ClassLoaderStack.class);
+
+    private final List<AutoCloseable> ownedResources = new ArrayList<>();
+    private final LocatedPaths locatedPaths;
+    /**
+     * The context class-loader that will be restored when the loader is closed.
+     */
+    @Nullable
+    private final ClassLoader originalClassLoader;
+    /**
+     * The current tail of the class-loader chain. It is moved whenever a new set of Jars is loaded.
+     */
+    private ClassLoader currentClassLoader;
+
+    public ClassLoaderStack(ClassLoader initialLoader, LocatedPaths locatedPaths) {
+        this.currentClassLoader = initialLoader;
+        this.locatedPaths = locatedPaths;
+        this.originalClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(currentClassLoader);
+    }
+
+    /**
+     * Loads the given services into a URL classloader.
+     */
+    public void appendLoader(String loaderName, List<JarContents> jars) {
+        if (jars.isEmpty()) {
+            LOGGER.info("No additional classpath items for {} were found.", loaderName);
+            return;
+        }
+
+        LOGGER.info("Loading {}:", loaderName);
+
+        List<URL> rootUrls = new ArrayList<>(jars.size());
+        for (var jar : jars) {
+            if (jar instanceof CompositeJarContents compositeJarContents && compositeJarContents.isFiltered()) {
+                throw new IllegalArgumentException("Cannot use simple URLClassLoader for filtered content " + jar);
+            }
+
+            // TODO: Order on the classpath matters, we need to double-check the content roots are in the right order here
+            for (var contentRoot : jar.getContentRoots()) {
+                LOGGER.info(" - {}", PathPrettyPrinting.prettyPrint(contentRoot));
+                try {
+                    rootUrls.add(contentRoot.toUri().toURL());
+                } catch (MalformedURLException e) {
+                    throw new RuntimeException(e); // This should not happen for file URLs
+                }
+                locatedPaths.addLocated(contentRoot); // Prevents it from getting picked up again
+            }
+        }
+
+        var loader = new URLClassLoader(loaderName, rootUrls.toArray(URL[]::new), currentClassLoader);
+        ownedResources.add(loader);
+        currentClassLoader = loader;
+        Thread.currentThread().setContextClassLoader(loader);
+    }
+
+    public ClassLoader getCurrentClassLoader() {
+        return currentClassLoader;
+    }
+
+    public void append(ClassLoader loader) {
+        currentClassLoader = loader;
+    }
+
+    /**
+     * If any location being added is already on the classpath, we add a masking classloader to ensure
+     * that resources are not double-reported when using getResources/getResource.
+     * <p>
+     * The primary purpose of this is in mod and NeoForge development environments, where IDEs put the mod
+     * on the app classpath, but we also add it as content to the game layer. This method is responsible
+     * for setting up a classloader that prevents getResource/getResources from reporting Jar resources
+     * for both the jar on the App classpath and on the transforming classloader.
+     */
+    public void maskContentAlreadyOnClasspath(List<JarContentsModule> content) {
+        var classpathItems = ClasspathResourceUtils.getAllClasspathItems(getCurrentClassLoader());
+
+        // Collect all paths that make up the game content, which are already on the classpath
+        Set<Path> needsMasking = new HashSet<>();
+        for (var secureJar : content) {
+            for (var basePath : getBasePaths(secureJar.contents(), true)) {
+                if (classpathItems.contains(basePath)) {
+                    needsMasking.add(basePath);
+                }
+            }
+        }
+
+        if (!needsMasking.isEmpty()) {
+            if (LOGGER.isDebugEnabled()) {
+                LOGGER.debug("Masking classpath elements: {}", needsMasking.stream().map(PathPrettyPrinting::prettyPrint).toList());
+            }
+
+            var maskedLoader = new ResourceMaskingClassLoader(currentClassLoader, needsMasking);
+            if (Thread.currentThread().getContextClassLoader() == currentClassLoader) {
+                Thread.currentThread().setContextClassLoader(maskedLoader);
+            }
+            currentClassLoader = maskedLoader;
+        }
+    }
+
+    private static List<Path> getBasePaths(JarContents contents, boolean ignoreFilter) {
+        var result = new ArrayList<Path>();
+        switch (contents) {
+            case CompositeJarContents compositeModContainer -> {
+                if (!ignoreFilter && compositeModContainer.isFiltered()) {
+                    throw new IllegalStateException("Cannot load filtered Jar content into a URL classloader");
+                }
+                for (var delegate : compositeModContainer.getDelegates()) {
+                    result.addAll(getBasePaths(delegate, ignoreFilter));
+                }
+            }
+            case EmptyJarContents ignored -> {}
+            case FolderJarContents folderModContainer -> result.add(folderModContainer.getPrimaryPath());
+            case JarFileContents jarModContainer -> result.add(jarModContainer.getPrimaryPath());
+            default -> throw new IllegalStateException("Don't know how to handle " + contents);
+        }
+        return result;
+    }
+
+    @Override
+    public void close() {
+        for (var ownedResource : ownedResources) {
+            try {
+                ownedResource.close();
+            } catch (Exception e) {
+                LOGGER.error("Failed to close resource {} owned by class loader stack", ownedResource, e);
+            }
+        }
+        ownedResources.clear();
+
+        if (Thread.currentThread().getContextClassLoader() == currentClassLoader) {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+        }
+    }
+}
diff --git a/loader/src/main/java/net/neoforged/fml/loading/FMLLoader.java b/loader/src/main/java/net/neoforged/fml/loading/FMLLoader.java
index 85a1bb9df..cac3941e1 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/FMLLoader.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/FMLLoader.java
@@ -7,16 +7,14 @@
 
 import com.mojang.logging.LogUtils;
 import java.io.BufferedInputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.lang.instrument.Instrumentation;
 import java.lang.module.Configuration;
 import java.lang.module.ModuleDescriptor;
 import java.lang.module.ModuleFinder;
-import java.net.MalformedURLException;
 import java.net.URI;
-import java.net.URL;
-import java.net.URLClassLoader;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -35,7 +33,6 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import net.neoforged.accesstransformer.api.AccessTransformerEngine;
 import net.neoforged.api.distmarker.Dist;
 import net.neoforged.fml.FMLVersion;
@@ -46,7 +43,6 @@
 import net.neoforged.fml.ModLoadingIssue;
 import net.neoforged.fml.classloading.JarContentsModule;
 import net.neoforged.fml.classloading.JarContentsModuleFinder;
-import net.neoforged.fml.classloading.ResourceMaskingClassLoader;
 import net.neoforged.fml.classloading.transformation.ClassProcessorAuditLog;
 import net.neoforged.fml.classloading.transformation.ClassProcessorAuditSource;
 import net.neoforged.fml.classloading.transformation.ClassProcessorSet;
@@ -55,17 +51,14 @@
 import net.neoforged.fml.common.asm.SimpleProcessorsGroup;
 import net.neoforged.fml.common.asm.enumextension.RuntimeEnumExtender;
 import net.neoforged.fml.i18n.FMLTranslations;
-import net.neoforged.fml.jarcontents.CompositeJarContents;
-import net.neoforged.fml.jarcontents.EmptyJarContents;
-import net.neoforged.fml.jarcontents.FolderJarContents;
 import net.neoforged.fml.jarcontents.JarContents;
-import net.neoforged.fml.jarcontents.JarFileContents;
 import net.neoforged.fml.jarcontents.JarResource;
+import net.neoforged.fml.loading.game.GameDiscovery;
+import net.neoforged.fml.loading.game.GameDiscoveryResult;
 import net.neoforged.fml.loading.mixin.MixinFacade;
 import net.neoforged.fml.loading.moddiscovery.ModDiscoverer;
 import net.neoforged.fml.loading.moddiscovery.ModFile;
 import net.neoforged.fml.loading.moddiscovery.ModFileInfo;
-import net.neoforged.fml.loading.moddiscovery.locators.GameLocator;
 import net.neoforged.fml.loading.moddiscovery.locators.InDevFolderLocator;
 import net.neoforged.fml.loading.moddiscovery.locators.InDevJarLocator;
 import net.neoforged.fml.loading.moddiscovery.locators.ModsFolderLocator;
@@ -74,10 +67,10 @@
 import net.neoforged.fml.loading.progress.StartupNotificationManager;
 import net.neoforged.fml.startup.InstrumentationHelper;
 import net.neoforged.fml.startup.StartupArgs;
-import net.neoforged.fml.util.ClasspathResourceUtils;
 import net.neoforged.fml.util.PathPrettyPrinting;
 import net.neoforged.fml.util.ServiceLoaderUtil;
 import net.neoforged.neoforgespi.ILaunchContext;
+import net.neoforged.neoforgespi.LocatedPaths;
 import net.neoforged.neoforgespi.language.IModFileInfo;
 import net.neoforged.neoforgespi.language.IModInfo;
 import net.neoforged.neoforgespi.locating.IModFile;
@@ -96,18 +89,10 @@ public final class FMLLoader implements AutoCloseable {
 
     private static final AtomicReference<@Nullable FMLLoader> current = new AtomicReference<>();
 
+    private final ClassLoaderStack classLoaderStack;
+
     /**
-     * The context class-loader that will be restored when the loader is closed.
-     */
-    @Nullable
-    private final ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
-    /**
-     * The current tail of the class-loader chain. It is moved whenever a new set of Jars is loaded.
-     */
-    private ClassLoader currentClassLoader;
-    /**
-     * Resources owned by this loader, such as opened URL classloaders, which
-     * will be closed alongside the loader.
+     * Resources owned by this loader, which will be closed alongside the loader.
      */
     private final List<AutoCloseable> ownedResources = new ArrayList<>();
     /**
@@ -120,15 +105,14 @@ public final class FMLLoader implements AutoCloseable {
     private final Dist dist;
     private LoadingModList loadingModList;
     private final Path gameDir;
-    private final Set<Path> locatedPaths = new HashSet<>();
+    private final LocatedPaths locatedPaths;
 
-    private VersionInfo versionInfo;
     private VersionSupportMatrix versionSupportMatrix;
     public BackgroundScanHandler backgroundScanHandler;
-    private final boolean production;
     @Nullable
     private ModuleLayer gameLayer;
     private final List<ModFile> earlyServicesJars = new ArrayList<>();
+    private final GameDiscoveryResult discoveredGame;
     @VisibleForTesting
     DiscoveryResult discoveryResult;
     private final ClassProcessorAuditLog classTransformerAuditLog = new ClassProcessorAuditLog();
@@ -169,25 +153,20 @@ public boolean hasErrors() {
         }
     }
 
-    private FMLLoader(ClassLoader currentClassLoader, String[] programArgs, Dist dist, boolean production, Path gameDir) {
-        this.currentClassLoader = currentClassLoader;
-        this.programArgs = ProgramArgs.from(programArgs);
+    private FMLLoader(LocatedPaths locatedPaths,
+            ClassLoaderStack classLoaderStack,
+            List<ModFile> earlyServiceJars,
+            GameDiscoveryResult discoveredGame,
+            ProgramArgs programArgs,
+            Dist dist,
+            Path gameDir) {
+        this.locatedPaths = locatedPaths;
+        this.classLoaderStack = classLoaderStack;
+        this.discoveredGame = discoveredGame;
+        this.programArgs = programArgs;
         this.dist = dist;
-        this.production = production;
         this.gameDir = gameDir;
-
-        versionInfo = new VersionInfo(
-                this.programArgs.remove("fml.neoForgeVersion"),
-                this.programArgs.remove("fml.mcVersion"),
-                this.programArgs.remove("fml.neoFormVersion"));
-
-        LOGGER.info(
-                "Starting FancyModLoader version {} ({} in {})",
-                FMLVersion.getVersion(),
-                dist,
-                production ? "PROD" : "DEV");
-
-        LOGGER.info("Game directory: {}", gameDir);
+        this.earlyServicesJars.addAll(earlyServiceJars);
 
         makeCurrent();
     }
@@ -259,9 +238,7 @@ public void close() {
         }
         ownedResources.clear();
 
-        if (Thread.currentThread().getContextClassLoader() == currentClassLoader) {
-            Thread.currentThread().setContextClassLoader(originalClassLoader);
-        }
+        classLoaderStack.close();
     }
 
     private void makeCurrent() {
@@ -272,7 +249,7 @@ private void makeCurrent() {
     }
 
     public ClassLoader getCurrentClassLoader() {
-        return currentClassLoader;
+        return classLoaderStack.getCurrentClassLoader();
     }
 
     public ProgramArgs getProgramArgs() {
@@ -307,45 +284,53 @@ public static FMLLoader create(StartupArgs startupArgs) {
     }
 
     public static FMLLoader create(@Nullable Instrumentation instrumentation, StartupArgs startupArgs) {
-        // If a client class is available, then it's client, otherwise DEDICATED_SERVER
-        // The auto-detection never detects JOINED since it's impossible to do so
         var initialLoader = Objects.requireNonNullElse(startupArgs.parentClassLoader(), ClassLoader.getSystemClassLoader());
+        var dist = Objects.requireNonNullElseGet(startupArgs.dist(), () -> GameDiscovery.detectDist(initialLoader));
+        LOGGER.info("Starting FancyModLoader {} ({}) in {}", FMLVersion.getVersion(), dist, startupArgs.gameDirectory());
 
         PathPrettyPrinting.addRoot(startupArgs.gameDirectory());
+        // We no longer make direct use of libraryDirectory, but only use it to pretty-print the paths for jars located in that dir
+        var librariesDirectory = System.getProperty("libraryDirectory");
+        if (librariesDirectory != null) {
+            PathPrettyPrinting.addSubstitution(Path.of(librariesDirectory), "~libraries/", "");
+        }
 
-        var loader = new FMLLoader(
-                initialLoader,
-                startupArgs.programArgs(),
-                Objects.requireNonNullElseGet(startupArgs.dist(), () -> detectDist(initialLoader)),
-                detectProduction(initialLoader),
-                startupArgs.gameDirectory());
+        var programArgs = ProgramArgs.from(startupArgs.programArgs());
 
-        try {
-            FMLPaths.loadAbsolutePaths(startupArgs.gameDirectory());
-            FMLConfig.load();
+        FMLPaths.loadAbsolutePaths(startupArgs.gameDirectory());
+        FMLConfig.load();
 
-            var launchContext = loader.new LaunchContextAdapter();
-            for (var claimedFile : startupArgs.claimedFiles()) {
-                launchContext.addLocated(claimedFile.toPath());
-            }
+        var locatedPaths = new LocatedPaths() {
+            final Set<Path> paths = new HashSet<>(startupArgs.claimedFiles().stream().map(File::toPath).toList());
 
-            loader.loadEarlyServices(startupArgs);
-
-            ImmediateWindowHandler.load(launchContext, startupArgs.headless(), loader.programArgs);
-            // Report known versions no
-            if (loader.versionInfo.neoForgeVersion() != null) {
-                ImmediateWindowHandler.setNeoForgeVersion(loader.versionInfo.neoForgeVersion());
-            }
-            if (loader.versionInfo.mcVersion() != null) {
-                ImmediateWindowHandler.setMinecraftVersion(loader.versionInfo.mcVersion());
+            @Override
+            public boolean isLocated(Path path) {
+                return paths.contains(path.toAbsolutePath().normalize());
             }
 
-            DiscoveryResult discoveryResult;
-            if (startupArgs.headless()) {
-                discoveryResult = loader.runDiscovery();
-            } else {
-                discoveryResult = runOffThread(loader::runDiscovery);
+            @Override
+            public boolean addLocated(Path path) {
+                return paths.add(path.toAbsolutePath().normalize());
             }
+        };
+
+        var classLoaderStack = new ClassLoaderStack(initialLoader, locatedPaths);
+
+        var earlyServiceJars = loadEarlyServices(classLoaderStack, startupArgs);
+
+        ImmediateWindowHandler.load(locatedPaths, startupArgs.headless(), programArgs);
+
+        var discoveredGame = runLongRunning(startupArgs, () -> GameDiscovery.discoverGame(classLoaderStack.getCurrentClassLoader(), locatedPaths, dist));
+        var neoForgeVersion = discoveredGame.neoforge().getModFileInfo().versionString();
+        var minecraftVersion = discoveredGame.minecraft().getModFileInfo().versionString();
+
+        LOGGER.info("Discovered NeoForge {} and Minecraft {} ({})", neoForgeVersion, minecraftVersion, discoveredGame.production() ? "production" : "development");
+        ImmediateWindowHandler.setNeoForgeVersion(neoForgeVersion);
+        ImmediateWindowHandler.setMinecraftVersion(minecraftVersion);
+
+        var loader = new FMLLoader(locatedPaths, classLoaderStack, earlyServiceJars, discoveredGame, programArgs, dist, startupArgs.gameDirectory());
+        try {
+            var discoveryResult = runLongRunning(startupArgs, loader::runDiscovery);
             for (var issue : discoveryResult.discoveryIssues()) {
                 LOGGER.atLevel(issue.severity() == ModLoadingIssue.Severity.ERROR ? Level.ERROR : Level.WARN)
                         .setCause(issue.cause())
@@ -371,7 +356,7 @@ public static FMLLoader create(@Nullable Instrumentation instrumentation, Startu
             loader.loadPlugins(loader.loadingModList.getPlugins());
 
             // Now go and build the language providers and let mods discover theirs
-            loader.languageProviderLoader = new LanguageProviderLoader(launchContext);
+            loader.languageProviderLoader = new LanguageProviderLoader();
             for (var modFile : discoveryResult.gameContent) {
                 modFile.identifyLanguage();
             }
@@ -384,7 +369,7 @@ public static FMLLoader create(@Nullable Instrumentation instrumentation, Startu
                         modFile.getModuleDescriptor()));
             }
 
-            var classProcessorSet = createClassProcessorSet(startupArgs, launchContext, discoveryResult, mixinFacade);
+            var classProcessorSet = createClassProcessorSet(startupArgs, discoveryResult, mixinFacade);
             if (!classProcessorSet.getGeneratedPackages().isEmpty()) {
                 var descriptor = ModuleDescriptor.newAutomaticModule(ClassProcessor.GENERATED_PACKAGE_MODULE)
                         .packages(classProcessorSet.getGeneratedPackages())
@@ -420,7 +405,6 @@ public static FMLLoader create(@Nullable Instrumentation instrumentation, Startu
     }
 
     private static ClassProcessorSet createClassProcessorSet(StartupArgs startupArgs,
-            LaunchContextAdapter launchContext,
             DiscoveryResult discoveryResult,
             MixinFacade mixinFacade) {
         // Add our own launch plugins explicitly.
@@ -445,8 +429,8 @@ private static ClassProcessorSet createClassProcessorSet(StartupArgs startupArgs
         return ClassProcessorSet.builder()
                 .markMarker(ClassProcessorIds.SIMPLE_PROCESSORS_GROUP)
                 .markMarker(ClassProcessorIds.COMPUTING_FRAMES)
-                .addProcessors(ServiceLoaderUtil.loadServices(launchContext, ClassProcessor.class, builtInProcessors))
-                .addProcessorProviders(ServiceLoaderUtil.loadServices(launchContext, ClassProcessorProvider.class))
+                .addProcessors(ServiceLoaderUtil.loadServices(ClassProcessor.class, builtInProcessors))
+                .addProcessorProviders(ServiceLoaderUtil.loadServices(ClassProcessorProvider.class))
                 .build();
     }
 
@@ -473,7 +457,7 @@ private static ClassProcessor createAccessTransformerService(DiscoveryResult dis
     private TransformingClassLoader buildTransformingLoader(ClassProcessorSet classProcessorSet,
             ClassProcessorAuditLog auditTrail,
             List<JarContentsModule> content) {
-        maskContentAlreadyOnClasspath(content);
+        classLoaderStack.maskContentAlreadyOnClasspath(content);
 
         long start = System.currentTimeMillis();
 
@@ -487,7 +471,7 @@ private TransformingClassLoader buildTransformingLoader(ClassProcessorSet classP
 
         var moduleNames = getModuleNameList(cf, content);
         LOGGER.info("Building game content classloader:\n{}", moduleNames);
-        var loader = new TransformingClassLoader(classProcessorSet, auditTrail, cf, parentLayers, currentClassLoader);
+        var loader = new TransformingClassLoader(classProcessorSet, auditTrail, cf, parentLayers, getCurrentClassLoader());
 
         var layer = ModuleLayer.defineModules(
                 cf,
@@ -497,69 +481,15 @@ private TransformingClassLoader buildTransformingLoader(ClassProcessorSet classP
         var elapsed = System.currentTimeMillis() - start;
         LOGGER.info("Built game content classloader in {}ms", elapsed);
 
-        loader.setFallbackClassLoader(currentClassLoader);
+        loader.setFallbackClassLoader(getCurrentClassLoader());
 
         gameLayer = layer;
         ownedResources.add(loader);
-        currentClassLoader = loader;
+        classLoaderStack.append(loader);
         Thread.currentThread().setContextClassLoader(loader);
         return loader;
     }
 
-    /**
-     * If any location being added is already on the classpath, we add a masking classloader to ensure
-     * that resources are not double-reported when using getResources/getResource.
-     * <p>
-     * The primary purpose of this is in mod and NeoForge development environments, where IDEs put the mod
-     * on the app classpath, but we also add it as content to the game layer. This method is responsible
-     * for setting up a classloader that prevents getResource/getResources from reporting Jar resources
-     * for both the jar on the App classpath and on the transforming classloader.
-     */
-    private void maskContentAlreadyOnClasspath(List<JarContentsModule> content) {
-        var classpathItems = ClasspathResourceUtils.getAllClasspathItems(currentClassLoader);
-
-        // Collect all paths that make up the game content, which are already on the classpath
-        Set<Path> needsMasking = new HashSet<>();
-        for (var secureJar : content) {
-            for (var basePath : getBasePaths(secureJar.contents(), true)) {
-                if (classpathItems.contains(basePath)) {
-                    needsMasking.add(basePath);
-                }
-            }
-        }
-
-        if (!needsMasking.isEmpty()) {
-            if (LOGGER.isDebugEnabled()) {
-                LOGGER.debug("Masking classpath elements: {}", needsMasking.stream().map(PathPrettyPrinting::prettyPrint).toList());
-            }
-
-            var maskedLoader = new ResourceMaskingClassLoader(currentClassLoader, needsMasking);
-            if (Thread.currentThread().getContextClassLoader() == currentClassLoader) {
-                Thread.currentThread().setContextClassLoader(maskedLoader);
-            }
-            currentClassLoader = maskedLoader;
-        }
-    }
-
-    private static List<Path> getBasePaths(JarContents contents, boolean ignoreFilter) {
-        var result = new ArrayList<Path>();
-        switch (contents) {
-            case CompositeJarContents compositeModContainer -> {
-                if (!ignoreFilter && compositeModContainer.isFiltered()) {
-                    throw new IllegalStateException("Cannot load filtered Jar content into a URL classloader");
-                }
-                for (var delegate : compositeModContainer.getDelegates()) {
-                    result.addAll(getBasePaths(delegate, ignoreFilter));
-                }
-            }
-            case EmptyJarContents ignored -> {}
-            case FolderJarContents folderModContainer -> result.add(folderModContainer.getPrimaryPath());
-            case JarFileContents jarModContainer -> result.add(jarModContainer.getPrimaryPath());
-            default -> throw new IllegalStateException("Don't know how to handle " + contents);
-        }
-        return result;
-    }
-
     private static String getModuleNameList(Configuration cf, List<JarContentsModule> content) {
         var jarsById = content.stream().collect(Collectors.toMap(JarContentsModule::moduleName, Function.identity()));
 
@@ -573,63 +503,17 @@ private static String getModuleNameList(Configuration cf, List<JarContentsModule
                 .collect(Collectors.joining("\n"));
     }
 
-    private static Dist detectDist(ClassLoader classLoader) {
-        var clientAvailable = classLoader.getResource("net/minecraft/client/main/Main.class") != null;
-        return clientAvailable ? Dist.CLIENT : Dist.DEDICATED_SERVER;
-    }
-
-    private static boolean detectProduction(ClassLoader classLoader) {
-        // We are not in production when an unobfuscated class is reachable on the classloader
-        // since that means the unobfuscated game is on the classpath. We use DetectedVersion here since
-        // it has existed across many Minecraft versions.
-        return classLoader.getResource("net/minecraft/DetectedVersion.class") == null;
-    }
-
-    private void loadEarlyServices(StartupArgs startupArgs) {
+    private static List<ModFile> loadEarlyServices(ClassLoaderStack classLoaderStack, StartupArgs startupArgs) {
         // Search for early services
-        this.earlyServicesJars.addAll(EarlyServiceDiscovery.findEarlyServiceJars(startupArgs, FMLPaths.MODSDIR.get()));
+        var earlyServicesJars = EarlyServiceDiscovery.findEarlyServiceJars(startupArgs, FMLPaths.MODSDIR.get());
         if (!earlyServicesJars.isEmpty()) {
-            appendLoader("FML Early Services", earlyServicesJars.stream().map(IModFile::getContents).toList());
+            classLoaderStack.appendLoader("FML Early Services", earlyServicesJars.stream().map(IModFile::getContents).toList());
         }
+        return earlyServicesJars;
     }
 
     private void loadPlugins(List<IModFileInfo> plugins) {
-        appendLoader("FML Plugins", plugins.stream().map(mfi -> mfi.getFile().getContents()).toList());
-    }
-
-    /**
-     * Loads the given services into a URL classloader.
-     */
-    private void appendLoader(String loaderName, List<JarContents> jars) {
-        if (jars.isEmpty()) {
-            LOGGER.info("No additional classpath items for {} were found.", loaderName);
-            return;
-        }
-
-        LOGGER.info("Loading {}:", loaderName);
-
-        List<URL> rootUrls = new ArrayList<>(jars.size());
-        for (var jar : jars) {
-            if (jar instanceof CompositeJarContents compositeJarContents && compositeJarContents.isFiltered()) {
-                throw new IllegalArgumentException("Cannot use simple URLClassLoader for filtered content " + jar);
-            }
-
-            // TODO: Order on the classpath matters, we need to double-check the content roots are in the right order here
-            for (var contentRoot : jar.getContentRoots()) {
-                LOGGER.info(" - {}", PathPrettyPrinting.prettyPrint(contentRoot));
-                try {
-                    rootUrls.add(contentRoot.toUri().toURL());
-                } catch (MalformedURLException e) {
-                    throw new RuntimeException(e); // This should not happen for file URLs
-                }
-                locatedPaths.add(contentRoot); // Prevents it from getting picked up again
-            }
-        }
-
-        var loader = new URLClassLoader(loaderName, rootUrls.toArray(URL[]::new), currentClassLoader);
-        ownedResources.add(loader);
-        currentClassLoader = loader;
-        Thread.currentThread().setContextClassLoader(loader);
+        classLoaderStack.appendLoader("FML Plugins", plugins.stream().map(mfi -> mfi.getFile().getContents()).toList());
     }
 
     private DiscoveryResult runDiscovery() {
@@ -637,38 +521,16 @@ private DiscoveryResult runDiscovery() {
 
         var additionalLocators = new ArrayList<IModFileCandidateLocator>();
 
-        additionalLocators.add(new GameLocator());
         additionalLocators.add(new InDevFolderLocator());
         additionalLocators.add(new InDevJarLocator());
         additionalLocators.add(new ModsFolderLocator());
 
-        var modDiscoverer = new ModDiscoverer(new LaunchContextAdapter(), additionalLocators);
+        var modDiscoverer = new ModDiscoverer(new LaunchContextAdapter(), discoveredGame, additionalLocators);
         var discoveryResult = modDiscoverer.discoverMods(earlyServicesJars);
 
-        // Now we should have a mod for "minecraft" and "neoforge" allowing us to fill in the versions
-        var neoForgeVersion = versionInfo.neoForgeVersion();
-        var minecraftVersion = versionInfo.mcVersion();
-        for (var modFile : discoveryResult.modFiles()) {
-            var mods = modFile.getModFileInfo().getMods();
-            if (mods.isEmpty()) {
-                continue;
-            }
-            var mainMod = mods.getFirst();
-            switch (modFile.getId()) {
-                case "minecraft" -> minecraftVersion = mainMod.getVersion().toString();
-                case "neoforge" -> neoForgeVersion = mainMod.getVersion().toString();
-            }
-        }
-        versionInfo = new VersionInfo(
-                neoForgeVersion,
-                minecraftVersion,
-                getVersionInfo().neoFormVersion());
-        versionSupportMatrix = new VersionSupportMatrix(versionInfo);
+        versionSupportMatrix = new VersionSupportMatrix(getMinecraftVersion());
         progress.complete();
 
-        ImmediateWindowHandler.setMinecraftVersion(versionInfo.mcVersion());
-        ImmediateWindowHandler.setNeoForgeVersion(versionInfo.neoForgeVersion());
-
         loadingModList = ModSorter.sort(discoveryResult.modFiles(), discoveryResult.discoveryIssues());
 
         Map<IModInfo, JarResource> enumExtensionsByMod = new HashMap<>();
@@ -697,6 +559,14 @@ private DiscoveryResult runDiscovery() {
                 loadingModList.getModLoadingIssues());
     }
 
+    private static <T> T runLongRunning(StartupArgs startupArgs, Supplier<T> supplier) {
+        if (startupArgs.headless()) {
+            return supplier.get();
+        } else {
+            return runOffThread(supplier);
+        }
+    }
+
     private static <T> T runOffThread(Supplier<T> supplier) {
         var cl = Thread.currentThread().getContextClassLoader();
         var future = CompletableFuture.supplyAsync(() -> {
@@ -761,7 +631,7 @@ public Path getGameDir() {
     }
 
     public boolean isProduction() {
-        return production;
+        return discoveredGame.production();
     }
 
     public ModuleLayer getGameLayer() {
@@ -771,12 +641,12 @@ public ModuleLayer getGameLayer() {
         return gameLayer;
     }
 
-    /**
-     * Please note that the returned version information can be incomplete until mod discovery has been completed.
-     * This is only relevant for early FML services.
-     */
-    public VersionInfo getVersionInfo() {
-        return versionInfo;
+    public String getMinecraftVersion() {
+        return discoveredGame.minecraft().getJarVersion().toString();
+    }
+
+    public String getNeoForgeVersion() {
+        return discoveredGame.neoforge().getJarVersion().toString();
     }
 
     VersionSupportMatrix getVersionSupportMatrix() {
@@ -798,24 +668,23 @@ public Path gameDirectory() {
         }
 
         @Override
-        public <T> Stream<ServiceLoader.Provider<T>> loadServices(Class<T> serviceClass) {
-            // We simply rely on thread context classloader to be correct
-            return ServiceLoader.load(serviceClass).stream();
+        public boolean isLocated(Path path) {
+            return locatedPaths.isLocated(path);
         }
 
         @Override
-        public boolean isLocated(Path path) {
-            return FMLLoader.this.locatedPaths.contains(path);
+        public boolean addLocated(Path path) {
+            return locatedPaths.addLocated(path);
         }
 
         @Override
-        public boolean addLocated(Path path) {
-            return FMLLoader.this.locatedPaths.add(path);
+        public String getMinecraftVersion() {
+            return FMLLoader.this.getMinecraftVersion();
         }
 
         @Override
-        public VersionInfo getVersions() {
-            return versionInfo;
+        public String getNeoForgeVersion() {
+            return FMLLoader.this.getNeoForgeVersion();
         }
     }
 }
diff --git a/loader/src/main/java/net/neoforged/fml/loading/FMLPaths.java b/loader/src/main/java/net/neoforged/fml/loading/FMLPaths.java
index 3e2765bf1..f268855f7 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/FMLPaths.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/FMLPaths.java
@@ -19,7 +19,8 @@
 
 public enum FMLPaths {
     GAMEDIR(),
-    JIJ_CACHEDIR(".cache/jij"),
+    CACHEDIR(".cache"),
+    JIJ_CACHEDIR(true, CACHEDIR, "jij"),
     MODSDIR("mods"),
     CONFIGDIR("config"),
     FMLCONFIG(false, CONFIGDIR, "fml.toml");
diff --git a/loader/src/main/java/net/neoforged/fml/loading/ImmediateWindowHandler.java b/loader/src/main/java/net/neoforged/fml/loading/ImmediateWindowHandler.java
index ae8b430e0..7e190d0b3 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/ImmediateWindowHandler.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/ImmediateWindowHandler.java
@@ -10,7 +10,7 @@
 import java.util.Objects;
 import net.neoforged.fml.ModLoadingIssue;
 import net.neoforged.fml.util.ServiceLoaderUtil;
-import net.neoforged.neoforgespi.ILaunchContext;
+import net.neoforged.neoforgespi.LocatedPaths;
 import net.neoforged.neoforgespi.earlywindow.GraphicsBootstrapper;
 import net.neoforged.neoforgespi.earlywindow.ImmediateWindowProvider;
 import org.apache.logging.log4j.LogManager;
@@ -25,8 +25,8 @@ public class ImmediateWindowHandler {
     @Nullable
     static ImmediateWindowProvider provider;
 
-    public static void load(ILaunchContext context, boolean headless, ProgramArgs arguments) {
-        ServiceLoaderUtil.loadEarlyServices(context, GraphicsBootstrapper.class, List.of())
+    public static void load(LocatedPaths located, boolean headless, ProgramArgs arguments) {
+        ServiceLoaderUtil.loadEarlyServices(located, GraphicsBootstrapper.class, List.of())
                 .forEach(bootstrap -> {
                     LOGGER.info("Running graphics bootstrap plugin {}", bootstrap.name());
                     bootstrap.bootstrap(arguments.getArguments()); // TODO: Should take ProgramArgs so it can *remove* args
@@ -44,7 +44,7 @@ public static void load(ILaunchContext context, boolean headless, ProgramArgs ar
         } else {
             var providername = FMLConfig.getConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_PROVIDER);
             LOGGER.info("Loading ImmediateWindowProvider {}", providername);
-            var maybeProvider = ServiceLoaderUtil.loadEarlyServices(context, ImmediateWindowProvider.class, List.of())
+            var maybeProvider = ServiceLoaderUtil.loadEarlyServices(located, ImmediateWindowProvider.class, List.of())
                     .stream()
                     .filter(p -> Objects.equals(p.name(), providername))
                     .findFirst();
diff --git a/loader/src/main/java/net/neoforged/fml/loading/LanguageProviderLoader.java b/loader/src/main/java/net/neoforged/fml/loading/LanguageProviderLoader.java
index a4d18dc55..0b8f93d9e 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/LanguageProviderLoader.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/LanguageProviderLoader.java
@@ -17,14 +17,15 @@
 import net.neoforged.fml.javafmlmod.FMLJavaModLanguageProvider;
 import net.neoforged.fml.loading.moddiscovery.ModFile;
 import net.neoforged.fml.util.ServiceLoaderUtil;
-import net.neoforged.neoforgespi.ILaunchContext;
 import net.neoforged.neoforgespi.language.IModLanguageLoader;
 import org.apache.maven.artifact.versioning.ArtifactVersion;
 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
 import org.apache.maven.artifact.versioning.VersionRange;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 
+@ApiStatus.Internal
 public class LanguageProviderLoader {
     private static final Logger LOGGER = LogUtils.getLogger();
     private final List<IModLanguageLoader> languageProviders;
@@ -40,8 +41,8 @@ public <T> Stream<T> applyForEach(Function<IModLanguageLoader, T> function) {
 
     private record ModLanguageWrapper(IModLanguageLoader modLanguageProvider, ArtifactVersion version) {}
 
-    LanguageProviderLoader(ILaunchContext launchContext) {
-        languageProviders = ServiceLoaderUtil.loadServices(launchContext, IModLanguageLoader.class);
+    LanguageProviderLoader() {
+        languageProviders = ServiceLoaderUtil.loadServices(IModLanguageLoader.class);
         ImmediateWindowHandler.updateProgress("Loading language providers");
         languageProviders.forEach(lp -> {
             String version = lp.version();
diff --git a/loader/src/main/java/net/neoforged/fml/loading/LibraryFinder.java b/loader/src/main/java/net/neoforged/fml/loading/LibraryFinder.java
deleted file mode 100644
index b0cf6a89d..000000000
--- a/loader/src/main/java/net/neoforged/fml/loading/LibraryFinder.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) Forge Development LLC and contributors
- * SPDX-License-Identifier: LGPL-2.1-only
- */
-
-package net.neoforged.fml.loading;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-public class LibraryFinder {
-    static Path findLibsPath() {
-        var libraryDirectoryProp = System.getProperty("libraryDirectory");
-        if (libraryDirectoryProp == null) {
-            throw new IllegalStateException("Missing libraryDirectory system property");
-        }
-        var libsPath = Path.of(libraryDirectoryProp);
-        if (!Files.isDirectory(libsPath)) {
-            throw new IllegalStateException("libraryDirectory system property refers to a non-directory: " + libsPath);
-        }
-        return libsPath;
-    }
-
-    public static Path findPathForMaven(String group, String artifact, String extension, String classifier, String version) {
-        return findPathForMaven(new MavenCoordinate(group, artifact, extension, classifier, version));
-    }
-
-    public static Path findPathForMaven(MavenCoordinate artifact) {
-        return findLibsPath().resolve(artifact.toRelativeRepositoryPath());
-    }
-}
diff --git a/loader/src/main/java/net/neoforged/fml/loading/VersionInfo.java b/loader/src/main/java/net/neoforged/fml/loading/VersionInfo.java
deleted file mode 100644
index fde6441b1..000000000
--- a/loader/src/main/java/net/neoforged/fml/loading/VersionInfo.java
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright (c) Forge Development LLC and contributors
- * SPDX-License-Identifier: LGPL-2.1-only
- */
-
-package net.neoforged.fml.loading;
-
-public record VersionInfo(String neoForgeVersion, String mcVersion, String neoFormVersion) {
-    public String mcAndNeoFormVersion() {
-        return mcVersion + "-" + neoFormVersion;
-    }
-}
diff --git a/loader/src/main/java/net/neoforged/fml/loading/VersionSupportMatrix.java b/loader/src/main/java/net/neoforged/fml/loading/VersionSupportMatrix.java
index a3577a11a..9015ab865 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/VersionSupportMatrix.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/VersionSupportMatrix.java
@@ -17,8 +17,8 @@
 class VersionSupportMatrix {
     private static final HashMap<String, List<ArtifactVersion>> overrideVersions = new HashMap<>();
 
-    public VersionSupportMatrix(VersionInfo versionInfo) {
-        var mcVersion = new DefaultArtifactVersion(versionInfo.mcVersion());
+    public VersionSupportMatrix(String minecraftVersion) {
+        var mcVersion = new DefaultArtifactVersion(minecraftVersion);
         // If the MC version is 1.21.8 and any default version constraint fails,
         // we'll also pass the version check if the versions below match
         if (MavenVersionAdapter.createFromVersionSpec("[1.21.8]").containsVersion(mcVersion)) {
diff --git a/loader/src/main/java/net/neoforged/fml/loading/cache/CacheUtils.java b/loader/src/main/java/net/neoforged/fml/loading/cache/CacheUtils.java
new file mode 100644
index 000000000..4c42d440d
--- /dev/null
+++ b/loader/src/main/java/net/neoforged/fml/loading/cache/CacheUtils.java
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.fml.loading.cache;
+
+import java.io.IOException;
+import net.neoforged.fml.loading.FMLPaths;
+import org.apache.commons.io.FileUtils;
+
+public class CacheUtils {
+    public static void purgeCache() throws IOException {
+        FileUtils.deleteDirectory(FMLPaths.CACHEDIR.get().toFile());
+    }
+}
diff --git a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/GameLocator.java b/loader/src/main/java/net/neoforged/fml/loading/game/GameDiscovery.java
similarity index 57%
rename from loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/GameLocator.java
rename to loader/src/main/java/net/neoforged/fml/loading/game/GameDiscovery.java
index 7bf8ab53f..a14598d85 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/GameLocator.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/game/GameDiscovery.java
@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: LGPL-2.1-only
  */
 
-package net.neoforged.fml.loading.moddiscovery.locators;
+package net.neoforged.fml.loading.game;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonObject;
@@ -21,72 +21,76 @@
 import net.neoforged.fml.ModLoadingException;
 import net.neoforged.fml.ModLoadingIssue;
 import net.neoforged.fml.jarcontents.JarContents;
-import net.neoforged.fml.loading.LibraryFinder;
-import net.neoforged.fml.loading.MavenCoordinate;
+import net.neoforged.fml.loading.FMLPaths;
+import net.neoforged.fml.loading.moddiscovery.ModFile;
 import net.neoforged.fml.loading.moddiscovery.ModJarMetadata;
+import net.neoforged.fml.loading.moddiscovery.locators.NeoForgeDevDistCleaner;
 import net.neoforged.fml.loading.moddiscovery.readers.JarModsDotTomlModFileReader;
 import net.neoforged.fml.util.ClasspathResourceUtils;
-import net.neoforged.fml.util.PathPrettyPrinting;
-import net.neoforged.neoforgespi.ILaunchContext;
-import net.neoforged.neoforgespi.locating.IDiscoveryPipeline;
+import net.neoforged.neoforgespi.LocatedPaths;
+import net.neoforged.neoforgespi.language.IModInfo;
 import net.neoforged.neoforgespi.locating.IModFile;
-import net.neoforged.neoforgespi.locating.IModFileCandidateLocator;
-import net.neoforged.neoforgespi.locating.IncompatibleFileReporting;
 import net.neoforged.neoforgespi.locating.ModFileDiscoveryAttributes;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class GameLocator implements IModFileCandidateLocator {
-    private static final Logger LOG = LoggerFactory.getLogger(GameLocator.class);
-    public static final String LIBRARIES_DIRECTORY_PROPERTY = "libraryDirectory";
+/**
+ * This class is responsible for finding the minecraft and neoforge "mods".
+ */
+public final class GameDiscovery {
+    private static final Logger LOG = LoggerFactory.getLogger(GameDiscovery.class);
     public static final String[] NEOFORGE_SPECIFIC_PATH_PREFIXES = { "net/neoforged/neoforge/", "META-INF/services/", JarModsDotTomlModFileReader.MODS_TOML };
 
-    @Override
-    public void findCandidates(ILaunchContext context, IDiscoveryPipeline pipeline) {
-        var ourCl = Thread.currentThread().getContextClassLoader();
+    private GameDiscovery() {}
+
+    public static GameDiscoveryResult discoverGame(ClassLoader classLoader, LocatedPaths locatedPaths, Dist requiredDist) {
+        var neoForgeVersion = findNeoForge(classLoader);
 
         // 0) Vanilla Launcher puts the obfuscated jar on the classpath. We mark it as claimed to prevent it from
         // being hoisted into a module, occupying the entrypoint packages.
-        preventLoadingOfObfuscatedClientJar(context, ourCl);
+        preventLoadingOfObfuscatedClientJar(locatedPaths, classLoader);
 
         // We look for a class present in both Minecraft distributions on the classpath, which would be obfuscated in production (DetectedVersion)
         // If that is present, we assume we're launching in dev (NeoDev or ModDev).
-        try (var systemFiles = RequiredSystemFiles.find(context, ourCl)) {
-            if (!systemFiles.isEmpty()) {
+        try (var systemFiles = RequiredSystemFiles.find(locatedPaths::isLocated, classLoader)) {
+            if (!systemFiles.isEmpty() && systemFiles.hasMinecraft()) {
                 // If we've only been able to find some of the required files, we need to error
-                systemFiles.checkForMissingMinecraftFiles(context.getRequiredDistribution() == Dist.CLIENT);
+                systemFiles.checkForMissingMinecraftFiles(requiredDist == Dist.CLIENT);
 
-                handleMergedMinecraftAndNeoForgeJar(context, pipeline, systemFiles);
-                return;
+                return handleMergedMinecraftAndNeoForgeJar(requiredDist, locatedPaths, systemFiles);
             } else {
                 LOG.info("Failed to find common Minecraft classes and resources on the classpath. Assuming we're launching production.");
             }
         }
 
         // In production, it's in the libraries directory, and we're passed the version to look for on the commandline
-        locateProductionMinecraft(context, pipeline);
+        return locateProductionMinecraft(neoForgeVersion, requiredDist, classLoader);
+    }
+
+    private static NeoForgeInfo findNeoForge(ClassLoader ourCl) {
+        var neoForgeVersion = NeoForgeInfo.fromClasspath(ourCl);
+
+        LOG.debug("Found NeoForge {} for Minecraft {}", neoForgeVersion.neoForgeVersion(), neoForgeVersion.minecraftVersion());
+        return neoForgeVersion;
     }
 
-    private static void handleMergedMinecraftAndNeoForgeJar(ILaunchContext context, IDiscoveryPipeline pipeline, RequiredSystemFiles systemFiles) {
+    private static GameDiscoveryResult handleMergedMinecraftAndNeoForgeJar(Dist requiredDist, LocatedPaths locatedPaths, RequiredSystemFiles systemFiles) {
         LOG.info("Detected a joined NeoForge and Minecraft configuration. Applying filtering...");
 
-        var mcJarContents = getCombinedMinecraftJar(context, systemFiles);
-        IModFile minecraftModFile;
+        var mcJarContents = getCombinedMinecraftJar(requiredDist, systemFiles);
+        ModFile minecraftModFile;
         if (mcJarContents.containsFile("META-INF/neoforged.mods.toml")) {
             // In this branch, the jar already has a neoforge.mods.toml
-            minecraftModFile = pipeline.addJarContent(mcJarContents, ModFileDiscoveryAttributes.DEFAULT, IncompatibleFileReporting.IGNORE).orElse(null);
+            minecraftModFile = (ModFile) new JarModsDotTomlModFileReader().read(mcJarContents, ModFileDiscoveryAttributes.DEFAULT);
             if (minecraftModFile == null) {
                 throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_minecraft_jar"));
             }
         } else {
             var minecraftVersion = detectMinecraftVersion(mcJarContents);
             var mcJarMetadata = new ModJarMetadata();
-            minecraftModFile = IModFile.create(mcJarContents, mcJarMetadata, new MinecraftModInfo(minecraftVersion)::buildMinecraftModInfo);
+            minecraftModFile = (ModFile) IModFile.create(mcJarContents, mcJarMetadata, new MinecraftModInfo(minecraftVersion)::buildMinecraftModInfo);
             mcJarMetadata.setModFile(minecraftModFile);
-            if (!pipeline.addModFile(minecraftModFile)) {
-                throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_minecraft_jar"));
-            }
         }
         if (!minecraftModFile.getId().equals("minecraft")) {
             LOG.error("The mod id for the Minecraft jar is not 'minecraft': {}", minecraftModFile.getId());
@@ -117,24 +121,24 @@ private static void handleMergedMinecraftAndNeoForgeJar(ILaunchContext context,
             throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_neoforge_jar").withCause(e));
         }
 
-        var modFile = JarModsDotTomlModFileReader.createModFile(nfJarContents, ModFileDiscoveryAttributes.DEFAULT);
+        var modFile = (ModFile) JarModsDotTomlModFileReader.createModFile(nfJarContents, ModFileDiscoveryAttributes.DEFAULT);
         if (modFile == null) {
             LOG.error("Failed to construct NeoForge mod file from {}", nfJarContents);
             throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_neoforge_jar"));
         }
-        pipeline.addModFile(modFile);
 
-        systemFiles.getAll().stream().map(JarContents::getPrimaryPath).forEach(context::addLocated);
+        systemFiles.getAll().stream().map(JarContents::getPrimaryPath).forEach(locatedPaths::addLocated);
+
+        return new GameDiscoveryResult(modFile, minecraftModFile, false);
     }
 
-    private static JarContents getCombinedMinecraftJar(ILaunchContext context, RequiredSystemFiles systemFiles) {
+    private static JarContents getCombinedMinecraftJar(Dist requiredDist, RequiredSystemFiles systemFiles) {
         if (systemFiles.getCommonResources() == systemFiles.getNeoForgeResources()) {
             throw new IllegalStateException("The Minecraft and NeoForge resources cannot come from the same jar: "
                     + systemFiles.getCommonResources() + " and " + systemFiles.getNeoForgeResources());
         }
 
-        var mcJarRoots = new ArrayList<JarContents.FilteredPath>();
-        mcJarRoots.addAll(getMinecraftResourcesRoots(context, systemFiles));
+        var mcJarRoots = new ArrayList<>(getMinecraftResourcesRoots(requiredDist, systemFiles));
 
         JarContents.PathFilter mcClassesFilter = relativePath -> {
             if (relativePath.endsWith(".class")) {
@@ -186,16 +190,16 @@ private static String detectMinecraftVersion(JarContents mcJarContents) {
         return minecraftVersion;
     }
 
-    private static List<JarContents.FilteredPath> getMinecraftResourcesRoots(ILaunchContext context, RequiredSystemFiles systemFiles) {
+    private static List<JarContents.FilteredPath> getMinecraftResourcesRoots(Dist requiredDist, RequiredSystemFiles systemFiles) {
         JarContents commonResources = systemFiles.getCommonResources();
         JarContents clientResources = systemFiles.getClientResources();
 
         // If the resource roots are separate from classes, no filter needs to be applied.
         List<JarContents.FilteredPath> result = new ArrayList<>();
-        result.add(buildFilteredMinecraftResourcesFilteredPath(commonResources, context.getRequiredDistribution(), systemFiles));
+        result.add(buildFilteredMinecraftResourcesFilteredPath(commonResources, requiredDist, systemFiles));
 
         if (clientResources != null && clientResources != commonResources) {
-            result.add(buildFilteredMinecraftResourcesFilteredPath(clientResources, context.getRequiredDistribution(), systemFiles));
+            result.add(buildFilteredMinecraftResourcesFilteredPath(clientResources, requiredDist, systemFiles));
         }
 
         return result;
@@ -246,94 +250,72 @@ private static void addContentRoot(List<JarContents.FilteredPath> roots, JarCont
     /**
      * In production, the client and neoforge jars are assembled from partial jars in the libraries folder.
      */
-    private static void locateProductionMinecraft(ILaunchContext context, IDiscoveryPipeline pipeline) {
-        // 2) It's neither, but a libraries directory and desired versions are given on the commandline
-        var librariesDirectory = System.getProperty(LIBRARIES_DIRECTORY_PROPERTY);
-        if (librariesDirectory == null) {
-            LOG.error("When launching in production, the system property {} must point to the libraries directory.", LIBRARIES_DIRECTORY_PROPERTY);
-            pipeline.addIssue(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation"));
-            return;
-        }
+    private static GameDiscoveryResult locateProductionMinecraft(NeoForgeInfo neoForgeVersion, Dist requiredDist, ClassLoader classLoader) {
+        var nfModFile = openModFile(neoForgeVersion.sourcePath(), "neoforge", "fml.modloadingissue.corrupted_neoforge_jar");
 
-        var librariesRoot = Path.of(librariesDirectory);
-        if (!Files.isDirectory(librariesRoot)) {
-            LOG.error("Libraries directory is not readable: {}", librariesRoot);
-            pipeline.addIssue(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation"));
-            return;
-        }
-
-        PathPrettyPrinting.addSubstitution(librariesRoot, "~libraries/", "");
+        var patchedMinecraftFilename = switch (requiredDist) {
+            case CLIENT -> "minecraft-client-patched-" + neoForgeVersion.neoForgeVersion() + ".jar";
+            case DEDICATED_SERVER -> "minecraft-server-patched-" + neoForgeVersion.neoForgeVersion() + ".jar";
+        };
+        var patchedMinecraftPath = FMLPaths.CACHEDIR.get().resolve(patchedMinecraftFilename);
 
-        // The versions for Minecraft and NeoForge, etc. must be given on the CLI
-        var versions = context.getVersions();
-        var minecraftVersion = versions.mcVersion();
-        if (minecraftVersion == null) {
-            LOG.error("When launching in production, --fml.mcVersion must be present as a command-line argument");
-            pipeline.addIssue(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation"));
-            return;
-        }
-        var neoForgeVersion = versions.neoForgeVersion();
-        if (neoForgeVersion == null) {
-            LOG.error("When launching in production, --fml.neoForgeVersion must be present as a command-line argument");
-            pipeline.addIssue(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation"));
-            return;
+        if (!Files.exists(patchedMinecraftPath)) {
+            LOG.info("Patched Minecraft does not exist. Creating new patched game jar...");
+            try {
+                MinecraftPatcher.discoverOrInstall(classLoader, requiredDist, neoForgeVersion, patchedMinecraftPath);
+            } catch (Throwable e) {
+                nfModFile.close();
+                throw e;
+            }
         }
-        var neoFormVersion = versions.neoFormVersion();
-        if (neoFormVersion == null) {
-            LOG.error("When launching in production, --fml.neoFormVersion must be present as a command-line argument");
-            pipeline.addIssue(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation"));
-            return;
+
+        ModFile minecraftModFile;
+        try {
+            minecraftModFile = openModFile(patchedMinecraftPath, "minecraft", "fml.modloadingissue.corrupted_minecraft_jar");
+        } catch (Exception e) {
+            // Try deleting it to not leave behind a corrupted Minecraft jar
+            LOG.info("Deleting corrupted Minecraft jar at {}", patchedMinecraftPath);
+            try {
+                Files.delete(patchedMinecraftPath);
+            } catch (IOException ex) {
+                LOG.error("Failed to delete corrupted Minecraft jar at {}", patchedMinecraftPath);
+            }
+            nfModFile.close();
+            throw e;
         }
 
-        // Detect if the newer Minecraft installation method is available. If not, we assume the old method.
-        var patchedMinecraftPath = librariesRoot.resolve((switch (context.getRequiredDistribution()) {
-            case CLIENT -> new MavenCoordinate("net.neoforged", "minecraft-client-patched", "", "", versions.neoForgeVersion());
-            case DEDICATED_SERVER -> new MavenCoordinate("net.neoforged", "minecraft-server-patched", "", "", versions.neoForgeVersion());
-        }).toRelativeRepositoryPath());
+        return new GameDiscoveryResult(nfModFile, minecraftModFile, true);
+    }
 
-        if (Files.isRegularFile(patchedMinecraftPath)) {
-            if (pipeline.addPath(patchedMinecraftPath, ModFileDiscoveryAttributes.DEFAULT, IncompatibleFileReporting.IGNORE).isEmpty()) {
-                throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_minecraft_jar").withAffectedPath(patchedMinecraftPath));
+    private static ModFile openModFile(Path path, String expectedModId, String errorTranslation) {
+        JarContents jarContents;
+        try {
+            jarContents = JarContents.ofPath(path);
+        } catch (IOException e) {
+            throw new ModLoadingException(ModLoadingIssue.error(errorTranslation).withAffectedPath(path).withCause(e));
+        }
+        try {
+            var modFile = JarModsDotTomlModFileReader.createModFile(jarContents, ModFileDiscoveryAttributes.DEFAULT);
+            if (modFile == null || modFile.getType() != IModFile.Type.MOD) {
+                throw new ModLoadingException(ModLoadingIssue.error(errorTranslation).withAffectedPath(path));
             }
-        } else {
-            var content = new ArrayList<Path>();
-            switch (context.getRequiredDistribution()) {
-                case CLIENT -> {
-                    addRequiredLibrary(new MavenCoordinate("net.minecraft", "client", "", "srg", versions.mcAndNeoFormVersion()), content);
-                    addRequiredLibrary(new MavenCoordinate("net.minecraft", "client", "", "extra", versions.mcAndNeoFormVersion()), content);
-                    addRequiredLibrary(new MavenCoordinate("net.neoforged", "neoforge", "", "client", versions.neoForgeVersion()), content);
-                }
-                case DEDICATED_SERVER -> {
-                    addRequiredLibrary(new MavenCoordinate("net.minecraft", "server", "", "srg", versions.mcAndNeoFormVersion()), content);
-                    addRequiredLibrary(new MavenCoordinate("net.minecraft", "server", "", "extra", versions.mcAndNeoFormVersion()), content);
-                    addRequiredLibrary(new MavenCoordinate("net.neoforged", "neoforge", "", "server", versions.neoForgeVersion()), content);
-                }
+            var containedModIds = modFile.getModInfos().stream().map(IModInfo::getModId).toList();
+            if (!containedModIds.equals(List.of(expectedModId))) {
+                LOG.error("The mod file {} does not contain only the expected mod '{}': {}", path, expectedModId, containedModIds);
+                throw new ModLoadingException(ModLoadingIssue.error(errorTranslation).withAffectedPath(path));
             }
-
+            return (ModFile) modFile;
+        } catch (Exception e) {
             try {
-                var mcJarContents = JarContents.ofPaths(content);
-
-                var mcJarMetadata = new ModJarMetadata();
-                var mcjar = IModFile.create(mcJarContents, mcJarMetadata, new MinecraftModInfo(minecraftVersion)::buildMinecraftModInfo);
-                mcJarMetadata.setModFile(mcjar);
-
-                pipeline.addModFile(mcjar);
-            } catch (Exception e) {
-                pipeline.addIssue(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation").withCause(e));
+                jarContents.close();
+            } catch (IOException ex) {
+                e.addSuppressed(ex);
             }
-        }
-
-        var neoforgeCoordinate = new MavenCoordinate("net.neoforged", "neoforge", "", "universal", versions.neoForgeVersion());
-        var neoforgeJar = librariesRoot.resolve(neoforgeCoordinate.toRelativeRepositoryPath());
-        if (!Files.exists(neoforgeJar)) {
-            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.missing_neoforge_jar").withAffectedPath(neoforgeJar));
-        }
-        if (pipeline.addPath(neoforgeJar, ModFileDiscoveryAttributes.DEFAULT, IncompatibleFileReporting.IGNORE).isEmpty()) {
-            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_neoforge_jar").withAffectedPath(neoforgeJar));
+            throw e;
         }
     }
 
-    private void preventLoadingOfObfuscatedClientJar(ILaunchContext context, ClassLoader ourCl) {
+    private static void preventLoadingOfObfuscatedClientJar(LocatedPaths locatedPaths, ClassLoader ourCl) {
         try {
             var resources = ourCl.getResources(RequiredSystemFiles.COMMON_CLASS);
             while (resources.hasMoreElements()) {
@@ -343,10 +325,12 @@ private void preventLoadingOfObfuscatedClientJar(ILaunchContext context, ClassLo
                     if (zip.getEntry(RequiredSystemFiles.COMMON_RESOURCE_ROOT) == null) {
                         continue;
                     }
-                    // If the client class is in it, also make sure it has the client resources and vice-versa
+                    // If the client class is in it, also make sure it has the client resources.
+                    // Vice versa is not true since the dedicated server jar also has assets/.mcassetsroots
+                    // because it has the English language files.
                     boolean hasClientClasses = zip.getEntry(RequiredSystemFiles.CLIENT_CLASS) != null;
                     boolean hasClientResources = zip.getEntry(RequiredSystemFiles.CLIENT_RESOURCE_ROOT) != null;
-                    if (hasClientClasses != hasClientResources) {
+                    if (hasClientClasses && !hasClientResources) {
                         continue;
                     }
 
@@ -356,30 +340,15 @@ private void preventLoadingOfObfuscatedClientJar(ILaunchContext context, ClassLo
                     }
 
                     LOG.info("Marking unmodified client jar as claimed to prevent loading: {}", jarPath);
-                    context.addLocated(jarPath);
+                    locatedPaths.addLocated(jarPath);
                     return;
                 } catch (IOException ignored) {}
             }
         } catch (IOException ignored) {}
     }
 
-    private static void addRequiredLibrary(MavenCoordinate coordinate, List<Path> content) {
-        var path = LibraryFinder.findPathForMaven(coordinate);
-        if (!Files.exists(path)) {
-            LOG.error("Failed to find required file {}", path);
-            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation").withAffectedPath(path));
-        } else {
-            content.add(path);
-        }
-    }
-
-    @Override
-    public int getPriority() {
-        return HIGHEST_SYSTEM_PRIORITY;
-    }
-
-    @Override
-    public String toString() {
-        return "game locator";
+    public static Dist detectDist(ClassLoader classLoader) {
+        var clientAvailable = classLoader.getResource("net/minecraft/client/main/Main.class") != null;
+        return clientAvailable ? Dist.CLIENT : Dist.DEDICATED_SERVER;
     }
 }
diff --git a/loader/src/main/java/net/neoforged/fml/loading/game/GameDiscoveryResult.java b/loader/src/main/java/net/neoforged/fml/loading/game/GameDiscoveryResult.java
new file mode 100644
index 000000000..2d95066dd
--- /dev/null
+++ b/loader/src/main/java/net/neoforged/fml/loading/game/GameDiscoveryResult.java
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.fml.loading.game;
+
+import net.neoforged.fml.loading.moddiscovery.ModFile;
+
+/**
+ * The result of discovering NeoForge and Minecraft.
+ */
+public record GameDiscoveryResult(ModFile neoforge, ModFile minecraft, boolean production) {}
diff --git a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/MinecraftModInfo.java b/loader/src/main/java/net/neoforged/fml/loading/game/MinecraftModInfo.java
similarity index 96%
rename from loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/MinecraftModInfo.java
rename to loader/src/main/java/net/neoforged/fml/loading/game/MinecraftModInfo.java
index 5f9f8b9e0..8e6ea2f47 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/MinecraftModInfo.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/game/MinecraftModInfo.java
@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: LGPL-2.1-only
  */
 
-package net.neoforged.fml.loading.moddiscovery.locators;
+package net.neoforged.fml.loading.game;
 
 import com.electronwill.nightconfig.core.Config;
 import java.util.List;
diff --git a/loader/src/main/java/net/neoforged/fml/loading/game/MinecraftPatcher.java b/loader/src/main/java/net/neoforged/fml/loading/game/MinecraftPatcher.java
new file mode 100644
index 000000000..f63f6623f
--- /dev/null
+++ b/loader/src/main/java/net/neoforged/fml/loading/game/MinecraftPatcher.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.fml.loading.game;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.zip.ZipFile;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.fml.ModLoadingException;
+import net.neoforged.fml.ModLoadingIssue;
+import net.neoforged.fml.loading.progress.StartupNotificationManager;
+import net.neoforged.fml.util.ClasspathResourceUtils;
+import net.neoforged.internal.binarypatchapplier.PatchBase;
+import net.neoforged.internal.binarypatchapplier.Patcher;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Applies the NeoForge patches to the original Minecraft jar.
+ * This is used in production only, because in userdev, the jar is created by the Gradle tooling, while in neodev, the
+ * Minecraft classes are in folders on the classpath.
+ */
+class MinecraftPatcher {
+    private static final Logger LOG = LoggerFactory.getLogger(MinecraftPatcher.class);
+
+    static void discoverOrInstall(ClassLoader classLoader, Dist requiredDist, NeoForgeInfo neoForgeInfo, Path destinationPath) {
+        var progress = StartupNotificationManager.addProgressBar("Patching Minecraft", 3);
+        progress.label("Patching - Looking for original game jar");
+        var minecraftJar = findOriginalMinecraftOnClasspath(classLoader, requiredDist);
+
+        // Create a temporary file for patching in the destination directory
+        Path destinationDir = Objects.requireNonNullElse(destinationPath.getParent(), Path.of("./"));
+        try {
+            Files.createDirectories(destinationDir);
+        } catch (IOException e) {
+            LOG.error("Failed to create patched game jar destination directory {}", destinationDir, e);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.patching_failed").withCause(e));
+        }
+
+        Path tempDestinationPath;
+        try {
+            tempDestinationPath = Files.createTempFile(destinationDir, destinationPath.getFileName().toString(), ".tmp");
+        } catch (IOException e) {
+            LOG.error("Failed to create temporary game jar file in {}", destinationDir, e);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.patching_failed").withCause(e));
+        }
+
+        try {
+            try (var patchesStream = openPatches(neoForgeInfo)) {
+                progress.increment();
+                progress.label("Patching - Applying NeoForge patches to game");
+
+                Patcher.patch(
+                        minecraftJar.toFile(),
+                        requiredDist == Dist.CLIENT ? PatchBase.CLIENT : PatchBase.SERVER,
+                        neoForgeInfo.sourcePath() + "!" + neoForgeInfo.patchBundleLocation(),
+                        patchesStream,
+                        tempDestinationPath.toFile(),
+                        (message) -> LOG.debug("Patching output: {}", message));
+            } catch (Exception e) {
+                LOG.error("Failed to apply patches from '{}' to Minecraft.", neoForgeInfo.sourcePath(), e);
+                throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.patching_failed").withCause(e));
+            }
+
+            progress.increment();
+            progress.label("Patching - Saving patched jar");
+
+            moveAtomically(tempDestinationPath, destinationPath);
+        } finally {
+            try {
+                Files.deleteIfExists(tempDestinationPath);
+            } catch (IOException e) {
+                LOG.error("Failed to delete the temporary game jar file {}", tempDestinationPath, e);
+            }
+        }
+
+        progress.increment();
+        progress.complete();
+    }
+
+    private static ByteArrayInputStream openPatches(NeoForgeInfo neoForgeInfo) {
+        // Since this is only used in Production, we assume that the source path is a file
+        ZipFile zipFile;
+        try {
+            zipFile = new ZipFile(neoForgeInfo.sourcePath().toFile());
+        } catch (IOException e) {
+            LOG.error("Failed to open the NeoForge jar {}", neoForgeInfo.sourcePath(), e);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_neoforge_jar"));
+        }
+        try (zipFile) {
+            var entry = zipFile.getEntry(neoForgeInfo.patchBundleLocation());
+            if (entry == null) {
+                LOG.error("The NeoForge jar at '{}' does not contain the patches at '{}'", neoForgeInfo.sourcePath(), neoForgeInfo.patchBundleLocation());
+                throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_neoforge_jar"));
+            }
+            try (var input = zipFile.getInputStream(entry)) {
+                return new ByteArrayInputStream(input.readAllBytes());
+            }
+        } catch (IOException e) {
+            LOG.error("Fail to read the patches from '{}' within the NeoForge jar at '{}'", neoForgeInfo.patchBundleLocation(), neoForgeInfo.sourcePath());
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_neoforge_jar"));
+        }
+    }
+
+    /**
+     * Searches the classpath for specific Minecraft classes and uses their containing Jar file as
+     * the input for patching.
+     */
+    private static Path findOriginalMinecraftOnClasspath(ClassLoader classLoader, Dist requiredDist) {
+        String entrypoint = switch (requiredDist) {
+            case CLIENT -> "net/minecraft/client/main/Main.class";
+            // TODO: This could false-positive detect a client jar as the server jar
+            case DEDICATED_SERVER -> "net/minecraft/server/Main.class";
+        };
+
+        var jarsWithEntrypoint = new HashSet<Path>();
+        try {
+            var resources = classLoader.getResources(entrypoint);
+            while (resources.hasMoreElements()) {
+                jarsWithEntrypoint.add(ClasspathResourceUtils.findJarPathFor(entrypoint, "minecraft jar", resources.nextElement()));
+            }
+        } catch (IOException e) {
+            LOG.error("Unexpected I/O error during search for Minecraft jar.", e);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation").withCause(e));
+        }
+
+        if (jarsWithEntrypoint.isEmpty()) {
+            LOG.error("Failed to find the original Minecraft jar on the classpath");
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.missing_original_minecraft_jar"));
+        } else if (jarsWithEntrypoint.size() > 1) {
+            LOG.error("Found multiple copies of Minecraft on the classpath: {}", jarsWithEntrypoint);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation"));
+        }
+
+        var gameJar = jarsWithEntrypoint.iterator().next();
+        LOG.info("Found original game jar: '{}'", gameJar);
+        return gameJar;
+    }
+
+    /**
+     * Atomically moves the extracted embedded jar file to its final location.
+     * If an atomic move is not supported, the file will be moved normally.
+     */
+    private static void moveAtomically(Path source, Path destination) {
+        try {
+            try {
+                Files.move(source, destination, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            } catch (AtomicMoveNotSupportedException ex) {
+                Files.move(source, destination, StandardCopyOption.REPLACE_EXISTING);
+            }
+        } catch (IOException e) {
+            LOG.error("Failed to move installation {} to its final location {}", source, destination, e);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.patching_failed").withAffectedPath(source).withCause(e));
+        }
+    }
+}
diff --git a/loader/src/main/java/net/neoforged/fml/loading/game/NeoForgeInfo.java b/loader/src/main/java/net/neoforged/fml/loading/game/NeoForgeInfo.java
new file mode 100644
index 000000000..036d01e15
--- /dev/null
+++ b/loader/src/main/java/net/neoforged/fml/loading/game/NeoForgeInfo.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.fml.loading.game;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
+import java.util.Properties;
+import net.neoforged.fml.ModLoadingException;
+import net.neoforged.fml.ModLoadingIssue;
+import net.neoforged.fml.util.ClasspathResourceUtils;
+import net.neoforged.fml.util.PathPrettyPrinting;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Information about the NeoForge version we're loading.
+ * <p>The content is sourced from a properties file in the NeoForge jar, which is generated during the NF build.
+ */
+record NeoForgeInfo(
+        Path sourcePath,
+        String neoForgeVersion,
+        String neoFormVersion,
+        String minecraftVersion,
+        String buildType,
+        String patchBundleLocation) {
+
+    private static final Logger LOG = LoggerFactory.getLogger(NeoForgeInfo.class);
+
+    private static final String PROPERTIES_LOCATION = "net/neoforged/neoforge/common/version.properties";
+    private static NeoForgeInfo read(Path sourcePath, InputStream input) throws IOException {
+        var p = new Properties();
+        p.load(new BufferedInputStream(input));
+
+        return new NeoForgeInfo(
+                sourcePath,
+                getRequiredProperty(p, "neoforge_version"),
+                getRequiredProperty(p, "neoform_version"),
+                getRequiredProperty(p, "minecraft_version"),
+                getRequiredProperty(p, "build_type"),
+                getRequiredProperty(p, "autoinstall_patches"));
+    }
+
+    private static String getRequiredProperty(Properties p, String name) throws IOException {
+        var value = p.getProperty(name);
+        if (value == null) {
+            throw new IOException("NeoForge version properties are missing required key '" + name + "'");
+        }
+        return value;
+    }
+
+    /**
+     * @throws ModLoadingException if not found or corrupted
+     */
+    public static NeoForgeInfo fromClasspath(ClassLoader classLoader) {
+        var versionInfoUrl = classLoader.getResource(PROPERTIES_LOCATION);
+        if (versionInfoUrl == null) {
+            LOG.error("Could not find {} on the classpath.", PROPERTIES_LOCATION);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.missing_neoforge_jar"));
+        }
+
+        var sourcePath = ClasspathResourceUtils.getRootFromResourceUrl(PROPERTIES_LOCATION, versionInfoUrl);
+        try (var input = versionInfoUrl.openStream()) {
+            return read(sourcePath, input);
+        } catch (IOException e) {
+            LOG.error("Could not load the NeoForge version from the version properties file in {}.", PathPrettyPrinting.prettyPrint(sourcePath), e);
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_neoforge_jar").withAffectedPath(sourcePath).withCause(e));
+        }
+    }
+}
diff --git a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/RequiredSystemFiles.java b/loader/src/main/java/net/neoforged/fml/loading/game/RequiredSystemFiles.java
similarity index 89%
rename from loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/RequiredSystemFiles.java
rename to loader/src/main/java/net/neoforged/fml/loading/game/RequiredSystemFiles.java
index f6ef51d34..a0c72147c 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/locators/RequiredSystemFiles.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/game/RequiredSystemFiles.java
@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: LGPL-2.1-only
  */
 
-package net.neoforged.fml.loading.moddiscovery.locators;
+package net.neoforged.fml.loading.game;
 
 import java.io.BufferedInputStream;
 import java.io.IOException;
@@ -13,6 +13,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Predicate;
 import java.util.jar.Manifest;
 import java.util.stream.Stream;
 import net.neoforged.fml.ModLoadingException;
@@ -20,7 +21,6 @@
 import net.neoforged.fml.jarcontents.JarContents;
 import net.neoforged.fml.loading.moddiscovery.readers.JarModsDotTomlModFileReader;
 import net.neoforged.fml.util.ClasspathResourceUtils;
-import net.neoforged.neoforgespi.ILaunchContext;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -85,21 +85,21 @@ public void checkForMissingMinecraftFiles(boolean clientRequired) {
         if (!missingFiles.isEmpty()) {
             var foundRoots = getAll().stream().distinct().toList();
             LOG.error("Couldn't find {} on classpath, while we did find other required files in: {}", missingFiles, foundRoots);
-            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.missing_minecraft_jar"));
+            throw new ModLoadingException(ModLoadingIssue.error("fml.modloadingissue.corrupted_installation"));
         }
     }
 
-    public static RequiredSystemFiles find(ILaunchContext context, ClassLoader loader) {
+    public static RequiredSystemFiles find(Predicate<Path> ignorePath, ClassLoader loader) {
         var locatedRoots = new ArrayList<JarContents>();
 
         var result = new RequiredSystemFiles();
         try {
-            result.commonClasses = findAndOpen(context, loader, locatedRoots, COMMON_CLASS);
-            result.commonResources = findAndOpen(context, loader, locatedRoots, COMMON_RESOURCE_ROOT);
-            result.clientClasses = findAndOpen(context, loader, locatedRoots, CLIENT_CLASS);
-            result.clientResources = findAndOpen(context, loader, locatedRoots, CLIENT_RESOURCE_ROOT);
-            result.neoForgeCommonClasses = findAndOpen(context, loader, locatedRoots, NEOFORGE_COMMON_CLASS);
-            result.neoForgeClientClasses = findAndOpen(context, loader, locatedRoots, NEOFORGE_CLIENT_CLASS);
+            result.commonClasses = findAndOpen(ignorePath, loader, locatedRoots, COMMON_CLASS);
+            result.commonResources = findAndOpen(ignorePath, loader, locatedRoots, COMMON_RESOURCE_ROOT);
+            result.clientClasses = findAndOpen(ignorePath, loader, locatedRoots, CLIENT_CLASS);
+            result.clientResources = findAndOpen(ignorePath, loader, locatedRoots, CLIENT_RESOURCE_ROOT);
+            result.neoForgeCommonClasses = findAndOpen(ignorePath, loader, locatedRoots, NEOFORGE_COMMON_CLASS);
+            result.neoForgeClientClasses = findAndOpen(ignorePath, loader, locatedRoots, NEOFORGE_CLIENT_CLASS);
             result.neoForgeResources = findNeoForgeResources(locatedRoots, loader);
         } catch (Exception e) {
             closeAll(locatedRoots);
@@ -136,7 +136,7 @@ private static JarContents findNeoForgeResources(List<JarContents> locatedRoots,
     }
 
     @Nullable
-    private static JarContents findAndOpen(ILaunchContext context,
+    private static JarContents findAndOpen(Predicate<Path> ignorePath,
             ClassLoader loader,
             List<JarContents> alreadyOpened,
             String relativePath) {
@@ -152,7 +152,7 @@ private static JarContents findAndOpen(ILaunchContext context,
         for (var path : roots) {
             // The obfuscated client jar is on the classpath in production, and we mark it as located earlier.
             // This check prevents us trying to load our files from it.
-            if (!context.isLocated(path)) {
+            if (!ignorePath.test(path)) {
                 var jar = openOrThrow(path);
                 alreadyOpened.add(jar);
                 return jar;
@@ -270,4 +270,8 @@ private static List<JarContents> uniqueAndNonNull(JarContents... contents) {
         }
         return result;
     }
+
+    public boolean hasMinecraft() {
+        return !getMinecraftJarComponents().isEmpty();
+    }
 }
diff --git a/loader/src/main/java/net/neoforged/fml/loading/game/package-info.java b/loader/src/main/java/net/neoforged/fml/loading/game/package-info.java
new file mode 100644
index 000000000..e57073dab
--- /dev/null
+++ b/loader/src/main/java/net/neoforged/fml/loading/game/package-info.java
@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+@ApiStatus.Internal
+package net.neoforged.fml.loading.game;
+
+import org.jetbrains.annotations.ApiStatus;
diff --git a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/ModDiscoverer.java b/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/ModDiscoverer.java
index d82d09db8..32cb35977 100644
--- a/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/ModDiscoverer.java
+++ b/loader/src/main/java/net/neoforged/fml/loading/moddiscovery/ModDiscoverer.java
@@ -26,6 +26,7 @@
 import net.neoforged.fml.loading.ImmediateWindowHandler;
 import net.neoforged.fml.loading.LogMarkers;
 import net.neoforged.fml.loading.UniqueModListBuilder;
+import net.neoforged.fml.loading.game.GameDiscoveryResult;
 import net.neoforged.fml.util.ServiceLoaderUtil;
 import net.neoforged.neoforgespi.ILaunchContext;
 import net.neoforged.neoforgespi.locating.IDependencyLocator;
@@ -35,23 +36,24 @@
 import net.neoforged.neoforgespi.locating.IModFileReader;
 import net.neoforged.neoforgespi.locating.IncompatibleFileReporting;
 import net.neoforged.neoforgespi.locating.ModFileDiscoveryAttributes;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 
+@ApiStatus.Internal
 public class ModDiscoverer {
     private static final Logger LOGGER = LogUtils.getLogger();
     private final List<IModFileCandidateLocator> modFileLocators;
     private final List<IDependencyLocator> dependencyLocators;
     private final List<IModFileReader> modFileReaders;
     private final ILaunchContext launchContext;
-
-    public ModDiscoverer(ILaunchContext launchContext) {
-        this(launchContext, List.of());
-    }
+    private final GameDiscoveryResult gameDiscoveryResult;
 
     public ModDiscoverer(ILaunchContext launchContext,
+            GameDiscoveryResult gameDiscoveryResult,
             Collection<IModFileCandidateLocator> additionalModFileLocators) {
         this.launchContext = launchContext;
+        this.gameDiscoveryResult = gameDiscoveryResult;
 
         modFileLocators = ServiceLoaderUtil.loadEarlyServices(launchContext, IModFileCandidateLocator.class, additionalModFileLocators);
         modFileReaders = ServiceLoaderUtil.loadEarlyServices(launchContext, IModFileReader.class, List.of());
@@ -65,6 +67,12 @@ public record Result(
     public Result discoverMods(List<ModFile> additionalDependencySources) {
         LOGGER.debug(LogMarkers.SCAN, "Scanning for mods and other resources to load. We know {} ways to find mods", modFileLocators.size());
         List<ModFile> loadedFiles = new ArrayList<>();
+        loadedFiles.add(gameDiscoveryResult.minecraft());
+        loadedFiles.add(gameDiscoveryResult.neoforge());
+
+        launchContext.addLocated(gameDiscoveryResult.minecraft().getFilePath());
+        launchContext.addLocated(gameDiscoveryResult.neoforge().getFilePath());
+
         List<ModLoadingIssue> discoveryIssues = new ArrayList<>();
         boolean successfullyLoadedMods = true;
         ImmediateWindowHandler.updateProgress("Discovering mod files");
diff --git a/loader/src/main/java/net/neoforged/fml/util/ServiceLoaderUtil.java b/loader/src/main/java/net/neoforged/fml/util/ServiceLoaderUtil.java
index 14fae2005..79df72ca9 100644
--- a/loader/src/main/java/net/neoforged/fml/util/ServiceLoaderUtil.java
+++ b/loader/src/main/java/net/neoforged/fml/util/ServiceLoaderUtil.java
@@ -14,10 +14,11 @@
 import java.util.Locale;
 import java.util.Objects;
 import java.util.ServiceConfigurationError;
+import java.util.ServiceLoader;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 import net.neoforged.fml.loading.LogMarkers;
-import net.neoforged.neoforgespi.ILaunchContext;
+import net.neoforged.neoforgespi.LocatedPaths;
 import net.neoforged.neoforgespi.locating.IOrderedProvider;
 import org.jetbrains.annotations.ApiStatus;
 import org.slf4j.Logger;
@@ -29,30 +30,26 @@ public final class ServiceLoaderUtil {
 
     private ServiceLoaderUtil() {}
 
-    public static <T> List<T> loadServices(ILaunchContext context, Class<T> serviceClass) {
-        return loadServices(context, serviceClass, List.of());
+    public static <T> List<T> loadServices(Class<T> serviceClass) {
+        return loadServices(serviceClass, List.of());
     }
 
-    public static <T> List<T> loadServices(ILaunchContext context, Class<T> serviceClass, Predicate<Class<? extends T>> filter) {
-        return loadServices(context, serviceClass, List.of(), filter);
-    }
-
-    public static <T> List<T> loadServices(ILaunchContext context, Class<T> serviceClass, Collection<T> additionalServices) {
-        return loadServices(context, serviceClass, additionalServices, ignored -> true);
+    public static <T> List<T> loadServices(Class<T> serviceClass, Collection<T> additionalServices) {
+        return loadServices(serviceClass, additionalServices, ignored -> true);
     }
 
     /**
      * Same as {@link #loadServices}, but it also marks any jar file that provided such services as located to prevent it
      * from being located again as a mod-file or library later.
      */
-    public static <T> List<T> loadEarlyServices(ILaunchContext context, Class<T> serviceClass, Collection<T> additionalServices) {
-        var services = loadServices(context, serviceClass, additionalServices, ignored -> true);
+    public static <T> List<T> loadEarlyServices(LocatedPaths located, Class<T> serviceClass, Collection<T> additionalServices) {
+        var services = loadServices(serviceClass, additionalServices, ignored -> true);
 
         for (var service : services) {
             var codeSource = service.getClass().getProtectionDomain().getCodeSource();
             if (codeSource != null && codeSource.getLocation() != null) {
                 try {
-                    context.addLocated(Path.of(codeSource.getLocation().toURI()));
+                    located.addLocated(Path.of(codeSource.getLocation().toURI()));
                 } catch (IllegalArgumentException | FileSystemNotFoundException | URISyntaxException ignored) {}
             }
         }
@@ -63,11 +60,10 @@ public static <T> List<T> loadEarlyServices(ILaunchContext context, Class<T> ser
     /**
      * @param serviceClass If the service class implements {@link IOrderedProvider}, the services will automatically be sorted.
      */
-    public static <T> List<T> loadServices(ILaunchContext context,
-            Class<T> serviceClass,
+    public static <T> List<T> loadServices(Class<T> serviceClass,
             Collection<T> additionalServices,
             Predicate<Class<? extends T>> filter) {
-        var serviceLoaderServices = context.loadServices(serviceClass)
+        var serviceLoaderServices = ServiceLoader.load(serviceClass).stream()
                 .filter(p -> {
                     if (!filter.test(p.type())) {
                         LOGGER.debug("Filtering out service provider {} for service class {}", p.type(), serviceClass);
diff --git a/loader/src/main/java/net/neoforged/neoforgespi/ILaunchContext.java b/loader/src/main/java/net/neoforged/neoforgespi/ILaunchContext.java
index 32910a862..850e0c954 100644
--- a/loader/src/main/java/net/neoforged/neoforgespi/ILaunchContext.java
+++ b/loader/src/main/java/net/neoforged/neoforgespi/ILaunchContext.java
@@ -6,19 +6,14 @@
 package net.neoforged.neoforgespi;
 
 import java.nio.file.Path;
-import java.util.ServiceLoader;
-import java.util.stream.Stream;
 import net.neoforged.api.distmarker.Dist;
-import net.neoforged.fml.loading.VersionInfo;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.jetbrains.annotations.ApiStatus;
 
 /**
  * Provides context for various FML plugins about the current launch operation.
  */
-public interface ILaunchContext {
-    Logger LOGGER = LoggerFactory.getLogger(ILaunchContext.class);
-
+@ApiStatus.NonExtendable
+public interface ILaunchContext extends LocatedPaths {
     Dist getRequiredDistribution();
 
     /**
@@ -26,17 +21,7 @@ public interface ILaunchContext {
      */
     Path gameDirectory();
 
-    <T> Stream<ServiceLoader.Provider<T>> loadServices(Class<T> serviceClass);
-
-    /**
-     * Checks if a given path was already found by a previous locator, or may be already loaded.
-     */
-    boolean isLocated(Path path);
-
-    /**
-     * Marks a path as being located and returns true if it was not previously located.
-     */
-    boolean addLocated(Path path);
+    String getMinecraftVersion();
 
-    VersionInfo getVersions();
+    String getNeoForgeVersion();
 }
diff --git a/loader/src/main/java/net/neoforged/neoforgespi/LocatedPaths.java b/loader/src/main/java/net/neoforged/neoforgespi/LocatedPaths.java
new file mode 100644
index 000000000..b6d9582ef
--- /dev/null
+++ b/loader/src/main/java/net/neoforged/neoforgespi/LocatedPaths.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.neoforgespi;
+
+import java.nio.file.Path;
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.NonExtendable
+public interface LocatedPaths {
+    /**
+     * Checks if a given path was already found by a previous locator, or may be already loaded.
+     */
+    boolean isLocated(Path path);
+
+    /**
+     * Marks a path as being located and returns true if it was not previously located.
+     */
+    boolean addLocated(Path path);
+}
diff --git a/loader/src/main/resources/lang/en_us.json b/loader/src/main/resources/lang/en_us.json
index 7c075c342..453622ff3 100644
--- a/loader/src/main/resources/lang/en_us.json
+++ b/loader/src/main/resources/lang/en_us.json
@@ -27,10 +27,11 @@
   "fml.modloadingissue.dependencyloading.mismatchedcontaineddependencies": "Some mods have agreed upon an acceptable version range for : §6{0}§r, but no jar was provided which matched the range. Requested by: §e{1}§r.",
   "fml.modloadingissue.coremod_error": "An error occurred while loading core-mod {0} from {1}",
   "fml.modloadingissue.corrupted_installation": "Your NeoForge installation is corrupted. Please try to reinstall NeoForge.",
-  "fml.modloadingissue.missing_minecraft_jar": "The patched Minecraft jar is missing. Please try to reinstall NeoForge.",
+  "fml.modloadingissue.missing_original_minecraft_jar": "The original Minecraft jar is missing. Please try to reinstall NeoForge.",
   "fml.modloadingissue.corrupted_minecraft_jar": "The patched Minecraft jar is corrupted. Please try to reinstall NeoForge.",
   "fml.modloadingissue.missing_neoforge_jar": "The NeoForge jar is missing. Please try to reinstall NeoForge.",
-  "fml.modloadingissue.corrupted_neoforge_jar": "The NeoForge jar is corrupted. Please try to reinstall NeoForge.",
+  "fml.modloadingissue.corrupted_neoforge_jar": "The NeoForge jar is corrupted or missing. Please try to reinstall NeoForge.",
+  "fml.modloadingissue.patching_failed": "Applying NeoForge patches to the game has failed. Please retry, check the logfile for details or try to reinstall NeoForge.",
   "fml.modloadingissue.cycle": "Detected a mod dependency cycle: {0}",
   "fml.modloading.failedtoprocesswork": "{0,modinfo,name} ({0,modinfo,id}) encountered an error processing deferred work\n§7{2,exc,msg}",
   "fml.modloadingissue.brokenfile": "File {101} is not a valid mod file",
@@ -89,5 +90,7 @@
   "fml.button.open.log": "Open Log File",
   "fml.button.open.crashreport": "Open Crash Report",
   "fml.button.open.mods.folder": "Open Mods Folder",
-  "fml.button.quit": "Quit Game"
+  "fml.button.quit": "Quit Game",
+  "fml.button.purge": "Purge Game Cache",
+  "fml.modloadingissue.cache.purge.failed": "Failed to purge the game cache."
 }
diff --git a/loader/src/test/java/net/neoforged/fml/jarcontents/EmptyJarContentsTest.java b/loader/src/test/java/net/neoforged/fml/jarcontents/EmptyJarContentsTest.java
index 78ef82eff..c6da13413 100644
--- a/loader/src/test/java/net/neoforged/fml/jarcontents/EmptyJarContentsTest.java
+++ b/loader/src/test/java/net/neoforged/fml/jarcontents/EmptyJarContentsTest.java
@@ -98,6 +98,6 @@ void testVisitContent() {
     @Test
     void testToString() {
         // Should show its identifying primary path and that it's empty in toString
-        assertEquals("empty(" + testPath + ")", emptyJar.toString());
+        assertEquals("empty(" + testPath.toString().replace('\\', '/') + ")", emptyJar.toString());
     }
 }
diff --git a/loader/src/test/java/net/neoforged/fml/jarcontents/FolderJarContentsTest.java b/loader/src/test/java/net/neoforged/fml/jarcontents/FolderJarContentsTest.java
index b4588c475..90fc980e0 100644
--- a/loader/src/test/java/net/neoforged/fml/jarcontents/FolderJarContentsTest.java
+++ b/loader/src/test/java/net/neoforged/fml/jarcontents/FolderJarContentsTest.java
@@ -22,6 +22,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.jar.Manifest;
+import net.neoforged.fml.util.PathPrettyPrinting;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -201,7 +202,7 @@ void testGetManifestReturnsEmptyManifestIfManifestIsMissing() {
 
     @Test
     void testToString() {
-        assertEquals("folder(" + tempDir + ")", contents.toString());
+        assertEquals("folder(" + PathPrettyPrinting.prettyPrint(tempDir) + ")", contents.toString());
     }
 
     @Nested
diff --git a/loader/src/test/java/net/neoforged/fml/jarcontents/JarFileContentsTest.java b/loader/src/test/java/net/neoforged/fml/jarcontents/JarFileContentsTest.java
index 141c0f4a6..016ac3b5a 100644
--- a/loader/src/test/java/net/neoforged/fml/jarcontents/JarFileContentsTest.java
+++ b/loader/src/test/java/net/neoforged/fml/jarcontents/JarFileContentsTest.java
@@ -30,6 +30,7 @@
 import java.util.function.Consumer;
 import java.util.jar.Manifest;
 import java.util.zip.ZipOutputStream;
+import net.neoforged.fml.util.PathPrettyPrinting;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.AutoClose;
 import org.junit.jupiter.api.BeforeEach;
@@ -254,7 +255,7 @@ void testGetManifestReturnsEmptyManifestIfManifestIsMissing() throws IOException
     @Test
     void testToString() throws IOException {
         JarContents jarContents = getJarContents();
-        assertEquals("jar(" + jarFilePath + ")", jarContents.toString());
+        assertEquals("jar(" + PathPrettyPrinting.prettyPrint(jarFilePath) + ")", jarContents.toString());
     }
 
     /**
diff --git a/loader/src/test/java/net/neoforged/fml/loading/FMLLoaderTest.java b/loader/src/test/java/net/neoforged/fml/loading/FMLLoaderTest.java
index 255a935c7..75d348507 100644
--- a/loader/src/test/java/net/neoforged/fml/loading/FMLLoaderTest.java
+++ b/loader/src/test/java/net/neoforged/fml/loading/FMLLoaderTest.java
@@ -31,8 +31,8 @@
 import net.neoforged.jarjar.metadata.ContainedJarIdentifier;
 import net.neoforged.jarjar.metadata.ContainedJarMetadata;
 import net.neoforged.jarjar.metadata.ContainedVersion;
-import net.neoforged.neoforgespi.earlywindow.GraphicsBootstrapper;
 import net.neoforged.neoforgespi.locating.IModFile;
+import net.neoforged.neoforgespi.locating.IModFileCandidateLocator;
 import net.neoforged.neoforgespi.locating.IModFileReader;
 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
 import org.apache.maven.artifact.versioning.VersionRange;
@@ -65,19 +65,6 @@ void testProductionClientDiscovery() throws Exception {
             assertNeoForgeJar(result);
         }
 
-        @Test
-        void testProductionClientDiscoveryLegacyApproach() throws Exception {
-            installation.setupProductionClientLegacy();
-
-            var result = launchAndLoad("neoforgeclient");
-            assertThat(result.loadedMods()).containsOnlyKeys("minecraft", "neoforge");
-            assertThat(result.gameLayerModules()).containsOnlyKeys("minecraft", "neoforge");
-            assertThat(result.pluginLayerModules()).isEmpty();
-
-            assertLegacyMinecraftClientJar(result, true);
-            assertNeoForgeJar(result);
-        }
-
         @Test
         void testProductionServerDiscovery() throws Exception {
             installation.setupProductionServer();
@@ -92,20 +79,6 @@ void testProductionServerDiscovery() throws Exception {
             assertNeoForgeJar(result);
         }
 
-        @Test
-        void testProductionServerDiscoveryLegacyApproach() throws Exception {
-            installation.setupProductionServerLegacy();
-
-            var result = launchAndLoad("neoforgeserver");
-            assertThat(result.issues()).isEmpty();
-            assertThat(result.loadedMods()).containsOnlyKeys("minecraft", "neoforge");
-            assertThat(result.gameLayerModules()).containsOnlyKeys("minecraft", "neoforge");
-            assertThat(result.pluginLayerModules()).isEmpty();
-
-            assertLegacyMinecraftServerJar(result);
-            assertNeoForgeJar(result);
-        }
-
         @Test
         void testNeoForgeDevServerDiscovery() throws Exception {
             var result = launchAndLoadInNeoForgeDevEnvironment("neoforgeserverdev");
@@ -132,8 +105,8 @@ void testNeoForgeDevClientDataDiscovery() throws Exception {
 
         @Test
         void testNeoForgeDevJarClientDiscovery() throws Exception {
-            var additionalClasspath = installation.setupSplitNeoForgeDevProjectForClientLaunch();
-            var result = launchAndLoadWithAdditionalClasspath("neoforgeclientdatadev", additionalClasspath);
+            installation.setup(SimulatedInstallation.Type.NEOFORGEDEV_CLIENT_GRADLE);
+            var result = launchAndLoad("neoforgeclientdatadev");
 
             assertThat(result.issues()).isEmpty();
             assertThat(result.loadedMods()).containsOnlyKeys("minecraft", "neoforge");
@@ -644,25 +617,25 @@ void testIncompatibleLoaderVersions(String requestedLoader, String requestedVers
         void testMissingMinecraftJarInClientInstallation() throws Exception {
             installation.setupProductionClient();
 
-            var clientPath = installation.getLibrariesDir().resolve("net/neoforged/minecraft-client-patched/20.4.9999/minecraft-client-patched-20.4.9999.jar");
+            var clientPath = installation.getVersionsDir().resolve("1.20.4/1.20.4.jar");
             Files.delete(clientPath);
 
-            var e = assertThrows(ModLoadingException.class, () -> launchAndLoad("neoforgeclient"));
+            var e = assertThrows(ModLoadingException.class, () -> launchInstalledDist());
             assertThat(getTranslatedIssues(e.getIssues())).containsOnly(
-                    "ERROR: Your NeoForge installation is corrupted. Please try to reinstall NeoForge.");
+                    "ERROR: The original Minecraft jar is missing. Please try to reinstall NeoForge.");
         }
 
         @Test
         void testCorruptedMinecraftJarInClientInstallation() throws Exception {
             installation.setupProductionClient();
 
-            var clientPath = installation.getLibrariesDir().resolve("net/neoforged/minecraft-client-patched/20.4.9999/minecraft-client-patched-20.4.9999.jar");
+            var clientPath = installation.getVersionsDir().resolve("1.20.4/1.20.4.jar");
             // Replace the jar with an empty zip (no neoforge.mods.toml)
             new ZipOutputStream(Files.newOutputStream(clientPath)).close();
 
             var e = assertThrows(ModLoadingException.class, () -> launchAndLoad("neoforgeclient"));
             assertThat(getTranslatedIssues(e.getIssues())).containsOnly(
-                    "ERROR: The patched Minecraft jar is corrupted. Please try to reinstall NeoForge.");
+                    "ERROR: The original Minecraft jar is missing. Please try to reinstall NeoForge.");
         }
 
         @Test
@@ -682,37 +655,37 @@ void testCorruptedNeoForgeJarInClientInstallation() throws Exception {
             installation.setupProductionClient();
 
             var clientPath = installation.getLibrariesDir().resolve("net/neoforged/neoforge/20.4.9999/neoforge-20.4.9999-universal.jar");
-            // Replace the jar with an empty zip (no neoforge.mods.toml)
+            // Replace the jar with an empty zip (no version.properties)
             new ZipOutputStream(Files.newOutputStream(clientPath)).close();
 
-            var e = assertThrows(ModLoadingException.class, () -> launchAndLoad("neoforgeclient"));
+            var e = assertThrows(ModLoadingException.class, () -> launchInstalledDist());
             assertThat(getTranslatedIssues(e.getIssues())).containsOnly(
-                    "ERROR: The NeoForge jar is corrupted. Please try to reinstall NeoForge.");
+                    "ERROR: The NeoForge jar is missing. Please try to reinstall NeoForge.");
         }
 
         @Test
         void testMissingMinecraftJarInServerInstallation() throws Exception {
             installation.setupProductionServer();
 
-            var serverPath = installation.getLibrariesDir().resolve("net/neoforged/minecraft-server-patched/20.4.9999/minecraft-server-patched-20.4.9999.jar");
+            var serverPath = installation.getLibrariesDir().resolve("net/minecraft/server/1.20.4/server-1.20.4.jar");
             Files.delete(serverPath);
 
             var e = assertThrows(ModLoadingException.class, () -> launchAndLoad("neoforgeserver"));
             assertThat(getTranslatedIssues(e.getIssues())).containsOnly(
-                    "ERROR: Your NeoForge installation is corrupted. Please try to reinstall NeoForge.");
+                    "ERROR: The original Minecraft jar is missing. Please try to reinstall NeoForge.");
         }
 
         @Test
         void testCorruptedMinecraftJarInServerInstallation() throws Exception {
             installation.setupProductionServer();
 
-            var serverPath = installation.getLibrariesDir().resolve("net/neoforged/minecraft-server-patched/20.4.9999/minecraft-server-patched-20.4.9999.jar");
-            // Replace the jar with an empty zip (no neoforge.mods.toml)
+            var serverPath = installation.getLibrariesDir().resolve("net/minecraft/server/1.20.4/server-1.20.4.jar");
+            // Replace the jar with an empty zip
             new ZipOutputStream(Files.newOutputStream(serverPath)).close();
 
             var e = assertThrows(ModLoadingException.class, () -> launchAndLoad("neoforgeserver"));
             assertThat(getTranslatedIssues(e.getIssues())).containsOnly(
-                    "ERROR: The patched Minecraft jar is corrupted. Please try to reinstall NeoForge.");
+                    "ERROR: The original Minecraft jar is missing. Please try to reinstall NeoForge.");
         }
 
         @Test
@@ -732,12 +705,12 @@ void testCorruptedNeoForgeJarInServerInstallation() throws Exception {
             installation.setupProductionServer();
 
             var neoforgePath = installation.getComponentRoots().neoforgeCommonClassesRoot();
-            // Replace the jar with an empty zip (no neoforge.mods.toml)
+            // Replace the jar with an empty zip (no version.properties)
             new ZipOutputStream(Files.newOutputStream(neoforgePath)).close();
 
             var e = assertThrows(ModLoadingException.class, () -> launchAndLoad("neoforgeserver"));
             assertThat(getTranslatedIssues(e.getIssues())).containsOnly(
-                    "ERROR: The NeoForge jar is corrupted. Please try to reinstall NeoForge.");
+                    "ERROR: The NeoForge jar is missing. Please try to reinstall NeoForge.");
         }
 
         /**
@@ -984,15 +957,13 @@ public class NotLoadedYet {
                                 public static boolean dummy;
                             }
                         """)
-                .addClass("test.Bootstrapper", """
-                        public class Bootstrapper implements net.neoforged.neoforgespi.earlywindow.GraphicsBootstrapper {
-                            @Override
-                            public String name() {
-                                return "dummy";
-                            }
-
+                .addClass("test.CandidateLocator", """
+                        import net.neoforged.neoforgespi.locating.IModFileCandidateLocator;
+                        import net.neoforged.neoforgespi.locating.IDiscoveryPipeline;
+                        import net.neoforged.neoforgespi.ILaunchContext;
+                        public class CandidateLocator implements IModFileCandidateLocator {
                             @Override
-                            public void bootstrap(String[] arguments) {
+                            public void findCandidates(ILaunchContext context, IDiscoveryPipeline pipeline) {
                                 net.neoforged.fml.loading.FMLLoader.getCurrent().addCloseCallback(() -> {
                                     NotLoadedYet.dummy = true; // This will fail if the CL is already closed
                                     net.neoforged.fml.loading.FMLLoaderTest.closeCallbackCalled = true;
@@ -1000,7 +971,7 @@ public void bootstrap(String[] arguments) {
                             }
                         }
                         """)
-                .addService(GraphicsBootstrapper.class, "test.Bootstrapper"));
+                .addService(IModFileCandidateLocator.class, "test.CandidateLocator"));
 
         launchClient();
 
diff --git a/loader/src/test/java/net/neoforged/fml/loading/LauncherTest.java b/loader/src/test/java/net/neoforged/fml/loading/LauncherTest.java
index 8262a7b78..6defe0fd7 100644
--- a/loader/src/test/java/net/neoforged/fml/loading/LauncherTest.java
+++ b/loader/src/test/java/net/neoforged/fml/loading/LauncherTest.java
@@ -119,7 +119,7 @@ final void cleanupLoaderAndInstallation() throws Exception {
      */
     LaunchResult launchInstalledDist() throws Exception {
         var supportedDist = switch (installation.getType()) {
-            case PRODUCTION_CLIENT, USERDEV_FOLDERS, USERDEV_JAR, USERDEV_LEGACY_FOLDERS, USERDEV_LEGACY_JAR -> Dist.CLIENT;
+            case PRODUCTION_CLIENT, USERDEV_FOLDERS, USERDEV_JAR, USERDEV_LEGACY_FOLDERS, USERDEV_LEGACY_JAR, NEOFORGEDEV_CLIENT_IDE, NEOFORGEDEV_CLIENT_GRADLE -> Dist.CLIENT;
             case PRODUCTION_SERVER -> Dist.DEDICATED_SERVER;
         };
         return launchAndLoad(supportedDist, true, List.of());
@@ -130,9 +130,9 @@ LaunchResult launchClient() throws Exception {
     }
 
     protected LaunchResult launchAndLoadInNeoForgeDevEnvironment(String launchTarget) throws Exception {
-        var additionalClasspath = installation.setupNeoForgeDevProject();
+        installation.setup(SimulatedInstallation.Type.NEOFORGEDEV_CLIENT_IDE);
 
-        return launchAndLoadWithAdditionalClasspath(launchTarget, additionalClasspath);
+        return launchAndLoad(launchTarget);
     }
 
     protected LaunchResult launchAndLoadWithAdditionalClasspath(String launchTarget) throws Exception {
@@ -236,7 +236,7 @@ private LaunchResult launch(Dist launchDist, boolean cleanDist, List<Path> addit
                         // TODO: We can pass less in certain scenarios and should (i.e. development)
                         "--fml.mcVersion", SimulatedInstallation.MC_VERSION,
                         "--fml.neoForgeVersion", SimulatedInstallation.NEOFORGE_VERSION,
-                        "--fml.neoFormVersion", SimulatedInstallation.NEOFORM_VERSION
+                        "--fml.neoFormVersion", SimulatedInstallation.NEOFORM_VERSION,
                 },
                 locatedPaths.stream().map(Path::toFile).collect(Collectors.toSet()),
                 additionalClassPath.stream().map(Path::toFile).toList(),
@@ -370,18 +370,6 @@ public void assertMinecraftServerJar(LaunchResult launchResult) throws IOExcepti
         assertModContent(launchResult, "minecraft", expectedContent);
     }
 
-    /**
-     * Asserts a Minecraft Jar in the legacy installation mode where the Minecraft jar is assembled in-memory from different individual pieces.
-     * The only noticeable difference is that the Minecraft jar does not have a neoforge.mods.toml.
-     */
-    public void assertLegacyMinecraftServerJar(LaunchResult launchResult) throws IOException {
-        var expectedContent = new ArrayList<IdentifiableContent>();
-        Collections.addAll(expectedContent, SimulatedInstallation.SERVER_EXTRA_JAR_CONTENT);
-        expectedContent.add(SimulatedInstallation.PATCHED_SHARED);
-
-        assertModContent(launchResult, "minecraft", expectedContent);
-    }
-
     /**
      * Asserts a Minecraft Jar in the legacy installation mode where the Minecraft jar is assembled in-memory from different individual pieces.
      * The only noticeable difference is that the Minecraft jar does not have a neoforge.mods.toml.
@@ -418,12 +406,13 @@ public void assertMinecraftClientJar(LaunchResult launchResult, boolean producti
     }
 
     public void assertNeoForgeJar(LaunchResult launchResult) throws IOException {
-        var expectedContent = List.of(
-                SimulatedInstallation.NEOFORGE_ASSETS,
-                SimulatedInstallation.NEOFORGE_CLASSES,
-                SimulatedInstallation.NEOFORGE_CLIENT_CLASSES,
-                SimulatedInstallation.NEOFORGE_MODS_TOML,
-                SimulatedInstallation.NEOFORGE_MANIFEST);
+        var expectedContent = new ArrayList<IdentifiableContent>();
+        Collections.addAll(expectedContent, SimulatedInstallation.NEOFORGE_UNIVERSAL_JAR_CONTENT);
+
+        // In NeoForge's own dev environment, the patches can't exist yet.
+        if (installation.getType().isNeoForgeDev()) {
+            expectedContent.remove(SimulatedInstallation.NEOFORGE_PATCHES);
+        }
 
         assertModContent(launchResult, "neoforge", expectedContent);
     }
diff --git a/testlib/build.gradle b/testlib/build.gradle
index 619d17022..310181c24 100644
--- a/testlib/build.gradle
+++ b/testlib/build.gradle
@@ -19,4 +19,5 @@ dependencies {
     implementation "net.neoforged:JarJarMetadata:${jarjar_version}"
     implementation "org.assertj:assertj-core:${assertj_version}"
     implementation "org.junit.jupiter:junit-jupiter-api:$jupiter_version"
+    implementation("net.neoforged.installertools:binarypatcher:${installer_tools_version}")
 }
diff --git a/testlib/src/main/java/net/neoforged/fml/testlib/SimulatedInstallation.java b/testlib/src/main/java/net/neoforged/fml/testlib/SimulatedInstallation.java
index fa65163c3..c0924921b 100644
--- a/testlib/src/main/java/net/neoforged/fml/testlib/SimulatedInstallation.java
+++ b/testlib/src/main/java/net/neoforged/fml/testlib/SimulatedInstallation.java
@@ -34,6 +34,9 @@
 import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
+import net.neoforged.binarypatcher.DiffOptions;
+import net.neoforged.binarypatcher.Generator;
+import net.neoforged.binarypatcher.PatchBase;
 import net.neoforged.jarjar.metadata.ContainedJarMetadata;
 import net.neoforged.jarjar.metadata.Metadata;
 import net.neoforged.jarjar.metadata.MetadataIOHandler;
@@ -59,7 +62,7 @@ public enum Type {
          * - A jar with all Minecraft Classes, NeoForge Classes and Resources
          * - A second jar with the original non-class content of the Minecraft jar
          * The Minecraft classes and resources are merged from server+client distributions.
-         *
+         * <p>
          * The difference between FOLDERS and JAR relates to how the "installation appropriate" mod project
          * is put onto the classpath (as folders, or built as a jar file).
          */
@@ -70,17 +73,24 @@ public enum Type {
          * It puts two jars on the classpath:
          * - The merged, patched Minecraft jar, including classes and resources from both distributions
          * - The unmodified NeoForge universal jar
-         *
+         * <p>
          * The difference between FOLDERS and JAR relates to how the "installation appropriate" mod project
          * is put onto the classpath (as folders, or built as a jar file).
          */
         USERDEV_FOLDERS,
         USERDEV_JAR,
+
+        NEOFORGEDEV_CLIENT_IDE,
+        NEOFORGEDEV_CLIENT_GRADLE,
         ;
 
         public boolean isProduction() {
             return this == PRODUCTION_CLIENT || this == PRODUCTION_SERVER;
         }
+
+        public boolean isNeoForgeDev() {
+            return this == NEOFORGEDEV_CLIENT_IDE || this == NEOFORGEDEV_CLIENT_GRADLE;
+        }
     }
 
     static {
@@ -92,6 +102,12 @@ public boolean isProduction() {
         }
     }
 
+    public static final String LIBRARIES_DIRECTORY_PROPERTY = "libraryDirectory";
+    public static final String MOD_FOLDERS_PROPERTIES = "fml.modFolders";
+    public static final String NEOFORGE_VERSION = "20.4.9999";
+    public static final String MC_VERSION = "1.20.4";
+    public static final String NEOFORM_VERSION = "202401020304";
+
     /**
      * A class that is contained in both client and dedicated server distribution, renamed to official mappings.
      */
@@ -101,41 +117,69 @@ public boolean isProduction() {
      * and containing NeoForge patches.
      */
     public static final IdentifiableContent PATCHED_SHARED = generateClass("PATCHED_SHARED", "net/minecraft/DetectedVersion.class");
-    /**
-     * A class that is only in the client distribution, renamed to official mappings.
-     */
-    public static final IdentifiableContent RENAMED_CLIENT = generateClass("RENAMED_CLIENT", "net/minecraft/client/Minecraft.class");
     /**
      * A neoforge.mods.toml for the Minecraft jar.
      */
     public static final IdentifiableContent MINECRAFT_MODS_TOML = new IdentifiableContent("MINECRAFT_MODS_TOML", "META-INF/neoforge.mods.toml", writeMinecraftModsToml());
 
+    public static final IdentifiableContent MINECRAFT_VERSION_JSON = new IdentifiableContent("MC_VERSION_JSON", "version.json", buildVersionJson(MC_VERSION));
+
     /**
      * A class that is contained in both client and dedicated server distribution, renamed to official mappings,
      * and containing NeoForge patches.
      */
     public static final IdentifiableContent PATCHED_CLIENT = generateClass("PATCHED_CLIENT", "net/minecraft/client/Minecraft.class");
     public static final IdentifiableContent UNPATCHED_CLIENT = generateClass("UNPATCHED_CLIENT", "net/minecraft/client/Minecraft.class");
+
+    private static final byte[] ORIGINAL_CLIENT_JAR = createJarFile(
+            generateClass("CLIENT_MAIN", "net/minecraft/client/main/Main.class"),
+            generateClass("CLIENT_DATA_MAIN", "net/minecraft/client/data/Main.class"),
+            generateClass("SERVER_MAIN", "net/minecraft/server/Main.class"),
+            generateClass("SERVER_DATA_MAIN", "net/minecraft/data/Main.class"),
+            generateClass("GAMETEST_MAIN", "net/minecraft/gametest/Main.class"),
+            generateClass("MINECRAFT_SERVER", "net/minecraft/server/MinecraftServer.class"),
+            UNPATCHED_CLIENT,
+            RENAMED_SHARED,
+            MINECRAFT_VERSION_JSON,
+            SHARED_ASSETS,
+            CLIENT_ASSETS);
+    private static final byte[] ORIGINAL_SERVER_JAR = createJarFile(
+            generateClass("SERVER_MAIN", "net/minecraft/server/Main.class"),
+            generateClass("SERVER_DATA_MAIN", "net/minecraft/data/Main.class"),
+            generateClass("GAMETEST_MAIN", "net/minecraft/gametest/Main.class"),
+            generateClass("MINECRAFT_SERVER", "net/minecraft/server/MinecraftServer.class"),
+            UNPATCHED_CLIENT,
+            RENAMED_SHARED,
+            MINECRAFT_VERSION_JSON,
+            SHARED_ASSETS,
+            CLIENT_ASSETS);
+
+    /**
+     * This simulates creating a Minecraft client modified by NeoForge,
+     * i.e. with added neoforge.mods.toml and modified classes.
+     * Note that this file is inaccessible to the running game and only exists during the Gradle build of NeoForge itself!
+     */
+    private static final byte[] PATCHED_CLIENT_JAR = createJarFile(PATCHED_CLIENT, RENAMED_SHARED, CLIENT_ASSETS, SHARED_ASSETS, MINECRAFT_MODS_TOML, MINECRAFT_VERSION_JSON);
+    /**
+     * Same as {@link #PATCHED_CLIENT_JAR}, but for the dedicated server.
+     */
+    private static final byte[] PATCHED_SERVER_JAR = createJarFile(RENAMED_SHARED, SHARED_ASSETS, MINECRAFT_MODS_TOML, MINECRAFT_VERSION_JSON);
+
     public static final IdentifiableContent NEOFORGE_CLIENT_CLASSES = generateClass("NEOFORGE_CLIENT_CLASSES", "net/neoforged/neoforge/client/ClientNeoForgeMod.class");
     public static final IdentifiableContent NEOFORGE_CLASSES = generateClass("NEOFORGE_CLASSES", "net/neoforged/neoforge/common/NeoForgeMod.class");
     public static final IdentifiableContent NEOFORGE_MODS_TOML = new IdentifiableContent("NEOFORGE_MODS_TOML", "META-INF/neoforge.mods.toml", writeNeoForgeModsToml());
     public static final IdentifiableContent NEOFORGE_MANIFEST = new IdentifiableContent("NEOFORGE_MANIFEST", JarFile.MANIFEST_NAME, writeNeoForgeManifest());
+    public static final IdentifiableContent NEOFORGE_VERSION_PROPERTIES = new IdentifiableContent("NEOFORGE_VERSION_PROPERTIES", "net/neoforged/neoforge/common/version.properties", writeNeoForgeVersionProperties());
     public static final IdentifiableContent NEOFORGE_ASSETS = new IdentifiableContent("NEOFORGE_ASSETS", "neoforged_logo.png");
-
-    public static final String LIBRARIES_DIRECTORY_PROPERTY = "libraryDirectory";
-    public static final String MOD_FOLDERS_PROPERTIES = "fml.modFolders";
-    public static final String NEOFORGE_VERSION = "20.4.9999";
-    public static final String MC_VERSION = "1.20.4";
-    public static final String NEOFORM_VERSION = "202401020304";
-    public static final IdentifiableContent MINECRAFT_VERSION_JSON = new IdentifiableContent("MC_VERSION_JSON", "version.json", buildVersionJson(MC_VERSION));
+    public static final IdentifiableContent NEOFORGE_PATCHES = new IdentifiableContent("NEOFORGE_PATCHES", "META-INF/net/neoforged/patches/patches.lzma", createPatches(
+            ORIGINAL_CLIENT_JAR, ORIGINAL_SERVER_JAR,
+            PATCHED_CLIENT_JAR, PATCHED_SERVER_JAR));
 
     public static final IdentifiableContent[] SERVER_EXTRA_JAR_CONTENT = { SHARED_ASSETS, MINECRAFT_VERSION_JSON };
     public static final IdentifiableContent[] CLIENT_EXTRA_JAR_CONTENT = { CLIENT_ASSETS, SHARED_ASSETS, RESOURCES_MANIFEST, MINECRAFT_VERSION_JSON };
-    public static final IdentifiableContent[] NEOFORGE_UNIVERSAL_JAR_CONTENT = { NEOFORGE_ASSETS, NEOFORGE_CLIENT_CLASSES, NEOFORGE_CLASSES, NEOFORGE_MODS_TOML, NEOFORGE_MANIFEST };
+    public static final IdentifiableContent[] NEOFORGE_UNIVERSAL_JAR_CONTENT = { NEOFORGE_ASSETS, NEOFORGE_CLIENT_CLASSES, NEOFORGE_CLASSES, NEOFORGE_MODS_TOML, NEOFORGE_MANIFEST, NEOFORGE_VERSION_PROPERTIES, NEOFORGE_PATCHES };
     public static final IdentifiableContent[] USERDEV_CLIENT_JAR_CONTENT = { PATCHED_CLIENT, PATCHED_SHARED };
 
-    private static final String GAV_PATCHED_CLIENT = "net.neoforged:minecraft-client-patched:" + NEOFORGE_VERSION;
-    private static final String GAV_PATCHED_SERVER = "net.neoforged:minecraft-server-patched:" + NEOFORGE_VERSION;
     private static final String GAV_NEOFORGE_UNIVERSAL = "net.neoforged:neoforge:" + NEOFORGE_VERSION + ":universal";
 
     private static byte[] buildVersionJson(String mcVersion) {
@@ -177,36 +221,29 @@ public void setup(Type type) throws IOException {
             case PRODUCTION_CLIENT -> {
                 System.setProperty(LIBRARIES_DIRECTORY_PROPERTY, librariesDir.toString());
 
-                var patchedClientJar = writeLibrary(GAV_PATCHED_CLIENT, PATCHED_CLIENT, RENAMED_SHARED, CLIENT_ASSETS, SHARED_ASSETS, MINECRAFT_MODS_TOML, MINECRAFT_VERSION_JSON);
+                var originalClientJar = versionsDir.resolve(MC_VERSION + "/" + MC_VERSION + ".jar");
+                Files.createDirectories(originalClientJar.getParent());
+                Files.write(originalClientJar, ORIGINAL_CLIENT_JAR);
+
                 var universalJar = writeLibrary(GAV_NEOFORGE_UNIVERSAL, NEOFORGE_UNIVERSAL_JAR_CONTENT);
+                launchClasspath.add(universalJar);
+                launchClasspath.add(originalClientJar);
 
-                // For the production client, the Vanilla launcher puts the original, obfuscated client jar on the classpath
-                // Since this can influence our detection logic, let's make sure it's included for the tests.
-                Path obfuscatedClientJar = versionsDir.resolve(MC_VERSION).resolve(MC_VERSION + ".jar");
-                writeJarFile(
-                        obfuscatedClientJar,
-                        generateClass("CLIENT_MAIN", "net/minecraft/client/main/Main.class"),
-                        generateClass("CLIENT_DATA_MAIN", "net/minecraft/client/data/Main.class"),
-                        generateClass("SERVER_MAIN", "net/minecraft/server/Main.class"),
-                        generateClass("SERVER_DATA_MAIN", "net/minecraft/data/Main.class"),
-                        generateClass("GAMETEST_MAIN", "net/minecraft/gametest/Main.class"),
-                        generateClass("MINECRAFT_SERVER", "net/minecraft/server/MinecraftServer.class"),
-                        UNPATCHED_CLIENT,
-                        RENAMED_SHARED,
-                        MINECRAFT_VERSION_JSON,
-                        SHARED_ASSETS,
-                        CLIENT_ASSETS);
-                launchClasspath.add(obfuscatedClientJar);
-
-                componentRoots = InstallationComponents.productionJars(patchedClientJar, universalJar);
+                componentRoots = InstallationComponents.productionJars(originalClientJar, universalJar);
             }
             case PRODUCTION_SERVER -> {
                 System.setProperty(LIBRARIES_DIRECTORY_PROPERTY, librariesDir.toString());
 
-                var patchedServerJar = writeLibrary(GAV_PATCHED_SERVER, PATCHED_SHARED, SHARED_ASSETS, MINECRAFT_MODS_TOML, MINECRAFT_VERSION_JSON);
+                // TODO: There's currently no convention for this, this is just where the server-starter jar stores it
+                var originalServerJar = librariesDir.resolve("net/minecraft/server/" + MC_VERSION + "/server-" + MC_VERSION + ".jar");
+                Files.createDirectories(originalServerJar.getParent());
+                Files.write(originalServerJar, ORIGINAL_SERVER_JAR);
+
                 var universalJar = writeLibrary(GAV_NEOFORGE_UNIVERSAL, NEOFORGE_UNIVERSAL_JAR_CONTENT);
+                launchClasspath.add(universalJar);
+                launchClasspath.add(originalServerJar);
 
-                componentRoots = InstallationComponents.productionJars(patchedServerJar, universalJar);
+                componentRoots = InstallationComponents.productionJars(originalServerJar, universalJar);
             }
             case USERDEV_LEGACY_FOLDERS, USERDEV_LEGACY_JAR -> {
                 var neoforgeJar = projectRoot.resolve("neoforge-joined.jar");
@@ -237,6 +274,28 @@ public void setup(Type type) throws IOException {
 
                 componentRoots = InstallationComponents.productionJars(minecraftJar, universalJar);
             }
+            case NEOFORGEDEV_CLIENT_IDE, NEOFORGEDEV_CLIENT_GRADLE -> {
+                // The classes directory in a NeoForge development environment will contain both the Minecraft
+                // and the NeoForge classes. This is due to both calling each other and having to be compiled in
+                // the same javac compilation as a result.
+                var folders = createNeoForgeDevFolders();
+
+                // Emulate the layout of a NeoForge development environment
+                // In dev, the NeoForge sources itself are joined, but the Minecraft sources are not
+                launchClasspath.add(folders.clientClassesDir);
+                // When launching the CLIENT through Gradle, the COMMON output will be included as a jar instead of folder references
+                if (type == Type.NEOFORGEDEV_CLIENT_GRADLE) {
+                    Path commonJarFile = projectRoot.resolve("build/libs/neoforge-common.jar");
+                    createJarFileFromFolders(commonJarFile, folders.commonClassesDir, folders.commonResourcesDir);
+                    launchClasspath.add(commonJarFile);
+                } else {
+                    launchClasspath.add(folders.commonClassesDir);
+                    launchClasspath.add(folders.commonResourcesDir);
+                }
+                launchClasspath.add(folders.clientExtraJar);
+
+                launchModFolders.put("minecraft", List.of(folders.clientClassesDir, folders.commonClassesDir, folders.commonResourcesDir, folders.clientExtraJar));
+            }
             default -> throw new UnsupportedOperationException();
         }
         this.type = type;
@@ -289,61 +348,10 @@ public void setupProductionClient() throws IOException {
         setup(Type.PRODUCTION_CLIENT);
     }
 
-    public void setupProductionClientLegacy() throws IOException {
-        System.setProperty(LIBRARIES_DIRECTORY_PROPERTY, librariesDir.toString());
-
-        writeLibrary("net.minecraft", "client", MC_VERSION + "-" + NEOFORM_VERSION, "srg", RENAMED_CLIENT, RENAMED_SHARED);
-        writeLibrary("net.minecraft", "client", MC_VERSION + "-" + NEOFORM_VERSION, "extra", CLIENT_ASSETS, SHARED_ASSETS, MINECRAFT_VERSION_JSON);
-        writeLibrary("net.neoforged", "neoforge", NEOFORGE_VERSION, "client", PATCHED_CLIENT);
-        writeLibrary("net.neoforged", "neoforge", NEOFORGE_VERSION, "universal", NEOFORGE_UNIVERSAL_JAR_CONTENT);
-    }
-
     public void setupProductionServer() throws IOException {
         setup(Type.PRODUCTION_SERVER);
     }
 
-    public void setupProductionServerLegacy() throws IOException {
-        System.setProperty(LIBRARIES_DIRECTORY_PROPERTY, librariesDir.toString());
-
-        writeLibrary("net.minecraft", "server", MC_VERSION + "-" + NEOFORM_VERSION, "srg", RENAMED_SHARED);
-        writeLibrary("net.minecraft", "server", MC_VERSION + "-" + NEOFORM_VERSION, "extra", SERVER_EXTRA_JAR_CONTENT);
-        writeLibrary("net.neoforged", "neoforge", NEOFORGE_VERSION, "server", PATCHED_SHARED);
-        writeLibrary("net.neoforged", "neoforge", NEOFORGE_VERSION, "universal", NEOFORGE_UNIVERSAL_JAR_CONTENT);
-    }
-
-    // The classes directory in a NeoForge development environment will contain both the Minecraft
-    // and the NeoForge classes. This is due to both calling each other and having to be compiled in
-    // the same javac compilation as a result.
-    public List<Path> setupNeoForgeDevProject() throws IOException {
-        var folders = createNeoForgeDevFolders();
-
-        var additionalClasspath = new ArrayList<Path>();
-
-        // Emulate the layout of a NeoForge development environment
-        // In dev, the NeoForge sources itself are joined, but the Minecraft sources are not
-        additionalClasspath.add(folders.clientClassesDir);
-        additionalClasspath.add(folders.commonClassesDir);
-        additionalClasspath.add(folders.commonResourcesDir);
-        additionalClasspath.add(folders.clientExtraJar);
-
-        launchModFolders.put("minecraft", List.of(folders.clientClassesDir, folders.commonClassesDir, folders.commonResourcesDir, folders.clientExtraJar));
-
-        return additionalClasspath;
-    }
-
-    // Similar to setupNeoForgeDevProject, but if the client is launched from Gradle, it will put the built jar files from
-    // the common sourceSet onto the classpath, while adding the client as directories.
-    public List<Path> setupSplitNeoForgeDevProjectForClientLaunch() throws IOException {
-        var folders = createNeoForgeDevFolders();
-
-        Path commonJarFile = projectRoot.resolve("build/libs/neoforge-common.jar");
-        createJarFileFromFolders(commonJarFile, folders.commonClassesDir, folders.commonResourcesDir);
-
-        launchModFolders.put("minecraft", List.of(folders.clientClassesDir, folders.commonClassesDir, folders.commonResourcesDir, folders.clientExtraJar));
-
-        return List.of(folders.clientClassesDir, commonJarFile, folders.clientExtraJar);
-    }
-
     protected record NeoForgeDevFolders(
             Path clientClassesDir,
             Path commonClassesDir,
@@ -360,7 +368,7 @@ private NeoForgeDevFolders createNeoForgeDevFolders() throws IOException {
         writeFiles(commonClassesDir, PATCHED_SHARED, NEOFORGE_CLASSES);
 
         var resourcesDir = projectRoot.resolve("projects/neoforge/build/resources/main");
-        writeFiles(resourcesDir, NEOFORGE_ASSETS, NEOFORGE_MODS_TOML, NEOFORGE_MANIFEST);
+        writeFiles(resourcesDir, NEOFORGE_ASSETS, NEOFORGE_MODS_TOML, NEOFORGE_MANIFEST, NEOFORGE_VERSION_PROPERTIES);
 
         var clientExtraJar = projectRoot.resolve("client-extra.jar");
         writeJarFile(clientExtraJar, CLIENT_EXTRA_JAR_CONTENT);
@@ -403,6 +411,10 @@ public Path getGameDir() {
         return gameDir;
     }
 
+    public Path getVersionsDir() {
+        return versionsDir;
+    }
+
     public Path getProjectRoot() {
         return projectRoot;
     }
@@ -510,6 +522,16 @@ private static byte[] writeNeoForgeModsToml() {
                 """.getBytes();
     }
 
+    private static byte[] writeNeoForgeVersionProperties() {
+        return """
+                neoforge_version=%s
+                neoform_version=1
+                minecraft_version=%s
+                autoinstall_patches=META-INF/net/neoforged/patches/patches.lzma
+                build_type=release
+                """.formatted(NEOFORGE_VERSION, MC_VERSION).getBytes();
+    }
+
     private static byte[] writeMinecraftModsToml() {
         return """
                 loader = "minecraft"
@@ -520,6 +542,47 @@ private static byte[] writeMinecraftModsToml() {
                 """.getBytes();
     }
 
+    private static byte[] createPatches(byte[] originalClientJar,
+            byte[] originalServerJar,
+            byte[] patchedClientJar,
+            byte[] patchedServerJar) {
+        List<File> tempFiles = new ArrayList<>();
+        try {
+            var originalClientJarFile = File.createTempFile("original", ".jar");
+            tempFiles.add(originalClientJarFile);
+            Files.write(originalClientJarFile.toPath(), originalClientJar);
+            var originalServerJarFile = File.createTempFile("original", ".jar");
+            tempFiles.add(originalServerJarFile);
+            Files.write(originalServerJarFile.toPath(), originalServerJar);
+            var patchedClientJarFile = File.createTempFile("patched", ".jar");
+            tempFiles.add(patchedClientJarFile);
+            Files.write(patchedClientJarFile.toPath(), patchedClientJar);
+            var patchedServerJarFile = File.createTempFile("patched", ".jar");
+            tempFiles.add(patchedServerJarFile);
+            Files.write(patchedServerJarFile.toPath(), patchedServerJar);
+            var patchBundleFile = File.createTempFile("patched", ".jar");
+            tempFiles.add(patchBundleFile);
+
+            Generator.createPatchBundle(
+                    Map.of(
+                            PatchBase.CLIENT, originalClientJarFile,
+                            PatchBase.SERVER, originalServerJarFile),
+                    Map.of(
+                            PatchBase.CLIENT, patchedClientJarFile,
+                            PatchBase.SERVER, patchedServerJarFile),
+                    patchBundleFile,
+                    new DiffOptions());
+
+            return Files.readAllBytes(patchBundleFile.toPath());
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        } finally {
+            for (var tempFile : tempFiles) {
+                tempFile.delete();
+            }
+        }
+    }
+
     public static IdentifiableContent createManifest(String name, Map<String, String> attributes) throws IOException {
         Manifest manifest = new Manifest();
         // If no manifest version is written, nothing is written.
@@ -667,6 +730,29 @@ public ModFileBuilder.ModJarBuilder buildModJar(String filename) throws IOExcept
         return ModFileBuilder.toJar(path);
     }
 
+    public Path createLibraryProject(String groupArtifactVersion, ModFileBuilder.ModJarCustomizer configurator) throws IOException {
+        String[] parts = groupArtifactVersion.split(":", 4);
+        return createLibraryProject(parts[0], parts[1], parts[2], parts.length > 3 ? parts[3] : null, configurator);
+    }
+
+    public Path createLibraryProject(String group, String artifact, String version, @Nullable String classifier, ModFileBuilder.ModJarCustomizer configurator) throws IOException {
+        var folder = librariesDir.resolve(group.replace('.', '/'))
+                .resolve(artifact)
+                .resolve(version);
+        Files.createDirectories(folder);
+
+        var filename = artifact + "-" + version;
+        if (classifier != null) {
+            filename += "-" + classifier;
+        }
+        filename += ".jar";
+        var file = folder.resolve(filename);
+
+        var builder = ModFileBuilder.toJar(file);
+        configurator.customize(builder);
+        return builder.build();
+    }
+
     /**
      * @param projectSubfolder Can be null to place output into the root project, but can also be a path relative
      *                         to the root project referring to the submodule.
@@ -700,10 +786,18 @@ public static void writeJarFile(Path file, IdentifiableContent... content) throw
         }
     }
 
-    public static IdentifiableContent createJarFile(String name, String relativePath, IdentifiableContent... content) throws IOException {
+    public static IdentifiableContent createJarFile(String name, String relativePath, IdentifiableContent... content) {
+        return new IdentifiableContent(name, relativePath, createJarFile(content));
+    }
+
+    public static byte[] createJarFile(IdentifiableContent... content) {
         var bout = new ByteArrayOutputStream();
-        writeJarFile(bout, content);
-        return new IdentifiableContent(name, relativePath, bout.toByteArray());
+        try {
+            writeJarFile(bout, content);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+        return bout.toByteArray();
     }
 
     public static void createJarFileFromFolders(Path jarFile, Path... folders) throws IOException {