Initial port to 1.18

Co-authored-by: David Quintana <[email protected]>
Co-authored-by: SizableShrimp <[email protected]>

.gitattributes

@@ -14,3 +14,10 @@
 *.cfg text eol=lf
 *.py text eol=lf
 *.jks binary
+
+# Disable autocrlf on generated files, they always generate with LF
+src/generated/**/.cache/cache text eol=lf
+src/generated/**/*.json text eol=lf
+src/generated_test/**/.cache/cache text eol=lf
+src/generated_test/**/*.json text eol=lf
+

.gitignore

@@ -9,30 +9,35 @@
 
 #idea
 /.idea
+/*/out
 /classes
 *.iml
 
 #gradle
 /build
 /.gradle
-/mdk/.gradle
-/mdk/build
+/*/build
+/*/.gradle
 
-#occupational hazards
+# Projects repo, either ignore it, or ignore patches.
 /projects/mcp/
 /projects/clean/
 /projects/forge/
+/projects/fmlonly/
+#/patches/*
+
+#occupational hazards
 /projects/**/build/
 /projects/**/out/
 /projects/**/run/
 /projects/**/*.launch
 /repo/
-/buildSrc
 src/generated/resources/.cache/
 
 #Patch rejects
 /patches-/
 *.patch.rej
+/projects/*/rejects/
 
 # FML changelog
 changelog.txt
@@ -40,5 +45,3 @@ changelog.txt
 *.7z
 /logs/
 
-gradle.properties
-!/mdk/gradle.properties

.travis.yml

@@ -1,38 +0,0 @@
-sudo: required
-dist: trusty
-
-language: java
-jdk: oraclejdk8
-
-env:
-  - BUILD_NUMBER=9999
-
-before_cache:
-  - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
-  - rm -fr $HOME/.gradle/caches/*/plugin-resolution/
-  - rm -f  $HOME/.gradle/caches/minecraft/deobfedDeps/providedDummy.jar
-  - rm -f  $HOME/.gradle/caches/minecraft/deobfedDeps/compileDummy.jar
-cache:
-  directories:
-    - $HOME/.gradle/caches/
-    - $HOME/.gradle/wrapper/
-    - $TRAVIS_BUILD_DIR/build/localCache/Forge/
-
-before_install: chmod +x gradlew
-install:
-  - ./gradlew --refresh-dependencies
-  - ./gradlew ciWriteBuildNumber
-script:
-  - travis_wait ./gradlew build -x createExe -S
-  - ./gradlew -p projects/Forge test -S -i
-
-notifications:
-  email: false
-
-# skip building travis on 1.13+ - it doesn't work there
-branches:
-  except:
-    - 1.13-pre
-    - 1.13.x
-    - 1.14.x
-    - /^noci-.*$/

Jenkinsfile

@@ -6,8 +6,8 @@ pipeline {
     }
     agent {
         docker {
-            image 'gradlewrapper:latest'
-            args '-v gradlecache:/gradlecache'
+            image 'gradle:7-jdk16'
+            //args '-v forgegc:/home/gradle/.gradle_cache/'
         }
     }
     environment {
@@ -18,11 +18,6 @@ pipeline {
     }
 
     stages {
-        stage('fetch') {
-            steps {
-                checkout scm
-            }
-        }
         stage('notify_start') {
             when {
                 not {
@@ -39,11 +34,23 @@ pipeline {
                 )
             }
         }
+        /*
+        stage('pull_cache') {
+            steps {
+                sh 'cp -r /home/gradle/.gradle_cache/jdks/ /home/gradle/.gradle/jdks/'
+                sh 'cp -r /home/gradle/.gradle_cache/wrapper/ /home/gradle/.gradle/wrapper/'
+                sh 'cp -r /home/gradle/.gradle_cache/caches/ /home/gradle/.gradle/caches/'
+            }
+        }
+        */
         stage('setup') {
             steps {
-                sh './gradlew ${GRADLE_ARGS} --refresh-dependencies --continue setup'
+                withGradle {
+                    sh './gradlew ${GRADLE_ARGS} --refresh-dependencies --continue setup'
+                }
                 script {
-                    env.MYVERSION = sh(returnStdout: true, script: './gradlew :forge:properties -q | grep "version:" | awk \'{print $2}\'').trim()
+                    env.MYVERSION = sh(returnStdout: true, script: './gradlew :forge:properties -q | grep "^version:" | cut -d" " -f2').trim()
+                    env.FMLONLY_VERSION = sh(returnStdout: true, script: './gradlew :fmlonly:properties -q | grep "^version:" | cut -d" " -f2').trim()
                 }
             }
         }
@@ -64,15 +71,23 @@ pipeline {
                 }
             }
             environment {
-                FORGE_MAVEN = credentials('forge-maven-forge-user')
                 CROWDIN = credentials('forge-crowdin')
                 KEYSTORE = credentials('forge-jenkins-keystore-old')
                 KEYSTORE_KEYPASS = credentials('forge-jenkins-keystore-old-keypass')
                 KEYSTORE_STOREPASS = credentials('forge-jenkins-keystore-old-keypass')
             }
             steps {
-                sh './gradlew ${GRADLE_ARGS} :forge:publish -PforgeMavenUser=${FORGE_MAVEN_USR} -PforgeMavenPassword=${FORGE_MAVEN_PSW} -PkeystoreKeyPass=${KEYSTORE_KEYPASS} -PkeystoreStorePass=${KEYSTORE_STOREPASS} -Pkeystore=${KEYSTORE} -PcrowdinKey=${CROWDIN}'
-                sh 'curl --user ${FORGE_MAVEN} http://files.minecraftforge.net/maven/manage/promote/latest/net.minecraftforge.forge/${MYVERSION}'
+                withCredentials([usernamePassword(credentialsId: 'maven-forge-user', usernameVariable: 'MAVEN_USER', passwordVariable: 'MAVEN_PASSWORD')]) {
+                    withGradle {
+                        sh './gradlew ${GRADLE_ARGS} publish -PkeystoreKeyPass=${KEYSTORE_KEYPASS} -PkeystoreStorePass=${KEYSTORE_STOREPASS} -Pkeystore=${KEYSTORE} -PcrowdinKey=${CROWDIN}'
+                    }
+                }
+            }
+            post {
+                success {
+                    build job: 'filegenerator', parameters: [string(name: 'COMMAND', value: "promote net.minecraftforge:forge ${env.MYVERSION} latest")], propagate: false, wait: false
+                    build job: 'filegenerator', parameters: [string(name: 'COMMAND', value: "promote net.minecraftforge:fmlonly ${env.FMLONLY_VERSION} latest")], propagate: false, wait: false
+                }
             }
         }
         stage('test_publish_pr') { //Publish to local repo to test full process, but don't include credentials so it can't sign/publish to maven
@@ -83,7 +98,9 @@ pipeline {
                 CROWDIN = credentials('forge-crowdin')
             }
             steps {
-                sh './gradlew ${GRADLE_ARGS} :forge:publish -PcrowdinKey=${CROWDIN}'
+                withGradle {
+                    sh './gradlew ${GRADLE_ARGS} publish -PcrowdinKey=${CROWDIN}'
+                }
             }
         }
     }
@@ -91,9 +108,7 @@ pipeline {
         always {
             script {
                 archiveArtifacts artifacts: 'projects/forge/build/libs/**/*.*', fingerprint: true, onlyIfSuccessful: true, allowEmptyArchive: true
-                //junit 'build/test-results/*/*.xml'
-                //jacoco sourcePattern: '**/src/*/java'
-                
+
                 if (env.CHANGE_ID == null) { // This is unset for non-PRs
                     discordSend(
                         title: "${DISCORD_PREFIX} Finished ${currentBuild.currentResult}",

LICENSE-header.txt

@@ -1,5 +1,5 @@
 Minecraft Forge
-Copyright (c) 2016-2019.
+Copyright (c) 2016-${year}.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public

buildSrc/.gitignore

@@ -0,0 +1,3 @@
+/.gradle/
+/build/
+/out/

buildSrc/build.gradle

@@ -0,0 +1,9 @@
+repositories {
+    maven { url = 'https://maven.minecraftforge.net/' }
+	mavenCentral()
+}
+dependencies {
+	implementation 'org.ow2.asm:asm:9.1'
+	implementation 'org.ow2.asm:asm-tree:9.1'
+    implementation 'net.minecraftforge:srgutils:0.4.+'
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/BytecodeFinder.groovy

@@ -0,0 +1,64 @@
+package net.minecraftforge.forge.tasks
+
+import groovy.json.JsonBuilder
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.Opcodes
+import org.objectweb.asm.tree.ClassNode
+import org.objectweb.asm.tree.FieldNode
+import org.objectweb.asm.tree.MethodNode
+
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+
+abstract class BytecodeFinder extends DefaultTask {
+    @InputFile abstract RegularFileProperty getJar()
+    @OutputFile abstract RegularFileProperty getOutput()
+
+    BytecodeFinder() {
+        output.convention(project.layout.buildDirectory.dir(name).map { it.file("output.json") })
+    }
+
+    @TaskAction
+    protected void exec() {
+        Util.init()
+
+        def outputFile = output.get().asFile
+        if (outputFile.exists())
+            outputFile.delete()
+
+        pre()
+
+        jar.get().asFile.withInputStream { i ->
+            new ZipInputStream(i).withCloseable { zin ->
+                ZipEntry zein
+                while ((zein = zin.nextEntry) != null) {
+                    if (zein.name.endsWith('.class')) {
+                        def node = new ClassNode(Opcodes.ASM9)
+                        new ClassReader(zin).accept(node, 0)
+                        process(node)
+                    }
+                }
+            }
+        }
+
+        post()
+        outputFile.text = new JsonBuilder(getData()).toPrettyString()
+    }
+
+
+    protected process(ClassNode node) {
+        if (node.fields != null) node.fields.each { process(node, it) }
+        if (node.methods != null) node.methods.each { process(node, it) }
+    }
+
+    protected pre() {}
+    protected process(ClassNode parent, FieldNode node) {}
+    protected process(ClassNode parent, MethodNode node) {}
+    protected post() {}
+    protected abstract Object getData()
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/CheckATs.groovy

@@ -0,0 +1,267 @@
+package net.minecraftforge.forge.tasks
+
+import net.minecraftforge.srgutils.IMappingFile
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.TaskAction
+import org.objectweb.asm.Opcodes
+
+abstract class CheckATs extends DefaultTask {
+	@InputFile abstract RegularFileProperty getInheritance()
+	@InputFiles abstract ConfigurableFileCollection getAts()
+    @InputFile @Optional abstract RegularFileProperty getMappings()
+	
+    @TaskAction
+    protected void exec() {
+        def mappings = mappings.map { IMappingFile.load(it.asFile) }.getOrNull()
+		Util.init()
+		def parse = { line ->
+			def idx = line.indexOf('#')
+			def comment = idx == -1 ? null : line.substring(idx)
+			if (idx != -1) line = line.substring(0, idx - 1)
+			def (modifier, cls, desc) = (line.trim() + '     ').split(' ', -1)
+			def key = cls + (desc.isEmpty() ? '' : ' ' + desc)
+			return [modifier, cls, desc, comment, key]
+		}
+		def accessLevel = { access ->
+			if ((access & Opcodes.ACC_PUBLIC)    != 0) return 3
+			if ((access & Opcodes.ACC_PROTECTED) != 0) return 2
+			if ((access & Opcodes.ACC_PRIVATE)   != 0) return 0
+			return 1
+		}
+		def accessStr = { access ->
+			if (access.endsWith('-f') || access.endsWith('+f'))
+				return 4
+			switch (access.toLowerCase()) {
+				case 'public':    return 3
+				case 'protected': return 2
+				case 'default':   return 1
+				case 'private':   return 0
+				default:          return -1
+			}
+		}
+		def json = inheritance.get().asFile.json()
+		
+		ats.each { f -> 
+			TreeMap lines = [:]
+			def group = null
+			for (def line : f.readLines()) {
+				if (line.isEmpty()) continue
+				if (line.startsWith('#group ')) {
+					def (modifier, cls, desc, comment, key) = parse.call(line.substring(7))
+					
+					if (desc != '*' && desc != '*()' && desc != '<init>')
+						throw new IllegalStateException('Invalid group: ' + line)
+					
+					group = [modifier: modifier, cls: cls, desc: desc, comment: comment, 
+						existing: [] as Set,
+						children: [] as TreeSet,
+						group: true
+					]
+					if (lines.containsKey(key))
+						throw new IllegalStateException('Duplicate group: ' + line)
+					
+					lines[key] = group
+				} else if (group != null) {
+					if (line.startsWith('#endgroup')) {
+						group = null
+					} else {
+						def (modifier, cls, desc, comment, key) = parse.call(line)
+						group['existing'].add(key)
+					}
+				} else if (line.startsWith('#endgroup')) {
+					throw new IllegalStateException('Invalid group ending: ' + line)
+				} else if (line.startsWith('#')) {
+					//Nom
+				} else {
+					def (modifier, cls, desc, comment, key) = parse.call(line)
+					if (lines.containsKey(key)) {
+						println('Duplicate: ' + line)
+						continue
+					}
+					lines[key] = [modifier: modifier, cls: cls, desc: desc, comment: comment, group: false]
+				}
+			}
+			
+			// Process Groups, this will remove any entries outside the group that is covered by the group
+			for (def key : new ArrayList<>(lines.keySet())) {
+				def entry = lines.get(key)
+				if (entry != null && entry['group']) {
+					def cls = entry['cls']
+					def jcls = json.get(cls.replaceAll('\\.', '/'))
+					if (jcls == null) {
+						lines.remove(key)
+						println('Invalid Group: ' + key)
+					} else if ('*' == entry['desc']) {
+						if (!jcls.containsKey('fields')) {
+							lines.remove(key)
+							println('Invalid Group, Class has no fields: ' + key)
+						} else {
+							jcls['fields'].each { field, value ->
+								def fkey = cls + ' ' + field
+								if (accessLevel.call(value['access']) < accessStr.call(entry['modifier'])) {
+									if (lines.containsKey(fkey)) {
+										lines.remove(fkey)
+									} else if (!entry['existing'].contains(fkey)) {
+										println('Added: ' + fkey)
+									}
+									entry['children'].add(fkey)
+								} else if (lines.containsKey(fkey)) {
+									lines.remove(fkey)
+									println('Removed: ' + fkey)
+								}
+							}
+							entry['existing'].stream().findAll{ !entry['children'].contains(it) }.each{ println('Removed: ' + it) }
+						}
+					} else if ('*()' == entry['desc']) {
+						if (!jcls.containsKey('methods')) {
+							lines.remove(key)
+							println('Invalid Group, Class has no methods: ' + key)
+						} else {
+							jcls['methods'].each{ mtd, value ->
+								if (mtd.startsWith('<clinit>') || mtd.startsWith('lambda$'))
+									return
+								key = cls + ' ' + mtd.replace(' ', '')
+								if (accessLevel.call(value['access']) < accessStr.call(entry['modifier'])) {
+									if (lines.containsKey(key)) {
+										lines.remove(key)
+									} else if (!entry['existing'].contains(key)) {
+										println('Added: ' + key)
+									}
+									entry['children'].add(key)
+								} else if (lines.containsKey(key)) {
+									lines.remove(key)
+									println('Removed: ' + key)
+								}
+							}
+							entry['existing'].stream().findAll{ !entry['children'].contains(it) }.each{ println('Removed: ' + it) }
+						}
+					} else if ('<init>' == entry['desc']) { //Make all public non-abstract subclasses
+						json.each{ tcls,value -> 
+							if (!value.containsKey('methods') || ((value['access'] & Opcodes.ACC_ABSTRACT) != 0))
+								return
+							def parents = [] as Set
+							def parent = tcls
+							while (parent != null && json.containsKey(parent)) {
+								parents.add(parent)
+								def p = json[parent]
+								parent = p == null ? null : p['superName']
+							}
+							if (parents.contains(cls.replaceAll('\\.', '/'))) {
+								value['methods'].each{ mtd, v -> 
+									if (mtd.startsWith('<init>')) {
+										def child = tcls.replaceAll('/', '\\.') + ' ' + mtd.replace(' ', '')
+										if (accessLevel.call(v['access']) < 3) {
+											if (lines.containsKey(child)) {
+												lines.remove(child)
+											} else if (!entry['existing'].contains(child)) {
+												println('Added: ' + child)
+											}
+											entry['children'].add(child)
+										} else if (lines.containsKey(child)) {
+											lines.remove(child)
+											println('Removed: ' + child)
+										}
+									}
+								}
+							}
+						}
+						entry['existing'].stream().findAll{ !entry['children'].contains(it) }.each{ println('Removed: ' + it) }
+					}
+				}
+			}
+			
+			// Process normal lines, remove invalid and remove narrowing
+			for (def key : new ArrayList<>(lines.keySet())) {
+				def entry = lines.get(key)
+				if (entry != null && !entry['group']) {
+					def cls = entry['cls']
+					def jcls = json.get(cls.replaceAll('\\.', '/'))
+					if (jcls == null) {
+						lines.remove(key)
+						println('Invalid: ' + key)
+					} else if (entry['desc'] == '') {
+						if (accessLevel.call(jcls['access']) > accessStr.call(entry['modifier']) && (entry.comment == null || !entry.comment.startsWith('#force '))) {
+							lines.remove(key)
+							println('Invalid Narrowing: ' + key)
+						}
+					} else if (!entry['desc'].contains('(')) {
+						if (!jcls.containsKey('fields') || !jcls['fields'].containsKey(entry['desc'])) {
+							lines.remove(key)
+							println('Invalid: ' + key)
+						} else {
+							def value = jcls['fields'][entry['desc']]
+							if (accessLevel.call(value['access']) > accessStr.call(entry['modifier']) && (entry.comment == null || !entry.comment.startsWith('#force '))) {
+								lines.remove(key)
+								println('Invalid Narrowing: ' + key)
+								println(entry.comment)
+							}
+						}
+					} else {
+						def jdesc = entry['desc'].replace('(', ' (')
+						if (!jcls.containsKey('methods') || !jcls['methods'].containsKey(jdesc)) {
+							lines.remove(key)
+							println('Invalid: ' + key)
+						} else {
+							def value = jcls['methods'][jdesc]
+							if (accessLevel.call(value['access']) > accessStr.call(entry['modifier']) && (entry.comment == null || !entry.comment.startsWith('#force '))) {
+								lines.remove(key)
+								println('Invalid Narrowing: ' + key)
+							}
+						}
+					}
+				}
+			}
+
+			
+			def data = []
+            def remapComment = { entry ->
+                if (!mappings || !entry || !entry.desc) return null
+                def comment = entry.comment?.substring(1)?.trim()
+                def jsonCls = json.get(entry.cls.replaceAll('\\.', '/'))
+                def mappingsClass = mappings?.getClass(jsonCls.name)
+                if (!mappingsClass) return entry.comment
+                def idx = entry.desc.indexOf('(')
+                def mappedName = idx == -1
+                        ? mappingsClass.remapField(entry.desc)
+                        : mappingsClass.remapMethod(entry.desc.substring(0, idx), entry.desc.substring(idx))
+                if (!mappedName) return entry.comment
+                if (mappedName == '<init>')
+                    mappedName = 'constructor'
+
+                if (comment?.startsWith(mappedName))
+                    return '# ' + comment
+                if (comment && comment.indexOf(' ') != -1) {
+                    def split = comment.split(" - ").toList()
+                    if (split[0].indexOf(' ') != -1)
+                        // The first string is more than one word, so append before it
+                        return "# ${mappedName} - ${comment}"
+                    split.remove(0)
+                    return "# ${mappedName} - ${String.join(' - ', split)}"
+                }
+                return '# ' + mappedName
+            }
+			lines.each { key,value -> 
+				if (!value.group) {
+                    def comment = remapComment.call(value)
+					data.add(value.modifier + ' ' + key + (comment ? ' ' + comment : ''))
+				} else {
+					data.add('#group ' + value.modifier + ' ' + key + (value.comment == null ? '' : ' ' + value.comment))
+					value.children.each {
+                        def line = value.modifier + ' ' + it
+                        def (modifier, cls, desc, comment) = parse.call(line)
+                        comment = remapComment.call([modifier: modifier, cls: cls, desc: desc, comment: comment])
+                        data.add(line + (comment ? ' ' + comment : ''))
+                    }
+					data.add('#endgroup')
+				}
+			}
+			f.text = data.join('\n')
+		}
+	}
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/CheckExcs.groovy

@@ -0,0 +1,94 @@
+package net.minecraftforge.forge.tasks
+
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.TaskAction
+
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.objectweb.asm.Type
+
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+
+abstract class CheckExcs extends DefaultTask {
+	@InputFile abstract RegularFileProperty getBinary()
+	@InputFiles abstract ConfigurableFileCollection getExcs()
+	
+    @TaskAction
+    protected void exec() {
+		Util.init()
+		def known = []
+		binary.get().asFile.withInputStream { i ->
+			new ZipInputStream(i).withCloseable { zin ->
+				def visitor = new ClassVisitor(Opcodes.ASM9) {
+					private String cls
+					@Override
+					public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+						this.cls = name
+					}
+					
+					@Override
+					public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+						known.add(this.cls + '.' + name + descriptor)
+						super.visitMethod(access, name, descriptor, signature, exceptions)
+					}
+				}
+				ZipEntry zein
+				while ((zein = zin.nextEntry) != null) {
+					if (zein.name.endsWith('.class')) {
+						ClassReader reader = new ClassReader(zin)
+						reader.accept(visitor, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES)
+					}
+				}
+			}
+		}
+		
+		excs.each { f -> 
+			def lines = []
+			f.eachLine { line ->
+				def idx = line.indexOf('#')
+				if (idx == 0 || line.isEmpty()) {
+					return
+				}
+				
+				def comment = idx == -1 ? null : line.substring(idx)
+				if (idx != -1) line = line.substring(0, idx - 1)
+				
+				if (!line.contains('=')) {
+					println('Invalid: ' + line)
+					return
+				}
+				
+				def (key, value) = line.split('=', 2)
+				if (!known.contains(key)) {
+					println('Unknown: ' + line)
+					return
+				}
+				
+				def (cls, desc) = key.split('\\.', 2)
+				if (!desc.contains('(')) {
+					println('Invalid: ' + line)
+					return
+				}
+				def name = desc.split('\\(', 2)[0]
+				desc = '(' + desc.split('\\(', 2)[1]
+				
+				def (exceptions, args) = value.contains('|') ? value.split('|', 2) : [value, '']
+				
+				if (args.split(',').length != Type.getArgumentTypes(desc).length) {
+					println('Invalid: ' + line)
+					return
+				}
+				lines.add(line)
+			}
+			f.text = lines.sort().join('\n')
+		}
+	}
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/CheckPatches.groovy

@@ -0,0 +1,219 @@
+package net.minecraftforge.forge.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.TaskAction
+
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.util.regex.Pattern
+
+abstract class CheckPatches extends DefaultTask {
+    @InputDirectory abstract DirectoryProperty getPatchDir()
+    @Input boolean autoFix = false
+
+    @TaskAction
+    protected void exec() {
+        def hasS2SArtifact = [
+                Paths.get("patches/minecraft/net/minecraft/client/renderer/ViewArea.java.patch"),
+                Paths.get("patches/minecraft/net/minecraft/data/models/blockstates/Variant.java.patch")
+        ]
+
+        def verified = true;
+        patchDir.get().asFileTree.each { patch ->
+            def patchPath = project.rootDir.toPath().relativize(patch.toPath())
+            verified &= verifyPatch(patch, autoFix, patchPath.toString(), hasS2SArtifact.contains(patchPath))
+        }
+
+        if (!verified)
+            throw new RuntimeException('One or more patches failed verification. Check the log for errors.')
+    }
+
+    def verifyPatch(patch, fix, patchPath, hasS2SArtifact) {
+        def hunk_start_pattern = Pattern.compile('^@@ -[0-9,]* \\+[0-9,_]* @@$')
+        def white_space_pattern = Pattern.compile('^[+\\-]\\s*$')
+        def import_pattern = Pattern.compile('^[+\\-]\\s*import.*')
+        def field_pattern = Pattern.compile('^[+\\-][\\s]*((public|protected|private)[\\s]*)?(static[\\s]*)?(final)?([^=;]*)(=.*)?;\\s*$')
+        def method_pattern = Pattern.compile('^[+\\-][\\s]*((public|protected|private)[\\s]*)?(static[\\s]*)?(final)?([^(]*)[(]([^)]*)?[)]\\s*[{]\\s*$')
+        def class_pattern = Pattern.compile('^[+\\-][\\s]*((public|protected|private)[\\s]*)?(static[\\s]*)?(final[\\s]*)?(class|interface)([^{]*)[{]\\s*$')
+
+        def accessMap = [("private"):0, (null):1, ("protected"):2, ("public"):3]
+
+        def hasProblem = false;
+        def lines = patch.readLines()
+
+        def hunksStart = 0
+        def onlyWhiteSpace = false
+
+        def didFix = false
+        def newLines = []
+        def whiteSpaceErrors = []
+
+        // First two lines are file name ++/-- and we do not care
+        newLines.add(lines[0] + '\n')
+        newLines.add(lines[1] + '\n')
+
+        int i = 2
+        for (; i < lines.size(); ++i) {
+            def line = lines[i]
+            newLines.add(line + '\n')
+
+            if (hunk_start_pattern.matcher(line).find()) {
+                if (onlyWhiteSpace) {
+                    if (fix || hasS2SArtifact) {
+                        logger.lifecycle("Removing white space hunk starting at line {}, file: {}", hunksStart + 1, patchPath)
+                        def toRemove = i - hunksStart;
+                        while (toRemove-- > 0)
+                            newLines.remove(newLines.size() - 1)
+                        didFix = true
+                    }
+                    else {
+                        logger.lifecycle("Patch contains only white space hunk starting at line {}, file: {}", hunksStart + 1, patchPath)
+                        hasProblem = true
+                    }
+                }
+                else {
+                    if (!whiteSpaceErrors.empty)
+                        hasProblem = true
+                    whiteSpaceErrors.each { error -> logger.lifecycle(error) }
+                    whiteSpaceErrors.clear()
+                }
+                hunksStart = i
+                onlyWhiteSpace = true
+                continue
+            }
+
+            if (line.startsWithAny('+','-')) {
+                def prefixChange = false
+                def prevLine = lines[i - 1]
+
+                if (line.charAt(0) == (char)'+' && prevLine.charAt(0) == (char)'-') {
+                    def prevTrim = prevLine.substring(1).replaceAll("\\s", "")
+                    def currTrim = line.substring(1).replaceAll("\\s", "")
+
+                    if (prevTrim.equals(currTrim)) {
+                        prefixChange = true
+                    }
+
+                    def pMatcher = field_pattern.matcher(prevLine)
+                    def cMatcher = field_pattern.matcher(line)
+
+                    if (pMatcher.find() && cMatcher.find() &&
+                            pMatcher.group(6) == cMatcher.group(6) && // = ...
+                            pMatcher.group(5) == cMatcher.group(5) && // field name
+                            pMatcher.group(3) == cMatcher.group(3) && // static
+                            (accessMap[pMatcher.group(2)] < accessMap[cMatcher.group(2)] || pMatcher.group(4) != cMatcher.group(4))) {
+                        logger.lifecycle("Patch contains access changes or final removal at line {}, file: {}", i + 1, patchPath)
+                        hasProblem = true
+                    }
+
+                    pMatcher = method_pattern.matcher(prevLine)
+                    cMatcher = method_pattern.matcher(line)
+
+                    if (pMatcher.find() && cMatcher.find() &&
+                            pMatcher.group(6) == cMatcher.group(6) && // params
+                            pMatcher.group(5) == cMatcher.group(5) && // <T> void name
+                            pMatcher.group(3) == cMatcher.group(3) && // static
+                            (accessMap[pMatcher.group(2)] < accessMap[cMatcher.group(2)] || pMatcher.group(4) != cMatcher.group(4))) {
+                        logger.lifecycle("Patch contains access changes or final removal at line {}, file: {}", i + 1, patchPath)
+                        hasProblem = true
+                    }
+
+                    pMatcher = class_pattern.matcher(prevLine)
+                    cMatcher = class_pattern.matcher(line)
+
+                    if (pMatcher.find() && cMatcher.find() &&
+                            pMatcher.group(6) == cMatcher.group(6) && // ClassName<> extends ...
+                            pMatcher.group(5) == cMatcher.group(5) && // class | interface
+                            pMatcher.group(3) == cMatcher.group(3) && // static
+                            (accessMap[pMatcher.group(2)] < accessMap[cMatcher.group(2)] || pMatcher.group(4) != cMatcher.group(4))) {
+                        logger.lifecycle("Patch contains access changes or final removal at line {}, file: {}", i + 1, patchPath)
+                        hasProblem = true
+                    }
+                }
+
+                if (line.charAt(0) == (char)'-' && i + 1 < lines.size()) {
+                    def nextLine = lines[i + 1]
+                    if (nextLine.charAt(0) == (char)'+') {
+                        def nextTrim = nextLine.substring(1).replaceAll("\\s", "")
+                        def currTrim = line.substring(1).replaceAll("\\s", "")
+
+                        if (nextTrim.equals(currTrim)) {
+                            prefixChange = true
+                        }
+                    }
+                }
+
+                def isWhiteSpaceChange = white_space_pattern.matcher(line).find()
+
+                if (!prefixChange && !isWhiteSpaceChange) {
+                    onlyWhiteSpace = hasS2SArtifact && import_pattern.matcher(line).find()
+                }
+                else if (isWhiteSpaceChange) {
+                    def prevLineChange = prevLine.startsWithAny('+','-')
+                    def nextLineChange = i + 1 < lines.size() && lines[i + 1].startsWithAny('+','-')
+
+                    if (!prevLineChange && !nextLineChange) {
+                        whiteSpaceErrors.add(String.format("Patch contains white space change in valid hunk at line %d (cannot auto fix), file: %s", i + 1, patchPath))
+                    }
+                }
+
+                if (line.contains("\t")) {
+                    if (!fix) {
+                        logger.lifecycle("Patch contains tabs on line {}, file: {}", i + 1, patchPath)
+                        hasProblem = true
+                    }
+                    else {
+                        logger.lifecycle("Fixing tabs on line {}, file: {}", i + 1, patchPath)
+                        line = line.replaceAll('\t', '    ')
+                        newLines.remove(newLines.size() - 1)
+                        newLines.add(line + '\n')
+                        didFix = true
+                    }
+                }
+
+                if (import_pattern.matcher(line).find() && !hasS2SArtifact) {
+                    logger.lifecycle("Patch contains import change on line {}, file: {}", i + 1, patchPath)
+                    hasProblem = true
+                }
+            }
+        }
+
+        if (onlyWhiteSpace) {
+            if (fix || hasS2SArtifact) {
+                logger.lifecycle("Removing white space hunk starting at line {}, file: {}", hunksStart + 1, patchPath)
+                def toRemove = i - hunksStart;
+                while (toRemove-- > 0)
+                    newLines.remove(newLines.size() - 1)
+                didFix = true
+            }
+            else {
+                logger.lifecycle("Patch contains only white space hunk starting at line {}, file: {}", hunksStart + 1, patchPath)
+                hasProblem = true
+            }
+        }
+        else {
+            if (!whiteSpaceErrors.empty)
+                hasProblem = true
+            whiteSpaceErrors.each { error -> logger.lifecycle(error) }
+        }
+
+        if (didFix) {
+            if (newLines.size() <= 2) {
+                logger.lifecycle("Patch is now empty removing, file: {}", patchPath)
+                Files.delete(patch.toPath())
+            }
+            else {
+                if (!hasS2SArtifact)
+                    logger.lifecycle("*** Updating patch file. Please run setup then genPatches again. ***")
+                patch.withWriter('UTF-8') { writer ->
+                    newLines.each { l -> writer.write(l) }
+                }
+            }
+        }
+
+        return !hasProblem
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/CheckSAS.groovy

@@ -0,0 +1,63 @@
+package net.minecraftforge.forge.tasks
+
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.TaskAction
+
+abstract class CheckSAS extends DefaultTask {
+	@InputFile abstract RegularFileProperty getInheritance()
+	@InputFiles abstract ConfigurableFileCollection getSass()
+	
+    @TaskAction
+    protected void exec() {
+		Util.init()
+		def json = inheritance.get().asFile.json()
+		
+		sass.each { f -> 
+			def lines = []
+			f.eachLine { line ->
+				if (line[0] == '\t') return //Skip any tabbed lines, those are ones we add
+				def idx = line.indexOf('#')
+				if (idx == 0 || line.isEmpty()) {
+					lines.add(line)
+					return
+				}
+				def comment = idx == -1 ? null : line.substring(idx)
+				if (idx != -1) line = line.substring(0, idx - 1)
+				def (cls, desc) = (line.trim() + '    ').split(' ', -1)
+				cls = cls.replaceAll('\\.', '/')
+				desc = desc.replace('(', ' (')
+
+				if (json[cls] == null || (!desc.isEmpty() && (json[cls]['methods'] == null || json[cls]['methods'][desc] == null))) {
+					println('Invalid: ' + line)
+					return
+				}
+
+				//Class SAS
+				if (desc.isEmpty()) {
+					lines.add(cls + (comment == null ? '' : ' ' + comment))
+					if (json[cls]['methods'] != null)
+						(json[cls]['methods'] as TreeMap).each {
+							findChildMethods(json, cls, it.key).each { lines.add('\t' + it) }
+						}
+					return
+				}
+
+				//Method SAS
+				lines.add(cls + ' ' + desc.replace(' ', '') + (comment == null ? '' : ' ' + comment))
+				findChildMethods(json, cls, desc).each { lines.add('\t' + it) }
+			}
+			f.text = lines.join('\n')
+		}
+	}
+
+	protected static findChildMethods(json, cls, desc)
+	{
+		return json.values().findAll{ it.methods != null && it.methods[desc] != null && it.methods[desc].override == cls}
+				.collect { it.name + ' ' + desc.replace(' ', '') } as TreeSet
+	}
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/ClosureHelper.groovy

@@ -0,0 +1,31 @@
+package net.minecraftforge.forge.tasks
+
+import java.util.function.BiConsumer
+
+public class ClosureHelper {
+    BiConsumer<String, Closure> callback
+    
+    public ClosureHelper(Closure cl, BiConsumer<String, Closure> callback) {
+        this.callback = callback
+        apply(this, cl)
+    }
+    
+    
+    def methodMissing(String name, Object args) {
+        if (!args.class.isArray()) return
+        Object[] aargs = (Object[])args
+        
+        if (aargs.length == 1 && aargs[0] instanceof Closure) {
+            this.callback.accept(name, (Closure)aargs[0])
+        } else {
+            throw new IllegalArgumentException('Unknown method: "' + name + '" with arguments ' + args + ' for ' + this)
+        }
+    }
+    
+    static <T> T apply(T obj, Closure cl) {
+        cl.delegate = obj
+        cl.resolveStrategy = Closure.DELEGATE_FIRST
+        cl()
+        return obj
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/Crowdin.groovy

@@ -0,0 +1,73 @@
+package net.minecraftforge.forge.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
+
+abstract class Crowdin extends DefaultTask {
+    @Input abstract Property<String> getId()
+	@Input @Optional abstract Property<String> getKey()
+	@Input boolean json = true
+	@OutputFile abstract RegularFileProperty getOutput()
+	@OutputFile abstract RegularFileProperty getExport()
+
+    Crowdin() {
+		outputs.upToDateWhen{ false }
+		id.convention('minecraft-forge')
+		output.convention(project.layout.buildDirectory.dir(name).map {it.file("output.zip") })
+		export.convention(project.layout.buildDirectory.dir(name).map {it.file("export.json") })
+	}
+
+    @TaskAction
+    def run() {
+		File outputFile = output.get().asFile
+		File exportFile = export.get().asFile
+		if (outputFile.exists())
+			outputFile.delete()
+		
+		if (!key.isPresent())
+			return
+		String key = this.key.get()
+		String id = this.id.get()
+		
+		// Force an export
+		new URL("https://api.crowdin.com/api/project/${id}/export?key=${key}").withInputStream { i ->
+			exportFile.withOutputStream { it << i }
+		}
+		
+		if (!exportFile.text.contains('success')) {
+			throw new RuntimeException("Crowdin export failed, see ${exportFile} for more info")
+		}
+
+		new URL("https://api.crowdin.com/api/project/${id}/download/all.zip?key=${key}").withInputStream { i -> 
+			new ZipInputStream(i).withCloseable { zin ->
+				outputFile.withOutputStream { out ->
+					new ZipOutputStream(out).withCloseable { zout -> 
+						ZipEntry zein
+						while ((zein = zin.nextEntry) != null) {
+							if (zein.isDirectory()) {
+								zout.putNextEntry(new ZipEntry(zein.name))
+							} else {
+								// 1.13+ uses json
+								if (zein.name.endsWith('.json') == json) {
+									ZipEntry zeout = new ZipEntry(json ? zein.name.toLowerCase() : zein.name)
+									zeout.time = 1
+									zout.putNextEntry(zeout)
+									zout << zin
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/DownloadLibraries.groovy

@@ -0,0 +1,54 @@
+package net.minecraftforge.forge.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.OutputFiles
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.OutputDirectory
+
+import java.nio.file.Files
+
+abstract class DownloadLibraries extends DefaultTask {
+	@InputFile abstract RegularFileProperty getInput()
+	@OutputDirectory abstract DirectoryProperty getOutput()
+	@OutputFile abstract RegularFileProperty getLibrariesOutput()
+
+    DownloadLibraries() {
+		output.convention(project.layout.buildDirectory.dir(name))
+        librariesOutput.convention(project.layout.buildDirectory.dir(name).map(d -> d.file('libraries.txt')))
+	}
+
+    @TaskAction
+    def run() {
+		Util.init()
+		File outputDir = output.get().asFile
+        def libraries = new ArrayList()
+
+		def json = input.get().asFile.json().libraries.each { lib ->
+		    //TODO: Thread?
+			def artifacts = [lib.downloads.artifact] + lib.downloads.get('classifiers', [:]).values()
+			artifacts.each{ art -> 
+				def target = new File(outputDir, art.path)
+				libraries.add(target.absolutePath)
+				if (!target.exists() || !art.sha1.equals(target.sha1())) {
+					project.logger.lifecycle("Downloading ${art.url}")
+					if (!target.parentFile.exists()) {
+						target.parentFile.mkdirs()
+					}
+					new URL(art.url).withInputStream { i ->
+						target.withOutputStream { it << i }
+					}
+					if (!art.sha1.equals(target.sha1())) {
+						throw new IllegalStateException("Failed to download ${art.url} to ${target.canonicalPath} SHA Mismatch")
+					}
+				}
+			}
+		}
+        Files.write(librariesOutput.get().asFile.toPath(), libraries)
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/FieldCompareFinder.groovy

@@ -0,0 +1,109 @@
+package net.minecraftforge.forge.tasks
+
+import groovy.transform.EqualsAndHashCode
+
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.TreeMap
+import java.util.TreeSet
+import java.util.function.BiConsumer
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.*
+
+import org.objectweb.asm.Opcodes
+import org.objectweb.asm.Type
+import org.objectweb.asm.tree.ClassNode
+import org.objectweb.asm.tree.FieldNode
+import org.objectweb.asm.tree.MethodNode
+
+import static org.objectweb.asm.Opcodes.*
+
+abstract class FieldCompareFinder extends BytecodeFinder {
+    @Nested
+    Map<String, Search> fields = [:] as HashMap
+    @Internal
+    Map<Search, String> fieldsReverse = [:] as HashMap
+    @Internal
+    Map<String, Set<ObjectTarget>> targets = [:] as TreeMap
+    
+    @Override
+    protected pre() {
+        //fields.each{ k,v -> logger.lifecycle("Fields: " + k + ' ' + v) }
+    }
+    
+    @Override
+    protected process(ClassNode parent, MethodNode node) {
+        def last = null
+        def parentInstance = new ObjectTarget(owner: parent.name, name: '', desc: '')
+        for (int x = 0; x < node.instructions.size(); x++) {
+            def current = node.instructions.get(x)
+            if (current.opcode == IF_ACMPEQ || current.opcode == IF_ACMPNE) {
+                if (last != null && (last.opcode == GETSTATIC || last.opcode == GETFIELD)) {
+                    def target = new Search(cls: last.owner, name: last.name)
+                    def wanted = fieldsReverse.get(target)
+                    def original = fields.get(wanted)
+                    def instance = new ObjectTarget(owner: parent.name, name: node.name, desc: node.desc)
+                    if (wanted != null && (original.blacklist == null || (!original.blacklist.contains(instance) && !original.blacklist.contains(parentInstance)))) {
+                        targets.computeIfAbsent(wanted, { k -> new TreeSet() }).add(instance)
+                    }
+                }
+            }
+            last = current
+        }
+    }
+    
+    @Internal
+    @Override
+    protected Object getData() {
+		def ret = [:] as HashMap
+		targets.forEach{ k, v -> 
+			def e = fields.get(k)
+			ret[k] = [
+				cls: e.cls, 
+				name: e.name, 
+				replacement: e.replacement, 
+				targets: v
+			]
+		}
+        return ret
+    }
+    
+    @EqualsAndHashCode(excludes = ['replacement', 'blacklist'])
+    public static class Search {
+        @Input
+        String cls
+        
+        @Input
+        String name
+		
+		@Input
+		String replacement
+    
+        @Nested
+        @Optional
+        Set<ObjectTarget> blacklist
+        
+        @Override
+        String toString() {
+            return cls + '.' + name
+        }
+        
+        def blacklist(def owner, def name, def desc) {
+            if (blacklist == null)
+                blacklist = new HashSet()
+            blacklist.add(new ObjectTarget(owner: owner, name: name, desc: desc))
+        }
+        def blacklist(def owner) {
+            blacklist(owner, '', '')
+        }
+    }
+    
+    def fields(Closure cl) {
+        new ClosureHelper(cl, {name, ccl ->
+            def search = ClosureHelper.apply(new Search(), ccl)
+            this.fields.put(name, search)
+            this.fieldsReverse.put(search, name)
+        })
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/InstallerJar.groovy

@@ -0,0 +1,44 @@
+package net.minecraftforge.forge.tasks
+
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.api.tasks.*
+import org.gradle.api.provider.SetProperty
+
+abstract class InstallerJar extends Zip {
+    @Input @Optional abstract SetProperty<String> getPackedDependencies()
+    
+    InstallerJar() {
+        archiveClassifier.set('installer')
+        archiveExtension.set('jar') // Needs to be Zip task to not override Manifest, so set extension
+        destinationDirectory.set(project.layout.buildDirectory.dir('libs'))
+
+        def installerJson = project.tasks.installerJson
+        def launcherJson = project.tasks.launcherJson
+        def downloadInstaller = project.tasks.downloadInstaller
+        
+        dependsOn(installerJson, launcherJson, downloadInstaller)
+        from(installerJson, launcherJson)
+
+        from(project.rootProject.file('/src/main/resources/url.png'))
+        project.afterEvaluate {
+            from(project.zipTree(downloadInstaller.output)) {
+                duplicatesStrategy = 'exclude'
+            }
+            
+            if (!System.env.MAVEN_USER) {
+                dependsOn(project.universalJar)
+                from(project.universalJar) {
+                    into '/maven/' + project.group.replace('.', '/') + '/' + project.universalJar.archiveBaseName.get() + '/' + project.version + '/'
+                }
+    
+                packedDependencies.get().forEach {
+                    def jarTask = project.rootProject.getTasks().findByPath(it)
+                    dependsOn(jarTask)
+                    from(jarTask) {
+                        into '/maven/' + jarTask.project.group.replace('.', '/') + '/' + jarTask.archiveBaseName.get() + '/' + jarTask.project.version + '/'
+                    }
+                }
+            }
+        }
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/InstallerJson.groovy

@@ -0,0 +1,81 @@
+package net.minecraftforge.forge.tasks
+
+import groovy.json.JsonBuilder
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.SetProperty
+import org.gradle.api.tasks.*
+
+import java.nio.file.Files
+
+abstract class InstallerJson extends DefaultTask {
+    @OutputFile abstract RegularFileProperty getOutput()
+    @InputFiles abstract ConfigurableFileCollection getInput()
+    @Input @Optional abstract SetProperty<String> getPackedDependencies()
+    @Input @Optional final Map<String, Object> libraries = new LinkedHashMap<>()
+    @Input Map<String, Object> json = new LinkedHashMap<>()
+    @InputFile abstract RegularFileProperty getIcon()
+    @Input abstract Property<String> getLauncherJsonName()
+    @Input abstract Property<String> getLogo()
+    @Input abstract Property<String> getMirrors()
+    @Input abstract Property<String> getWelcome()
+
+    InstallerJson() {
+        getLauncherJsonName().convention('/version.json')
+        getLogo().convention('/big_logo.png')
+        getMirrors().convention('https://files.minecraftforge.net/mirrors-2.0.json')
+        getWelcome().convention("Welcome to the simple ${project.name.capitalize()} installer.")
+                
+        getOutput().convention(project.layout.buildDirectory.file('install_profile.json'))
+
+        ['client', 'server'].each { side ->
+            ['slim', 'extra'].each { type ->
+                def tsk = project.tasks.getByName("download${side.capitalize()}${type.capitalize()}")
+                dependsOn(tsk)
+                input.from(tsk.output)
+            }
+            def tsk = project.tasks.getByName("create${side.capitalize()}SRG")
+            dependsOn(tsk)
+            input.from(tsk.output)
+        }
+
+        
+        project.afterEvaluate {
+            (packedDependencies.get().collect{ project.rootProject.tasks.findByPath(it) } + [project.universalJar]).forEach {
+                dependsOn(it)
+                input.from it.archiveFile
+            }
+        }
+    }
+
+    @TaskAction
+    protected void exec() {
+        def libs = libraries
+        for (def child : packedDependencies.get().collect{ project.rootProject.tasks.findByPath(it) } + [project.universalJar]) {
+            def dep = Util.getMavenDep(child)
+            def path = Util.getMavenPath(child)
+            libs.put(dep.toString(), [
+                name: dep,
+                downloads: [
+                    artifact: [
+                        path: path,
+                        url: "https://maven.minecraftforge.net/${path}",
+                        sha1: child.archiveFile.get().asFile.sha1(),
+                        size: child.archiveFile.get().asFile.length()
+                    ]
+                ]
+            ])
+        }
+        json.libraries = libs.values().sort{a,b -> a.name.compareTo(b.name)}
+        json.icon = "data:image/png;base64," + new String(Base64.getEncoder().encode(Files.readAllBytes(icon.get().asFile.toPath())))
+        json.json = launcherJsonName.get()
+        json.logo = logo.get()
+        if (!mirrors.get().isEmpty())
+            json.mirrorList = mirrors.get()
+        json.welcome = welcome.get()
+
+        Files.writeString(output.get().getAsFile().toPath(), new JsonBuilder(json).toPrettyString())
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/LauncherJson.groovy

@@ -0,0 +1,74 @@
+package net.minecraftforge.forge.tasks
+
+import groovy.json.JsonBuilder
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.SetProperty
+import org.gradle.api.tasks.*
+
+import java.nio.file.Files
+
+import static net.minecraftforge.forge.tasks.Util.getArtifacts
+import static net.minecraftforge.forge.tasks.Util.iso8601Now
+
+abstract class LauncherJson extends DefaultTask {
+    @OutputFile abstract RegularFileProperty getOutput()
+    @InputFiles abstract ConfigurableFileCollection getInput()
+    @Input Map<String, Object> json = new LinkedHashMap<>()
+    @Input @Optional abstract SetProperty<String> getPackedDependencies()
+    
+    @Internal final vanilla = project.project(':mcp').file('build/mcp/downloadJson/version.json')
+    @Internal final timestamp = iso8601Now()
+    @Internal final comment = [
+        "Please do not automate the download and installation of Forge.",
+        "Our efforts are supported by ads from the download page.",
+        "If you MUST automate this, please consider supporting the project through https://www.patreon.com/LexManos/"
+    ]
+    @Internal final id = "${project.rootProject.ext.MC_VERSION}-${project.name}${project.version.substring(project.rootProject.ext.MC_VERSION.length())}"
+
+    LauncherJson() {
+        getOutput().convention(project.layout.buildDirectory.file('version.json'))
+
+        dependsOn(':fmlloader:jar', 'universalJar')
+        getInput().from(project.tasks.universalJar.archiveFile,
+                project.project(':fmlloader').jar.archiveFile,
+                vanilla)
+                
+        project.afterEvaluate {
+            packedDependencies.get().forEach {
+                def jarTask = project.rootProject.tasks.findByPath(it)
+                dependsOn(jarTask)
+                input.from jarTask.archiveFile
+            }
+        }
+    }
+
+    @TaskAction
+    protected void exec() {
+        if (!json.libraries)
+            json.libraries = []
+        def libs = [:]
+        getArtifacts(project, project.configurations.installer, false).each { key, lib -> libs[key] = lib }
+        getArtifacts(project, project.configurations.moduleonly, false).each { key, lib -> libs[key] = lib }
+
+        packedDependencies.get().collect{ project.rootProject.tasks.findByPath(it) }.forEach {
+            def path = Util.getMavenPath(it)
+            def key = Util.getMavenDep(it)
+            
+            libs[key] = [
+                name: key,
+                downloads: [
+                    artifact: [
+                        path: path,
+                        url: "https://maven.minecraftforge.net/${path}",
+                        sha1: it.archiveFile.get().asFile.sha1(),
+                        size: it.archiveFile.get().asFile.length()
+                    ]
+                ]
+            ]
+        }
+        libs.each { key, lib -> json.libraries.add(lib) }
+        Files.writeString(output.get().asFile.toPath(), new JsonBuilder(json).toPrettyString())
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/ObjectTarget.groovy

@@ -0,0 +1,32 @@
+package net.minecraftforge.forge.tasks
+
+import groovy.transform.EqualsAndHashCode
+
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Nested
+import org.gradle.api.tasks.Optional
+
+@EqualsAndHashCode
+public class ObjectTarget implements Comparable<ObjectTarget> {
+    @Input
+    String owner
+    
+    @Input
+    String name
+    
+    @Input
+    @Optional
+    String desc
+    
+    @Override
+    String toString() {
+        if (desc == null)
+            return owner + '.' + name
+        return owner + '.' + name + desc
+    }
+    
+    @Override
+    int compareTo(ObjectTarget o) {
+        return toString().compareTo(o.toString())
+    }
+}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/Util.groovy

@@ -0,0 +1,141 @@
+package net.minecraftforge.forge.tasks
+
+import groovy.json.JsonSlurper
+
+import java.io.File
+import java.security.MessageDigest
+import java.text.SimpleDateFormat
+import java.util.Date
+
+public class Util {
+	static void init() {
+		File.metaClass.sha1 = { ->
+			MessageDigest md = MessageDigest.getInstance('SHA-1')
+			delegate.eachByte 4096, {bytes, size ->
+				md.update(bytes, 0, size)
+			}
+			return md.digest().collect {String.format "%02x", it}.join()
+		}
+	
+		File.metaClass.json = { -> new JsonSlurper().parseText(delegate.text) }
+		
+		Date.metaClass.iso8601 = { ->
+			def format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
+			def result = format.format(delegate)
+			return result[0..21] + ':' + result[22..-1]
+		}
+        
+        String.metaClass.rsplit = { String del, int limit = -1 ->
+            def lst = new ArrayList()
+            def x = 0, idx
+            def tmp = delegate
+            while ((idx = tmp.lastIndexOf(del)) != -1 && (limit == -1 || x++ < limit)) {
+                lst.add(0, tmp.substring(idx + del.length(), tmp.length()))
+                tmp = tmp.substring(0, idx)
+            }
+            lst.add(0, tmp)
+            return lst
+        }
+	}
+	
+	public static String[] getClasspath(project, libs, artifact) {
+		def ret = []
+		artifactTree(project, artifact).each { key, lib ->
+			libs[lib.name] = lib
+			if (lib.name != artifact)
+				ret.add(lib.name)
+		}
+		return ret
+	}
+	
+	public static def getArtifacts(project, config, classifiers) {
+		def ret = [:]
+		config.resolvedConfiguration.resolvedArtifacts.each {
+			def art = [
+				group: it.moduleVersion.id.group,
+				name: it.moduleVersion.id.name,
+				version: it.moduleVersion.id.version,
+				classifier: it.classifier,
+				extension: it.extension,
+				file: it.file
+			]
+			def key = art.group + ':' + art.name
+			def folder = "${art.group.replace('.', '/')}/${art.name}/${art.version}/"
+			def filename = "${art.name}-${art.version}"
+			if (art.classifier != null)
+				filename += "-${art.classifier}"
+			filename += ".${art.extension}"
+			def path = "${folder}${filename}"
+			def url = "https://libraries.minecraft.net/${path}"
+			if (!checkExists(url)) {
+				url = "https://maven.minecraftforge.net/${path}"
+			}
+			//TODO remove when Mojang launcher is updated
+			if (!classifiers && art.classifier != null) { 
+				//Mojang launcher doesn't currently support classifiers, so... move it to part of the version, and force the extension to 'jar'
+				// However, keep the path normal so that our mirror system works.
+				art.version = "${art.version}-${art.classifier}"
+				art.classifier = null
+				art.extension = 'jar'
+			}
+			ret[key] = [
+				name: "${art.group}:${art.name}:${art.version}" + (art.classifier == null ? '' : ":${art.classifier}") + (art.extension == 'jar' ? '' : "@${art.extension}"),
+				downloads: [
+					artifact: [
+						path: path,
+						url: url,
+						sha1: sha1(art.file),
+						size: art.file.length()
+					]
+				]
+			]
+		}
+		return ret
+	}
+    
+    public static def getMavenPath(task) {        
+        def classifier = task.archiveClassifier.get()
+        def dep = "${task.project.group}:${task.project.name}:${task.project.version}" + (classifier == '' ? '' : ':' + classifier)
+        return "${task.project.group.replace('.', '/')}/${task.project.name}/${task.project.version}/${task.project.name}-${task.project.version}".toString() + (classifier == '' ? '' : '-' + classifier) + '.jar'
+    }
+    
+    public static def getMavenDep(task) {        
+        def classifier = task.archiveClassifier.get()
+        return "${task.project.group}:${task.project.name}:${task.project.version}" + (classifier == '' ? '' : ':' + classifier)
+    }
+
+	public static def iso8601Now() { new Date().iso8601() }
+
+	public static def sha1(file) {
+		MessageDigest md = MessageDigest.getInstance('SHA-1')
+		file.eachByte 4096, {bytes, size ->
+			md.update(bytes, 0, size)
+		}
+		return md.digest().collect {String.format "%02x", it}.join()
+	}
+
+	private static def artifactTree(project, artifact) {
+		if (!project.ext.has('tree_resolver'))
+			project.ext.tree_resolver = 1
+		def cfg = project.configurations.create('tree_resolver_' + project.ext.tree_resolver++)
+		def dep = project.dependencies.create(artifact)
+		cfg.dependencies.add(dep)
+		def files = cfg.resolve()
+		return getArtifacts(project, cfg, true)
+	}
+	
+	private static boolean checkExists(url) {
+		try {
+			def code = new URL(url).openConnection().with {
+				requestMethod = 'HEAD'
+				connect()
+				responseCode
+			}
+			return code == 200
+		} catch (Exception e) {
+			if (e.toString().contains('unable to find valid certification path to requested target'))
+				throw new RuntimeException('Failed to connect to ' + url + ': Missing certificate root authority, try updating java')
+			throw e
+		}
+	}
+}

docs/CONTRIBUTING.md

@@ -15,8 +15,4 @@ Contributor License Agreement
 - You grant Forge a license to use your code contributed to the primary codebase (everything **not** under patches) in Forge, under the LGPLv2.1 license.
 - You assign copyright ownership of your contributions to the patches codebase (everything under patches) to Forge, where it will be licensed under the LGPLv2.1 license.
 
-Additionally, while 1.9.4 is being maintained, you will be asked to acknowledge these two additional clauses.
-- You grant Forge a license to use your code contributed to the primary codebase (everything **not** under patches) in Forge, under the MinecraftForge license.
-- You grant assign copyright ownership of your contributions to the patches codebase (everything under patches) to Forge, where it will be licensed under the MinecraftForge license.
-
 "Forge" is Forge Development LLC, a legally incorporated entity in Oregon, USA.

docs/README.md

@@ -1,14 +1,17 @@
-<img src="assets/Forge_logo.svg">
+![Forge Logo](assets/Forge_logo.svg)
 
-MinecraftForge [![Latest Release](https://img.shields.io/maven-metadata/v/https/files.minecraftforge.net/maven/net/minecraftforge/forge/maven-metadata.xml.svg?label=latest)](https://files.minecraftforge.net) [![Discord](https://img.shields.io/discord/313125603924639766.svg?color=%237289da&label=discord&logo=discord&logoColor=%237289da)](https://discord.gg/UvedJ9m) [![Support](https://img.shields.io/badge/patreon-support-orange.svg)](https://www.patreon.com/LexManos) [![Merch](https://img.shields.io/badge/flocker-merch-blueviolet.svg)](https://forgedev.flocker.tv/)
+MinecraftForge
 =============
+[![Stable Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Stable&prefix=1.17.1-&query=$.promos["1.17.1-recommended"]&color=brightgreen&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtc3RhciBmYS13LTE4IiBhcmlhLWhpZGRlbj0idHJ1ZSIgZGF0YS1pY29uPSJzdGFyIiBkYXRhLXByZWZpeD0iZmFzIiBmb2N1c2FibGU9ImZhbHNlIiByb2xlPSJpbWciIHZpZXdCb3g9IjAgMCA1NzYgNTEyIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8cGF0aCBkPSJNMjU5LjMgMTcuOEwxOTQgMTUwLjIgNDcuOSAxNzEuNWMtMjYuMiAzLjgtMzYuNyAzNi4xLTE3LjcgNTQuNmwxMDUuNyAxMDMtMjUgMTQ1LjVjLTQuNSAyNi4zIDIzLjIgNDYgNDYuNCAzMy43TDI4OCA0MzkuNmwxMzAuNyA2OC43YzIzLjIgMTIuMiA1MC45LTcuNCA0Ni40LTMzLjdsLTI1LTE0NS41IDEwNS43LTEwM2MxOS0xOC41IDguNS01MC44LTE3LjctNTQuNkwzODIgMTUwLjIgMzE2LjcgMTcuOGMtMTEuNy0yMy42LTQ1LjYtMjMuOS01Ny40IDB6IiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K)](https://files.minecraftforge.net)
+[![Latest Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Latest&prefix=1.17.1-&query=$.promos["1.17.1-latest"]&color=blue&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtYnVnIGZhLXctMTYiIGFyaWEtaGlkZGVuPSJ0cnVlIiBkYXRhLWljb249ImJ1ZyIgZGF0YS1wcmVmaXg9ImZhcyIgZm9jdXNhYmxlPSJmYWxzZSIgcm9sZT0iaW1nIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTUxMS45ODggMjg4LjljLS40NzggMTcuNDMtMTUuMjE3IDMxLjEtMzIuNjUzIDMxLjFINDI0djE2YzAgMjEuODY0LTQuODgyIDQyLjU4NC0xMy42IDYxLjE0NWw2MC4yMjggNjAuMjI4YzEyLjQ5NiAxMi40OTcgMTIuNDk2IDMyLjc1OCAwIDQ1LjI1NS0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDBsLTU0LjczNi01NC43MzZDMzQ1Ljg4NiA0NjcuOTY1IDMxNC4zNTEgNDgwIDI4MCA0ODBWMjM2YzAtNi42MjctNS4zNzMtMTItMTItMTJoLTI0Yy02LjYyNyAwLTEyIDUuMzczLTEyIDEydjI0NGMtMzQuMzUxIDAtNjUuODg2LTEyLjAzNS05MC42MzYtMzIuMTA4bC01NC43MzYgNTQuNzM2Yy0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDAtMTIuNDk2LTEyLjQ5Ny0xMi40OTYtMzIuNzU4IDAtNDUuMjU1bDYwLjIyOC02MC4yMjhDOTIuODgyIDM3OC41ODQgODggMzU3Ljg2NCA4OCAzMzZ2LTE2SDMyLjY2NkMxNS4yMyAzMjAgLjQ5MSAzMDYuMzMuMDEzIDI4OC45LS40ODQgMjcwLjgxNiAxNC4wMjggMjU2IDMyIDI1Nmg1NnYtNTguNzQ1bC00Ni42MjgtNDYuNjI4Yy0xMi40OTYtMTIuNDk3LTEyLjQ5Ni0zMi43NTggMC00NS4yNTUgMTIuNDk4LTEyLjQ5NyAzMi43NTgtMTIuNDk3IDQ1LjI1NiAwTDE0MS4yNTUgMTYwaDIyOS40ODlsNTQuNjI3LTU0LjYyN2MxMi40OTgtMTIuNDk3IDMyLjc1OC0xMi40OTcgNDUuMjU2IDAgMTIuNDk2IDEyLjQ5NyAxMi40OTYgMzIuNzU4IDAgNDUuMjU1TDQyNCAxOTcuMjU1VjI1Nmg1NmMxNy45NzIgMCAzMi40ODQgMTQuODE2IDMxLjk4OCAzMi45ek0yNTcgMGMtNjEuODU2IDAtMTEyIDUwLjE0NC0xMTIgMTEyaDIyNEMzNjkgNTAuMTQ0IDMxOC44NTYgMCAyNTcgMHoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo=
+)](https://files.minecraftforge.net) [![Discord](https://img.shields.io/discord/313125603924639766.svg?color=%237289da&label=Discord&logo=discord&logoColor=%237289da)](https://discord.gg/UvedJ9m) [![Support](https://img.shields.io/badge/Patreon-Support-orange.svg?logo=Patreon)](https://www.patreon.com/LexManos)
 
 Forge is a free, open-source modding API all of your favourite mods use!
 
-| Version  | Support |
+|    Version    |    Support    |
 | ------------- | ------------- |
-| 1.14.x  | Active (latest)  |
-| 1.12.x  | Active (stable)  |
+|    1.17.x     |    Active     |
+|    1.16.x     |    LTS        |
 
 * [Download]
 * [Forum]
@@ -57,7 +60,7 @@ We require all contributors to acknowledge the [Forge Contributor
  signed it, you should be OK.
 
 #### Donate
-*Forge is a large project with many collaborators working on it around the clock. Forge is and will always remain free to use and modify. However, it costs money to run such a large project as this, so please consider [becoming a patron](https://www.patreon.com/LexManos) or buying some [cool merch](https://forgedev.flocker.tv/).*
+*Forge is a large project with many collaborators working on it around the clock. Forge is and will always remain free to use and modify. However, it costs money to run such a large project as this, so please consider [becoming a patron](https://www.patreon.com/LexManos).*
 
 [Download]: https://files.minecraftforge.net/
 [Forum]: https://www.minecraftforge.net/forum/

fmlcore/build.gradle

@@ -0,0 +1,64 @@
+plugins {
+    id 'com.github.ben-manes.versions'
+    id 'org.javamodularity.moduleplugin' version '1.8.3' apply false
+}
+apply plugin: 'java-library'
+apply plugin: 'jacoco'
+apply plugin: 'org.javamodularity.moduleplugin'
+
+dependencyUpdates.rejectVersionIf { isNonStable(it.candidate.version) }
+
+dependencies {
+    compileOnly('org.jetbrains:annotations:21.0.1')
+    implementation(project(':fmlloader'))
+    api('net.minecraftforge:eventbus:5.0.+')
+    implementation('commons-io:commons-io:2.5')
+}
+
+task sourcesJar(type: Jar) {
+    archiveClassifier = 'sources'
+    from sourceSets.main.allSource
+}
+
+ext {
+    MANIFESTS = [
+        '': [
+            'FMLModType': 'LIBRARY',
+            'Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
+            'Git-Commit': GIT_INFO.abbreviatedId,
+            'Git-Branch': GIT_INFO.branch,
+            'Build-Number': "${System.getenv('BUILD_NUMBER')?:0}"
+        ] as LinkedHashMap,
+        'net/minecraftforge/fml/loading/': [
+            'Specification-Title':      'FMLLoader',
+            'Specification-Vendor':     'Forge Development LLC',
+            'Specification-Version':    '1',
+            'Implementation-Title':     'FML Loader',
+            'Implementation-Version':   '1.0',
+            'Implementation-Vendor':    'Forge'
+        ] as LinkedHashMap
+    ]
+}
+
+jar.doFirst {
+    MANIFESTS.each { pkg, values ->
+        if (pkg == '')
+            manifest.attributes(values)
+        else
+            manifest.attributes(values, pkg)
+    }
+}
+
+tasks.withType(JavaCompile) {
+    options.compilerArgs << '-Xlint:unchecked'
+}
+
+artifacts {
+    archives jar
+    archives sourcesJar
+}
+
+publishing.publications.mavenJava(MavenPublication) {
+    from components.java
+    artifact sourcesJar
+}

fmlcore/src/main/java/net/minecraftforge/fml/Bindings.java

@@ -0,0 +1,35 @@
+package net.minecraftforge.fml;
+
+import cpw.mods.modlauncher.util.ServiceLoaderUtils;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.config.IConfigEvent;
+import net.minecraftforge.fml.loading.FMLLoader;
+
+import java.util.ServiceLoader;
+import java.util.function.Supplier;
+
+public class Bindings {
+    private static final Bindings INSTANCE = new Bindings();
+
+    private final IBindingsProvider provider;
+
+    private Bindings() {
+        final var providers = ServiceLoaderUtils.streamServiceLoader(()->ServiceLoader.load(FMLLoader.getGameLayer(), IBindingsProvider.class), sce->{}).toList();
+        if (providers.size() != 1) {
+            throw new IllegalStateException("Could not find bindings provider");
+        }
+        this.provider = providers.get(0);
+    }
+
+    public static Supplier<IEventBus> getForgeBus() {
+        return INSTANCE.provider.getForgeBusSupplier();
+    }
+
+    public static Supplier<I18NParser> getMessageParser() {
+        return INSTANCE.provider.getMessageParser();
+    }
+
+    public static Supplier<IConfigEvent.ConfigConfig> getConfigConfiguration() {
+        return INSTANCE.provider.getConfigConfiguration();
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/CrashReportCallables.java

@@ -0,0 +1,32 @@
+package net.minecraftforge.fml;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class CrashReportCallables {
+    private static final List<ISystemReportExtender> crashCallables = Collections.synchronizedList(new ArrayList<>());
+
+    public static void registerCrashCallable(ISystemReportExtender callable)
+    {
+        crashCallables.add(callable);
+    }
+
+    public static void registerCrashCallable(String headerName, Supplier<String> reportGenerator) {
+        registerCrashCallable(new ISystemReportExtender() {
+            @Override
+            public String getLabel() {
+                return headerName;
+            }
+            @Override
+            public String get() {
+                return reportGenerator.get();
+            }
+        });
+    }
+
+    public static List<ISystemReportExtender> allCrashCallables() {
+        return List.copyOf(crashCallables);
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/DeferredWorkQueue.java

@@ -0,0 +1,101 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import static net.minecraftforge.fml.Logging.LOADING;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import com.google.common.base.Stopwatch;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * Utility for running code on the main launch thread at the next available
+ * opportunity. There is no guaranteed order that work from various mods will be
+ * run, but your own work will be run sequentially.
+ * <p>
+ * <strong>Use of this class after startup is not possible.</strong> At that
+ * point, {@code ReentrantBlockableEventLoop} should be used instead.
+ * <p>
+ * Exceptions from tasks will be handled gracefully, causing a mod loading
+ * error. Tasks that take egregiously long times to run will be logged.
+ */
+public class DeferredWorkQueue
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    private static final Map<ModLoadingStage, DeferredWorkQueue> workQueues = new HashMap<>();
+
+    private final ConcurrentLinkedDeque<TaskInfo> tasks = new ConcurrentLinkedDeque<>();
+    private final ModLoadingStage modLoadingStage;
+
+    public DeferredWorkQueue(ModLoadingStage modLoadingStage) {
+        this.modLoadingStage = modLoadingStage;
+        workQueues.put(modLoadingStage, this);
+    }
+
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    public static Optional<DeferredWorkQueue> lookup(Optional<ModLoadingStage> parallelClass) {
+        return Optional.ofNullable(workQueues.get(parallelClass.orElse(null)));
+    }
+
+    public void runTasks() {
+        if (tasks.isEmpty()) return;
+        LOGGER.debug(LOADING, "Dispatching synchronous work for work queue {}: {} jobs", modLoadingStage, tasks.size());
+        Stopwatch timer = Stopwatch.createStarted();
+        tasks.forEach(t->makeRunnable(t, Runnable::run));
+        timer.stop();
+        LOGGER.debug(LOADING, "Synchronous work queue completed in {}", timer);
+    }
+
+    private static void makeRunnable(TaskInfo ti, Executor executor) {
+        executor.execute(() -> {
+            Stopwatch timer = Stopwatch.createStarted();
+            ModLoadingContext.get().setActiveContainer(ti.owner);
+            try {
+                ti.task.run();
+            } finally {
+                ModLoadingContext.get().setActiveContainer(null);
+            }
+            timer.stop();
+            if (timer.elapsed(TimeUnit.SECONDS) >= 1) {
+                LOGGER.warn(LOADING, "Mod '{}' took {} to run a deferred task.", ti.owner.getModId(), timer);
+            }
+        });
+    }
+
+    public CompletableFuture<Void> enqueueWork(final ModContainer modInfo, final Runnable work) {
+        return CompletableFuture.runAsync(work, r->tasks.add(new TaskInfo(modInfo, r)));
+    }
+
+    public <T> CompletableFuture<T> enqueueWork(final ModContainer modInfo, final Supplier<T> work) {
+        return CompletableFuture.supplyAsync(work, r->tasks.add(new TaskInfo(modInfo, r)));
+    }
+
+    record TaskInfo(ModContainer owner, Runnable task) {}
+}

fmlcore/src/main/java/net/minecraftforge/fml/DistExecutor.java

@@ -0,0 +1,276 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.fml.loading.FMLEnvironment;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.Serializable;
+import java.lang.invoke.SerializedLambda;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Objects;
+import java.util.concurrent.Callable;
+import java.util.function.Supplier;
+
+/**
+ * Use to execute code conditionally based on sidedness.
+ * <ul>
+ * <li>When you want to call something on one side and return a result {@link #safeCallWhenOn(Dist, Supplier)}</li>
+ * <li>When you want to call one thing on one side, another thing on the other and return a result {@link #safeRunForDist(Supplier, Supplier)}</li>
+ * <li>When you want to run something on one side {@link #safeRunWhenOn(Dist, Supplier)}</li>
+ * </ul>
+ */
+public final class DistExecutor
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private DistExecutor() {}
+
+    /**
+     * Run the callable in the supplier only on the specified {@link Dist}.
+     * This method is NOT sided-safe and special care needs to be taken in code using this method that implicit class
+     * loading is not triggered by the Callable.
+     *
+     * This method can cause unexpected ClassNotFound exceptions.
+     *
+     * Use {@link #safeCallWhenOn(Dist, Supplier)} where possible.
+     *
+     * @param dist The dist to run on
+     * @param toRun A supplier of the callable to run (Supplier wrapper to ensure classloading only on the appropriate dist)
+     * @param <T> The return type from the callable
+     * @return The callable's result
+     * @deprecated use {@link #safeCallWhenOn(Dist, Supplier)} instead. This remains for advanced use cases.
+     */
+    @Deprecated
+    public static <T> T callWhenOn(Dist dist, Supplier<Callable<T>> toRun) {
+        return unsafeCallWhenOn(dist, toRun);
+    }
+
+    public static <T> T unsafeCallWhenOn(Dist dist, Supplier<Callable<T>> toRun) {
+        if (dist == FMLEnvironment.dist) {
+            try
+            {
+                return toRun.get().call();
+            }
+            catch (Exception e)
+            {
+                throw new RuntimeException(e);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Call the SafeCallable when on the correct {@link Dist}.
+     *
+     * <strong>The lambda supplied here is required to be a method reference to a method defined in
+     * another class, otherwise an invalid SafeReferent error will be thrown</strong>
+     * @param dist the dist which this will run on
+     * @param toRun the SafeCallable to run and return the result from
+     * @param <T> The type of the SafeCallable
+     * @return the result of the SafeCallable or null if on the wrong side
+     */
+    public static <T> T safeCallWhenOn(Dist dist, Supplier<SafeCallable<T>> toRun) {
+        validateSafeReferent(toRun);
+        return callWhenOn(dist, toRun::get);
+    }
+
+    /**
+     * Runs the supplied Runnable on the speicified side. Same warnings apply as {@link #callWhenOn(Dist, Supplier)}.
+     *
+     * This method can cause unexpected ClassNotFound exceptions.
+     *
+     * @see #callWhenOn(Dist, Supplier)
+     * @param dist Dist to run this code on
+     * @param toRun The code to run
+     * @deprecated use {@link #safeRunWhenOn(Dist, Supplier)} where possible. Advanced uses only.
+     */
+    @Deprecated
+    public static void runWhenOn(Dist dist, Supplier<Runnable> toRun) {
+        unsafeRunWhenOn(dist, toRun);
+    }
+    /**
+     * Runs the supplied Runnable on the speicified side. Same warnings apply as {@link #unsafeCallWhenOn(Dist, Supplier)}.
+     *
+     * This method can cause unexpected ClassNotFoundException problems in common scenarios. Understand the pitfalls of
+     * the way the class verifier works to load classes before using this.
+     *
+     * Use {@link #safeRunWhenOn(Dist, Supplier)} if you can.
+     *
+     * @see #unsafeCallWhenOn(Dist, Supplier)
+     * @param dist Dist to run this code on
+     * @param toRun The code to run
+     */
+    public static void unsafeRunWhenOn(Dist dist, Supplier<Runnable> toRun) {
+        if (dist == FMLEnvironment.dist) {
+            toRun.get().run();
+        }
+    }
+
+    /**
+     * Call the supplied SafeRunnable when on the correct Dist.
+     * @param dist The dist to run on
+     * @param toRun The code to run
+     */
+    public static void safeRunWhenOn(Dist dist, Supplier<SafeRunnable> toRun) {
+        validateSafeReferent(toRun);
+        if (dist == FMLEnvironment.dist)  {
+            toRun.get().run();
+        }
+    }
+    /**
+     * Executes one of the two suppliers, based on which side is active.
+     *
+     * <p>
+     *     Example (replacement for old SidedProxy):<br/>
+     * {@code Proxy p = DistExecutor.runForDist(()->ClientProxy::new, ()->ServerProxy::new);}
+     *
+     * NOTE: the double supplier is required to avoid classloading the secondary target.
+     *
+     * @param clientTarget The supplier supplier to run when on the {@link Dist#CLIENT}
+     * @param serverTarget The supplier supplier to run when on the {@link Dist#DEDICATED_SERVER}
+     * @param <T> The common type to return
+     * @return The returned instance
+     * @deprecated Use {@link #safeRunForDist(Supplier, Supplier)}
+     */
+    @Deprecated
+    public static <T> T runForDist(Supplier<Supplier<T>> clientTarget, Supplier<Supplier<T>> serverTarget) {
+        return unsafeRunForDist(clientTarget, serverTarget);
+    }
+
+    /**
+     * Unsafe version of {@link #safeRunForDist(Supplier, Supplier)}. Use only when you know what you're doing
+     * and understand why the verifier can cause unexpected ClassNotFoundException crashes even when code is apparently
+     * not sided. Ensure you test both sides fully to be confident in using this.
+     *
+     * @param clientTarget The supplier supplier to run when on the {@link Dist#CLIENT}
+     * @param serverTarget The supplier supplier to run when on the {@link Dist#DEDICATED_SERVER}
+     * @param <T> The common type to return
+     * @return The returned instance
+     */
+    public static <T> T unsafeRunForDist(Supplier<Supplier<T>> clientTarget, Supplier<Supplier<T>> serverTarget) {
+        switch (FMLEnvironment.dist)
+        {
+            case CLIENT:
+                return clientTarget.get().get();
+            case DEDICATED_SERVER:
+                return serverTarget.get().get();
+            default:
+                throw new IllegalArgumentException("UNSIDED?");
+        }
+    }
+    /**
+     * Executes one of the two suppliers, based on which side is active.
+     *
+     * <p>
+     *     Example (replacement for old SidedProxy):<br/>
+     * {@code Proxy p = DistExecutor.safeRunForDist(()->ClientProxy::new, ()->ServerProxy::new);}
+     *
+     * NOTE: the double supplier is required to avoid classloading the secondary target.
+     *
+     * @param clientTarget The supplier supplier to run when on the {@link Dist#CLIENT}
+     * @param serverTarget The supplier supplier to run when on the {@link Dist#DEDICATED_SERVER}
+     * @param <T> The common type to return
+     * @return The returned instance
+     */
+    public static <T> T safeRunForDist(Supplier<SafeSupplier<T>> clientTarget, Supplier<SafeSupplier<T>> serverTarget) {
+        validateSafeReferent(clientTarget);
+        validateSafeReferent(serverTarget);
+        switch (FMLEnvironment.dist)
+        {
+            case CLIENT:
+                return clientTarget.get().get();
+            case DEDICATED_SERVER:
+                return serverTarget.get().get();
+            default:
+                throw new IllegalArgumentException("UNSIDED?");
+        }
+    }
+
+    /**
+     * A safe referent. This will assert that it is being called via a separated class method reference. This will
+     * avoid the common pitfalls of {@link #callWhenOn(Dist, Supplier)} above.
+     *
+     * SafeReferents assert that they are defined as a separate method outside the scope of the calling class.
+     *
+     * <strong>Implementations need to be defined in a separate class to the referring site, with appropriate
+     * visibility to be accessible at the callsite (generally, avoid private methods).</strong>
+     *
+     * <p>
+     * Valid:<br/>
+     *
+     * {@code DistExecutor.safeCallWhenOn(Dist.CLIENT, ()->AnotherClass::clientOnlyMethod);}
+     *
+     * <p>
+     * Invalid:<br/>
+     *
+     * {@code DistExecutor.safeCallWhenOn(Dist.CLIENT, ()->()->Minecraft.getInstance().world);}
+     */
+    public interface SafeReferent {}
+
+    /**
+     * SafeCallable version of {@link SafeReferent}.
+     * @see SafeReferent
+     * @param <T> The return type of the Callable
+     */
+    public interface SafeCallable<T> extends SafeReferent, Callable<T>, Serializable {}
+
+    /**
+     * SafeSupplier version of {@link SafeReferent}
+     * @param <T> The return type of the Supplier
+     */
+    public interface SafeSupplier<T> extends SafeReferent, Supplier<T>, Serializable {}
+
+    /**
+     * SafeRunnable version of {@link SafeReferent}
+     */
+    public interface SafeRunnable extends SafeReferent, Runnable, Serializable {}
+
+    private static final void validateSafeReferent(Supplier<? extends SafeReferent> safeReferentSupplier) {
+        if (FMLEnvironment.production) return;
+        final SafeReferent setter;
+        try {
+            setter = safeReferentSupplier.get();
+        } catch (Exception e) {
+            // Typically a class cast exception, just return out, expected.
+            return;
+        }
+
+        for (Class<?> cl = setter.getClass(); cl != null; cl = cl.getSuperclass()) {
+            try {
+                Method m = cl.getDeclaredMethod("writeReplace");
+                m.setAccessible(true);
+                Object replacement = m.invoke(setter);
+                if (!(replacement instanceof SerializedLambda))
+                    break;// custom interface implementation
+                SerializedLambda l = (SerializedLambda) replacement;
+                if (Objects.equals(l.getCapturingClass(), l.getImplClass())) {
+                    LOGGER.fatal("Detected unsafe referent usage, please view the code at {}",Thread.currentThread().getStackTrace()[3]);
+                    throw new RuntimeException("Unsafe Referent usage found in safe referent method");
+                }
+            } catch (NoSuchMethodException e) {
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                break;
+            }
+        }
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/I18NParser.java

@@ -0,0 +1,6 @@
+package net.minecraftforge.fml;
+
+public interface I18NParser {
+    String parseMessage(String i18nMessage, Object... args);
+    String stripControlCodes(String toStrip);
+}

fmlcore/src/main/java/net/minecraftforge/fml/IBindingsProvider.java

@@ -0,0 +1,12 @@
+package net.minecraftforge.fml;
+
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.config.IConfigEvent;
+
+import java.util.function.Supplier;
+
+public interface IBindingsProvider {
+    Supplier<IEventBus> getForgeBusSupplier();
+    Supplier<I18NParser> getMessageParser();
+    Supplier<IConfigEvent.ConfigConfig> getConfigConfiguration();
+}

fmlcore/src/main/java/net/minecraftforge/fml/IExtensionPoint.java

@@ -0,0 +1,62 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import java.util.function.BiPredicate;
+import java.util.function.Supplier;
+
+public interface IExtensionPoint<T extends Record>
+{
+    /**
+     * Compatibility display test for the mod.
+     * Used for displaying compatibility with remote servers with the same mod, and on disk saves.
+     *
+     * The supplier provides my "local" version for sending across the impl or writing to disk
+     * The predicate tests the version from a remote instance or save for acceptability (Boolean is true for impl, false for local save)
+     * and returns true if the version is compatible.
+     *
+     * <p>Return {@code net.minecraftforge.impl.impl.FMLNetworkConstants#IGNORESERVERONLY} in the supplier, if you wish to be ignored
+     * as a server side only mod.</p>
+     * <p>Return true in the predicate for all values of the input string (when impl boolean is true) if you are client side,
+     * and don't care about matching any potential server version.</p>
+     *
+     * <p>
+     * Examples: A server only mod
+     * </p>
+     * <pre>{@code
+     *     registerExtensionPoint(DISPLAYTEST, ()->Pair.of(
+     *      ()->FMLNetworkConstants.IGNORESERVERONLY, // ignore me, I'm a server only mod
+     *      (s,b)->true // i accept anything from the server or the save, if I'm asked
+     *     )
+     * }</pre>
+     *
+     * <p>
+     * Examples: A client only mod
+     * </p>
+     * <pre>{@code
+     *     registerExtensionPoint(DISPLAYTEST, ()->Pair.of(
+     *      ()->"anything. i don't care", // if i'm actually on the server, this string is sent but i'm a client only mod, so it won't be
+     *      (remoteversionstring,networkbool)->networkbool // i accept anything from the server, by returning true if it's asking about the server
+     *     )
+     * }</pre>
+     *
+     */
+    record DisplayTest(Supplier<String> suppliedVersion, BiPredicate<String, Boolean> remoteVersionTest) implements IExtensionPoint<DisplayTest> {}
+}

fmlcore/src/main/java/net/minecraftforge/fml/IModLoadingState.java

@@ -0,0 +1,25 @@
+package net.minecraftforge.fml;
+
+import net.minecraftforge.eventbus.api.Event;
+import net.minecraftforge.fml.event.IModBusEvent;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public interface IModLoadingState {
+    String name();
+    String previous();
+    ModLoadingPhase phase();
+    Function<ModList, String> message();
+    Optional<Consumer<ModList>> inlineRunnable();
+
+    default <T extends Event & IModBusEvent> Optional<CompletableFuture<List<Throwable>>> buildTransition(final Executor syncExecutor, final Executor parallelExecutor) {
+        return buildTransition(syncExecutor, parallelExecutor, e->CompletableFuture.runAsync(()->{}, e), e->CompletableFuture.runAsync(()->{}, e));
+    }
+
+    <T extends Event & IModBusEvent> Optional<CompletableFuture<List<Throwable>>> buildTransition(Executor syncExecutor, Executor parallelExecutor, Function<Executor, CompletableFuture<Void>> preSyncTask, Function<Executor, CompletableFuture<Void>> postSyncTask);
+}

fmlcore/src/main/java/net/minecraftforge/fml/IModStateProvider.java

@@ -0,0 +1,7 @@
+package net.minecraftforge.fml;
+
+import java.util.List;
+
+public interface IModStateProvider {
+    List<IModLoadingState> getAllStates();
+}

fmlcore/src/main/java/net/minecraftforge/fml/IModStateTransition.java

@@ -0,0 +1,87 @@
+package net.minecraftforge.fml;
+
+import net.minecraftforge.eventbus.api.Event;
+import net.minecraftforge.fml.event.IModBusEvent;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+@SuppressWarnings("unchecked")
+public interface IModStateTransition {
+    static IModStateTransition buildNoopTransition() {
+        return new NoopTransition();
+    }
+
+    default <T extends Event & IModBusEvent> CompletableFuture<List<Throwable>> build(Executor syncExecutor, Executor parallelExecutor, Function<Executor, CompletableFuture<Void>> preSyncTask, Function<Executor, CompletableFuture<Void>> postSyncTask) {
+        List<CompletableFuture<List<Throwable>>> cfs = new ArrayList<>();
+        this.eventFunctionStream().get()
+                .map(f->(EventGenerator<T>)f)
+                .reduce((head, tail)-> addCompletableFutureTaskForModDispatch(syncExecutor, parallelExecutor, cfs, head, ModLoadingStage::currentState, tail))
+                .ifPresent(last-> addCompletableFutureTaskForModDispatch(syncExecutor, parallelExecutor, cfs, last, nextModLoadingStage(), null));
+        final CompletableFuture<Void> preSyncTaskCF = preSyncTask.apply(syncExecutor);
+        final CompletableFuture<List<Throwable>> eventDispatchCF = ModList.gather(cfs).thenCompose(ModList::completableFutureFromExceptionList);
+        final CompletableFuture<List<Throwable>> postEventDispatchCF = preSyncTaskCF.thenComposeAsync(n -> eventDispatchCF, parallelExecutor).thenApply(r -> {
+            postSyncTask.apply(syncExecutor);
+            return r;
+        });
+        return this.finalActivityGenerator().apply(syncExecutor, postEventDispatchCF);
+    }
+
+    default BiFunction<ModLoadingStage, Throwable, ModLoadingStage> nextModLoadingStage() {
+        return ModLoadingStage::nextState;
+    }
+
+    private <T extends Event & IModBusEvent> EventGenerator<T> addCompletableFutureTaskForModDispatch(final Executor syncExecutor, final Executor parallelExecutor, final List<CompletableFuture<List<Throwable>>> completeableFutures, final EventGenerator<T> eventGenerator, BiFunction<ModLoadingStage, Throwable, ModLoadingStage> nextState, final EventGenerator<T> nextGenerator) {
+        completeableFutures.add(((BiFunction<Executor, EventGenerator<T>, CompletableFuture<List<Throwable>>>)preDispatchHook()).apply(threadSelector().apply(syncExecutor, parallelExecutor), eventGenerator));
+        completeableFutures.add(ModList.get().futureVisitor(eventGenerator, nextState).apply(threadSelector().apply(syncExecutor, parallelExecutor)));
+        completeableFutures.add(((BiFunction<Executor, EventGenerator<T>, CompletableFuture<List<Throwable>>>)postDispatchHook()).apply(threadSelector().apply(syncExecutor, parallelExecutor), eventGenerator));
+        return nextGenerator;
+    }
+
+    Supplier<Stream<EventGenerator<?>>> eventFunctionStream();
+    ThreadSelector threadSelector();
+    BiFunction<Executor, CompletableFuture<List<Throwable>>, CompletableFuture<List<Throwable>>> finalActivityGenerator();
+    BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<List<Throwable>>> preDispatchHook();
+    BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<List<Throwable>>> postDispatchHook();
+
+    interface EventGenerator<T extends Event & IModBusEvent> extends Function<ModContainer, T> {
+        static <FN extends Event & IModBusEvent> EventGenerator<FN> fromFunction(Function<ModContainer, FN> fn) {
+            return fn::apply;
+        }
+    }
+}
+
+record NoopTransition() implements IModStateTransition {
+
+    @Override
+    public Supplier<Stream<EventGenerator<?>>> eventFunctionStream() {
+        return Stream::of;
+    }
+
+    @Override
+    public ThreadSelector threadSelector() {
+        return ThreadSelector.SYNC;
+    }
+
+    @Override
+    public BiFunction<Executor, CompletableFuture<List<Throwable>>, CompletableFuture<List<Throwable>>> finalActivityGenerator() {
+        return (e, t) -> t.thenApplyAsync(Function.identity(), e);
+    }
+
+    @Override
+    public BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<List<Throwable>>> preDispatchHook() {
+        return (t, f)-> CompletableFuture.completedFuture(Collections.emptyList());
+    }
+
+    @Override
+    public BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<List<Throwable>>> postDispatchHook() {
+        return (t, f)-> CompletableFuture.completedFuture(Collections.emptyList());
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ISystemReportExtender.java

@@ -0,0 +1,27 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import java.util.function.Supplier;
+
+public interface ISystemReportExtender extends Supplier<String>
+{
+    String getLabel();
+}

fmlcore/src/main/java/net/minecraftforge/fml/InterModComms.java

@@ -0,0 +1,178 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+
+import java.util.Iterator;
+import java.util.Spliterator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+public class InterModComms
+{
+    public record IMCMessage(String senderModId, String modId, String method, Supplier<?> messageSupplier) {
+
+        /**
+         * Deprecated: use {@link #senderModId()}
+         * @return The modid of the sender. This is supplied by the caller, or by the active mod container context.
+         * Consider it unreliable.
+         */
+        @Deprecated
+        public final String getSenderModId() {
+            return this.senderModId;
+        }
+
+        /**
+         * Deprecated: use {@link #modId()}
+         * @return The modid being sent to.
+         */
+        @Deprecated
+        public final String getModId() {
+            return this.modId;
+        }
+
+        /**
+         * Deprecated: use {@link #method()}
+         * @return The method being sent to.
+         */
+        @Deprecated
+        public final String getMethod() {
+            return this.method;
+        }
+
+        /**
+         * @param <T> The type of the message.
+         * @return A {@link Supplier} of the message.
+         * Use {@link #messageSupplier()}
+         */
+        @SuppressWarnings("unchecked")
+        @Deprecated
+        public final <T> Supplier<T> getMessageSupplier() {
+            return (Supplier<T>) this.messageSupplier;
+        }
+    }
+
+    private static ConcurrentMap<String, ConcurrentLinkedQueue<IMCMessage>> containerQueues = new ConcurrentHashMap<>();
+
+    /**
+     * Send IMC to remote. Sender will default to the active modcontainer, or minecraft if not.
+     *
+     * @param modId the mod id to send to
+     * @param method the method name to send
+     * @param thing the thing associated with the method name
+     * @return true if the message was enqueued for sending (the target modid is loaded)
+     */
+    public static boolean sendTo(final String modId, final String method, final Supplier<?> thing) {
+        if (!ModList.get().isLoaded(modId)) return false;
+        containerQueues.computeIfAbsent(modId, k->new ConcurrentLinkedQueue<>()).add(new IMCMessage(ModLoadingContext.get().getActiveContainer().getModId(), modId, method, thing));
+        return true;
+    }
+
+    /**
+     * Send IMC to remote.
+     *
+     * @param senderModId the mod id you are sending from
+     * @param modId the mod id to send to
+     * @param method the method name to send
+     * @param thing the thing associated with the method name
+     * @return true if the message was enqueued for sending (the target modid is loaded)
+     */
+    public static boolean sendTo(final String senderModId, final String modId, final String method, final Supplier<?> thing) {
+        if (!ModList.get().isLoaded(modId)) return false;
+        containerQueues.computeIfAbsent(modId, k->new ConcurrentLinkedQueue<>()).add(new IMCMessage(senderModId, modId, method, thing));
+        return true;
+    }
+
+    /**
+     * Retrieve pending messages for your modid. Use the predicate to filter the method name.
+     *
+     * @param modId the modid you are querying for
+     * @param methodMatcher a predicate for the method you are interested in
+     * @return All messages passing the supplied method predicate
+     */
+    public static Stream<IMCMessage> getMessages(final String modId, final Predicate<String> methodMatcher) {
+        ConcurrentLinkedQueue<IMCMessage> queue = containerQueues.get(modId);
+        if (queue == null) return Stream.empty();
+        return StreamSupport.stream(new QueueFilteringSpliterator(queue, methodMatcher), false);
+    }
+
+    /**
+     * Retrieve all message for your modid.
+     *
+     * @param modId the modid you are querying for
+     * @return All messages
+     */
+    public static Stream<IMCMessage> getMessages(final String modId) {
+        return getMessages(modId, s->Boolean.TRUE);
+    }
+
+    private static class QueueFilteringSpliterator implements Spliterator<IMCMessage>
+    {
+        private final ConcurrentLinkedQueue<IMCMessage> queue;
+        private final Predicate<String> methodFilter;
+        private final Iterator<IMCMessage> iterator;
+
+        public QueueFilteringSpliterator(final ConcurrentLinkedQueue<IMCMessage> queue, final Predicate<String> methodFilter) {
+            this.queue = queue;
+            this.iterator = queue.iterator();
+            this.methodFilter = methodFilter;
+        }
+
+        @Override
+        public int characteristics() {
+            return Spliterator.CONCURRENT | Spliterator.NONNULL | Spliterator.ORDERED;
+        }
+
+        @Override
+        public long estimateSize() {
+            return queue.size();
+        }
+
+        @Override
+        public boolean tryAdvance(final Consumer<? super IMCMessage> action)
+        {
+            IMCMessage next;
+            do
+            {
+                if (!iterator.hasNext())
+                {
+                    return false;
+                }
+                next = this.iterator.next();
+            }
+            while (!methodFilter.test(next.method));
+            action.accept(next);
+            this.iterator.remove();
+            return true;
+        }
+
+        @Override
+        public Spliterator<IMCMessage> trySplit() {
+            return null;
+        }
+
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/LoadingFailedException.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,6 +20,7 @@
 package net.minecraftforge.fml;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class LoadingFailedException extends RuntimeException {
     private final List<ModLoadingException> loadingExceptions;
@@ -31,4 +32,9 @@ public class LoadingFailedException extends RuntimeException {
     public List<ModLoadingException> getErrors() {
         return this.loadingExceptions;
     }
+
+    @Override
+    public String getMessage() {
+        return "Loading errors encountered: " + this.loadingExceptions.stream().map(ModLoadingException::getMessage).collect(Collectors.joining(",\n\t", "[\n\t", "\n]"));
+    }
 }

fmlcore/src/main/java/net/minecraftforge/fml/Logging.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,12 +19,8 @@
 
 package net.minecraftforge.fml;
 
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.Marker;
 import org.apache.logging.log4j.MarkerManager;
-import org.apache.logging.log4j.core.config.Configurator;
 
 public class Logging
 {
@@ -35,6 +31,7 @@ public class Logging
     public static final Marker SPLASH = MarkerManager.getMarker("SPLASH");
     public static final Marker CAPABILITIES = MarkerManager.getMarker("CAPABILITIES");
     public static final Marker MODELLOADING = MarkerManager.getMarker("MODELLOADING");
+    public static final Marker FORGEMOD = MarkerManager.getMarker("FORGEMOD").addParents(LOADING);
 
     // --log CORE:+DEBUG,SCAN:-OFF
     // forge log debug 5

fmlcore/src/main/java/net/minecraftforge/fml/LogicalSide.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

fmlcore/src/main/java/net/minecraftforge/fml/ModContainer.java

@@ -0,0 +1,170 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import net.minecraftforge.eventbus.api.Event;
+import net.minecraftforge.fml.config.IConfigEvent;
+import net.minecraftforge.fml.config.ModConfig;
+import net.minecraftforge.fml.event.IModBusEvent;
+import net.minecraftforge.forgespi.language.IModInfo;
+
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * The container that wraps around mods in the system.
+ * <p>
+ * The philosophy is that individual mod implementation technologies should not
+ * impact the actual loading and management of mod code. This class provides
+ * a mechanism by which we can wrap actual mod code so that the loader and other
+ * facilities can treat mods at arms length.
+ * </p>
+ *
+ * @author cpw
+ *
+ */
+
+public abstract class ModContainer
+{
+    protected final String modId;
+    protected final String namespace;
+    protected final IModInfo modInfo;
+    protected ModLoadingStage modLoadingStage;
+    protected Supplier<?> contextExtension;
+    protected final Map<ModLoadingStage, Runnable> activityMap = new HashMap<>();
+    protected final Map<Class<? extends IExtensionPoint<?>>, Supplier<?>> extensionPoints = new IdentityHashMap<>();
+    protected final EnumMap<ModConfig.Type, ModConfig> configs = new EnumMap<>(ModConfig.Type.class);
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    protected Optional<Consumer<IConfigEvent>> configHandler = Optional.empty();
+
+    public ModContainer(IModInfo info)
+    {
+        this.modId = info.getModId();
+        // TODO: Currently not reading namespace from configuration..
+        this.namespace = this.modId;
+        this.modInfo = info;
+        this.modLoadingStage = ModLoadingStage.CONSTRUCT;
+        // default displaytest extension checks for version string match
+        registerExtensionPoint(IExtensionPoint.DisplayTest.class, () -> new IExtensionPoint.DisplayTest(()->this.modInfo.getVersion().toString(),
+                (incoming, isNetwork)->Objects.equals(incoming, this.modInfo.getVersion().toString())));
+    }
+
+    /**
+     * Errored container state, used for filtering. Does nothing.
+     */
+    ModContainer()
+    {
+        this.modLoadingStage = ModLoadingStage.ERROR;
+        modId = "BROKEN";
+        namespace = "BROKEN";
+        modInfo = null;
+    }
+    /**
+     * @return the modid for this mod
+     */
+    public final String getModId()
+    {
+        return modId;
+    }
+
+    /**
+     * @return the resource prefix for the mod
+     */
+    public final String getNamespace()
+    {
+        return namespace;
+    }
+
+    /**
+     * @return The current loading stage for this mod
+     */
+    public ModLoadingStage getCurrentState()
+    {
+        return modLoadingStage;
+    }
+
+    public static <T extends Event & IModBusEvent> CompletableFuture<Void> buildTransitionHandler(
+            final ModContainer target,
+            final IModStateTransition.EventGenerator<T> eventGenerator,
+            final BiFunction<ModLoadingStage, Throwable, ModLoadingStage> stateChangeHandler,
+            final Executor executor) {
+        return CompletableFuture
+                .runAsync(() -> {
+                    ModLoadingContext.get().setActiveContainer(target);
+                    target.activityMap.getOrDefault(target.modLoadingStage, ()->{}).run();
+                    target.acceptEvent(eventGenerator.apply(target));
+                }, executor)
+                .whenComplete((mc, exception) -> {
+                    target.modLoadingStage = stateChangeHandler.apply(target.modLoadingStage, exception);
+                    ModLoadingContext.get().setActiveContainer(null);
+                });
+    }
+
+    public IModInfo getModInfo()
+    {
+        return modInfo;
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends Record> Optional<T> getCustomExtension(Class<? extends IExtensionPoint<T>> point) {
+        return Optional.ofNullable((T)extensionPoints.getOrDefault(point,()-> null).get());
+    }
+
+    public <T extends Record & IExtensionPoint<T>> void registerExtensionPoint(Class<? extends IExtensionPoint<T>> point, Supplier<T> extension)
+    {
+        extensionPoints.put(point, extension);
+    }
+
+    public void addConfig(final ModConfig modConfig) {
+       configs.put(modConfig.getType(), modConfig);
+    }
+
+    public void dispatchConfigEvent(IConfigEvent event) {
+        configHandler.ifPresent(configHandler->configHandler.accept(event));
+    }
+
+    /**
+     * Does this mod match the supplied mod?
+     *
+     * @param mod to compare
+     * @return if the mod matches
+     */
+    public abstract boolean matches(Object mod);
+
+    /**
+     * @return the mod object instance
+     */
+    public abstract Object getMod();
+
+    /**
+     * Accept an arbitrary event for processing by the mod. Probably posted to an event bus in the lower level container.
+     * @param e Event to accept
+     */
+    protected <T extends Event & IModBusEvent> void acceptEvent(T e) {}
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModList.java

@@ -0,0 +1,244 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import net.minecraftforge.eventbus.api.Event;
+import net.minecraftforge.fml.event.IModBusEvent;
+import net.minecraftforge.forgespi.language.IModFileInfo;
+import net.minecraftforge.forgespi.language.IModInfo;
+import net.minecraftforge.forgespi.language.ModFileScanData;
+import net.minecraftforge.fml.loading.moddiscovery.ModFile;
+import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
+import net.minecraftforge.fml.loading.moddiscovery.ModInfo;
+import net.minecraftforge.forgespi.locating.IModFile;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ForkJoinWorkerThread;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Master list of all mods - game-side version. This is classloaded in the game scope and
+ * can dispatch game level events as a result.
+ */
+public class ModList
+{
+    private static Logger LOGGER = LogManager.getLogger();
+    private static ModList INSTANCE;
+    private final List<IModFileInfo> modFiles;
+    private final List<IModInfo> sortedList;
+    private final Map<String, ModFileInfo> fileById;
+    private List<ModContainer> mods;
+    private Map<String, ModContainer> indexedMods;
+    private List<ModFileScanData> modFileScanData;
+
+    private ModList(final List<ModFile> modFiles, final List<ModInfo> sortedList)
+    {
+        this.modFiles = modFiles.stream().map(ModFile::getModFileInfo).map(ModFileInfo.class::cast).collect(Collectors.toList());
+        this.sortedList = sortedList.stream().
+                map(ModInfo.class::cast).
+                collect(Collectors.toList());
+        this.fileById = this.modFiles.stream().map(IModFileInfo::getMods).flatMap(Collection::stream).
+                map(ModInfo.class::cast).
+                collect(Collectors.toMap(ModInfo::getModId, ModInfo::getOwningFile));
+        CrashReportCallables.registerCrashCallable("Mod List", this::crashReport);
+    }
+
+    private String getModContainerState(String modId) {
+        return getModContainerById(modId).map(ModContainer::getCurrentState).map(Object::toString).orElse("NONE");
+    }
+
+    private String fileToLine(IModFile mf) {
+        return String.format("%-50.50s|%-30.30s|%-30.30s|%-20.20s|%-10.10s|Manifest: %s", mf.getFileName(),
+                mf.getModInfos().get(0).getDisplayName(),
+                mf.getModInfos().get(0).getModId(),
+                mf.getModInfos().get(0).getVersion(),
+                getModContainerState(mf.getModInfos().get(0).getModId()),
+                ((ModFileInfo)mf.getModFileInfo()).getCodeSigningFingerprint().orElse("NOSIGNATURE"));
+    }
+    private String crashReport() {
+        return "\n"+applyForEachModFile(this::fileToLine).collect(Collectors.joining("\n\t\t", "\t\t", ""));
+    }
+
+    public static ModList of(List<ModFile> modFiles, List<ModInfo> sortedList)
+    {
+        INSTANCE = new ModList(modFiles, sortedList);
+        return INSTANCE;
+    }
+
+    public static ModList get() {
+        return INSTANCE;
+    }
+
+    private static ForkJoinWorkerThread newForkJoinWorkerThread(ForkJoinPool pool) {
+        ForkJoinWorkerThread thread = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(pool);
+        thread.setName("modloading-worker-" + thread.getPoolIndex());
+        // The default sets it to the SystemClassloader, so copy the current one.
+        thread.setContextClassLoader(Thread.currentThread().getContextClassLoader());
+        return thread;
+    }
+
+    public List<IModFileInfo> getModFiles()
+    {
+        return modFiles;
+    }
+
+    public IModFileInfo getModFileById(String modid)
+    {
+        return this.fileById.get(modid);
+    }
+
+    <T extends Event & IModBusEvent> Function<Executor, CompletableFuture<List<Throwable>>> futureVisitor(
+            final IModStateTransition.EventGenerator<T> eventGenerator,
+            final BiFunction<ModLoadingStage, Throwable, ModLoadingStage> stateChange) {
+        return executor -> gather(
+                this.mods.stream()
+                .map(mod -> ModContainer.buildTransitionHandler(mod, eventGenerator, stateChange, executor))
+                .collect(Collectors.toList()))
+            .thenComposeAsync(ModList::completableFutureFromExceptionList, executor);
+    }
+    static CompletionStage<List<Throwable>> completableFutureFromExceptionList(List<? extends Map.Entry<?, Throwable>> t) {
+        if (t.stream().noneMatch(e->e.getValue()!=null)) {
+            return CompletableFuture.completedFuture(Collections.emptyList());
+        } else {
+            final List<Throwable> throwables = t.stream().filter(e -> e.getValue() != null).map(Map.Entry::getValue).collect(Collectors.toList());
+            CompletableFuture<List<Throwable>> cf = new CompletableFuture<>();
+            final RuntimeException accumulator = new RuntimeException();
+            cf.completeExceptionally(accumulator);
+            throwables.forEach(exception -> {
+                if (exception instanceof CompletionException) {
+                    exception = exception.getCause();
+                }
+                if (exception.getSuppressed().length!=0) {
+                    Arrays.stream(exception.getSuppressed()).forEach(accumulator::addSuppressed);
+                } else {
+                    accumulator.addSuppressed(exception);
+                }
+            });
+            return cf;
+        }
+    }
+
+    static <V> CompletableFuture<List<Map.Entry<V, Throwable>>> gather(List<? extends CompletableFuture<? extends V>> futures) {
+        List<Map.Entry<V, Throwable>> list = new ArrayList<>(futures.size());
+        CompletableFuture<?>[] results = new CompletableFuture[futures.size()];
+        futures.forEach(future -> {
+            int i = list.size();
+            list.add(null);
+            results[i] = future.whenComplete((result, exception) -> list.set(i, new AbstractMap.SimpleImmutableEntry<>(result, exception)));
+        });
+        return CompletableFuture.allOf(results).handle((r, th)->null).thenApply(res -> list);
+    }
+
+    void setLoadedMods(final List<ModContainer> modContainers)
+    {
+        this.mods = modContainers;
+        this.indexedMods = modContainers.stream().collect(Collectors.toMap(ModContainer::getModId, Function.identity()));
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> Optional<T> getModObjectById(String modId)
+    {
+        return getModContainerById(modId).map(ModContainer::getMod).map(o -> (T) o);
+    }
+
+    public Optional<? extends ModContainer> getModContainerById(String modId)
+    {
+        return Optional.ofNullable(this.indexedMods.get(modId));
+    }
+
+    public Optional<? extends ModContainer> getModContainerByObject(Object obj)
+    {
+        return mods.stream().filter(mc -> mc.getMod() == obj).findFirst();
+    }
+
+    public List<IModInfo> getMods()
+    {
+        return this.sortedList;
+    }
+
+    public boolean isLoaded(String modTarget)
+    {
+        return this.indexedMods.containsKey(modTarget);
+    }
+
+    public int size()
+    {
+        return mods.size();
+    }
+
+    public List<ModFileScanData> getAllScanData()
+    {
+        if (modFileScanData == null)
+        {
+            modFileScanData = this.sortedList.stream().
+                    map(IModInfo::getOwningFile).
+                    filter(Objects::nonNull).
+                    map(IModFileInfo::getFile).
+                    distinct().
+                    map(IModFile::getScanResult).
+                    collect(Collectors.toList());
+        }
+        return modFileScanData;
+
+    }
+
+    public void forEachModFile(Consumer<IModFile> fileConsumer)
+    {
+        modFiles.stream().map(IModFileInfo::getFile).forEach(fileConsumer);
+    }
+
+    public <T> Stream<T> applyForEachModFile(Function<IModFile, T> function) {
+        return modFiles.stream().map(IModFileInfo::getFile).map(function);
+    }
+
+    public void forEachModContainer(BiConsumer<String, ModContainer> modContainerConsumer) {
+        indexedMods.forEach(modContainerConsumer);
+    }
+
+    public <T> Stream<T> applyForEachModContainer(Function<ModContainer, T> function) {
+        return indexedMods.values().stream().map(function);
+    }
+
+    private static class UncaughtModLoadingException extends ModLoadingException {
+        public UncaughtModLoadingException(ModLoadingStage stage, Throwable originalException) {
+            super(null, stage, "fml.modloading.uncaughterror", originalException);
+        }
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModLoader.java

@@ -0,0 +1,332 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import com.google.common.collect.ImmutableList;
+import net.minecraftforge.eventbus.api.Event;
+import net.minecraftforge.fml.event.IModBusEvent;
+import net.minecraftforge.fml.loading.FMLLoader;
+import net.minecraftforge.fml.loading.LoadingModList;
+import net.minecraftforge.fml.loading.moddiscovery.InvalidModIdentifier;
+import net.minecraftforge.fml.loading.moddiscovery.ModFile;
+import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
+import net.minecraftforge.fml.loading.progress.StartupMessageManager;
+import net.minecraftforge.forgespi.language.IModInfo;
+import net.minecraftforge.forgespi.language.IModLanguageProvider;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static net.minecraftforge.fml.Logging.CORE;
+import static net.minecraftforge.fml.Logging.LOADING;
+
+/**
+ * Loads mods.
+ *
+ * Dispatch cycle is seen in {@code #loadMods()} and {@code #finishMods()}
+ *
+ * Overall sequence for loadMods is:
+ * <dl>
+ *     <dt>CONSTRUCT</dt>
+ *     <dd>Constructs the mod instance. Mods can typically setup basic environment such as Event listeners
+ *     and Configuration specifications here.</dd>
+ *     <dt>Automated dispatches</dt>
+ *     <dd>Dispatches automated elements : {@code net.minecraftforge.fml.common.Mod.EventBusSubscriber},
+ *     {@code net.minecraftforge.event.RegistryEvent}, {@code net.minecraftforge.common.capabilities.CapabilityInject}
+ *     and others</dd>
+ *     <dt>CONFIG_LOAD</dt>
+ *     <dd>Dispatches ConfigLoadEvent to mods</dd>
+ *     <dt>COMMON_SETUP</dt>
+ *     <dd>Dispatches {@code net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent} to mods</dd>
+ *     <dt>SIDED_SETUP</dt>
+ *     <dd>Dispatches {@code net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent} or
+ *     {@code net.minecraftforge.fml.event.lifecycle.FMLDedicatedServerSetupEvent} to mods</dd>
+ * </dl>
+ *
+ * Overall sequence for finishMods is:
+ * <dl>
+ *     <dt>ENQUEUE_IMC</dt>
+ *     <dd>Dispatches {@code net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent} to mods,
+ *     for enqueuing {@link InterModComms} messages for other mods to receive subsequently</dd>
+ *     <dt>PROCESS_IMC</dt>
+ *     <dd>Dispatches {@code net.minecraftforge.fml.event.lifecycle.InterModProcessEvent} to mods,
+ *     for processing {@link InterModComms} messages received from other mods prior to this event</dd>
+ *     <dt>COMPLETE</dt>
+ *     <dd>Dispatches {@code net.minecraftforge.fml.event.lifecycle.FMLLoadCompleteEvent} to mods,
+ *     and completes the mod loading sequence.</dd>
+ * </dl>
+ */
+public class ModLoader
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static ModLoader INSTANCE;
+    private final LoadingModList loadingModList;
+
+    private final List<ModLoadingException> loadingExceptions;
+    private final List<ModLoadingWarning> loadingWarnings;
+    private final ModStateManager stateManager;
+    private boolean loadingStateValid;
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    private final Optional<Consumer<String>> statusConsumer = StartupMessageManager.modLoaderConsumer();
+    private ModList modList;
+
+    private ModLoader()
+    {
+        INSTANCE = this;
+        this.loadingModList = FMLLoader.getLoadingModList();
+        this.loadingExceptions = FMLLoader.getLoadingModList().getErrors().stream()
+                .flatMap(ModLoadingException::fromEarlyException)
+                .collect(Collectors.toList());
+        this.loadingWarnings = FMLLoader.getLoadingModList().getBrokenFiles().stream()
+                .map(file -> new ModLoadingWarning(null, ModLoadingStage.VALIDATE, InvalidModIdentifier.identifyJarProblem(file.getFilePath()).orElse("fml.modloading.brokenfile"), file.getFileName()))
+                .collect(Collectors.toList());
+        FMLLoader.getLoadingModList().getModFiles().stream()
+                .filter(ModFileInfo::missingLicense) //Search for files with missing licenses
+                .filter(modFileInfo -> modFileInfo.getMods().stream().noneMatch(thisModInfo -> this.loadingExceptions.stream().map(ModLoadingException::getModInfo).anyMatch(otherInfo -> otherInfo == thisModInfo))) //Ignore files where any other mod already encountered an error
+                .map(modFileInfo -> new ModLoadingException(null, ModLoadingStage.VALIDATE, "fml.modloading.missinglicense", null, modFileInfo.getFile()))
+                .forEach(this.loadingExceptions::add);
+        this.stateManager = new ModStateManager();
+        CrashReportCallables.registerCrashCallable("ModLauncher", FMLLoader::getLauncherInfo);
+        CrashReportCallables.registerCrashCallable("ModLauncher launch target", FMLLoader::launcherHandlerName);
+        CrashReportCallables.registerCrashCallable("ModLauncher naming", FMLLoader::getNaming);
+        CrashReportCallables.registerCrashCallable("ModLauncher services", this::computeModLauncherServiceList);
+        CrashReportCallables.registerCrashCallable("FML Language Providers", this::computeLanguageList);
+    }
+
+    private String computeLanguageList() {
+        return "\n"+FMLLoader.getLanguageLoadingProvider().applyForEach(lp->lp.name() +"@"+ lp.getClass().getPackage().getImplementationVersion()).collect(Collectors.joining("\n\t\t", "\t\t", ""));
+    }
+
+    private String computeModLauncherServiceList() {
+        final List<Map<String, String>> mods = FMLLoader.modLauncherModList();
+        return "\n"+mods.stream().map(mod->mod.getOrDefault("file","nofile")+
+                " "+mod.getOrDefault("name", "missing")+
+                " "+mod.getOrDefault("type","NOTYPE")+
+                " "+mod.getOrDefault("description", "")).
+                collect(Collectors.joining("\n\t\t","\t\t",""));
+    }
+
+    public static ModLoader get()
+    {
+        return INSTANCE == null ? INSTANCE = new ModLoader() : INSTANCE;
+    }
+
+    /**
+     * Run on the primary starting thread by ClientModLoader and ServerModLoader
+     * @param syncExecutor An executor to run tasks on the main thread
+     * @param parallelExecutor An executor to run tasks on a parallel loading thread pool
+     * @param periodicTask Optional periodic task to perform on the main thread while other activities run
+     */
+    public void gatherAndInitializeMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
+        loadingStateValid = true;
+        statusConsumer.ifPresent(c->c.accept("Waiting for scan to complete"));
+        FMLLoader.backgroundScanHandler.waitForScanToComplete(periodicTask);
+        statusConsumer.ifPresent(c->c.accept("Loading mods"));
+        final ModList modList = ModList.of(loadingModList.getModFiles().stream().map(ModFileInfo::getFile).toList(),
+                loadingModList.getMods());
+        if (!this.loadingExceptions.isEmpty()) {
+            LOGGER.fatal(CORE, "Error during pre-loading phase", loadingExceptions.get(0));
+            modList.setLoadedMods(Collections.emptyList());
+            loadingStateValid = false;
+            throw new LoadingFailedException(loadingExceptions);
+        }
+        statusConsumer.ifPresent(c->c.accept("Building Mod List"));
+        final List<ModContainer> modContainers = loadingModList.getModFiles().stream()
+                .map(ModFileInfo::getFile)
+                .map(this::buildMods)
+                .<ModContainer>mapMulti(Iterable::forEach)
+                .toList();
+        if (!loadingExceptions.isEmpty()) {
+            LOGGER.fatal(CORE, "Failed to initialize mod containers", loadingExceptions.get(0));
+            modList.setLoadedMods(Collections.emptyList());
+            loadingStateValid = false;
+            throw new LoadingFailedException(loadingExceptions);
+        }
+        modList.setLoadedMods(modContainers);
+        this.modList = modList;
+        statusConsumer.ifPresent(c->c.accept("Dispatching gathering events"));
+        stateManager.getStates(ModLoadingPhase.GATHER).forEach(mls->dispatchAndHandleError(mls, syncExecutor, parallelExecutor, periodicTask));
+        statusConsumer.ifPresent(c->c.accept("Gathering phase complete"));
+    }
+
+    public void loadMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
+        statusConsumer.ifPresent(c->c.accept("Performing load phase"));
+        stateManager.getStates(ModLoadingPhase.LOAD).forEach(mls->dispatchAndHandleError(mls, syncExecutor, parallelExecutor, periodicTask));
+        statusConsumer.ifPresent(c->c.accept("Mod setup complete"));
+    }
+
+    public void finishMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
+        statusConsumer.ifPresent(c->c.accept("Performing completion phase"));
+        stateManager.getStates(ModLoadingPhase.COMPLETE).forEach(mls->dispatchAndHandleError(mls, syncExecutor, parallelExecutor, periodicTask));
+        statusConsumer.ifPresent(c->c.accept(String.format("Mod loading complete - %d mods loaded", this.modList.size())));
+    }
+
+    private void dispatchAndHandleError(IModLoadingState state, ModWorkManager.DrivenExecutor syncExecutor, Executor parallelExecutor, final Runnable ticker) {
+        if (!isLoadingStateValid()) {
+            LOGGER.error("Cowardly refusing to process mod state change request from {}", state);
+            return;
+        }
+        statusConsumer.ifPresent(c->c.accept(state.message().apply(this.modList)));
+        state.inlineRunnable().ifPresent(a->a.accept(this.modList));
+        state.buildTransition(syncExecutor, parallelExecutor).ifPresent(t->waitForTransition(state, syncExecutor, ticker, t));
+    }
+
+    private void dispatchAndHandleError(IModLoadingState state, ModWorkManager.DrivenExecutor syncExecutor, Executor parallelExecutor, final Runnable ticker, Function<Executor, CompletableFuture<Void>> preSyncTask, Function<Executor, CompletableFuture<Void>> postSyncTask) {
+        if (!isLoadingStateValid()) {
+            LOGGER.error("Cowardly refusing to process mod state change request from {}", state);
+            return;
+        }
+        statusConsumer.ifPresent(c->c.accept(state.message().apply(this.modList)));
+        state.inlineRunnable().ifPresent(a->a.accept(this.modList));
+        state.buildTransition(syncExecutor, parallelExecutor, preSyncTask, postSyncTask).ifPresent(t->waitForTransition(state, syncExecutor, ticker, t));
+    }
+
+    private void waitForTransition(final IModLoadingState state, final ModWorkManager.DrivenExecutor syncExecutor, final Runnable ticker, final CompletableFuture<List<Throwable>> transition) {
+        while (!transition.isDone()) {
+            syncExecutor.drive(ticker);
+        }
+        try {
+            transition.join();
+        } catch (CompletionException e) {
+            loadingStateValid = false;
+            Throwable t = e.getCause();
+            final List<Throwable> notModLoading = Arrays.stream(t.getSuppressed())
+                    .filter(obj -> !(obj instanceof ModLoadingException))
+                    .collect(Collectors.toList());
+            if (!notModLoading.isEmpty()) {
+                LOGGER.fatal("Encountered non-modloading exceptions!", e);
+                throw e;
+            }
+
+            final List<ModLoadingException> modLoadingExceptions = Arrays.stream(t.getSuppressed())
+                    .filter(ModLoadingException.class::isInstance)
+                    .map(ModLoadingException.class::cast)
+                    .collect(Collectors.toList());
+            LOGGER.fatal(LOADING,"Failed to complete lifecycle event {}, {} errors found", state.name(), modLoadingExceptions.size());
+            throw new LoadingFailedException(modLoadingExceptions);
+        }
+    }
+
+    private List<ModContainer> buildMods(final ModFile modFile)
+    {
+        final Map<String, IModInfo> modInfoMap = modFile.getModFileInfo().getMods().stream().collect(Collectors.toMap(IModInfo::getModId, Function.identity()));
+
+        LOGGER.trace(LOADING, "ModContainer is {}", ModContainer.class.getClassLoader());
+        final List<ModContainer> containers = modFile.getScanResult().getTargets()
+                .entrySet()
+                .stream()
+                .map(e -> buildModContainerFromTOML(modFile, modInfoMap, e))
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        if (containers.size() != modInfoMap.size()) {
+            LOGGER.fatal(LOADING,"File {} constructed {} mods: {}, but had {} mods specified: {}",
+                    modFile.getFilePath(),
+                    containers.size(), containers.stream().map(c -> c != null ? c.getModId() : "(null)").sorted().collect(Collectors.toList()),
+                    modInfoMap.size(), modInfoMap.values().stream().map(IModInfo::getModId).sorted().collect(Collectors.toList()));
+            loadingExceptions.add(new ModLoadingException(null, ModLoadingStage.CONSTRUCT, "fml.modloading.missingclasses", null, modFile.getFilePath()));
+        }
+        // remove errored mod containers
+        return containers.stream().filter(mc -> mc.modLoadingStage != ModLoadingStage.ERROR).collect(Collectors.toList());
+    }
+
+    private ModContainer buildModContainerFromTOML(final ModFile modFile, final Map<String, IModInfo> modInfoMap, final Map.Entry<String, ? extends IModLanguageProvider.IModLanguageLoader> idToProviderEntry) {
+        try {
+            final String modId = idToProviderEntry.getKey();
+            final IModLanguageProvider.IModLanguageLoader languageLoader = idToProviderEntry.getValue();
+            IModInfo info = Optional.ofNullable(modInfoMap.get(modId)).
+                    // throw a missing metadata error if there is no matching modid in the modInfoMap from the mods.toml file
+                    orElseThrow(()->new ModLoadingException(null, ModLoadingStage.CONSTRUCT, "fml.modloading.missingmetadata", null, modId));
+            return languageLoader.loadMod(info, modFile.getScanResult(), FMLLoader.getGameLayer());
+        } catch (ModLoadingException mle) {
+            // exceptions are caught and added to the error list for later handling
+            loadingExceptions.add(mle);
+            // return an errored container instance here, because we tried and failed building a container.
+            return new ErroredModContainer();
+        }
+    }
+
+    /**
+     * @return If the current mod loading state is valid. Use if you interact with vanilla systems directly during loading
+     * and don't want to cause extraneous crashes due to trying to do things that aren't possible in a "broken load"
+     */
+    public static boolean isLoadingStateValid() {
+        return get().loadingStateValid;
+    }
+
+    public <T extends Event & IModBusEvent> void runEventGenerator(Function<ModContainer, T> generator) {
+        if (!loadingStateValid) {
+            LOGGER.error("Cowardly refusing to send event generator to a broken mod state");
+            return;
+        }
+        ModList.get().forEachModContainer((id, mc) -> mc.acceptEvent(generator.apply(mc)));
+    }
+
+    public <T extends Event & IModBusEvent> void postEvent(T e) {
+        if (!loadingStateValid) {
+            LOGGER.error("Cowardly refusing to send event {} to a broken mod state", e.getClass().getName());
+            return;
+        }
+        ModList.get().forEachModContainer((id, mc) -> mc.acceptEvent(e));
+    }
+
+    public List<ModLoadingWarning> getWarnings()
+    {
+        return ImmutableList.copyOf(this.loadingWarnings);
+    }
+
+    public void addWarning(ModLoadingWarning warning)
+    {
+        this.loadingWarnings.add(warning);
+    }
+
+    private static boolean runningDataGen = false;
+
+    public static boolean isDataGenRunning () {
+        return runningDataGen;
+    }
+
+    private static class ErroredModContainer extends ModContainer {
+        public ErroredModContainer() {
+            super();
+        }
+
+        @Override
+        public boolean matches(final Object mod) {
+            return false;
+        }
+
+        @Override
+        public Object getMod() {
+            return null;
+        }
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingContext.java

@@ -0,0 +1,75 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import net.minecraftforge.fml.config.IConfigSpec;
+import net.minecraftforge.fml.config.ModConfig;
+
+import java.util.function.Supplier;
+
+public class ModLoadingContext
+{
+    private static final ThreadLocal<ModLoadingContext> context = ThreadLocal.withInitial(ModLoadingContext::new);
+    private Object languageExtension;
+    private ModLoadingStage stage;
+
+    public static ModLoadingContext get() {
+        return context.get();
+    }
+
+    private ModContainer activeContainer;
+
+    public void setActiveContainer(final ModContainer container) {
+        this.activeContainer = container;
+        this.languageExtension = container == null ? null : container.contextExtension.get();
+    }
+
+    public ModContainer getActiveContainer() {
+        return activeContainer == null ? ModList.get().getModContainerById("minecraft").orElseThrow(()->new RuntimeException("Where is minecraft???!")) : activeContainer;
+    }
+
+    public String getActiveNamespace() {
+        return activeContainer == null ? "minecraft" : activeContainer.getNamespace();
+    }
+
+    /**
+     * Register an {@link IExtensionPoint} with the mod container.
+     * @param point The extension point to register
+     * @param extension An extension operator
+     * @param <T> The type signature of the extension operator
+     */
+    public <T extends Record & IExtensionPoint<T>> void registerExtensionPoint(Class<? extends IExtensionPoint<T>> point, Supplier<T> extension) {
+        getActiveContainer().registerExtensionPoint(point, extension);
+    }
+
+    public void registerConfig(ModConfig.Type type, IConfigSpec<?> spec) {
+        getActiveContainer().addConfig(new ModConfig(type, spec, getActiveContainer()));
+    }
+
+    public void registerConfig(ModConfig.Type type, IConfigSpec<?> spec, String fileName) {
+        getActiveContainer().addConfig(new ModConfig(type, spec, getActiveContainer(), fileName));
+    }
+
+
+    @SuppressWarnings("unchecked")
+    public <T> T extension() {
+        return (T)languageExtension;
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingException.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,12 +20,11 @@
 package net.minecraftforge.fml;
 
 import com.google.common.collect.Streams;
-import net.minecraftforge.forgespi.language.IModInfo;
 import net.minecraftforge.fml.loading.EarlyLoadingException;
+import net.minecraftforge.forgespi.language.IModInfo;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
@@ -33,6 +32,7 @@ import java.util.stream.Stream;
  */
 public class ModLoadingException extends RuntimeException
 {
+    private static final long serialVersionUID = 2048947398536935507L;
     /**
      * Mod Info for mod with issue
      */
@@ -53,7 +53,7 @@ public class ModLoadingException extends RuntimeException
     private final List<Object> context;
 
     public ModLoadingException(final IModInfo modInfo, final ModLoadingStage errorStage, final String i18nMessage, final Throwable originalException, Object... context) {
-        super("Mod Loading Exception : " + i18nMessage + " " + Arrays.toString(Streams.concat(Stream.of(modInfo, errorStage, originalException), Stream.of(context)).toArray()), originalException);
+        super("Mod Loading Exception", originalException);
         this.modInfo = modInfo;
         this.errorStage = errorStage;
         this.i18nMessage = i18nMessage;
@@ -61,7 +61,7 @@ public class ModLoadingException extends RuntimeException
     }
 
     static Stream<ModLoadingException> fromEarlyException(final EarlyLoadingException e) {
-        return e.getAllData().stream().map(ed->new ModLoadingException(null, ModLoadingStage.VALIDATE, ed.getI18message(), e.getCause(), ed.getArgs()));
+        return e.getAllData().stream().map(ed->new ModLoadingException(ed.getModInfo(), ModLoadingStage.VALIDATE, ed.getI18message(), e.getCause(), ed.getArgs()));
     }
 
     public String getI18NMessage() {
@@ -73,6 +73,18 @@ public class ModLoadingException extends RuntimeException
     }
 
     public String formatToString() {
-        return ForgeI18n.parseMessage(i18nMessage, Streams.concat(Stream.of(modInfo, errorStage, getCause()), context.stream()).toArray());
+        return Bindings.getMessageParser().get().parseMessage(i18nMessage, Streams.concat(Stream.of(modInfo, errorStage, getCause()), context.stream()).toArray());
+    }
+
+    @Override
+    public String getMessage() {
+        return formatToString();
+    }
+
+    public IModInfo getModInfo() {
+        return modInfo;
+    }
+    public String getCleanMessage() {
+        return Bindings.getMessageParser().get().stripControlCodes(formatToString());
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingPhase.java

@@ -0,0 +1,9 @@
+package net.minecraftforge.fml;
+
+public enum ModLoadingPhase {
+    ERROR, // Special state for error handling
+    GATHER,
+    LOAD,
+    COMPLETE,
+    DONE;
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingStage.java

@@ -0,0 +1,51 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+public enum ModLoadingStage
+{
+    ERROR,
+    VALIDATE,
+    CONSTRUCT,
+    COMMON_SETUP,
+    SIDED_SETUP,
+    ENQUEUE_IMC,
+    PROCESS_IMC,
+    COMPLETE,
+    DONE;
+
+    private final DeferredWorkQueue deferredWorkQueue;
+
+    ModLoadingStage() {
+        deferredWorkQueue = new DeferredWorkQueue(this);
+    }
+
+    ModLoadingStage nextState(Throwable exception) {
+        return exception != null ? ERROR : values()[this.ordinal()+1];
+    }
+
+    public ModLoadingStage currentState(Throwable exception) {
+        return exception != null ? ERROR : this;
+    }
+
+    public DeferredWorkQueue getDeferredWorkQueue() {
+        return deferredWorkQueue;
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingState.java

@@ -0,0 +1,33 @@
+package net.minecraftforge.fml;
+
+import net.minecraftforge.eventbus.api.Event;
+import net.minecraftforge.fml.event.IModBusEvent;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public record ModLoadingState(String name, String previous, Function<ModList, String> message, ModLoadingPhase phase, Optional<Consumer<ModList>> inlineRunnable, Optional<IModStateTransition> transition) implements IModLoadingState {
+    @Override
+    public <T extends Event & IModBusEvent> Optional<CompletableFuture<List<Throwable>>> buildTransition(final Executor syncExecutor, final Executor parallelExecutor, Function<Executor, CompletableFuture<Void>> preSyncTask, Function<Executor, CompletableFuture<Void>> postSyncTask) {
+        return transition.map(t->t.build(syncExecutor, parallelExecutor, preSyncTask, postSyncTask));
+    }
+
+    public static ModLoadingState empty(final String name, final String previous, final ModLoadingPhase phase) {
+        return new ModLoadingState(name, previous, ml->"", phase, Optional.empty(), Optional.empty());
+    }
+
+    public static ModLoadingState withTransition(final String name, final String previous, final ModLoadingPhase phase, IModStateTransition transition) {
+        return new ModLoadingState(name, previous, ml->"Processing transition "+name, phase, Optional.empty(), Optional.of(transition));
+    }
+
+    public static ModLoadingState withTransition(final String name, final String previous, final Function<ModList, String> message, final ModLoadingPhase phase, IModStateTransition transition) {
+        return new ModLoadingState(name, previous, message, phase, Optional.empty(), Optional.of(transition));
+    }
+    public static ModLoadingState withInline(final String name, final String previous, final ModLoadingPhase phase, Consumer<ModList> inline) {
+        return new ModLoadingState(name, previous, ml->"Processing work "+name, phase, Optional.of(inline), Optional.empty());
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingWarning.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -55,6 +55,6 @@ public class ModLoadingWarning
     }
 
     public String formatToString() {
-        return ForgeI18n.parseMessage(i18nMessage, Streams.concat(Stream.of(modInfo, warningStage), context.stream()).toArray());
+        return Bindings.getMessageParser().get().parseMessage(i18nMessage, Streams.concat(Stream.of(modInfo, warningStage), context.stream()).toArray());
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/ModStateManager.java

@@ -0,0 +1,37 @@
+package net.minecraftforge.fml;
+
+import com.google.common.graph.GraphBuilder;
+import cpw.mods.modlauncher.util.ServiceLoaderUtils;
+import net.minecraftforge.fml.loading.FMLLoader;
+import net.minecraftforge.fml.loading.toposort.TopologicalSort;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@SuppressWarnings("UnstableApiUsage")
+public class ModStateManager {
+    static ModStateManager INSTANCE;
+    private final EnumMap<ModLoadingPhase, List<IModLoadingState>> stateMap;
+
+    public ModStateManager() {
+        INSTANCE = this;
+        final var sp = ServiceLoader.load(FMLLoader.getGameLayer(), IModStateProvider.class);
+        this.stateMap = ServiceLoaderUtils.streamWithErrorHandling(sp, sce->{})
+                .map(IModStateProvider::getAllStates)
+                .<IModLoadingState>mapMulti(Iterable::forEach)
+                .collect(Collectors.groupingBy(IModLoadingState::phase, ()->new EnumMap<>(ModLoadingPhase.class), Collectors.toUnmodifiableList()));
+    }
+
+    public List<IModLoadingState> getStates(final ModLoadingPhase phase) {
+        var nodes = stateMap.get(phase);
+        var lookup = nodes.stream().collect(Collectors.toMap(IModLoadingState::name, Function.identity()));
+
+        var graph = GraphBuilder.directed().allowsSelfLoops(false).<IModLoadingState>build();
+        var dummy = ModLoadingState.empty("", "", phase);
+        nodes.forEach(graph::addNode);
+        graph.addNode(dummy);
+        nodes.forEach(n->graph.putEdge(lookup.getOrDefault(n.previous(), dummy), n));
+        return TopologicalSort.topologicalSort(graph, Comparator.comparingInt(nodes::indexOf)).stream().filter(st->st!=dummy).toList();
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModWorkManager.java

@@ -0,0 +1,125 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import net.minecraftforge.fml.loading.FMLConfig;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.concurrent.*;
+import java.util.concurrent.locks.LockSupport;
+
+import static net.minecraftforge.fml.Logging.LOADING;
+
+public class ModWorkManager {
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static final long PARK_TIME = TimeUnit.MILLISECONDS.toNanos(1);
+    public interface DrivenExecutor extends Executor {
+        boolean selfDriven();
+        boolean driveOne();
+
+        default void drive(Runnable ticker) {
+            if (!selfDriven()) {
+                while (driveOne()) {
+                    ticker.run();
+                }
+            } else {
+                // park for a bit so other threads can schedule
+                LockSupport.parkNanos(PARK_TIME);
+            }
+        }
+    }
+    private static class SyncExecutor implements DrivenExecutor {
+        private ConcurrentLinkedDeque<Runnable> tasks = new ConcurrentLinkedDeque<>();
+
+        @Override
+        public boolean driveOne() {
+            final Runnable task = tasks.pollFirst();
+            if (task != null) {
+                task.run();
+            }
+            return task != null;
+        }
+
+        @Override
+        public boolean selfDriven() {
+            return false;
+        }
+
+        @Override
+        public void execute(final Runnable command) {
+            tasks.addLast(command);
+        }
+    }
+
+    private static class WrappingExecutor implements DrivenExecutor {
+        private final Executor wrapped;
+
+        public WrappingExecutor(final Executor executor) {
+            this.wrapped = executor;
+        }
+
+        @Override
+        public boolean selfDriven() {
+            return true;
+        }
+
+        @Override
+        public boolean driveOne() {
+            return false;
+        }
+
+        @Override
+        public void execute(final Runnable command) {
+            wrapped.execute(command);
+        }
+    }
+
+    private static SyncExecutor syncExecutor;
+
+    public static DrivenExecutor syncExecutor() {
+        if (syncExecutor == null)
+            syncExecutor = new SyncExecutor();
+        return syncExecutor;
+    }
+
+    public static DrivenExecutor wrappedExecutor(Executor executor) {
+        return new WrappingExecutor(executor);
+    }
+
+    private static ForkJoinPool parallelThreadPool;
+    public static Executor parallelExecutor() {
+        if (parallelThreadPool == null) {
+            final int loadingThreadCount = FMLConfig.loadingThreadCount();
+            LOGGER.debug(LOADING, "Using {} threads for parallel mod-loading", loadingThreadCount);
+            parallelThreadPool = new ForkJoinPool(loadingThreadCount, ModWorkManager::newForkJoinWorkerThread, null, false);
+        }
+        return parallelThreadPool;
+    }
+
+    private static ForkJoinWorkerThread newForkJoinWorkerThread(ForkJoinPool pool) {
+        ForkJoinWorkerThread thread = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(pool);
+        thread.setName("modloading-worker-" + thread.getPoolIndex());
+        // The default sets it to the SystemClassloader, so copy the current one.
+        thread.setContextClassLoader(Thread.currentThread().getContextClassLoader());
+        return thread;
+    }
+
+}

fmlcore/src/main/java/net/minecraftforge/fml/OptionalMod.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

fmlcore/src/main/java/net/minecraftforge/fml/StartupMessageManager.java

@@ -0,0 +1,37 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+
+public class StartupMessageManager {
+    public static void addModMessage(final String message) {
+        net.minecraftforge.fml.loading.progress.StartupMessageManager.addModMessage(message);
+    }
+
+    public static Optional<Consumer<String>> modLoaderConsumer() {
+        return net.minecraftforge.fml.loading.progress.StartupMessageManager.modLoaderConsumer();
+    }
+
+    public static Optional<Consumer<String>> mcLoaderConsumer() {
+        return net.minecraftforge.fml.loading.progress.StartupMessageManager.mcLoaderConsumer();
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/ThreadSelector.java

@@ -0,0 +1,20 @@
+package net.minecraftforge.fml;
+
+import java.util.concurrent.Executor;
+import java.util.function.BinaryOperator;
+
+public enum ThreadSelector implements BinaryOperator<Executor> {
+    SYNC((sync, parallel) -> sync),
+    PARALLEL((sync, parallel) -> parallel);
+
+    private final BinaryOperator<Executor> selector;
+
+    ThreadSelector(final BinaryOperator<Executor> selector) {
+        this.selector = selector;
+    }
+
+    @Override
+    public Executor apply(final Executor sync, final Executor parallel) {
+        return this.selector.apply(sync, parallel);
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/VersionChecker.java

@@ -0,0 +1,290 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml;
+
+import com.google.gson.Gson;
+import net.minecraftforge.fml.loading.FMLConfig;
+import net.minecraftforge.fml.loading.FMLLoader;
+import net.minecraftforge.forgespi.language.IModInfo;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.maven.artifact.versioning.ComparableVersion;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import java.util.zip.GZIPInputStream;
+
+import static net.minecraftforge.fml.VersionChecker.Status.*;
+
+public class VersionChecker
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static final int MAX_HTTP_REDIRECTS = Integer.getInteger("http.maxRedirects", 20);
+    private static final int HTTP_TIMEOUT_SECS = Integer.getInteger("http.timeoutSecs", 15);
+
+    public enum Status
+    {
+        PENDING(),
+        FAILED(),
+        UP_TO_DATE(),
+        OUTDATED(3, true),
+        AHEAD(),
+        BETA(),
+        BETA_OUTDATED(6, true);
+
+        final int sheetOffset;
+        final boolean draw, animated;
+
+        Status()
+        {
+            this(0, false, false);
+        }
+
+        Status(int sheetOffset)
+        {
+            this(sheetOffset, true, false);
+        }
+
+        Status(int sheetOffset, boolean animated)
+        {
+            this(sheetOffset, true, animated);
+        }
+
+        Status(int sheetOffset, boolean draw, boolean animated)
+        {
+            this.sheetOffset = sheetOffset;
+            this.draw = draw;
+            this.animated = animated;
+        }
+
+        public int getSheetOffset()
+        {
+            return sheetOffset;
+        }
+
+        public boolean shouldDraw()
+        {
+            return draw;
+        }
+
+        public boolean isAnimated()
+        {
+            return animated;
+        }
+
+    }
+
+    public record CheckResult(VersionChecker.Status status, ComparableVersion target, Map<ComparableVersion, String> changes, String url) {}
+
+    public static void startVersionCheck()
+    {
+        new Thread("Forge Version Check")
+        {
+            private HttpClient client;
+
+            @Override
+            public void run()
+            {
+                if (!FMLConfig.runVersionCheck())
+                {
+                    LOGGER.info("Global Forge version check system disabled, no further processing.");
+                    return;
+                }
+
+                client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(HTTP_TIMEOUT_SECS)).build();
+                gatherMods().forEach(this::process);
+            }
+
+            /**
+             * Returns the response body as a String for the given URL while following redirects
+             */
+            private String openUrlString(URL url) throws IOException, URISyntaxException, InterruptedException {
+                URL currentUrl = url;
+                for (int redirects = 0; redirects < MAX_HTTP_REDIRECTS; redirects++)
+                {
+                    var request = HttpRequest.newBuilder()
+                            .uri(currentUrl.toURI())
+                            .timeout(Duration.ofSeconds(HTTP_TIMEOUT_SECS))
+                            .setHeader("Accept-Encoding", "gzip")
+                            .GET()
+                            .build();
+
+                    final HttpResponse<InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
+
+                    int responseCode = response.statusCode();
+                    if (responseCode >= 300 && responseCode <= 399)
+                    {
+                        String newLocation = response.headers().firstValue("Location")
+                                .orElseThrow(() -> new IOException("Got a 3xx response code but Location header was null while trying to fetch " + url));
+                        currentUrl = new URL(currentUrl, newLocation);
+                        continue;
+                    }
+
+                    final boolean isGzipEncoded = response.headers().firstValue("Content-Encoding").orElse("").equals("gzip");
+
+                    final String bodyStr;
+                    try (InputStream inStream = isGzipEncoded ? new GZIPInputStream(response.body()) : response.body())
+                    {
+                        try (var bufferedReader = new BufferedReader(new InputStreamReader(inStream)))
+                        {
+                            bodyStr = bufferedReader.lines().collect(Collectors.joining("\n"));
+                        }
+                    }
+                    return bodyStr;
+                }
+                throw new IOException("Too many redirects while trying to fetch " + url);
+            }
+
+            private void process(IModInfo mod)
+            {
+                Status status = PENDING;
+                ComparableVersion target = null;
+                Map<ComparableVersion, String> changes = null;
+                String display_url = null;
+                try
+                {
+                    if (mod.getUpdateURL().isEmpty()) return;
+                    URL url = mod.getUpdateURL().get();
+                    LOGGER.info("[{}] Starting version check at {}", mod.getModId(), url.toString());
+
+                    String data = openUrlString(url);
+
+                    LOGGER.debug("[{}] Received version check data:\n{}", mod.getModId(), data);
+
+
+                    @SuppressWarnings("unchecked")
+                    Map<String, Object> json = new Gson().fromJson(data, Map.class);
+                    @SuppressWarnings("unchecked")
+                    Map<String, String> promos = (Map<String, String>)json.get("promos");
+                    display_url = (String)json.get("homepage");
+
+                    var mcVersion = FMLLoader.versionInfo().mcVersion();
+                    String rec = promos.get(mcVersion + "-recommended");
+                    String lat = promos.get(mcVersion + "-latest");
+                    ComparableVersion current = new ComparableVersion(mod.getVersion().toString());
+
+                    if (rec != null)
+                    {
+                        ComparableVersion recommended = new ComparableVersion(rec);
+                        int diff = recommended.compareTo(current);
+
+                        if (diff == 0)
+                            status = UP_TO_DATE;
+                        else if (diff < 0)
+                        {
+                            status = AHEAD;
+                            if (lat != null)
+                            {
+                                ComparableVersion latest = new ComparableVersion(lat);
+                                if (current.compareTo(latest) < 0)
+                                {
+                                    status = OUTDATED;
+                                    target = latest;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            status = OUTDATED;
+                            target = recommended;
+                        }
+                    }
+                    else if (lat != null)
+                    {
+                        ComparableVersion latest = new ComparableVersion(lat);
+                        if (current.compareTo(latest) < 0)
+                            status = BETA_OUTDATED;
+                        else
+                            status = BETA;
+                        target = latest;
+                    }
+                    else
+                        status = BETA;
+
+                    LOGGER.info("[{}] Found status: {} Current: {} Target: {}", mod.getModId(), status, current, target);
+
+                    changes = new LinkedHashMap<>();
+                    @SuppressWarnings("unchecked")
+                    Map<String, String> tmp = (Map<String, String>)json.get(mcVersion);
+                    if (tmp != null)
+                    {
+                        List<ComparableVersion> ordered = new ArrayList<>();
+                        for (String key : tmp.keySet())
+                        {
+                            ComparableVersion ver = new ComparableVersion(key);
+                            if (ver.compareTo(current) > 0 && (target == null || ver.compareTo(target) < 1))
+                            {
+                                ordered.add(ver);
+                            }
+                        }
+                        Collections.sort(ordered);
+
+                        for (ComparableVersion ver : ordered)
+                        {
+                            changes.put(ver, tmp.get(ver.toString()));
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    LOGGER.warn("Failed to process update information", e);
+                    status = FAILED;
+                }
+                results.put(mod, new CheckResult(status, target, changes, display_url));
+            }
+        }.start();
+    }
+
+    // Gather a list of mods that have opted in to this update system by providing a URL.
+    private static List<IModInfo> gatherMods()
+    {
+        List<IModInfo> ret = new LinkedList<>();
+        for (IModInfo info : ModList.get().getMods()) {
+            if (info.getUpdateURL().isPresent())
+                ret.add(info);
+        }
+        return ret;
+    }
+
+    private static Map<IModInfo, CheckResult> results = new ConcurrentHashMap<>();
+    private static final CheckResult PENDING_CHECK = new CheckResult(PENDING, null, null, null);
+
+    public static CheckResult getResult(IModInfo mod)
+    {
+        return results.getOrDefault(mod, PENDING_CHECK);
+    }
+
+}

fmlcore/src/main/java/net/minecraftforge/fml/config/ConfigFileTypeHandler.java

@@ -0,0 +1,172 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.config;
+
+import com.electronwill.nightconfig.core.ConfigFormat;
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import com.electronwill.nightconfig.core.file.FileWatcher;
+import com.electronwill.nightconfig.core.io.ParsingException;
+import com.electronwill.nightconfig.core.io.WritingMode;
+import net.minecraftforge.fml.loading.FMLConfig;
+import net.minecraftforge.fml.loading.FMLPaths;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.function.Function;
+
+import static net.minecraftforge.fml.config.ConfigTracker.CONFIG;
+
+public class ConfigFileTypeHandler {
+    private static final Logger LOGGER = LogManager.getLogger();
+    static ConfigFileTypeHandler TOML = new ConfigFileTypeHandler();
+    private static final Path defaultConfigPath = FMLPaths.GAMEDIR.get().resolve(FMLConfig.defaultConfigPath());
+
+    public Function<ModConfig, CommentedFileConfig> reader(Path configBasePath) {
+        return (c) -> {
+            final Path configPath = configBasePath.resolve(c.getFileName());
+            final CommentedFileConfig configData = CommentedFileConfig.builder(configPath).sync().
+                    preserveInsertionOrder().
+                    autosave().
+                    onFileNotFound((newfile, configFormat)-> setupConfigFile(c, newfile, configFormat)).
+                    writingMode(WritingMode.REPLACE).
+                    build();
+            LOGGER.debug(CONFIG, "Built TOML config for {}", configPath.toString());
+            try
+            {
+                configData.load();
+            }
+            catch (ParsingException ex)
+            {
+                throw new ConfigLoadingException(c, ex);
+            }
+            LOGGER.debug(CONFIG, "Loaded TOML config file {}", configPath.toString());
+            try {
+                FileWatcher.defaultInstance().addWatch(configPath, new ConfigWatcher(c, configData, Thread.currentThread().getContextClassLoader()));
+                LOGGER.debug(CONFIG, "Watching TOML config file {} for changes", configPath.toString());
+            } catch (IOException e) {
+                throw new RuntimeException("Couldn't watch config file", e);
+            }
+            return configData;
+        };
+    }
+
+    public void unload(Path configBasePath, ModConfig config) {
+        Path configPath = configBasePath.resolve(config.getFileName());
+        try {
+            FileWatcher.defaultInstance().removeWatch(configBasePath.resolve(config.getFileName()));
+        } catch (RuntimeException e) {
+            LOGGER.error("Failed to remove config {} from tracker!", configPath.toString(), e);
+        }
+    }
+
+    private boolean setupConfigFile(final ModConfig modConfig, final Path file, final ConfigFormat<?> conf) throws IOException {
+        Path p = defaultConfigPath.resolve(modConfig.getFileName());
+        if (Files.exists(p)) {
+            LOGGER.info(CONFIG, "Loading default config file from path {}", p);
+            Files.copy(p, file);
+        } else {
+            Files.createFile(file);
+            conf.initEmptyFile(file);
+        }
+        return true;
+    }
+
+    public static void backUpConfig(final CommentedFileConfig commentedFileConfig)
+    {
+        backUpConfig(commentedFileConfig, 5); //TODO: Think of a way for mods to set their own preference (include a sanity check as well, no disk stuffing)
+    }
+
+    public static void backUpConfig(final CommentedFileConfig commentedFileConfig, final int maxBackups)
+    {
+        Path bakFileLocation = commentedFileConfig.getNioPath().getParent();
+        String bakFileName = FilenameUtils.removeExtension(commentedFileConfig.getFile().getName());
+        String bakFileExtension = FilenameUtils.getExtension(commentedFileConfig.getFile().getName()) + ".bak";
+        Path bakFile = bakFileLocation.resolve(bakFileName + "-1" + "." + bakFileExtension);
+        try
+        {
+            for(int i = maxBackups; i > 0; i--)
+            {
+                Path oldBak = bakFileLocation.resolve(bakFileName + "-" + i + "." + bakFileExtension);
+                if(Files.exists(oldBak))
+                {
+                    if(i >= maxBackups)
+                        Files.delete(oldBak);
+                    else
+                        Files.move(oldBak, bakFileLocation.resolve(bakFileName + "-" + (i + 1) + "." + bakFileExtension));
+                }
+            }
+            Files.copy(commentedFileConfig.getNioPath(), bakFile);
+        }
+        catch (IOException exception)
+        {
+            LOGGER.warn(CONFIG, "Failed to back up config file {}", commentedFileConfig.getNioPath(), exception);
+        }
+    }
+
+    private static class ConfigWatcher implements Runnable {
+        private final ModConfig modConfig;
+        private final CommentedFileConfig commentedFileConfig;
+        private final ClassLoader realClassLoader;
+
+        ConfigWatcher(final ModConfig modConfig, final CommentedFileConfig commentedFileConfig, final ClassLoader classLoader) {
+            this.modConfig = modConfig;
+            this.commentedFileConfig = commentedFileConfig;
+            this.realClassLoader = classLoader;
+        }
+
+        @Override
+        public void run() {
+            // Force the regular classloader onto the special thread
+            Thread.currentThread().setContextClassLoader(realClassLoader);
+            if (!this.modConfig.getSpec().isCorrecting()) {
+                try
+                {
+                    this.commentedFileConfig.load();
+                    if(!this.modConfig.getSpec().isCorrect(commentedFileConfig))
+                    {
+                        LOGGER.warn(CONFIG, "Configuration file {} is not correct. Correcting", commentedFileConfig.getFile().getAbsolutePath());
+                        ConfigFileTypeHandler.backUpConfig(commentedFileConfig);
+                        this.modConfig.getSpec().correct(commentedFileConfig);
+                        commentedFileConfig.save();
+                    }
+                }
+                catch (ParsingException ex)
+                {
+                    throw new ConfigLoadingException(modConfig, ex);
+                }
+                LOGGER.debug(CONFIG, "Config file {} changed, sending notifies", this.modConfig.getFileName());
+                this.modConfig.getSpec().afterReload();
+                this.modConfig.fireEvent(IConfigEvent.reloading(this.modConfig));
+            }
+        }
+    }
+
+    private static class ConfigLoadingException extends RuntimeException
+    {
+        public ConfigLoadingException(ModConfig config, Exception cause)
+        {
+            super("Failed loading config file " + config.getFileName() + " of type " + config.getType() + " for modid " + config.getModId(), cause);
+        }
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/config/ConfigTracker.java

@@ -0,0 +1,110 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.config;
+
+import com.electronwill.nightconfig.core.CommentedConfig;
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.MarkerManager;
+
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ConfigTracker {
+    private static final Logger LOGGER = LogManager.getLogger();
+    static final Marker CONFIG = MarkerManager.getMarker("CONFIG");
+    public static final ConfigTracker INSTANCE = new ConfigTracker();
+    private final ConcurrentHashMap<String, ModConfig> fileMap;
+    private final EnumMap<ModConfig.Type, Set<ModConfig>> configSets;
+    private final ConcurrentHashMap<String, Map<ModConfig.Type, ModConfig>> configsByMod;
+
+    private ConfigTracker() {
+        this.fileMap = new ConcurrentHashMap<>();
+        this.configSets = new EnumMap<>(ModConfig.Type.class);
+        this.configsByMod = new ConcurrentHashMap<>();
+        this.configSets.put(ModConfig.Type.CLIENT, Collections.synchronizedSet(new LinkedHashSet<>()));
+        this.configSets.put(ModConfig.Type.COMMON, Collections.synchronizedSet(new LinkedHashSet<>()));
+//        this.configSets.put(ModConfig.Type.PLAYER, new ConcurrentSkipListSet<>());
+        this.configSets.put(ModConfig.Type.SERVER, Collections.synchronizedSet(new LinkedHashSet<>()));
+    }
+
+    void trackConfig(final ModConfig config) {
+        if (this.fileMap.containsKey(config.getFileName())) {
+            LOGGER.error(CONFIG,"Detected config file conflict {} between {} and {}", config.getFileName(), this.fileMap.get(config.getFileName()).getModId(), config.getModId());
+            throw new RuntimeException("Config conflict detected!");
+        }
+        this.fileMap.put(config.getFileName(), config);
+        this.configSets.get(config.getType()).add(config);
+        this.configsByMod.computeIfAbsent(config.getModId(), (k)->new EnumMap<>(ModConfig.Type.class)).put(config.getType(), config);
+        LOGGER.debug(CONFIG, "Config file {} for {} tracking", config.getFileName(), config.getModId());
+    }
+
+    public void loadConfigs(ModConfig.Type type, Path configBasePath) {
+        LOGGER.debug(CONFIG, "Loading configs type {}", type);
+        this.configSets.get(type).forEach(config -> openConfig(config, configBasePath));
+    }
+
+    public void unloadConfigs(ModConfig.Type type, Path configBasePath) {
+        LOGGER.debug(CONFIG, "Unloading configs type {}", type);
+        this.configSets.get(type).forEach(config -> closeConfig(config, configBasePath));
+    }
+
+    private void openConfig(final ModConfig config, final Path configBasePath) {
+        LOGGER.trace(CONFIG, "Loading config file type {} at {} for {}", config.getType(), config.getFileName(), config.getModId());
+        final CommentedFileConfig configData = config.getHandler().reader(configBasePath).apply(config);
+        config.setConfigData(configData);
+        config.fireEvent(IConfigEvent.loading(config));
+        config.save();
+    }
+
+    private void closeConfig(final ModConfig config, final Path configBasePath) {
+        if (config.getConfigData() != null) {
+            LOGGER.trace(CONFIG, "Closing config file type {} at {} for {}", config.getType(), config.getFileName(), config.getModId());
+            config.save();
+            config.getHandler().unload(configBasePath, config);
+            config.setConfigData(null);
+        }
+    }
+
+    public void loadDefaultServerConfigs() {
+        configSets.get(ModConfig.Type.SERVER).forEach(modConfig -> {
+            final CommentedConfig commentedConfig = CommentedConfig.inMemory();
+            modConfig.getSpec().correct(commentedConfig);
+            modConfig.setConfigData(commentedConfig);
+            modConfig.fireEvent(IConfigEvent.loading(modConfig));
+        });
+    }
+
+    public String getConfigFileName(String modId, ModConfig.Type type) {
+        return Optional.ofNullable(configsByMod.getOrDefault(modId, Collections.emptyMap()).getOrDefault(type, null)).
+                map(ModConfig::getFullPath).map(Object::toString).orElse(null);
+    }
+
+    public Map<ModConfig.Type, Set<ModConfig>> configSets() {
+        return configSets;
+    }
+
+    public ConcurrentHashMap<String, ModConfig> fileMap() {
+        return fileMap;
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/config/IConfigEvent.java

@@ -0,0 +1,24 @@
+package net.minecraftforge.fml.config;
+
+import net.minecraftforge.eventbus.api.Event;
+import net.minecraftforge.fml.Bindings;
+
+import java.util.function.Function;
+
+public interface IConfigEvent {
+    record ConfigConfig(Function<ModConfig, IConfigEvent> loading, Function<ModConfig, IConfigEvent> reloading) {}
+    ConfigConfig CONFIGCONFIG = Bindings.getConfigConfiguration().get();
+
+    static IConfigEvent reloading(ModConfig modConfig) {
+        return CONFIGCONFIG.reloading().apply(modConfig);
+    }
+    static IConfigEvent loading(ModConfig modConfig) {
+        return CONFIGCONFIG.loading().apply(modConfig);
+    }
+    ModConfig getConfig();
+
+    @SuppressWarnings("unchecked")
+    default <T extends Event & IConfigEvent> T self() {
+        return (T) this;
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/config/IConfigSpec.java

@@ -0,0 +1,21 @@
+package net.minecraftforge.fml.config;
+
+import com.electronwill.nightconfig.core.CommentedConfig;
+import com.electronwill.nightconfig.core.UnmodifiableConfig;
+
+public interface IConfigSpec<T extends IConfigSpec<T>> extends UnmodifiableConfig {
+    @SuppressWarnings("unchecked")
+    default T self() {
+        return (T) this;
+    }
+
+    void acceptConfig(CommentedConfig data);
+
+    boolean isCorrecting();
+
+    boolean isCorrect(CommentedConfig commentedFileConfig);
+
+    int correct(CommentedConfig commentedFileConfig);
+
+    void afterReload();
+}

fmlcore/src/main/java/net/minecraftforge/fml/config/ModConfig.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -21,28 +21,25 @@ package net.minecraftforge.fml.config;
 
 import com.electronwill.nightconfig.core.CommentedConfig;
 import com.electronwill.nightconfig.core.file.CommentedFileConfig;
-import net.minecraftforge.common.ForgeConfigSpec;
-import net.minecraftforge.eventbus.api.Event;
+import com.electronwill.nightconfig.toml.TomlFormat;
 import net.minecraftforge.fml.ModContainer;
 import net.minecraftforge.fml.loading.StringUtils;
 
+import java.io.ByteArrayInputStream;
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
-import java.util.function.Consumer;
-
-import static cpw.mods.modlauncher.api.LamdbaExceptionUtils.uncheck;
 
 public class ModConfig
 {
     private final Type type;
-    private final ForgeConfigSpec spec;
+    private final IConfigSpec<?> spec;
     private final String fileName;
     private final ModContainer container;
     private final ConfigFileTypeHandler configHandler;
     private CommentedConfig configData;
     private Callable<Void> saveHandler;
 
-    public ModConfig(final Type type, final ForgeConfigSpec spec, final ModContainer container, final String fileName) {
+    public ModConfig(final Type type, final IConfigSpec<?> spec, final ModContainer container, final String fileName) {
         this.type = type;
         this.spec = spec;
         this.fileName = fileName;
@@ -51,7 +48,7 @@ public class ModConfig
         ConfigTracker.INSTANCE.trackConfig(this);
     }
 
-    public ModConfig(final Type type, final ForgeConfigSpec spec, final ModContainer activeContainer) {
+    public ModConfig(final Type type, final IConfigSpec<?> spec, final ModContainer activeContainer) {
         this(type, spec, activeContainer, defaultConfigName(type, activeContainer.getModId()));
     }
 
@@ -71,8 +68,9 @@ public class ModConfig
         return configHandler;
     }
 
-    public ForgeConfigSpec getSpec() {
-        return spec;
+    @SuppressWarnings("unchecked")
+    public <T extends IConfigSpec<T>> IConfigSpec<T> getSpec() {
+        return (IConfigSpec<T>) spec;
     }
 
     public String getModId() {
@@ -85,10 +83,10 @@ public class ModConfig
 
     void setConfigData(final CommentedConfig configData) {
         this.configData = configData;
-        this.spec.setConfig(this.configData);
+        this.spec.acceptConfig(this.configData);
     }
 
-    void fireEvent(final ModConfigEvent configEvent) {
+    void fireEvent(final IConfigEvent configEvent) {
         this.container.dispatchConfigEvent(configEvent);
     }
 
@@ -100,6 +98,11 @@ public class ModConfig
         return ((CommentedFileConfig)this.configData).getNioPath();
     }
 
+    public void acceptSyncedConfig(byte[] bytes) {
+        setConfigData(TomlFormat.instance().createParser().parse(new ByteArrayInputStream(bytes)));
+        fireEvent(IConfigEvent.reloading(this));
+    }
+
     public enum Type {
         /**
          * Common mod config for configuration that needs to be loaded on both environments.
@@ -135,28 +138,4 @@ public class ModConfig
             return StringUtils.toLowerCase(name());
         }
     }
-
-    public static class ModConfigEvent extends Event {
-        private final ModConfig config;
-
-        ModConfigEvent(final ModConfig config) {
-            this.config = config;
-        }
-
-        public ModConfig getConfig() {
-            return config;
-        }
-    }
-
-    public static class Loading extends ModConfigEvent {
-        Loading(final ModConfig config) {
-            super(config);
-        }
-    }
-
-    public static class ConfigReloading extends ModConfigEvent {
-        ConfigReloading(final ModConfig config) {
-            super(config);
-        }
-    }
 }

fmlcore/src/main/java/net/minecraftforge/fml/event/IModBusEvent.java

@@ -0,0 +1,26 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.event;
+
+/**
+ * Marker interface for events dispatched on the ModLifecycle event bus instead of the primary event bus
+ */
+public interface IModBusEvent {
+}

fmlcore/src/main/java/net/minecraftforge/fml/util/CertificateHelper.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,7 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.fml.common;
+package net.minecraftforge.fml.util;
 
 import com.google.common.collect.ImmutableList;
 

fmlcore/src/main/java/net/minecraftforge/fml/util/EnhancedRuntimeException.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,7 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.fml.common;
+package net.minecraftforge.fml.util;
 
 import java.io.PrintStream;
 import java.io.PrintWriter;

fmlcore/src/main/java/net/minecraftforge/fml/util/LoaderException.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,8 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.fml.common;
-import net.minecraftforge.fml.common.EnhancedRuntimeException.WrappedPrintStream;
+package net.minecraftforge.fml.util;
 
 
 public class LoaderException extends EnhancedRuntimeException

fmlcore/src/main/java/net/minecraftforge/fml/util/LoaderExceptionModCrash.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,7 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.fml.common;
+package net.minecraftforge.fml.util;
 
 /**
  * Prevent LoaderException from adding its own stack trace to the wrapped throwable's stack trace.

fmlcore/src/main/java/net/minecraftforge/fml/util/ObfuscationReflectionHelper.java

@@ -0,0 +1,276 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.util;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.StringJoiner;
+
+import cpw.mods.modlauncher.api.INameMappingService;
+import net.minecraftforge.fml.loading.FMLLoader;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.MarkerManager;
+
+import com.google.common.base.Preconditions;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Some reflection helper code.
+ * This may not work properly in Java 9 with its new, more restrictive, reflection management.
+ * As such, if issues are encountered, please report them and we can see what we can do to expand
+ * the compatibility.
+ *
+ * In other cases, AccessTransformers may be used.
+ *
+ * All field and method names should be passed in as SRG names, and this will automatically resolve if MCP mappings are detected.
+ *
+ */
+@SuppressWarnings({"serial", "unchecked", "unused", "WeakerAccess"})
+public class ObfuscationReflectionHelper
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static final Marker REFLECTION = MarkerManager.getMarker("REFLECTION");
+
+    /**
+     * Remaps a name using the SRG naming function
+     * @param domain The {@link INameMappingService.Domain} to use to remap the name.
+     * @param name   The name to try and remap.
+     * @return The remapped name, or the original name if it couldn't be remapped.
+     */
+    @NotNull
+    public static String remapName(INameMappingService.Domain domain, String name)
+    {
+        return FMLLoader.getNameFunction("srg").map(f->f.apply(domain, name)).orElse(name);
+    }
+
+    /**
+     * Gets the value a field with the specified name in the given class.
+     * Note: For performance, use {@link #findField(Class, String)} if you are getting the value more than once.
+     * <p>
+     * Throws an exception if the field is not found or the value of the field cannot be gotten.
+     *
+     * @param classToAccess The class to find the field on.
+     * @param instance      The instance of the {@code classToAccess}.
+     * @param fieldName     The SRG (unmapped) name of the field to find (e.g. "f_46443_").
+     * @param <T>           The type of the value.
+     * @param <E>           The type of the {@code classToAccess}.
+     * @return The value of the field with the specified name in the {@code classToAccess}.
+     * @throws UnableToAccessFieldException If there was a problem getting the field.
+     * @throws UnableToAccessFieldException If there was a problem getting the value.
+     */
+    @Nullable
+    public static <T, E> T getPrivateValue(Class<? super E> classToAccess, E instance, String fieldName)
+    {
+        try
+        {
+            return (T) findField(classToAccess, fieldName).get(instance);
+        }
+        catch (UnableToFindFieldException e)
+        {
+            LOGGER.error(REFLECTION,"Unable to locate field {} ({}) on type {}", fieldName, remapName(INameMappingService.Domain.FIELD, fieldName), classToAccess.getName(), e);
+            throw e;
+        }
+        catch (IllegalAccessException e)
+        {
+            LOGGER.error(REFLECTION,"Unable to access field {} ({}) on type {}", fieldName, remapName(INameMappingService.Domain.FIELD, fieldName), classToAccess.getName(), e);
+            throw new UnableToAccessFieldException(e);
+        }
+    }
+
+    /**
+     * Sets the value a field with the specified name in the given class.
+     * Note: For performance, use {@link #findField(Class, String)} if you are setting the value more than once.
+     * <p>
+     * Throws an exception if the field is not found or the value of the field cannot be set.
+     *
+     * @param classToAccess The class to find the field on.
+     * @param instance      The instance of the {@code classToAccess}.
+     * @param value         The new value for the field
+     * @param fieldName     The name of the field in the {@code classToAccess}.
+     * @param <T>           The type of the value.
+     * @param <E>           The type of the {@code classToAccess}.
+     * @throws UnableToFindFieldException   If there was a problem getting the field.
+     * @throws UnableToAccessFieldException If there was a problem setting the value of the field.
+     */
+    public static <T, E> void setPrivateValue(@NotNull final Class<? super T> classToAccess, @NotNull final T instance, @Nullable final E value, @NotNull final String fieldName)
+    {
+        try
+        {
+            findField(classToAccess, fieldName).set(instance, value);
+        }
+        catch (UnableToFindFieldException e)
+        {
+            LOGGER.error("Unable to locate any field {} on type {}", fieldName, classToAccess.getName(), e);
+            throw e;
+        }
+        catch (IllegalAccessException e)
+        {
+            LOGGER.error("Unable to set any field {} on type {}", fieldName, classToAccess.getName(), e);
+            throw new UnableToAccessFieldException(e);
+        }
+    }
+
+    /**
+     * Finds a method with the specified name and parameters in the given class and makes it accessible.
+     * Note: For performance, store the returned value and avoid calling this repeatedly.
+     * <p>
+     * Throws an exception if the method is not found.
+     *
+     * @param clazz          The class to find the method on.
+     * @param methodName     The SRG (unmapped) name of the method to find (e.g. "m_5776_").
+     * @param parameterTypes The parameter types of the method to find.
+     * @return The method with the specified name and parameters in the given class.
+     * @throws NullPointerException        If {@code clazz} is null.
+     * @throws NullPointerException        If {@code methodName} is null.
+     * @throws IllegalArgumentException    If {@code methodName} is empty.
+     * @throws NullPointerException        If {@code parameterTypes} is null.
+     * @throws UnableToFindMethodException If the method could not be found.
+     */
+    @NotNull
+    public static Method findMethod(@NotNull final Class<?> clazz, @NotNull final String methodName, @NotNull final Class<?>... parameterTypes)
+    {
+        Preconditions.checkNotNull(clazz, "Class to find method on cannot be null.");
+        Preconditions.checkNotNull(methodName, "Name of method to find cannot be null.");
+        Preconditions.checkArgument(!methodName.isEmpty(), "Name of method to find cannot be empty.");
+        Preconditions.checkNotNull(parameterTypes, "Parameter types of method to find cannot be null.");
+
+        try
+        {
+            Method m = clazz.getDeclaredMethod(remapName(INameMappingService.Domain.METHOD, methodName), parameterTypes);
+            m.setAccessible(true);
+            return m;
+        }
+        catch (Exception e)
+        {
+            throw new UnableToFindMethodException(e);
+        }
+    }
+
+    /**
+     * Finds a constructor with the specified parameter types in the given class and makes it accessible.
+     * Note: For performance, store the returned value and avoid calling this repeatedly.
+     * <p>
+     * Throws an exception if the constructor is not found.
+     *
+     * @param clazz          The class to find the constructor in.
+     * @param parameterTypes The parameter types of the constructor.
+     * @param <T>            The type.
+     * @return The constructor with the specified parameters in the given class.
+     * @throws NullPointerException        If {@code clazz} is null.
+     * @throws NullPointerException        If {@code parameterTypes} is null.
+     * @throws UnknownConstructorException If the constructor could not be found.
+     */
+    @NotNull
+    public static <T> Constructor<T> findConstructor(@NotNull final Class<T> clazz, @NotNull final Class<?>... parameterTypes)
+    {
+        Preconditions.checkNotNull(clazz, "Class to find constructor on cannot be null.");
+        Preconditions.checkNotNull(parameterTypes, "Parameter types of constructor to find cannot be null.");
+
+        try
+        {
+            Constructor<T> constructor = clazz.getDeclaredConstructor(parameterTypes);
+            constructor.setAccessible(true);
+            return constructor;
+        }
+        catch (final NoSuchMethodException e)
+        {
+            final StringBuilder desc = new StringBuilder();
+            desc.append(clazz.getSimpleName());
+
+            StringJoiner joiner = new StringJoiner(", ", "(", ")");
+            for (Class<?> type : parameterTypes)
+            {
+                joiner.add(type.getSimpleName());
+            }
+            desc.append(joiner);
+
+            throw new UnknownConstructorException("Could not find constructor '" + desc.toString() + "' in " + clazz);
+        }
+    }
+
+    /**
+     * Finds a field with the specified name in the given class and makes it accessible.
+     * Note: For performance, store the returned value and avoid calling this repeatedly.
+     * <p>
+     * Throws an exception if the field is not found.
+     *
+     * @param clazz     The class to find the field on.
+     * @param fieldName The SRG (unmapped) name of the field to find (e.g. "f_46443_").
+     * @param <T>       The type.
+     * @return The constructor with the specified parameters in the given class.
+     * @throws NullPointerException       If {@code clazz} is null.
+     * @throws NullPointerException       If {@code fieldName} is null.
+     * @throws IllegalArgumentException   If {@code fieldName} is empty.
+     * @throws UnableToFindFieldException If the field could not be found.
+     */
+    @NotNull
+    public static <T> Field findField(@NotNull final Class<? super T> clazz, @NotNull final String fieldName)
+    {
+        Preconditions.checkNotNull(clazz, "Class to find field on cannot be null.");
+        Preconditions.checkNotNull(fieldName, "Name of field to find cannot be null.");
+        Preconditions.checkArgument(!fieldName.isEmpty(), "Name of field to find cannot be empty.");
+
+        try
+        {
+            Field f = clazz.getDeclaredField(remapName(INameMappingService.Domain.FIELD, fieldName));
+            f.setAccessible(true);
+            return f;
+        }
+        catch (Exception e)
+        {
+            throw new UnableToFindFieldException(e);
+        }
+    }
+
+    public static class UnableToAccessFieldException extends RuntimeException
+    {
+        private UnableToAccessFieldException(Exception e)
+        {
+            super(e);
+        }
+    }
+
+    public static class UnableToFindFieldException extends RuntimeException
+    {
+        private UnableToFindFieldException(Exception e)
+        {
+            super(e);
+        }
+    }
+
+    public static class UnableToFindMethodException extends RuntimeException
+    {
+        public UnableToFindMethodException(Throwable failed)
+        {
+            super(failed);
+        }
+    }
+
+    public static class UnknownConstructorException extends RuntimeException
+    {
+        public UnknownConstructorException(final String message)
+        {
+            super(message);
+        }
+    }
+}

fmlcore/src/main/java/net/minecraftforge/fml/util/thread/EffectiveSide.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,7 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.fml.common.thread;
+package net.minecraftforge.fml.util.thread;
 
 import net.minecraftforge.fml.LogicalSide;
 

fmlcore/src/main/java/net/minecraftforge/fml/util/thread/SidedThreadGroup.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,14 +17,13 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.fml.common.thread;
+package net.minecraftforge.fml.util.thread;
 
 import net.minecraftforge.fml.LogicalSide;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.concurrent.ThreadFactory;
 
-import javax.annotation.Nonnull;
-
 /**
  * A thread group and factory combination which belongs to a {@link LogicalSide}.
  */
@@ -49,7 +48,7 @@ public final class SidedThreadGroup extends ThreadGroup implements ThreadFactory
     }
 
     @Override
-    public Thread newThread(@Nonnull final Runnable runnable)
+    public Thread newThread(@NotNull final Runnable runnable)
     {
         return new Thread(this, runnable);
     }

fmlcore/src/main/java/net/minecraftforge/fml/util/thread/SidedThreadGroups.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,7 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.fml.common.thread;
+package net.minecraftforge.fml.util.thread;
 
 import net.minecraftforge.fml.LogicalSide;
 

fmlloader/build.gradle

@@ -0,0 +1,80 @@
+plugins {
+    id 'com.github.ben-manes.versions'
+    id 'org.javamodularity.moduleplugin' version '1.8.3' apply false
+}
+apply plugin: 'java-library'
+apply plugin: 'jacoco'
+apply plugin: 'org.javamodularity.moduleplugin'
+
+dependencyUpdates.rejectVersionIf { isNonStable(it.candidate.version) }
+configurations.forEach{ it.transitive = false }
+
+dependencies {
+    implementation('net.sf.jopt-simple:jopt-simple:5.0.4')
+    compileOnly('org.jetbrains:annotations:21.0.0')
+    api("org.ow2.asm:asm:${ASM_VERSION}")
+    api("org.ow2.asm:asm-tree:${ASM_VERSION}")
+    api("org.ow2.asm:asm-commons:${ASM_VERSION}")
+    api('net.minecraftforge:forgespi:4.0.+')
+    api('org.apache.logging.log4j:log4j-api:2.14.1')
+    api('com.google.guava:guava:21.0')
+    api('com.google.code.gson:gson:2.8.0')
+    api('org.apache.maven:maven-artifact:3.8.1')
+    api('org.apache.commons:commons-lang3:3.8.1')
+    api('com.electronwill.night-config:core:3.6.3')
+    api('com.electronwill.night-config:toml:3.6.3')
+    api('cpw.mods:modlauncher:9.0.+')
+    api('net.minecraftforge:coremods:5.0.+')
+    implementation("cpw.mods:securejarhandler:${SECUREJARHANDLER_VERSION}")
+    implementation('org.apache.logging.log4j:log4j-core:2.14.1')
+    annotationProcessor('org.apache.logging.log4j:log4j-core:2.14.1')
+    implementation('net.minecraftforge:accesstransformers:8.0.4')
+    implementation('net.minecrell:terminalconsoleappender:1.2.0')
+//    implementation('org.jline:jline:3.12.+')
+    testCompileOnly('org.jetbrains:annotations:21.0.0')
+    testRuntimeOnly("cpw.mods:bootstraplauncher:${BOOTSTRAPLAUNCHER_VERSION}")
+}
+
+task sourcesJar(type: Jar) {
+    archiveClassifier = 'sources'
+    from sourceSets.main.allSource
+}
+
+ext {
+    MANIFESTS = [
+        '/': [
+            'Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
+            'Git-Commit': GIT_INFO.abbreviatedId,
+            'Git-Branch': GIT_INFO.branch,
+            'Build-Number': "${System.getenv('BUILD_NUMBER')?:0}",
+        ] as LinkedHashMap,
+        'net/minecraftforge/fml/loading/': [
+            'Specification-Title':      'FMLLoader',
+            'Specification-Vendor':     'Forge Development LLC',
+            'Specification-Version':    '1',
+            'Implementation-Title':     'FML Loader',
+            'Implementation-Version':   '1.0',
+            'Implementation-Vendor':    'Forge'
+        ] as LinkedHashMap
+    ]
+}
+
+jar.doFirst {
+    MANIFESTS.each { pkg, values ->
+        manifest.attributes(values, pkg)
+    }
+}
+
+tasks.withType(JavaCompile) {
+    options.compilerArgs << '-Xlint:unchecked'
+}
+
+artifacts {
+    archives jar
+    archives sourcesJar
+}
+
+publishing.publications.mavenJava(MavenPublication) {
+    from components.java
+    artifact sourcesJar
+}

fmlloader/src/main/java/net/minecraftforge/fml/common/asm/CapabilityTokenSubclass.java

@@ -0,0 +1,134 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.common.asm;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.EnumSet;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.signature.SignatureReader;
+import org.objectweb.asm.signature.SignatureVisitor;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import cpw.mods.modlauncher.serviceapi.ILaunchPluginService;
+
+/**
+ * Implements getType() in CapabilityToken subclasses.
+ *
+ * Using the class's signature to determine the generic type of TypeToken, and then implements getType() using that value.
+ * <pre>
+ * Example:
+ *
+ *  <code>new CapabilityToken&lt;String>(){}</code>
+ *  Has the signature <code>"CapabilityToken&lt;Ljava/lang/String;>"</code>
+ *
+ *  Implements the method:
+ *  <code>public String getType() {
+ *    return "java/lang/String";
+ *  }</code>
+ * </pre>
+ */
+public class CapabilityTokenSubclass implements ILaunchPluginService {
+
+    private final String FUNC_NAME = "getType";
+    private final String FUNC_DESC = "()Ljava/lang/String;";
+    private final String CAP_INJECT = "net/minecraftforge/common/capabilities/CapabilityToken"; //Don't directly reference this to prevent class loading.
+
+    @Override
+    public String name() {
+        return "capability_token_subclass";
+    }
+
+    private static final EnumSet<Phase> YAY = EnumSet.of(Phase.AFTER);
+    private static final EnumSet<Phase> NAY = EnumSet.noneOf(Phase.class);
+
+    @Override
+    public EnumSet<Phase> handlesClass(Type classType, boolean isEmpty)
+    {
+        return isEmpty ? NAY : YAY;
+    }
+
+    @Override
+    public int processClassWithFlags(final Phase phase, final ClassNode classNode, final Type classType, final String reason)
+    {
+        if (CAP_INJECT.equals(classNode.name))
+        {
+            for (MethodNode mtd : classNode.methods)
+            {
+                if (FUNC_NAME.equals(mtd.name) && FUNC_DESC.equals(mtd.desc))
+                {
+                    mtd.access &= ~Opcodes.ACC_FINAL; // We have it final in code so people don't override it, cuz that'd be stupid, and make our transformer more complicated.
+                }
+            }
+            return ComputeFlags.SIMPLE_REWRITE;
+        }
+        else if (CAP_INJECT.equals(classNode.superName))
+        {
+            Holder cls = new Holder();
+
+            SignatureReader reader = new SignatureReader(classNode.signature); // Having a node version of this would probably be useful.
+            reader.accept(new SignatureVisitor(Opcodes.ASM9)
+            {
+                Deque<String> stack = new ArrayDeque<>();
+
+                @Override
+                public void visitClassType(final String name)
+                {
+                    stack.push(name);
+                }
+
+                @Override
+                public void visitInnerClassType(final String name)
+                {
+                    stack.push(stack.pop() + '$' + name);
+                }
+
+                @Override
+                public void visitEnd()
+                {
+                    var val = stack.pop();
+                    if (!stack.isEmpty() && CAP_INJECT.equals(stack.peek()))
+                        cls.value = val;
+                }
+            });
+
+            if (cls.value == null)
+                throw new IllegalStateException("Could not find signature for CapabilityToken on " + classNode.name + " from " + classNode.signature);
+
+            var mtd = classNode.visitMethod(Opcodes.ACC_PUBLIC, FUNC_NAME, FUNC_DESC, null, new String[0]);
+            mtd.visitLdcInsn(cls.value);
+            mtd.visitInsn(Opcodes.ARETURN);
+            mtd.visitEnd();
+            return ComputeFlags.COMPUTE_MAXS;
+        }
+        else
+        {
+            return ComputeFlags.NO_REWRITE;
+        }
+    }
+
+    private static class Holder {
+        String value;
+    }
+
+}

fmlloader/src/main/java/net/minecraftforge/fml/common/asm/ObjectHolderDefinalize.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,9 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.common.asm;
+package net.minecraftforge.fml.common.asm;
 
-import java.nio.file.Path;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -73,9 +72,9 @@ public class ObjectHolderDefinalize implements ILaunchPluginService {
     }
 
     @Override
-    public boolean processClass(Phase phase, ClassNode classNode, Type classType)
+    public int processClassWithFlags(final Phase phase, final ClassNode classNode, final Type classType, final String reason)
     {
-        AtomicBoolean changes = new AtomicBoolean();
+        final AtomicBoolean changes = new AtomicBoolean();
         //Must be public static finals, and non-array objects
         final int flags = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL;
 
@@ -107,7 +106,7 @@ public class ObjectHolderDefinalize implements ILaunchPluginService {
                 changes.compareAndSet(false, prev != f.access);
             });
         }
-        return changes.get();
+        return changes.get() ? ComputeFlags.SIMPLE_REWRITE : ComputeFlags.NO_REWRITE;
     }
 
 }

fmlloader/src/main/java/net/minecraftforge/fml/common/asm/RuntimeEnumExtender.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,9 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-package net.minecraftforge.common.asm;
+package net.minecraftforge.fml.common.asm;
 
-import java.nio.file.Path;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -69,10 +68,10 @@ public class RuntimeEnumExtender implements ILaunchPluginService {
     }
 
     @Override
-    public boolean processClass(Phase phase, ClassNode classNode, Type classType)
+    public int processClassWithFlags(final Phase phase, final ClassNode classNode, final Type classType, final String reason)
     {
         if ((classNode.access & Opcodes.ACC_ENUM) == 0)
-            return false;
+            return ComputeFlags.NO_REWRITE;
 
         Type array = Type.getType("[" + classType.getDescriptor());
         final int flags = Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC;
@@ -80,7 +79,7 @@ public class RuntimeEnumExtender implements ILaunchPluginService {
         FieldNode values = classNode.fields.stream().filter(f -> f.desc.contentEquals(array.getDescriptor()) && ((f.access & flags) == flags)).findFirst().orElse(null);
         
         if (!classNode.interfaces.contains(MARKER_IFACE.getInternalName())) {
-            return false;
+            return ComputeFlags.NO_REWRITE;
         }
         
         //Static methods named "create" with first argument as a string
@@ -98,8 +97,8 @@ public class RuntimeEnumExtender implements ILaunchPluginService {
             if (args.length == 0 || !args[0].equals(STRING)) {
                 LOGGER.fatal(()->new AdvancedLogMessageAdapter(sb-> {
                     sb.append("Enum has create method without String as first parameter:\n");
-                    sb.append("  Enum: " + classType.getDescriptor()).append("\n");
-                    sb.append("  Target: ").append(mtd.name + mtd.desc).append("\n");
+                    sb.append("  Enum: ").append(classType.getDescriptor()).append("\n");
+                    sb.append("  Target: ").append(mtd.name).append(mtd.desc).append("\n");
                 }));
                 throw new IllegalStateException("Enum has create method without String as first parameter: " + mtd.name + mtd.desc);
             }
@@ -108,8 +107,8 @@ public class RuntimeEnumExtender implements ILaunchPluginService {
             if (!ret.equals(classType)) {
                 LOGGER.fatal(()->new AdvancedLogMessageAdapter(sb-> {
                     sb.append("Enum has create method with incorrect return type:\n");
-                    sb.append("  Enum: " + classType.getDescriptor()).append("\n");
-                    sb.append("  Target: ").append(mtd.name + mtd.desc).append("\n");
+                    sb.append("  Enum: ").append(classType.getDescriptor()).append("\n");
+                    sb.append("  Target: ").append(mtd.name).append(mtd.desc).append("\n");
                     sb.append("  Found: ").append(ret.getClassName()).append(", Expected: ").append(classType.getClassName());
                 }));
                 throw new IllegalStateException("Enum has create method with incorrect return type: " + mtd.name + mtd.desc);
@@ -215,12 +214,15 @@ public class RuntimeEnumExtender implements ILaunchPluginService {
                 //EnumHelper.cleanEnumCache(ThisType.class)
                 ins.visitLdcInsn(classType);
                 ins.invokestatic(UNSAFE_HACKS.getInternalName(), "cleanEnumCache", CLEAN_DESC, false);
+                //init ret
+                ins.load(vars, classType);
+                ins.invokeinterface(MARKER_IFACE.getInternalName(), "init", "()V");
                 //return ret
                 ins.load(vars, classType);
                 ins.areturn(classType);
             }
         });
-        return true;
+        return ComputeFlags.COMPUTE_FRAMES;
     }
 
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/AdvancedLogMessageAdapter.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,6 +25,8 @@ import org.apache.logging.log4j.util.StringBuilderFormattable;
 import java.util.function.Consumer;
 
 public class AdvancedLogMessageAdapter implements Message, StringBuilderFormattable {
+    private static final long serialVersionUID = -8291754833965087436L;
+
     private static final Object[] EMPTY = new Object[0];
 
     private final Consumer<StringBuilder> logMessageBuilder;

fmlloader/src/main/java/net/minecraftforge/fml/loading/BackgroundWaiter.java

@@ -0,0 +1,48 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class BackgroundWaiter {
+    private static ExecutorService runner = Executors.newSingleThreadExecutor();
+
+    public static void runAndTick(Runnable r, Runnable tick) {
+        final Future<?> work = runner.submit(r);
+        do {
+            tick.run();
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException ignored) {
+            }
+        } while (!work.isDone());
+        try {
+            runner.shutdown();
+            work.get();
+        } catch (ExecutionException ee) {
+            throw new RuntimeException(ee.getCause());
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/EarlyLoadingException.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,6 +19,8 @@
 
 package net.minecraftforge.fml.loading;
 
+import net.minecraftforge.forgespi.language.IModInfo;
+
 import java.util.List;
 
 /**
@@ -27,12 +29,17 @@ import java.util.List;
  */
 public class EarlyLoadingException extends RuntimeException {
     public static class ExceptionData {
-
-
+        private final IModInfo modInfo;
         private final String i18message;
         private final Object[] args;
+
         public ExceptionData(final String message, Object... args) {
+            this(message, null, args);
+        }
+
+        public ExceptionData(final String message, final IModInfo modInfo, Object... args) {
             this.i18message = message;
+            this.modInfo = modInfo;
             this.args = args;
         }
 
@@ -43,6 +50,10 @@ public class EarlyLoadingException extends RuntimeException {
         public Object[] getArgs() {
             return args;
         }
+
+        public IModInfo getModInfo() {
+            return modInfo;
+        }
     }
     private final List<ExceptionData> errorMessages;
 

fmlloader/src/main/java/net/minecraftforge/fml/loading/FMLConfig.java

@@ -0,0 +1,102 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import com.electronwill.nightconfig.core.ConfigSpec;
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import com.electronwill.nightconfig.core.file.FileNotFoundAction;
+import com.electronwill.nightconfig.core.io.ParsingException;
+import com.electronwill.nightconfig.core.io.WritingMode;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+
+import static net.minecraftforge.fml.loading.LogMarkers.CORE;
+
+public class FMLConfig
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static FMLConfig INSTANCE = new FMLConfig();
+    private static ConfigSpec configSpec = new ConfigSpec();
+    static {
+        configSpec.define("splashscreen", Boolean.TRUE);
+        configSpec.define("maxThreads", -1);
+        configSpec.define("versionCheck", Boolean.TRUE);
+        configSpec.define("defaultConfigPath",  "defaultconfigs");
+    }
+
+    private CommentedFileConfig configData;
+
+    private void loadFrom(final Path configFile)
+    {
+        configData = CommentedFileConfig.builder(configFile).sync()
+                .onFileNotFound(FileNotFoundAction.copyData(Objects.requireNonNull(getClass().getResourceAsStream("/META-INF/defaultfmlconfig.toml"))))
+                .autosave().autoreload()
+                .writingMode(WritingMode.REPLACE)
+                .build();
+        try
+        {
+            configData.load();
+        }
+        catch (ParsingException e)
+        {
+            throw new RuntimeException("Failed to load FML config from " + configFile.toString(), e);
+        }
+        if (!configSpec.isCorrect(configData)) {
+            LOGGER.warn(CORE, "Configuration file {} is not correct. Correcting", configFile);
+            configSpec.correct(configData, (action, path, incorrectValue, correctedValue) ->
+                    LOGGER.warn(CORE, "Incorrect key {} was corrected from {} to {}", path, incorrectValue, correctedValue));
+        }
+        configData.save();
+    }
+
+    public static void load()
+    {
+        final Path configFile = FMLPaths.FMLCONFIG.get();
+        INSTANCE.loadFrom(configFile);
+        LOGGER.trace(CORE, "Loaded FML config from {}", FMLPaths.FMLCONFIG.get());
+        LOGGER.trace(CORE, "Splash screen is {}", FMLConfig::splashScreenEnabled);
+        LOGGER.trace(CORE, "Max threads for mod loading computed at {}", FMLConfig::loadingThreadCount);
+        LOGGER.trace(CORE, "Version check is {}", FMLConfig::runVersionCheck);
+        LOGGER.trace(CORE, "Default config paths at {}", FMLConfig::defaultConfigPath);
+        FMLPaths.getOrCreateGameRelativePath(Paths.get(FMLConfig.defaultConfigPath()), "default config directory");
+    }
+
+    public static boolean splashScreenEnabled() {
+        return INSTANCE.configData.<Boolean>getOptional("splashscreen").orElse(Boolean.FALSE);
+    }
+
+    public static int loadingThreadCount() {
+        int val = INSTANCE.configData.<Integer>getOptional("maxThreads").orElse(-1);
+        if (val <= 0) return Runtime.getRuntime().availableProcessors();
+        return val;
+    }
+
+    public static boolean runVersionCheck() {
+        return INSTANCE.configData.<Boolean>getOptional("versionCheck").orElse(Boolean.TRUE);
+    }
+
+    public static String defaultConfigPath() {
+        return INSTANCE.configData.<String>getOptional("defaultConfigPath").orElse("defaultconfigs");
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/FMLEnvironment.java

@@ -0,0 +1,44 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import cpw.mods.modlauncher.api.IEnvironment;
+import cpw.mods.modlauncher.api.TypesafeMap;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.forgespi.Environment;
+
+import java.util.function.Supplier;
+
+public class FMLEnvironment
+{
+    public static final Dist dist = FMLLoader.getDist();
+    public static final String naming = FMLLoader.getNaming();
+    public static final boolean production = FMLLoader.isProduction() || System.getProperties().containsKey("production");
+    public static final boolean secureJarsEnabled = FMLLoader.isSecureJarEnabled();
+
+    static void setupInteropEnvironment(IEnvironment environment) {
+        environment.computePropertyIfAbsent(IEnvironment.Keys.NAMING.get(), v->naming);
+        environment.computePropertyIfAbsent(Environment.Keys.DIST.get(), v->dist);
+    }
+
+    public static class Keys {
+        public static final Supplier<TypesafeMap.Key<ClassLoader>> LOCATORCLASSLOADER = IEnvironment.buildKey("LOCATORCLASSLOADER",ClassLoader.class);
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/FMLLoader.java

@@ -0,0 +1,273 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import cpw.mods.modlauncher.Launcher;
+import cpw.mods.modlauncher.api.*;
+import cpw.mods.modlauncher.serviceapi.ILaunchPluginService;
+import cpw.mods.modlauncher.util.ServiceLoaderUtils;
+import net.minecraftforge.fml.loading.moddiscovery.BackgroundScanHandler;
+import net.minecraftforge.fml.loading.moddiscovery.ModDiscoverer;
+import net.minecraftforge.fml.loading.moddiscovery.ModFile;
+import net.minecraftforge.fml.loading.moddiscovery.ModValidator;
+import net.minecraftforge.accesstransformer.service.AccessTransformerService;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.fml.loading.progress.EarlyProgressVisualization;
+import net.minecraftforge.fml.loading.progress.StartupMessageManager;
+import net.minecraftforge.fml.loading.targets.CommonLaunchHandler;
+import net.minecraftforge.forgespi.Environment;
+import net.minecraftforge.forgespi.coremod.ICoreModProvider;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+
+import static net.minecraftforge.fml.loading.LogMarkers.CORE;
+import static net.minecraftforge.fml.loading.LogMarkers.SCAN;
+
+public class FMLLoader
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static AccessTransformerService accessTransformer;
+    private static ModDiscoverer modDiscoverer;
+    private static ICoreModProvider coreModProvider;
+    private static ILaunchPluginService eventBus;
+    private static LanguageLoadingProvider languageLoadingProvider;
+    private static Dist dist;
+    private static String naming;
+    private static LoadingModList loadingModList;
+    private static RuntimeDistCleaner runtimeDistCleaner;
+    private static Path gamePath;
+    private static VersionInfo versionInfo;
+    private static String launchHandlerName;
+    private static CommonLaunchHandler commonLaunchHandler;
+    public static Runnable progressWindowTick;
+    private static ModValidator modValidator;
+    public static BackgroundScanHandler backgroundScanHandler;
+    private static boolean production;
+    private static IModuleLayerManager moduleLayerManager;
+
+    static void onInitialLoad(IEnvironment environment, Set<String> otherServices) throws IncompatibleEnvironmentException
+    {
+        final String version = LauncherVersion.getVersion();
+        LOGGER.debug(CORE,"FML {} loading", version);
+        final Package modLauncherPackage = ITransformationService.class.getPackage();
+        LOGGER.debug(CORE,"FML found ModLauncher version : {}", modLauncherPackage.getImplementationVersion());
+        if (!modLauncherPackage.isCompatibleWith("4.0")) {
+            LOGGER.fatal(CORE,"Found incompatible ModLauncher specification : {}, version {} from {}", modLauncherPackage.getSpecificationVersion(), modLauncherPackage.getImplementationVersion(), modLauncherPackage.getImplementationVendor());
+            throw new IncompatibleEnvironmentException("Incompatible modlauncher found "+modLauncherPackage.getSpecificationVersion());
+        }
+
+        accessTransformer = (AccessTransformerService) environment.findLaunchPlugin("accesstransformer").orElseThrow(()-> {
+            LOGGER.fatal(CORE,"Access Transformer library is missing, we need this to run");
+            return new IncompatibleEnvironmentException("Missing AccessTransformer, cannot run");
+        });
+
+        final Package atPackage = accessTransformer.getClass().getPackage();
+        LOGGER.debug(CORE,"FML found AccessTransformer version : {}", atPackage.getImplementationVersion());
+        if (!atPackage.isCompatibleWith("1.0")) {
+            LOGGER.fatal(CORE,"Found incompatible AccessTransformer specification : {}, version {} from {}", atPackage.getSpecificationVersion(), atPackage.getImplementationVersion(), atPackage.getImplementationVendor());
+            throw new IncompatibleEnvironmentException("Incompatible accesstransformer found "+atPackage.getSpecificationVersion());
+        }
+
+        eventBus = environment.findLaunchPlugin("eventbus").orElseThrow(()-> {
+            LOGGER.fatal(CORE,"Event Bus library is missing, we need this to run");
+            return new IncompatibleEnvironmentException("Missing EventBus, cannot run");
+        });
+
+        final Package eventBusPackage = eventBus.getClass().getPackage();
+        LOGGER.debug(CORE,"FML found EventBus version : {}", eventBusPackage.getImplementationVersion());
+        if (!eventBusPackage.isCompatibleWith("1.0")) {
+            LOGGER.fatal(CORE,"Found incompatible EventBus specification : {}, version {} from {}", eventBusPackage.getSpecificationVersion(), eventBusPackage.getImplementationVersion(), eventBusPackage.getImplementationVendor());
+            throw new IncompatibleEnvironmentException("Incompatible eventbus found "+eventBusPackage.getSpecificationVersion());
+        }
+
+        runtimeDistCleaner = (RuntimeDistCleaner)environment.findLaunchPlugin("runtimedistcleaner").orElseThrow(()-> {
+            LOGGER.fatal(CORE,"Dist Cleaner is missing, we need this to run");
+            return new IncompatibleEnvironmentException("Missing DistCleaner, cannot run!");
+        });
+        LOGGER.debug(CORE, "Found Runtime Dist Cleaner");
+
+        var coreModProviders = ServiceLoaderUtils.streamWithErrorHandling(ServiceLoader.load(FMLLoader.class.getModule().getLayer(), ICoreModProvider.class), sce -> LOGGER.fatal(CORE, "Failed to load a coremod library, expect problems", sce)).toList();
+
+        if (coreModProviders.isEmpty()) {
+            LOGGER.fatal(CORE, "Found no coremod provider. Cannot run");
+            throw new IncompatibleEnvironmentException("No coremod library found");
+        } else if (coreModProviders.size() > 1) {
+            LOGGER.fatal(CORE, "Found multiple coremod providers : {}. Cannot run", coreModProviders.stream().map(p -> p.getClass().getName()).collect(Collectors.toList()));
+            throw new IncompatibleEnvironmentException("Multiple coremod libraries found");
+        }
+
+        coreModProvider = coreModProviders.get(0);
+        final Package coremodPackage = coreModProvider.getClass().getPackage();
+        LOGGER.debug(CORE,"FML found CoreMod version : {}", coremodPackage.getImplementationVersion());
+
+
+        LOGGER.debug(CORE, "Found ForgeSPI package implementation version {}", Environment.class.getPackage().getImplementationVersion());
+        LOGGER.debug(CORE, "Found ForgeSPI package specification {}", Environment.class.getPackage().getSpecificationVersion());
+        if (Integer.parseInt(Environment.class.getPackage().getSpecificationVersion()) < 2) {
+            LOGGER.fatal(CORE, "Found an out of date ForgeSPI implementation: {}, loading cannot continue", Environment.class.getPackage().getSpecificationVersion());
+            throw new IncompatibleEnvironmentException("ForgeSPI is out of date, we cannot continue");
+        }
+
+        try {
+            Class.forName("com.electronwill.nightconfig.core.Config", false, environment.getClass().getClassLoader());
+            Class.forName("com.electronwill.nightconfig.toml.TomlFormat", false, environment.getClass().getClassLoader());
+        } catch (ClassNotFoundException e) {
+            LOGGER.fatal(CORE, "Failed to load NightConfig");
+            throw new IncompatibleEnvironmentException("Missing NightConfig");
+        }
+    }
+
+    static void setupLaunchHandler(final IEnvironment environment, final Map<String, Object> arguments)
+    {
+        final String launchTarget = environment.getProperty(IEnvironment.Keys.LAUNCHTARGET.get()).orElse("MISSING");
+        arguments.put("launchTarget", launchTarget);
+        final Optional<ILaunchHandlerService> launchHandler = environment.findLaunchHandler(launchTarget);
+        LOGGER.debug(CORE, "Using {} as launch service", launchTarget);
+        if (launchHandler.isEmpty()) {
+            LOGGER.fatal(CORE,"Missing LaunchHandler {}, cannot continue", launchTarget);
+            throw new RuntimeException("Missing launch handler: " + launchTarget);
+        }
+
+        if (!(launchHandler.get() instanceof CommonLaunchHandler)) {
+            LOGGER.fatal(CORE, "Incompatible Launch handler found - type {}, cannot continue", launchHandler.get().getClass().getName());
+            throw new RuntimeException("Incompatible launch handler found");
+        }
+        commonLaunchHandler = (CommonLaunchHandler)launchHandler.get();
+        launchHandlerName = launchHandler.get().name();
+        gamePath = environment.getProperty(IEnvironment.Keys.GAMEDIR.get()).orElse(Paths.get(".").toAbsolutePath());
+
+        naming = commonLaunchHandler.getNaming();
+        dist = commonLaunchHandler.getDist();
+        production = commonLaunchHandler.isProduction();
+
+        versionInfo = new VersionInfo(arguments);
+
+        StartupMessageManager.modLoaderConsumer().ifPresent(c->c.accept("Early Loading!"));
+        accessTransformer.getExtension().accept(Pair.of(naming, "srg"));
+
+        LOGGER.debug(CORE,"Received command line version data  : {}", versionInfo);
+
+        runtimeDistCleaner.getExtension().accept(dist);
+    }
+    public static List<ITransformationService.Resource> beginModScan(final Map<String,?> arguments)
+    {
+        LOGGER.debug(SCAN,"Scanning for Mod Locators");
+        modDiscoverer = new ModDiscoverer(arguments);
+        modValidator = modDiscoverer.discoverMods();
+        var pluginResources = modValidator.getPluginResources();
+        return List.of(pluginResources);
+    }
+
+    public static List<ITransformationService.Resource> completeScan(IModuleLayerManager layerManager) {
+        progressWindowTick = EarlyProgressVisualization.INSTANCE.accept(dist, commonLaunchHandler.isData(), versionInfo.mcVersion());
+        moduleLayerManager = layerManager;
+        languageLoadingProvider = new LanguageLoadingProvider();
+        backgroundScanHandler = modValidator.stage2Validation();
+        loadingModList = backgroundScanHandler.getLoadingModList();
+        return List.of(modValidator.getModResources());
+    }
+
+    public static ICoreModProvider getCoreModProvider() {
+        return coreModProvider;
+    }
+
+    public static LanguageLoadingProvider getLanguageLoadingProvider()
+    {
+        return languageLoadingProvider;
+    }
+
+    static ModDiscoverer getModDiscoverer() {
+        return modDiscoverer;
+    }
+
+    public static CommonLaunchHandler getLaunchHandler() {
+        return commonLaunchHandler;
+    }
+
+    public static void addAccessTransformer(Path atPath, ModFile modName)
+    {
+        LOGGER.debug(SCAN, "Adding Access Transformer in {}", modName.getFilePath());
+        accessTransformer.offerResource(atPath, modName.getFileName());
+    }
+
+    public static Dist getDist()
+    {
+        return dist;
+    }
+
+    public static void beforeStart(ClassLoader launchClassLoader)
+    {
+        StartupMessageManager.modLoaderConsumer().ifPresent(c->c.accept("Launching minecraft"));
+        progressWindowTick.run();
+    }
+
+    public static LoadingModList getLoadingModList()
+    {
+        return loadingModList;
+    }
+
+    public static Path getGamePath()
+    {
+        return gamePath;
+    }
+
+    public static String getNaming() {
+        return naming;
+    }
+
+    public static Optional<BiFunction<INameMappingService.Domain, String, String>> getNameFunction(final String naming) {
+        return Launcher.INSTANCE.environment().findNameMapping(naming);
+    }
+
+    public static String getLauncherInfo() {
+        return Launcher.INSTANCE.environment().getProperty(IEnvironment.Keys.MLIMPL_VERSION.get()).orElse("MISSING");
+    }
+
+    public static List<Map<String, String>> modLauncherModList() {
+        return Launcher.INSTANCE.environment().getProperty(IEnvironment.Keys.MODLIST.get()).orElseGet(Collections::emptyList);
+    }
+
+    public static String launcherHandlerName() {
+        return launchHandlerName;
+    }
+
+    public static boolean isProduction() {
+        return production;
+    }
+
+    public static boolean isSecureJarEnabled() {
+        return true;
+    }
+
+    public static ModuleLayer getGameLayer() {
+        return moduleLayerManager.getLayer(IModuleLayerManager.Layer.GAME).orElseThrow();
+    }
+
+    public static VersionInfo versionInfo() {
+        return versionInfo;
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/FMLPaths.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -50,16 +50,16 @@ public enum FMLPaths
         this.isDirectory = true;
     }
 
-    private Path computePath(String... path)
-    {
-        return Paths.get(path[0], Arrays.copyOfRange(path, 1, path.length));
-    }
-
     FMLPaths(boolean isDir, FMLPaths parent, String... path) {
         this.relativePath = parent.relativePath.resolve(computePath(path));
         this.isDirectory = isDir;
     }
 
+    private Path computePath(String... path)
+    {
+        return Paths.get(path[0], Arrays.copyOfRange(path, 1, path.length));
+    }
+
     public static void setup(IEnvironment env) {
         final Path rootPath = env.getProperty(IEnvironment.Keys.GAMEDIR.get()).orElseThrow(() -> new RuntimeException("No game path found"));
 
@@ -79,6 +79,10 @@ public enum FMLPaths
         }
     }
 
+    public static Path getOrCreateGameRelativePath(Path path, String name) {
+        return FileUtils.getOrCreateDirectory(FMLPaths.GAMEDIR.get().resolve(path), name);
+    }
+
     public Path relative() {
         return relativePath;
     }

fmlloader/src/main/java/net/minecraftforge/fml/loading/FMLServiceProvider.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,25 +19,27 @@
 
 package net.minecraftforge.fml.loading;
 
-import cpw.mods.modlauncher.api.IEnvironment;
-import cpw.mods.modlauncher.api.ITransformationService;
-import cpw.mods.modlauncher.api.ITransformer;
-import cpw.mods.modlauncher.api.IncompatibleEnvironmentException;
+import cpw.mods.modlauncher.api.*;
 import joptsimple.ArgumentAcceptingOptionSpec;
 import joptsimple.OptionSpecBuilder;
+import net.minecraftforge.fml.loading.moddiscovery.ModFile;
 import net.minecraftforge.forgespi.Environment;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
 
-import javax.annotation.Nonnull;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
 import java.util.function.BiFunction;
-
 import static net.minecraftforge.fml.loading.LogMarkers.CORE;
 
 public class FMLServiceProvider implements ITransformationService
 {
-
     private static final Logger LOGGER = LogManager.getLogger();
     private ArgumentAcceptingOptionSpec<String> modsOption;
     private ArgumentAcceptingOptionSpec<String> modListsOption;
@@ -57,6 +59,12 @@ public class FMLServiceProvider implements ITransformationService
     private String targetForgeGroup;
     private Map<String, Object> arguments;
 
+    public FMLServiceProvider()
+    {
+        final String markerselection = System.getProperty("forge.logging.markers", "");
+        Arrays.stream(markerselection.split(",")).forEach(marker -> System.setProperty("forge.logging.marker." + marker.toLowerCase(Locale.ROOT), "ACCEPT"));
+    }
+
     @Override
     public String name()
     {
@@ -69,6 +77,8 @@ public class FMLServiceProvider implements ITransformationService
         FMLPaths.setup(environment);
         LOGGER.debug(CORE, "Loading configuration");
         FMLConfig.load();
+        LOGGER.debug(CORE, "Preparing ModFile");
+        environment.computePropertyIfAbsent(Environment.Keys.MODFILEFACTORY.get(), k->ModFile::new);
         arguments = new HashMap<>();
         arguments.put("modLists", modListsArgumentList);
         arguments.put("mods", modsArgumentList);
@@ -85,17 +95,22 @@ public class FMLServiceProvider implements ITransformationService
     }
 
     @Override
-    public void beginScanning(final IEnvironment environment) {
+    public List<Resource> beginScanning(final IEnvironment environment) {
         LOGGER.debug(CORE,"Initiating mod scan");
-        FMLLoader.beginModScan(arguments);
+        return FMLLoader.beginModScan(arguments);
+    }
+
+    @Override
+    public List<Resource> completeScan(final IModuleLayerManager layerManager) {
+        return FMLLoader.completeScan(layerManager);
     }
 
     @Override
     public void onLoad(IEnvironment environment, Set<String> otherServices) throws IncompatibleEnvironmentException
     {
-        LOGGER.debug("Injecting tracing printstreams for STDOUT/STDERR.");
-        System.setOut(new TracingPrintStream(LogManager.getLogger("STDOUT"), System.out));
-        System.setErr(new TracingPrintStream(LogManager.getLogger("STDERR"), System.err));
+//        LOGGER.debug("Injecting tracing printstreams for STDOUT/STDERR.");
+//        System.setOut(new TracingPrintStream(LogManager.getLogger("STDOUT"), System.out));
+//        System.setErr(new TracingPrintStream(LogManager.getLogger("STDERR"), System.err));
         FMLLoader.onInitialLoad(environment, otherServices);
     }
 
@@ -125,9 +140,8 @@ public class FMLServiceProvider implements ITransformationService
         targetMcpMappings = option.value(mappingsOption);
     }
 
-    @Nonnull
     @Override
-    public List<ITransformer> transformers()
+    public @NotNull List<ITransformer> transformers()
     {
         LOGGER.debug(CORE, "Loading coremod transformers");
         return new ArrayList<>(FMLLoader.getCoreModProvider().getCoreModTransformers());

fmlloader/src/main/java/net/minecraftforge/fml/loading/FileUtils.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

fmlloader/src/main/java/net/minecraftforge/fml/loading/JarVersionLookupHandler.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

fmlloader/src/main/java/net/minecraftforge/fml/loading/LanguageLoadingProvider.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,7 +19,10 @@
 
 package net.minecraftforge.fml.loading;
 
-import cpw.mods.modlauncher.ServiceLoaderStreamUtils;
+import cpw.mods.modlauncher.Launcher;
+import cpw.mods.modlauncher.api.IModuleLayerManager;
+import cpw.mods.modlauncher.util.ServiceLoaderUtils;
+import net.minecraftforge.fml.loading.progress.StartupMessageManager;
 import net.minecraftforge.forgespi.language.IModLanguageProvider;
 import net.minecraftforge.fml.loading.moddiscovery.ExplodedDirectoryLocator;
 import net.minecraftforge.fml.loading.moddiscovery.ModFile;
@@ -29,25 +32,27 @@ import org.apache.maven.artifact.versioning.ArtifactVersion;
 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
 import org.apache.maven.artifact.versioning.VersionRange;
 
-import java.io.File;
-import java.net.URI;
 import java.net.URISyntaxException;
-import java.net.URL;
-import java.net.URLClassLoader;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.ServiceLoader;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
-import static cpw.mods.modlauncher.api.LamdbaExceptionUtils.rethrowFunction;
 import static net.minecraftforge.fml.loading.LogMarkers.CORE;
+import static net.minecraftforge.fml.loading.LogMarkers.LOADING;
 
 public class LanguageLoadingProvider
 {
     private static final Logger LOGGER = LogManager.getLogger();
-    private final LanguageClassLoader languageClassLoader;
     private final List<IModLanguageProvider> languageProviders = new ArrayList<>();
     private final ServiceLoader<IModLanguageProvider> serviceLoader;
     private final Map<String, ModLanguageWrapper> languageProviderMap = new HashMap<>();
@@ -58,8 +63,11 @@ public class LanguageLoadingProvider
         languageProviders.forEach(consumer);
     }
 
-    private static class ModLanguageWrapper {
+    public <T> Stream<T> applyForEach(final Function<IModLanguageProvider, T> function) {
+        return languageProviders.stream().map(function);
+    }
 
+    private static class ModLanguageWrapper {
         private final IModLanguageProvider modLanguageProvider;
 
         private final ArtifactVersion version;
@@ -80,26 +88,14 @@ public class LanguageLoadingProvider
 
 
     }
-    private static class LanguageClassLoader extends URLClassLoader
-    {
-        public LanguageClassLoader() {
-            super(new URL[0]);
-        }
 
-        @Override
-        public void addURL(final URL url) {
-            LOGGER.debug(CORE, "Adding {} to languageloader classloader", url);
-            super.addURL(url);
-        }
-
-    }
     LanguageLoadingProvider() {
-        languageClassLoader = new LanguageClassLoader();
-        serviceLoader = ServiceLoader.load(IModLanguageProvider.class, languageClassLoader);
+        var sl = Launcher.INSTANCE.environment().findModuleLayerManager().flatMap(lm->lm.getLayer(IModuleLayerManager.Layer.PLUGIN)).orElseThrow();
+        serviceLoader = ServiceLoader.load(sl, IModLanguageProvider.class);
         loadLanguageProviders();
     }
     private void loadLanguageProviders() {
-        LOGGER.debug(CORE, "Found {} language providers", ServiceLoaderStreamUtils.toList(serviceLoader).size());
+        LOGGER.debug(CORE, "Found {} language providers", ServiceLoaderUtils.streamServiceLoader(()->serviceLoader, sce->LOGGER.fatal("Problem with language loaders")).count());
         serviceLoader.forEach(languageProviders::add);
 
         languageProviders.forEach(lp -> {
@@ -110,12 +106,13 @@ public class LanguageLoadingProvider
                 throw new RuntimeException("Huh?", e);
             }
             Optional<String> implementationVersion = JarVersionLookupHandler.getImplementationVersion(lp.getClass());
-            String impl = implementationVersion.orElse(Files.isDirectory(lpPath) ? FMLLoader.forgeVersion.split("\\.")[0] : null);
+            String impl = implementationVersion.orElse(Files.isDirectory(lpPath) ? FMLLoader.versionInfo().forgeVersion().split("\\.")[0] : null);
             if (impl == null) {
                 LOGGER.fatal(CORE, "Found unversioned language provider {}", lp.name());
                 throw new RuntimeException("Failed to find implementation version for language provider "+ lp.name());
             }
             LOGGER.debug(CORE, "Found language provider {}, version {}", lp.name(), impl);
+            StartupMessageManager.modLoaderConsumer().ifPresent(c->c.accept("Loaded language provider "+lp.name()+ " " + impl));
             languageProviderMap.put(lp.name(), new ModLanguageWrapper(lp, new DefaultArtifactVersion(impl)));
         });
     }
@@ -134,7 +131,7 @@ public class LanguageLoadingProvider
     private void addLanguagePaths(final Stream<Path> langPaths) {
         languageProviders.clear();
         languageProviderMap.clear();
-        langPaths.peek(languagePaths::add).map(Path::toFile).map(File::toURI).map(rethrowFunction(URI::toURL)).forEach(languageClassLoader::addURL);
+//        langPaths.peek(languagePaths::add).map(Path::toFile).map(File::toURI).map(rethrowFunction(URI::toURL)).forEach(languageClassLoader::addURL);
     }
 
     public void addAdditionalLanguages(List<ModFile> modFiles)
@@ -154,11 +151,11 @@ public class LanguageLoadingProvider
         final String languageFileName = mf.getLocator() instanceof ExplodedDirectoryLocator ? "in-development" : mf.getFileName();
         final ModLanguageWrapper mlw = languageProviderMap.get(modLoader);
         if (mlw == null) {
-            LOGGER.error("Missing language {} version {} wanted by {}", modLoader, modLoaderVersion, languageFileName);
+            LOGGER.error(LOADING,"Missing language {} version {} wanted by {}", modLoader, modLoaderVersion, languageFileName);
             throw new EarlyLoadingException("Missing language "+modLoader, null, Collections.singletonList(new EarlyLoadingException.ExceptionData("fml.language.missingversion", modLoader, modLoaderVersion, languageFileName, "null")));
         }
-        if (!modLoaderVersion.containsVersion(mlw.getVersion())) {
-            LOGGER.error("Missing language {} version {} wanted by {}, found {}", modLoader, modLoaderVersion, languageFileName, mlw.getVersion());
+        if (!VersionSupportMatrix.testVersionSupportMatrix(modLoaderVersion, modLoader, "languageloader", (llid, range) -> range.containsVersion(mlw.getVersion()))) {
+            LOGGER.error(LOADING,"Missing language {} version {} wanted by {}, found {}", modLoader, modLoaderVersion, languageFileName, mlw.getVersion());
             throw new EarlyLoadingException("Missing language "+ modLoader + " matching range "+modLoaderVersion + " found "+mlw.getVersion(), null, Collections.singletonList(new EarlyLoadingException.ExceptionData("fml.language.missingversion", modLoader, modLoaderVersion, languageFileName, mlw.getVersion())));
         }
 

fmlloader/src/main/java/net/minecraftforge/fml/loading/LauncherVersion.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

fmlloader/src/main/java/net/minecraftforge/fml/loading/LibraryFinder.java

@@ -0,0 +1,67 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class LibraryFinder {
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static Path libsPath;
+    static Path findLibsPath() {
+        if (libsPath == null) {
+            libsPath = Path.of(System.getProperty("libraryDirectory","crazysnowmannonsense/cheezwhizz"));
+            if (!Files.isDirectory(libsPath)) {
+                throw new IllegalStateException("Missing libraryDirectory system property, cannot continue");
+            }
+        }
+        return libsPath;
+    }
+
+    static Path getForgeLibraryPath(final String mcVersion, final String forgeVersion, final String forgeGroup) {
+        Path forgePath = findLibsPath().resolve(MavenCoordinateResolver.get(forgeGroup, "forge", "", "universal", mcVersion+"-"+forgeVersion));
+        LOGGER.debug(LogMarkers.CORE, "Found forge path {} is {}", forgePath, pathStatus(forgePath));
+        return forgePath;
+    }
+
+    static String pathStatus(final Path path) {
+        return Files.exists(path) ? "present" : "missing";
+    }
+
+    static Path[] getMCPaths(final String mcVersion, final String mcpVersion, final String forgeVersion, final String forgeGroup, final String type) {
+        Path srgMcPath = findLibsPath().resolve(MavenCoordinateResolver.get("net.minecraft", type, "", "srg", mcVersion+"-"+mcpVersion));
+        Path mcExtrasPath = findLibsPath().resolve(MavenCoordinateResolver.get("net.minecraft", type, "", "extra", mcVersion+"-"+mcpVersion));
+        Path patchedBinariesPath = findLibsPath().resolve(MavenCoordinateResolver.get(forgeGroup, "forge", "", type, mcVersion+"-"+forgeVersion));
+        LOGGER.debug(LogMarkers.CORE,"SRG MC at {} is {}", srgMcPath.toString(), pathStatus(srgMcPath));
+        LOGGER.debug(LogMarkers.CORE,"MC Extras at {} is {}", mcExtrasPath.toString(), pathStatus(mcExtrasPath));
+        LOGGER.debug(LogMarkers.CORE,"Forge patches at {} is {}", patchedBinariesPath.toString(), pathStatus(patchedBinariesPath));
+        return new Path[] { patchedBinariesPath, mcExtrasPath, srgMcPath };
+    }
+
+    public static Path findPathForMaven(final String group, final String artifact, final String extension, final String classifier, final String version) {
+        return findLibsPath().resolve(MavenCoordinateResolver.get(group, artifact, extension, classifier, version));
+    }
+    public static Path findPathForMaven(final String maven) {
+        return findLibsPath().resolve(MavenCoordinateResolver.get(maven));
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/LoadingModList.java

@@ -0,0 +1,178 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import cpw.mods.modlauncher.api.LamdbaExceptionUtils;
+import net.minecraftforge.fml.loading.moddiscovery.BackgroundScanHandler;
+import net.minecraftforge.fml.loading.moddiscovery.ModFile;
+import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
+import net.minecraftforge.fml.loading.moddiscovery.ModInfo;
+
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Master list of all mods <em>in the loading context. This class cannot refer outside the
+ * loading package</em>
+ */
+public class LoadingModList
+{
+    private static LoadingModList INSTANCE;
+    private final List<ModFileInfo> modFiles;
+    private final List<ModInfo> sortedList;
+    private final Map<String, ModFileInfo> fileById;
+    private final List<EarlyLoadingException> preLoadErrors;
+    private List<ModFile> brokenFiles;
+
+    private LoadingModList(final List<ModFile> modFiles, final List<ModInfo> sortedList)
+    {
+        this.modFiles = modFiles.stream()
+                .map(ModFile::getModFileInfo)
+                .map(ModFileInfo.class::cast)
+                .collect(Collectors.toList());
+        this.sortedList = sortedList.stream()
+                .map(ModInfo.class::cast)
+                .collect(Collectors.toList());
+        this.fileById = this.modFiles.stream()
+                .map(ModFileInfo::getMods)
+                .flatMap(Collection::stream)
+                .map(ModInfo.class::cast)
+                .collect(Collectors.toMap(ModInfo::getModId, ModInfo::getOwningFile));
+        this.preLoadErrors = new ArrayList<>();
+    }
+
+    public static LoadingModList of(List<ModFile> modFiles, List<ModInfo> sortedList, final EarlyLoadingException earlyLoadingException)
+    {
+        INSTANCE = new LoadingModList(modFiles, sortedList);
+        if (earlyLoadingException != null)
+        {
+            INSTANCE.preLoadErrors.add(earlyLoadingException);
+        }
+        return INSTANCE;
+    }
+
+    public static LoadingModList get() {
+        return INSTANCE;
+    }
+    public void addCoreMods()
+    {
+        modFiles.stream()
+                .map(ModFileInfo::getFile)
+                .map(ModFile::getCoreMods)
+                .flatMap(List::stream)
+                .forEach(FMLLoader.getCoreModProvider()::addCoreMod);
+    }
+
+    public void addAccessTransformers()
+    {
+        modFiles.stream()
+                .map(ModFileInfo::getFile)
+                .forEach(mod -> mod.getAccessTransformer().ifPresent(path -> FMLLoader.addAccessTransformer(path, mod)));
+    }
+
+    public void addForScanning(BackgroundScanHandler backgroundScanHandler)
+    {
+        backgroundScanHandler.setLoadingModList(this);
+        modFiles.stream()
+                .map(ModFileInfo::getFile)
+                .forEach(backgroundScanHandler::submitForScanning);
+    }
+
+    public List<ModFileInfo> getModFiles()
+    {
+        return modFiles;
+    }
+
+    public Path findResource(final String className)
+    {
+        for (ModFileInfo mf : modFiles) {
+            final Path resource = mf.getFile().findResource(className);
+            if (Files.exists(resource)) return resource;
+        }
+        return null;
+    }
+
+    public Enumeration<URL> findAllURLsForResource(final String resName) {
+        final String resourceName;
+        // strip a leading slash
+        if (resName.startsWith("/")) {
+            resourceName = resName.substring(1);
+        } else {
+            resourceName = resName;
+        }
+        return new Enumeration<URL>() {
+            private final Iterator<ModFileInfo> modFileIterator = modFiles.iterator();
+            private URL next;
+            @Override
+            public boolean hasMoreElements() {
+                if (next!=null) return true;
+                next = findNextURL();
+                return next != null;
+            }
+
+            @Override
+            public URL nextElement() {
+                if (next == null) {
+                    next = findNextURL();
+                    if (next == null) throw new NoSuchElementException();
+                }
+                URL result = next;
+                next = null;
+                return result;
+            }
+
+            private URL findNextURL() {
+                while (modFileIterator.hasNext()) {
+                    final ModFileInfo next = modFileIterator.next();
+                    final Path resource = next.getFile().findResource(resourceName);
+                    if (Files.exists(resource)) {
+                        return LamdbaExceptionUtils.uncheck(()->new URL("modjar://" + next.getMods().get(0).getModId() + "/" + resourceName));
+                    }
+                }
+                return null;
+            }
+        };
+    }
+
+    public ModFileInfo getModFileById(String modid)
+    {
+        return this.fileById.get(modid);
+    }
+
+    public List<ModInfo> getMods()
+    {
+        return this.sortedList;
+    }
+
+    public List<EarlyLoadingException> getErrors() {
+        return preLoadErrors;
+    }
+
+    public void setBrokenFiles(final List<ModFile> brokenFiles) {
+        this.brokenFiles = brokenFiles;
+    }
+
+    public List<ModFile> getBrokenFiles() {
+        return this.brokenFiles;
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/LogMarkers.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -27,5 +27,4 @@ public class LogMarkers {
     public static final Marker LOADING = MarkerManager.getMarker("LOADING");
     public static final Marker SCAN = MarkerManager.getMarker("SCAN");
     public static final Marker SPLASH = MarkerManager.getMarker("SPLASH");
-    public static final Marker FORGEMOD = MarkerManager.getMarker("FORGEMOD").addParents(LOADING);
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/MCPNamingService.java

@@ -0,0 +1,85 @@
+package net.minecraftforge.fml.loading;
+
+import cpw.mods.modlauncher.api.INameMappingService;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+
+public class MCPNamingService implements INameMappingService {
+    private static final Logger LOGGER = LogManager.getLogger();
+    private HashMap<String, String> methods;
+    private HashMap<String, String> fields;
+
+    @Override
+    public String mappingName() {
+        return "srgtomcp";
+    }
+
+    @Override
+    public String mappingVersion() {
+        return "1234"; //TODO: Minecraft Version?
+    }
+
+    @Override
+    public Map.Entry<String, String> understanding() {
+        return Pair.of("srg", "mcp");
+    }
+
+    @Override
+    public BiFunction<Domain, String, String> namingFunction() {
+        return this::findMapping;
+    }
+
+    private String findMapping(final Domain domain, final String srgName) {
+        switch (domain) {
+            case CLASS:
+                return srgName;
+            case FIELD:
+                return findFieldMapping(srgName);
+            case METHOD:
+                return findMethodMapping(srgName);
+        }
+        return srgName;
+    }
+
+    private String findMethodMapping(final String origin) {
+        if (methods == null) {
+            HashMap<String,String> tmpmethods = new HashMap<>(1000);
+            loadMappings("methods.csv", tmpmethods::put);
+            methods = tmpmethods;
+            LOGGER.debug(LogMarkers.CORE, "Loaded {} method mappings from methods.csv", methods.size());
+        }
+        return methods.getOrDefault(origin, origin);
+    }
+
+    private String findFieldMapping(final String origin) {
+        if (fields == null) {
+            HashMap<String,String> tmpfields = new HashMap<>(1000);
+            loadMappings("fields.csv", tmpfields::put);
+            fields = tmpfields;
+            LOGGER.debug(LogMarkers.CORE, "Loaded {} field mappings from fields.csv", fields.size());
+        }
+        return fields.getOrDefault(origin, origin);
+    }
+
+    private static void loadMappings(final String mappingFileName, BiConsumer<String, String> mapStore) {
+        URL path = ClassLoader.getSystemResource(mappingFileName); //We EXPLICITLY go through the SystemClassLoader here because this is dev-time only. And will be on the root classpath.
+        if (path == null)
+            return;
+
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(path.openStream()))) {
+            reader.lines().skip(1).map(e -> e.split(",")).forEach(e -> mapStore.accept(e[0], e[1]));
+        } catch (IOException e1) {
+            LOGGER.error(LogMarkers.CORE, "Error reading mappings", e1);
+        }
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/MavenCoordinateResolver.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

fmlloader/src/main/java/net/minecraftforge/fml/loading/ModDirTransformerDiscoverer.java

@@ -0,0 +1,75 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import cpw.mods.modlauncher.api.LamdbaExceptionUtils;
+import cpw.mods.modlauncher.api.NamedPath;
+import cpw.mods.modlauncher.serviceapi.ITransformerDiscoveryService;
+import org.apache.logging.log4j.LogManager;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.ZipFile;
+
+public class ModDirTransformerDiscoverer implements ITransformerDiscoveryService {
+    @Override
+    public List<NamedPath> candidates(final Path gameDirectory) {
+        ModDirTransformerDiscoverer.scan(gameDirectory);
+        return List.copyOf(found);
+    }
+
+    private final static List<NamedPath> found = new ArrayList<>();
+
+    public static List<Path> allExcluded() {
+        return found.stream().map(np->np.paths()[0]).toList();
+    }
+
+    private static void scan(final Path gameDirectory) {
+        final Path modsDir = gameDirectory.resolve(FMLPaths.MODSDIR.relative()).toAbsolutePath().normalize();
+        if (!Files.exists(modsDir)) {
+            // Skip if the mods dir doesn't exist yet.
+            return;
+        }
+        try (var walk = Files.walk(modsDir, 1)){
+            walk.forEach(ModDirTransformerDiscoverer::visitFile);
+        } catch (IOException | IllegalStateException ioe) {
+            LogManager.getLogger().error("Error during early discovery", ioe);
+        }
+    }
+
+    private static void visitFile(Path path) {
+        if (!Files.isRegularFile(path)) return;
+        if (!path.toString().endsWith(".jar")) return;
+        if (LamdbaExceptionUtils.uncheck(() -> Files.size(path)) == 0) return;
+        try (ZipFile zf = new ZipFile(new File(path.toUri()))) {
+            if (zf.getEntry("META-INF/services/cpw.mods.modlauncher.api.ITransformationService") != null) {
+                found.add(new NamedPath(zf.getName(), path));
+            } else if (zf.getEntry("META-INF/services/net.minecraftforge.forgespi.locating.IModLocator") != null) {
+                found.add(new NamedPath(zf.getName(), path));
+            }
+        } catch (IOException ioe) {
+            LogManager.getLogger().error("Zip Error when loading jar file {}", path, ioe);
+        }
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/ModJarURLHandler.java

@@ -0,0 +1,110 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import cpw.mods.modlauncher.api.LamdbaExceptionUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.jar.Manifest;
+
+import static net.minecraftforge.fml.loading.LogMarkers.CORE;
+
+public class ModJarURLHandler extends URLStreamHandler
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    // modjar://modid/path/to/file
+    @Override
+    protected URLConnection openConnection(URL url) {
+        return new ModJarURLConnection(url);
+    }
+
+    @Override
+    protected int hashCode(final URL u) {
+        return Objects.hash(u.getHost(), u.getFile());
+    }
+
+    @Override
+    protected boolean equals(final URL u1, final URL u2) {
+        return Objects.equals(u1.getProtocol(), u2.getProtocol())
+                && Objects.equals(u1.getHost(), u2.getHost())
+                && Objects.equals(u1.getFile(), u2.getFile());
+    }
+
+    static class ModJarURLConnection extends URLConnection {
+        private Path resource;
+        private String modpath;
+        private String modid;
+        private Optional<Manifest> manifest;
+
+        public ModJarURLConnection(final URL url) {
+            super(url);
+        }
+
+        @Override
+        public void connect()
+        {
+//            if (resource == null) {
+//                modid = url.getHost();
+//                // trim first char
+//                modpath = url.getPath().substring(1);
+//                resource = FMLLoader.getLoadingModList().getModFileById(modid).getFile().findResource(modpath);
+//                manifest = FMLLoader.getLoadingModList().getModFileById(modid).getManifest();
+//            }
+        }
+
+        @Override
+        public InputStream getInputStream() throws IOException
+        {
+            connect();
+            LOGGER.trace(CORE, "Loading modjar URL {} got resource {} {}", url, resource, resource != null ? Files.exists(resource) : "missing");
+            return Files.newInputStream(resource);
+        }
+
+        @Override
+        public long getContentLengthLong() {
+            try {
+                connect();
+                return Files.size(resource);
+            } catch (IOException e) {
+                return -1L;
+            }
+        }
+
+        // Used to cache protectiondomains by "top level object" aka the modid
+        @Override
+        public URL getURL() {
+            return LamdbaExceptionUtils.uncheck(()->new URL("modjar://"+modid));
+        }
+
+        public Optional<Manifest> getManifest() {
+            return manifest;
+        }
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/ModSorter.java

@@ -0,0 +1,250 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import com.google.common.graph.GraphBuilder;
+import com.google.common.graph.MutableGraph;
+import net.minecraftforge.forgespi.language.IModFileInfo;
+import net.minecraftforge.forgespi.language.IModInfo;
+import net.minecraftforge.fml.loading.EarlyLoadingException.ExceptionData;
+import net.minecraftforge.fml.loading.moddiscovery.ModFile;
+import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
+import net.minecraftforge.fml.loading.moddiscovery.ModInfo;
+import net.minecraftforge.fml.loading.toposort.CyclePresentException;
+import net.minecraftforge.fml.loading.toposort.TopologicalSort;
+import net.minecraftforge.forgespi.locating.IModFile;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.maven.artifact.versioning.ArtifactVersion;
+import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.*;
+import static net.minecraftforge.fml.loading.LogMarkers.LOADING;
+
+public class ModSorter
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private List<ModFile> modFiles;
+    private List<ModInfo> sortedList;
+    private Map<String, ModInfo> modIdNameLookup;
+    private List<ModFile> forgeAndMC;
+
+    private ModSorter(final List<ModFile> modFiles)
+    {
+        this.modFiles = modFiles;
+    }
+
+    public static LoadingModList sort(List<ModFile> mods, final List<ExceptionData> errors)
+    {
+        final ModSorter ms = new ModSorter(mods);
+        try {
+            ms.buildUniqueList();
+        } catch (EarlyLoadingException e) {
+            // We cannot build any list with duped mods. We have to abort immediately and report it
+            return LoadingModList.of(ms.forgeAndMC, ms.forgeAndMC.stream().map(mf->(ModInfo)mf.getModInfos().get(0)).collect(toList()), e);
+        }
+        // try and validate dependencies
+        final List<ExceptionData> failedList = Stream.concat(ms.verifyDependencyVersions().stream(), errors.stream()).toList();
+        // if we miss one or the other, we abort now
+        if (!failedList.isEmpty()) {
+            return LoadingModList.of(ms.forgeAndMC, ms.forgeAndMC.stream().map(mf->(ModInfo)mf.getModInfos().get(0)).collect(toList()), new EarlyLoadingException("failure to validate mod list", null, failedList));
+        } else {
+            // Otherwise, lets try and sort the modlist and proceed
+            EarlyLoadingException earlyLoadingException = null;
+            try {
+                ms.sort();
+            } catch (EarlyLoadingException e) {
+                earlyLoadingException = e;
+            }
+            return LoadingModList.of(ms.modFiles, ms.sortedList, earlyLoadingException);
+        }
+    }
+
+    @SuppressWarnings("UnstableApiUsage")
+    private void sort()
+    {
+        // lambdas are identity based, so sorting them is impossible unless you hold reference to them
+        final MutableGraph<ModFileInfo> graph = GraphBuilder.directed().build();
+        AtomicInteger counter = new AtomicInteger();
+        Map<IModFileInfo, Integer> infos = modFiles.stream()
+                .map(ModFile::getModFileInfo)
+                .filter(ModFileInfo.class::isInstance)
+                .collect(toMap(Function.identity(), e -> counter.incrementAndGet()));
+        infos.keySet().forEach(i -> graph.addNode((ModFileInfo) i));
+        modFiles.stream()
+                .map(ModFile::getModInfos)
+                .<IModInfo>mapMulti(Iterable::forEach)
+                .map(IModInfo::getDependencies)
+                .<IModInfo.ModVersion>mapMulti(Iterable::forEach)
+                .forEach(dep -> addDependency(graph, dep));
+
+        final List<ModFileInfo> sorted;
+        try
+        {
+            sorted = TopologicalSort.topologicalSort(graph, Comparator.comparing(infos::get));
+        }
+        catch (CyclePresentException e)
+        {
+            Set<Set<ModFileInfo>> cycles = e.getCycles();
+            LOGGER.error(LOADING, () -> new AdvancedLogMessageAdapter(buffer ->
+                    buffer.append("Mod Sorting failed.\n")
+                    .append("Detected Cycles: ")
+                    .append(cycles)
+                    .append('\n')));
+            var dataList = cycles.stream()
+                    .<ModFileInfo>mapMulti(Iterable::forEach)
+                    .<IModInfo>mapMulti((mf,c)->mf.getMods().forEach(c))
+                    .map(IModInfo::getModId)
+                    .map(list -> new ExceptionData("fml.modloading.cycle", list))
+                    .toList();
+            throw new EarlyLoadingException("Sorting error", e, dataList);
+        }
+        this.sortedList = sorted.stream()
+                .map(ModFileInfo::getMods)
+                .<IModInfo>mapMulti(Iterable::forEach)
+                .map(ModInfo.class::cast)
+                .collect(toList());
+        this.modFiles = sorted.stream()
+                .map(ModFileInfo::getFile)
+                .collect(toList());
+    }
+
+    @SuppressWarnings("UnstableApiUsage")
+    private void addDependency(MutableGraph<ModFileInfo> topoGraph, IModInfo.ModVersion dep)
+    {
+        final ModFileInfo self = (ModFileInfo)dep.getOwner().getOwningFile();
+        final ModInfo targetModInfo = modIdNameLookup.get(dep.getModId());
+        // soft dep that doesn't exist. Just return. No edge required.
+        if (targetModInfo == null) return;
+        final ModFileInfo target = targetModInfo.getOwningFile();
+        if (self == target)
+            return; // in case a jar has two mods that have dependencies between
+        switch (dep.getOrdering()) {
+            case BEFORE -> topoGraph.putEdge(self, target);
+            case AFTER -> topoGraph.putEdge(target, self);
+        }
+    }
+
+    private void buildUniqueList()
+    {
+        // Collect mod files by module name. This will be used for deduping purposes
+        final Map<String, List<IModFile>> modFilesByFirstId = modFiles.stream()
+                .collect(groupingBy(mf -> mf.getModFileInfo().moduleName()));
+
+        // Capture forge and MC here, so we can keep them for later
+        forgeAndMC = new ArrayList<>();
+        var mc = modFilesByFirstId.get("minecraft");
+        if (mc != null && !mc.isEmpty())
+            forgeAndMC.add((ModFile) mc.get(0));
+        else
+            throw new IllegalStateException("Failed to find minecraft somehow?");
+        // TODO: remove this hardcoding and make it more flexible
+        var forge = modFilesByFirstId.get("forge");
+        if (forge != null && !forge.isEmpty())
+            forgeAndMC.add((ModFile) forge.get(0)); // Silently ignore if Forge isn't present
+
+        // Select the newest by artifact version sorting of non-unique files thus identified
+        this.modFiles = modFilesByFirstId.entrySet().stream()
+                .map(this::selectNewestModInfo)
+                .map(Map.Entry::getValue)
+                .map(ModFile.class::cast)
+                .collect(toList());
+
+        // Transform to the full mod id list
+        final Map<String, List<ModInfo>> modIds = modFiles.stream()
+                .map(ModFile::getModInfos)
+                .flatMap(Collection::stream)
+                .map(ModInfo.class::cast)
+                .collect(groupingBy(IModInfo::getModId));
+
+        // Its theoretically possible that some mod has somehow moved an id to a secondary place, thus causing a dupe.
+        // We can't handle this
+        final List<ModInfo> dupedMods = modIds.values().stream()
+                .filter(modInfos -> modInfos.size() > 1)
+                .map(modInfos -> modInfos.get(0))
+                .toList();
+
+        if (!dupedMods.isEmpty()) {
+            final List<EarlyLoadingException.ExceptionData> duplicateModErrors = dupedMods.stream()
+                    .map(dm -> new EarlyLoadingException.ExceptionData("fml.modloading.dupedmod",
+                            dm, Objects.toString(dm))).toList();
+            throw new EarlyLoadingException("Duplicate mods found", null,  duplicateModErrors);
+        }
+
+        modIdNameLookup = modIds.entrySet().stream()
+                .collect(toMap(Map.Entry::getKey, e -> e.getValue().get(0)));
+    }
+
+    private Map.Entry<String, IModFile> selectNewestModInfo(Map.Entry<String, List<IModFile>> fullList) {
+        List<IModFile> modInfoList = fullList.getValue();
+        if (modInfoList.size() > 1) {
+            LOGGER.debug("Found {} mods for first modid {}, selecting most recent based on version data", modInfoList.size(), fullList.getKey());
+            modInfoList.sort(Comparator.<IModFile, ArtifactVersion>comparing(mf -> mf.getModInfos().get(0).getVersion()).reversed());
+            LOGGER.debug("Selected file {} for modid {} with version {}", modInfoList.get(0).getFileName(), fullList.getKey(), modInfoList.get(0).getModInfos().get(0).getVersion());
+        }
+        return Map.entry(fullList.getKey(), modInfoList.get(0));
+    }
+
+    private List<EarlyLoadingException.ExceptionData> verifyDependencyVersions()
+    {
+        final var modVersions = modFiles.stream()
+                .map(ModFile::getModInfos)
+                .<IModInfo>mapMulti(Iterable::forEach)
+                .collect(toMap(IModInfo::getModId, IModInfo::getVersion));
+
+        final var modVersionDependencies = modFiles.stream()
+                .map(ModFile::getModInfos)
+                .<IModInfo>mapMulti(Iterable::forEach)
+                .collect(groupingBy(Function.identity(), flatMapping(e -> e.getDependencies().stream(), toList())));
+
+        final var modRequirements = modVersionDependencies.values().stream()
+                .<IModInfo.ModVersion>mapMulti(Iterable::forEach)
+                .filter(mv -> mv.getSide().isCorrectSide())
+                .collect(toSet());
+
+        final long mandatoryRequired = modRequirements.stream().filter(IModInfo.ModVersion::isMandatory).count();
+        LOGGER.debug(LOADING, "Found {} mod requirements ({} mandatory, {} optional)", modRequirements.size(), mandatoryRequired, modRequirements.size() - mandatoryRequired);
+        final var missingVersions = modRequirements.stream()
+                .filter(mv -> (mv.isMandatory() || modVersions.containsKey(mv.getModId())) && this.modVersionNotContained(mv, modVersions))
+                .collect(toSet());
+        final long mandatoryMissing = missingVersions.stream().filter(IModInfo.ModVersion::isMandatory).count();
+        LOGGER.debug(LOADING, "Found {} mod requirements missing ({} mandatory, {} optional)", missingVersions.size(), mandatoryMissing, missingVersions.size() - mandatoryMissing);
+
+        if (!missingVersions.isEmpty()) {
+            return missingVersions.stream()
+                    .map(mv -> new ExceptionData(mv.isMandatory() ? "fml.modloading.missingdependency" : "fml.modloading.missingdependency.optional",
+                            mv.getOwner(), mv.getModId(), mv.getOwner().getModId(), mv.getVersionRange(),
+                            modVersions.getOrDefault(mv.getModId(), new DefaultArtifactVersion("null"))))
+                    .toList();
+        }
+        return Collections.emptyList();
+    }
+
+    private boolean modVersionNotContained(final IModInfo.ModVersion mv, final Map<String, ArtifactVersion> modVersions)
+    {
+        return !(VersionSupportMatrix.testVersionSupportMatrix(mv.getVersionRange(), mv.getModId(), "mod", (modId, range) -> modVersions.containsKey(modId) &&
+                (range.containsVersion(modVersions.get(modId)) || modVersions.get(modId).toString().equals("0.0NONE"))));
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/RuntimeDistCleaner.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -62,7 +62,7 @@ public class RuntimeDistCleaner implements ILaunchPluginService
     }
 
     @Override
-    public boolean processClass(Phase phase, ClassNode classNode, Type classType)
+    public int processClassWithFlags(final Phase phase, final ClassNode classNode, final Type classType, final String reason)
     {
         AtomicBoolean changes = new AtomicBoolean();
         if (remove(classNode.visibleAnnotations, DIST))
@@ -147,7 +147,7 @@ public class RuntimeDistCleaner implements ILaunchPluginService
                 }
             }
         }
-        return changes.get();
+        return changes.get() ? ComputeFlags.SIMPLE_REWRITE : ComputeFlags.NO_REWRITE;
     }
 
     @SuppressWarnings("unchecked")
@@ -196,7 +196,7 @@ public class RuntimeDistCleaner implements ILaunchPluginService
         private final List<Handle> dynamicLambdaHandles = new ArrayList<>();
 
         public LambdaGatherer() {
-            super(Opcodes.ASM5);
+            super(Opcodes.ASM9);
         }
 
         public void accept(MethodNode method) {

fmlloader/src/main/java/net/minecraftforge/fml/loading/StringSubstitutor.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -30,8 +30,8 @@ import java.util.Map;
 public class StringSubstitutor
 {
     private static final Map<String,String> globals = ImmutableMap.of(
-            "mcVersion", FMLLoader.mcVersion,
-            "forgeVersion", FMLLoader.forgeVersion
+            "mcVersion", FMLLoader.versionInfo().mcVersion(),
+            "forgeVersion", FMLLoader.versionInfo().forgeVersion()
     );
 
     public static String replace(final String in, final ModFile file) {

fmlloader/src/main/java/net/minecraftforge/fml/loading/StringUtils.java

@@ -0,0 +1,66 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import org.apache.commons.lang3.text.StrSubstitutor;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Locale;
+import java.util.Map;
+
+public class StringUtils {
+    public static String toLowerCase(final String str) {
+        return str.toLowerCase(Locale.ROOT);
+    }
+
+    public static String toUpperCase(final String str) {
+        return str.toUpperCase(Locale.ROOT);
+    }
+
+    public static boolean endsWith(final String search, final String... endings) {
+        String lowerSearch = toLowerCase(search);
+        return java.util.stream.Stream.of(endings).anyMatch(lowerSearch::endsWith);
+    }
+
+    public static URL toURL(final String string) {
+        if (string == null || string.trim().isEmpty() || string.contains("myurl.me") || string.contains("example.invalid"))
+            return null;
+
+        try {
+            return new URL(string); }
+        catch (MalformedURLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String parseStringFormat(final String input, final Map<String, String> properties) {
+        return StrSubstitutor.replace(input, properties);
+    }
+
+    public static String binToHex(final byte[] bytes) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < bytes.length; i++) {
+            sb.append(Integer.toHexString((bytes[i]&0xf0) >>4));
+            sb.append(Integer.toHexString(bytes[i]&0x0f));
+        }
+        return sb.toString();
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/TracingPrintStream.java

@@ -1,6 +1,6 @@
 /*
  * Minecraft Forge
- * Copyright (c) 2016-2019.
+ * Copyright (c) 2016-2021.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

fmlloader/src/main/java/net/minecraftforge/fml/loading/VersionInfo.java

@@ -0,0 +1,17 @@
+package net.minecraftforge.fml.loading;
+
+import java.util.Map;
+
+public record VersionInfo(String forgeVersion, String mcVersion, String mcpVersion, String forgeGroup) {
+    VersionInfo(Map<String, ?> arguments) {
+        this((String) arguments.get("forgeVersion"), (String) arguments.get("mcVersion"), (String) arguments.get("mcpVersion"), (String) arguments.get("forgeGroup"));
+    }
+
+    public String mcAndForgeVersion() {
+        return mcVersion+"-"+forgeVersion;
+    }
+
+    public String mcAndMCPVersion() {
+        return mcVersion + "-" + mcpVersion;
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/VersionSupportMatrix.java

@@ -0,0 +1,54 @@
+/*
+ * Minecraft Forge
+ * Copyright (c) 2016-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading;
+
+import org.apache.maven.artifact.versioning.ArtifactVersion;
+import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
+import org.apache.maven.artifact.versioning.VersionRange;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.function.BiPredicate;
+
+public class VersionSupportMatrix {
+    private static final HashMap<String, List<ArtifactVersion>> overrideVersions = new HashMap<>();
+    static {
+        final ArtifactVersion version = new DefaultArtifactVersion(FMLLoader.versionInfo().mcVersion());
+        // if (MavenVersionAdapter.createFromVersionSpec("[1.16.4,1.16.5]").containsVersion(version)) {
+        //     // 1.16.4 is Compatible with 1.16.3
+        //     add("languageloader.javafml", "34");
+        //     add("mod.minecraft",          "1.16.3");
+        //     add("mod.forge",              "34.1.42");
+        //     // 1.16.5 is Compatible with 1.16.4, and thus 1.16.3
+        //     add("languageloader.javafml", "35");
+        //     add("mod.minecraft",          "1.16.4");
+        //     add("mod.forge",              "35.1.37");
+        // }
+    }
+    private static void add(String key, String value) {
+        overrideVersions.computeIfAbsent(key, k -> new ArrayList<>()).add(new DefaultArtifactVersion(value));
+    }
+    public static <T> boolean testVersionSupportMatrix(VersionRange declaredRange, String lookupId, String type, BiPredicate<String, VersionRange> standardLookup) {
+        if (standardLookup.test(lookupId, declaredRange)) return true;
+        List<ArtifactVersion> custom = overrideVersions.get(type +"." +lookupId);
+        return custom == null ? false  : custom.stream().anyMatch(declaredRange::containsVersion);
+    }
+}