diff --git a/SabreTools.DatFiles/DatFile.ToMetadata.cs b/SabreTools.DatFiles/DatFile.ToMetadata.cs
index 4f041f68..40fdc402 100644
--- a/SabreTools.DatFiles/DatFile.ToMetadata.cs
+++ b/SabreTools.DatFiles/DatFile.ToMetadata.cs
@@ -1,6 +1,6 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using SabreTools.Core;
 using SabreTools.Core.Tools;
 
 namespace SabreTools.DatFiles
@@ -12,7 +12,7 @@ namespace SabreTools.DatFiles
         /// <summary>
         /// Convert metadata information
         /// </summary>
-        public Models.Metadata.MetadataFile? ConvertMetadata()
+        public Models.Metadata.MetadataFile? ConvertMetadata(bool ignoreblanks = false)
         {
             // If we don't have items, we can't do anything
             if (this.Items == null || !this.Items.Any())
@@ -26,7 +26,10 @@ namespace SabreTools.DatFiles
             if (header != null)
                 metadataFile[Models.Metadata.MetadataFile.HeaderKey] = header;
 
-            // TODO: Implement machine creation
+            // Convert and assign the machines
+            var machines = ConvertMachines(ignoreblanks);
+            if (machines != null)
+                metadataFile[Models.Metadata.MetadataFile.MachineKey] = header;
 
             return metadataFile;
         }
@@ -41,78 +44,7 @@ namespace SabreTools.DatFiles
                 return null;
 
             // Create an internal header
-            var header = new Models.Metadata.Header();
-
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.AuthorKey) == null)
-                header[Models.Metadata.Header.AuthorKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.AuthorKey);
-            if (Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.BiosModeKey) == MergingFlag.None)
-                header[Models.Metadata.Header.BiosModeKey] = Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.BiosModeKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.BuildKey) == null)
-                header[Models.Metadata.Header.BuildKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.BuildKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.CategoryKey) == null)
-                header[Models.Metadata.Header.CategoryKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.CategoryKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.CommentKey) == null)
-                header[Models.Metadata.Header.CommentKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.CommentKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.DateKey) == null)
-                header[Models.Metadata.Header.DateKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.DateKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.DatVersionKey) == null)
-                header[Models.Metadata.Header.DatVersionKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.DatVersionKey);
-            if (Header.GetFieldValue<bool?>(Models.Metadata.Header.DebugKey) == null)
-                header[Models.Metadata.Header.DebugKey] = Header.GetFieldValue<bool?>(Models.Metadata.Header.DebugKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.DescriptionKey) == null)
-                header[Models.Metadata.Header.DescriptionKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.DescriptionKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.EmailKey) == null)
-                header[Models.Metadata.Header.EmailKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.EmailKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.EmulatorVersionKey) == null)
-                header[Models.Metadata.Header.EmulatorVersionKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.EmulatorVersionKey);
-            if (Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.ForceMergingKey) == MergingFlag.None)
-                header[Models.Metadata.Header.ForceMergingKey] = Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.ForceMergingKey);
-            if (Header.GetFieldValue<NodumpFlag>(Models.Metadata.Header.ForceNodumpKey) == NodumpFlag.None)
-                header[Models.Metadata.Header.ForceNodumpKey] = Header.GetFieldValue<NodumpFlag>(Models.Metadata.Header.ForceNodumpKey);
-            if (Header.GetFieldValue<PackingFlag>(Models.Metadata.Header.ForcePackingKey) == PackingFlag.None)
-                header[Models.Metadata.Header.ForcePackingKey] = Header.GetFieldValue<PackingFlag>(Models.Metadata.Header.ForcePackingKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.HeaderKey) == null)
-                header[Models.Metadata.Header.HeaderKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.HeaderKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.HomepageKey) == null)
-                header[Models.Metadata.Header.HomepageKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.HomepageKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.IdKey) == null)
-                header[Models.Metadata.Header.IdKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.IdKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.ImFolderKey) == null)
-                header[Models.Metadata.Header.ImFolderKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.ImFolderKey);
-            if (Header.GetFieldValue<bool?>(Models.Metadata.Header.LockBiosModeKey) == null)
-                header[Models.Metadata.Header.LockBiosModeKey] = Header.GetFieldValue<bool?>(Models.Metadata.Header.LockBiosModeKey);
-            if (Header.GetFieldValue<bool?>(Models.Metadata.Header.LockRomModeKey) == null)
-                header[Models.Metadata.Header.LockRomModeKey] = Header.GetFieldValue<bool?>(Models.Metadata.Header.LockRomModeKey);
-            if (Header.GetFieldValue<bool?>(Models.Metadata.Header.LockSampleModeKey) == null)
-                header[Models.Metadata.Header.LockSampleModeKey] = Header.GetFieldValue<bool?>(Models.Metadata.Header.LockSampleModeKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.MameConfigKey) == null)
-                header[Models.Metadata.Header.MameConfigKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.NameKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.NameKey) == null)
-                header[Models.Metadata.Header.NameKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.MameConfigKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.PluginKey) == null)
-                header[Models.Metadata.Header.PluginKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.PluginKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.RefNameKey) == null)
-                header[Models.Metadata.Header.RefNameKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.RefNameKey);
-            if (Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.RomModeKey) == MergingFlag.None)
-                header[Models.Metadata.Header.RomModeKey] = Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.RomModeKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.RomTitleKey) == null)
-                header[Models.Metadata.Header.RomTitleKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.RomTitleKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.RootDirKey) == null)
-                header[Models.Metadata.Header.RootDirKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.RootDirKey);
-            if (Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.SampleModeKey) == MergingFlag.None)
-                header[Models.Metadata.Header.SampleModeKey] = Header.GetFieldValue<MergingFlag>(Models.Metadata.Header.SampleModeKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.ScreenshotsHeightKey) == null)
-                header[Models.Metadata.Header.ScreenshotsHeightKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.ScreenshotsHeightKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.ScreenshotsWidthKey) == null)
-                header[Models.Metadata.Header.ScreenshotsWidthKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.ScreenshotsWidthKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.SystemKey) == null)
-                header[Models.Metadata.Header.SystemKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.SystemKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.TypeKey) == null)
-                header[Models.Metadata.Header.TypeKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.TypeKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.UrlKey) == null)
-                header[Models.Metadata.Header.UrlKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.UrlKey);
-            if (Header.GetFieldValue<string?>(Models.Metadata.Header.VersionKey) == null)
-                header[Models.Metadata.Header.VersionKey] = Header.GetFieldValue<string?>(Models.Metadata.Header.VersionKey);
+            var header = Header.GetInternalClone();
 
             // Convert subheader values
             if (Header.CanOpenSpecified)
@@ -252,6 +184,422 @@ namespace SabreTools.DatFiles
             return header;
         }
 
+        /// <summary>
+        /// Convert machines information
+        /// </summary>
+        private Models.Metadata.Machine[]? ConvertMachines(bool ignoreblanks = false)
+        {
+            // Create a machine list to hold all outputs
+            var machines = new List<Models.Metadata.Machine>();
+
+            // Loop through the sorted items and create games for them
+            foreach (string key in Items.SortedKeys)
+            {
+                var items = Items.FilteredItems(key);
+                if (items == null || !items.Any())
+                    continue;
+
+                // Create a machine to hold everything
+                var machine = items[0].GetFieldValue<DatItems.Machine>(DatItems.DatItem.MachineKey)!.GetInternalClone();
+
+                // Loop through and convert the items to respective lists
+                for (int index = 0; index < items.Count; index++)
+                {
+                    // Get the item
+                    var item = items[index];
+
+                    // Check for a "null" item
+                    item = ProcessNullifiedItem(item);
+
+                    // Skip if we're ignoring the item
+                    if (ShouldIgnore(item, ignoreblanks))
+                        continue;
+
+                    switch (item)
+                    {
+                        case DatItems.Formats.Adjuster adjuster:
+                            var adjusterItem = ProcessItem(adjuster);
+                            EnsureMachineKey<Models.Metadata.Adjuster[]?>(machine, Models.Metadata.Machine.AdjusterKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.AdjusterKey, adjusterItem);
+                            break;
+                        case DatItems.Formats.Archive archive:
+                            var archiveItem = archive.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Archive[]?>(machine, Models.Metadata.Machine.ArchiveKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.ArchiveKey, archiveItem);
+                            break;
+                        case DatItems.Formats.BiosSet biosSet:
+                            var biosSetItem = biosSet.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.BiosSet[]?>(machine, Models.Metadata.Machine.BiosSetKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.BiosSetKey, biosSetItem);
+                            break;
+                        case DatItems.Formats.Chip chip:
+                            var chipItem = chip.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Chip[]?>(machine, Models.Metadata.Machine.ChipKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.ChipKey, chipItem);
+                            break;
+                        case DatItems.Formats.Configuration configuration:
+                            var configurationItem = ProcessItem(configuration);
+                            EnsureMachineKey<Models.Metadata.Configuration[]?>(machine, Models.Metadata.Machine.ConfigurationKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.ConfigurationKey, configurationItem);
+                            break;
+                        case DatItems.Formats.Device device:
+                            var deviceItem = ProcessItem(device);
+                            EnsureMachineKey<Models.Metadata.Device[]?>(machine, Models.Metadata.Machine.DeviceKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.DeviceKey, deviceItem);
+                            break;
+                        case DatItems.Formats.DeviceRef deviceRef:
+                            var deviceRefItem = deviceRef.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.DeviceRef[]?>(machine, Models.Metadata.Machine.DeviceRefKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.DeviceRefKey, deviceRefItem);
+                            break;
+                        case DatItems.Formats.DipSwitch dipSwitch:
+                            var dipSwitchItem = ProcessItem(dipSwitch);
+                            EnsureMachineKey<Models.Metadata.DipSwitch[]?>(machine, Models.Metadata.Machine.DipSwitchKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.DipSwitchKey, dipSwitchItem);
+                            break;
+                        case DatItems.Formats.Disk disk:
+                            var diskItem = ProcessItem(disk);
+                            EnsureMachineKey<Models.Metadata.Disk[]?>(machine, Models.Metadata.Machine.DiskKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.DiskKey, diskItem);
+                            break;
+                        case DatItems.Formats.Display display:
+                            // TODO: Handle cases where it's actually a Video
+                            var displayItem = display.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Display[]?>(machine, Models.Metadata.Machine.DisplayKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.DisplayKey, displayItem);
+                            break;
+                        case DatItems.Formats.Driver driver:
+                            var driverItem = driver.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Driver[]?>(machine, Models.Metadata.Machine.DriverKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.DriverKey, driverItem);
+                            break;
+                        case DatItems.Formats.Feature feature:
+                            var featureItem = feature.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Feature[]?>(machine, Models.Metadata.Machine.FeatureKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.FeatureKey, featureItem);
+                            break;
+                        case DatItems.Formats.Info info:
+                            var infoItem = info.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Info[]?>(machine, Models.Metadata.Machine.InfoKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.InfoKey, infoItem);
+                            break;
+                        case DatItems.Formats.Input input:
+                            var inputItem = ProcessItem(input);
+                            EnsureMachineKey<Models.Metadata.Input[]?>(machine, Models.Metadata.Machine.InputKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.InputKey, inputItem);
+                            break;
+                        case DatItems.Formats.Media media:
+                            var mediaItem = media.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Media[]?>(machine, Models.Metadata.Machine.MediaKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.MediaKey, mediaItem);
+                            break;
+                        case DatItems.Formats.Port port:
+                            var portItem = ProcessItem(port);
+                            EnsureMachineKey<Models.Metadata.Port[]?>(machine, Models.Metadata.Machine.PortKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.PortKey, portItem);
+                            break;
+                        case DatItems.Formats.RamOption ramOption:
+                            var ramOptionItem = ramOption.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.RamOption[]?>(machine, Models.Metadata.Machine.RamOptionKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.RamOptionKey, ramOptionItem);
+                            break;
+                        case DatItems.Formats.Release release:
+                            var releaseItem = release.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Release[]?>(machine, Models.Metadata.Machine.ReleaseKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.ReleaseKey, releaseItem);
+                            break;
+                        case DatItems.Formats.Rom rom:
+                            // TODO: Handle cases where it's actually a Dump
+                            var romItem = ProcessItem(rom);
+                            EnsureMachineKey<Models.Metadata.Rom[]?>(machine, Models.Metadata.Machine.RomKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.RomKey, romItem);
+                            break;
+                        case DatItems.Formats.Sample sample:
+                            var sampleItem = sample.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Sample[]?>(machine, Models.Metadata.Machine.SampleKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.SampleKey, sampleItem);
+                            break;
+                        case DatItems.Formats.SharedFeat sharedFeat:
+                            var sharedFeatItem = sharedFeat.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.SharedFeat[]?>(machine, Models.Metadata.Machine.SharedFeatKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.SharedFeatKey, sharedFeatItem);
+                            break;
+                        case DatItems.Formats.Slot slot:
+                            var slotItem = ProcessItem(slot);
+                            EnsureMachineKey<Models.Metadata.Slot[]?>(machine, Models.Metadata.Machine.SlotKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.SlotKey, slotItem);
+                            break;
+                        case DatItems.Formats.SoftwareList softwareList:
+                            var softwareListItem = softwareList.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.SoftwareList[]?>(machine, Models.Metadata.Machine.SoftwareListKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.SoftwareListKey, softwareListItem);
+                            break;
+                        case DatItems.Formats.Sound sound:
+                            var soundItem = sound.GetInternalClone();
+                            EnsureMachineKey<Models.Metadata.Sound[]?>(machine, Models.Metadata.Machine.SoundKey);
+                            AppendToMachineKey(machine, Models.Metadata.Machine.SoundKey, soundItem);
+                            break;
+                    }
+                }
+
+                // Add the machine to the list
+                machines.Add(machine);
+            }
+
+            // Return the list of machines
+            return [.. machines];
+        }
+
+        /// <summary>
+        /// Convert Adjuster information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Adjuster ProcessItem(DatItems.Formats.Adjuster item)
+        {
+            var adjusterItem = item.GetInternalClone();
+
+            var condition = item.GetFieldValue<DatItems.Formats.Condition?>(Models.Metadata.Adjuster.ConditionKey);
+            if (condition != null)
+                adjusterItem[Models.Metadata.Adjuster.ConditionKey] = condition.GetInternalClone();
+
+            return adjusterItem;
+        }
+
+        /// <summary>
+        /// Convert Configuration information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Configuration ProcessItem(DatItems.Formats.Configuration item)
+        {
+            var configurationItem = item.GetInternalClone();
+
+            var condition = item.GetFieldValue<DatItems.Formats.Condition?>(Models.Metadata.Configuration.ConditionKey);
+            if (condition != null)
+                configurationItem[Models.Metadata.Configuration.ConditionKey] = condition.GetInternalClone();
+
+            var confLocations = item.GetFieldValue<DatItems.Formats.ConfLocation[]?>(Models.Metadata.Configuration.ConfLocationKey);
+            if (confLocations != null)
+            {
+                var confLocationItems = new List<Models.Metadata.ConfLocation>();
+                foreach (var confLocation in confLocations)
+                {
+                    var confLocationItem = confLocation.GetInternalClone();
+                    confLocationItems.Add(confLocationItem);
+                }
+
+                configurationItem[Models.Metadata.Configuration.ConfLocationKey] = confLocationItems.ToArray();
+            }
+
+            var confSettings = item.GetFieldValue<DatItems.Formats.ConfSetting[]?>(Models.Metadata.Configuration.ConfSettingKey);
+            if (confSettings != null)
+            {
+                var confSettingItems = new List<Models.Metadata.ConfSetting>();
+                foreach (var confSetting in confSettings)
+                {
+                    var confSettingItem = confSetting.GetInternalClone();
+                    confSettingItems.Add(confSettingItem);
+                }
+
+                configurationItem[Models.Metadata.Configuration.ConfSettingKey] = confSettingItems.ToArray();
+            }
+
+            return configurationItem;
+        }
+
+        /// <summary>
+        /// Convert Device information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Device ProcessItem(DatItems.Formats.Device item)
+        {
+            var deviceItem = item.GetInternalClone();
+
+            var instance = item.GetFieldValue<DatItems.Formats.Instance?>(Models.Metadata.Device.InstanceKey);
+            if (instance != null)
+                deviceItem[Models.Metadata.Device.InstanceKey] = instance.GetInternalClone();
+
+            var extensions = item.GetFieldValue<DatItems.Formats.Extension[]?>(Models.Metadata.Device.ExtensionKey);
+            if (extensions != null)
+            {
+                var extensionItems = new List<Models.Metadata.Extension>();
+                foreach (var extension in extensions)
+                {
+                    var extensionItem = extension.GetInternalClone();
+                    extensionItems.Add(extensionItem);
+                }
+
+                deviceItem[Models.Metadata.Device.ExtensionKey] = extensionItems.ToArray();
+            }
+
+            return deviceItem;
+        }
+
+        /// <summary>
+        /// Convert DipSwitch information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.DipSwitch ProcessItem(DatItems.Formats.DipSwitch item)
+        {
+            var dipSwitchItem = item.GetInternalClone();
+
+            var condition = item.GetFieldValue<DatItems.Formats.Condition?>(Models.Metadata.DipSwitch.ConditionKey);
+            if (condition != null)
+                dipSwitchItem[Models.Metadata.DipSwitch.ConditionKey] = condition.GetInternalClone();
+
+            var dipLocations = item.GetFieldValue<DatItems.Formats.DipLocation[]?>(Models.Metadata.DipSwitch.DipLocationKey);
+            if (dipLocations != null)
+            {
+                var dipLocationItems = new List<Models.Metadata.DipLocation>();
+                foreach (var dipLocation in dipLocations)
+                {
+                    var extensionItem = dipLocation.GetInternalClone();
+                    dipLocationItems.Add(extensionItem);
+                }
+
+                dipSwitchItem[Models.Metadata.DipSwitch.DipLocationKey] = dipLocationItems.ToArray();
+            }
+
+            var dipValues = item.GetFieldValue<DatItems.Formats.DipValue[]?>(Models.Metadata.DipSwitch.DipValueKey);
+            if (dipValues != null)
+            {
+                var dipValueItems = new List<Models.Metadata.DipValue>();
+                foreach (var dipValue in dipValues)
+                {
+                    var extensionItem = dipValue.GetInternalClone();
+                    dipValueItems.Add(extensionItem);
+                }
+
+                dipSwitchItem[Models.Metadata.DipSwitch.DipValueKey] = dipValueItems.ToArray();
+            }
+
+            // TODO: Handle DipSwitch in Part inversion
+
+            return dipSwitchItem;
+        }
+
+        /// <summary>
+        /// Convert Disk information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Disk ProcessItem(DatItems.Formats.Disk item)
+        {
+            var diskItem = item.GetInternalClone();
+
+            // TODO: Handle DipSwitch in Part inversion
+            // TODO: Handle DipSwitch in DiskArea inversion
+
+            return diskItem;
+        }
+
+        /// <summary>
+        /// Convert Input information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Input ProcessItem(DatItems.Formats.Input item)
+        {
+            var inputItem = item.GetInternalClone();
+
+            var controls = item.GetFieldValue<DatItems.Formats.Control[]?>(Models.Metadata.Input.ControlKey);
+            if (controls != null)
+            {
+                var controlItems = new List<Models.Metadata.Control>();
+                foreach (var control in controls)
+                {
+                    var controlItem = control.GetInternalClone();
+                    controlItems.Add(controlItem);
+                }
+
+                inputItem[Models.Metadata.Input.ControlKey] = controlItems.ToArray();
+            }
+
+            return inputItem;
+        }
+
+        /// <summary>
+        /// Convert Port information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Port ProcessItem(DatItems.Formats.Port item)
+        {
+            var slotItem = item.GetInternalClone();
+
+            var analogs = item.GetFieldValue<DatItems.Formats.Analog[]?>(Models.Metadata.Port.AnalogKey);
+            if (analogs != null)
+            {
+                var analogItems = new List<Models.Metadata.Analog>();
+                foreach (var analog in analogs)
+                {
+                    var extensionItem = analog.GetInternalClone();
+                    analogItems.Add(extensionItem);
+                }
+
+                slotItem[Models.Metadata.Port.AnalogKey] = analogItems.ToArray();
+            }
+
+            return slotItem;
+        }
+
+        /// <summary>
+        /// Convert Rom information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Rom ProcessItem(DatItems.Formats.Rom item)
+        {
+            var romItem = item.GetInternalClone();
+
+            // TODO: Handle DipSwitch in Part inversion
+            // TODO: Handle DipSwitch in DataArea inversion
+
+            return romItem;
+        }
+
+        /// <summary>
+        /// Convert Slot information
+        /// </summary>
+        /// <param name="item">Item to convert</param>
+        private static Models.Metadata.Slot ProcessItem(DatItems.Formats.Slot item)
+        {
+            var slotItem = item.GetInternalClone();
+
+            var slotOptions = item.GetFieldValue<DatItems.Formats.SlotOption[]?>(Models.Metadata.Slot.SlotOptionKey);
+            if (slotOptions != null)
+            {
+                var slotOptionItems = new List<Models.Metadata.SlotOption>();
+                foreach (var slotOption in slotOptions)
+                {
+                    var extensionItem = slotOption.GetInternalClone();
+                    slotOptionItems.Add(extensionItem);
+                }
+
+                slotItem[Models.Metadata.Slot.SlotOptionKey] = slotOptionItems.ToArray();
+            }
+
+            return slotItem;
+        }
+
+        /// <summary>
+        /// Ensure a key in a machine
+        /// </summary>
+        private static void EnsureMachineKey<T>(Models.Metadata.Machine machine, string key)
+        {
+            if (machine.Read<T>(key) == null)
+                machine[key] = Activator.CreateInstance<T>();
+        }
+
+        /// <summary>
+        /// Append to a machine key as if its an array
+        /// </summary>
+        private static void AppendToMachineKey<T>(Models.Metadata.Machine machine, string key, T value)
+        {
+            var arr = machine.Read<T[]>(key);
+            if (arr == null)
+                return;
+
+            List<T> list = [.. arr];
+            list.Add(value);
+            machine[key] = list.ToArray();
+        }
+
         #endregion
     }
 }
\ No newline at end of file
diff --git a/SabreTools.DatFiles/DatHeader.cs b/SabreTools.DatFiles/DatHeader.cs
index fed8e764..01aec6e6 100644
--- a/SabreTools.DatFiles/DatHeader.cs
+++ b/SabreTools.DatFiles/DatHeader.cs
@@ -181,6 +181,11 @@ namespace SabreTools.DatFiles
             return true;
         }
 
+        /// <summary>
+        /// Get a clone of the current internal model
+        /// </summary>
+        public Models.Metadata.Header GetInternalClone() => (_header.Clone() as Models.Metadata.Header)!;
+
         #endregion
 
         #region Cloning Methods
diff --git a/SabreTools.DatItems/Formats/Archive.cs b/SabreTools.DatItems/Formats/Archive.cs
index a3a31116..862518e1 100644
--- a/SabreTools.DatItems/Formats/Archive.cs
+++ b/SabreTools.DatItems/Formats/Archive.cs
@@ -8,13 +8,18 @@ namespace SabreTools.DatItems.Formats
     /// Represents generic archive files to be included in a set
     /// </summary>
     [JsonObject("archive"), XmlRoot("archive")]
-    public sealed class Archive : DatItem
+    public sealed class Archive : DatItem<Models.Metadata.Archive>
     {
         #region Fields
 
         /// <inheritdoc>/>
         protected override ItemType ItemType => ItemType.Archive;
 
+        /// <inheritdoc>/>
+        protected override string? NameKey => Models.Metadata.Archive.NameKey;
+
+        // TODO: None of the following are used or checked
+
         /// <summary>
         /// Archive ID number
         /// </summary>
@@ -84,51 +89,8 @@ namespace SabreTools.DatItems.Formats
 
         #region Constructors
 
-        /// <summary>
-        /// Create a default, empty Archive object
-        /// </summary>
-        public Archive()
-        {
-            _internal = new Models.Metadata.Archive();
-
-            SetName(string.Empty);
-            SetFieldValue<ItemType>(Models.Metadata.DatItem.TypeKey, ItemType);
-            SetFieldValue<Machine>(DatItem.MachineKey, new Machine());
-        }
-
-        /// <summary>
-        /// Create an Archive object from the internal model
-        /// </summary>
-        public Archive(Models.Metadata.Archive item)
-        {
-            _internal = item;
-
-            SetFieldValue<ItemType>(Models.Metadata.DatItem.TypeKey, ItemType);
-            SetFieldValue<Machine>(DatItem.MachineKey, new Machine());
-        }
-
-        #endregion
-
-        #region Accessors
-
-        /// <inheritdoc/>
-        public override string? GetName() => GetFieldValue<string>(Models.Metadata.Archive.NameKey);
-
-        /// <inheritdoc/>
-        public override void SetName(string? name) => SetFieldValue(Models.Metadata.Archive.NameKey, name);
-        
-        #endregion
-
-        #region Cloning Methods
-
-        /// <inheritdoc/>
-        public override object Clone()
-        {
-            return new Archive()
-            {
-                _internal = this._internal?.Clone() as Models.Metadata.Archive ?? [],
-            };
-        }
+        public Archive() : base() { }
+        public Archive(Models.Metadata.Archive item) : base(item) { }
 
         #endregion
     }
diff --git a/SabreTools.DatItems/Machine.cs b/SabreTools.DatItems/Machine.cs
index eeec4ee7..d2c9af7e 100644
--- a/SabreTools.DatItems/Machine.cs
+++ b/SabreTools.DatItems/Machine.cs
@@ -148,6 +148,11 @@ namespace SabreTools.DatItems
             return true;
         }
 
+        /// <summary>
+        /// Get a clone of the current internal model
+        /// </summary>
+        public Models.Metadata.Machine GetInternalClone() => (_machine.Clone() as Models.Metadata.Machine)!;
+
         #endregion
 
         #region Constructors