8 files changed, 168 insertions, 112 deletions

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 922d668..5e64b2c 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 04d49f2..ef7cfaa 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);
                 }
+
+                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);
         }
 
         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 787625b..c452d8c 100644
--- a/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
+++ b/enigma-cli/src/main/java/cuchaz/enigma/command/MappingCommandsUtil.java
@@ -4,14 +4,15 @@ import java.io.IOException;
 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 +23,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);
                 }
 
                 if (type.equals("tiny")) {
-                        return TinyMappingsReader.INSTANCE.read(path, ProgressListener.none(), saveParameters);
+                        return MappingFormat.TINY_FILE.read(path, ProgressListener.none(), saveParameters);
                 }
 
                 MappingFormat format = null;
@@ -40,15 +41,15 @@ public final class MappingCommandsUtil {
                 }
 
                 if (format != null) {
-                        return format.getReader().read(path, ProgressListener.none(), saveParameters);
+                        return format.read(path, ProgressListener.none(), saveParameters);
                 }
 
                 throw new IllegalArgumentException("no reader for " + type);
         }
 
-        public static void write(EntryTree<EntryMapping> mappings, String type, Path path, MappingSaveParameters saveParameters) {
+        public static void write(EntryTree<EntryMapping> mappings, String type, Path path, MappingSaveParameters saveParameters) throws IOException {
                 if (type.equals("enigma")) {
-                        EnigmaMappingsWriter.DIRECTORY.write(mappings, path, ProgressListener.none(), saveParameters);
+                        MappingFormat.ENIGMA_DIRECTORY.write(mappings, path, ProgressListener.none(), saveParameters);
                         return;
                 }
 
@@ -59,7 +60,13 @@ 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;
+                        }
+
+                        VisitableMappingTree tree = MappingIoConverter.toMappingIo(mappings, ProgressListener.none(), split[1], split[2]);
+                        tree.accept(MappingWriter.create(path, net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE));
                         return;
                 }
 
@@ -70,7 +77,13 @@ 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;
+                        }
+
+                        VisitableMappingTree tree = MappingIoConverter.toMappingIo(mappings, ProgressListener.none(), split[1], split[2]);
+                        tree.accept(MappingWriter.create(path, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE));
                         return;
                 }
 
@@ -83,7 +96,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-swing/src/main/java/cuchaz/enigma/gui/GuiController.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
index 2c15305..88dc070 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
@@ -29,11 +29,6 @@ import javax.swing.JOptionPane;
 import javax.swing.SwingUtilities;
 
 import com.google.common.collect.Lists;
-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 cuchaz.enigma.Enigma;
 import cuchaz.enigma.EnigmaProfile;
@@ -82,7 +77,6 @@ import cuchaz.enigma.translation.mapping.EntryUtil;
 import cuchaz.enigma.translation.mapping.MappingDelta;
 import cuchaz.enigma.translation.mapping.ResolutionStrategy;
 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;
@@ -105,7 +99,6 @@ public class GuiController implements ClientPacketHandler {
 
         private Path loadedMappingPath;
         private MappingFormat loadedMappingFormat;
-        public boolean useMappingIo = true;
 
         private ClassHandleProvider chp;
 
@@ -146,6 +139,11 @@ public class GuiController implements ClientPacketHandler {
                 this.gui.onCloseJar();
         }
 
+        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);
@@ -156,26 +154,7 @@ public class GuiController implements ClientPacketHandler {
                 return ProgressDialog.runOffThread(gui.getFrame(), progress -> {
                         try {
                                 MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters();
-                                EntryTree<EntryMapping> mappings;
-
-                                if (useMappingIo) {
-                                        String loadingMessage;
-
-                                        if (format.getMappingIoCounterpart().hasSingleFile()) {
-                                                loadingMessage = I18n.translate("progress.mappings.loading_file");
-                                        } else {
-                                                loadingMessage = I18n.translate("progress.mappings.loading_directory");
-                                        }
-
-                                        progress.init(1, loadingMessage);
-                                        VisitableMappingTree mappingTree = new MemoryMappingTree();
-                                        MappingReader.read(path, format.getMappingIoCounterpart(), mappingTree);
-                                        mappings = MappingIoConverter.fromMappingIo(mappingTree, progress);
-                                } else {
-                                        mappings = format.read(path, progress, saveParameters);
-                                }
-
-                                project.setMappings(mappings);
+                                project.setMappings(format.read(path, progress, saveParameters));
 
                                 loadedMappingFormat = format;
                                 loadedMappingPath = path;
@@ -203,6 +182,11 @@ public class GuiController implements ClientPacketHandler {
                 return saveMappings(path, loadedMappingFormat);
         }
 
+        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.
          *
@@ -229,15 +213,7 @@ public class GuiController implements ClientPacketHandler {
                         loadedMappingFormat = format;
                         loadedMappingPath = path;
 
-                        if (useMappingIo) {
-                                VisitableMappingTree mappingTree = MappingIoConverter.toMappingIo(mapper.getObfToDeobf(), progress);
-
-                                progress.init(1, I18n.translate("progress.mappings.writing"));
-                                MappingWriter writer = MappingWriter.create(path, format.getMappingIoCounterpart());
-                                mappingTree.accept(writer, VisitOrder.createByName());
-                                writer.close();
-                                progress.step(1, I18n.translate("progress.done"));
-                        } else if (saveAll) {
+                        if (saveAll) {
                                 format.write(mapper.getObfToDeobf(), path, progress, saveParameters);
                         } else {
                                 format.write(mapper.getObfToDeobf(), delta, path, progress, saveParameters);
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 59362e5..30e3586 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
@@ -7,7 +7,6 @@ import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
-import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -404,22 +403,11 @@ public class MenuBar {
         }
 
         private static void prepareOpenMappingsMenu(JMenu openMappingsMenu, Gui gui) {
-                List<MappingFormat> readableMappingIoFormats = Arrays.asList(
-                                MappingFormat.ENIGMA_DIRECTORY,
-                                MappingFormat.ENIGMA_FILE,
-                                MappingFormat.TINY_FILE,
-                                MappingFormat.TINY_V2,
-                                MappingFormat.SRG_FILE,
-                                MappingFormat.TSRG_FILE,
-                                MappingFormat.TSRG_2_FILE,
-                                MappingFormat.PROGUARD);
-
                 // Mapping-IO readers
-                for (MappingFormat format : readableMappingIoFormats) {
-                        addOpenMappingsMenuEntry(I18n.translate(format.getMappingIoCounterpart().name),
-                                        format, true, openMappingsMenu, gui);
-                }
-
+                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
@@ -438,8 +426,7 @@ public class MenuBar {
 
                         if (gui.enigmaMappingsFileChooser.showOpenDialog(gui.getFrame()) == JFileChooser.APPROVE_OPTION) {
                                 File selectedFile = gui.enigmaMappingsFileChooser.getSelectedFile();
-                                gui.getController().useMappingIo = mappingIo;
-                                gui.getController().openMappings(format, selectedFile.toPath());
+                                gui.getController().openMappings(format, selectedFile.toPath(), mappingIo);
                                 UiConfig.setLastSelectedDir(gui.enigmaMappingsFileChooser.getCurrentDirectory().toString());
                         }
                 });
@@ -447,19 +434,11 @@ public class MenuBar {
         }
 
         private static void prepareSaveMappingsAsMenu(JMenu saveMappingsAsMenu, JMenuItem saveMappingsItem, Gui gui) {
-                List<MappingFormat> writableMappingIoFormats = Arrays.asList(
-                                MappingFormat.ENIGMA_DIRECTORY,
-                                MappingFormat.ENIGMA_FILE,
-                                MappingFormat.TINY_FILE,
-                                MappingFormat.TINY_V2,
-                                MappingFormat.PROGUARD);
-
                 // Mapping-IO writers
-                for (MappingFormat format : writableMappingIoFormats) {
-                        addSaveMappingsAsMenuEntry(format.getMappingIoCounterpart().name,
-                                        format, true, saveMappingsAsMenu, saveMappingsItem, gui);
-                }
-
+                MappingFormat.getWritableFormats().stream()
+                                .filter(format -> format.hasMappingIoWriter())
+                                .forEach(format -> addSaveMappingsAsMenuEntry(format.getMappingIoCounterpart().name,
+                                                        format, true, saveMappingsAsMenu, saveMappingsItem, gui));
                 saveMappingsAsMenu.addSeparator();
 
                 // Enigma's own writers
@@ -480,8 +459,7 @@ public class MenuBar {
                         }
 
                         if (gui.enigmaMappingsFileChooser.showSaveDialog(gui.getFrame()) == JFileChooser.APPROVE_OPTION) {
-                                gui.getController().useMappingIo = mappingIo;
-                                gui.getController().saveMappings(gui.enigmaMappingsFileChooser.getSelectedFile().toPath(), format);
+                                gui.getController().saveMappings(gui.enigmaMappingsFileChooser.getSelectedFile().toPath(), format, mappingIo);
                                 saveMappingsItem.setEnabled(true);
                                 UiConfig.setLastSelectedDir(gui.enigmaMappingsFileChooser.getCurrentDirectory().toString());
                         }
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 f402c19..4d34720 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,10 +1,19 @@
 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 cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.translation.mapping.EntryMapping;
 import cuchaz.enigma.translation.mapping.MappingDelta;
@@ -19,27 +28,30 @@ 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, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_FILE),
-        ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_DIR),
-        ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null),
-        TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE),
-        TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE),
-        SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE),
-        TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_FILE),
-        TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_2_FILE),
-        PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD_FILE),
-        RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null);
+        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, 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;
 
-        MappingFormat(MappingsWriter writer, MappingsReader reader, net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart) {
+        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) {
@@ -47,19 +59,49 @@ 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, delta, path, progressListener, saveParameters);
+                        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"));
+                } catch (IOException e) {
+                        throw new UncheckedIOException(e);
+                }
         }
 
         public EntryTree<EntryMapping> read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                if (reader == null) {
-                        throw new IllegalStateException(name() + " does not support reading");
+                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);
         }
 
         @Nullable
@@ -76,4 +118,35 @@ public enum MappingFormat {
         public net.fabricmc.mappingio.format.MappingFormat getMappingIoCounterpart() {
                 return mappingIoCounterpart;
         }
+
+        public boolean hasMappingIoWriter() {
+                return hasMappingIoWriter;
+        }
+
+        public boolean isReadable() {
+                return reader != null || mappingIoCounterpart != null;
+        }
+
+        public boolean isWritable() {
+                return writer != null || hasMappingIoWriter;
+        }
+
+        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
index a0912fa..4372585 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java
@@ -33,19 +33,23 @@ import cuchaz.enigma.utils.I18n;
 
 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 steps = 0;
+                        int stepsDone = 0;
 
                         MemoryMappingTree mappingTree = new MemoryMappingTree();
-                        mappingTree.visitNamespaces("intermediary", List.of("named"));
+                        mappingTree.visitNamespaces(fromNs, List.of(toNs));
 
                         for (EntryTreeNode<EntryMapping> classNode : classes) {
-                                progress.step(steps++, classNode.getEntry().getFullName());
+                                progress.step(++stepsDone, classNode.getEntry().getFullName());
                                 writeClass(classNode, mappings, mappingTree);
                         }
 
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 681fd3f..34d5a6e 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;
@@ -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");