diff --git a/CrossModel/ClrMamePro.Deserializer.cs b/CrossModel/ClrMamePro.Deserializer.cs
new file mode 100644
index 00000000..79662031
--- /dev/null
+++ b/CrossModel/ClrMamePro.Deserializer.cs
@@ -0,0 +1,410 @@
+using System;
+using System.Linq;
+using SabreTools.Models.ClrMamePro;
+
+namespace SabreTools.Serialization.CrossModel
+{
+    public partial class ClrMamePro : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
+    {
+        /// <inheritdoc/>
+#if NET48
+        public MetadataFile Deserialize(Models.Metadata.MetadataFile obj) => Deserialize(obj, false);
+#else
+        public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj) => Deserialize(obj, false);
+#endif
+
+        /// <inheritdoc cref="Deserialize(Models.Metadata.MetadataFile)"/>
+#if NET48
+        public MetadataFile Deserialize(Models.Metadata.MetadataFile obj, bool game)
+#else
+        public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj, bool game)
+#endif
+        {
+            if (obj == null)
+                return null;
+
+            var metadataFile = new MetadataFile();
+
+            var header = obj.Read<Models.Metadata.Header>(Models.Metadata.MetadataFile.HeaderKey);
+            if (header != null)
+                metadataFile.ClrMamePro = ConvertHeaderFromInternalModel(header);
+
+            var machines = obj.Read<Models.Metadata.Machine[]>(Models.Metadata.MetadataFile.MachineKey);
+            if (machines != null && machines.Any())
+            {
+                metadataFile.Game = machines
+                    .Where(m => m != null)
+                    .Select(machine => ConvertMachineFromInternalModel(machine, game))
+                    .ToArray();
+            }
+
+            return metadataFile;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Header"/> to <cref="Models.ClrMamePro.ClrMamePro"/>
+        /// </summary>
+        private static Models.ClrMamePro.ClrMamePro ConvertHeaderFromInternalModel(Models.Metadata.Header item)
+        {
+            var clrMamePro = new Models.ClrMamePro.ClrMamePro
+            {
+                Name = item.ReadString(Models.Metadata.Header.NameKey),
+                Description = item.ReadString(Models.Metadata.Header.DescriptionKey),
+                RootDir = item.ReadString(Models.Metadata.Header.RootDirKey),
+                Category = item.ReadString(Models.Metadata.Header.CategoryKey),
+                Version = item.ReadString(Models.Metadata.Header.VersionKey),
+                Date = item.ReadString(Models.Metadata.Header.DateKey),
+                Author = item.ReadString(Models.Metadata.Header.AuthorKey),
+                Homepage = item.ReadString(Models.Metadata.Header.HomepageKey),
+                Url = item.ReadString(Models.Metadata.Header.UrlKey),
+                Comment = item.ReadString(Models.Metadata.Header.CommentKey),
+                Header = item.ReadString(Models.Metadata.Header.HeaderKey),
+                Type = item.ReadString(Models.Metadata.Header.TypeKey),
+                ForceMerging = item.ReadString(Models.Metadata.Header.ForceMergingKey),
+                ForceZipping = item.ReadString(Models.Metadata.Header.ForceZippingKey),
+                ForcePacking = item.ReadString(Models.Metadata.Header.ForcePackingKey),
+            };
+            return clrMamePro;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Archive"/> to <cref="Models.ClrMamePro.Machine"/>
+        /// </summary>
+        private static GameBase ConvertMachineFromInternalModel(Models.Metadata.Machine item, bool game = false)
+        {
+#if NET48
+            GameBase gameBase;
+            if (game)
+                gameBase = new Game();
+            else
+                gameBase = new Machine();
+#else
+            GameBase gameBase = game ? new Models.ClrMamePro.Game() : new Models.ClrMamePro.Machine();
+#endif
+
+            gameBase.Name = item.ReadString(Models.Metadata.Machine.NameKey);
+            gameBase.Description = item.ReadString(Models.Metadata.Machine.DescriptionKey);
+            gameBase.Year = item.ReadString(Models.Metadata.Machine.YearKey);
+            gameBase.Manufacturer = item.ReadString(Models.Metadata.Machine.ManufacturerKey);
+            gameBase.Category = item.ReadString(Models.Metadata.Machine.CategoryKey);
+            gameBase.CloneOf = item.ReadString(Models.Metadata.Machine.CloneOfKey);
+            gameBase.RomOf = item.ReadString(Models.Metadata.Machine.RomOfKey);
+            gameBase.SampleOf = item.ReadString(Models.Metadata.Machine.SampleOfKey);
+
+            var releases = item.Read<Models.Metadata.Release[]>(Models.Metadata.Machine.ReleaseKey);
+            if (releases != null && releases.Any())
+            {
+                gameBase.Release = releases
+                    .Where(r => r != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var biosSets = item.Read<Models.Metadata.BiosSet[]>(Models.Metadata.Machine.BiosSetKey);
+            if (biosSets != null && biosSets.Any())
+            {
+                gameBase.BiosSet = biosSets
+                    .Where(r => r != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var roms = item.Read<Models.Metadata.Rom[]>(Models.Metadata.Machine.RomKey);
+            if (roms != null && roms.Any())
+            {
+                gameBase.Rom = roms
+                    .Where(r => r != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var disks = item.Read<Models.Metadata.Disk[]>(Models.Metadata.Machine.DiskKey);
+            if (disks != null && disks.Any())
+            {
+                gameBase.Disk = disks
+                    .Where(d => d != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var medias = item.Read<Models.Metadata.Media[]>(Models.Metadata.Machine.MediaKey);
+            if (medias != null && medias.Any())
+            {
+                gameBase.Media = medias
+                    .Where(m => m != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var samples = item.Read<Models.Metadata.Sample[]>(Models.Metadata.Machine.SampleKey);
+            if (samples != null && samples.Any())
+            {
+                gameBase.Sample = samples
+                    .Where(m => m != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var archives = item.Read<Models.Metadata.Archive[]>(Models.Metadata.Machine.ArchiveKey);
+            if (archives != null && archives.Any())
+            {
+                gameBase.Archive = archives
+                    .Where(m => m != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var chips = item.Read<Models.Metadata.Chip[]>(Models.Metadata.Machine.ChipKey);
+            if (chips != null && chips.Any())
+            {
+                gameBase.Chip = chips
+                    .Where(m => m != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var videos = item.Read<Models.Metadata.Video[]>(Models.Metadata.Machine.VideoKey);
+            if (videos != null && videos.Any())
+            {
+                gameBase.Video = videos
+                    .Where(m => m != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var sound = item.Read<Models.Metadata.Sound>(Models.Metadata.Machine.SoundKey);
+            if (sound != null)
+                gameBase.Sound = ConvertFromInternalModel(sound);
+
+            var input = item.Read<Models.Metadata.Input>(Models.Metadata.Machine.InputKey);
+            if (input != null)
+                gameBase.Input = ConvertFromInternalModel(input);
+
+            var dipSwitches = item.Read<Models.Metadata.DipSwitch[]>(Models.Metadata.Machine.DipSwitchKey);
+            if (dipSwitches != null && dipSwitches.Any())
+            {
+                gameBase.DipSwitch = dipSwitches
+                    .Where(m => m != null)
+                    .Select(ConvertFromInternalModel)
+                    .ToArray();
+            }
+
+            var driver = item.Read<Models.Metadata.Driver>(Models.Metadata.Machine.DriverKey);
+            if (driver != null)
+                gameBase.Driver = ConvertFromInternalModel(driver);
+
+            return gameBase;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Archive"/> to <cref="Models.ClrMamePro.Archive"/>
+        /// </summary>
+        private static Archive ConvertFromInternalModel(Models.Metadata.Archive item)
+        {
+            var archive = new Archive
+            {
+                Name = item.ReadString(Models.Metadata.Archive.NameKey),
+            };
+            return archive;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.BiosSet"/> to <cref="Models.ClrMamePro.BiosSet"/>
+        /// </summary>
+        private static BiosSet ConvertFromInternalModel(Models.Metadata.BiosSet item)
+        {
+            var biosset = new BiosSet
+            {
+                Name = item.ReadString(Models.Metadata.BiosSet.NameKey),
+                Description = item.ReadString(Models.Metadata.BiosSet.DescriptionKey),
+                Default = item.ReadString(Models.Metadata.BiosSet.DefaultKey),
+            };
+            return biosset;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Chip"/> to <cref="Models.ClrMamePro.Chip"/>
+        /// </summary>
+        private static Chip ConvertFromInternalModel(Models.Metadata.Chip item)
+        {
+            var chip = new Chip
+            {
+                Type = item.ReadString(Models.Metadata.Chip.ChipTypeKey),
+                Name = item.ReadString(Models.Metadata.Chip.NameKey),
+                Flags = item.ReadString(Models.Metadata.Chip.FlagsKey),
+                Clock = item.ReadString(Models.Metadata.Chip.ClockKey),
+            };
+            return chip;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.DipSwitch"/> to <cref="Models.ClrMamePro.DipSwitch"/>
+        /// </summary>
+        private static DipSwitch ConvertFromInternalModel(Models.Metadata.DipSwitch item)
+        {
+            var dipswitch = new DipSwitch
+            {
+                Name = item.ReadString(Models.Metadata.DipSwitch.NameKey),
+                Entry = item[Models.Metadata.DipSwitch.EntryKey] as string[],
+                Default = item.ReadString(Models.Metadata.DipSwitch.DefaultKey),
+            };
+            return dipswitch;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Disk"/> to <cref="Models.ClrMamePro.Disk"/>
+        /// </summary>
+        private static Disk ConvertFromInternalModel(Models.Metadata.Disk item)
+        {
+            var disk = new Disk
+            {
+                Name = item.ReadString(Models.Metadata.Disk.NameKey),
+                MD5 = item.ReadString(Models.Metadata.Disk.MD5Key),
+                SHA1 = item.ReadString(Models.Metadata.Disk.SHA1Key),
+                Merge = item.ReadString(Models.Metadata.Disk.MergeKey),
+                Status = item.ReadString(Models.Metadata.Disk.StatusKey),
+                Flags = item.ReadString(Models.Metadata.Disk.FlagsKey),
+            };
+            return disk;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Driver"/> to <cref="Models.ClrMamePro.Driver"/>
+        /// </summary>
+        private static Driver ConvertFromInternalModel(Models.Metadata.Driver item)
+        {
+            var driver = new Driver
+            {
+                Status = item.ReadString(Models.Metadata.Driver.StatusKey),
+                Color = item.ReadString(Models.Metadata.Driver.ColorKey),
+                Sound = item.ReadString(Models.Metadata.Driver.SoundKey),
+                PaletteSize = item.ReadString(Models.Metadata.Driver.PaletteSizeKey),
+                Blit = item.ReadString(Models.Metadata.Driver.BlitKey),
+            };
+            return driver;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Input"/> to <cref="Models.ClrMamePro.Input"/>
+        /// </summary>
+        private static Input ConvertFromInternalModel(Models.Metadata.Input item)
+        {
+            var input = new Input
+            {
+                Players = item.ReadString(Models.Metadata.Input.PlayersKey),
+                Control = item.ReadString(Models.Metadata.Input.ControlKey),
+                Buttons = item.ReadString(Models.Metadata.Input.ButtonsKey),
+                Coins = item.ReadString(Models.Metadata.Input.CoinsKey),
+                Tilt = item.ReadString(Models.Metadata.Input.TiltKey),
+                Service = item.ReadString(Models.Metadata.Input.ServiceKey),
+            };
+            return input;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Media"/> to <cref="Models.ClrMamePro.Media"/>
+        /// </summary>
+        private static Media ConvertFromInternalModel(Models.Metadata.Media item)
+        {
+            var media = new Media
+            {
+                Name = item.ReadString(Models.Metadata.Media.NameKey),
+                MD5 = item.ReadString(Models.Metadata.Media.MD5Key),
+                SHA1 = item.ReadString(Models.Metadata.Media.SHA1Key),
+                SHA256 = item.ReadString(Models.Metadata.Media.SHA256Key),
+                SpamSum = item.ReadString(Models.Metadata.Media.SpamSumKey),
+            };
+            return media;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Release"/> to <cref="Models.ClrMamePro.Release"/>
+        /// </summary>
+        private static Release ConvertFromInternalModel(Models.Metadata.Release item)
+        {
+            var release = new Release
+            {
+                Name = item.ReadString(Models.Metadata.Release.NameKey),
+                Region = item.ReadString(Models.Metadata.Release.RegionKey),
+                Language = item.ReadString(Models.Metadata.Release.LanguageKey),
+                Date = item.ReadString(Models.Metadata.Release.DateKey),
+                Default = item.ReadString(Models.Metadata.Release.DefaultKey),
+            };
+            return release;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Rom"/> to <cref="Models.ClrMamePro.Rom"/>
+        /// </summary>
+        private static Rom ConvertFromInternalModel(Models.Metadata.Rom item)
+        {
+            var rom = new Rom
+            {
+                Name = item.ReadString(Models.Metadata.Rom.NameKey),
+                Size = item.ReadString(Models.Metadata.Rom.SizeKey),
+                CRC = item.ReadString(Models.Metadata.Rom.CRCKey),
+                MD5 = item.ReadString(Models.Metadata.Rom.MD5Key),
+                SHA1 = item.ReadString(Models.Metadata.Rom.SHA1Key),
+                SHA256 = item.ReadString(Models.Metadata.Rom.SHA256Key),
+                SHA384 = item.ReadString(Models.Metadata.Rom.SHA384Key),
+                SHA512 = item.ReadString(Models.Metadata.Rom.SHA512Key),
+                SpamSum = item.ReadString(Models.Metadata.Rom.SpamSumKey),
+                xxHash364 = item.ReadString(Models.Metadata.Rom.xxHash364Key),
+                xxHash3128 = item.ReadString(Models.Metadata.Rom.xxHash3128Key),
+                Merge = item.ReadString(Models.Metadata.Rom.MergeKey),
+                Status = item.ReadString(Models.Metadata.Rom.StatusKey),
+                Region = item.ReadString(Models.Metadata.Rom.RegionKey),
+                Flags = item.ReadString(Models.Metadata.Rom.FlagsKey),
+                Offs = item.ReadString(Models.Metadata.Rom.OffsetKey),
+                Serial = item.ReadString(Models.Metadata.Rom.SerialKey),
+                Header = item.ReadString(Models.Metadata.Rom.HeaderKey),
+                Date = item.ReadString(Models.Metadata.Rom.DateKey),
+                Inverted = item.ReadString(Models.Metadata.Rom.InvertedKey),
+                MIA = item.ReadString(Models.Metadata.Rom.MIAKey),
+            };
+            return rom;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Sample"/> to <cref="Models.ClrMamePro.Sample"/>
+        /// </summary>
+        private static Sample ConvertFromInternalModel(Models.Metadata.Sample item)
+        {
+            var sample = new Sample
+            {
+                Name = item.ReadString(Models.Metadata.Sample.NameKey),
+            };
+            return sample;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Sound"/> to <cref="Models.ClrMamePro.Sound"/>
+        /// </summary>
+        private static Sound ConvertFromInternalModel(Models.Metadata.Sound item)
+        {
+            var sound = new Sound
+            {
+                Channels = item.ReadString(Models.Metadata.Sound.ChannelsKey),
+            };
+            return sound;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.Metadata.Video"/> to <cref="Models.ClrMamePro.Video"/>
+        /// </summary>
+        private static Video ConvertFromInternalModel(Models.Metadata.Video item)
+        {
+            var video = new Video
+            {
+                Screen = item.ReadString(Models.Metadata.Video.ScreenKey),
+                Orientation = item.ReadString(Models.Metadata.Video.OrientationKey),
+                X = item.ReadString(Models.Metadata.Video.WidthKey),
+                Y = item.ReadString(Models.Metadata.Video.HeightKey),
+                AspectX = item.ReadString(Models.Metadata.Video.AspectXKey),
+                AspectY = item.ReadString(Models.Metadata.Video.AspectYKey),
+                Freq = item.ReadString(Models.Metadata.Video.RefreshKey),
+            };
+            return video;
+        }
+    }
+}
\ No newline at end of file
diff --git a/CrossModel/ClrMamePro.Serializer.cs b/CrossModel/ClrMamePro.Serializer.cs
new file mode 100644
index 00000000..e11d5ca8
--- /dev/null
+++ b/CrossModel/ClrMamePro.Serializer.cs
@@ -0,0 +1,380 @@
+using System.Linq;
+using SabreTools.Models.ClrMamePro;
+
+namespace SabreTools.Serialization.CrossModel
+{
+    public partial class ClrMamePro : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
+    {
+        /// <inheritdoc/>
+#if NET48
+        public Models.Metadata.MetadataFile Serialize(MetadataFile obj)
+#else
+        public Models.Metadata.MetadataFile? Serialize(MetadataFile? obj)
+#endif
+        {
+            if (obj == null)
+                return null;
+
+            var metadataFile = new Models.Metadata.MetadataFile();
+
+            if (obj?.ClrMamePro != null)
+                metadataFile[Models.Metadata.MetadataFile.HeaderKey] = ConvertHeaderToInternalModel(obj.ClrMamePro);
+
+            if (obj?.Game != null && obj.Game.Any())
+            {
+                metadataFile[Models.Metadata.MetadataFile.MachineKey] = obj.Game
+                    .Where(g => g != null)
+                    .Select(ConvertMachineToInternalModel)
+                    .ToArray();
+            }
+
+            return metadataFile;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.ClrMamePro"/> to <cref="Models.Metadata.Header"/>
+        /// </summary>
+        private static Models.Metadata.Header ConvertHeaderToInternalModel(Models.ClrMamePro.ClrMamePro item)
+        {
+            var header = new Models.Metadata.Header
+            {
+                [Models.Metadata.Header.NameKey] = item.Name,
+                [Models.Metadata.Header.DescriptionKey] = item.Description,
+                [Models.Metadata.Header.RootDirKey] = item.RootDir,
+                [Models.Metadata.Header.CategoryKey] = item.Category,
+                [Models.Metadata.Header.VersionKey] = item.Version,
+                [Models.Metadata.Header.DateKey] = item.Date,
+                [Models.Metadata.Header.AuthorKey] = item.Author,
+                [Models.Metadata.Header.HomepageKey] = item.Homepage,
+                [Models.Metadata.Header.UrlKey] = item.Url,
+                [Models.Metadata.Header.CommentKey] = item.Comment,
+                [Models.Metadata.Header.HeaderKey] = item.Header,
+                [Models.Metadata.Header.TypeKey] = item.Type,
+                [Models.Metadata.Header.ForceMergingKey] = item.ForceMerging,
+                [Models.Metadata.Header.ForceZippingKey] = item.ForceZipping,
+                [Models.Metadata.Header.ForcePackingKey] = item.ForcePacking,
+            };
+            return header;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.GameBase"/> to <cref="Models.Metadata.Machine"/>
+        /// </summary>
+        private static Models.Metadata.Machine ConvertMachineToInternalModel(GameBase item)
+        {
+            var machine = new Models.Metadata.Machine
+            {
+                [Models.Metadata.Machine.NameKey] = item.Name,
+                [Models.Metadata.Machine.DescriptionKey] = item.Description,
+                [Models.Metadata.Machine.YearKey] = item.Year,
+                [Models.Metadata.Machine.ManufacturerKey] = item.Manufacturer,
+                [Models.Metadata.Machine.CategoryKey] = item.Category,
+                [Models.Metadata.Machine.CloneOfKey] = item.CloneOf,
+                [Models.Metadata.Machine.RomOfKey] = item.RomOf,
+                [Models.Metadata.Machine.SampleOfKey] = item.SampleOf,
+            };
+
+            if (item.Release != null && item.Release.Any())
+            {
+                machine[Models.Metadata.Machine.ReleaseKey] = item.Release
+                    .Where(r => r != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.BiosSet != null && item.BiosSet.Any())
+            {
+                machine[Models.Metadata.Machine.BiosSetKey] = item.BiosSet
+                    .Where(b => b != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Rom != null && item.Rom.Any())
+            {
+                machine[Models.Metadata.Machine.RomKey] = item.Rom
+                    .Where(r => r != null)
+                .Select(ConvertToInternalModel)
+                .ToArray();
+            }
+
+            if (item.Disk != null && item.Disk.Any())
+            {
+                machine[Models.Metadata.Machine.DiskKey] = item.Disk
+                    .Where(d => d != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Media != null && item.Media.Any())
+            {
+                machine[Models.Metadata.Machine.MediaKey] = item.Media
+                    .Where(m => m != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Sample != null && item.Sample.Any())
+            {
+                machine[Models.Metadata.Machine.SampleKey] = item.Sample
+                    .Where(s => s != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Archive != null && item.Archive.Any())
+            {
+                machine[Models.Metadata.Machine.ArchiveKey] = item.Archive
+                    .Where(a => a != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Chip != null && item.Chip.Any())
+            {
+                machine[Models.Metadata.Machine.ChipKey] = item.Chip
+                    .Where(c => c != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Video != null)
+            {
+                machine[Models.Metadata.Machine.VideoKey] = item.Video
+                    .Where(v => v != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Sound != null)
+                machine[Models.Metadata.Machine.SoundKey] = ConvertToInternalModel(item.Sound);
+
+            if (item.Input != null)
+                machine[Models.Metadata.Machine.InputKey] = ConvertToInternalModel(item.Input);
+
+            if (item.DipSwitch != null && item.DipSwitch.Any())
+            {
+                machine[Models.Metadata.Machine.DipSwitchKey] = item.DipSwitch
+                    .Where(d => d != null)
+                    .Select(ConvertToInternalModel)
+                    .ToArray();
+            }
+
+            if (item.Driver != null)
+                machine[Models.Metadata.Machine.DriverKey] = ConvertToInternalModel(item.Driver);
+
+            return machine;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Archive"/> to <cref="Models.Metadata.Archive"/>
+        /// </summary>
+        private static Models.Metadata.Archive ConvertToInternalModel(Archive item)
+        {
+            var archive = new Models.Metadata.Archive
+            {
+                [Models.Metadata.Archive.NameKey] = item.Name,
+            };
+            return archive;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.BiosSet"/> to <cref="Models.Metadata.BiosSet"/>
+        /// </summary>
+        private static Models.Metadata.BiosSet ConvertToInternalModel(BiosSet item)
+        {
+            var biosset = new Models.Metadata.BiosSet
+            {
+                [Models.Metadata.BiosSet.NameKey] = item.Name,
+                [Models.Metadata.BiosSet.DescriptionKey] = item.Description,
+                [Models.Metadata.BiosSet.DefaultKey] = item.Default,
+            };
+            return biosset;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Chip"/> to <cref="Models.Metadata.Chip"/>
+        /// </summary>
+        private static Models.Metadata.Chip ConvertToInternalModel(Chip item)
+        {
+            var chip = new Models.Metadata.Chip
+            {
+                [Models.Metadata.Chip.ChipTypeKey] = item.Type,
+                [Models.Metadata.Chip.NameKey] = item.Name,
+                [Models.Metadata.Chip.FlagsKey] = item.Flags,
+                [Models.Metadata.Chip.ClockKey] = item.Clock,
+            };
+            return chip;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.DipSwitch"/> to <cref="Models.Metadata.DipSwitch"/>
+        /// </summary>
+        private static Models.Metadata.DipSwitch ConvertToInternalModel(DipSwitch item)
+        {
+            var dipswitch = new Models.Metadata.DipSwitch
+            {
+                [Models.Metadata.DipSwitch.NameKey] = item.Name,
+                [Models.Metadata.DipSwitch.EntryKey] = item.Entry,
+                [Models.Metadata.DipSwitch.DefaultKey] = item.Default,
+            };
+            return dipswitch;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Disk"/> to <cref="Models.Metadata.Disk"/>
+        /// </summary>
+        private static Models.Metadata.Disk ConvertToInternalModel(Disk item)
+        {
+            var disk = new Models.Metadata.Disk
+            {
+                [Models.Metadata.Disk.NameKey] = item.Name,
+                [Models.Metadata.Disk.MD5Key] = item.MD5,
+                [Models.Metadata.Disk.SHA1Key] = item.SHA1,
+                [Models.Metadata.Disk.MergeKey] = item.Merge,
+                [Models.Metadata.Disk.StatusKey] = item.Status,
+                [Models.Metadata.Disk.FlagsKey] = item.Flags,
+            };
+            return disk;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Driver"/> to <cref="Models.Metadata.Driver"/>
+        /// </summary>
+        private static Models.Metadata.Driver ConvertToInternalModel(Driver item)
+        {
+            var driver = new Models.Metadata.Driver
+            {
+                [Models.Metadata.Driver.StatusKey] = item.Status,
+                [Models.Metadata.Driver.ColorKey] = item.Color,
+                [Models.Metadata.Driver.SoundKey] = item.Sound,
+                [Models.Metadata.Driver.PaletteSizeKey] = item.PaletteSize,
+                [Models.Metadata.Driver.BlitKey] = item.Blit,
+            };
+            return driver;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Input"/> to <cref="Models.Metadata.Input"/>
+        /// </summary>
+        private static Models.Metadata.Input ConvertToInternalModel(Input item)
+        {
+            var input = new Models.Metadata.Input
+            {
+                [Models.Metadata.Input.PlayersKey] = item.Players,
+                [Models.Metadata.Input.ControlKey] = item.Control,
+                [Models.Metadata.Input.ButtonsKey] = item.Buttons,
+                [Models.Metadata.Input.CoinsKey] = item.Coins,
+                [Models.Metadata.Input.TiltKey] = item.Tilt,
+                [Models.Metadata.Input.ServiceKey] = item.Service,
+            };
+            return input;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Media"/> to <cref="Models.Metadata.Media"/>
+        /// </summary>
+        private static Models.Metadata.Media ConvertToInternalModel(Media item)
+        {
+            var media = new Models.Metadata.Media
+            {
+                [Models.Metadata.Media.NameKey] = item.Name,
+                [Models.Metadata.Media.MD5Key] = item.MD5,
+                [Models.Metadata.Media.SHA1Key] = item.SHA1,
+                [Models.Metadata.Media.SHA256Key] = item.SHA256,
+                [Models.Metadata.Media.SpamSumKey] = item.SpamSum,
+            };
+            return media;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Release"/> to <cref="Models.Metadata.Release"/>
+        /// </summary>
+        private static Models.Metadata.Release ConvertToInternalModel(Release item)
+        {
+            var release = new Models.Metadata.Release
+            {
+                [Models.Metadata.Release.NameKey] = item.Name,
+                [Models.Metadata.Release.RegionKey] = item.Region,
+                [Models.Metadata.Release.LanguageKey] = item.Language,
+                [Models.Metadata.Release.DateKey] = item.Date,
+                [Models.Metadata.Release.DefaultKey] = item.Default,
+            };
+            return release;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Rom"/> to <cref="Models.Metadata.Rom"/>
+        /// </summary>
+        private static Models.Metadata.Rom ConvertToInternalModel(Rom item)
+        {
+            var rom = new Models.Metadata.Rom
+            {
+                [Models.Metadata.Rom.NameKey] = item.Name,
+                [Models.Metadata.Rom.SizeKey] = item.Size,
+                [Models.Metadata.Rom.CRCKey] = item.CRC,
+                [Models.Metadata.Rom.MD5Key] = item.MD5,
+                [Models.Metadata.Rom.SHA1Key] = item.SHA1,
+                [Models.Metadata.Rom.SHA256Key] = item.SHA256,
+                [Models.Metadata.Rom.SHA384Key] = item.SHA384,
+                [Models.Metadata.Rom.SHA512Key] = item.SHA512,
+                [Models.Metadata.Rom.SpamSumKey] = item.SpamSum,
+                [Models.Metadata.Rom.xxHash364Key] = item.xxHash364,
+                [Models.Metadata.Rom.xxHash3128Key] = item.xxHash3128,
+                [Models.Metadata.Rom.MergeKey] = item.Merge,
+                [Models.Metadata.Rom.StatusKey] = item.Status,
+                [Models.Metadata.Rom.RegionKey] = item.Region,
+                [Models.Metadata.Rom.FlagsKey] = item.Flags,
+                [Models.Metadata.Rom.OffsetKey] = item.Offs,
+                [Models.Metadata.Rom.SerialKey] = item.Serial,
+                [Models.Metadata.Rom.HeaderKey] = item.Header,
+                [Models.Metadata.Rom.DateKey] = item.Date,
+                [Models.Metadata.Rom.InvertedKey] = item.Inverted,
+                [Models.Metadata.Rom.MIAKey] = item.MIA,
+            };
+            return rom;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Sample"/> to <cref="Models.Metadata.Sample"/>
+        /// </summary>
+        private static Models.Metadata.Sample ConvertToInternalModel(Sample item)
+        {
+            var sample = new Models.Metadata.Sample
+            {
+                [Models.Metadata.Sample.NameKey] = item.Name,
+            };
+            return sample;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Sound"/> to <cref="Models.Metadata.Sound"/>
+        /// </summary>
+        private static Models.Metadata.Sound ConvertToInternalModel(Sound item)
+        {
+            var sound = new Models.Metadata.Sound
+            {
+                [Models.Metadata.Sound.ChannelsKey] = item.Channels,
+            };
+            return sound;
+        }
+
+        /// <summary>
+        /// Convert from <cref="Models.ClrMamePro.Video"/> to <cref="Models.Metadata.Video"/>
+        /// </summary>
+        private static Models.Metadata.Video ConvertToInternalModel(Video item)
+        {
+            var video = new Models.Metadata.Video
+            {
+                [Models.Metadata.Video.ScreenKey] = item.Screen,
+                [Models.Metadata.Video.OrientationKey] = item.Orientation,
+                [Models.Metadata.Video.WidthKey] = item.X,
+                [Models.Metadata.Video.HeightKey] = item.Y,
+                [Models.Metadata.Video.AspectXKey] = item.AspectX,
+                [Models.Metadata.Video.AspectYKey] = item.AspectY,
+                [Models.Metadata.Video.RefreshKey] = item.Freq,
+            };
+            return video;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Files/AttractMode.Serializer.cs b/Files/AttractMode.Serializer.cs
index d47a6529..0b973607 100644
--- a/Files/AttractMode.Serializer.cs
+++ b/Files/AttractMode.Serializer.cs
@@ -10,7 +10,6 @@ namespace SabreTools.Serialization.Files
         public bool Serialize(MetadataFile obj, string path)
 #else
         public bool Serialize(MetadataFile? obj, string? path)
-
 #endif
         {
             using (var stream = new Streams.AttractMode().Serialize(obj))
diff --git a/Files/ClrMamePro.Deserializer.cs b/Files/ClrMamePro.Deserializer.cs
new file mode 100644
index 00000000..c6ec4723
--- /dev/null
+++ b/Files/ClrMamePro.Deserializer.cs
@@ -0,0 +1,20 @@
+using SabreTools.Models.ClrMamePro;
+
+namespace SabreTools.Serialization.Files
+{
+    public partial class ClrMamePro : IFileSerializer<MetadataFile>
+    {
+        /// <inheritdoc/>
+#if NET48
+        public MetadataFile Deserialize(string path)
+#else
+        public MetadataFile? Deserialize(string? path)
+#endif
+        {
+            using (var stream = PathProcessor.OpenStream(path))
+            {
+                return new Streams.ClrMamePro().Deserialize(stream);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Files/ClrMamePro.Serializer.cs b/Files/ClrMamePro.Serializer.cs
new file mode 100644
index 00000000..d67de58c
--- /dev/null
+++ b/Files/ClrMamePro.Serializer.cs
@@ -0,0 +1,35 @@
+using System.IO;
+using SabreTools.Models.ClrMamePro;
+
+namespace SabreTools.Serialization.Files
+{
+    public partial class ClrMamePro : IFileSerializer<MetadataFile>
+    {
+        /// <inheritdoc/>
+#if NET48
+        public bool Serialize(MetadataFile obj, string path) => Serialize(obj, path, true);
+#else
+        public bool Serialize(MetadataFile? obj, string? path) => Serialize(obj, path, true);
+#endif
+
+        /// <inheritdoc cref="Serialize(MetadataFile, string)"/>
+#if NET48
+        public bool Serialize(MetadataFile obj, string path, bool quotes)
+#else
+        public bool Serialize(MetadataFile? obj, string? path, bool quotes)
+#endif
+        {
+            using (var stream = new Streams.ClrMamePro().Serialize(obj, quotes))
+            {
+                if (stream == null)
+                    return false;
+
+                using (var fs = File.OpenWrite(path))
+                {
+                    stream.CopyTo(fs);
+                    return true;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Streams/ClrMamePro.Deserializer.cs b/Streams/ClrMamePro.Deserializer.cs
new file mode 100644
index 00000000..d9249794
--- /dev/null
+++ b/Streams/ClrMamePro.Deserializer.cs
@@ -0,0 +1,989 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using SabreTools.IO.Readers;
+using SabreTools.Models.ClrMamePro;
+
+namespace SabreTools.Serialization.Streams
+{
+    public partial class ClrMamePro : IStreamSerializer<MetadataFile>
+    {
+        /// <inheritdoc/>
+#if NET48
+        public MetadataFile Deserialize(Stream data) => Deserialize(data, true);
+#else
+        public MetadataFile? Deserialize(Stream? data) => Deserialize(data, true);
+#endif
+
+        /// <inheritdoc cref="Deserialize(Stream)"/>
+#if NET48
+        public MetadataFile Deserialize(Stream data, bool quotes)
+#else
+        public MetadataFile? Deserialize(Stream? data, bool quotes)
+#endif
+        {
+            // If the stream is null
+            if (data == null)
+                return default;
+
+            // Setup the reader and output
+            var reader = new ClrMameProReader(data, Encoding.UTF8) { Quotes = quotes };
+            var dat = new MetadataFile();
+
+            // Loop through and parse out the values
+#if NET48
+            string lastTopLevel = reader.TopLevel;
+#else
+            string? lastTopLevel = reader.TopLevel;
+#endif
+
+#if NET48
+            GameBase game = null;
+#else
+            GameBase? game = null;
+#endif
+            var games = new List<GameBase>();
+            var releases = new List<Release>();
+            var biosSets = new List<BiosSet>();
+            var roms = new List<Rom>();
+            var disks = new List<Disk>();
+            var medias = new List<Media>();
+            var samples = new List<Sample>();
+            var archives = new List<Archive>();
+            var chips = new List<Chip>();
+            var videos = new List<Video>();
+            var dipSwitches = new List<DipSwitch>();
+
+            var additional = new List<string>();
+            var headerAdditional = new List<string>();
+            var gameAdditional = new List<string>();
+            while (!reader.EndOfStream)
+            {
+                // If we have no next line
+                if (!reader.ReadNextLine())
+                    break;
+
+                // Ignore certain row types
+                switch (reader.RowType)
+                {
+                    case CmpRowType.None:
+                    case CmpRowType.Comment:
+                        continue;
+                    case CmpRowType.EndTopLevel:
+                        switch (lastTopLevel)
+                        {
+                            case "doscenter":
+                                if (dat.ClrMamePro != null)
+                                    dat.ClrMamePro.ADDITIONAL_ELEMENTS = headerAdditional.ToArray();
+
+                                headerAdditional.Clear();
+                                break;
+                            case "game":
+                            case "machine":
+                            case "resource":
+                            case "set":
+                                if (game != null)
+                                {
+                                    game.Release = releases.ToArray();
+                                    game.BiosSet = biosSets.ToArray();
+                                    game.Rom = roms.ToArray();
+                                    game.Disk = disks.ToArray();
+                                    game.Media = medias.ToArray();
+                                    game.Sample = samples.ToArray();
+                                    game.Archive = archives.ToArray();
+                                    game.Chip = chips.ToArray();
+                                    game.Video = videos.ToArray();
+                                    game.DipSwitch = dipSwitches.ToArray();
+                                    game.ADDITIONAL_ELEMENTS = gameAdditional.ToArray();
+
+                                    games.Add(game);
+                                    game = null;
+                                }
+
+                                releases.Clear();
+                                biosSets.Clear();
+                                roms.Clear();
+                                disks.Clear();
+                                medias.Clear();
+                                samples.Clear();
+                                archives.Clear();
+                                chips.Clear();
+                                videos.Clear();
+                                dipSwitches.Clear();
+                                gameAdditional.Clear();
+                                break;
+                            default:
+                                // No-op
+                                break;
+                        }
+                        continue;
+                }
+
+                // If we're at the root
+                if (reader.RowType == CmpRowType.TopLevel)
+                {
+                    lastTopLevel = reader.TopLevel;
+                    switch (reader.TopLevel)
+                    {
+                        case "clrmamepro":
+                            dat.ClrMamePro = new Models.ClrMamePro.ClrMamePro();
+                            break;
+                        case "game":
+                            game = new Game();
+                            break;
+                        case "machine":
+                            game = new Machine();
+                            break;
+                        case "resource":
+                            game = new Resource();
+                            break;
+                        case "set":
+                            game = new Set();
+                            break;
+                        default:
+                            if (reader.CurrentLine != null)
+                                additional.Add(reader.CurrentLine);
+                            break;
+                    }
+                }
+
+                // If we're in the doscenter block
+                else if (reader.TopLevel == "clrmamepro"
+                    && reader.RowType == CmpRowType.Standalone)
+                {
+                    // Create the block if we haven't already
+#if NET48
+                    dat.ClrMamePro = dat.ClrMamePro != null ? dat.ClrMamePro : new Models.ClrMamePro.ClrMamePro();
+#else
+                    dat.ClrMamePro ??= new Models.ClrMamePro.ClrMamePro();
+#endif
+
+                    switch (reader.Standalone?.Key?.ToLowerInvariant())
+                    {
+                        case "name":
+                            dat.ClrMamePro.Name = reader.Standalone?.Value;
+                            break;
+                        case "description":
+                            dat.ClrMamePro.Description = reader.Standalone?.Value;
+                            break;
+                        case "rootdir":
+                            dat.ClrMamePro.RootDir = reader.Standalone?.Value;
+                            break;
+                        case "category":
+                            dat.ClrMamePro.Category = reader.Standalone?.Value;
+                            break;
+                        case "version":
+                            dat.ClrMamePro.Version = reader.Standalone?.Value;
+                            break;
+                        case "date":
+                            dat.ClrMamePro.Date = reader.Standalone?.Value;
+                            break;
+                        case "author":
+                            dat.ClrMamePro.Author = reader.Standalone?.Value;
+                            break;
+                        case "homepage":
+                            dat.ClrMamePro.Homepage = reader.Standalone?.Value;
+                            break;
+                        case "url":
+                            dat.ClrMamePro.Url = reader.Standalone?.Value;
+                            break;
+                        case "comment":
+                            dat.ClrMamePro.Comment = reader.Standalone?.Value;
+                            break;
+                        case "header":
+                            dat.ClrMamePro.Header = reader.Standalone?.Value;
+                            break;
+                        case "type":
+                            dat.ClrMamePro.Type = reader.Standalone?.Value;
+                            break;
+                        case "forcemerging":
+                            dat.ClrMamePro.ForceMerging = reader.Standalone?.Value;
+                            break;
+                        case "forcezipping":
+                            dat.ClrMamePro.ForceZipping = reader.Standalone?.Value;
+                            break;
+                        case "forcepacking":
+                            dat.ClrMamePro.ForcePacking = reader.Standalone?.Value;
+                            break;
+                        default:
+                            if (reader.CurrentLine != null)
+                                headerAdditional.Add(reader.CurrentLine);
+                            break;
+                    }
+                }
+
+                // If we're in a game, machine, resource, or set block
+                else if ((reader.TopLevel == "game"
+                        || reader.TopLevel == "machine"
+                        || reader.TopLevel == "resource"
+                        || reader.TopLevel == "set")
+                    && reader.RowType == CmpRowType.Standalone)
+                {
+                    // Create the block if we haven't already
+#if NET48
+                    if (game == null)
+                    {
+                        switch (reader.TopLevel)
+                        {
+                            case "game":
+                                game = new Game();
+                                break;
+                            case "machine":
+                                game = new Machine();
+                                break;
+                            case "resource":
+                                game = new Resource();
+                                break;
+                            case "set":
+                                game = new Set();
+                                break;
+                            default:
+                                throw new FormatException($"Unknown top-level block: {reader.TopLevel}");
+                        }
+                    }
+#else
+                    game ??= reader.TopLevel switch
+                    {
+                        "game" => new Game(),
+                        "machine" => new Machine(),
+                        "resource" => new Resource(),
+                        "set" => new Set(),
+                        _ => throw new FormatException($"Unknown top-level block: {reader.TopLevel}"),
+                    };
+#endif
+
+                    switch (reader.Standalone?.Key?.ToLowerInvariant())
+                    {
+                        case "name":
+                            game.Name = reader.Standalone?.Value;
+                            break;
+                        case "description":
+                            game.Description = reader.Standalone?.Value;
+                            break;
+                        case "year":
+                            game.Year = reader.Standalone?.Value;
+                            break;
+                        case "manufacturer":
+                            game.Manufacturer = reader.Standalone?.Value;
+                            break;
+                        case "category":
+                            game.Category = reader.Standalone?.Value;
+                            break;
+                        case "cloneof":
+                            game.CloneOf = reader.Standalone?.Value;
+                            break;
+                        case "romof":
+                            game.RomOf = reader.Standalone?.Value;
+                            break;
+                        case "sampleof":
+                            game.SampleOf = reader.Standalone?.Value;
+                            break;
+                        case "sample":
+                            var sample = new Sample
+                            {
+                                Name = reader.Standalone?.Value ?? string.Empty,
+                                ADDITIONAL_ELEMENTS = Array.Empty<string>()
+                            };
+                            samples.Add(sample);
+                            break;
+                        default:
+                            if (reader.CurrentLine != null)
+                                gameAdditional.Add(reader.CurrentLine);
+                            break;
+                    }
+                }
+
+                // If we're in an item block
+                else if ((reader.TopLevel == "game"
+                        || reader.TopLevel == "machine"
+                        || reader.TopLevel == "resource"
+                        || reader.TopLevel == "set")
+                    && game != null
+                    && reader.RowType == CmpRowType.Internal)
+                {
+                    // Create the block
+                    switch (reader.InternalName)
+                    {
+                        case "release":
+                            var release = CreateRelease(reader);
+                            if (release != null)
+                                releases.Add(release);
+                            break;
+                        case "biosset":
+                            var biosSet = CreateBiosSet(reader);
+                            if (biosSet != null)
+                                biosSets.Add(biosSet);
+                            break;
+                        case "rom":
+                            var rom = CreateRom(reader);
+                            if (rom != null)
+                                roms.Add(rom);
+                            break;
+                        case "disk":
+                            var disk = CreateDisk(reader);
+                            if (disk != null)
+                                disks.Add(disk);
+                            break;
+                        case "media":
+                            var media = CreateMedia(reader);
+                            if (media != null)
+                                medias.Add(media);
+                            break;
+                        case "sample":
+                            var sample = CreateSample(reader);
+                            if (sample != null)
+                                samples.Add(sample);
+                            break;
+                        case "archive":
+                            var archive = CreateArchive(reader);
+                            if (archive != null)
+                                archives.Add(archive);
+                            break;
+                        case "chip":
+                            var chip = CreateChip(reader);
+                            if (chip != null)
+                                chips.Add(chip);
+                            break;
+                        case "video":
+                            var video = CreateVideo(reader);
+                            if (video != null)
+                                videos.Add(video);
+                            break;
+                        case "sound":
+                            var sound = CreateSound(reader);
+                            if (sound != null)
+                                game.Sound = sound;
+                            break;
+                        case "input":
+                            var input = CreateInput(reader);
+                            if (input != null)
+                                game.Input = input;
+                            break;
+                        case "dipswitch":
+                            var dipSwitch = CreateDipSwitch(reader);
+                            if (dipSwitch != null)
+                                dipSwitches.Add(dipSwitch);
+                            break;
+                        case "driver":
+                            var driver = CreateDriver(reader);
+                            if (driver != null)
+                                game.Driver = driver;
+                            break;
+                        default:
+                            if (reader.CurrentLine != null)
+                                gameAdditional.Add(reader.CurrentLine);
+                            continue;
+                    }
+                }
+
+                else
+                {
+                    if (reader.CurrentLine != null)
+                        additional.Add(reader.CurrentLine);
+                }
+            }
+
+            // Add extra pieces and return
+            dat.Game = games.ToArray();
+            dat.ADDITIONAL_ELEMENTS = additional.ToArray();
+            return dat;
+        }
+
+        /// <summary>
+        /// Create a Release object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Release object created from the reader context</returns>
+#if NET48
+        private static Release CreateRelease(ClrMameProReader reader)
+#else
+        private static Release? CreateRelease(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var release = new Release();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        release.Name = kvp.Value;
+                        break;
+                    case "region":
+                        release.Region = kvp.Value;
+                        break;
+                    case "language":
+                        release.Language = kvp.Value;
+                        break;
+                    case "date":
+                        release.Date = kvp.Value;
+                        break;
+                    case "default":
+                        release.Default = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            release.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return release;
+        }
+
+        /// <summary>
+        /// Create a BiosSet object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>BiosSet object created from the reader context</returns>
+#if NET48
+        private static BiosSet CreateBiosSet(ClrMameProReader reader)
+#else
+        private static BiosSet? CreateBiosSet(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var biosset = new BiosSet();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        biosset.Name = kvp.Value;
+                        break;
+                    case "description":
+                        biosset.Description = kvp.Value;
+                        break;
+                    case "default":
+                        biosset.Default = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            biosset.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return biosset;
+        }
+
+        /// <summary>
+        /// Create a Rom object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Rom object created from the reader context</returns>
+#if NET48
+        private static Rom CreateRom(ClrMameProReader reader)
+#else
+        private static Rom? CreateRom(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var rom = new Rom();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        rom.Name = kvp.Value;
+                        break;
+                    case "size":
+                        rom.Size = kvp.Value;
+                        break;
+                    case "crc":
+                        rom.CRC = kvp.Value;
+                        break;
+                    case "md5":
+                        rom.MD5 = kvp.Value;
+                        break;
+                    case "sha1":
+                        rom.SHA1 = kvp.Value;
+                        break;
+                    case "sha256":
+                        rom.SHA256 = kvp.Value;
+                        break;
+                    case "sha384":
+                        rom.SHA384 = kvp.Value;
+                        break;
+                    case "sha512":
+                        rom.SHA512 = kvp.Value;
+                        break;
+                    case "spamsum":
+                        rom.SpamSum = kvp.Value;
+                        break;
+                    case "xxh3_64":
+                        rom.xxHash364 = kvp.Value;
+                        break;
+                    case "xxh3_128":
+                        rom.xxHash3128 = kvp.Value;
+                        break;
+                    case "merge":
+                        rom.Merge = kvp.Value;
+                        break;
+                    case "status":
+                        rom.Status = kvp.Value;
+                        break;
+                    case "region":
+                        rom.Region = kvp.Value;
+                        break;
+                    case "flags":
+                        rom.Flags = kvp.Value;
+                        break;
+                    case "offs":
+                        rom.Offs = kvp.Value;
+                        break;
+                    case "serial":
+                        rom.Serial = kvp.Value;
+                        break;
+                    case "header":
+                        rom.Header = kvp.Value;
+                        break;
+                    case "date":
+                        rom.Date = kvp.Value;
+                        break;
+                    case "inverted":
+                        rom.Inverted = kvp.Value;
+                        break;
+                    case "mia":
+                        rom.MIA = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            rom.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return rom;
+        }
+
+        /// <summary>
+        /// Create a Disk object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Disk object created from the reader context</returns>
+#if NET48
+        private static Disk CreateDisk(ClrMameProReader reader)
+#else
+        private static Disk? CreateDisk(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var disk = new Disk();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        disk.Name = kvp.Value;
+                        break;
+                    case "md5":
+                        disk.MD5 = kvp.Value;
+                        break;
+                    case "sha1":
+                        disk.SHA1 = kvp.Value;
+                        break;
+                    case "merge":
+                        disk.Merge = kvp.Value;
+                        break;
+                    case "status":
+                        disk.Status = kvp.Value;
+                        break;
+                    case "flags":
+                        disk.Flags = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            disk.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return disk;
+        }
+
+        /// <summary>
+        /// Create a Media object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Media object created from the reader context</returns>
+#if NET48
+        private static Media CreateMedia(ClrMameProReader reader)
+#else
+        private static Media? CreateMedia(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var media = new Media();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        media.Name = kvp.Value;
+                        break;
+                    case "md5":
+                        media.MD5 = kvp.Value;
+                        break;
+                    case "sha1":
+                        media.SHA1 = kvp.Value;
+                        break;
+                    case "sha256":
+                        media.SHA256 = kvp.Value;
+                        break;
+                    case "spamsum":
+                        media.SpamSum = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            media.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return media;
+        }
+
+        /// <summary>
+        /// Create a Sample object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Sample object created from the reader context</returns>
+#if NET48
+        private static Sample CreateSample(ClrMameProReader reader)
+#else
+        private static Sample? CreateSample(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var sample = new Sample();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        sample.Name = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            sample.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return sample;
+        }
+
+        /// <summary>
+        /// Create a Archive object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Archive object created from the reader context</returns>
+#if NET48
+        private static Archive CreateArchive(ClrMameProReader reader)
+#else
+        private static Archive? CreateArchive(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var archive = new Archive();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        archive.Name = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            archive.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return archive;
+        }
+
+        /// <summary>
+        /// Create a Chip object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Chip object created from the reader context</returns>
+#if NET48
+        private static Chip CreateChip(ClrMameProReader reader)
+#else
+        private static Chip? CreateChip(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var chip = new Chip();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "type":
+                        chip.Type = kvp.Value;
+                        break;
+                    case "name":
+                        chip.Name = kvp.Value;
+                        break;
+                    case "flags":
+                        chip.Flags = kvp.Value;
+                        break;
+                    case "clock":
+                        chip.Clock = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            chip.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return chip;
+        }
+
+        /// <summary>
+        /// Create a Video object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Video object created from the reader context</returns>
+#if NET48
+        private static Video CreateVideo(ClrMameProReader reader)
+#else
+        private static Video? CreateVideo(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var video = new Video();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "screen":
+                        video.Screen = kvp.Value;
+                        break;
+                    case "orientation":
+                        video.Orientation = kvp.Value;
+                        break;
+                    case "x":
+                        video.X = kvp.Value;
+                        break;
+                    case "y":
+                        video.Y = kvp.Value;
+                        break;
+                    case "aspectx":
+                        video.AspectX = kvp.Value;
+                        break;
+                    case "aspecty":
+                        video.AspectY = kvp.Value;
+                        break;
+                    case "freq":
+                        video.Freq = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            video.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return video;
+        }
+
+        /// <summary>
+        /// Create a Sound object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Sound object created from the reader context</returns>
+#if NET48
+        private static Sound CreateSound(ClrMameProReader reader)
+#else
+        private static Sound? CreateSound(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var sound = new Sound();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "channels":
+                        sound.Channels = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            sound.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return sound;
+        }
+
+        /// <summary>
+        /// Create a Input object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Input object created from the reader context</returns>
+#if NET48
+        private static Input CreateInput(ClrMameProReader reader)
+#else
+        private static Input? CreateInput(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var input = new Input();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "players":
+                        input.Players = kvp.Value;
+                        break;
+                    case "control":
+                        input.Control = kvp.Value;
+                        break;
+                    case "buttons":
+                        input.Buttons = kvp.Value;
+                        break;
+                    case "coins":
+                        input.Coins = kvp.Value;
+                        break;
+                    case "tilt":
+                        input.Tilt = kvp.Value;
+                        break;
+                    case "service":
+                        input.Service = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            input.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return input;
+        }
+
+        /// <summary>
+        /// Create a DipSwitch object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>DipSwitch object created from the reader context</returns>
+#if NET48
+        private static DipSwitch CreateDipSwitch(ClrMameProReader reader)
+#else
+        private static DipSwitch? CreateDipSwitch(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var dipswitch = new DipSwitch();
+            var entries = new List<string>();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "name":
+                        dipswitch.Name = kvp.Value;
+                        break;
+                    case "entry":
+                        entries.Add(kvp.Value);
+                        break;
+                    case "default":
+                        dipswitch.Default = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            dipswitch.Entry = entries.ToArray();
+            dipswitch.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return dipswitch;
+        }
+
+        /// <summary>
+        /// Create a Driver object from the current reader context
+        /// </summary>
+        /// <param name="reader">ClrMameProReader representing the metadata file</param>
+        /// <returns>Driver object created from the reader context</returns>
+#if NET48
+        private static Driver CreateDriver(ClrMameProReader reader)
+#else
+        private static Driver? CreateDriver(ClrMameProReader reader)
+#endif
+        {
+            if (reader.Internal == null)
+                return null;
+
+            var itemAdditional = new List<string>();
+            var driver = new Driver();
+            foreach (var kvp in reader.Internal)
+            {
+                switch (kvp.Key?.ToLowerInvariant())
+                {
+                    case "status":
+                        driver.Status = kvp.Value;
+                        break;
+                    case "color":
+                        driver.Color = kvp.Value;
+                        break;
+                    case "sound":
+                        driver.Sound = kvp.Value;
+                        break;
+                    case "palettesize":
+                        driver.PaletteSize = kvp.Value;
+                        break;
+                    case "blit":
+                        driver.Blit = kvp.Value;
+                        break;
+                    default:
+                        itemAdditional.Add($"{kvp.Key}: {kvp.Value}");
+                        break;
+                }
+            }
+
+            driver.ADDITIONAL_ELEMENTS = itemAdditional.ToArray();
+            return driver;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Streams/ClrMamePro.Serializer.cs b/Streams/ClrMamePro.Serializer.cs
new file mode 100644
index 00000000..4645fcbd
--- /dev/null
+++ b/Streams/ClrMamePro.Serializer.cs
@@ -0,0 +1,519 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using SabreTools.IO.Writers;
+using SabreTools.Models.ClrMamePro;
+
+namespace SabreTools.Serialization.Streams
+{
+    public partial class ClrMamePro : IStreamSerializer<MetadataFile>
+    {
+        /// <inheritdoc/>
+#if NET48
+        public Stream Serialize(MetadataFile obj) => Serialize(obj, true);
+#else
+        public Stream? Serialize(MetadataFile? obj) => Serialize(obj, true);
+#endif
+
+        /// <inheritdoc cref="Serialize(MetadataFile)"/>
+#if NET48
+        public Stream Serialize(MetadataFile obj, bool quotes)
+#else
+        public Stream? Serialize(MetadataFile? obj, bool quotes)
+#endif
+        {
+            // If the metadata file is null
+            if (obj == null)
+                return null;
+
+            // Setup the writer and output
+            var stream = new MemoryStream();
+            var writer = new ClrMameProWriter(stream, Encoding.UTF8) { Quotes = quotes };
+
+            // Write the header, if it exists
+            WriteHeader(obj.ClrMamePro, writer);
+
+            // Write out the games, if they exist
+            WriteGames(obj.Game, writer);
+
+            // Return the stream
+            stream.Seek(0, SeekOrigin.Begin);
+            return stream;
+        }
+
+        /// <summary>
+        /// Write header information to the current writer
+        /// </summary>
+        /// <param name="header">ClrMamePro representing the header information</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteHeader(Models.ClrMamePro.ClrMamePro header, ClrMameProWriter writer)
+#else
+        private static void WriteHeader(Models.ClrMamePro.ClrMamePro? header, ClrMameProWriter writer)
+#endif
+        {
+            // If the header information is missing, we can't do anything
+            if (header == null)
+                return;
+
+            writer.WriteStartElement("clrmamepro");
+
+            writer.WriteOptionalStandalone("name", header.Name);
+            writer.WriteOptionalStandalone("description", header.Description);
+            writer.WriteOptionalStandalone("rootdir", header.RootDir);
+            writer.WriteOptionalStandalone("category", header.Category);
+            writer.WriteOptionalStandalone("version", header.Version);
+            writer.WriteOptionalStandalone("date", header.Date);
+            writer.WriteOptionalStandalone("author", header.Author);
+            writer.WriteOptionalStandalone("homepage", header.Homepage);
+            writer.WriteOptionalStandalone("url", header.Url);
+            writer.WriteOptionalStandalone("comment", header.Comment);
+            writer.WriteOptionalStandalone("header", header.Header);
+            writer.WriteOptionalStandalone("type", header.Type);
+            writer.WriteOptionalStandalone("forcemerging", header.ForceMerging);
+            writer.WriteOptionalStandalone("forcezipping", header.ForceZipping);
+            writer.WriteOptionalStandalone("forcepacking", header.ForcePacking);
+
+            writer.WriteEndElement(); // clrmamepro
+            writer.Flush();
+        }
+
+        /// <summary>
+        /// Write games information to the current writer
+        /// </summary>
+        /// <param name="games">Array of GameBase objects representing the games information</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteGames(GameBase[] games, ClrMameProWriter writer)
+#else
+        private static void WriteGames(GameBase[]? games, ClrMameProWriter writer)
+#endif
+        {
+            // If the games information is missing, we can't do anything
+            if (games == null || !games.Any())
+                return;
+
+            // Loop through and write out the games
+            foreach (var game in games)
+            {
+                WriteGame(game, writer);
+                writer.Flush();
+            }
+        }
+
+        /// <summary>
+        /// Write game information to the current writer
+        /// </summary>
+        /// <param name="game">GameBase object representing the game information</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+        private static void WriteGame(GameBase game, ClrMameProWriter writer)
+        {
+            // If the game information is missing, we can't do anything
+            if (game == null)
+                return;
+
+#if NET48
+            if (game is Game)
+                writer.WriteStartElement("game");
+            else if (game is Machine)
+                writer.WriteStartElement("machine");
+            else if (game is Resource)
+                writer.WriteStartElement("resource");
+            else if (game is Set)
+                writer.WriteStartElement(name: "set");
+#else
+            switch (game)
+            {
+                case Game:
+                    writer.WriteStartElement("game");
+                    break;
+                case Machine:
+                    writer.WriteStartElement("machine");
+                    break;
+                case Resource:
+                    writer.WriteStartElement("resource");
+                    break;
+                case Set:
+                    writer.WriteStartElement(name: "set");
+                    break;
+            }
+#endif
+
+            // Write the standalone values
+            writer.WriteRequiredStandalone("name", game.Name, throwOnError: true);
+            writer.WriteOptionalStandalone("description", game.Description);
+            writer.WriteOptionalStandalone("year", game.Year);
+            writer.WriteOptionalStandalone("manufacturer", game.Manufacturer);
+            writer.WriteOptionalStandalone("category", game.Category);
+            writer.WriteOptionalStandalone("cloneof", game.CloneOf);
+            writer.WriteOptionalStandalone("romof", game.RomOf);
+            writer.WriteOptionalStandalone("sampleof", game.SampleOf);
+
+            // Write the item values
+            WriteReleases(game.Release, writer);
+            WriteBiosSets(game.BiosSet, writer);
+            WriteRoms(game.Rom, writer);
+            WriteDisks(game.Disk, writer);
+            WriteMedia(game.Media, writer);
+            WriteSamples(game.Sample, writer);
+            WriteArchives(game.Archive, writer);
+            WriteChips(game.Chip, writer);
+            WriteVideos(game.Video, writer);
+            WriteSound(game.Sound, writer);
+            WriteInput(game.Input, writer);
+            WriteDipSwitches(game.DipSwitch, writer);
+            WriteDriver(game.Driver, writer);
+
+            writer.WriteEndElement(); // game, machine, resource, set
+        }
+
+        /// <summary>
+        /// Write releases information to the current writer
+        /// </summary>
+        /// <param name="releases">Array of Release objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteReleases(Release[] releases, ClrMameProWriter writer)
+#else
+        private static void WriteReleases(Release[]? releases, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (releases == null)
+                return;
+
+            foreach (var release in releases)
+            {
+                writer.WriteStartElement("release");
+                writer.WriteRequiredAttributeString("name", release.Name, throwOnError: true);
+                writer.WriteRequiredAttributeString("region", release.Region, throwOnError: true);
+                writer.WriteOptionalAttributeString("language", release.Language);
+                writer.WriteOptionalAttributeString("date", release.Date);
+                writer.WriteOptionalAttributeString("default", release.Default);
+                writer.WriteEndElement(); // release
+            }
+        }
+
+        /// <summary>
+        /// Write biossets information to the current writer
+        /// </summary>
+        /// <param name="biossets">Array of BiosSet objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteBiosSets(BiosSet[] biossets, ClrMameProWriter writer)
+#else
+        private static void WriteBiosSets(BiosSet[]? biossets, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (biossets == null)
+                return;
+
+            foreach (var biosset in biossets)
+            {
+                writer.WriteStartElement("biosset");
+                writer.WriteRequiredAttributeString("name", biosset.Name, throwOnError: true);
+                writer.WriteRequiredAttributeString("description", biosset.Description, throwOnError: true);
+                writer.WriteOptionalAttributeString("default", biosset.Default);
+                writer.WriteEndElement(); // release
+            }
+        }
+
+        /// <summary>
+        /// Write roms information to the current writer
+        /// </summary>
+        /// <param name="roms">Array of Rom objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteRoms(Rom[] roms, ClrMameProWriter writer)
+#else
+        private static void WriteRoms(Rom[]? roms, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (roms == null)
+                return;
+
+            foreach (var rom in roms)
+            {
+                writer.WriteStartElement("rom");
+                writer.WriteRequiredAttributeString("name", rom.Name, throwOnError: true);
+                writer.WriteRequiredAttributeString("size", rom.Size, throwOnError: true);
+                writer.WriteOptionalAttributeString("crc", rom.CRC);
+                writer.WriteOptionalAttributeString("md5", rom.MD5);
+                writer.WriteOptionalAttributeString("sha1", rom.SHA1);
+                writer.WriteOptionalAttributeString("sha256", rom.SHA256);
+                writer.WriteOptionalAttributeString("sha384", rom.SHA384);
+                writer.WriteOptionalAttributeString("sha512", rom.SHA512);
+                writer.WriteOptionalAttributeString("spamsum", rom.SpamSum);
+                writer.WriteOptionalAttributeString("xxh3_64", rom.xxHash364);
+                writer.WriteOptionalAttributeString("xxh3_128", rom.xxHash3128);
+                writer.WriteOptionalAttributeString("merge", rom.Merge);
+                writer.WriteOptionalAttributeString("status", rom.Status);
+                writer.WriteOptionalAttributeString("region", rom.Region);
+                writer.WriteOptionalAttributeString("flags", rom.Flags);
+                writer.WriteOptionalAttributeString("offs", rom.Offs);
+                writer.WriteOptionalAttributeString("serial", rom.Serial);
+                writer.WriteOptionalAttributeString("header", rom.Header);
+                writer.WriteOptionalAttributeString("date", rom.Date);
+                writer.WriteOptionalAttributeString("inverted", rom.Inverted);
+                writer.WriteOptionalAttributeString("mia", rom.MIA);
+                writer.WriteEndElement(); // rom
+            }
+        }
+
+        /// <summary>
+        /// Write disks information to the current writer
+        /// </summary>
+        /// <param name="disks">Array of Disk objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteDisks(Disk[] disks, ClrMameProWriter writer)
+#else
+        private static void WriteDisks(Disk[]? disks, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (disks == null)
+                return;
+
+            foreach (var disk in disks)
+            {
+                writer.WriteStartElement("disk");
+                writer.WriteRequiredAttributeString("name", disk.Name, throwOnError: true);
+                writer.WriteOptionalAttributeString("md5", disk.MD5);
+                writer.WriteOptionalAttributeString("sha1", disk.SHA1);
+                writer.WriteOptionalAttributeString("merge", disk.Merge);
+                writer.WriteOptionalAttributeString("status", disk.Status);
+                writer.WriteOptionalAttributeString("flags", disk.Flags);
+                writer.WriteEndElement(); // disk
+            }
+        }
+
+        /// <summary>
+        /// Write medias information to the current writer
+        /// </summary>
+        /// <param name="medias">Array of Media objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteMedia(Media[] medias, ClrMameProWriter writer)
+#else
+        private static void WriteMedia(Media[]? medias, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (medias == null)
+                return;
+
+            foreach (var media in medias)
+            {
+                writer.WriteStartElement("media");
+                writer.WriteRequiredAttributeString("name", media.Name, throwOnError: true);
+                writer.WriteOptionalAttributeString("md5", media.MD5);
+                writer.WriteOptionalAttributeString("sha1", media.SHA1);
+                writer.WriteOptionalAttributeString("sha256", media.SHA256);
+                writer.WriteOptionalAttributeString("spamsum", media.SpamSum);
+                writer.WriteEndElement(); // media
+            }
+        }
+
+        /// <summary>
+        /// Write samples information to the current writer
+        /// </summary>
+        /// <param name="samples">Array of Sample objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteSamples(Sample[] samples, ClrMameProWriter writer)
+#else
+        private static void WriteSamples(Sample[]? samples, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (samples == null)
+                return;
+
+            foreach (var sample in samples)
+            {
+                writer.WriteStartElement("sample");
+                writer.WriteRequiredAttributeString("name", sample.Name, throwOnError: true);
+                writer.WriteEndElement(); // sample
+            }
+        }
+
+        /// <summary>
+        /// Write archives information to the current writer
+        /// </summary>
+        /// <param name="archives">Array of Archive objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteArchives(Archive[] archives, ClrMameProWriter writer)
+#else
+        private static void WriteArchives(Archive[]? archives, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (archives == null)
+                return;
+
+            foreach (var archive in archives)
+            {
+                writer.WriteStartElement("archive");
+                writer.WriteRequiredAttributeString("name", archive.Name, throwOnError: true);
+                writer.WriteEndElement(); // archive
+            }
+        }
+
+        /// <summary>
+        /// Write chips information to the current writer
+        /// </summary>
+        /// <param name="chips">Array of Chip objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteChips(Chip[] chips, ClrMameProWriter writer)
+#else
+        private static void WriteChips(Chip[]? chips, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (chips == null)
+                return;
+
+            foreach (var chip in chips)
+            {
+                writer.WriteStartElement("chip");
+                writer.WriteRequiredAttributeString("type", chip.Type, throwOnError: true);
+                writer.WriteRequiredAttributeString("name", chip.Name, throwOnError: true);
+                writer.WriteOptionalAttributeString("flags", chip.Flags);
+                writer.WriteOptionalAttributeString("clock", chip.Clock);
+                writer.WriteEndElement(); // chip
+            }
+        }
+
+        /// <summary>
+        /// Write video information to the current writer
+        /// </summary>
+        /// <param name="videos">Array of Video objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteVideos(Video[] videos, ClrMameProWriter writer)
+#else
+        private static void WriteVideos(Video[]? videos, ClrMameProWriter writer)
+#endif
+        {
+            // If the item is missing, we can't do anything
+            if (videos == null)
+                return;
+
+            foreach (var video in videos)
+            {
+                writer.WriteStartElement("video");
+                writer.WriteRequiredAttributeString("screen", video.Screen, throwOnError: true);
+                writer.WriteRequiredAttributeString("orientation", video.Orientation, throwOnError: true);
+                writer.WriteOptionalAttributeString("x", video.X);
+                writer.WriteOptionalAttributeString("y", video.Y);
+                writer.WriteOptionalAttributeString("aspectx", video.AspectX);
+                writer.WriteOptionalAttributeString("aspecty", video.AspectY);
+                writer.WriteOptionalAttributeString("freq", video.Freq);
+                writer.WriteEndElement(); // video
+            }
+        }
+
+        /// <summary>
+        /// Write sound information to the current writer
+        /// </summary>
+        /// <param name="sound">Sound object to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteSound(Sound sound, ClrMameProWriter writer)
+#else
+        private static void WriteSound(Sound? sound, ClrMameProWriter writer)
+#endif
+        {
+            // If the item is missing, we can't do anything
+            if (sound == null)
+                return;
+
+            writer.WriteStartElement("sound");
+            writer.WriteRequiredAttributeString("channels", sound.Channels, throwOnError: true);
+            writer.WriteEndElement(); // sound
+        }
+
+        /// <summary>
+        /// Write input information to the current writer
+        /// </summary>
+        /// <param name="input">Input object to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteInput(Input input, ClrMameProWriter writer)
+#else
+        private static void WriteInput(Input? input, ClrMameProWriter writer)
+#endif
+        {
+            // If the item is missing, we can't do anything
+            if (input == null)
+                return;
+
+            writer.WriteStartElement("input");
+            writer.WriteRequiredAttributeString("players", input.Players, throwOnError: true);
+            writer.WriteOptionalAttributeString("control", input.Control);
+            writer.WriteRequiredAttributeString("buttons", input.Buttons, throwOnError: true);
+            writer.WriteOptionalAttributeString("coins", input.Coins);
+            writer.WriteOptionalAttributeString("tilt", input.Tilt);
+            writer.WriteOptionalAttributeString("service", input.Service);
+            writer.WriteEndElement(); // input
+        }
+
+        /// <summary>
+        /// Write dipswitches information to the current writer
+        /// </summary>
+        /// <param name="dipswitches">Array of DipSwitch objects to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteDipSwitches(DipSwitch[] dipswitches, ClrMameProWriter writer)
+#else
+        private static void WriteDipSwitches(DipSwitch[]? dipswitches, ClrMameProWriter writer)
+#endif
+        {
+            // If the array is missing, we can't do anything
+            if (dipswitches == null)
+                return;
+
+            foreach (var dipswitch in dipswitches)
+            {
+                writer.WriteStartElement("dipswitch");
+                writer.WriteRequiredAttributeString("name", dipswitch.Name, throwOnError: true);
+                foreach (var entry in dipswitch.Entry ?? Array.Empty<string>())
+                {
+                    writer.WriteRequiredAttributeString("entry", entry);
+                }
+                writer.WriteOptionalAttributeString("default", dipswitch.Default);
+                writer.WriteEndElement(); // dipswitch
+            }
+        }
+
+        /// <summary>
+        /// Write driver information to the current writer
+        /// </summary>
+        /// <param name="driver">Driver object to write</param>
+        /// <param name="writer">ClrMameProWriter representing the output</param>
+#if NET48
+        private static void WriteDriver(Driver driver, ClrMameProWriter writer)
+#else
+        private static void WriteDriver(Driver? driver, ClrMameProWriter writer)
+#endif
+        {
+            // If the item is missing, we can't do anything
+            if (driver == null)
+                return;
+
+            writer.WriteStartElement("driver");
+            writer.WriteRequiredAttributeString("status", driver.Status, throwOnError: true);
+            writer.WriteOptionalAttributeString("color", driver.Color); // TODO: Probably actually required
+            writer.WriteOptionalAttributeString("sound", driver.Sound); // TODO: Probably actually required
+            writer.WriteOptionalAttributeString("palettesize", driver.PaletteSize);
+            writer.WriteOptionalAttributeString("blit", driver.Blit);
+            writer.WriteEndElement(); // driver
+        }
+    }
+}
\ No newline at end of file