diff --git a/.idea/.gitignore b/.idea/.gitignore
index 13566b8..ddc3775 100644
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -1,6 +1,7 @@
 # Default ignored files
 /shelf/
 /workspace.xml
+/misc.xml
 # Editor-based HTTP Client requests
 /httpRequests/
 # Datasource local storage ignored files
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index c54981c..44632e4 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -13,6 +13,7 @@
             <option value="$PROJECT_DIR$/modules/common" />
             <option value="$PROJECT_DIR$/modules/crowdin" />
             <option value="$PROJECT_DIR$/modules/curseforge" />
+            <option value="$PROJECT_DIR$/modules/dependencies" />
             <option value="$PROJECT_DIR$/modules/git" />
             <option value="$PROJECT_DIR$/modules/jarjar" />
             <option value="$PROJECT_DIR$/modules/java" />
diff --git a/.idea/misc.xml b/.idea/misc.xml
deleted file mode 100644
index 596538b..0000000
--- a/.idea/misc.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="FrameworkDetectionExcludesConfiguration">
-    <file type="web" url="file://$PROJECT_DIR$" />
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="corretto-21" project-jdk-type="JavaSDK" />
-</project>
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index d1ee9fe..5a72abd 100644
--- a/build.gradle
+++ b/build.gradle
@@ -12,6 +12,7 @@ plugins {
 }
 
 dependencies {
+    api(project(':dependencies'))
     api(project(':changelog'))
     api(project(':maven-publishing'))
     api(project(':resource-processing'))
diff --git a/examples/basic/build.gradle b/examples/basic/build.gradle
index c58532f..f568859 100644
--- a/examples/basic/build.gradle
+++ b/examples/basic/build.gradle
@@ -5,6 +5,6 @@ tableau {
         group = 'com.example' // Use your own group here.
         minecraftVersion = '1.21.3' // Or any other minecraft version.
         publisher = 'SomePublisher' // Use your own name here.
-        url = 'https://github.com/someorg/modid' // Use your own URL here.
+        repositoryUrl = uri('https://github.com/someorg/modid') // Use your own URL here.
     }
-}
\ No newline at end of file
+}
diff --git a/examples/maven-publish/build.gradle b/examples/maven-publish/build.gradle
index e663b9c..9a2a3f1 100644
--- a/examples/maven-publish/build.gradle
+++ b/examples/maven-publish/build.gradle
@@ -5,7 +5,7 @@ tableau {
         group = 'com.example' // Use your own group here.
         minecraftVersion = '1.21.3' // Or any other minecraft version.
         publisher = 'SomePublisher' // Use your own name here.
-        url = 'https://github.com/someorg/modid' // Use your own URL here.
+        repositoryUrl = uri('https://github.com/someorg/modid') // Use your own URL here.
     }
 
     maven {
@@ -14,4 +14,4 @@ tableau {
             usingGit()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 9a4957e..72e6a11 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -6,6 +6,8 @@ sonarqube = "5.+"
 shadow = "8.+"
 jetbrainsAnnotations = "+"
 curseForgeGradle = "1.+"
+fancyModLoader = "5.+"
+secureJarHandler = "3.+"
 
 [libraries]
 neogradle-userdev = { module = "net.neoforged.gradle:userdev", version.ref = "neogradle" }
@@ -15,11 +17,14 @@ sonarqube = { module = "org.sonarsource.scanner.gradle:sonarqube-gradle-plugin",
 shadow = { module = "com.gradleup.shadow:shadow-gradle-plugin", version.ref = "shadow" }
 jetbrainsAnnotations = { module = "org.jetbrains:annotations", version.ref = "jetbrainsAnnotations" }
 curseForgeGradle = { module = "net.darkhax.curseforgegradle:CurseForgeGradle", version.ref = "curseForgeGradle" }
+fancyModLoader = { module = "net.neoforged.fancymodloader:loader", version.ref = "fancyModLoader" }
+secureJarHandler = { module = "cpw.mods:securejarhandler", version.ref = "secureJarHandler" }
 
 [bundles]
-neogradle = ["neogradle-userdev"]
+neogradle = ["neogradle-userdev", "fancyModLoader"]
 crowdin = ["crowdin", "gradle-download"]
 sonarqube = ["sonarqube"]
 shadow = ["shadow"]
 jetbrainsAnnotations = ["jetbrainsAnnotations"]
-curseForgeGradle = ["curseForgeGradle"]
\ No newline at end of file
+curseForgeGradle = ["curseForgeGradle"]
+fancyModLoader = ["fancyModLoader", "secureJarHandler"]
diff --git a/modules/common/src/main/java/com/ldtteam/tableau/common/extensions/ModExtension.java b/modules/common/src/main/java/com/ldtteam/tableau/common/extensions/ModExtension.java
index f8e2b08..91ccfcf 100644
--- a/modules/common/src/main/java/com/ldtteam/tableau/common/extensions/ModExtension.java
+++ b/modules/common/src/main/java/com/ldtteam/tableau/common/extensions/ModExtension.java
@@ -3,10 +3,10 @@
 import com.ldtteam.tableau.scripting.extensions.TableauScriptingExtension;
 import org.gradle.api.Action;
 import org.gradle.api.Project;
-import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
 
 import javax.inject.Inject;
+import java.net.URI;
 
 /**
  * Mod extension, handles the project configuration for the mod.
@@ -64,6 +64,7 @@ public void versioning(final Action<Versioning> action) {
      * The current mod id for the mod.
      * <p>
      *     Not configuring the mod id, will likely result in an error during the build.
+     * </p>
      *
      * @return The mod id.
      */
@@ -88,6 +89,27 @@ public void versioning(final Action<Versioning> action) {
      */
     public abstract Property<String> getMinecraftVersion();
 
+    /**
+     * The mod display name.
+     *
+     * @return The mod display name.
+     */
+    public abstract Property<String> getModName();
+
+    /**
+     * The full mod description.
+     *
+     * @return The mod description.
+     */
+    public abstract Property<String> getModDescription();
+
+    /**
+     * The mod logo file.
+     *
+     * @return The mod logo.
+     */
+    public abstract Property<String> getModLogo();
+
     /**
      * The display name of the team or contributor who publishes the mod.
      *
@@ -96,11 +118,32 @@ public void versioning(final Action<Versioning> action) {
     public abstract Property<String> getPublisher();
 
     /**
-     * The url of the website where documentation or source code can be found for the project.
+     * The url of the website where documentation can be found for the project.
+     *
+     * @return The website url, the location where documentation/support can be found.
+     */
+    public abstract Property<URI> getDisplayUrl();
+
+    /**
+     * The url of the website where the source code can be found for the project.
+     *
+     * @return The repository url, is the location where the source code can be found.
+     */
+    public abstract Property<URI> getRepositoryUrl();
+
+    /**
+     * The url of the website where the issue tracker can be found for the project.
+     *
+     * @return The issue tracker url, where issues may be filed for the mod.
+     */
+    public abstract Property<URI> getIssueTrackerUrl();
+
+    /**
+     * The license for the mod.
      *
-     * @return The mod url, is the location where documentation and support can be found.
+     * @return The license used for the mod.
      */
-    public abstract Property<String> getUrl();
+    public abstract Property<String> getLicense();
 
     /**
      * Mod versioning configuration model.
diff --git a/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/CurseForgeProjectPlugin.java b/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/CurseForgeProjectPlugin.java
index af6349e..5266572 100644
--- a/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/CurseForgeProjectPlugin.java
+++ b/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/CurseForgeProjectPlugin.java
@@ -5,7 +5,7 @@
 
 import com.ldtteam.tableau.common.extensions.ModExtension;
 import com.ldtteam.tableau.curseforge.extensions.CurseForgeExtension;
-import com.ldtteam.tableau.extensions.NeoGradleExtension;
+import com.ldtteam.tableau.dependencies.extensions.DependenciesExtension;
 import com.ldtteam.tableau.jarjar.JarJarPlugin;
 import com.ldtteam.tableau.neogradle.NeoGradlePlugin;
 import com.ldtteam.tableau.scripting.extensions.TableauScriptingExtension;
@@ -14,11 +14,9 @@
 import net.darkhax.curseforgegradle.Constants;
 import net.darkhax.curseforgegradle.TaskPublishCurseForge;
 import net.darkhax.curseforgegradle.UploadArtifact;
-import org.gradle.api.GradleException;
 import org.gradle.api.InvalidUserDataException;
 import org.gradle.api.Project;
 import org.gradle.api.Plugin;
-import org.gradle.api.internal.project.IProjectFactory;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.TaskProvider;
 import org.gradle.jvm.tasks.Jar;
@@ -70,6 +68,7 @@ private void configureUploadTask(final Project project) {
         final TaskProvider<? extends Jar> mainJar = getMainJar(project);
         final CurseForgeExtension curse = CurseForgeExtension.get(project);
         final SourceSetExtension sourceSets = SourceSetExtension.get(project);
+        final DependenciesExtension dependencies = DependenciesExtension.get(project);
         final ModExtension mod = ModExtension.get(project);
 
         if (!curse.getId().isPresent()) {
@@ -118,6 +117,9 @@ private void configureUploadTask(final Project project) {
                 }
             });
 
+            dependencies.getAllRequiredDependencies().get().forEach(dep -> artifact.addRelation(dep.modId(), Constants.RELATION_REQUIRED));
+            dependencies.getAllOptionalDependencies().get().forEach(dep -> artifact.addRelation(dep.modId(), Constants.RELATION_OPTIONAL));
+
             curse.getRelationships().get().forEach((slug, relationship) -> {
                 if (!Constants.VALID_RELATION_TYPES.contains(relationship)) {
                     throw new InvalidUserDataException("Invalid relationship type: %s for project: %s".formatted(relationship, slug));
diff --git a/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/extensions/CurseForgeExtension.java b/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/extensions/CurseForgeExtension.java
index f607ed9..2811b4d 100644
--- a/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/extensions/CurseForgeExtension.java
+++ b/modules/curseforge/src/main/java/com/ldtteam/tableau/curseforge/extensions/CurseForgeExtension.java
@@ -143,8 +143,6 @@ public String toString() {
      *     <ul>
      *         <li>embeddedLibrary</li>
      *         <li>incompatible</li>
-     *         <li>optionalDependency</li>
-     *         <li>requiredDependency</li>
      *         <li>tool</li>
      *     </ul>
      * @return the relationships this project has with others
@@ -187,18 +185,18 @@ public Relationships(MapProperty<String, String> relationships) {
         /**
          * The relationships of the project on CurseForge.
          * <p>
-         *     The key is the slug of the project in the relationship and the value is the kind of relationship.
-         *     As values, you can use:
-         *     <ul>
-         *         <li>embeddedLibrary</li>
-         *         <li>incompatible</li>
-         *         <li>optionalDependency</li>
-         *         <li>requiredDependency</li>
-         *         <li>tool</li>
-         *     </ul>
+         * The key is the slug of the project in the relationship and the value is the kind of relationship.
+         * As values, you can use:
+         * </p>
+         * <ul>
+         *     <li>embeddedLibrary</li>
+         *     <li>incompatible</li>
+         *     <li>tool</li>
+         * </ul>
          * @return the relationships this project has with other published projects on CurseForge.
          */
-        public MapProperty<String, String> getRelationships() {
+        public MapProperty<String, String> getRelationships()
+        {
             return this.relationships;
         }
 
@@ -228,23 +226,5 @@ public void embedded(String slug) {
         public void incompatible(String slug) {
             getRelationships().put(slug, Constants.RELATION_INCOMPATIBLE);
         }
-
-        /**
-         * Marks the given project as an optional dependency.
-         *
-         * @param slug the slug of the project
-         */
-        public void optional(String slug) {
-            getRelationships().put(slug, Constants.RELATION_OPTIONAL);
-        }
-
-        /**
-         * Marks the given project as a required dependency.
-         *
-         * @param slug the slug of the project
-         */
-        public void required(String slug) {
-            getRelationships().put(slug, Constants.RELATION_REQUIRED);
-        }
     }
 }
diff --git a/modules/dependencies/build.gradle b/modules/dependencies/build.gradle
new file mode 100644
index 0000000..b1ad90c
--- /dev/null
+++ b/modules/dependencies/build.gradle
@@ -0,0 +1,29 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * This generated file contains a sample Gradle plugin project to get you started.
+ * For more details on writing Custom Plugins, please refer to https://docs.gradle.org/8.10/userguide/custom_plugins.html in the Gradle documentation.
+ * This project uses @Incubating APIs which are subject to change.
+ */
+
+plugins {
+    // Apply the Java Gradle plugin development plugin to add support for developing Gradle plugins
+    id 'java-gradle-plugin'
+}
+
+dependencies {
+    api project(':scripting')
+    api project(':sourceset-management')
+
+    api libs.bundles.fancyModLoader
+}
+
+gradlePlugin {
+    // Define the plugin
+    plugins {
+        "dependencies" {
+            id = 'com.ldtteam.tableau.dependencies'
+            implementationClass = 'com.ldtteam.tableau.dependencies.DependenciesPlugin'
+        }
+    }
+}
diff --git a/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/DependenciesPlugin.java b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/DependenciesPlugin.java
new file mode 100644
index 0000000..288fca6
--- /dev/null
+++ b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/DependenciesPlugin.java
@@ -0,0 +1,32 @@
+/*
+ * This source file was generated by the Gradle 'init' task
+ */
+package com.ldtteam.tableau.dependencies;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.jetbrains.annotations.NotNull;
+
+import javax.inject.Inject;
+
+/**
+ * The root plugin for the Dependencies module.
+ * <p>
+ * Can be applied to any {@link org.gradle.api.plugins.PluginAware} but will only interact with {@link Project projects}
+ */
+public class DependenciesPlugin implements Plugin<Object> {
+
+    /**
+     * Creates a new plugin instance.
+     */
+    @Inject
+    public DependenciesPlugin() {
+    }
+
+    @Override
+    public void apply(@NotNull Object target) {
+        if (target instanceof Project project) {
+            project.getPlugins().apply(DependenciesProjectPlugin.class);
+        }
+    }
+}
diff --git a/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/DependenciesProjectPlugin.java b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/DependenciesProjectPlugin.java
new file mode 100644
index 0000000..7ac8c56
--- /dev/null
+++ b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/DependenciesProjectPlugin.java
@@ -0,0 +1,32 @@
+/*
+ * This source file was generated by the Gradle 'init' task
+ */
+package com.ldtteam.tableau.dependencies;
+
+import com.ldtteam.tableau.dependencies.extensions.DependenciesExtension;
+import com.ldtteam.tableau.scripting.extensions.TableauScriptingExtension;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.jetbrains.annotations.NotNull;
+
+import javax.inject.Inject;
+
+/**
+ * Defines the Dependencies module plugin for {@link Project projects}
+ */
+public class DependenciesProjectPlugin implements Plugin<Project> {
+
+    /**
+     * Creates a new plugin instance.
+     */
+    @Inject
+    public DependenciesProjectPlugin() {
+    }
+
+    @Override
+    public void apply(@NotNull Project target) {
+        target.getPlugins().apply(JavaLibraryPlugin.class);
+        TableauScriptingExtension.register(target, DependenciesExtension.EXTENSION_NAME, DependenciesExtension.class, target);
+    }
+}
diff --git a/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/extensions/DependenciesExtension.java b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/extensions/DependenciesExtension.java
new file mode 100644
index 0000000..742cfe9
--- /dev/null
+++ b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/extensions/DependenciesExtension.java
@@ -0,0 +1,154 @@
+package com.ldtteam.tableau.dependencies.extensions;
+
+import com.ldtteam.tableau.dependencies.model.ModDependency;
+import com.ldtteam.tableau.dependencies.util.DependencyResolver;
+import com.ldtteam.tableau.scripting.extensions.TableauScriptingExtension;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.dsl.Dependencies;
+import org.gradle.api.artifacts.dsl.DependencyCollector;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.SetProperty;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.SourceSetContainer;
+
+import javax.inject.Inject;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * The Dependencies extension for the Tableau project.
+ * <p>
+ * Provides a way to register mod dependencies as project and Neogradle dependencies.
+ */
+public abstract class DependenciesExtension implements Dependencies {
+
+    /**
+     * The name of the extension.
+     */
+    public static final String EXTENSION_NAME = "modDependencies";
+
+    /**
+     * The project this extension is added to.
+     */
+    private final Project project;
+
+    /**
+     * Creates a new extension for the given project.
+     *
+     * @param project The project to create the extension for.
+     */
+    @Inject
+    public DependenciesExtension(final Project project) {
+        this.project = project;
+
+        final SourceSet mainSourceSet = project.getExtensions().getByType(SourceSetContainer.class).getByName(SourceSet.MAIN_SOURCE_SET_NAME);
+        final Configuration apiConfiguration = project.getConfigurations().getByName(mainSourceSet.getApiConfigurationName());
+
+        apiConfiguration.fromDependencyCollector(getRequired());
+        apiConfiguration.fromDependencyCollector(getOptional());
+    }
+
+    /**
+     * Gets the dependencies extension for a given project.
+     *
+     * @param project The project.
+     * @return The git extension.
+     */
+    public static DependenciesExtension get(final Project project) {
+        return TableauScriptingExtension.get(project, DependenciesExtension.class);
+    }
+
+    /**
+     * Get the required dependencies.
+     *
+     * @return The dependency collector for required mods.
+     */
+    public abstract DependencyCollector getRequired();
+
+    /**
+     * Get the required runtime dependencies.
+     *
+     * @return A set property containing all the required runtime mods.
+     */
+    public abstract SetProperty<ModDependency> getRequiredRuntimeMods();
+
+    /**
+     * Add a required runtime dependency.
+     *
+     * @param modId        The mod id for the dependency.
+     * @param versionRange The version range for the dependency.
+     */
+    public void requiredRuntime(final String modId, final String versionRange) {
+        getRequiredRuntimeMods().add(new ModDependency(modId, versionRange, true));
+    }
+
+    /**
+     * Get the optional dependencies.
+     *
+     * @return The dependency collector for optional mods.
+     */
+    public abstract DependencyCollector getOptional();
+
+    /**
+     * Get the optional runtime dependencies.
+     *
+     * @return A set property containing all the optional runtime mods.
+     */
+    public abstract SetProperty<ModDependency> getOptionalRuntimeMods();
+
+    /**
+     * Add an optional runtime dependency.
+     *
+     * @param modId        The mod id for the dependency.
+     * @param versionRange The version range for the dependency.
+     */
+    public void optionalRuntime(final String modId, final String versionRange) {
+        getOptionalRuntimeMods().add(new ModDependency(modId, versionRange, true));
+    }
+
+    /**
+     * Get the configuration for the required dependencies.
+     *
+     * @return The configuration instance.
+     */
+    public Configuration getRequiredConfiguration() {
+        final Configuration configuration = project.getConfigurations().detachedConfiguration();
+        configuration.fromDependencyCollector(getRequired());
+        return configuration;
+    }
+
+    /**
+     * Get the configuration for the optional dependencies.
+     *
+     * @return The configuration instance.
+     */
+    public Configuration getOptionalConfiguration() {
+        final Configuration configuration = project.getConfigurations().detachedConfiguration();
+        configuration.fromDependencyCollector(getOptional());
+        return configuration;
+    }
+
+    /**
+     * Get all the required dependencies, combined {@link DependenciesExtension#getRequired()} and {@link DependenciesExtension#getRequiredRuntimeMods()}.
+     *
+     * @return The combined set of dependencies.
+     */
+    public Provider<Set<ModDependency>> getAllRequiredDependencies() {
+        final Provider<Set<ModDependency>> requiredDependencies = DependencyResolver.resolveDependencies(getRequiredConfiguration(), true);
+
+        return requiredDependencies.zip(getRequiredRuntimeMods(), (a, b) -> Stream.concat(a.stream(), b.stream()).collect(Collectors.toSet()));
+    }
+
+    /**
+     * Get all the optional dependencies, combined {@link DependenciesExtension#getOptional()} and {@link DependenciesExtension#getOptionalRuntimeMods()}.
+     *
+     * @return The combined set of dependencies.
+     */
+    public Provider<Set<ModDependency>> getAllOptionalDependencies() {
+        final Provider<Set<ModDependency>> optionalDependencies = DependencyResolver.resolveDependencies(getOptionalConfiguration(), false);
+
+        return optionalDependencies.zip(getOptionalRuntimeMods(), (a, b) -> Stream.concat(a.stream(), b.stream()).collect(Collectors.toSet()));
+    }
+}
diff --git a/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/CombinedDependencyData.java b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/CombinedDependencyData.java
new file mode 100644
index 0000000..110dda9
--- /dev/null
+++ b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/CombinedDependencyData.java
@@ -0,0 +1,16 @@
+package com.ldtteam.tableau.dependencies.model;
+
+import org.gradle.api.artifacts.result.ResolvedArtifactResult;
+import org.gradle.api.artifacts.result.ResolvedComponentResult;
+
+import java.util.Set;
+
+/**
+ * Container class for combining the set of resolved artifacts and the resolved component result, turning them into a single provider.
+ *
+ * @param artifacts The set of the resolved artifacts.
+ * @param component The resolved component result.
+ */
+public record CombinedDependencyData(Set<ResolvedArtifactResult> artifacts, ResolvedComponentResult component)
+{
+}
diff --git a/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/ModDependency.java b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/ModDependency.java
new file mode 100644
index 0000000..a65c049
--- /dev/null
+++ b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/ModDependency.java
@@ -0,0 +1,11 @@
+package com.ldtteam.tableau.dependencies.model;
+
+/**
+ * A container class for holding a runtime dependency that can be used by other modules.
+ *
+ * @param modId        The mod identifier.
+ * @param versionRange The version range for the mod.
+ * @param required     If the dependency is required or optional.
+ */
+public record ModDependency(String modId, String versionRange, boolean required) {
+}
diff --git a/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/ResolvedDependencyData.java b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/ResolvedDependencyData.java
new file mode 100644
index 0000000..ff9558a
--- /dev/null
+++ b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/model/ResolvedDependencyData.java
@@ -0,0 +1,12 @@
+package com.ldtteam.tableau.dependencies.model;
+
+import java.io.File;
+
+/**
+ * Dependency information container, contains the dependency identifier and the original jar file.
+ *
+ * @param versionRange The version range of the dependency.
+ * @param file         The jar file.
+ */
+public record ResolvedDependencyData(String versionRange, File file) {
+}
diff --git a/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/util/DependencyResolver.java b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/util/DependencyResolver.java
new file mode 100644
index 0000000..74d0539
--- /dev/null
+++ b/modules/dependencies/src/main/java/com/ldtteam/tableau/dependencies/util/DependencyResolver.java
@@ -0,0 +1,138 @@
+package com.ldtteam.tableau.dependencies.util;
+
+import com.electronwill.nightconfig.core.UnmodifiableCommentedConfig;
+import com.electronwill.nightconfig.core.file.FileConfig;
+import com.electronwill.nightconfig.toml.TomlFormat;
+import com.ldtteam.tableau.dependencies.model.CombinedDependencyData;
+import com.ldtteam.tableau.dependencies.model.ModDependency;
+import com.ldtteam.tableau.dependencies.model.ResolvedDependencyData;
+import net.neoforged.fml.loading.moddiscovery.NightConfigWrapper;
+import net.neoforged.neoforgespi.language.IConfigurable;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
+import org.gradle.api.artifacts.component.ModuleComponentSelector;
+import org.gradle.api.artifacts.result.DependencyResult;
+import org.gradle.api.artifacts.result.ResolvedArtifactResult;
+import org.gradle.api.artifacts.result.ResolvedComponentResult;
+import org.gradle.api.provider.Provider;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Utility class for helping resolving dependencies data.
+ */
+public class DependencyResolver {
+
+    /**
+     * Logger instance.
+     */
+    private static final Logger LOGGER = LoggerFactory.getLogger(DependencyResolver.class);
+
+    /**
+     * Utility class, not meant to be instantiated.
+     */
+    private DependencyResolver() {
+    }
+
+    /**
+     * Find all the resolved dependencies.
+     *
+     * @param configuration The configuration to look for dependencies in.
+     * @param required      Whether this dependency is required or not.
+     * @return The set provider.
+     */
+    public static Provider<Set<ModDependency>> resolveDependencies(final Configuration configuration, final boolean required) {
+        final Provider<CombinedDependencyData> combinedDependencyData = configuration.getIncoming().getArtifacts().getResolvedArtifacts()
+                .zip(configuration.getIncoming().getResolutionResult().getRootComponent(), CombinedDependencyData::new);
+
+        final Provider<Set<ResolvedDependencyData>> resolvedDependencies = combinedDependencyData.map(dependency -> dependency.artifacts().stream()
+                .map(artifact -> resolveDependency(artifact, dependency.component()))
+                .filter(Objects::nonNull)
+                .collect(Collectors.toSet()));
+
+        return resolvedDependencies.map(m -> m.stream()
+                .flatMap(fm -> getModInfos(fm, required).stream())
+                .collect(Collectors.toSet()));
+    }
+
+    @Nullable
+    private static ResolvedDependencyData resolveDependency(final ResolvedArtifactResult resolvedArtifact, final ResolvedComponentResult component) {
+        final String versionRange = component.getDependencies().stream()
+                .map(DependencyResult::getRequested)
+                .filter(f -> f instanceof ModuleComponentSelector)
+                .map(ModuleComponentSelector.class::cast)
+                .filter(f -> componentMatches(f, resolvedArtifact))
+                .map(m -> m.getVersionConstraint().getRequiredVersion())
+                .findFirst()
+                .orElse(null);
+        if (versionRange == null) {
+            return null;
+        }
+
+        return new ResolvedDependencyData(versionRange, resolvedArtifact.getFile());
+    }
+
+    /**
+     * Check whether the given component selector matches the provided resolved artifact.
+     *
+     * @param selector The input component selector.
+     * @param artifact The resolved artifact.
+     * @return True if the artifact identifier matches the component selector.
+     */
+    private static boolean componentMatches(final ModuleComponentSelector selector, final ResolvedArtifactResult artifact) {
+        if (artifact.getId().getComponentIdentifier() instanceof ModuleComponentIdentifier artifactIdentifier) {
+            return selector.getModuleIdentifier().equals(artifactIdentifier.getModuleIdentifier());
+        }
+        return false;
+    }
+
+    /**
+     * Get a list of mod information classes for the given jar file.
+     *
+     * @param data     The input dependency data.
+     * @param required Whether this dependency is required or not.
+     * @return The list of mod info instances, or an empty list if no mods were found in the jar.
+     */
+    @NotNull
+    private static List<ModDependency> getModInfos(final ResolvedDependencyData data, final boolean required) {
+        try (final FileSystem fileSystem = FileSystems.newFileSystem(data.file().toPath())) {
+            final Path path = fileSystem.getPath("META-INF/neoforge.mods.toml");
+            if (!Files.exists(path)) {
+                return List.of();
+            }
+
+            final FileConfig fileConfig = FileConfig.builder(path).build();
+            fileConfig.load();
+            fileConfig.close();
+            final TomlFormat format = TomlFormat.instance();
+            final UnmodifiableCommentedConfig unmodifiableConfig = format.createParser().parse(format.createWriter().writeToString(fileConfig)).unmodifiable();
+            final NightConfigWrapper configWrapper = new NightConfigWrapper(unmodifiableConfig);
+
+            final List<ModDependency> modInfos = new ArrayList<>();
+            for (final IConfigurable config : configWrapper.getConfigList("mods")) {
+                final Optional<String> modId = config.getConfigElement("modId");
+                if (modId.isPresent()) {
+                    LOGGER.info("Obtained the mod info for jar \"{}\", found mod with modId \"{}\"", data.file().getName(), modId.get());
+                    modInfos.add(new ModDependency(modId.get(), data.versionRange(), required));
+                }
+            }
+            return Collections.unmodifiableList(modInfos);
+        } catch (Exception ex) {
+            if (LOGGER.isDebugEnabled()) {
+                LOGGER.warn("Failure obtaining the mod info for jar \"{}\", the provided jar doesn't seem to be a Neoforge mod file. Reason:", data.file().getName(), ex);
+            } else {
+                LOGGER.warn("Failure obtaining the mod info for jar \"{}\", the provided jar doesn't seem to be a Neoforge mod file.", data.file().getName());
+            }
+            return List.of();
+        }
+    }
+}
diff --git a/modules/maven-publishing/src/main/java/com/ldtteam/tableau/maven/publishing/MavenPublishingExtension.java b/modules/maven-publishing/src/main/java/com/ldtteam/tableau/maven/publishing/MavenPublishingExtension.java
index 6370457..35b3535 100644
--- a/modules/maven-publishing/src/main/java/com/ldtteam/tableau/maven/publishing/MavenPublishingExtension.java
+++ b/modules/maven-publishing/src/main/java/com/ldtteam/tableau/maven/publishing/MavenPublishingExtension.java
@@ -14,6 +14,7 @@
 import org.gradle.internal.instrumentation.api.annotations.ToBeReplacedByLazyProperty;
 
 import javax.inject.Inject;
+import java.net.URI;
 import java.util.*;
 
 /**
@@ -193,7 +194,7 @@ void configure(MavenPom pom) {
 
         final ModExtension mod = ModExtension.get(project);
 
-        pom.getUrl().set(mod.getUrl());
+        pom.getUrl().set(mod.getRepositoryUrl().map(URI::toString));
 
         pom.organization(organization -> {
             organization.getName().set(mod.getPublisher());
diff --git a/modules/neogradle/build.gradle b/modules/neogradle/build.gradle
index fa2c4e4..ce56257 100644
--- a/modules/neogradle/build.gradle
+++ b/modules/neogradle/build.gradle
@@ -16,6 +16,7 @@ dependencies {
     api project(':common')
     api project(':resource-processing')
     api project(':sourceset-management')
+    api project(':dependencies')
 
     api libs.bundles.neogradle
 }
diff --git a/modules/neogradle/src/main/java/com/ldtteam/tableau/extensions/NeoGradleExtension.java b/modules/neogradle/src/main/java/com/ldtteam/tableau/extensions/NeoGradleExtension.java
index 6e5ac29..4449818 100644
--- a/modules/neogradle/src/main/java/com/ldtteam/tableau/extensions/NeoGradleExtension.java
+++ b/modules/neogradle/src/main/java/com/ldtteam/tableau/extensions/NeoGradleExtension.java
@@ -56,6 +56,7 @@ public NeoGradleExtension(final Project project) {
 
         //Set the default values for the extension.
         getPrimaryJarClassifier().convention("universal");
+        getAutoGenerateModsToml().convention(true);
 
         //By default, we extract the latest neoforge version from the minecraft version.
         getNeoForgeVersion().convention(
@@ -122,6 +123,13 @@ public void interfaceInjection(Object file) {
      */
     public abstract Property<String> getNeoForgeVersion();
 
+    /**
+     * Whether to automatically build the neoforge.mods.toml or not.
+     *
+     * @return Whether to automatically generate a neoforge.mods.toml during build.
+     */
+    public abstract Property<Boolean> getAutoGenerateModsToml();
+
     /**
      * The classifier to use for the primary jar.
      *
diff --git a/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/NeoGradleProjectPlugin.java b/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/NeoGradleProjectPlugin.java
index a2797e7..4d8aa59 100644
--- a/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/NeoGradleProjectPlugin.java
+++ b/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/NeoGradleProjectPlugin.java
@@ -6,14 +6,15 @@
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
 import com.ldtteam.tableau.common.extensions.ModExtension;
+import com.ldtteam.tableau.dependencies.extensions.DependenciesExtension;
 import com.ldtteam.tableau.extensions.NeoGradleExtension;
 import com.ldtteam.tableau.extensions.NeoGradleResourceProcessingExtension;
 import com.ldtteam.tableau.extensions.NeoGradleSourceSetConfigurationExtension;
+import com.ldtteam.tableau.neogradle.tasks.GenerateModsTomlTask;
 import com.ldtteam.tableau.resource.processing.extensions.ResourceProcessingExtension;
 import com.ldtteam.tableau.scripting.extensions.TableauScriptingExtension;
 import com.ldtteam.tableau.sourceset.management.extensions.SourceSetExtension;
-import net.neoforged.gradle.common.extensions.MinecraftExtension;
-import net.neoforged.gradle.common.util.ProjectUtils;
+import com.ldtteam.tableau.sourceset.management.extensions.SourceSetExtension.SourceSetConfiguration;
 import net.neoforged.gradle.dsl.common.extensions.AccessTransformers;
 import net.neoforged.gradle.dsl.common.extensions.InterfaceInjections;
 import net.neoforged.gradle.dsl.common.extensions.Minecraft;
@@ -23,8 +24,8 @@
 import org.gradle.api.Plugin;
 import org.gradle.api.Rule;
 import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.tasks.SourceSet;
-import org.gradle.api.tasks.SourceSetContainer;
+import org.gradle.api.tasks.*;
+import org.gradle.language.jvm.tasks.ProcessResources;
 import org.jetbrains.annotations.NotNull;
 
 import javax.inject.Inject;
@@ -57,6 +58,7 @@ public void apply(@NotNull Project target) {
         configureResourceProcessing(target);
         configureAccessTransformers(target);
         configureInterfaceInjections(target);
+        configureModsTomlGeneration(target);
     }
 
     /**
@@ -109,7 +111,7 @@ public void apply(@NotNull String domainObjectName) {
 
                 //Check if the source set is marked to be included in the libraries.
                 if (domainObjectName.equals("library")) {
-                    final SourceSetExtension.SourceSetConfiguration mainSourceSetConfig = sourceSetExtension.getSourceSets().getByName(SourceSet.MAIN_SOURCE_SET_NAME);
+                    final SourceSetConfiguration mainSourceSetConfig = sourceSetExtension.getSourceSets().getByName(SourceSet.MAIN_SOURCE_SET_NAME);
                     final NeoGradleSourceSetConfigurationExtension extension = NeoGradleSourceSetConfigurationExtension.get(mainSourceSetConfig);
                     final SourceSet mainSourceSet = target.getExtensions().getByType(SourceSetContainer.class).getByName(SourceSet.MAIN_SOURCE_SET_NAME);
 
@@ -136,7 +138,7 @@ public void apply(@NotNull String domainObjectName) {
                 //We know that a source set configuration exists for the given source set name.
                 //So we also know a neogradle extension exists for the source set configuration.
                 //And we know that the source set itself will exist.
-                final SourceSetExtension.SourceSetConfiguration sourceSetConfig = sourceSetExtension.getSourceSets().getByName(sourceSetName);
+                final SourceSetConfiguration sourceSetConfig = sourceSetExtension.getSourceSets().getByName(sourceSetName);
                 final NeoGradleSourceSetConfigurationExtension extension = NeoGradleSourceSetConfigurationExtension.get(sourceSetConfig);
                 final SourceSet sourceSet = target.getExtensions().getByType(SourceSetContainer.class).getByName(sourceSetName);
 
@@ -324,4 +326,38 @@ private void configureInterfaceInjections(final Project project) {
 
         //TODO: Consider how and when to expose the interface injections as artifacts.
     }
+
+    /**
+     * Configures the automatic mods toml generation for the given project.
+     */
+    private void configureModsTomlGeneration(final Project project) {
+        final ModExtension mod = ModExtension.get(project);
+        final NeoGradleExtension neogradle = NeoGradleExtension.get(project);
+        final DependenciesExtension dependencies = DependenciesExtension.get(project);
+
+        final TaskProvider<GenerateModsTomlTask> generationTask = project.getTasks().register("generateModsToml", GenerateModsTomlTask.class, (task) -> {
+            task.getNeoforgeVersion().set(neogradle.getNeoForgeVersion());
+            task.getMinecraftVersion().set(mod.getMinecraftVersion());
+            task.getModId().set(mod.getModId());
+            task.getModName().set(mod.getModName());
+            task.getModDescription().set(mod.getModDescription());
+            task.getModLogo().set(mod.getModLogo());
+            task.getModVersion().set(project.getVersion().toString());
+            task.getPublisher().set(mod.getPublisher());
+            task.getDisplayUrl().set(mod.getDisplayUrl());
+            task.getIssueTrackerUrl().set(mod.getIssueTrackerUrl());
+            task.getLicense().set(mod.getLicense());
+
+            task.getRequiredDependencies().set(dependencies.getAllRequiredDependencies());
+            task.getOptionalDependencies().set(dependencies.getAllOptionalDependencies());
+        });
+
+        if (neogradle.getAutoGenerateModsToml().get()) {
+            project.getTasks().named("processResources", ProcessResources.class).configure(task -> {
+                task.from(generationTask.get().getOutputFile(), (it) -> {
+                    it.into("META-INF");
+                });
+            });
+        }
+    }
 }
diff --git a/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/model/ModsTomlDependency.java b/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/model/ModsTomlDependency.java
new file mode 100644
index 0000000..b428b0f
--- /dev/null
+++ b/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/model/ModsTomlDependency.java
@@ -0,0 +1,15 @@
+package com.ldtteam.tableau.neogradle.model;
+
+import net.neoforged.neoforgespi.language.IModInfo.Ordering;
+
+/**
+ * A container class for holding a dependency that can be written to the neoforge.mods.toml file.
+ *
+ * @param modId        The mod identifier.
+ * @param versionRange The version range for the mod.
+ * @param required     If the dependency is required or optional.
+ * @param ordering     How the dependency should be ordered compared to the current mod.
+ */
+public record ModsTomlDependency(String modId, String versionRange, boolean required, Ordering ordering)
+{
+}
diff --git a/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/tasks/GenerateModsTomlTask.java b/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/tasks/GenerateModsTomlTask.java
new file mode 100644
index 0000000..dac3c61
--- /dev/null
+++ b/modules/neogradle/src/main/java/com/ldtteam/tableau/neogradle/tasks/GenerateModsTomlTask.java
@@ -0,0 +1,255 @@
+package com.ldtteam.tableau.neogradle.tasks;
+
+import com.ldtteam.tableau.dependencies.model.ModDependency;
+import com.ldtteam.tableau.neogradle.model.ModsTomlDependency;
+import net.neoforged.neoforgespi.language.IModInfo.Ordering;
+import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.RegularFile;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.SetProperty;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Nested;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import java.util.Set;
+
+/**
+ * Task for automatically generating the neoforge.mods.toml based on input data.
+ */
+public abstract class GenerateModsTomlTask extends DefaultTask {
+
+    /**
+     * Creates a new task instance.
+     */
+    public GenerateModsTomlTask() {
+        setGroup("neogradle");
+        setDescription("Generate the neoforge.mods.toml file");
+
+        final Provider<RegularFile> outputFile = getProject().getLayout().getBuildDirectory().dir(getName()).map(dir -> dir.file("neoforge.mods.toml"));
+        getOutputFile().convention(outputFile);
+        getOutputs().file(outputFile);
+    }
+
+    /**
+     * Executes the task and generates the neoforge.mods.toml file.
+     *
+     * @throws IOException when a failure occurs during the attempt to write the text to the file.
+     */
+    @TaskAction
+    public void generateModsToml() throws IOException {
+        final File modsTomlFile = getOutputFile().get().getAsFile();
+        if (modsTomlFile.exists()) {
+            if (!modsTomlFile.delete()) {
+                getLogger().warn("Could not delete old neoforge.mods.toml, will keep using old file.");
+                return;
+            }
+        }
+
+        try (final BufferedWriter writer = Files.newBufferedWriter(modsTomlFile.toPath(), StandardOpenOption.CREATE_NEW)) {
+            writeHeader(writer);
+            writeLine(writer, "modLoader=\"javafml\"");
+            writeLine(writer, String.format("loaderVersion=\"[%d,)\"", 4));
+            writeLine(writer, String.format("license=\"%s\"", getLicense().get()));
+            writeLine(writer, String.format("issueTrackerURL=\"%s\"", getIssueTrackerUrl().get()));
+            writeLine(writer, "");
+            writeLine(writer, "[[mods]]");
+            writeLine(writer, String.format("modId=\"%s\"", getModId().get()));
+            writeLine(writer, String.format("version=\"%s\"", getModVersion().get()));
+            writeLine(writer, String.format("displayName=\"%s\"", getModName().get()));
+            writeLine(writer, String.format("description='''%s'''", getModDescription().get()));
+            writeLine(writer, String.format("logoFile=\"%s\"", getModLogo().get()));
+            writeLine(writer, String.format("authors=\"%s\"", getPublisher().get()));
+            writeLine(writer, String.format("displayURL=\"%s\"", getDisplayUrl().get()));
+            writeLine(writer, "");
+
+            final String mcVersion = getMinecraftVersion().get();
+            final DefaultArtifactVersion artifactVersion = new DefaultArtifactVersion(mcVersion);
+            final String nextMcMajorVersion = String.format("%s.%s", artifactVersion.getMajorVersion(), artifactVersion.getMinorVersion() + 1);
+
+            writeDependency(writer, new ModsTomlDependency("neoforge", String.format("[%s,)", getNeoforgeVersion().get()), true, Ordering.NONE));
+            writeDependency(writer, new ModsTomlDependency("minecraft", String.format("[%s,%s)", mcVersion, nextMcMajorVersion), true, Ordering.NONE));
+            writeDependencies(writer, getRequiredDependencies().get(), true);
+            writeDependencies(writer, getOptionalDependencies().get(), false);
+        }
+    }
+
+    /**
+     * Write the list of dependencies to the output of the neoforge.mods.toml from runtime dependencies.
+     *
+     * @param writer       The buffered writer.
+     * @param dependencies The set of dependencies.
+     * @param required     Whether these are required or optional dependencies.
+     * @throws IOException If an exception is thrown during writing.
+     */
+    private void writeDependencies(final BufferedWriter writer, final Set<ModDependency> dependencies, final boolean required) throws IOException {
+        for (final ModDependency dependency : dependencies) {
+            writeDependency(writer, new ModsTomlDependency(dependency.modId(), dependency.versionRange(), required, Ordering.AFTER));
+        }
+    }
+
+    /**
+     * Write the header to the output of the neoforge.mods.toml.
+     *
+     * @param writer The buffered writer.
+     * @throws IOException If an exception is thrown during writing.
+     */
+    private void writeHeader(final BufferedWriter writer) throws IOException {
+        writeLine(writer, "# This file is automatically generated by Tableau.");
+        writeLine(writer, "# If anything is wrong with this file and Tableau has no option to fix this,");
+        writeLine(writer, "# you may disable automatic generation by writing:");
+        writeLine(writer, "# ```");
+        writeLine(writer, "# tableau {");
+        writeLine(writer, "#     neogradle {");
+        writeLine(writer, "#         autoGenerateModsToml = false");
+        writeLine(writer, "#     }");
+        writeLine(writer, "# }");
+        writeLine(writer, "# ```");
+        writeLine(writer, "# When you do this, you have to supply all the configuration manually.");
+        writeLine(writer, "");
+    }
+
+    /**
+     * Write a dependency block to the neoforge.mods.toml.
+     *
+     * @param writer The buffered writer.
+     * @throws IOException If an exception is thrown during writing.
+     */
+    private void writeDependency(final BufferedWriter writer, final ModsTomlDependency dependency) throws IOException {
+        writeLine(writer, String.format("[[dependencies.%s]]", getModId().get()));
+        writeLine(writer, String.format("\tmodId=\"%s\"", dependency.modId()));
+        writeLine(writer, String.format("\ttype=\"%s\"", dependency.required() ? "required" : "optional"));
+        writeLine(writer, String.format("\tversionRange=\"%s\"", dependency.versionRange()));
+        writeLine(writer, String.format("\tordering=\"%s\"", dependency.ordering()));
+        writeLine(writer, "\tside=\"BOTH\"");
+    }
+
+    /**
+     * Internal line write method.
+     */
+    private void writeLine(final BufferedWriter writer, final String content) throws IOException {
+        writer.write(content);
+        writer.newLine();
+    }
+
+    /**
+     * Get the Neoforge version.
+     *
+     * @return The Neoforge version.
+     */
+    @Input
+    public abstract Property<String> getNeoforgeVersion();
+
+    /**
+     * Get the Minecraft version.
+     *
+     * @return The Minecraft version.
+     */
+    @Input
+    public abstract Property<String> getMinecraftVersion();
+
+    /**
+     * Get the mod id.
+     *
+     * @return The mod id.
+     */
+    @Input
+    public abstract Property<String> getModId();
+
+    /**
+     * Get the mod display name.
+     *
+     * @return The mod display name.
+     */
+    @Input
+    public abstract Property<String> getModName();
+
+    /**
+     * Get the mod description.
+     *
+     * @return The mod description.
+     */
+    @Input
+    public abstract Property<String> getModDescription();
+
+    /**
+     * Get the mod logo.
+     *
+     * @return The mod logo.
+     */
+    @Input
+    public abstract Property<String> getModLogo();
+
+    /**
+     * Get the version of the mod.
+     *
+     * @return The version of the mod.
+     */
+    @Input
+    public abstract Property<String> getModVersion();
+
+    /**
+     * Get the mod publisher.
+     *
+     * @return The mod publisher.
+     */
+    @Input
+    public abstract Property<String> getPublisher();
+
+    /**
+     * Get the website for the mod.
+     *
+     * @return The website for the mod.
+     */
+    @Input
+    public abstract Property<URI> getDisplayUrl();
+
+    /**
+     * Get the issue tracker url, where issues may be filed for the mod.
+     *
+     * @return The issue tracker url, where issues may be filed for the mod.
+     */
+    @Input
+    public abstract Property<URI> getIssueTrackerUrl();
+
+    /**
+     * Get the license used for the mod.
+     *
+     * @return The license used for the mod.
+     */
+    @Input
+    public abstract Property<String> getLicense();
+
+    /**
+     * Get the required mod dependencies.
+     *
+     * @return The required mod dependencies.
+     */
+    @Nested
+    public abstract SetProperty<ModDependency> getRequiredDependencies();
+
+    /**
+     * Get the optional mod dependencies.
+     *
+     * @return The optional mod dependencies.
+     */
+    @Nested
+    public abstract SetProperty<ModDependency> getOptionalDependencies();
+
+    /**
+     * Get the destination file for the mods toml.
+     *
+     * @return The destination file for the mods toml.
+     */
+    @OutputFile
+    public abstract RegularFileProperty getOutputFile();
+}
diff --git a/settings.gradle b/settings.gradle
index 68612cc..bc2aff5 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -56,3 +56,5 @@ include('changelog')
 project(':changelog').projectDir = file('modules/changelog')
 include('bootstrap')
 project(':bootstrap').projectDir = file('bootstrap')
+include('dependencies')
+project(':dependencies').projectDir = file('modules/dependencies')
diff --git a/src/main/java/com/ldtteam/tableau/TableauProjectPlugin.java b/src/main/java/com/ldtteam/tableau/TableauProjectPlugin.java
index 852eab8..6883be7 100644
--- a/src/main/java/com/ldtteam/tableau/TableauProjectPlugin.java
+++ b/src/main/java/com/ldtteam/tableau/TableauProjectPlugin.java
@@ -4,6 +4,7 @@
 import com.ldtteam.tableau.common.CommonPlugin;
 import com.ldtteam.tableau.crowdin.CrowdinPlugin;
 import com.ldtteam.tableau.curseforge.CurseForgePlugin;
+import com.ldtteam.tableau.dependencies.DependenciesPlugin;
 import com.ldtteam.tableau.extensions.ModuleFeatures;
 import com.ldtteam.tableau.features.FeaturePluginManager;
 import com.ldtteam.tableau.git.GitPlugin;
@@ -45,6 +46,7 @@ public void apply(@NotNull Project target) {
         target.getPlugins().apply(CommonPlugin.class);
         target.getPlugins().apply(JavaPlugin.class);
         target.getPlugins().apply(SourcesetManagementPlugin.class);
+        target.getPlugins().apply(DependenciesPlugin.class);
         target.getPlugins().apply(ResourceProcessingPlugin.class);
         target.getPlugins().apply(NeoGradlePlugin.class);
         target.getPlugins().apply(JetbrainsAnnotationsPlugin.class);
diff --git a/website/docs/03-guides/01-neoforge-configuration.mdx b/website/docs/03-guides/01-neoforge-configuration.mdx
index 5045ecd..ad75f75 100644
--- a/website/docs/03-guides/01-neoforge-configuration.mdx
+++ b/website/docs/03-guides/01-neoforge-configuration.mdx
@@ -15,6 +15,7 @@ We will cover the following topics:
 - Creating a library instead of a mod
 - Using a random player name
 - Setting the primary jars classifier
+- Creating the neoforge.mods.toml file
 
 :::info
 All sections of this guide will happen in the `neogradle` block of the Tableau DSL.
@@ -243,3 +244,46 @@ tableau {
 ```
 </TabItem>
 </Tabs>
+
+## Creating the neoforge.mods.toml
+
+The `neoforge.mods.toml` file is required for Neoforge to locate important information regarding your mod, like the mod identifier, name, logo, etc.
+
+Tableau can automatically generate this file with zero additional effort required from the developers.
+All you have to do is merely fill in the required fields in the `mod` extension for Tableau and the rest is history.
+
+You may opt out of this generation in case you need to manage it yourself for any reason, in this case you can add:
+
+<Tabs groupId="gradle-code">
+    <TabItem value="groovy" label="Groovy">
+        ```groovy title="build.gradle"
+        tableau {
+            neogradle {
+                autoGenerateModsToml = false
+            }
+        }
+        ```
+    </TabItem>
+    <TabItem value="kotlin" label="Kotlin">
+        ```kotlin title="build.gradle.kts"
+        tableau {
+            neogradle {
+                autoGenerateModsToml.set(false)
+            }
+        }
+        ```
+    </TabItem>
+</Tabs>
+
+After that you can manually add the `neoforge.mods.toml` in your `resources/META-INF` folder.
+After which you can use [resource interpolation](interpolate-resources) to fill the file with the correct data.
+
+### Automatic dependency management
+
+The `neoforge.mods.toml` dependencies section can be automatically generated if you are using the [mod dependencies](managing-dependencies) block,
+all mod dependencies defined here will automatically be added to the `neoforge.mods.toml` as well, next to the default information that is already provided.
+
+:::warning
+This feature uses FML to take a look inside the jar file when it's downloaded by Gradle. When a mod does not properly provide a `neoforge.mods.toml` file in their JAR
+Tableau will be unable to register this as a valid mod dependency, and the dependency will not be added to the `neoforge.mods.toml`.
+:::
diff --git a/website/docs/03-guides/02-managing-dependencies.mdx b/website/docs/03-guides/02-managing-dependencies.mdx
new file mode 100644
index 0000000..410942f
--- /dev/null
+++ b/website/docs/03-guides/02-managing-dependencies.mdx
@@ -0,0 +1,117 @@
+---
+sidebar_label: Managing dependencies
+title: Managing dependencies
+slug: managing-dependencies
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+Tableau has automatic dependency management that works just like regular Gradle dependency management.
+You can define a mod dependencies block that Gradle will use to automatically resolve mod dependencies,
+but these dependencies will also be used for other use-cases from other modules.
+
+Whilst this dependencies block is a regular dependency collector, it's meant specifically for putting mod dependencies here.
+Nothing prevents you from putting other dependencies here, like regular `implementation` dependencies, however we recommend
+you put these in the default `dependencies` block, as you normally would.
+
+## Dependency management
+
+In order to start defining the dependencies you have to define the dependencies block:
+
+<Tabs groupId="gradle-code">
+    <TabItem value="groovy" label="Groovy">
+        ```groovy title="build.gradle"
+        tableau {
+            modDependencies {
+                // Fill in your mod dependencies
+            }
+        }
+        ```
+    </TabItem>
+    <TabItem value="kotlin" label="Kotlin">
+        ```kotlin title="build.gradle.kts"
+        tableau {
+            modDependencies {
+                // Fill in your mod dependencies
+            }
+        }
+        ```
+    </TabItem>
+</Tabs>
+
+The dependencies block supports two types of dependencies: `required` and `optional` dependencies.
+Both of these are defined the same way as any other dependency in Gradle, meaning you can do:
+
+<Tabs groupId="gradle-code">
+    <TabItem value="groovy" label="Groovy">
+        ```groovy title="build.gradle"
+        tableau {
+            modDependencies {
+                required 'com.ldtteam:structurize:[1.0.755-1.21.1-snapshot,)'
+                // Or
+                optional 'com.ldtteam:structurize:[1.0.755-1.21.1-snapshot,)'
+            }
+        }
+        ```
+    </TabItem>
+    <TabItem value="kotlin" label="Kotlin">
+        ```kotlin title="build.gradle.kts"
+        tableau {
+            modDependencies {
+                required("com.ldtteam:structurize:[1.0.755-1.21.1-snapshot,)")
+                // Or
+                optional("com.ldtteam:structurize:[1.0.755-1.21.1-snapshot,)")
+            }
+        }
+        ```
+    </TabItem>
+</Tabs>
+
+## Runtime dependencies
+
+The above way of defining dependencies doesn't always work, some mods split their code in an API mod, and the mod itself.
+Examples of this are mods like [JEI](https://github.com/mezz/JustEnoughItems/wiki) or [JourneyMap](https://bitbucket.org/TeamJM/journeymap-api/src/master/docs/howto.md).
+
+If you attempt to define these as a required or optional mod you will get the API package as a dependency,
+though other modules like the `neoforge.mods.toml` will incorrectly register these API packages as dependencies, instead of the actual mod.
+
+For these scenarios you can add runtime dependencies into the mod dependencies block.
+These use a slightly different API as these are not compile dependencies,
+these dependencies are only meant to be registered in the `neoforge.mods.toml` and/or Curseforge.
+You then provide the API package as a separate `compileOnly` dependency.
+
+<Tabs groupId="gradle-code">
+    <TabItem value="groovy" label="Groovy">
+        ```groovy title="build.gradle"
+        dependencies {
+            compileOnly 'mezz.jei:jei-1.21.1-neoforge-api:[19.19.6.235,)'
+        }
+
+        tableau {
+            modDependencies {
+                requiredRuntime 'jei', '[19.19.6.235,)'
+                // Or
+                optionalRuntime 'jei', '[19.19.6.235,)'
+            }
+        }
+        ```
+    </TabItem>
+    <TabItem value="kotlin" label="Kotlin">
+        ```kotlin title="build.gradle.kts"
+        dependencies {
+            compileOnly("mezz.jei:jei-1.21.1-neoforge-api:[19.19.6.235,)")
+        }
+
+        tableau {
+            modDependencies {
+                requiredRuntime("jei", "[19.19.6.235,)")
+                // Or
+                optionalRuntime("jei", "[19.19.6.235,)")
+            }
+        }
+        ```
+    </TabItem>
+</Tabs>
+
+This way you can still use all Tableau its features that rely on mod dependencies without having to resort to manually configuring them.
diff --git a/website/docs/03-guides/02-custom-source-sets.mdx b/website/docs/03-guides/03-custom-source-sets.mdx
similarity index 100%
rename from website/docs/03-guides/02-custom-source-sets.mdx
rename to website/docs/03-guides/03-custom-source-sets.mdx
diff --git a/website/docs/03-guides/03-publish-to-curseforge.mdx b/website/docs/03-guides/04-publish-to-curseforge.mdx
similarity index 92%
rename from website/docs/03-guides/03-publish-to-curseforge.mdx
rename to website/docs/03-guides/04-publish-to-curseforge.mdx
index 241fb2e..dfd9a81 100644
--- a/website/docs/03-guides/03-publish-to-curseforge.mdx
+++ b/website/docs/03-guides/04-publish-to-curseforge.mdx
@@ -207,10 +207,11 @@ If your mod has a relationship with another project you can configure these rela
 Available relationships are:
 - `embeddedLibrary` -> This project is a library that is embedded in your project. Users do not need to download this library separately.
 - `incompatible` -> This project is incompatible with your project. Users should not use these projects together.
-- `optionalDependency` -> This project is an optional dependency of your project. Users can use this project with your project, but it is not required.
-- `requiredDependency` -> This project is a required dependency of your project. Users need to download this project separately.
 - `tool` -> This project is a tool that is used by your project. Users can download this project separately.
 
+There are two more types of relationships: `requiredDependency` and `optionalDependency`, however these are not manually configurable here.
+These are provided through the [mod dependencies](managing-dependencies) block.
+
 To configure these relationships, you can use the `relationships` property of the CurseForge module:
 
 <Tabs groupId="gradle-code">
@@ -221,8 +222,6 @@ tableau {
         relationships {
             embeddedLibrary("MyLibrary") // This project is a library that is embedded in your project
             incompatible("IncompatibleMod") // This project is incompatible with your project
-            optionalDependency("OptionalMod") // This project is an optional dependency of your project
-            requiredDependency("RequiredMod") // This project is a required dependency of your project
             tool("ToolMod") // This project is a tool that is used by your project
         }
     }
@@ -236,8 +235,6 @@ tableau {
         relationships {
             embeddedLibrary("MyLibrary") // This project is a library that is embedded in your project
             incompatible("IncompatibleMod") // This project is incompatible with your project
-            optionalDependency("OptionalMod") // This project is an optional dependency of your project
-            requiredDependency("RequiredMod") // This project is a required dependency of your project
             tool("ToolMod") // This project is a tool that is used by your project
         }
     }
diff --git a/website/docs/03-guides/04-publishing-to-maven.mdx b/website/docs/03-guides/05-publishing-to-maven.mdx
similarity index 100%
rename from website/docs/03-guides/04-publishing-to-maven.mdx
rename to website/docs/03-guides/05-publishing-to-maven.mdx
diff --git a/website/docs/03-guides/05-interpolate-resources.mdx b/website/docs/03-guides/06-interpolate-resources.mdx
similarity index 100%
rename from website/docs/03-guides/05-interpolate-resources.mdx
rename to website/docs/03-guides/06-interpolate-resources.mdx
diff --git a/website/docs/03-guides/index.mdx b/website/docs/03-guides/index.mdx
index 603630a..86f5394 100644
--- a/website/docs/03-guides/index.mdx
+++ b/website/docs/03-guides/index.mdx
@@ -11,8 +11,9 @@ Examples of these are:
 - Publishing your mod to CurseForge
 - Publishing your mod to a Maven repository
 - Interpolate your resources
+- Creating the neoforge.mods.toml file
 
 :::info
 Any of the guides in this section assume that you have at least performed the [Getting started](../02-getting-started.mdx) guide and have imported your project at least once into an IDE, to validate that you set it up right.
 This will not guide you through setting up Tableau and bootstrap it.
-:::
\ No newline at end of file
+:::