diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/GenerateRuntimeGraph.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/GenerateRuntimeGraph.cs
index 7948abe8db1..25946410251 100644
--- a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/GenerateRuntimeGraph.cs
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/GenerateRuntimeGraph.cs
@@ -4,12 +4,10 @@
 using Microsoft.Build.Framework;
 using Newtonsoft.Json;
 using NuGet.RuntimeModel;
-using NuGet.Versioning;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Xml.Linq;
 
 namespace Microsoft.DotNet.Build.Tasks.Packaging
@@ -54,6 +52,15 @@ public ITaskItem[] RuntimeGroups
             set;
         }
 
+        /// <summary>
+        /// Additional runtime identifiers to add to the graph.
+        /// </summary>
+        public string[] AdditionalRuntimeIdentifiers
+        {
+            get;
+            set;
+        }
+
         /// <summary>
         /// Optional source Runtime.json to use as a starting point when merging additional RuntimeGroups
         /// </summary>
@@ -135,7 +142,11 @@ public override bool Execute()
                 runtimeGraph = new RuntimeGraph();
             }
 
-            foreach (var runtimeGroup in RuntimeGroups.NullAsEmpty().Select(i => new RuntimeGroup(i)))
+            List<RuntimeGroup> runtimeGroups = RuntimeGroups.NullAsEmpty().Select(i => new RuntimeGroup(i)).ToList();
+
+            AddRuntimeIdentifiers(runtimeGroups, AdditionalRuntimeIdentifiers.NullAsEmpty(), defaultParent: "linux");
+
+            foreach (var runtimeGroup in runtimeGroups)
             {
                 runtimeGraph = SafeMerge(runtimeGraph, runtimeGroup);
             }
@@ -273,307 +284,67 @@ private void ValidateImports(RuntimeGraph runtimeGraph, IDictionary<string, stri
             }
         }
 
-        class RuntimeGroup
+        internal static void AddRuntimeIdentifiers(ICollection<RuntimeGroup> runtimeGroups, IEnumerable<string> runtimeIdentifiers, string defaultParent)
         {
-            private const string rootRID = "any";
-            private const char VersionDelimiter = '.';
-            private const char ArchitectureDelimiter = '-';
-            private const char QualifierDelimiter = '-';
+            var runtimeGroupsByBaseRID = runtimeGroups.GroupBy(rg => rg.BaseRID).ToDictionary(g => g.Key, g => new List<RuntimeGroup>(g.AsEnumerable()));
 
-            public RuntimeGroup(ITaskItem item)
+            foreach(var runtimeIdentifer in runtimeIdentifiers)
             {
-                BaseRID = item.ItemSpec;
-                Parent = item.GetString(nameof(Parent));
-                Versions = item.GetStrings(nameof(Versions));
-                TreatVersionsAsCompatible = item.GetBoolean(nameof(TreatVersionsAsCompatible), true);
-                OmitVersionDelimiter = item.GetBoolean(nameof(OmitVersionDelimiter));
-                ApplyVersionsToParent = item.GetBoolean(nameof(ApplyVersionsToParent));
-                Architectures = item.GetStrings(nameof(Architectures));
-                AdditionalQualifiers = item.GetStrings(nameof(AdditionalQualifiers));
-                OmitRIDs = new HashSet<string>(item.GetStrings(nameof(OmitRIDs)));
-                OmitRIDDefinitions = new HashSet<string>(item.GetStrings(nameof(OmitRIDDefinitions)));
-                OmitRIDReferences = new HashSet<string>(item.GetStrings(nameof(OmitRIDReferences)));
-            }
-
-            public string BaseRID { get; }
-            public string Parent { get; }
-            public IEnumerable<string> Versions { get; }
-            public bool TreatVersionsAsCompatible { get; }
-            public bool OmitVersionDelimiter { get; }
-            public bool ApplyVersionsToParent { get; }
-            public IEnumerable<string> Architectures { get; }
-            public IEnumerable<string> AdditionalQualifiers { get; }
-            public ICollection<string> OmitRIDs { get; }
-            public ICollection<string> OmitRIDDefinitions { get; }
-            public ICollection<string> OmitRIDReferences { get; }
-
-            private class RIDMapping
-            {
-                public RIDMapping(RID runtimeIdentifier)
-                {
-                    RuntimeIdentifier = runtimeIdentifier;
-                    Imports = Enumerable.Empty<RID>();
-                }
-
-                public RIDMapping(RID runtimeIdentifier, IEnumerable<RID> imports)
-                {
-                    RuntimeIdentifier = runtimeIdentifier;
-                    Imports = imports;
-                }
-
-                public RID RuntimeIdentifier { get; }
-
-                public IEnumerable<RID> Imports { get; }
-            }
-
-            private class RID
-            {
-                public string BaseRID { get; set; }
-                public string VersionDelimiter { get; set; }
-                public string Version { get; set; }
-                public string ArchitectureDelimiter { get; set; }
-                public string Architecture { get; set; }
-                public string QualifierDelimiter { get; set; }
-                public string Qualifier { get; set; }
-
-                public override string ToString()
-                {
-                    StringBuilder builder = new StringBuilder(BaseRID);
-
-                    if (HasVersion())
-                    {
-                        builder.Append(VersionDelimiter);
-                        builder.Append(Version);
-                    }
-
-                    if (HasArchitecture())
-                    {
-                        builder.Append(ArchitectureDelimiter);
-                        builder.Append(Architecture);
-                    }
-
-                    if (HasQualifier())
-                    {
-                        builder.Append(QualifierDelimiter);
-                        builder.Append(Qualifier);
-                    }
-
-                    return builder.ToString();
-                }
-
-                public bool HasVersion()
-                {
-                    return Version != null;
-                }
-
-                public bool HasArchitecture()
-                {
-                    return Architecture != null;
-                }
-
-                public bool HasQualifier()
-                {
-                    return Qualifier != null;
-                }
-            }
-
-            private RID CreateRuntime(string baseRid, string version = null, string architecture = null, string qualifier = null)
-            {
-                return new RID()
-                {
-                    BaseRID = baseRid,
-                    VersionDelimiter = OmitVersionDelimiter ? String.Empty : VersionDelimiter.ToString(),
-                    Version = version,
-                    ArchitectureDelimiter = ArchitectureDelimiter.ToString(),
-                    Architecture = architecture,
-                    QualifierDelimiter = QualifierDelimiter.ToString(),
-                    Qualifier = qualifier
-                };
-            }
-
-            private IEnumerable<RIDMapping> GetRIDMappings()
-            {
-                // base =>
-                //      Parent
-                yield return Parent == null ?
-                    new RIDMapping(CreateRuntime(BaseRID)) :
-                    new RIDMapping(CreateRuntime(BaseRID), new[] { CreateRuntime(Parent) });
-
-                foreach (var architecture in Architectures)
-                {
-                    // base + arch =>
-                    //      base,
-                    //      parent + arch
-                    var imports = new List<RID>()
-                    {
-                        CreateRuntime(BaseRID)
-                    };
+                RuntimeGroup runtimeGroup = null;
+                RID rid = RID.Parse(runtimeIdentifer);
 
-                    if (!IsNullOrRoot(Parent))
-                    {
-                        imports.Add(CreateRuntime(Parent, architecture: architecture));
-                    }
-
-                    yield return new RIDMapping(CreateRuntime(BaseRID, architecture: architecture), imports);
-                }
 
-                string lastVersion = null;
-                foreach (var version in Versions)
+                if (runtimeGroupsByBaseRID.TryGetValue(rid.BaseRID, out var candidateRuntimeGroups))
                 {
-                    // base + version =>
-                    //      base + lastVersion,
-                    //      parent + version (optionally)
-                    var imports = new List<RID>()
-                    {
-                        CreateRuntime(BaseRID, version: lastVersion)
-                    };
-
-                    if (ApplyVersionsToParent)
-                    {
-                        imports.Add(CreateRuntime(Parent, version: version));
-                    }
-
-                    yield return new RIDMapping(CreateRuntime(BaseRID, version: version), imports);
+                    RuntimeVersion closestVersion = null;
 
-                    foreach (var architecture in Architectures)
+                    foreach(var candidate in candidateRuntimeGroups)
                     {
-                        // base + version + architecture =>
-                        //      base + version,
-                        //      base + lastVersion + architecture,
-                        //      parent + version + architecture (optionally)
-                        var archImports = new List<RID>()
-                        {
-                            CreateRuntime(BaseRID, version: version),
-                            CreateRuntime(BaseRID, version: lastVersion, architecture: architecture)
-                        };
-
-                        if (ApplyVersionsToParent)
+                        if (rid.HasArchitecture && !candidate.Architectures.Contains(rid.Architecture))
                         {
-                            archImports.Add(CreateRuntime(Parent, version: version, architecture: architecture));
+                            continue;
                         }
 
-                        yield return new RIDMapping(CreateRuntime(BaseRID, version: version, architecture: architecture), archImports);
-                    }
-
-                    if (TreatVersionsAsCompatible)
-                    {
-                        lastVersion = version;
-                    }
-                }
-
-                foreach (var qualifier in AdditionalQualifiers)
-                {
-                    // base + qual =>
-                    //      base,
-                    //      parent + qual
-                    yield return new RIDMapping(CreateRuntime(BaseRID, qualifier: qualifier),
-                        new[]
-                        {
-                            CreateRuntime(BaseRID),
-                            IsNullOrRoot(Parent) ? CreateRuntime(qualifier) : CreateRuntime(Parent, qualifier:qualifier)
-                        });
-
-                    foreach (var architecture in Architectures)
-                    {
-                        // base + arch + qualifier =>
-                        //      base + qualifier,
-                        //      base + arch
-                        //      parent + arch + qualifier
-                        var imports = new List<RID>()
+                        if (!rid.HasVersion)
                         {
-                            CreateRuntime(BaseRID, qualifier: qualifier),
-                            CreateRuntime(BaseRID, architecture: architecture)
-                        };
-
-                        if (!IsNullOrRoot(Parent))
-                        {
-                            imports.Add(CreateRuntime(Parent, architecture: architecture, qualifier: qualifier));
+                            runtimeGroup = candidate;
+                            continue;
                         }
 
-                        yield return new RIDMapping(CreateRuntime(BaseRID, architecture: architecture, qualifier: qualifier), imports);
-                    }
-
-                    lastVersion = null;
-                    foreach (var version in Versions)
-                    {
-                        // base + version + qualifier =>
-                        //      base + version,
-                        //      base + lastVersion + qualifier
-                        //      parent + version + qualifier (optionally)
-                        var imports = new List<RID>()
+                        foreach(var version in candidate.Versions)
                         {
-                            CreateRuntime(BaseRID, version: version),
-                            CreateRuntime(BaseRID, version: lastVersion, qualifier: qualifier)
-                        };
-
-                        if (ApplyVersionsToParent)
-                        {
-                            imports.Add(CreateRuntime(Parent, version: version, qualifier: qualifier));
-                        }
-
-                        yield return new RIDMapping(CreateRuntime(BaseRID, version: version, qualifier: qualifier), imports);
-
-                        foreach (var architecture in Architectures)
-                        {
-                            // base + version + architecture + qualifier =>
-                            //      base + version + qualifier, 
-                            //      base + version + architecture, 
-                            //      base + version,
-                            //      base + lastVersion + architecture + qualifier,
-                            //      parent + version + architecture + qualifier (optionally)
-                            var archImports = new List<RID>()
-                            {
-                                CreateRuntime(BaseRID, version: version, qualifier: qualifier),
-                                CreateRuntime(BaseRID, version: version, architecture: architecture),
-                                CreateRuntime(BaseRID, version: version),
-                                CreateRuntime(BaseRID, version: lastVersion, architecture: architecture, qualifier: qualifier)
-                            };
-
-                            if (ApplyVersionsToParent)
+                            if (closestVersion == null || 
+                               ((version <= rid.Version) &&
+                                (version > closestVersion)))
                             {
-                                imports.Add(CreateRuntime(Parent, version: version, architecture: architecture, qualifier: qualifier));
+                                closestVersion = version;
+                                runtimeGroup = candidate;
                             }
-
-                            yield return new RIDMapping(CreateRuntime(BaseRID, version: version, architecture: architecture, qualifier: qualifier), archImports);
-                        }
-
-                        if (TreatVersionsAsCompatible)
-                        {
-                            lastVersion = version;
                         }
                     }
-                }
-            }
 
-            private bool IsNullOrRoot(string rid)
-            {
-                return rid == null || rid == rootRID;
-            }
+                    if (runtimeGroup == null)
+                    {
+                        // couldn't find a close group, create a new one for just this arch/version
+                        RuntimeGroup templateGroup = candidateRuntimeGroups.First();
+                        runtimeGroup = RuntimeGroup.CreateFromTemplate(templateGroup);
 
+                        // add to overall list
+                        runtimeGroups.Add(runtimeGroup);
 
-            public IEnumerable<RuntimeDescription> GetRuntimeDescriptions()
-            {
-                foreach (var mapping in GetRIDMappings())
-                {
-                    var rid = mapping.RuntimeIdentifier.ToString();
-
-                    if (OmitRIDs.Contains(rid) || OmitRIDDefinitions.Contains(rid))
-                    {
-                        continue;
+                        // add to our base-RID specific list from the dictionary so that further iterations see it.
+                        candidateRuntimeGroups.Add(runtimeGroup);
                     }
+                }
+                else
+                {
+                    runtimeGroup = new RuntimeGroup(rid.BaseRID, defaultParent);
+                    runtimeGroups.Add(runtimeGroup);
 
-                    var imports = mapping.Imports
-                           .Select(i => i.ToString())
-                           .Where(i => !OmitRIDs.Contains(i) && !OmitRIDReferences.Contains(i))
-                           .ToArray();
-
-                    yield return new RuntimeDescription(rid, imports);
+                    runtimeGroupsByBaseRID.Add(rid.BaseRID, new List<RuntimeGroup>() { runtimeGroup });
                 }
-            }
 
-            public RuntimeGraph GetRuntimeGraph()
-            {
-                return new RuntimeGraph(GetRuntimeDescriptions());
+                runtimeGroup.ApplyRid(rid);
             }
         }
 
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj
index 1148b8a5ac7..42d2e34cec2 100644
--- a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj
@@ -48,6 +48,10 @@
     <BeforePack>$(BeforePack);AddRuntimeJson</BeforePack>
   </PropertyGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="Microsoft.DotNet.Build.Tasks.Packaging.Tests" />
+  </ItemGroup>
+
   <ItemGroup>
     <!-- nuget pack needs an actual empty file to use for placeholders for empty directories
          so we must provide one.
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RID.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RID.cs
new file mode 100644
index 00000000000..c3dc3f6991b
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RID.cs
@@ -0,0 +1,204 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+using System.Text;
+
+namespace Microsoft.DotNet.Build.Tasks.Packaging
+{
+    internal class RID
+    {
+        internal const char VersionDelimiter = '.';
+        internal const char ArchitectureDelimiter = '-';
+        internal const char QualifierDelimiter = '-';
+
+        public string BaseRID { get; set; }
+        public bool OmitVersionDelimiter { get; set; }
+        public RuntimeVersion Version { get; set; }
+        public string Architecture { get; set; }
+        public string Qualifier { get; set; }
+
+        public override string ToString()
+        {
+            StringBuilder builder = new StringBuilder(BaseRID);
+
+            if (HasVersion)
+            {
+                if (!OmitVersionDelimiter)
+                {
+                    builder.Append(VersionDelimiter);
+                }
+                builder.Append(Version);
+            }
+
+            if (HasArchitecture)
+            {
+                builder.Append(ArchitectureDelimiter);
+                builder.Append(Architecture);
+            }
+
+            if (HasQualifier)
+            {
+                builder.Append(QualifierDelimiter);
+                builder.Append(Qualifier);
+            }
+
+            return builder.ToString();
+        }
+
+
+        enum RIDPart : int
+        {
+            Base = 0,
+            Version,
+            Architcture,
+            Qualifier,
+            Max = Qualifier
+        }
+
+        public static RID Parse(string runtimeIdentifier)
+        {
+            string[] parts = new string[(int)RIDPart.Max + 1];
+            bool omitVersionDelimiter = true;
+            RIDPart parseState = RIDPart.Base;
+
+            int partStart = 0, partLength = 0;
+
+            // qualifier is indistinguishable from arch so we cannot distinguish it for parsing purposes
+            Debug.Assert(ArchitectureDelimiter == QualifierDelimiter);
+
+            for (int i = 0; i < runtimeIdentifier.Length; i++)
+            {
+                char current = runtimeIdentifier[i];
+                partLength = i - partStart;
+
+                switch (parseState)
+                {
+                    case RIDPart.Base:
+                        // treat any number as the start of the version
+                        if (current == VersionDelimiter || (current >= '0' && current <= '9'))
+                        {
+                            SetPart();
+                            partStart = i;
+                            if (current == VersionDelimiter)
+                            {
+                                omitVersionDelimiter = false;
+                                partStart = i + 1;
+                            }
+                            parseState = RIDPart.Version;
+                        }
+                        // version might be omitted
+                        else if (current == ArchitectureDelimiter)
+                        {
+                            // ensure there's no version later in the string
+                            if (-1 != runtimeIdentifier.IndexOf(VersionDelimiter, i))
+                            {
+                                break;
+                            }
+                            SetPart();
+                            partStart = i + 1;  // skip delimiter
+                            parseState = RIDPart.Architcture;
+                        }
+                        break;
+                    case RIDPart.Version:
+                        if (current == ArchitectureDelimiter)
+                        {
+                            SetPart();
+                            partStart = i + 1;  // skip delimiter
+                            parseState = RIDPart.Architcture;
+                        }
+                        break;
+                    case RIDPart.Architcture:
+                        if (current == QualifierDelimiter)
+                        {
+                            SetPart();
+                            partStart = i + 1;  // skip delimiter
+                            parseState = RIDPart.Qualifier;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            partLength = runtimeIdentifier.Length - partStart;
+            if (partLength > 0)
+            {
+                SetPart();
+            }
+
+            string GetPart(RIDPart part)
+            {
+                return parts[(int)part];
+            }
+
+            void SetPart()
+            {
+                if (partLength == 0)
+                {
+                    throw new ArgumentException($"unexpected delimiter at position {partStart} in {runtimeIdentifier}");
+                }
+
+                parts[(int)parseState] = runtimeIdentifier.Substring(partStart, partLength);
+            }
+
+            string version = GetPart(RIDPart.Version);
+
+            if (version == null)
+            {
+                omitVersionDelimiter = false;
+            }
+
+            return new RID()
+            {
+                BaseRID = GetPart(RIDPart.Base),
+                OmitVersionDelimiter = omitVersionDelimiter,
+                Version = version == null ? null : new RuntimeVersion(version),
+                Architecture = GetPart(RIDPart.Architcture),
+                Qualifier = GetPart(RIDPart.Qualifier)
+            };
+        }
+
+
+        public bool HasVersion => Version != null;
+
+        public bool HasArchitecture => Architecture != null;
+
+        public bool HasQualifier => Qualifier != null;
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as RID);
+        }
+
+        public bool Equals(RID obj)
+        {
+            return object.ReferenceEquals(obj, this) ||
+                (!(obj is null) &&
+                BaseRID == obj.BaseRID &&
+                OmitVersionDelimiter == obj.OmitVersionDelimiter &&
+                Version == obj.Version &&
+                Architecture == obj.Architecture &&
+                Qualifier == obj.Qualifier);
+
+        }
+
+        public override int GetHashCode()
+        {
+#if NETFRAMEWORK
+            return BaseRID.GetHashCode();
+#else
+            HashCode hashCode = new HashCode();
+            hashCode.Add(BaseRID);
+            hashCode.Add(VersionDelimiter);
+            hashCode.Add(Version);
+            hashCode.Add(ArchitectureDelimiter);
+            hashCode.Add(Architecture);
+            hashCode.Add(QualifierDelimiter);
+            hashCode.Add(Qualifier);
+            return hashCode.ToHashCode();
+#endif
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RuntimeGroup.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RuntimeGroup.cs
new file mode 100644
index 00000000000..a3ed3f4ddec
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RuntimeGroup.cs
@@ -0,0 +1,308 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Build.Framework;
+using NuGet.RuntimeModel;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.DotNet.Build.Tasks.Packaging
+{
+    internal class RuntimeGroup
+    {
+        private const string rootRID = "any";
+
+        public RuntimeGroup(ITaskItem item)
+        {
+            BaseRID = item.ItemSpec;
+            Parent = item.GetString(nameof(Parent));
+            Versions = new HashSet<RuntimeVersion>(item.GetStrings(nameof(Versions)).Select(v => new RuntimeVersion(v)));
+            TreatVersionsAsCompatible = item.GetBoolean(nameof(TreatVersionsAsCompatible), true);
+            OmitVersionDelimiter = item.GetBoolean(nameof(OmitVersionDelimiter));
+            ApplyVersionsToParent = item.GetBoolean(nameof(ApplyVersionsToParent));
+            Architectures = new HashSet<string>(item.GetStrings(nameof(Architectures)));
+            AdditionalQualifiers = new HashSet<string>(item.GetStrings(nameof(AdditionalQualifiers)));
+            OmitRIDs = new HashSet<string>(item.GetStrings(nameof(OmitRIDs)));
+            OmitRIDDefinitions = new HashSet<string>(item.GetStrings(nameof(OmitRIDDefinitions)));
+            OmitRIDReferences = new HashSet<string>(item.GetStrings(nameof(OmitRIDReferences)));
+        }
+
+        public RuntimeGroup(string baseRID, string parent, bool treatVersionsAsCompatible = true, bool omitVersionDelimiter = false, bool applyVersionsToParent = false, IEnumerable<string> additionalQualifiers = null)
+        {
+            BaseRID = baseRID;
+            Parent = parent;
+            Versions = new HashSet<RuntimeVersion>();
+            TreatVersionsAsCompatible = treatVersionsAsCompatible;
+            OmitVersionDelimiter = omitVersionDelimiter;
+            ApplyVersionsToParent = applyVersionsToParent;
+            Architectures = new HashSet<string>();
+            AdditionalQualifiers = new HashSet<string>(additionalQualifiers.NullAsEmpty());
+            OmitRIDs = new HashSet<string>();
+            OmitRIDDefinitions = new HashSet<string>();
+            OmitRIDReferences = new HashSet<string>();
+        }
+
+        /// <summary>
+        /// Creates a new RuntimeGroup that matches existing template for parent and format with no architectures nor versions.
+        /// </summary>
+        /// <param name="runtimeGroup"></param>
+        /// <returns></returns>
+        public static RuntimeGroup CreateFromTemplate(RuntimeGroup template)
+        {
+            return new RuntimeGroup(template.BaseRID, template.Parent, template.TreatVersionsAsCompatible, template.OmitVersionDelimiter, template.ApplyVersionsToParent, template.AdditionalQualifiers);
+        }
+
+        public string BaseRID { get; }
+        public string Parent { get; }
+        public ICollection<RuntimeVersion> Versions { get; }
+        public bool TreatVersionsAsCompatible { get; }
+        public bool OmitVersionDelimiter { get; }
+        public bool ApplyVersionsToParent { get; }
+        public ICollection<string> Architectures { get; }
+        public ICollection<string> AdditionalQualifiers { get; }
+        public ICollection<string> OmitRIDs { get; }
+        public ICollection<string> OmitRIDDefinitions { get; }
+        public ICollection<string> OmitRIDReferences { get; }
+
+        public void ApplyRid(RID rid)
+        {
+            if (!rid.BaseRID.Equals(BaseRID, StringComparison.Ordinal))
+            {
+                throw new ArgumentException(nameof(rid), $"Cannot apply {nameof(RID)} with {nameof(RID.BaseRID)} {rid.BaseRID} to {nameof(RuntimeGroup)} with {nameof(RuntimeGroup.BaseRID)} {BaseRID}.");
+            }
+
+            if (rid.HasArchitecture)
+            {
+                Architectures.Add(rid.Architecture);
+            }
+
+            if (rid.HasVersion)
+            {
+                Versions.Add(rid.Version);
+            }
+
+            if (rid.HasQualifier)
+            {
+                AdditionalQualifiers.Add(rid.Qualifier);
+            }
+        }
+
+        private class RIDMapping
+        {
+            public RIDMapping(RID runtimeIdentifier)
+            {
+                RuntimeIdentifier = runtimeIdentifier;
+                Imports = Enumerable.Empty<RID>();
+            }
+
+            public RIDMapping(RID runtimeIdentifier, IEnumerable<RID> imports)
+            {
+                RuntimeIdentifier = runtimeIdentifier;
+                Imports = imports;
+            }
+
+            public RID RuntimeIdentifier { get; }
+
+            public IEnumerable<RID> Imports { get; }
+        }
+
+
+        private RID CreateRuntime(string baseRid, RuntimeVersion version = null, string architecture = null, string qualifier = null)
+        {
+            return new RID()
+            {
+                BaseRID = baseRid,
+                Version = version,
+                OmitVersionDelimiter = OmitVersionDelimiter,
+                Architecture = architecture,
+                Qualifier = qualifier
+            };
+        }
+
+        private IEnumerable<RIDMapping> GetRIDMappings()
+        {
+            // base =>
+            //      Parent
+            yield return Parent == null ?
+                new RIDMapping(CreateRuntime(BaseRID)) :
+                new RIDMapping(CreateRuntime(BaseRID), new[] { CreateRuntime(Parent) });
+
+            foreach (var architecture in Architectures)
+            {
+                // base + arch =>
+                //      base,
+                //      parent + arch
+                var imports = new List<RID>()
+                    {
+                        CreateRuntime(BaseRID)
+                    };
+
+                if (!IsNullOrRoot(Parent))
+                {
+                    imports.Add(CreateRuntime(Parent, architecture: architecture));
+                }
+
+                yield return new RIDMapping(CreateRuntime(BaseRID, architecture: architecture), imports);
+            }
+
+            RuntimeVersion lastVersion = null;
+            foreach (var version in Versions)
+            {
+                // base + version =>
+                //      base + lastVersion,
+                //      parent + version (optionally)
+                var imports = new List<RID>()
+                    {
+                        CreateRuntime(BaseRID, version: lastVersion)
+                    };
+
+                if (ApplyVersionsToParent)
+                {
+                    imports.Add(CreateRuntime(Parent, version: version));
+                }
+
+                yield return new RIDMapping(CreateRuntime(BaseRID, version: version), imports);
+
+                foreach (var architecture in Architectures)
+                {
+                    // base + version + architecture =>
+                    //      base + version,
+                    //      base + lastVersion + architecture,
+                    //      parent + version + architecture (optionally)
+                    var archImports = new List<RID>()
+                        {
+                            CreateRuntime(BaseRID, version: version),
+                            CreateRuntime(BaseRID, version: lastVersion, architecture: architecture)
+                        };
+
+                    if (ApplyVersionsToParent)
+                    {
+                        archImports.Add(CreateRuntime(Parent, version: version, architecture: architecture));
+                    }
+
+                    yield return new RIDMapping(CreateRuntime(BaseRID, version: version, architecture: architecture), archImports);
+                }
+
+                if (TreatVersionsAsCompatible)
+                {
+                    lastVersion = version;
+                }
+            }
+
+            foreach (var qualifier in AdditionalQualifiers)
+            {
+                // base + qual =>
+                //      base,
+                //      parent + qual
+                yield return new RIDMapping(CreateRuntime(BaseRID, qualifier: qualifier),
+                    new[]
+                    {
+                            CreateRuntime(BaseRID),
+                            IsNullOrRoot(Parent) ? CreateRuntime(qualifier) : CreateRuntime(Parent, qualifier:qualifier)
+                    });
+
+                foreach (var architecture in Architectures)
+                {
+                    // base + arch + qualifier =>
+                    //      base + qualifier,
+                    //      base + arch
+                    //      parent + arch + qualifier
+                    var imports = new List<RID>()
+                        {
+                            CreateRuntime(BaseRID, qualifier: qualifier),
+                            CreateRuntime(BaseRID, architecture: architecture)
+                        };
+
+                    if (!IsNullOrRoot(Parent))
+                    {
+                        imports.Add(CreateRuntime(Parent, architecture: architecture, qualifier: qualifier));
+                    }
+
+                    yield return new RIDMapping(CreateRuntime(BaseRID, architecture: architecture, qualifier: qualifier), imports);
+                }
+
+                lastVersion = null;
+                foreach (var version in Versions)
+                {
+                    // base + version + qualifier =>
+                    //      base + version,
+                    //      base + lastVersion + qualifier
+                    //      parent + version + qualifier (optionally)
+                    var imports = new List<RID>()
+                        {
+                            CreateRuntime(BaseRID, version: version),
+                            CreateRuntime(BaseRID, version: lastVersion, qualifier: qualifier)
+                        };
+
+                    if (ApplyVersionsToParent)
+                    {
+                        imports.Add(CreateRuntime(Parent, version: version, qualifier: qualifier));
+                    }
+
+                    yield return new RIDMapping(CreateRuntime(BaseRID, version: version, qualifier: qualifier), imports);
+
+                    foreach (var architecture in Architectures)
+                    {
+                        // base + version + architecture + qualifier =>
+                        //      base + version + qualifier, 
+                        //      base + version + architecture, 
+                        //      base + version,
+                        //      base + lastVersion + architecture + qualifier,
+                        //      parent + version + architecture + qualifier (optionally)
+                        var archImports = new List<RID>()
+                            {
+                                CreateRuntime(BaseRID, version: version, qualifier: qualifier),
+                                CreateRuntime(BaseRID, version: version, architecture: architecture),
+                                CreateRuntime(BaseRID, version: version),
+                                CreateRuntime(BaseRID, version: lastVersion, architecture: architecture, qualifier: qualifier)
+                            };
+
+                        if (ApplyVersionsToParent)
+                        {
+                            imports.Add(CreateRuntime(Parent, version: version, architecture: architecture, qualifier: qualifier));
+                        }
+
+                        yield return new RIDMapping(CreateRuntime(BaseRID, version: version, architecture: architecture, qualifier: qualifier), archImports);
+                    }
+
+                    if (TreatVersionsAsCompatible)
+                    {
+                        lastVersion = version;
+                    }
+                }
+            }
+        }
+
+        private bool IsNullOrRoot(string rid)
+        {
+            return rid == null || rid == rootRID;
+        }
+
+
+        public IEnumerable<RuntimeDescription> GetRuntimeDescriptions()
+        {
+            foreach (var mapping in GetRIDMappings())
+            {
+                var rid = mapping.RuntimeIdentifier.ToString();
+
+                if (OmitRIDs.Contains(rid) || OmitRIDDefinitions.Contains(rid))
+                {
+                    continue;
+                }
+
+                var imports = mapping.Imports
+                       .Select(i => i.ToString())
+                       .Where(i => !OmitRIDs.Contains(i) && !OmitRIDReferences.Contains(i))
+                       .ToArray();
+
+                yield return new RuntimeDescription(rid, imports);
+            }
+        }
+
+        public RuntimeGraph GetRuntimeGraph()
+        {
+            return new RuntimeGraph(GetRuntimeDescriptions());
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RuntimeVersion.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RuntimeVersion.cs
new file mode 100644
index 00000000000..66b44439121
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/RuntimeVersion.cs
@@ -0,0 +1,136 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.DotNet.Build.Tasks.Packaging
+{
+
+    /// <summary>
+    /// A Version class that also supports a single integer (major only)
+    /// </summary>
+    internal sealed class RuntimeVersion : IComparable, IComparable<RuntimeVersion>, IEquatable<RuntimeVersion>
+    {
+        private string versionString;
+        private Version version;
+        private bool hasMinor;
+
+        public RuntimeVersion(string versionString)
+        {
+            // intentionally don't support the type of version that omits the separators as it is abiguous.
+            // for example Windows 8.1 was encoded as win81, where as Windows 10.0 was encoded as win10
+            this.versionString = versionString;
+            string toParse = versionString;
+            if (toParse.IndexOf('.') == -1)
+            {
+                toParse += ".0";
+                hasMinor = false;
+            }
+            else
+            {
+                hasMinor = true;
+            }
+            version = Version.Parse(toParse);
+        }
+
+        public int CompareTo(object obj)
+        {
+            if (obj == null)
+            {
+                return 1;
+            }
+
+            if (obj is RuntimeVersion version)
+            {
+                return CompareTo(version);
+            }
+
+            throw new ArgumentException();
+        }
+
+        public int CompareTo(RuntimeVersion other)
+        {
+            if (other == null)
+            {
+                return 1;
+            }
+
+            int versionResult = version.CompareTo(other?.version);
+
+            if (versionResult == 0)
+            {
+                if (!hasMinor && other.hasMinor)
+                {
+                    return -1;
+                }
+
+                if (hasMinor && !other.hasMinor)
+                {
+                    return 1;
+                }
+
+                return string.CompareOrdinal(versionString, other.versionString);
+            }
+
+            return versionResult;
+        }
+
+        public bool Equals(RuntimeVersion other)
+        {
+            return object.ReferenceEquals(other, this) ||
+                (other != null && 
+                versionString.Equals(other.versionString, StringComparison.Ordinal));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as RuntimeVersion);
+        }
+
+        public override int GetHashCode()
+        {
+            return versionString.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return versionString;
+        }
+
+        public static bool operator ==(RuntimeVersion v1, RuntimeVersion v2)
+        {
+            if (v2 is null)
+            {
+                return (v1 is null) ? true : false;
+            }
+
+            return ReferenceEquals(v2, v1) ? true : v2.Equals(v1);
+        }
+
+        public static bool operator !=(RuntimeVersion v1, RuntimeVersion v2) => !(v1 == v2);
+
+        public static bool operator <(RuntimeVersion v1, RuntimeVersion v2)
+        {
+            if (v1 is null)
+            {
+                return !(v2 is null);
+            }
+
+            return v1.CompareTo(v2) < 0;
+        }
+
+        public static bool operator <=(RuntimeVersion v1, RuntimeVersion v2)
+        {
+            if (v1 is null)
+            {
+                return true;
+            }
+
+            return v1.CompareTo(v2) <= 0;
+        }
+
+        public static bool operator >(RuntimeVersion v1, RuntimeVersion v2) => v2 < v1;
+
+        public static bool operator >=(RuntimeVersion v1, RuntimeVersion v2) => v2 <= v1;
+    }
+}
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/GenerateRuntimeGraphTests.CanCreateRuntimeGraph.runtime.json b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/GenerateRuntimeGraphTests.CanCreateRuntimeGraph.runtime.json
new file mode 100644
index 00000000000..f298932ca02
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/GenerateRuntimeGraphTests.CanCreateRuntimeGraph.runtime.json
@@ -0,0 +1,1071 @@
+{
+  "runtimes": {
+    "any": {
+      "#import": []
+    },
+    "aot": {
+      "#import": []
+    },
+    "centos": {
+      "#import": [
+        "rhel"
+      ]
+    },
+    "centos-arm64": {
+      "#import": [
+        "centos",
+        "rhel-arm64"
+      ]
+    },
+    "centos-x64": {
+      "#import": [
+        "centos",
+        "rhel-x64"
+      ]
+    },
+    "centos.7": {
+      "#import": [
+        "centos",
+        "rhel.7"
+      ]
+    },
+    "centos.7-x64": {
+      "#import": [
+        "centos.7",
+        "centos-x64",
+        "rhel.7-x64"
+      ]
+    },
+    "centos.8": {
+      "#import": [
+        "centos",
+        "rhel.8"
+      ]
+    },
+    "centos.8-arm64": {
+      "#import": [
+        "centos.8",
+        "centos-arm64",
+        "rhel.8-arm64"
+      ]
+    },
+    "centos.8-x64": {
+      "#import": [
+        "centos.8",
+        "centos-x64",
+        "rhel.8-x64"
+      ]
+    },
+    "centos.9": {
+      "#import": [
+        "centos",
+        "rhel.9"
+      ]
+    },
+    "centos.9-arm64": {
+      "#import": [
+        "centos.9",
+        "centos-arm64",
+        "rhel.9-arm64"
+      ]
+    },
+    "centos.9-x64": {
+      "#import": [
+        "centos.9",
+        "centos-x64",
+        "rhel.9-x64"
+      ]
+    },
+    "debian": {
+      "#import": [
+        "linux"
+      ]
+    },
+    "debian-arm": {
+      "#import": [
+        "debian",
+        "linux-arm"
+      ]
+    },
+    "debian-arm64": {
+      "#import": [
+        "debian",
+        "linux-arm64"
+      ]
+    },
+    "debian-armel": {
+      "#import": [
+        "debian",
+        "linux-armel"
+      ]
+    },
+    "debian-x64": {
+      "#import": [
+        "debian",
+        "linux-x64"
+      ]
+    },
+    "debian-x86": {
+      "#import": [
+        "debian",
+        "linux-x86"
+      ]
+    },
+    "debian.10": {
+      "#import": [
+        "debian"
+      ]
+    },
+    "debian.10-arm": {
+      "#import": [
+        "debian.10",
+        "debian-arm"
+      ]
+    },
+    "debian.10-arm64": {
+      "#import": [
+        "debian.10",
+        "debian-arm64"
+      ]
+    },
+    "debian.10-armel": {
+      "#import": [
+        "debian.10",
+        "debian-armel"
+      ]
+    },
+    "debian.10-x64": {
+      "#import": [
+        "debian.10",
+        "debian-x64"
+      ]
+    },
+    "debian.10-x86": {
+      "#import": [
+        "debian.10",
+        "debian-x86"
+      ]
+    },
+    "debian.8": {
+      "#import": [
+        "debian"
+      ]
+    },
+    "debian.8-arm": {
+      "#import": [
+        "debian.8",
+        "debian-arm"
+      ]
+    },
+    "debian.8-arm64": {
+      "#import": [
+        "debian.8",
+        "debian-arm64"
+      ]
+    },
+    "debian.8-armel": {
+      "#import": [
+        "debian.8",
+        "debian-armel"
+      ]
+    },
+    "debian.8-x64": {
+      "#import": [
+        "debian.8",
+        "debian-x64"
+      ]
+    },
+    "debian.8-x86": {
+      "#import": [
+        "debian.8",
+        "debian-x86"
+      ]
+    },
+    "debian.9": {
+      "#import": [
+        "debian"
+      ]
+    },
+    "debian.9-arm": {
+      "#import": [
+        "debian.9",
+        "debian-arm"
+      ]
+    },
+    "debian.9-arm64": {
+      "#import": [
+        "debian.9",
+        "debian-arm64"
+      ]
+    },
+    "debian.9-armel": {
+      "#import": [
+        "debian.9",
+        "debian-armel"
+      ]
+    },
+    "debian.9-x64": {
+      "#import": [
+        "debian.9",
+        "debian-x64"
+      ]
+    },
+    "debian.9-x86": {
+      "#import": [
+        "debian.9",
+        "debian-x86"
+      ]
+    },
+    "linux": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "linux-arm": {
+      "#import": [
+        "linux",
+        "unix-arm"
+      ]
+    },
+    "linux-arm64": {
+      "#import": [
+        "linux",
+        "unix-arm64"
+      ]
+    },
+    "linux-armel": {
+      "#import": [
+        "linux",
+        "unix-armel"
+      ]
+    },
+    "linux-mips64": {
+      "#import": [
+        "linux",
+        "unix-mips64"
+      ]
+    },
+    "linux-x64": {
+      "#import": [
+        "linux",
+        "unix-x64"
+      ]
+    },
+    "linux-x86": {
+      "#import": [
+        "linux",
+        "unix-x86"
+      ]
+    },
+    "osx": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "osx-arm64": {
+      "#import": [
+        "osx",
+        "unix-arm64"
+      ]
+    },
+    "osx-x64": {
+      "#import": [
+        "osx",
+        "unix-x64"
+      ]
+    },
+    "osx.10.10": {
+      "#import": [
+        "osx"
+      ]
+    },
+    "osx.10.10-arm64": {
+      "#import": [
+        "osx.10.10",
+        "osx-arm64"
+      ]
+    },
+    "osx.10.10-x64": {
+      "#import": [
+        "osx.10.10",
+        "osx-x64"
+      ]
+    },
+    "osx.10.11": {
+      "#import": [
+        "osx.10.10"
+      ]
+    },
+    "osx.10.11-arm64": {
+      "#import": [
+        "osx.10.11",
+        "osx.10.10-arm64"
+      ]
+    },
+    "osx.10.11-x64": {
+      "#import": [
+        "osx.10.11",
+        "osx.10.10-x64"
+      ]
+    },
+    "osx.10.12": {
+      "#import": [
+        "osx.10.11"
+      ]
+    },
+    "osx.10.12-arm64": {
+      "#import": [
+        "osx.10.12",
+        "osx.10.11-arm64"
+      ]
+    },
+    "osx.10.12-x64": {
+      "#import": [
+        "osx.10.12",
+        "osx.10.11-x64"
+      ]
+    },
+    "osx.10.13": {
+      "#import": [
+        "osx.10.12"
+      ]
+    },
+    "osx.10.13-arm64": {
+      "#import": [
+        "osx.10.13",
+        "osx.10.12-arm64"
+      ]
+    },
+    "osx.10.13-x64": {
+      "#import": [
+        "osx.10.13",
+        "osx.10.12-x64"
+      ]
+    },
+    "osx.10.14": {
+      "#import": [
+        "osx.10.13"
+      ]
+    },
+    "osx.10.14-arm64": {
+      "#import": [
+        "osx.10.14",
+        "osx.10.13-arm64"
+      ]
+    },
+    "osx.10.14-x64": {
+      "#import": [
+        "osx.10.14",
+        "osx.10.13-x64"
+      ]
+    },
+    "osx.10.15": {
+      "#import": [
+        "osx.10.14"
+      ]
+    },
+    "osx.10.15-arm64": {
+      "#import": [
+        "osx.10.15",
+        "osx.10.14-arm64"
+      ]
+    },
+    "osx.10.15-x64": {
+      "#import": [
+        "osx.10.15",
+        "osx.10.14-x64"
+      ]
+    },
+    "osx.10.16": {
+      "#import": [
+        "osx.10.15"
+      ]
+    },
+    "osx.10.16-arm64": {
+      "#import": [
+        "osx.10.16",
+        "osx.10.15-arm64"
+      ]
+    },
+    "osx.10.16-x64": {
+      "#import": [
+        "osx.10.16",
+        "osx.10.15-x64"
+      ]
+    },
+    "osx.11.0": {
+      "#import": [
+        "osx.10.16"
+      ]
+    },
+    "osx.11.0-arm64": {
+      "#import": [
+        "osx.11.0",
+        "osx.10.16-arm64"
+      ]
+    },
+    "osx.11.0-x64": {
+      "#import": [
+        "osx.11.0",
+        "osx.10.16-x64"
+      ]
+    },
+    "rhel": {
+      "#import": [
+        "linux"
+      ]
+    },
+    "rhel-arm64": {
+      "#import": [
+        "rhel",
+        "linux-arm64"
+      ]
+    },
+    "rhel-x64": {
+      "#import": [
+        "rhel",
+        "linux-x64"
+      ]
+    },
+    "rhel.6": {
+      "#import": [
+        "rhel"
+      ]
+    },
+    "rhel.6-x64": {
+      "#import": [
+        "rhel.6",
+        "rhel-x64"
+      ]
+    },
+    "rhel.7": {
+      "#import": [
+        "rhel"
+      ]
+    },
+    "rhel.7-x64": {
+      "#import": [
+        "rhel.7",
+        "rhel-x64"
+      ]
+    },
+    "rhel.7.0": {
+      "#import": [
+        "rhel.7"
+      ]
+    },
+    "rhel.7.0-x64": {
+      "#import": [
+        "rhel.7.0",
+        "rhel.7-x64"
+      ]
+    },
+    "rhel.7.1": {
+      "#import": [
+        "rhel.7.0"
+      ]
+    },
+    "rhel.7.1-x64": {
+      "#import": [
+        "rhel.7.1",
+        "rhel.7.0-x64"
+      ]
+    },
+    "rhel.7.2": {
+      "#import": [
+        "rhel.7.1"
+      ]
+    },
+    "rhel.7.2-x64": {
+      "#import": [
+        "rhel.7.2",
+        "rhel.7.1-x64"
+      ]
+    },
+    "rhel.7.3": {
+      "#import": [
+        "rhel.7.2"
+      ]
+    },
+    "rhel.7.3-x64": {
+      "#import": [
+        "rhel.7.3",
+        "rhel.7.2-x64"
+      ]
+    },
+    "rhel.7.4": {
+      "#import": [
+        "rhel.7.3"
+      ]
+    },
+    "rhel.7.4-x64": {
+      "#import": [
+        "rhel.7.4",
+        "rhel.7.3-x64"
+      ]
+    },
+    "rhel.7.5": {
+      "#import": [
+        "rhel.7.4"
+      ]
+    },
+    "rhel.7.5-x64": {
+      "#import": [
+        "rhel.7.5",
+        "rhel.7.4-x64"
+      ]
+    },
+    "rhel.7.6": {
+      "#import": [
+        "rhel.7.5"
+      ]
+    },
+    "rhel.7.6-x64": {
+      "#import": [
+        "rhel.7.6",
+        "rhel.7.5-x64"
+      ]
+    },
+    "rhel.8": {
+      "#import": [
+        "rhel"
+      ]
+    },
+    "rhel.8-arm64": {
+      "#import": [
+        "rhel.8",
+        "rhel-arm64"
+      ]
+    },
+    "rhel.8-x64": {
+      "#import": [
+        "rhel.8",
+        "rhel-x64"
+      ]
+    },
+    "rhel.8.0": {
+      "#import": [
+        "rhel.8"
+      ]
+    },
+    "rhel.8.0-arm64": {
+      "#import": [
+        "rhel.8.0",
+        "rhel.8-arm64"
+      ]
+    },
+    "rhel.8.0-x64": {
+      "#import": [
+        "rhel.8.0",
+        "rhel.8-x64"
+      ]
+    },
+    "rhel.8.1": {
+      "#import": [
+        "rhel.8.0"
+      ]
+    },
+    "rhel.8.1-arm64": {
+      "#import": [
+        "rhel.8.1",
+        "rhel.8.0-arm64"
+      ]
+    },
+    "rhel.8.1-x64": {
+      "#import": [
+        "rhel.8.1",
+        "rhel.8.0-x64"
+      ]
+    },
+    "rhel.9": {
+      "#import": [
+        "rhel"
+      ]
+    },
+    "rhel.9-arm64": {
+      "#import": [
+        "rhel.9",
+        "rhel-arm64"
+      ]
+    },
+    "rhel.9-x64": {
+      "#import": [
+        "rhel.9",
+        "rhel-x64"
+      ]
+    },
+    "ubuntu": {
+      "#import": [
+        "debian"
+      ]
+    },
+    "ubuntu-arm": {
+      "#import": [
+        "ubuntu",
+        "debian-arm"
+      ]
+    },
+    "ubuntu-x64": {
+      "#import": [
+        "ubuntu",
+        "debian-x64"
+      ]
+    },
+    "ubuntu-x86": {
+      "#import": [
+        "ubuntu",
+        "debian-x86"
+      ]
+    },
+    "ubuntu.14.04": {
+      "#import": [
+        "ubuntu"
+      ]
+    },
+    "ubuntu.14.04-arm": {
+      "#import": [
+        "ubuntu.14.04",
+        "ubuntu-arm"
+      ]
+    },
+    "ubuntu.14.04-x64": {
+      "#import": [
+        "ubuntu.14.04",
+        "ubuntu-x64"
+      ]
+    },
+    "ubuntu.14.04-x86": {
+      "#import": [
+        "ubuntu.14.04",
+        "ubuntu-x86"
+      ]
+    },
+    "ubuntu.14.10": {
+      "#import": [
+        "ubuntu"
+      ]
+    },
+    "ubuntu.14.10-arm": {
+      "#import": [
+        "ubuntu.14.10",
+        "ubuntu-arm"
+      ]
+    },
+    "ubuntu.14.10-x64": {
+      "#import": [
+        "ubuntu.14.10",
+        "ubuntu-x64"
+      ]
+    },
+    "ubuntu.14.10-x86": {
+      "#import": [
+        "ubuntu.14.10",
+        "ubuntu-x86"
+      ]
+    },
+    "ubuntu.15.04": {
+      "#import": [
+        "ubuntu"
+      ]
+    },
+    "ubuntu.15.04-arm": {
+      "#import": [
+        "ubuntu.15.04",
+        "ubuntu-arm"
+      ]
+    },
+    "ubuntu.15.04-x64": {
+      "#import": [
+        "ubuntu.15.04",
+        "ubuntu-x64"
+      ]
+    },
+    "ubuntu.15.04-x86": {
+      "#import": [
+        "ubuntu.15.04",
+        "ubuntu-x86"
+      ]
+    },
+    "ubuntu.15.10": {
+      "#import": [
+        "ubuntu"
+      ]
+    },
+    "ubuntu.15.10-arm": {
+      "#import": [
+        "ubuntu.15.10",
+        "ubuntu-arm"
+      ]
+    },
+    "ubuntu.15.10-x64": {
+      "#import": [
+        "ubuntu.15.10",
+        "ubuntu-x64"
+      ]
+    },
+    "ubuntu.15.10-x86": {
+      "#import": [
+        "ubuntu.15.10",
+        "ubuntu-x86"
+      ]
+    },
+    "unix": {
+      "#import": [
+        "any"
+      ]
+    },
+    "unix-arm": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "unix-arm64": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "unix-armel": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "unix-mips64": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "unix-x64": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "unix-x86": {
+      "#import": [
+        "unix"
+      ]
+    },
+    "win": {
+      "#import": [
+        "any"
+      ]
+    },
+    "win-aot": {
+      "#import": [
+        "win",
+        "aot"
+      ]
+    },
+    "win-arm": {
+      "#import": [
+        "win"
+      ]
+    },
+    "win-arm-aot": {
+      "#import": [
+        "win-aot",
+        "win-arm"
+      ]
+    },
+    "win-arm64": {
+      "#import": [
+        "win"
+      ]
+    },
+    "win-arm64-aot": {
+      "#import": [
+        "win-aot",
+        "win-arm64"
+      ]
+    },
+    "win-x64": {
+      "#import": [
+        "win"
+      ]
+    },
+    "win-x64-aot": {
+      "#import": [
+        "win-aot",
+        "win-x64"
+      ]
+    },
+    "win-x86": {
+      "#import": [
+        "win"
+      ]
+    },
+    "win-x86-aot": {
+      "#import": [
+        "win-aot",
+        "win-x86"
+      ]
+    },
+    "win10": {
+      "#import": [
+        "win81"
+      ]
+    },
+    "win10-aot": {
+      "#import": [
+        "win10",
+        "win81-aot"
+      ]
+    },
+    "win10-arm": {
+      "#import": [
+        "win10",
+        "win81-arm"
+      ]
+    },
+    "win10-arm-aot": {
+      "#import": [
+        "win10-aot",
+        "win10-arm",
+        "win10",
+        "win81-arm-aot"
+      ]
+    },
+    "win10-arm64": {
+      "#import": [
+        "win10",
+        "win81-arm64"
+      ]
+    },
+    "win10-arm64-aot": {
+      "#import": [
+        "win10-aot",
+        "win10-arm64",
+        "win10",
+        "win81-arm64-aot"
+      ]
+    },
+    "win10-x64": {
+      "#import": [
+        "win10",
+        "win81-x64"
+      ]
+    },
+    "win10-x64-aot": {
+      "#import": [
+        "win10-aot",
+        "win10-x64",
+        "win10",
+        "win81-x64-aot"
+      ]
+    },
+    "win10-x86": {
+      "#import": [
+        "win10",
+        "win81-x86"
+      ]
+    },
+    "win10-x86-aot": {
+      "#import": [
+        "win10-aot",
+        "win10-x86",
+        "win10",
+        "win81-x86-aot"
+      ]
+    },
+    "win7": {
+      "#import": [
+        "win"
+      ]
+    },
+    "win7-aot": {
+      "#import": [
+        "win7",
+        "win-aot"
+      ]
+    },
+    "win7-arm": {
+      "#import": [
+        "win7",
+        "win-arm"
+      ]
+    },
+    "win7-arm-aot": {
+      "#import": [
+        "win7-aot",
+        "win7-arm",
+        "win7",
+        "win-arm-aot"
+      ]
+    },
+    "win7-arm64": {
+      "#import": [
+        "win7",
+        "win-arm64"
+      ]
+    },
+    "win7-arm64-aot": {
+      "#import": [
+        "win7-aot",
+        "win7-arm64",
+        "win7",
+        "win-arm64-aot"
+      ]
+    },
+    "win7-x64": {
+      "#import": [
+        "win7",
+        "win-x64"
+      ]
+    },
+    "win7-x64-aot": {
+      "#import": [
+        "win7-aot",
+        "win7-x64",
+        "win7",
+        "win-x64-aot"
+      ]
+    },
+    "win7-x86": {
+      "#import": [
+        "win7",
+        "win-x86"
+      ]
+    },
+    "win7-x86-aot": {
+      "#import": [
+        "win7-aot",
+        "win7-x86",
+        "win7",
+        "win-x86-aot"
+      ]
+    },
+    "win8": {
+      "#import": [
+        "win7"
+      ]
+    },
+    "win8-aot": {
+      "#import": [
+        "win8",
+        "win7-aot"
+      ]
+    },
+    "win8-arm": {
+      "#import": [
+        "win8",
+        "win7-arm"
+      ]
+    },
+    "win8-arm-aot": {
+      "#import": [
+        "win8-aot",
+        "win8-arm",
+        "win8",
+        "win7-arm-aot"
+      ]
+    },
+    "win8-arm64": {
+      "#import": [
+        "win8",
+        "win7-arm64"
+      ]
+    },
+    "win8-arm64-aot": {
+      "#import": [
+        "win8-aot",
+        "win8-arm64",
+        "win8",
+        "win7-arm64-aot"
+      ]
+    },
+    "win8-x64": {
+      "#import": [
+        "win8",
+        "win7-x64"
+      ]
+    },
+    "win8-x64-aot": {
+      "#import": [
+        "win8-aot",
+        "win8-x64",
+        "win8",
+        "win7-x64-aot"
+      ]
+    },
+    "win8-x86": {
+      "#import": [
+        "win8",
+        "win7-x86"
+      ]
+    },
+    "win8-x86-aot": {
+      "#import": [
+        "win8-aot",
+        "win8-x86",
+        "win8",
+        "win7-x86-aot"
+      ]
+    },
+    "win81": {
+      "#import": [
+        "win8"
+      ]
+    },
+    "win81-aot": {
+      "#import": [
+        "win81",
+        "win8-aot"
+      ]
+    },
+    "win81-arm": {
+      "#import": [
+        "win81",
+        "win8-arm"
+      ]
+    },
+    "win81-arm-aot": {
+      "#import": [
+        "win81-aot",
+        "win81-arm",
+        "win81",
+        "win8-arm-aot"
+      ]
+    },
+    "win81-arm64": {
+      "#import": [
+        "win81",
+        "win8-arm64"
+      ]
+    },
+    "win81-arm64-aot": {
+      "#import": [
+        "win81-aot",
+        "win81-arm64",
+        "win81",
+        "win8-arm64-aot"
+      ]
+    },
+    "win81-x64": {
+      "#import": [
+        "win81",
+        "win8-x64"
+      ]
+    },
+    "win81-x64-aot": {
+      "#import": [
+        "win81-aot",
+        "win81-x64",
+        "win81",
+        "win8-x64-aot"
+      ]
+    },
+    "win81-x86": {
+      "#import": [
+        "win81",
+        "win8-x86"
+      ]
+    },
+    "win81-x86-aot": {
+      "#import": [
+        "win81-aot",
+        "win81-x86",
+        "win81",
+        "win8-x86-aot"
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/GenerateRuntimeGraphTests.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/GenerateRuntimeGraphTests.cs
new file mode 100644
index 00000000000..160e39bb886
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/GenerateRuntimeGraphTests.cs
@@ -0,0 +1,178 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+using Xunit;
+using Xunit.Abstractions;
+using FluentAssertions;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace Microsoft.DotNet.Build.Tasks.Packaging.Tests
+{
+    public class GenerateRuntimeGraphTests
+    {
+        private Log _log;
+        private TestBuildEngine _engine;
+
+        public GenerateRuntimeGraphTests(ITestOutputHelper output)
+        {
+            _log = new Log(output);
+            _engine = new TestBuildEngine(_log);
+        }
+
+        [Fact]
+        public void CanCreateRuntimeGraph()
+        {
+            string runtimeFile = $"{nameof(GenerateRuntimeGraphTests)}.{nameof(CanCreateRuntimeGraph)}.runtime.json";
+
+            // will generate and compare to existing file.
+            GenerateRuntimeGraph task = new GenerateRuntimeGraph()
+            {
+                BuildEngine = _engine,
+                RuntimeGroups = runtimeGroups,
+                RuntimeJson = runtimeFile
+            };
+
+            _log.Reset();
+            task.Execute();
+            _log.ErrorsLogged.Should().Be(0);
+            _log.WarningsLogged.Should().Be(0);
+        }
+
+        [Fact]
+        public void CanAddVersionsToExistingGroups()
+        {
+            List<RuntimeGroup> groups = runtimeGroups.Select(g => new RuntimeGroup(g)).ToList();
+
+            RuntimeGroup rhelGroup = groups.Where(g => g.BaseRID.Equals("rhel", StringComparison.Ordinal) &&
+                        g.Versions.Contains(new RuntimeVersion("9")) &&
+                        g.Architectures.Contains("x64")).Single();
+            RuntimeGroup centosGroup = groups.Where(g => g.BaseRID.Equals("centos", StringComparison.Ordinal) &&
+                        g.Versions.Contains(new RuntimeVersion("9")) &&
+                        g.Architectures.Contains("arm64")).Single();
+
+            GenerateRuntimeGraph.AddRuntimeIdentifiers(groups, new[] { "rhel.9.2-x64", "centos.9.2-arm64" }, null);
+
+            rhelGroup.Versions.Should().Contain(new RuntimeVersion("9.2"));
+            centosGroup.Versions.Should().Contain(new RuntimeVersion("9.2"));
+        }
+
+        [Fact]
+        public void CanAddArchitectureToExistingGroups()
+        {
+            List<RuntimeGroup> groups = runtimeGroups.Select(g => new RuntimeGroup(g)).ToList();
+            List<RuntimeGroup> originalGroups = new List<RuntimeGroup>(groups);
+            GenerateRuntimeGraph.AddRuntimeIdentifiers(groups, new[] { "win10-x128" }, null);
+
+            groups.Except(originalGroups).Should().SatisfyRespectively(g =>
+            {
+                Assert.Equal("win", g.BaseRID);
+                Assert.Equal("any", g.Parent);
+                g.Versions.Should().SatisfyRespectively(v => Assert.Equal(new RuntimeVersion("10"), v));
+                g.Architectures.Should().SatisfyRespectively(a => Assert.Equal("x128", a));
+            });
+        }
+
+        [Fact]
+        public void CanAdNewGroups()
+        {
+            List<RuntimeGroup> groups = runtimeGroups.Select(g => new RuntimeGroup(g)).ToList();
+            List<RuntimeGroup> originalGroups = new List<RuntimeGroup>(groups);
+            GenerateRuntimeGraph.AddRuntimeIdentifiers(groups, new[] { "yolinux.42.0-quantum" }, "linux");
+
+            groups.Except(originalGroups).Should().SatisfyRespectively(g =>
+            {
+                Assert.Equal("yolinux", g.BaseRID);
+                Assert.Equal("linux", g.Parent);
+                g.Versions.Should().SatisfyRespectively(v => Assert.Equal(new RuntimeVersion("42.0"), v));
+                g.Architectures.Should().SatisfyRespectively(a => Assert.Equal("quantum", a));
+            });
+        }
+
+        [Fact]
+        public void CanIgnoreExistingInferRids()
+        {
+            // intentionally use same file as CanCreateRuntimeGraph, we don't want changes
+            string runtimeFile = $"{nameof(GenerateRuntimeGraphTests)}.{nameof(CanCreateRuntimeGraph)}.runtime.json";
+
+            // will generate and compare to existing file.
+            GenerateRuntimeGraph task = new GenerateRuntimeGraph()
+            {
+                BuildEngine = _engine,
+                RuntimeGroups = runtimeGroups,
+                RuntimeJson = runtimeFile,
+                AdditionalRuntimeIdentifiers = new[] { "rhel.9-x64", "centos.9-arm64", "win-x64" }
+            };
+
+            _log.Reset();
+            task.Execute();
+            _log.ErrorsLogged.Should().Be(0);
+            _log.WarningsLogged.Should().Be(0);
+        }
+
+        // a subset of the actual runtimegraph that excercises most of the functionality of the task.
+        static ITaskItem[] runtimeGroups = new[]
+        {
+            CreateRuntimeGroup("any"),
+            CreateRuntimeGroup("aot"),
+            CreateRuntimeGroup("unix", "any", "x64;x86;arm;armel;arm64;mips64"),
+            CreateRuntimeGroup("linux", "unix", "x64;x86;arm;armel;arm64;mips64"),
+            CreateRuntimeGroup("osx", "unix", "x64;arm64", "10.10;10.11;10.12;10.13;10.14;10.15;10.16;11.0"),
+            CreateRuntimeGroup("win", "any", "x64;x86;arm;arm64", "7;8;81;10", additionalQualifiers:"aot", omitVersionDelimiter:true),
+            CreateRuntimeGroup("debian", "linux", "x64;x86;arm;armel;arm64", "8;9;10", treatVersionsAsCompatible:false),
+            CreateRuntimeGroup("ubuntu", "debian", "x64;x86;arm", "14.04;14.10;15.04;15.10", treatVersionsAsCompatible:false),
+            CreateRuntimeGroup("rhel", "linux", "x64", "6"),
+            CreateRuntimeGroup("rhel", "linux", "x64", "7;7.0;7.1;7.2;7.3;7.4;7.5;7.6"),
+            CreateRuntimeGroup("rhel", "linux", "x64;arm64", "8;8.0;8.1"),
+            CreateRuntimeGroup("rhel", "linux", "x64;arm64", "9"),
+            CreateRuntimeGroup("centos", "rhel", "x64", "7", applyVersionsToParent:true, treatVersionsAsCompatible:false),
+            CreateRuntimeGroup("centos", "rhel", "x64;arm64", "8;9", applyVersionsToParent:true, treatVersionsAsCompatible:false)
+        };
+
+        private static ITaskItem CreateRuntimeGroup(string name, string parent = null, string architectures = null, string versions = null, string additionalQualifiers = null, bool applyVersionsToParent = false, bool treatVersionsAsCompatible = true, bool omitVersionDelimiter = false)
+        {
+            TaskItem item = new TaskItem(name);
+
+            if (parent != null)
+            {
+                item.SetMetadata("Parent", parent);
+            }
+
+            if (architectures != null)
+            {
+                item.SetMetadata("Architectures", architectures);
+            }
+
+            if (versions != null)
+            {
+                item.SetMetadata("Versions", versions);
+            }
+
+            if (applyVersionsToParent)
+            {
+                item.SetMetadata("ApplyVersionsToParent", applyVersionsToParent.ToString());
+            }
+
+            if (!treatVersionsAsCompatible)
+            {
+                item.SetMetadata("TreatVersionsAsCompatible", treatVersionsAsCompatible.ToString());
+            }
+
+            if (omitVersionDelimiter)
+            {
+                item.SetMetadata("OmitVersionDelimiter", omitVersionDelimiter.ToString());
+            }
+
+            if (additionalQualifiers != null)
+            {
+                item.SetMetadata("AdditionalQualifiers", additionalQualifiers);
+            }
+
+            return item;
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/Microsoft.DotNet.Build.Tasks.Packaging.Tests.csproj b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/Microsoft.DotNet.Build.Tasks.Packaging.Tests.csproj
index 59733ff36bc..63323c0d13b 100644
--- a/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/Microsoft.DotNet.Build.Tasks.Packaging.Tests.csproj
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/Microsoft.DotNet.Build.Tasks.Packaging.Tests.csproj
@@ -1,20 +1,19 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>netcoreapp3.1;net472</TargetFrameworks>
     <LangVersion>Latest</LangVersion>
-    <SignAssembly>false</SignAssembly>
     <NoWarn>xUnit2013</NoWarn>
   </PropertyGroup>
   <ItemGroup>
-    <Content Include="packageIndex.json" CopyToOutputDirectory="Always"/>
-    <Content Include="FrameworkLists\**\*" CopyToOutputDirectory="Always"/>
+    <Content Include="packageIndex.json" CopyToOutputDirectory="Always" />
+    <Content Include="FrameworkLists\**\*" CopyToOutputDirectory="Always" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\src\Microsoft.DotNet.Build.Tasks.Packaging.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Build" Version="$(MicrosoftBuildVersion)"/>
-    <PackageReference Include="Microsoft.Build.Tasks.Core" Version="$(MicrosoftBuildTasksCoreVersion)"/>
+    <PackageReference Include="Microsoft.Build" Version="$(MicrosoftBuildVersion)" />
+    <PackageReference Include="Microsoft.Build.Tasks.Core" Version="$(MicrosoftBuildTasksCoreVersion)" />
     <PackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftJsonVersion)" />
     <PackageReference Include="NuGet.Commands" Version="$(NuGetVersion)" />
     <PackageReference Include="NuGet.Packaging" Version="$(NuGetVersion)" />
@@ -38,11 +37,13 @@
   <ItemGroup>
     <_candidatPackageFolders Include="$(NuGetPackageFolders)" />
   </ItemGroup>
+  
+  <ItemGroup>
+    <None Update="*.runtime.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
 
   <!-- Find the packages from one of many package folders -->
-  <Target Name="FindTestPackages"
-          Inputs="%(_candidatPackageFolders.Identity)"
-          Outputs="unused">
+  <Target Name="FindTestPackages" Inputs="%(_candidatPackageFolders.Identity)" Outputs="unused">
     <PropertyGroup>
       <_candidatePackageFolder>%(_candidatPackageFolders.Identity)</_candidatePackageFolder>
     </PropertyGroup>
@@ -50,17 +51,14 @@
       <TestPackage>
         <Folder Condition="Exists('$(_candidatePackageFolder)\%(Identity)\%(Version)')">$(_candidatePackageFolder)\%(Identity)\%(Version)</Folder>
         <!-- NuGet will restore to lower case folder and linux is case sensitive -->
-        <Folder Condition="Exists('$(_candidatePackageFolder)\$([System.String]::new(&quot;%(Identity)\%(Version)&quot;).ToLower())')">$(_candidatePackageFolder)\$([System.String]::new(&quot;%(Identity)\%(Version)&quot;).ToLower())</Folder>
+        <Folder Condition="Exists('$(_candidatePackageFolder)\$([System.String]::new(&quot;%(Identity)\%(Version)&quot;).ToLower())')">$(_candidatePackageFolder)\$([System.String]::new("%(Identity)\%(Version)").ToLower())</Folder>
       </TestPackage>
     </ItemGroup>
   </Target>
 
   <!-- Check that we found the test packages and set up content items to copy them -->
-  <Target Name="AddTestPackageContent"
-          DependsOnTargets="FindTestPackages"
-          AfterTargets="ResolveReferences">
-     <Error Condition="'%(TestPackage.Folder)'==''"
-            Text="Could not locate package '%(TestPackage.Identity)\%(TestPackage.Version)' under any of '$(NuGetPackageFolders)'" />
+  <Target Name="AddTestPackageContent" DependsOnTargets="FindTestPackages" AfterTargets="ResolveReferences">
+     <Error Condition="'%(TestPackage.Folder)'==''" Text="Could not locate package '%(TestPackage.Identity)\%(TestPackage.Version)' under any of '$(NuGetPackageFolders)'" />
      <ItemGroup>
        <TestPackageContent Include="%(TestPackage.Folder)\**\*" LinkBase="packages\%(TestPackage.Identity)\%(TestPackage.Version)\" />
        <Content Include="@(TestPackageContent)" Link="%(TestPackageContent.LinkBase)%(RecursiveDir)%(FileName)%(Extension)" CopyToOutputDirectory="PreserveNewest" />
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/RidTests.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/RidTests.cs
new file mode 100644
index 00000000000..762309bd79a
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/RidTests.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using Xunit;
+
+namespace Microsoft.DotNet.Build.Tasks.Packaging.Tests
+{
+    public class RidTests
+    {
+        public static IEnumerable<object[]> ValidRIDData()
+        {
+            yield return new object[] { "win10-x64", new RID() { BaseRID = "win", OmitVersionDelimiter = true, Version = new RuntimeVersion("10"), Architecture = "x64" } };
+            yield return new object[] { "win10", new RID() { BaseRID = "win", OmitVersionDelimiter = true, Version = new RuntimeVersion("10")} };
+            yield return new object[] { "linux", new RID() { BaseRID = "linux" } };
+            yield return new object[] { "linux-x64", new RID() { BaseRID = "linux", Architecture = "x64" } };
+            yield return new object[] { "linux-x64", new RID() { BaseRID = "linux", Architecture = "x64" } };
+            yield return new object[] { "debian.10-x64", new RID() { BaseRID = "debian", Version = new RuntimeVersion("10"), Architecture = "x64" } };
+            yield return new object[] { "linuxmint.19.2-x64", new RID() { BaseRID = "linuxmint", Version = new RuntimeVersion("19.2"), Architecture = "x64" } };
+            yield return new object[] { "ubuntu.14.04-x64", new RID() { BaseRID = "ubuntu", Version = new RuntimeVersion("14.04"), Architecture = "x64" } };
+            yield return new object[] { "foo-bar.42-arm", new RID() { BaseRID = "foo-bar", Version = new RuntimeVersion("42"), Architecture = "arm" } };
+            yield return new object[] { "foo-bar-arm", new RID() { BaseRID = "foo", Architecture = "bar", Qualifier = "arm" } };  // demonstrates ambiguity, avoid using `-` in base
+        }
+
+        [Theory]
+        [MemberData(nameof(ValidRIDData))]
+        internal void ParseCorrectly(string input, RID expected)
+        {
+            RID actual = RID.Parse(input);
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [MemberData(nameof(ValidRIDData))]
+        internal void ToStringAsExpected(string expected, RID rid)
+        {
+            string actual = rid.ToString();
+
+            Assert.Equal(expected, actual);
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/RuntimeVersionTests.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/RuntimeVersionTests.cs
new file mode 100644
index 00000000000..579f14cf0f7
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/tests/RuntimeVersionTests.cs
@@ -0,0 +1,233 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using Xunit;
+
+namespace Microsoft.DotNet.Build.Tasks.Packaging.Tests
+{
+    public class RuntimeVersionTests
+    {
+        public enum Comparison
+        {
+            LessThan,
+            Equal,
+            GreaterThan
+        }
+
+        public static IEnumerable<object[]> ComparisonData()
+        {
+            yield return new object[] { "0.0", "00.0", Comparison.LessThan };
+            yield return new object[] { "2.0", "1.0", Comparison.GreaterThan };
+            yield return new object[] { "2", "1.0", Comparison.GreaterThan };
+            yield return new object[] { "2", "1", Comparison.GreaterThan };
+            yield return new object[] { "10", "10.0", Comparison.LessThan };
+            yield return new object[] { "10", "10.00", Comparison.LessThan };
+            yield return new object[] { "10.0", "10.0", Comparison.Equal };
+            yield return new object[] { "10.0", null, Comparison.GreaterThan };
+            yield return new object[] { "8", "8", Comparison.Equal };
+        }
+
+        [MemberData(nameof(ComparisonData))]
+        [Theory]
+        public static void CompareTo(string vs1, string vs2, Comparison expected)
+        {
+            RuntimeVersion v1 = new RuntimeVersion(vs1);
+            RuntimeVersion v2 = vs2 == null ? null : new RuntimeVersion(vs2);
+            int actual = v1.CompareTo(v2);
+            int invActual = v2?.CompareTo(v1) ?? -1;
+
+            switch (expected)
+            {
+                case Comparison.LessThan:
+                    Assert.True(actual < 0);
+                    Assert.True(invActual > 0);
+                    break;
+                case Comparison.Equal:
+                    Assert.Equal(0, actual);
+                    Assert.Equal(0, invActual);
+                    break;
+                case Comparison.GreaterThan:
+                    Assert.True(actual > 0);
+                    Assert.True(invActual < 0);
+                    break;
+            }
+        }
+
+        [MemberData(nameof(ComparisonData))]
+        [Theory]
+        public static void GreaterThan(string vs1, string vs2, Comparison expected)
+        {
+            RuntimeVersion v1 = new RuntimeVersion(vs1);
+            RuntimeVersion v2 = vs2 == null ? null : new RuntimeVersion(vs2);
+            bool actual = v1 > v2;
+            bool invActual = v2 > v1;
+
+            switch (expected)
+            {
+                case Comparison.LessThan:
+                    Assert.False(actual);
+                    Assert.True(invActual);
+                    break;
+                case Comparison.Equal:
+                    Assert.False(actual);
+                    Assert.False(invActual);
+                    break;
+                case Comparison.GreaterThan:
+                    Assert.True(actual);
+                    Assert.False(invActual);
+                    break;
+            }
+        }
+
+        [MemberData(nameof(ComparisonData))]
+        [Theory]
+        public static void GreaterThanOrEqual(string vs1, string vs2, Comparison expected)
+        {
+            RuntimeVersion v1 = new RuntimeVersion(vs1);
+            RuntimeVersion v2 = vs2 == null ? null : new RuntimeVersion(vs2);
+            bool actual = v1 >= v2;
+            bool invActual = v2 >= v1;
+
+            switch (expected)
+            {
+                case Comparison.LessThan:
+                    Assert.False(actual);
+                    Assert.True(invActual);
+                    break;
+                case Comparison.Equal:
+                    Assert.True(actual);
+                    Assert.True(invActual);
+                    break;
+                case Comparison.GreaterThan:
+                    Assert.True(actual);
+                    Assert.False(invActual);
+                    break;
+            }
+        }
+
+        [MemberData(nameof(ComparisonData))]
+        [Theory]
+        public static void LessThan(string vs1, string vs2, Comparison expected)
+        {
+            RuntimeVersion v1 = new RuntimeVersion(vs1);
+            RuntimeVersion v2 = vs2 == null ? null : new RuntimeVersion(vs2);
+            bool actual = v1 < v2;
+            bool invActual = v2 < v1;
+
+            switch (expected)
+            {
+                case Comparison.LessThan:
+                    Assert.True(actual);
+                    Assert.False(invActual);
+                    break;
+                case Comparison.Equal:
+                    Assert.False(actual);
+                    Assert.False(invActual);
+                    break;
+                case Comparison.GreaterThan:
+                    Assert.False(actual);
+                    Assert.True(invActual);
+                    break;
+            }
+        }
+
+        [MemberData(nameof(ComparisonData))]
+        [Theory]
+        public static void LessThanOrEqual(string vs1, string vs2, Comparison expected)
+        {
+            RuntimeVersion v1 = new RuntimeVersion(vs1);
+            RuntimeVersion v2 = vs2 == null ? null : new RuntimeVersion(vs2);
+            bool actual = v1 <= v2;
+            bool invActual = v2 <= v1;
+
+            switch (expected)
+            {
+                case Comparison.LessThan:
+                    Assert.True(actual);
+                    Assert.False(invActual);
+                    break;
+                case Comparison.Equal:
+                    Assert.True(actual);
+                    Assert.True(invActual);
+                    break;
+                case Comparison.GreaterThan:
+                    Assert.False(actual);
+                    Assert.True(invActual);
+                    break;
+            }
+        }
+
+        [MemberData(nameof(ComparisonData))]
+        [Theory]
+        public static void Equal(string vs1, string vs2, Comparison expected)
+        {
+            RuntimeVersion v1 = new RuntimeVersion(vs1);
+            RuntimeVersion v2 = vs2 == null ? null : new RuntimeVersion(vs2);
+            bool actual = v1 == v2;
+            bool invActual = v2 == v1;
+
+            switch (expected)
+            {
+                case Comparison.LessThan:
+                    Assert.False(actual);
+                    Assert.False(invActual);
+                    break;
+                case Comparison.Equal:
+                    Assert.True(actual);
+                    Assert.True(invActual);
+                    break;
+                case Comparison.GreaterThan:
+                    Assert.False(actual);
+                    Assert.False(invActual);
+                    break;
+            }
+        }
+
+        [MemberData(nameof(ComparisonData))]
+        [Theory]
+        public static void GetHashCodeUnique(string vs1, string vs2, Comparison expected)
+        {
+            RuntimeVersion v1 = new RuntimeVersion(vs1);
+            RuntimeVersion v2 = vs2 == null ? null : new RuntimeVersion(vs2);
+            int h1 = v1.GetHashCode();
+            int h2 = v2?.GetHashCode() ?? 0;
+
+            switch (expected)
+            {
+                case Comparison.LessThan:
+                    Assert.NotEqual(h1, h2);
+                    break;
+                case Comparison.Equal:
+                    Assert.Equal(h1, h2);
+                    break;
+                case Comparison.GreaterThan:
+                    Assert.NotEqual(h1, h2);
+                    break;
+            }
+        }
+        public static IEnumerable<object[]> ValidVersions()
+        {
+            yield return new object[] { "0" };
+            yield return new object[] { "00" };
+            yield return new object[] { "000" };
+            yield return new object[] { "1" };
+            yield return new object[] { "1.0" };
+            yield return new object[] { "1.1" };
+            yield return new object[] { "1.01" };
+            yield return new object[] { "1.2.3.4" };
+            yield return new object[] { "1.02.03.04" };
+        }
+
+
+        [MemberData(nameof(ValidVersions))]
+        [Theory]
+        public static void RoundTripToString(string expected)
+        {
+            RuntimeVersion version = new RuntimeVersion(expected);
+            string actual = version.ToString();
+            Assert.Equal(expected, actual);
+        }
+
+    }
+}