Merge pull request #463 from NebelNidas/mapping-io

Initial Mapping-IO support

19 files changed, 556 insertions, 122 deletions

diff --git a/build.gradle b/build.gradle
index 58cb0bad..b89f1b59 100644
--- a/build.gradle
+++ b/build.gradle
@@ -17,6 +17,9 @@ subprojects {
         dependencies {
                 implementation 'com.google.guava:guava:32.1.2-jre'
                 implementation 'com.google.code.gson:gson:2.10.1'
+                implementation 'net.fabricmc:mapping-io:0.5.0'
+                
+                compileOnly 'org.jetbrains:annotations:24.0.1'
 
                 testImplementation 'junit:junit:4.13.2'
                 testImplementation 'org.hamcrest:hamcrest:2.2'
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java
index 922d6688..5e64b2c1 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java
@@ -10,7 +10,6 @@ import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.analysis.index.JarIndex;
 import cuchaz.enigma.classprovider.ClasspathClassProvider;
 import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.serde.MappingFormat;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 import cuchaz.enigma.translation.representation.entry.ClassEntry;
@@ -38,15 +37,12 @@ public class CheckMappingsCommand extends Command {
                 Enigma enigma = Enigma.create();
 
                 System.out.println("Reading JAR...");
-
                 EnigmaProject project = enigma.openJar(fileJarIn, new ClasspathClassProvider(), ProgressListener.none());
 
                 System.out.println("Reading mappings...");
-
-                MappingFormat format = chooseEnigmaFormat(fileMappings);
                 MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters();
 
-                EntryTree<EntryMapping> mappings = format.read(fileMappings, ProgressListener.none(), saveParameters);
+                EntryTree<EntryMapping> mappings = readMappings(fileMappings, ProgressListener.none(), saveParameters);
                 project.setMappings(mappings);
 
                 JarIndex idx = project.getJarIndex();
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java
index 04d49f2f..de06fa6e 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java
@@ -1,11 +1,15 @@
 package cuchaz.enigma.command;
 
 import java.io.File;
+import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
 import com.google.common.io.MoreFiles;
+import net.fabricmc.mappingio.MappingReader;
+import net.fabricmc.mappingio.tree.MemoryMappingTree;
+import net.fabricmc.mappingio.tree.VisitableMappingTree;
 
 import cuchaz.enigma.Enigma;
 import cuchaz.enigma.EnigmaProject;
@@ -13,6 +17,8 @@ import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.classprovider.ClasspathClassProvider;
 import cuchaz.enigma.translation.mapping.EntryMapping;
 import cuchaz.enigma.translation.mapping.serde.MappingFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingIoConverter;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 
@@ -41,7 +47,7 @@ public abstract class Command {
                         System.out.println("Reading mappings...");
 
                         MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters();
-                        EntryTree<EntryMapping> mappings = chooseEnigmaFormat(fileMappings).read(fileMappings, progress, saveParameters);
+                        EntryTree<EntryMapping> mappings = readMappings(fileMappings, progress, saveParameters);
 
                         project.setMappings(mappings);
                 }
@@ -49,14 +55,18 @@ public abstract class Command {
                 return project;
         }
 
-        protected static MappingFormat chooseEnigmaFormat(Path path) {
-                if (Files.isDirectory(path)) {
-                        return MappingFormat.ENIGMA_DIRECTORY;
-                } else if ("zip".equalsIgnoreCase(MoreFiles.getFileExtension(path))) {
-                        return MappingFormat.ENIGMA_ZIP;
-                } else {
-                        return MappingFormat.ENIGMA_FILE;
+        protected static EntryTree<EntryMapping> readMappings(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
+                // Legacy
+                if ("zip".equalsIgnoreCase(MoreFiles.getFileExtension(path))) {
+                        return MappingFormat.ENIGMA_ZIP.read(path, progress, saveParameters, null);
                 }
+
+                net.fabricmc.mappingio.format.MappingFormat format = MappingReader.detectFormat(path);
+                if (format == null) throw new IllegalArgumentException("Unknown mapping format!");
+
+                VisitableMappingTree tree = new MemoryMappingTree();
+                MappingReader.read(path, format, tree);
+                return MappingIoConverter.fromMappingIo(tree, progress, null);
         }
 
         protected static File getWritableFile(String path) {
diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java b/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
index 787625b6..e1e216a5 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
@@ -1,17 +1,19 @@
 package cuchaz.enigma.command;
 
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 
+import net.fabricmc.mappingio.MappingWriter;
+import net.fabricmc.mappingio.tree.VisitableMappingTree;
+
 import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.translation.mapping.EntryMapping;
 import cuchaz.enigma.translation.mapping.serde.MappingFormat;
+import cuchaz.enigma.translation.mapping.serde.MappingIoConverter;
 import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader;
-import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsWriter;
-import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsReader;
 import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsWriter;
 import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
@@ -22,11 +24,11 @@ public final class MappingCommandsUtil {
 
         public static EntryTree<EntryMapping> read(String type, Path path, MappingSaveParameters saveParameters) throws MappingParseException, IOException {
                 if (type.equals("enigma")) {
-                        return (Files.isDirectory(path) ? EnigmaMappingsReader.DIRECTORY : EnigmaMappingsReader.ZIP).read(path, ProgressListener.none(), saveParameters);
+                        return (Files.isDirectory(path) ? MappingFormat.ENIGMA_DIRECTORY : MappingFormat.ENIGMA_ZIP).read(path, ProgressListener.none(), saveParameters, null);
                 }
 
                 if (type.equals("tiny")) {
-                        return TinyMappingsReader.INSTANCE.read(path, ProgressListener.none(), saveParameters);
+                        return MappingFormat.TINY_FILE.read(path, ProgressListener.none(), saveParameters, null);
                 }
 
                 MappingFormat format = null;
@@ -40,7 +42,7 @@ public final class MappingCommandsUtil {
                 }
 
                 if (format != null) {
-                        return format.getReader().read(path, ProgressListener.none(), saveParameters);
+                        return format.read(path, ProgressListener.none(), saveParameters, null);
                 }
 
                 throw new IllegalArgumentException("no reader for " + type);
@@ -48,7 +50,7 @@ public final class MappingCommandsUtil {
 
         public static void write(EntryTree<EntryMapping> mappings, String type, Path path, MappingSaveParameters saveParameters) {
                 if (type.equals("enigma")) {
-                        EnigmaMappingsWriter.DIRECTORY.write(mappings, path, ProgressListener.none(), saveParameters);
+                        MappingFormat.ENIGMA_DIRECTORY.write(mappings, path, ProgressListener.none(), saveParameters);
                         return;
                 }
 
@@ -59,7 +61,18 @@ public final class MappingCommandsUtil {
                                 throw new IllegalArgumentException("specify column names as 'tinyv2:from_namespace:to_namespace'");
                         }
 
-                        new TinyV2Writer(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
+                        if (!System.getProperty("enigma.use_mappingio", "true").equals("true")) {
+                                new TinyV2Writer(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
+                                return;
+                        }
+
+                        try {
+                                VisitableMappingTree tree = MappingIoConverter.toMappingIo(mappings, ProgressListener.none(), split[1], split[2]);
+                                tree.accept(MappingWriter.create(path, net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE));
+                        } catch (IOException e) {
+                                throw new UncheckedIOException(e);
+                        }
+
                         return;
                 }
 
@@ -70,7 +83,18 @@ public final class MappingCommandsUtil {
                                 throw new IllegalArgumentException("specify column names as 'tiny:from_column:to_column'");
                         }
 
-                        new TinyMappingsWriter(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
+                        if (!System.getProperty("enigma.use_mappingio", "true").equals("true")) {
+                                new TinyMappingsWriter(split[1], split[2]).write(mappings, path, ProgressListener.none(), saveParameters);
+                                return;
+                        }
+
+                        try {
+                                VisitableMappingTree tree = MappingIoConverter.toMappingIo(mappings, ProgressListener.none(), split[1], split[2]);
+                                tree.accept(MappingWriter.create(path, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE));
+                        } catch (IOException e) {
+                                throw new UncheckedIOException(e);
+                        }
+
                         return;
                 }
 
@@ -83,7 +107,7 @@ public final class MappingCommandsUtil {
                 }
 
                 if (format != null) {
-                        format.getWriter().write(mappings, path, ProgressListener.none(), saveParameters);
+                        format.write(mappings, path, ProgressListener.none(), saveParameters);
                         return;
                 }
 
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/DedicatedEnigmaServer.java b/enigma-server/src/main/java/cuchaz/enigma/network/DedicatedEnigmaServer.java
index eb22a506..fbee40d0 100644
--- a/enigma-server/src/main/java/cuchaz/enigma/network/DedicatedEnigmaServer.java
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/DedicatedEnigmaServer.java
@@ -108,7 +108,7 @@ public class DedicatedEnigmaServer extends EnigmaServer {
                                         mappingFormat = MappingFormat.ENIGMA_FILE;
                                 }
 
-                                mappings = EntryRemapper.mapped(project.getJarIndex(), mappingFormat.read(mappingsFile, ProgressListener.none(), profile.getMappingSaveParameters()));
+                                mappings = EntryRemapper.mapped(project.getJarIndex(), mappingFormat.read(mappingsFile, ProgressListener.none(), profile.getMappingSaveParameters(), project.getJarIndex()));
                         }
 
                         PrintWriter log = new PrintWriter(Files.newBufferedWriter(logFile));
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
index 91037b00..c5799019 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
@@ -29,6 +29,7 @@ import javax.swing.JOptionPane;
 import javax.swing.SwingUtilities;
 
 import com.google.common.collect.Lists;
+import org.jetbrains.annotations.ApiStatus;
 
 import cuchaz.enigma.Enigma;
 import cuchaz.enigma.EnigmaProfile;
@@ -139,6 +140,12 @@ public class GuiController implements ClientPacketHandler {
                 this.gui.onCloseJar();
         }
 
+        @ApiStatus.Internal
+        public CompletableFuture<Void> openMappings(MappingFormat format, Path path, boolean useMappingIo) {
+                System.getProperties().setProperty("enigma.use_mappingio", useMappingIo ? "true" : "false");
+                return openMappings(format, path);
+        }
+
         public CompletableFuture<Void> openMappings(MappingFormat format, Path path) {
                 if (project == null) {
                         return CompletableFuture.completedFuture(null);
@@ -149,9 +156,7 @@ public class GuiController implements ClientPacketHandler {
                 return ProgressDialog.runOffThread(gui.getFrame(), progress -> {
                         try {
                                 MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters();
-
-                                EntryTree<EntryMapping> mappings = format.read(path, progress, saveParameters);
-                                project.setMappings(mappings);
+                                project.setMappings(format.read(path, progress, saveParameters, project.getJarIndex()));
 
                                 loadedMappingFormat = format;
                                 loadedMappingPath = path;
@@ -179,6 +184,12 @@ public class GuiController implements ClientPacketHandler {
                 return saveMappings(path, loadedMappingFormat);
         }
 
+        @ApiStatus.Internal
+        public CompletableFuture<Void> saveMappings(Path path, MappingFormat format, boolean useMappingIo) {
+                System.getProperties().setProperty("enigma.use_mappingio", useMappingIo ? "true" : "false");
+                return saveMappings(path, format);
+        }
+
         /**
          * Saves the mappings, with a dialog popping up, showing the progress.
          *
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java
index 1cfad504..30e35861 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/MenuBar.java
@@ -45,7 +45,7 @@ public class MenuBar {
         private final JMenu fileMenu = new JMenu();
         private final JMenuItem jarOpenItem = new JMenuItem();
         private final JMenuItem jarCloseItem = new JMenuItem();
-        private final JMenu openMenu = new JMenu();
+        private final JMenu openMappingsMenu = new JMenu();
         private final JMenuItem saveMappingsItem = new JMenuItem();
         private final JMenu saveMappingsAsMenu = new JMenu();
         private final JMenuItem closeMappingsItem = new JMenuItem();
@@ -88,7 +88,7 @@ public class MenuBar {
 
                 this.retranslateUi();
 
-                prepareOpenMenu(this.openMenu, gui);
+                prepareOpenMappingsMenu(this.openMappingsMenu, gui);
                 prepareSaveMappingsAsMenu(this.saveMappingsAsMenu, this.saveMappingsItem, gui);
                 prepareDecompilerMenu(this.decompilerMenu, gui);
                 prepareThemesMenu(this.themesMenu, gui);
@@ -98,7 +98,7 @@ public class MenuBar {
                 this.fileMenu.add(this.jarOpenItem);
                 this.fileMenu.add(this.jarCloseItem);
                 this.fileMenu.addSeparator();
-                this.fileMenu.add(this.openMenu);
+                this.fileMenu.add(this.openMappingsMenu);
                 this.fileMenu.add(this.saveMappingsItem);
                 this.fileMenu.add(this.saveMappingsAsMenu);
                 this.fileMenu.add(this.closeMappingsItem);
@@ -174,7 +174,7 @@ public class MenuBar {
                 this.startServerItem.setText(I18n.translate(connectionState != ConnectionState.HOSTING ? "menu.collab.server.start" : "menu.collab.server.stop"));
 
                 this.jarCloseItem.setEnabled(jarOpen);
-                this.openMenu.setEnabled(jarOpen);
+                this.openMappingsMenu.setEnabled(jarOpen);
                 this.saveMappingsItem.setEnabled(jarOpen && this.gui.enigmaMappingsFileChooser.getSelectedFile() != null && connectionState != ConnectionState.CONNECTED);
                 this.saveMappingsAsMenu.setEnabled(jarOpen);
                 this.closeMappingsItem.setEnabled(jarOpen);
@@ -189,7 +189,7 @@ public class MenuBar {
                 this.fileMenu.setText(I18n.translate("menu.file"));
                 this.jarOpenItem.setText(I18n.translate("menu.file.jar.open"));
                 this.jarCloseItem.setText(I18n.translate("menu.file.jar.close"));
-                this.openMenu.setText(I18n.translate("menu.file.mappings.open"));
+                this.openMappingsMenu.setText(I18n.translate("menu.file.mappings.open"));
                 this.saveMappingsItem.setText(I18n.translate("menu.file.mappings.save"));
                 this.saveMappingsAsMenu.setText(I18n.translate("menu.file.mappings.save_as"));
                 this.closeMappingsItem.setText(I18n.translate("menu.file.mappings.close"));
@@ -402,45 +402,71 @@ public class MenuBar {
                 GuiUtil.openUrl("https://github.com/FabricMC/Enigma");
         }
 
-        private static void prepareOpenMenu(JMenu openMenu, Gui gui) {
+        private static void prepareOpenMappingsMenu(JMenu openMappingsMenu, Gui gui) {
+                // Mapping-IO readers
+                MappingFormat.getReadableFormats().stream()
+                                .filter(format -> format.getMappingIoCounterpart() != null)
+                                .forEach(format -> addOpenMappingsMenuEntry(I18n.translate(format.getMappingIoCounterpart().name),
+                                        format, true, openMappingsMenu, gui));
+                openMappingsMenu.addSeparator();
+
+                // Enigma's own readers
                 for (MappingFormat format : MappingFormat.values()) {
                         if (format.getReader() != null) {
-                                JMenuItem item = new JMenuItem(I18n.translate("mapping_format." + format.name().toLowerCase(Locale.ROOT)));
-                                item.addActionListener(event -> {
-                                        gui.enigmaMappingsFileChooser.setCurrentDirectory(new File(UiConfig.getLastSelectedDir()));
-
-                                        if (gui.enigmaMappingsFileChooser.showOpenDialog(gui.getFrame()) == JFileChooser.APPROVE_OPTION) {
-                                                File selectedFile = gui.enigmaMappingsFileChooser.getSelectedFile();
-                                                gui.getController().openMappings(format, selectedFile.toPath());
-                                                UiConfig.setLastSelectedDir(gui.enigmaMappingsFileChooser.getCurrentDirectory().toString());
-                                        }
-                                });
-                                openMenu.add(item);
+                                addOpenMappingsMenuEntry(I18n.translate("mapping_format." + format.name().toLowerCase(Locale.ROOT)) + " (legacy)",
+                                                format, false, openMappingsMenu, gui);
                         }
                 }
         }
 
+        private static void addOpenMappingsMenuEntry(String text, MappingFormat format, boolean mappingIo, JMenu openMappingsMenu, Gui gui) {
+                JMenuItem item = new JMenuItem(text);
+                item.addActionListener(event -> {
+                        gui.enigmaMappingsFileChooser.setCurrentDirectory(new File(UiConfig.getLastSelectedDir()));
+
+                        if (gui.enigmaMappingsFileChooser.showOpenDialog(gui.getFrame()) == JFileChooser.APPROVE_OPTION) {
+                                File selectedFile = gui.enigmaMappingsFileChooser.getSelectedFile();
+                                gui.getController().openMappings(format, selectedFile.toPath(), mappingIo);
+                                UiConfig.setLastSelectedDir(gui.enigmaMappingsFileChooser.getCurrentDirectory().toString());
+                        }
+                });
+                openMappingsMenu.add(item);
+        }
+
         private static void prepareSaveMappingsAsMenu(JMenu saveMappingsAsMenu, JMenuItem saveMappingsItem, Gui gui) {
+                // Mapping-IO writers
+                MappingFormat.getWritableFormats().stream()
+                                .filter(format -> format.hasMappingIoWriter())
+                                .forEach(format -> addSaveMappingsAsMenuEntry(format.getMappingIoCounterpart().name,
+                                                        format, true, saveMappingsAsMenu, saveMappingsItem, gui));
+                saveMappingsAsMenu.addSeparator();
+
+                // Enigma's own writers
                 for (MappingFormat format : MappingFormat.values()) {
                         if (format.getWriter() != null) {
-                                JMenuItem item = new JMenuItem(I18n.translate("mapping_format." + format.name().toLowerCase(Locale.ROOT)));
-                                item.addActionListener(event -> {
-                                        // TODO: Use a specific file chooser for it
-                                        if (gui.enigmaMappingsFileChooser.getCurrentDirectory() == null) {
-                                                gui.enigmaMappingsFileChooser.setCurrentDirectory(new File(UiConfig.getLastSelectedDir()));
-                                        }
-
-                                        if (gui.enigmaMappingsFileChooser.showSaveDialog(gui.getFrame()) == JFileChooser.APPROVE_OPTION) {
-                                                gui.getController().saveMappings(gui.enigmaMappingsFileChooser.getSelectedFile().toPath(), format);
-                                                saveMappingsItem.setEnabled(true);
-                                                UiConfig.setLastSelectedDir(gui.enigmaMappingsFileChooser.getCurrentDirectory().toString());
-                                        }
-                                });
-                                saveMappingsAsMenu.add(item);
+                                addSaveMappingsAsMenuEntry(I18n.translate("mapping_format." + format.name().toLowerCase(Locale.ROOT)) + " (legacy)",
+                                                format, false, saveMappingsAsMenu, saveMappingsItem, gui);
                         }
                 }
         }
 
+        private static void addSaveMappingsAsMenuEntry(String text, MappingFormat format, boolean mappingIo, JMenu saveMappingsAsMenu, JMenuItem saveMappingsItem, Gui gui) {
+                JMenuItem item = new JMenuItem(text);
+                item.addActionListener(event -> {
+                        // TODO: Use a specific file chooser for it
+                        if (gui.enigmaMappingsFileChooser.getCurrentDirectory() == null) {
+                                gui.enigmaMappingsFileChooser.setCurrentDirectory(new File(UiConfig.getLastSelectedDir()));
+                        }
+
+                        if (gui.enigmaMappingsFileChooser.showSaveDialog(gui.getFrame()) == JFileChooser.APPROVE_OPTION) {
+                                gui.getController().saveMappings(gui.enigmaMappingsFileChooser.getSelectedFile().toPath(), format, mappingIo);
+                                saveMappingsItem.setEnabled(true);
+                                UiConfig.setLastSelectedDir(gui.enigmaMappingsFileChooser.getCurrentDirectory().toString());
+                        }
+                });
+                saveMappingsAsMenu.add(item);
+        }
+
         private static void prepareDecompilerMenu(JMenu decompilerMenu, Gui gui) {
                 ButtonGroup decompilerGroup = new ButtonGroup();
 
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
index 367af3b3..4521591e 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
@@ -1,11 +1,22 @@
 package cuchaz.enigma.translation.mapping.serde;
 
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
 
 import javax.annotation.Nullable;
 
+import net.fabricmc.mappingio.MappingReader;
+import net.fabricmc.mappingio.MappingWriter;
+import net.fabricmc.mappingio.tree.MemoryMappingTree;
+import net.fabricmc.mappingio.tree.VisitOrder;
+import net.fabricmc.mappingio.tree.VisitableMappingTree;
+import org.jetbrains.annotations.ApiStatus;
+
 import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.analysis.index.JarIndex;
 import cuchaz.enigma.translation.mapping.EntryMapping;
 import cuchaz.enigma.translation.mapping.MappingDelta;
 import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader;
@@ -19,23 +30,33 @@ import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsWriter;
 import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Reader;
 import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.utils.I18n;
 
 public enum MappingFormat {
-        ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE),
-        ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY),
-        ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP),
-        TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader()),
-        TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE),
-        SRG_FILE(SrgMappingsWriter.INSTANCE, null),
-        PROGUARD(null, ProguardMappingsReader.INSTANCE),
-        RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE);
+        ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_FILE, true),
+        ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_DIR, true),
+        ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null, false),
+        TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE, true),
+        TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE, true),
+        SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE, true),
+        XSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.XSRG_FILE, true),
+        CSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.CSRG_FILE, false),
+        TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_FILE, false),
+        TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_2_FILE, false),
+        PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD_FILE, true),
+        RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null, false);
 
         private final MappingsWriter writer;
         private final MappingsReader reader;
+        private final net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart;
+        private final boolean hasMappingIoWriter;
+        private boolean lastUsedMappingIoWriter;
 
-        MappingFormat(MappingsWriter writer, MappingsReader reader) {
+        MappingFormat(MappingsWriter writer, MappingsReader reader, net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart, boolean hasMappingIoWriter) {
                 this.writer = writer;
                 this.reader = reader;
+                this.mappingIoCounterpart = mappingIoCounterpart;
+                this.hasMappingIoWriter = hasMappingIoWriter;
         }
 
         public void write(EntryTree<EntryMapping> mappings, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) {
@@ -43,19 +64,56 @@ public enum MappingFormat {
         }
 
         public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) {
-                if (writer == null) {
-                        throw new IllegalStateException(name() + " does not support writing");
+                if (!hasMappingIoWriter || !useMappingIo()) {
+                        if (writer == null) {
+                                throw new IllegalStateException(name() + " does not support writing");
+                        }
+
+                        writer.write(mappings, lastUsedMappingIoWriter ? MappingDelta.added(mappings) : delta, path, progressListener, saveParameters);
+                        lastUsedMappingIoWriter = false;
+                        return;
                 }
 
-                writer.write(mappings, delta, path, progressListener, saveParameters);
+                try {
+                        VisitableMappingTree tree = MappingIoConverter.toMappingIo(mappings, progressListener);
+                        progressListener.init(1, I18n.translate("progress.mappings.writing"));
+                        progressListener.step(1, null); // Reset message
+
+                        tree.accept(MappingWriter.create(path, mappingIoCounterpart), VisitOrder.createByName());
+                        progressListener.step(1, I18n.translate("progress.done"));
+                        lastUsedMappingIoWriter = true;
+                } catch (IOException e) {
+                        throw new UncheckedIOException(e);
+                }
         }
 
+        @Deprecated
         public EntryTree<EntryMapping> read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                if (reader == null) {
-                        throw new IllegalStateException(name() + " does not support reading");
+                return read(path, progressListener, saveParameters, null);
+        }
+
+        public EntryTree<EntryMapping> read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters, JarIndex index) throws IOException, MappingParseException {
+                if (!useMappingIo()) {
+                        if (reader == null) {
+                                throw new IllegalStateException(name() + " does not support reading");
+                        }
+
+                        return reader.read(path, progressListener, saveParameters);
                 }
 
-                return reader.read(path, progressListener, saveParameters);
+                String loadingMessage;
+
+                if (mappingIoCounterpart.hasSingleFile()) {
+                        loadingMessage = I18n.translate("progress.mappings.loading_file");
+                } else {
+                        loadingMessage = I18n.translate("progress.mappings.loading_directory");
+                }
+
+                progressListener.init(1, loadingMessage);
+
+                VisitableMappingTree mappingTree = new MemoryMappingTree();
+                MappingReader.read(path, mappingIoCounterpart, mappingTree);
+                return MappingIoConverter.fromMappingIo(mappingTree, progressListener, index);
         }
 
         @Nullable
@@ -67,4 +125,43 @@ public enum MappingFormat {
         public MappingsReader getReader() {
                 return reader;
         }
+
+        @Nullable
+        @ApiStatus.Internal
+        public net.fabricmc.mappingio.format.MappingFormat getMappingIoCounterpart() {
+                return mappingIoCounterpart;
+        }
+
+        @ApiStatus.Internal
+        public boolean hasMappingIoWriter() {
+                return hasMappingIoWriter;
+        }
+
+        public boolean isReadable() {
+                return reader != null || mappingIoCounterpart != null;
+        }
+
+        public boolean isWritable() {
+                return writer != null || hasMappingIoWriter;
+        }
+
+        @ApiStatus.Internal
+        private boolean useMappingIo() {
+                if (mappingIoCounterpart == null) return false;
+                return System.getProperty("enigma.use_mappingio", "true").equals("true");
+        }
+
+        public static List<MappingFormat> getReadableFormats() {
+                return Arrays.asList(values())
+                                .stream()
+                                .filter(MappingFormat::isReadable)
+                                .toList();
+        }
+
+        public static List<MappingFormat> getWritableFormats() {
+                return Arrays.asList(values())
+                                .stream()
+                                .filter(MappingFormat::isWritable)
+                                .toList();
+        }
 }
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java
new file mode 100644
index 00000000..3843d8e4
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java
@@ -0,0 +1,279 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.StreamSupport;
+
+import javax.annotation.Nullable;
+
+import org.jetbrains.annotations.ApiStatus;
+import net.fabricmc.mappingio.MappedElementKind;
+import net.fabricmc.mappingio.tree.MemoryMappingTree;
+import net.fabricmc.mappingio.tree.VisitableMappingTree;
+import net.fabricmc.mappingio.tree.MappingTree.ClassMapping;
+import net.fabricmc.mappingio.tree.MappingTree.FieldMapping;
+import net.fabricmc.mappingio.tree.MappingTree.MethodArgMapping;
+import net.fabricmc.mappingio.tree.MappingTree.MethodMapping;
+import net.fabricmc.mappingio.tree.MappingTree.MethodVarMapping;
+
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.mapping.EntryMap;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
+import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import cuchaz.enigma.utils.I18n;
+
+@ApiStatus.Internal
+public class MappingIoConverter {
+        public static VisitableMappingTree toMappingIo(EntryTree<EntryMapping> mappings, ProgressListener progress) {
+                return toMappingIo(mappings, progress, "intermediary", "named");
+        }
+
+        public static VisitableMappingTree toMappingIo(EntryTree<EntryMapping> mappings, ProgressListener progress, String fromNs, String toNs) {
+                try {
+                        List<EntryTreeNode<EntryMapping>> classes = StreamSupport.stream(mappings.spliterator(), false)
+                                        .filter(node -> node.getEntry() instanceof ClassEntry)
+                                        .toList();
+
+                        progress.init(classes.size(), I18n.translate("progress.mappings.converting.to_mappingio"));
+                        int stepsDone = 0;
+
+                        MemoryMappingTree mappingTree = new MemoryMappingTree();
+                        mappingTree.visitNamespaces(fromNs, List.of(toNs));
+
+                        for (EntryTreeNode<EntryMapping> classNode : classes) {
+                                progress.step(++stepsDone, classNode.getEntry().getFullName());
+                                writeClass(classNode, mappings, mappingTree);
+                        }
+
+                        mappingTree.visitEnd();
+                        return mappingTree;
+                } catch (IOException e) {
+                        throw new UncheckedIOException(e);
+                }
+        }
+
+        private static void writeClass(EntryTreeNode<EntryMapping> classNode, EntryMap<EntryMapping> oldMappingTree, VisitableMappingTree newMappingTree) throws IOException {
+                ClassEntry classEntry = (ClassEntry) classNode.getEntry();
+                EntryMapping mapping = oldMappingTree.get(classEntry);
+                Deque<String> parts = new LinkedList<>();
+
+                newMappingTree.visitClass(classEntry.getFullName());
+                newMappingTree.visitComment(MappedElementKind.CLASS, mapping.javadoc());
+
+                do {
+                        mapping = oldMappingTree.get(classEntry);
+
+                        if (mapping != null && mapping.targetName() != null) {
+                                parts.addFirst(mapping.targetName());
+                        } else {
+                                parts.addFirst(classEntry.getName());
+                        }
+
+                        classEntry = classEntry.getOuterClass();
+                } while (classEntry != null);
+
+                String mappedName = String.join("$", parts);
+                newMappingTree.visitDstName(MappedElementKind.CLASS, 0, mappedName);
+
+                for (EntryTreeNode<EntryMapping> child : classNode.getChildNodes()) {
+                        Entry<?> entry = child.getEntry();
+
+                        if (entry instanceof FieldEntry) {
+                                writeField(child, newMappingTree);
+                        } else if (entry instanceof MethodEntry) {
+                                writeMethod(child, newMappingTree);
+                        }
+                }
+        }
+
+        private static void writeField(EntryTreeNode<EntryMapping> fieldNode, VisitableMappingTree mappingTree) throws IOException {
+                if (fieldNode.getValue() == null || fieldNode.getValue().equals(EntryMapping.DEFAULT)) {
+                        return; // Shortcut
+                }
+
+                FieldEntry fieldEntry = ((FieldEntry) fieldNode.getEntry());
+                mappingTree.visitField(fieldEntry.getName(), fieldEntry.getDesc().toString());
+
+                EntryMapping fieldMapping = fieldNode.getValue();
+
+                if (fieldMapping == null) {
+                        fieldMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.FIELD, 0, fieldMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.FIELD, fieldMapping.javadoc());
+        }
+
+        private static void writeMethod(EntryTreeNode<EntryMapping> methodNode, VisitableMappingTree mappingTree) throws IOException {
+                MethodEntry methodEntry = ((MethodEntry) methodNode.getEntry());
+                mappingTree.visitMethod(methodEntry.getName(), methodEntry.getDesc().toString());
+
+                EntryMapping methodMapping = methodNode.getValue();
+
+                if (methodMapping == null) {
+                        methodMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.METHOD, 0, methodMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.METHOD, methodMapping.javadoc());
+
+                for (EntryTreeNode<EntryMapping> child : methodNode.getChildNodes()) {
+                        Entry<?> entry = child.getEntry();
+
+                        if (entry instanceof LocalVariableEntry local) {
+                                if (local.isArgument()) {
+                                        writeMethodArg(child, mappingTree);
+                                } else {
+                                        writeMethodVar(child, mappingTree);
+                                }
+                        }
+                }
+        }
+
+        private static void writeMethodArg(EntryTreeNode<EntryMapping> argNode, VisitableMappingTree mappingTree) throws IOException {
+                if (argNode.getValue() == null || argNode.getValue().equals(EntryMapping.DEFAULT)) {
+                        return; // Shortcut
+                }
+
+                LocalVariableEntry argEntry = ((LocalVariableEntry) argNode.getEntry());
+                mappingTree.visitMethodArg(-1, argEntry.getIndex(), argEntry.getName());
+
+                EntryMapping argMapping = argNode.getValue();
+
+                if (argMapping == null) {
+                        argMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.METHOD_ARG, 0, argMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.METHOD_ARG, argMapping.javadoc());
+        }
+
+        private static void writeMethodVar(EntryTreeNode<EntryMapping> varNode, VisitableMappingTree mappingTree) throws IOException {
+                if (varNode.getValue() == null || varNode.getValue().equals(EntryMapping.DEFAULT)) {
+                        return; // Shortcut
+                }
+
+                LocalVariableEntry varEntry = ((LocalVariableEntry) varNode.getEntry());
+                mappingTree.visitMethodVar(-1, varEntry.getIndex(), -1, -1, varEntry.getName());
+
+                EntryMapping varMapping = varNode.getValue();
+
+                if (varMapping == null) {
+                        varMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.METHOD_VAR, 0, varMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.METHOD_VAR, varMapping.javadoc());
+        }
+
+        public static EntryTree<EntryMapping> fromMappingIo(VisitableMappingTree mappingTree, ProgressListener progress, @Nullable JarIndex index) {
+                EntryTree<EntryMapping> dstMappingTree = new HashEntryTree<>();
+                progress.init(mappingTree.getClasses().size(), I18n.translate("progress.mappings.converting.from_mappingio"));
+                int steps = 0;
+
+                for (ClassMapping classMapping : mappingTree.getClasses()) {
+                        progress.step(steps++, classMapping.getDstName(0) != null ? classMapping.getDstName(0) : classMapping.getSrcName());
+                        readClass(classMapping, dstMappingTree, index);
+                }
+
+                return dstMappingTree;
+        }
+
+        private static void readClass(ClassMapping classMapping, EntryTree<EntryMapping> mappingTree, JarIndex index) {
+                ClassEntry currentClass = new ClassEntry(classMapping.getSrcName());
+                String dstName = classMapping.getDstName(0);
+
+                if (dstName != null) {
+                        dstName = dstName.substring(dstName.lastIndexOf('$') + 1);
+                }
+
+                mappingTree.insert(currentClass, new EntryMapping(dstName, classMapping.getComment()));
+
+                for (FieldMapping fieldMapping : classMapping.getFields()) {
+                        readField(fieldMapping, currentClass, mappingTree, index);
+                }
+
+                for (MethodMapping methodMapping : classMapping.getMethods()) {
+                        readMethod(methodMapping, currentClass, mappingTree);
+                }
+        }
+
+        private static void readField(FieldMapping fieldMapping, ClassEntry parent, EntryTree<EntryMapping> mappingTree, JarIndex index) {
+                String srcDesc = fieldMapping.getSrcDesc();
+                FieldEntry[] fieldEntries;
+
+                if (srcDesc != null) {
+                        fieldEntries = new FieldEntry[] { new FieldEntry(parent, fieldMapping.getSrcName(), new TypeDescriptor(fieldMapping.getSrcDesc())) };
+                } else {
+                        if (index == null) return; // Enigma requires source descriptors, and without an index we can't look them up
+
+                        fieldEntries = index.getChildrenByClass().get(parent).stream()
+                                        .filter(entry -> entry instanceof FieldEntry)
+                                        .filter(entry -> entry.getName().equals(fieldMapping.getSrcName()))
+                                        .toArray(FieldEntry[]::new);
+
+                        if (fieldEntries.length == 0) { // slow path for synthetics
+                                fieldEntries = index.getEntryIndex().getFields().stream()
+                                                .filter(entry -> entry.getParent().getFullName().equals(parent.getFullName()))
+                                                .filter(entry -> {
+                                                        if (entry.getName().equals(fieldMapping.getSrcName())) {
+                                                                return true;
+                                                        } else {
+                                                                System.out.println("Entry name: " + entry.getName() + ", mapping name: " + fieldMapping.getSrcName());
+                                                                return false;
+                                                        }
+                                                })
+                                                .toArray(FieldEntry[]::new);
+                        }
+
+                        if (fieldEntries.length == 0) return; // No target found, invalid mapping
+                }
+
+                for (FieldEntry fieldEntry : fieldEntries) {
+                        mappingTree.insert(fieldEntry, new EntryMapping(fieldMapping.getDstName(0), fieldMapping.getComment()));
+                }
+        }
+
+        private static void readMethod(MethodMapping methodMapping, ClassEntry parent, EntryTree<EntryMapping> mappingTree) {
+                MethodEntry currentMethod;
+                mappingTree.insert(currentMethod = new MethodEntry(parent, methodMapping.getSrcName(), new MethodDescriptor(methodMapping.getSrcDesc())),
+                                new EntryMapping(methodMapping.getDstName(0), methodMapping.getComment()));
+
+                for (MethodArgMapping argMapping : methodMapping.getArgs()) {
+                        readMethodArg(argMapping, currentMethod, mappingTree);
+                }
+
+                for (MethodVarMapping varMapping : methodMapping.getVars()) {
+                        readMethodVar(varMapping, currentMethod, mappingTree);
+                }
+        }
+
+        private static void readMethodArg(MethodArgMapping argMapping, MethodEntry parent, EntryTree<EntryMapping> mappingTree) {
+                String srcName = argMapping.getSrcName() != null ? argMapping.getSrcName() : "";
+
+                mappingTree.insert(
+                                new LocalVariableEntry(parent, argMapping.getLvIndex(), srcName, true, null),
+                                new EntryMapping(argMapping.getDstName(0), argMapping.getComment()));
+        }
+
+        private static void readMethodVar(MethodVarMapping varMapping, MethodEntry parent, EntryTree<EntryMapping> mappingTree) {
+                String srcName = varMapping.getSrcName() != null ? varMapping.getSrcName() : "";
+
+                mappingTree.insert(
+                                new LocalVariableEntry(parent, varMapping.getLvIndex(), srcName, false, null),
+                                new EntryMapping(varMapping.getDstName(0), varMapping.getComment()));
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
index 54613426..d5570e98 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
@@ -40,12 +40,12 @@ public enum EnigmaMappingsReader implements MappingsReader {
         FILE {
                 @Override
                 public EntryTree<EntryMapping> read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                        progress.init(1, I18n.translate("progress.mappings.enigma_file.loading"));
+                        progress.init(1, I18n.translate("progress.mappings.loading_file"));
 
                         EntryTree<EntryMapping> mappings = new HashEntryTree<>();
                         readFile(path, mappings);
 
-                        progress.step(1, I18n.translate("progress.mappings.enigma_file.done"));
+                        progress.step(1, I18n.translate("progress.done"));
 
                         return mappings;
                 }
@@ -60,7 +60,7 @@ public enum EnigmaMappingsReader implements MappingsReader {
                         EntryTree<EntryMapping> mappings = new HashEntryTree<>();
                         List<Path> files = Files.walk(root).filter(f -> !Files.isDirectory(f)).filter(f -> f.toString().endsWith(".mapping")).toList();
 
-                        progress.init(files.size(), I18n.translate("progress.mappings.enigma_directory.loading"));
+                        progress.init(files.size(), I18n.translate("progress.mappings.loading_directory"));
                         int step = 0;
 
                         for (Path file : files) {
@@ -102,7 +102,7 @@ public enum EnigmaMappingsReader implements MappingsReader {
                         throw new IllegalArgumentException("No paths to read mappings from");
                 }
 
-                progress.init(paths.length, I18n.translate("progress.mappings.enigma_directory.loading"));
+                progress.init(paths.length, I18n.translate("progress.mappings.loading_directory"));
                 int step = 0;
 
                 for (Path file : paths) {
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
index df1af912..73f29a16 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
@@ -58,7 +58,7 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
                 public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters) {
                         Collection<ClassEntry> classes = mappings.getRootNodes().filter(entry -> entry.getEntry() instanceof ClassEntry).map(entry -> (ClassEntry) entry.getEntry()).toList();
 
-                        progress.init(classes.size(), I18n.translate("progress.mappings.enigma_file.writing"));
+                        progress.init(classes.size(), I18n.translate("progress.mappings.writing"));
 
                         int steps = 0;
 
@@ -78,11 +78,9 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
                         Collection<ClassEntry> changedClasses = delta.getChangedRoots().filter(entry -> entry instanceof ClassEntry).map(entry -> (ClassEntry) entry).toList();
 
                         applyDeletions(path, changedClasses, mappings, delta.getBaseMappings(), saveParameters.getFileNameFormat());
-
                         changedClasses = changedClasses.stream().filter(entry -> !isClassEmpty(mappings, entry)).collect(Collectors.toList());
 
-                        progress.init(changedClasses.size(), I18n.translate("progress.mappings.enigma_directory.writing"));
-
+                        progress.init(changedClasses.size(), I18n.translate("progress.mappings.writing"));
                         AtomicInteger steps = new AtomicInteger();
 
                         Translator translator = new MappingTranslator(mappings, VoidEntryResolver.INSTANCE);
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
index 4621efef..5addcade 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
@@ -45,7 +45,7 @@ public enum SrgMappingsWriter implements MappingsWriter {
                 List<String> methodLines = new ArrayList<>();
 
                 List<? extends Entry<?>> rootEntries = Lists.newArrayList(mappings).stream().map(EntryTreeNode::getEntry).toList();
-                progress.init(rootEntries.size(), I18n.translate("progress.mappings.srg_file.generating"));
+                progress.init(rootEntries.size(), I18n.translate("progress.mappings.converting"));
 
                 int steps = 0;
 
@@ -54,7 +54,7 @@ public enum SrgMappingsWriter implements MappingsWriter {
                         writeEntry(classLines, fieldLines, methodLines, mappings, entry);
                 }
 
-                progress.init(3, I18n.translate("progress.mappings.srg_file.writing"));
+                progress.init(3, I18n.translate("progress.mappings.writing"));
 
                 try (PrintWriter writer = new LfPrintWriter(Files.newBufferedWriter(path))) {
                         progress.step(0, I18n.translate("type.classes"));
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
index 534a567c..1575f468 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
@@ -35,7 +35,7 @@ public enum TinyMappingsReader implements MappingsReader {
                 EntryTree<EntryMapping> mappings = new HashEntryTree<>();
                 lines.remove(0);
 
-                progress.init(lines.size(), I18n.translate("progress.mappings.tiny_file.loading"));
+                progress.init(lines.size(), I18n.translate("progress.mappings.loading_file"));
 
                 for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) {
                         progress.step(lineNumber, "");
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
index eecbc35b..28185f58 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
@@ -46,7 +46,7 @@ public final class TinyV2Reader implements MappingsReader {
         private EntryTree<EntryMapping> read(Path path, List<String> lines, ProgressListener progress) throws MappingParseException {
                 EntryTree<EntryMapping> mappings = new HashEntryTree<>();
 
-                progress.init(lines.size(), "progress.mappings.tiny_v2.loading");
+                progress.init(lines.size(), "progress.mappings.loading_file");
 
                 BitSet state = new BitSet(STATE_SIZE);
                 @SuppressWarnings({"unchecked", "rawtypes"}) MappingPair<? extends Entry<?>, RawEntryMapping>[] holds = new MappingPair[STATE_SIZE];
diff --git a/enigma/src/main/resources/lang/en_us.json b/enigma/src/main/resources/lang/en_us.json
index 421620e9..2a3cfb2d 100644
--- a/enigma/src/main/resources/lang/en_us.json
+++ b/enigma/src/main/resources/lang/en_us.json
@@ -137,6 +137,7 @@
         "log_panel.messages": "Messages",
         "log_panel.users": "Users",
 
+        "progress.done": "Done!",
         "progress.operation": "%s - Operation in progress",
         "progress.jar.indexing": "Indexing jar",
         "progress.jar.indexing.entries": "Entries...",
@@ -147,15 +148,12 @@
         "progress.sources.writing": "Writing sources...",
         "progress.classes.deobfuscating": "Deobfuscating classes...",
         "progress.classes.decompiling": "Decompiling classes...",
-        "progress.mappings.enigma_file.loading": "Loading mapping file",
-        "progress.mappings.enigma_file.done": "Done!",
-        "progress.mappings.enigma_file.writing": "Writing classes",
-        "progress.mappings.enigma_directory.loading": "Loading mapping files",
-        "progress.mappings.enigma_directory.writing": "Writing classes",
-        "progress.mappings.tiny_file.loading": "Loading mapping file",
-        "progress.mappings.tiny_v2.loading": "Loading mapping file",
-        "progress.mappings.srg_file.generating": "Generating mappings",
-        "progress.mappings.srg_file.writing": "Writing mappings",
+        "progress.mappings.loading_file": "Loading mapping file",
+        "progress.mappings.loading_directory": "Loading mapping files",
+        "progress.mappings.writing": "Writing classes",
+        "progress.mappings.converting": "Converting mappings",
+        "progress.mappings.converting.to_mappingio": "Converting to Mapping-IO",
+        "progress.mappings.converting.from_mappingio": "Converting from Mapping-IO",
         "progress.stats": "Generating stats",
         "progress.stats.data": "Generating data",
 
diff --git a/enigma/src/main/resources/lang/fr_fr.json b/enigma/src/main/resources/lang/fr_fr.json
index d3d0c297..520dd32e 100644
--- a/enigma/src/main/resources/lang/fr_fr.json
+++ b/enigma/src/main/resources/lang/fr_fr.json
@@ -131,6 +131,7 @@
         "log_panel.messages": "Messages",
         "log_panel.users": "Utilisateurs",
 
+        "progress.done": "Terminé !",
         "progress.operation": "%s - Opération en cours",
         "progress.jar.indexing": "Indexation du jar",
         "progress.jar.indexing.entries": "Entrées...",
@@ -141,15 +142,10 @@
         "progress.sources.writing": "Écriture des sources...",
         "progress.classes.deobfuscating": "Déobfuscation des classes...",
         "progress.classes.decompiling": "Décompilation des classes...",
-        "progress.mappings.enigma_file.loading": "Chargement du fichier de mappings",
-        "progress.mappings.enigma_file.done": "Terminé !",
-        "progress.mappings.enigma_file.writing": "Écriture des classes",
-        "progress.mappings.enigma_directory.loading": "Chargement des fichiers de mappings",
-        "progress.mappings.enigma_directory.writing": "Écriture des classes",
-        "progress.mappings.tiny_file.loading": "Chargement du fichier de mappings",
-        "progress.mappings.tiny_v2.loading": "Chargement du fichier de mappings",
-        "progress.mappings.srg_file.generating": "Génération des mappings",
-        "progress.mappings.srg_file.writing": "Écriture des mappings",
+        "progress.mappings.loading_file": "Chargement du fichier de mappings",
+        "progress.mappings.loading_directory": "Chargement des fichiers de mappings",
+        "progress.mappings.writing": "Écriture des mappings",
+        "progress.mappings.converting": "Conversion des mappings",
         "progress.stats": "Génération des statistiques",
         "progress.stats.data": "Génération des données",
 
diff --git a/enigma/src/main/resources/lang/ja_jp.json b/enigma/src/main/resources/lang/ja_jp.json
index 09e7ee08..b4d51998 100644
--- a/enigma/src/main/resources/lang/ja_jp.json
+++ b/enigma/src/main/resources/lang/ja_jp.json
@@ -132,6 +132,7 @@
         "log_panel.messages": "メッセージ",
         "log_panel.users": "ユーザー",
 
+        "progress.done": "完了しました!",
         "progress.operation": "%s - 処理中",
         "progress.jar.indexing": "jarのインデックス中",
         "progress.jar.indexing.entries": "エントリー...",
@@ -142,15 +143,9 @@
         "progress.sources.writing": "ソースコードを書き出し中...",
         "progress.classes.deobfuscating": "クラスを難読化解除中...",
         "progress.classes.decompiling": "クラスのデコンパイル中...",
-        "progress.mappings.enigma_file.loading": "マッピングファイルをロード",
-        "progress.mappings.enigma_file.done": "完了しました!",
-        "progress.mappings.enigma_file.writing": "クラスの書き出し中",
-        "progress.mappings.enigma_directory.loading": "マッピングファイルの読込中",
-        "progress.mappings.enigma_directory.writing": "クラスの書き出し中",
-        "progress.mappings.tiny_file.loading": "マッピングファイルの読込中",
-        "progress.mappings.tiny_v2.loading": "マッピングファイルの読込中",
-        "progress.mappings.srg_file.generating": "マッピングの作成中",
-        "progress.mappings.srg_file.writing": "マッピングの書き出し中",
+        "progress.mappings.loading_file": "マッピングファイルをロード",
+        "progress.mappings.loading_directory": "マッピングファイルの読込中",
+        "progress.mappings.writing": "マッピングの書き出し中",
         "progress.stats": "統計情報を作成中",
         "progress.stats.data": "データの作成中",
 
diff --git a/enigma/src/main/resources/lang/zh_cn.json b/enigma/src/main/resources/lang/zh_cn.json
index fe806fb3..dbc6dd33 100644
--- a/enigma/src/main/resources/lang/zh_cn.json
+++ b/enigma/src/main/resources/lang/zh_cn.json
@@ -75,6 +75,7 @@
         "info_panel.tree.implementations": "实现",
         "info_panel.tree.calls": "调用图",
 
+        "progress.done": "完成！",
         "progress.operation": "%s - 进行中",
         "progress.jar.indexing": "索引 Jar",
         "progress.jar.indexing.entries": "条目...",
@@ -85,15 +86,9 @@
         "progress.sources.writing": "写出源码中...",
         "progress.classes.deobfuscating": "反混淆类中...",
         "progress.classes.decompiling": "反编译类中...",
-        "progress.mappings.enigma_file.loading": "加载映射文件",
-        "progress.mappings.enigma_file.done": "完成！",
-        "progress.mappings.enigma_file.writing": "写入类",
-        "progress.mappings.enigma_directory.loading": "加载映射文件",
-        "progress.mappings.enigma_directory.writing": "写入类",
-        "progress.mappings.tiny_file.loading": "加载映射文件",
-        "progress.mappings.tiny_v2.loading": "加载映射文件",
-        "progress.mappings.srg_file.generating": "生成映射",
-        "progress.mappings.srg_file.writing": "写出映射",
+        "progress.mappings.loading_file": "加载映射文件",
+        "progress.mappings.loading_directory": "加载映射文件",
+        "progress.mappings.writing": "写出映射",
         "progress.stats": "生成统计范围",
         "progress.stats.data": "生成数据",
 
diff --git a/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java
index 681fd3f2..25f11fbc 100644
--- a/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java
+++ b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java
@@ -4,6 +4,7 @@ import java.io.File;
 import java.io.IOException;
 
 import org.junit.Assert;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import cuchaz.enigma.ProgressListener;
@@ -62,7 +63,7 @@ public class TestReadWriteCycle {
                 mappingFormat.write(testMappings, tempFile.toPath(), ProgressListener.none(), parameters);
                 Assert.assertTrue("Written file not created", tempFile.exists());
 
-                EntryTree<EntryMapping> loadedMappings = mappingFormat.read(tempFile.toPath(), ProgressListener.none(), parameters);
+                EntryTree<EntryMapping> loadedMappings = mappingFormat.read(tempFile.toPath(), ProgressListener.none(), parameters, null);
 
                 Assert.assertTrue("Loaded mappings don't contain testClazz", loadedMappings.contains(testClazz.a));
                 Assert.assertTrue("Loaded mappings don't contain testField1", loadedMappings.contains(testField1.a));
@@ -87,6 +88,11 @@ public class TestReadWriteCycle {
                 tempFile.delete();
         }
 
+        @BeforeClass
+        public static void setup() {
+                System.getProperties().setProperty("enigma.use_mappingio", "false");
+        }
+
         @Test
         public void testEnigmaFile() throws IOException, MappingParseException {
                 testReadWriteCycle(MappingFormat.ENIGMA_FILE, true, ".enigma");