diff --git a/SabreTools.Library/DatFiles/Listxml.cs b/SabreTools.Library/DatFiles/Listxml.cs
index 71dbc33e..6f68c7bf 100644
--- a/SabreTools.Library/DatFiles/Listxml.cs
+++ b/SabreTools.Library/DatFiles/Listxml.cs
@@ -360,7 +360,7 @@ namespace SabreTools.Library.DatFiles
                         datItems.Add(new Display
                         {
                             Tag = reader.GetAttribute("tag"),
-                            DisplayType = reader.GetAttribute("type"),
+                            DisplayType = reader.GetAttribute("type").AsDisplayType(),
                             Rotate = reader.GetAttribute("rotate"),
                             FlipX = reader.GetAttribute("flipx").AsYesNo(),
                             Width = reader.GetAttribute("width"),
@@ -1511,7 +1511,7 @@ namespace SabreTools.Library.DatFiles
                         var display = datItem as Display;
                         xtw.WriteStartElement("display");
                         xtw.WriteOptionalAttributeString("tag", display.Tag);
-                        xtw.WriteOptionalAttributeString("type", display.DisplayType);
+                        xtw.WriteOptionalAttributeString("type", display.DisplayType.FromDisplayType());
                         xtw.WriteOptionalAttributeString("rotate", display.Rotate);
                         xtw.WriteOptionalAttributeString("flipx", display.FlipX.FromYesNo());
                         xtw.WriteOptionalAttributeString("width", display.Width);
diff --git a/SabreTools.Library/DatFiles/SabreDat.cs b/SabreTools.Library/DatFiles/SabreDat.cs
index c705fe72..747a3bd2 100644
--- a/SabreTools.Library/DatFiles/SabreDat.cs
+++ b/SabreTools.Library/DatFiles/SabreDat.cs
@@ -1436,7 +1436,7 @@ namespace SabreTools.Library.DatFiles
                         xtw.WriteStartElement("file");
                         xtw.WriteAttributeString("type", "display");
                         xtw.WriteOptionalAttributeString("tag", display.Tag);
-                        xtw.WriteOptionalAttributeString("type", display.DisplayType);
+                        xtw.WriteOptionalAttributeString("type", display.DisplayType.FromDisplayType());
                         xtw.WriteOptionalAttributeString("rotate", display.Rotate);
                         xtw.WriteOptionalAttributeString("flipx", display.FlipX.FromYesNo());
                         xtw.WriteOptionalAttributeString("width", display.Width);
diff --git a/SabreTools.Library/DatFiles/SoftwareList.cs b/SabreTools.Library/DatFiles/SoftwareList.cs
index 184faee3..5baf228c 100644
--- a/SabreTools.Library/DatFiles/SoftwareList.cs
+++ b/SabreTools.Library/DatFiles/SoftwareList.cs
@@ -384,7 +384,7 @@ namespace SabreTools.Library.DatFiles
                             Offset = reader.GetAttribute("offset"),
                             Value = reader.GetAttribute("value"),
                             ItemStatus = reader.GetAttribute("status").AsItemStatus(),
-                            LoadFlag = reader.GetAttribute("loadflag"),
+                            LoadFlag = reader.GetAttribute("loadflag").AsLoadFlag(),
 
                             DataArea = dataArea,
                         };
@@ -787,7 +787,7 @@ namespace SabreTools.Library.DatFiles
                         xtw.WriteOptionalAttributeString("offset", rom.Offset);
                         xtw.WriteOptionalAttributeString("value", rom.Value);
                         xtw.WriteOptionalAttributeString("status", rom.ItemStatus.FromItemStatus(false));
-                        xtw.WriteOptionalAttributeString("loadflag", rom.LoadFlag);
+                        xtw.WriteOptionalAttributeString("loadflag", rom.LoadFlag.FromLoadFlag());
                         xtw.WriteEndElement();
 
                         // End dataarea
diff --git a/SabreTools.Library/DatItems/Display.cs b/SabreTools.Library/DatItems/Display.cs
index d184a3cb..e68d62e2 100644
--- a/SabreTools.Library/DatItems/Display.cs
+++ b/SabreTools.Library/DatItems/Display.cs
@@ -4,6 +4,7 @@ using System.Linq;
 using SabreTools.Library.Filtering;
 using SabreTools.Library.Tools;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 
 namespace SabreTools.Library.DatItems
 {
@@ -25,7 +26,8 @@ namespace SabreTools.Library.DatItems
         /// Display type
         /// </summary>
         [JsonProperty("type", DefaultValueHandling = DefaultValueHandling.Ignore)]
-        public string DisplayType { get; set; } // TODO: (raster|vector|lcd|svg|unknown)
+        [JsonConverter(typeof(StringEnumConverter))]
+        public DisplayType DisplayType { get; set; }
 
         /// <summary>
         /// Display rotation
@@ -117,7 +119,7 @@ namespace SabreTools.Library.DatItems
                 Tag = mappings[Field.DatItem_Tag];
 
             if (mappings.Keys.Contains(Field.DatItem_DisplayType))
-                DisplayType = mappings[Field.DatItem_DisplayType];
+                DisplayType = mappings[Field.DatItem_DisplayType].AsDisplayType();
 
             if (mappings.Keys.Contains(Field.DatItem_Rotate))
                 Rotate = mappings[Field.DatItem_Rotate];
@@ -252,9 +254,9 @@ namespace SabreTools.Library.DatItems
                 return false;
 
             // Filter on display type
-            if (filter.DatItem_DisplayType.MatchesPositiveSet(DisplayType) == false)
+            if (filter.DatItem_DisplayType.MatchesPositive(DisplayType.NULL, DisplayType) == false)
                 return false;
-            if (filter.DatItem_DisplayType.MatchesNegativeSet(DisplayType) == true)
+            if (filter.DatItem_DisplayType.MatchesNegative(DisplayType.NULL, DisplayType) == true)
                 return false;
 
             // Filter on rotation
@@ -344,7 +346,7 @@ namespace SabreTools.Library.DatItems
                 Tag = null;
 
             if (fields.Contains(Field.DatItem_DisplayType))
-                DisplayType = null;
+                DisplayType = DisplayType.NULL;
 
             if (fields.Contains(Field.DatItem_Rotate))
                 Rotate = null;
diff --git a/SabreTools.Library/DatItems/Enums.cs b/SabreTools.Library/DatItems/Enums.cs
index 21ba5dbe..b3cd3e3a 100644
--- a/SabreTools.Library/DatItems/Enums.cs
+++ b/SabreTools.Library/DatItems/Enums.cs
@@ -17,6 +17,24 @@ namespace SabreTools.Library.DatItems
         Audio = 1 << 1,
     }
 
+    /// <summary>
+    /// Determine the display type
+    /// </summary>
+    [Flags]
+    public enum DisplayType
+    {
+        /// <summary>
+        /// This is a fake flag that is used for filter only
+        /// </summary>
+        NULL = 0,
+
+        Raster = 1 << 0,
+        Vector = 1 << 1,
+        LCD = 1 << 2,
+        SVG = 1 << 3,
+        Unknown = 1 << 4,
+    }
+
     /// <summary>
     /// Determines which type of duplicate a file is
     /// </summary>
@@ -78,7 +96,6 @@ namespace SabreTools.Library.DatItems
     /// List of valid field types within a DatItem/Machine
     /// </summary>
     /// TODO: Move this to a more common location
-    /// TODO: Ensure the order of these after all shuffling
     public enum Field : int
     {
         NULL = 0,
@@ -469,19 +486,30 @@ namespace SabreTools.Library.DatItems
     }
 
     /// <summary>
-    /// Determine which OpenMSX subtype an item is
+    /// Determine the loadflag value
     /// </summary>
     [Flags]
-    public enum OpenMSXSubType
+    public enum LoadFlag
     {
         /// <summary>
         /// This is a fake flag that is used for filter only
         /// </summary>
         NULL = 0,
 
-        Rom = 1 << 0,
-        MegaRom = 1 << 1,
-        SCCPlusCart = 1 << 2,
+        Load16Byte = 1 << 0,
+        Load16Word = 1 << 1,
+        Load16WordSwap = 1 << 2,
+        Load32Byte = 1 << 3,
+        Load32Word = 1 << 4,
+        Load32WordSwap = 1 << 5,
+        Load32DWord = 1 << 6,
+        Load64Word = 1 << 7,
+        Load64WordSwap = 1 << 8,
+        Reload = 1 << 9,
+        Fill = 1 << 10,
+        Continue = 1 << 11,
+        ReloadPlain = 1 << 12,
+        Ignore = 1 << 13,
     }
 
     /// <summary>
@@ -500,6 +528,22 @@ namespace SabreTools.Library.DatItems
         Mechanical = 1 << 3,
     }
 
+    /// <summary>
+    /// Determine which OpenMSX subtype an item is
+    /// </summary>
+    [Flags]
+    public enum OpenMSXSubType
+    {
+        /// <summary>
+        /// This is a fake flag that is used for filter only
+        /// </summary>
+        NULL = 0,
+
+        Rom = 1 << 0,
+        MegaRom = 1 << 1,
+        SCCPlusCart = 1 << 2,
+    }
+
     /// <summary>
     /// Determine machine runnable status
     /// </summary>
diff --git a/SabreTools.Library/DatItems/Machine.cs b/SabreTools.Library/DatItems/Machine.cs
index 2aba8150..f10b85fd 100644
--- a/SabreTools.Library/DatItems/Machine.cs
+++ b/SabreTools.Library/DatItems/Machine.cs
@@ -402,9 +402,6 @@ namespace SabreTools.Library.DatItems
             if (mappings.Keys.Contains(Field.Machine_Supported))
                 Supported = mappings[Field.Machine_Supported].AsSupported();
 
-            // TODO: Add Machine_Info*
-            // TODO: Add Machine_SharedFeature*
-
             #endregion
         }
 
diff --git a/SabreTools.Library/DatItems/Rom.cs b/SabreTools.Library/DatItems/Rom.cs
index cb28b6c7..5a552a11 100644
--- a/SabreTools.Library/DatItems/Rom.cs
+++ b/SabreTools.Library/DatItems/Rom.cs
@@ -235,8 +235,8 @@ namespace SabreTools.Library.DatItems
         /// Loading flag
         /// </summary>
         [JsonProperty("loadflag", DefaultValueHandling = DefaultValueHandling.Ignore)]
-        public string LoadFlag { get; set; } // TODO: (load16_byte|load16_word|load16_word_swap|load32_byte|load32_word|load32_word_swap|load32_dword|load64_word|load64_word_swap|reload|fill|continue|reload_plain|ignore)
-
+        [JsonConverter(typeof(StringEnumConverter))]
+        public LoadFlag LoadFlag { get; set; }
 
         /// <summary>
         /// Original hardware part associated with the item
@@ -401,7 +401,7 @@ namespace SabreTools.Library.DatItems
             }
 
             if (mappings.Keys.Contains(Field.DatItem_LoadFlag))
-                LoadFlag = mappings[Field.DatItem_LoadFlag];
+                LoadFlag = mappings[Field.DatItem_LoadFlag].AsLoadFlag();
 
             if (mappings.Keys.Contains(Field.DatItem_Part_Name))
             {
@@ -919,9 +919,9 @@ namespace SabreTools.Library.DatItems
                 return false;
 
             // Filter on load flag
-            if (filter.DatItem_LoadFlag.MatchesPositiveSet(LoadFlag) == false)
+            if (filter.DatItem_LoadFlag.MatchesPositive(LoadFlag.NULL, LoadFlag) == false)
                 return false;
-            if (filter.DatItem_LoadFlag.MatchesNegativeSet(LoadFlag) == true)
+            if (filter.DatItem_LoadFlag.MatchesNegative(LoadFlag.NULL, LoadFlag) == true)
                 return false;
 
             // Filter on part name
@@ -942,7 +942,7 @@ namespace SabreTools.Library.DatItems
             if (filter.DatItem_Value.MatchesNegativeSet(Value) == true)
                 return false;
 
-            // TODO: Handle DatItem_Feature*
+            // TODO: Handle DatItem_Part_Feature*
 
             #endregion
 
@@ -1073,7 +1073,7 @@ namespace SabreTools.Library.DatItems
             }
 
             if (fields.Contains(Field.DatItem_LoadFlag))
-                LoadFlag = null;
+                LoadFlag = LoadFlag.NULL;
 
             if (fields.Contains(Field.DatItem_Part_Name) && Part != null)
                 Part.Name = null;
@@ -1081,7 +1081,7 @@ namespace SabreTools.Library.DatItems
             if (fields.Contains(Field.DatItem_Part_Interface) && Part != null)
                 Part.Interface = null;
 
-            // TODO: Handle DatItem_Feature*
+            // TODO: Handle DatItem_Part_Feature*
 
             if (fields.Contains(Field.DatItem_Value))
                 Value = null;
diff --git a/SabreTools.Library/Filtering/Filter.cs b/SabreTools.Library/Filtering/Filter.cs
index 8fc10cfe..c5d34814 100644
--- a/SabreTools.Library/Filtering/Filter.cs
+++ b/SabreTools.Library/Filtering/Filter.cs
@@ -138,7 +138,7 @@ namespace SabreTools.Library.Filtering
         public FilterItem<long?> DatItem_AreaSize { get; private set; } = new FilterItem<long?>() { Positive = null, Negative = null, Neutral = null };
         public FilterItem<string> DatItem_AreaWidth { get; private set; } = new FilterItem<string>();
         public FilterItem<string> DatItem_AreaEndianness { get; private set; } = new FilterItem<string>();
-        public FilterItem<string> DatItem_LoadFlag { get; private set; } = new FilterItem<string>();
+        public FilterItem<LoadFlag> DatItem_LoadFlag { get; private set; } = new FilterItem<LoadFlag>() { Positive = LoadFlag.NULL, Negative = LoadFlag.NULL };
         public FilterItem<string> DatItem_Part_Name { get; private set; } = new FilterItem<string>();
         public FilterItem<string> DatItem_Part_Interface { get; private set; } = new FilterItem<string>();
         public FilterItem<string> DatItem_Part_Feature_Name { get; private set; } = new FilterItem<string>();
@@ -196,7 +196,7 @@ namespace SabreTools.Library.Filtering
         public FilterItem<string> DatItem_Interface { get; private set; } = new FilterItem<string>();
 
         // Display
-        public FilterItem<string> DatItem_DisplayType { get; private set; } = new FilterItem<string>();
+        public FilterItem<DisplayType> DatItem_DisplayType { get; private set; } = new FilterItem<DisplayType>() { Positive = DisplayType.NULL, Negative = DisplayType.NULL };
         public FilterItem<string> DatItem_Rotate { get; private set; } = new FilterItem<string>();
         public FilterItem<bool?> DatItem_FlipX { get; private set; } = new FilterItem<bool?>() { Neutral = null };
         public FilterItem<string> DatItem_Width { get; private set; } = new FilterItem<string>();
@@ -928,9 +928,9 @@ namespace SabreTools.Library.Filtering
 
                 case Field.DatItem_LoadFlag:
                     if (negate)
-                        DatItem_LoadFlag.NegativeSet.Add(value);
+                        DatItem_LoadFlag.Negative |= value.AsLoadFlag();
                     else
-                        DatItem_LoadFlag.PositiveSet.Add(value);
+                        DatItem_LoadFlag.Positive |= value.AsLoadFlag();
                     break;
 
                 case Field.DatItem_Part_Name:
@@ -1193,9 +1193,9 @@ namespace SabreTools.Library.Filtering
                 // Display
                 case Field.DatItem_DisplayType:
                     if (negate)
-                        DatItem_DisplayType.NegativeSet.Add(value);
+                        DatItem_DisplayType.Negative |= value.AsDisplayType();
                     else
-                        DatItem_DisplayType.PositiveSet.Add(value);
+                        DatItem_DisplayType.Positive |= value.AsDisplayType();
                     break;
 
                 case Field.DatItem_Rotate:
diff --git a/SabreTools.Library/Tools/Converters.cs b/SabreTools.Library/Tools/Converters.cs
index 4edda1e0..ce79c2b9 100644
--- a/SabreTools.Library/Tools/Converters.cs
+++ b/SabreTools.Library/Tools/Converters.cs
@@ -172,6 +172,42 @@ namespace SabreTools.Library.Tools
             }
         }
 
+        /// <summary>
+        /// Get DisplayType value from input string
+        /// </summary>
+        /// <param name="displayType">String to get value from</param>
+        /// <returns>DisplayType value corresponding to the string</returns>
+        public static DisplayType AsDisplayType(this string displayType)
+        {
+#if NET_FRAMEWORK
+            switch (displayType?.ToLowerInvariant())
+            {
+                case "raster":
+                    return DisplayType.Raster;
+                case "vector":
+                    return DisplayType.Vector;
+                case "lcd":
+                    return DisplayType.LCD;
+                case "svg":
+                    return DisplayType.SVG;
+                case "unknown":
+                    return DisplayType.Unknown;
+                default:
+                    return DisplayType.NULL;
+            }
+#else
+            return displayType?.ToLowerInvariant() switch
+            {
+                "raster" => DisplayType.Raster,
+                "vector" => DisplayType.Vector,
+                "lcd" => DisplayType.LCD,
+                "svg" => DisplayType.SVG,
+                "unknown" => DisplayType.Unknown,
+                _ => DisplayType.NULL,
+            };
+#endif
+        }
+
         /// <summary>
         /// Get FeatureStatus value from input string
         /// </summary>
@@ -1669,6 +1705,69 @@ namespace SabreTools.Library.Tools
 #endif
         }
 
+        /// <summary>
+        /// Get LoadFlag value from input string
+        /// </summary>
+        /// <param name="loadFlag">String to get value from</param>
+        /// <returns>LoadFlag value corresponding to the string</returns>
+        public static LoadFlag AsLoadFlag(this string loadFlag)
+        {
+#if NET_FRAMEWORK
+            switch (loadFlag?.ToLowerInvariant())
+            {
+                case "load16_byte":
+                    return LoadFlag.Load16Byte;
+                case "load16_word":
+                    return LoadFlag.Load16Word;
+                case "load16_word_swap":
+                    return LoadFlag.Load16WordSwap;
+                case "load32_byte":
+                    return LoadFlag.Load32Byte;
+                case "load32_word":
+                    return LoadFlag.Load32Word;
+                case "load32_word_swap":
+                    return LoadFlag.Load32WordSwap;
+                case "load32_dword":
+                    return LoadFlag.Load32DWord;
+                case "load64_word":
+                    return LoadFlag.Load64Word;
+                case "load64_word_swap":
+                    return LoadFlag.Load64WordSwap;
+                case "reload":
+                    return LoadFlag.Reload;
+                case "fill":
+                    return LoadFlag.Fill;
+                case "continue":
+                    return LoadFlag.Continue;
+                case "reload_plain":
+                    return LoadFlag.ReloadPlain;
+                case "sccpluscart":
+                    return LoadFlag.Ignore;
+                default:
+                    return LoadFlag.NULL;
+            }
+#else
+            return loadFlag?.ToLowerInvariant() switch
+            {
+                "load16_byte" => LoadFlag.Load16Byte,
+                "load16_word" => LoadFlag.Load16Word,
+                "load16_word_swap" => LoadFlag.Load16WordSwap,
+                "load32_byte" => LoadFlag.Load32Byte,
+                "load32_word" => LoadFlag.Load32Word,
+                "load32_word_swap" => LoadFlag.Load32WordSwap,
+                "load32_dword" => LoadFlag.Load32DWord,
+                "load64_word" => LoadFlag.Load64Word,
+                "load64_word_swap" => LoadFlag.Load64WordSwap,
+                "reload" => LoadFlag.Reload,
+                "fill" => LoadFlag.Fill,
+                "continue" => LoadFlag.Continue,
+                "reload_plain" => LoadFlag.ReloadPlain,
+                "ignore" => LoadFlag.Ignore,
+                _ => LoadFlag.NULL,
+            };
+#endif
+        }
+
         /// <summary>
         /// Get MachineType value from input string
         /// </summary>
@@ -2072,6 +2171,42 @@ namespace SabreTools.Library.Tools
 #endif
         }
 
+        /// <summary>
+        /// Get string value from input DisplayType
+        /// </summary>
+        /// <param name="displayType">DisplayType to get value from</param>
+        /// <returns>String value corresponding to the DisplayType</returns>
+        public static string FromDisplayType(this DisplayType displayType)
+        {
+#if NET_FRAMEWORK
+            switch (displayType)
+            {
+                case DisplayType.Raster:
+                    return "raster";
+                case DisplayType.Vector:
+                    return "vector";
+                case DisplayType.LCD:
+                    return "lcd";
+                case DisplayType.SVG:
+                    return "svg";
+                case DisplayType.Unknown:
+                    return "unknown";
+                default:
+                    return null;
+            }
+#else
+            return displayType switch
+            {
+                DisplayType.Raster => "raster",
+                DisplayType.Vector => "vector",
+                DisplayType.LCD => "lcd",
+                DisplayType.SVG => "svg",
+                DisplayType.Unknown => "unknown",
+                _ => null,
+            };
+#endif
+        }
+
         /// <summary>
         /// Get string value from input FeatureStatus
         /// </summary>
@@ -2196,6 +2331,69 @@ namespace SabreTools.Library.Tools
 #endif
         }
 
+        /// <summary>
+        /// Get string value from input LoadFlag
+        /// </summary>
+        /// <param name="loadFlag">LoadFlag to get value from</param>
+        /// <returns>String value corresponding to the LoadFlag</returns>
+        public static string FromLoadFlag(this LoadFlag loadFlag)
+        {
+#if NET_FRAMEWORK
+            switch (loadFlag)
+            {
+                case LoadFlag.Load16Byte:
+                    return "load16_byte";
+                case LoadFlag.Load16Word:
+                    return "load16_word";
+                case LoadFlag.Load16WordSwap:
+                    return "load16_word_swap";
+                case LoadFlag.Load32Byte:
+                    return "load32_byte";
+                case LoadFlag.Load32Word:
+                    return "load32_word";
+                case LoadFlag.Load32WordSwap:
+                    return "load32_word_swap";
+                case LoadFlag.Load32DWord:
+                    return "load32_dword";
+                case LoadFlag.Load64Word:
+                    return "load64_word";
+                case LoadFlag.Load64WordSwap:
+                    return "load64_word_swap";
+                case LoadFlag.Reload:
+                    return "reload";
+                case LoadFlag.Fill:
+                    return "fill";
+                case LoadFlag.Continue:
+                    return "continue";
+                case LoadFlag.ReloadPlain:
+                    return "reload_plain";
+                case LoadFlag.Ignore:
+                    return "sccpluscart";
+                default:
+                    return null;
+            }
+#else
+            return loadFlag switch
+            {
+                LoadFlag.Load16Byte => "load16_byte",
+                LoadFlag.Load16Word => "load16_word",
+                LoadFlag.Load16WordSwap => "load16_word_swap",
+                LoadFlag.Load32Byte => "load32_byte",
+                LoadFlag.Load32Word => "load32_word",
+                LoadFlag.Load32WordSwap => "load32_word_swap",
+                LoadFlag.Load32DWord => "load32_dword",
+                LoadFlag.Load64Word => "load64_word",
+                LoadFlag.Load64WordSwap => "load64_word_swap",
+                LoadFlag.Reload => "reload",
+                LoadFlag.Fill => "fill",
+                LoadFlag.Continue => "continue",
+                LoadFlag.ReloadPlain => "reload_plain",
+                LoadFlag.Ignore => "ignore",
+                _ => null,
+            };
+#endif
+        }
+
         /// <summary>
         /// Get string value from input ItemType?
         /// </summary>