diff --git a/src/libraries/System.Text.Json/gen/Helpers/KnownTypeSymbols.cs b/src/libraries/System.Text.Json/gen/Helpers/KnownTypeSymbols.cs
index 0837c6f42f8871..a0440bfe77be6d 100644
--- a/src/libraries/System.Text.Json/gen/Helpers/KnownTypeSymbols.cs
+++ b/src/libraries/System.Text.Json/gen/Helpers/KnownTypeSymbols.cs
@@ -52,6 +52,9 @@ public KnownTypeSymbols(Compilation compilation)
         public INamedTypeSymbol? ISetOfTType => GetOrResolveType(typeof(ISet<>), ref _ISetOfTType);
         private Option<INamedTypeSymbol?> _ISetOfTType;
 
+        public INamedTypeSymbol? IReadOnlySetOfTType => GetOrResolveType("System.Collections.Generic.IReadOnlySet`1", ref _IReadOnlySetOfTType);
+        private Option<INamedTypeSymbol?> _IReadOnlySetOfTType;
+
         public INamedTypeSymbol? StackOfTType => GetOrResolveType(typeof(Stack<>), ref _StackOfTType);
         private Option<INamedTypeSymbol?> _StackOfTType;
 
diff --git a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs
index cefc1c51e2f5ca..953fd9ed3d77af 100644
--- a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs
+++ b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs
@@ -1514,7 +1514,7 @@ private static string GetCollectionInfoMethodName(CollectionType collectionType)
                     CollectionType.MemoryOfT => "CreateMemoryInfo",
                     CollectionType.ReadOnlyMemoryOfT => "CreateReadOnlyMemoryInfo",
                     CollectionType.ISet => "CreateISetInfo",
-
+                    CollectionType.IReadOnlySetOfT => "CreateIReadOnlySetInfo",
                     CollectionType.Dictionary => "CreateDictionaryInfo",
                     CollectionType.IDictionaryOfTKeyTValue or CollectionType.IDictionary => "CreateIDictionaryInfo",
                     CollectionType.IReadOnlyDictionary => "CreateIReadOnlyDictionaryInfo",
diff --git a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs
index fc64ef50b766f3..1b0959368fb193 100644
--- a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs
+++ b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs
@@ -846,6 +846,11 @@ private bool TryResolveCollectionType(
                     collectionType = CollectionType.ISet;
                     valueType = actualTypeToConvert.TypeArguments[0];
                 }
+                else if ((actualTypeToConvert = type.GetCompatibleGenericBaseType(_knownSymbols.IReadOnlySetOfTType)) != null)
+                {
+                    collectionType = CollectionType.IReadOnlySetOfT;
+                    valueType = actualTypeToConvert.TypeArguments[0];
+                }
                 else if ((actualTypeToConvert = type.GetCompatibleGenericBaseType(_knownSymbols.ICollectionOfTType)) != null)
                 {
                     collectionType = CollectionType.ICollectionOfT;
diff --git a/src/libraries/System.Text.Json/gen/Model/CollectionType.cs b/src/libraries/System.Text.Json/gen/Model/CollectionType.cs
index 7692e0973bb296..e2bb8d8d0837fa 100644
--- a/src/libraries/System.Text.Json/gen/Model/CollectionType.cs
+++ b/src/libraries/System.Text.Json/gen/Model/CollectionType.cs
@@ -30,6 +30,7 @@ public enum CollectionType
         Queue,
         ImmutableEnumerable,
         MemoryOfT,
-        ReadOnlyMemoryOfT
+        ReadOnlyMemoryOfT,
+        IReadOnlySetOfT
     }
 }
diff --git a/src/libraries/System.Text.Json/ref/System.Text.Json.cs b/src/libraries/System.Text.Json/ref/System.Text.Json.cs
index cea226f6fadf40..13702e69741d95 100644
--- a/src/libraries/System.Text.Json/ref/System.Text.Json.cs
+++ b/src/libraries/System.Text.Json/ref/System.Text.Json.cs
@@ -1344,6 +1344,11 @@ public static partial class JsonMetadataServices
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateImmutableEnumerableInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo, System.Func<System.Collections.Generic.IEnumerable<TElement>, TCollection> createRangeFunc) where TCollection : System.Collections.Generic.IEnumerable<TElement> { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateIReadOnlyDictionaryInfo<TCollection, TKey, TValue>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> where TKey : notnull { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateISetInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.ISet<TElement> { throw null; }
+
+#if NET
+        public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateIReadOnlySetInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.IReadOnlySet<TElement> { throw null; }
+#endif
+
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateListInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.List<TElement> { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<System.Memory<TElement>> CreateMemoryInfo<TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<System.Memory<TElement>> collectionInfo) { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<T> CreateObjectInfo<T>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonObjectInfoValues<T> objectInfo) where T : notnull { throw null; }
diff --git a/src/libraries/System.Text.Json/src/System.Text.Json.csproj b/src/libraries/System.Text.Json/src/System.Text.Json.csproj
index e8106e1f215008..befb39824c0210 100644
--- a/src/libraries/System.Text.Json/src/System.Text.Json.csproj
+++ b/src/libraries/System.Text.Json/src/System.Text.Json.csproj
@@ -388,6 +388,7 @@ The System.Text.Json library is built-in as part of the shared framework in .NET
     <Compile Include="System\Text\Json\Serialization\Converters\Value\TimeOnlyConverter.cs" />
     <Compile Include="System\Text\Json\Serialization\Converters\Value\UInt128Converter.cs" />
     <Compile Include="System\Text\Json\Serialization\JsonSerializerOptionsUpdateHandler.cs" />
+    <Compile Include="System\Text\Json\Serialization\Converters\Collection\IReadOnlySetOfTConverter.cs" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs
index 59b2591152955e..0b9b62442f0670 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs
@@ -108,6 +108,14 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer
                 converterType = typeof(ISetOfTConverter<,>);
                 elementType = actualTypeToConvert.GetGenericArguments()[0];
             }
+#if NET
+            // IReadOnlySet<>
+            else if ((actualTypeToConvert = typeToConvert.GetCompatibleGenericInterface(typeof(IReadOnlySet<>))) != null)
+            {
+                converterType = typeof(IReadOnlySetOfTConverter<,>);
+                elementType = actualTypeToConvert.GetGenericArguments()[0];
+            }
+#endif
             // ICollection<>
             else if ((actualTypeToConvert = typeToConvert.GetCompatibleGenericInterface(typeof(ICollection<>))) != null)
             {
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IReadOnlySetOfTConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IReadOnlySetOfTConverter.cs
new file mode 100644
index 00000000000000..ae8ea4e487af93
--- /dev/null
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IReadOnlySetOfTConverter.cs
@@ -0,0 +1,47 @@
+// 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 System.Diagnostics;
+using System.Text.Json.Serialization.Metadata;
+
+namespace System.Text.Json.Serialization.Converters
+{
+    internal sealed class IReadOnlySetOfTConverter<TCollection, TElement>
+        : IEnumerableDefaultConverter<TCollection, TElement>
+        where TCollection : IReadOnlySet<TElement>
+    {
+        private readonly bool _isDeserializable = typeof(TCollection).IsAssignableFrom(typeof(HashSet<TElement>));
+
+        protected override void Add(in TElement value, ref ReadStack state)
+        {
+            // Directly convert to HashSet<TElement> since IReadOnlySet<T> does not have an Add method.
+            HashSet<TElement> collection = (HashSet<TElement>)state.Current.ReturnValue!;
+            collection.Add(value);
+            if (IsValueType)
+            {
+                state.Current.ReturnValue = collection;
+            }
+        }
+
+        protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref ReadStack state, JsonSerializerOptions options)
+        {
+            if (!_isDeserializable)
+            {
+                ThrowHelper.ThrowNotSupportedException_CannotPopulateCollection(Type, ref reader, ref state);
+            }
+
+            state.Current.ReturnValue = new HashSet<TElement>();
+        }
+
+        internal override void ConfigureJsonTypeInfo(JsonTypeInfo jsonTypeInfo, JsonSerializerOptions options)
+        {
+            // Deserialize as HashSet<TElement> for interface types that support it.
+            if (jsonTypeInfo.CreateObject is null && Type.IsAssignableFrom(typeof(HashSet<TElement>)))
+            {
+                Debug.Assert(Type.IsInterface);
+                jsonTypeInfo.CreateObject = () => new HashSet<TElement>();
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs
index 4ab1eca5b1a5d8..0d8e3fbdf85f89 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterFactory.cs
@@ -43,7 +43,7 @@ internal JsonConverter GetConverterInternal(Type typeToConvert, JsonSerializerOp
                     ThrowHelper.ThrowInvalidOperationException_SerializerConverterFactoryReturnsNull(GetType());
                     break;
                 case JsonConverterFactory:
-                    ThrowHelper.ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactorty(GetType());
+                    ThrowHelper.ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactory(GetType());
                     break;
             }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.Collections.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.Collections.cs
index 6e423c6ff7357f..68304fa84133a2 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.Collections.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.Collections.cs
@@ -211,6 +211,26 @@ public static JsonTypeInfo<TCollection> CreateISetInfo<TCollection, TElement>(
                 collectionInfo,
                 new ISetOfTConverter<TCollection, TElement>());
 
+#if NET
+        /// <summary>
+        /// Creates serialization metadata for types assignable to <see cref="IReadOnlySet{T}"/>.
+        /// </summary>
+        /// <typeparam name="TCollection">The generic definition of the type.</typeparam>
+        /// <typeparam name="TElement">The generic definition of the element type.</typeparam>
+        /// <param name="options"></param>
+        /// <param name="collectionInfo">Provides serialization metadata about the collection type.</param>
+        /// <returns>Serialization metadata for the given type.</returns>
+        /// <remarks>This API is for use by the output of the System.Text.Json source generator and should not be called directly.</remarks>
+        public static JsonTypeInfo<TCollection> CreateIReadOnlySetInfo<TCollection, TElement>(
+            JsonSerializerOptions options,
+            JsonCollectionInfoValues<TCollection> collectionInfo)
+            where TCollection : IReadOnlySet<TElement>
+            => CreateCore(
+                options,
+                collectionInfo,
+                new IReadOnlySetOfTConverter<TCollection, TElement>());
+#endif
+
         /// <summary>
         /// Creates serialization metadata for types assignable to <see cref="ICollection{T}"/>.
         /// </summary>
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
index 3292e7602c94b1..80b2acc9f25b4e 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
@@ -376,7 +376,7 @@ public static void ThrowInvalidOperationException_SerializerConverterFactoryRetu
         }
 
         [DoesNotReturn]
-        public static void ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactorty(Type converterType)
+        public static void ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactory(Type converterType)
         {
             throw new InvalidOperationException(SR.Format(SR.SerializerConverterFactoryReturnsJsonConverterFactory, converterType));
         }
diff --git a/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Read.cs b/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Read.cs
index d02db100547dbd..94d1aa56df64a3 100644
--- a/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Read.cs
+++ b/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Read.cs
@@ -687,6 +687,86 @@ public async Task ReadSimpleISetT()
             Assert.Equal(0, result.Count());
         }
 
+#if NET
+        [Fact]
+        public async Task ReadNullableGenericStructIReadOnlySetWithNullJson()
+        {
+            var wrapper = await Serializer.DeserializeWrapper<GenericStructIReadOnlySetWrapper<int>?>("null");
+            Assert.False(wrapper.HasValue);
+        }
+
+        [Fact]
+        public async Task ReadIReadOnlySetTOfHashSetT()
+        {
+            IReadOnlySet<HashSet<int>> result = await Serializer.DeserializeWrapper<IReadOnlySet<HashSet<int>>>(@"[[1,2],[3,4]]");
+
+            if (result.First().Contains(1))
+            {
+                AssertExtensions.Equal(new HashSet<int> { 1, 2 }, result.First());
+                AssertExtensions.Equal(new HashSet<int> { 3, 4 }, result.Last());
+            }
+            else
+            {
+                AssertExtensions.Equal(new HashSet<int> { 3, 4 }, result.First());
+                AssertExtensions.Equal(new HashSet<int> { 1, 2 }, result.Last());
+            }
+        }
+
+        [Fact]
+        public async Task ReadHashSetTOfIReadOnlySetT()
+        {
+            HashSet<IReadOnlySet<int>> result = await Serializer.DeserializeWrapper<HashSet<IReadOnlySet<int>>>(@"[[1,2],[3,4]]");
+
+            if (result.First().Contains(1))
+            {
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.First());
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.Last());
+            }
+            else
+            {
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.First());
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.Last());
+            }
+        }
+
+        [Fact]
+        public async Task ReadIReadOnlySetTOfArray()
+        {
+            IReadOnlySet<int[]> result = await Serializer.DeserializeWrapper<IReadOnlySet<int[]>>(@"[[1,2],[3,4]]");
+
+            if (result.First().Contains(1))
+            {
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.First());
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.Last());
+            }
+            else
+            {
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.First());
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.Last());
+            }
+        }
+
+        [Fact]
+        public async Task ReadArrayOfIReadOnlySetT()
+        {
+            IReadOnlySet<int>[] result = await Serializer.DeserializeWrapper<IReadOnlySet<int>[]>(@"[[1,2],[3,4]]");
+
+            Assert.Equal(new HashSet<int> { 1, 2 }, result.First());
+            Assert.Equal(new HashSet<int> { 3, 4 }, result.Last());
+        }
+
+        [Fact]
+        public async Task ReadSimpleIReadOnlySetT()
+        {
+            IReadOnlySet<int> result = await Serializer.DeserializeWrapper<IReadOnlySet<int>>(@"[1,2]");
+
+            Assert.Equal(new HashSet<int> { 1, 2 }, result);
+
+            result = await Serializer.DeserializeWrapper<IReadOnlySet<int>>(@"[]");
+            Assert.Equal(0, result.Count());
+        }
+#endif
+
         [Fact]
         public async Task StackTOfStackT()
         {
@@ -1136,6 +1216,15 @@ public static IEnumerable<object[]> ReadSimpleTestClass_GenericWrappers_NoAddMet
                     SimpleTestClassWithStringToStringIReadOnlyDictionaryWrapper.s_json,
                     typeof(GenericIReadOnlyDictionaryWrapper<string, string>)
                 };
+
+#if NET
+                yield return new object[]
+                {
+                    typeof(SimpleTestClassWithStringIReadOnlySetWrapper),
+                    SimpleTestClassWithStringIReadOnlySetWrapper.s_json,
+                    typeof(WrapperForIReadOnlySetOfT<string>)
+                };
+#endif
             }
         }
 
@@ -1173,6 +1262,12 @@ public async Task Read_HigherOrderCollectionInheritance_Works()
         [InlineData(typeof(GenericIListWrapperInternalConstructor<string>), @"[""1""]")]
         [InlineData(typeof(GenericISetWrapperPrivateConstructor<string>), @"[""1""]")]
         [InlineData(typeof(GenericISetWrapperInternalConstructor<string>), @"[""1""]")]
+
+#if NET
+        [InlineData(typeof(GenericIReadOnlySetWrapperPrivateConstructor<string>), @"[""1""]")]
+        [InlineData(typeof(GenericIReadOnlySetWrapperInternalConstructor<string>), @"[""1""]")]
+#endif
+
         [InlineData(typeof(GenericIDictionaryWrapperPrivateConstructor<string, string>), @"{""Key"":""Value""}")]
         [InlineData(typeof(GenericIDictionaryWrapperInternalConstructor<string, string>), @"{""Key"":""Value""}")]
         [InlineData(typeof(StringToStringIReadOnlyDictionaryWrapperPrivateConstructor), @"{""Key"":""Value""}")]
@@ -1271,6 +1366,11 @@ public static IEnumerable<object[]> CustomInterfaces_Enumerables()
             yield return new object[] { typeof(IDerivedICollectionOfT<string>) };
             yield return new object[] { typeof(IDerivedIList) };
             yield return new object[] { typeof(IDerivedISetOfT<string>) };
+
+#if NET
+            yield return new object[] { typeof(IDerivedIReadOnlySetOfT<string>) };
+#endif
+
         }
 
         public static IEnumerable<object[]> CustomInterfaces_Dictionaries()
diff --git a/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Write.cs b/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Write.cs
index aa0a740819d8ea..f3fbfb39c71a61 100644
--- a/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Write.cs
+++ b/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Write.cs
@@ -523,6 +523,112 @@ public async Task WritePrimitiveISetT()
             Assert.True(json == "[1,2]" || json == "[2,1]");
         }
 
+#if NET
+        [Fact]
+        public async Task GenericStructIReadOnlySetWrapperT()
+        {
+            {
+                GenericStructISetWrapper<int> obj = new GenericStructISetWrapper<int>() { 10, 20 };
+                Assert.Equal("[10,20]", await Serializer.SerializeWrapper(obj));
+            }
+
+            {
+                GenericStructISetWrapper<int> obj = default;
+                Assert.Equal("[]", await Serializer.SerializeWrapper(obj));
+            }
+        }
+
+        [Fact]
+        public async Task WriteIReadOnlySetTOfHashSetT()
+        {
+            IReadOnlySet<HashSet<int>> input = new HashSet<HashSet<int>>
+            {
+                new HashSet<int>() { 1, 2 },
+                new HashSet<int>() { 3, 4 }
+            };
+
+            string json = await Serializer.SerializeWrapper(input);
+
+            // Because order isn't guaranteed, roundtrip data to ensure write was accurate.
+            input = await Serializer.DeserializeWrapper<IReadOnlySet<HashSet<int>>>(json);
+
+            if (input.First().Contains(1))
+            {
+                AssertExtensions.Equal(new HashSet<int> { 1, 2 }, input.First());
+                AssertExtensions.Equal(new HashSet<int> { 3, 4 }, input.Last());
+            }
+            else
+            {
+                AssertExtensions.Equal(new HashSet<int> { 3, 4 }, input.First());
+                AssertExtensions.Equal(new HashSet<int> { 1, 2 }, input.Last());
+            }
+        }
+
+        [Fact]
+        public async Task WriteHashSetTOfIReadOnlySet()
+        {
+            HashSet<IReadOnlySet<int>> input = new HashSet<IReadOnlySet<int>>
+            {
+                new HashSet<int>() { 1, 2 },
+                new HashSet<int>() { 3, 4 }
+            };
+
+            string json = await Serializer.SerializeWrapper(input);
+
+            // Because order isn't guaranteed, roundtrip data to ensure write was accurate.
+            input = await Serializer.DeserializeWrapper<HashSet<IReadOnlySet<int>>>(json);
+
+            if (input.First().Contains(1))
+            {
+                Assert.Equal(new HashSet<int> { 1, 2 }, input.First());
+                Assert.Equal(new HashSet<int> { 3, 4 }, input.Last());
+            }
+            else
+            {
+                Assert.Equal(new HashSet<int> { 3, 4 }, input.First());
+                Assert.Equal(new HashSet<int> { 1, 2 }, input.Last());
+            }
+        }
+
+        [Fact]
+        public async Task WriteIReadOnlySetTOfArray()
+        {
+            IReadOnlySet<int[]> input = new HashSet<int[]>
+            {
+                new int[] { 1, 2 },
+                new int[] { 3, 4 }
+            };
+
+            string json = await Serializer.SerializeWrapper(input);
+            Assert.Contains("[1,2]", json);
+            Assert.Contains("[3,4]", json);
+        }
+
+        [Fact]
+        public async Task WriteArrayOfIReadOnlySet()
+        {
+            IReadOnlySet<int>[] input = new HashSet<int>[2];
+            input[0] = new HashSet<int>() { 1, 2 };
+            input[1] = new HashSet<int>() { 3, 4 };
+
+            string json = await Serializer.SerializeWrapper(input);
+
+            // Because order isn't guaranteed, roundtrip data to ensure write was accurate.
+            input = await Serializer.DeserializeWrapper<IReadOnlySet<int>[]>(json);
+            Assert.Equal(new HashSet<int> { 1, 2 }, input.First());
+            Assert.Equal(new HashSet<int> { 3, 4 }, input.Last());
+        }
+
+        [Fact]
+        public async Task WritePrimitiveIReadOnlySet()
+        {
+            IReadOnlySet<int> input = new HashSet<int> { 1, 2 };
+
+            string json = await Serializer.SerializeWrapper(input);
+            Assert.True(json == "[1,2]" || json == "[2,1]");
+        }
+#endif
+
         [Fact]
         public async Task WriteStackTOfStackT()
         {
@@ -802,12 +908,18 @@ public async Task WriteGenericCollectionWrappers()
             SimpleTestClassWithStringIReadOnlyCollectionWrapper obj3 = new SimpleTestClassWithStringIReadOnlyCollectionWrapper();
             SimpleTestClassWithStringIReadOnlyListWrapper obj4 = new SimpleTestClassWithStringIReadOnlyListWrapper();
             SimpleTestClassWithStringToStringIReadOnlyDictionaryWrapper obj5 = new SimpleTestClassWithStringToStringIReadOnlyDictionaryWrapper();
+#if NET
+            SimpleTestClassWithStringIReadOnlySetWrapper obj6 = new SimpleTestClassWithStringIReadOnlySetWrapper();
+#endif
 
             obj1.Initialize();
             obj2.Initialize();
             obj3.Initialize();
             obj4.Initialize();
             obj5.Initialize();
+#if NET
+            obj6.Initialize();
+#endif
 
             Assert.Equal(SimpleTestClassWithGenericCollectionWrappers.s_json.StripWhitespace(), await Serializer.SerializeWrapper(obj1));
             Assert.Equal(SimpleTestClassWithGenericCollectionWrappers.s_json.StripWhitespace(), await Serializer.SerializeWrapper<object>(obj1));
@@ -823,6 +935,11 @@ public async Task WriteGenericCollectionWrappers()
 
             Assert.Equal(SimpleTestClassWithStringToStringIReadOnlyDictionaryWrapper.s_json.StripWhitespace(), await Serializer.SerializeWrapper(obj5));
             Assert.Equal(SimpleTestClassWithStringToStringIReadOnlyDictionaryWrapper.s_json.StripWhitespace(), await Serializer.SerializeWrapper<object>(obj5));
+
+#if NET
+            Assert.Equal(SimpleTestClassWithStringIReadOnlySetWrapper.s_json.StripWhitespace(), await Serializer.SerializeWrapper(obj6));
+            Assert.Equal(SimpleTestClassWithStringIReadOnlySetWrapper.s_json.StripWhitespace(), await Serializer.SerializeWrapper<object>(obj6));
+#endif
         }
 
         [Fact]
@@ -957,6 +1074,20 @@ public async Task WriteISetT_DisposesEnumerators()
             }
         }
 
+#if NET
+        [Fact]
+        public async Task WriteIReadOnlySetT_DisposesEnumerators()
+        {
+            for (int count = 0; count < 5; count++)
+            {
+                var items = new RefCountedSet<int>(Enumerable.Range(1, count));
+                _ = await Serializer.SerializeWrapper((IReadOnlySet<int>)items);
+
+                Assert.Equal(0, items.RefCount);
+            }
+        }
+#endif
+
         [Fact]
         public async Task WriteIEnumerableT_ElementSerializationThrows_DisposesEnumerators()
         {
diff --git a/src/libraries/System.Text.Json/tests/Common/JsonCreationHandlingTests.Generic.cs b/src/libraries/System.Text.Json/tests/Common/JsonCreationHandlingTests.Generic.cs
index b02cece0945ed6..3b63c20af6f4e9 100644
--- a/src/libraries/System.Text.Json/tests/Common/JsonCreationHandlingTests.Generic.cs
+++ b/src/libraries/System.Text.Json/tests/Common/JsonCreationHandlingTests.Generic.cs
@@ -260,6 +260,86 @@ public void Validate()
         }
     }
 
+#if NET
+    internal struct StructReadOnlySet<T> : IReadOnlySet<T>
+    {
+        private HashSet<T> _set = new HashSet<T>();
+
+        // we track count separately to make sure tests are not passing by accident because we use reference to list inside of struct
+        private int _count;
+
+        public int Count => _count;
+
+        public StructReadOnlySet() { }
+
+        /// <remarks>
+        /// This method is used to initialize the HashSet because IReadOnlySet<T> does not have an Add method.
+        /// We use this instead of a constructor to allow for parameterless construction, which is important for some tests.
+        /// </remarks>
+        public StructReadOnlySet<T> Initialize(HashSet<T> items)
+        {
+            foreach (T item in items)
+            {
+                _set.Add(item);
+                _count++;
+            }
+
+            return this;
+        }
+
+        public bool Contains(T item)
+        {
+            return _set.Contains(item);
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return ((IReadOnlySet<T>)_set).GetEnumerator();
+        }
+
+        public bool IsProperSubsetOf(IEnumerable<T> other)
+        {
+            return _set.IsProperSubsetOf(other);
+        }
+
+        public bool IsProperSupersetOf(IEnumerable<T> other)
+        {
+            return _set.IsProperSupersetOf(other);
+        }
+
+        public bool IsSubsetOf(IEnumerable<T> other)
+        {
+            return _set.IsSubsetOf(other);
+        }
+
+        public bool IsSupersetOf(IEnumerable<T> other)
+        {
+            return _set.IsSupersetOf(other);
+        }
+
+        public bool Overlaps(IEnumerable<T> other)
+        {
+            return _set.Overlaps(other);
+        }
+
+        public bool SetEquals(IEnumerable<T> other)
+        {
+            return _set.SetEquals(other);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IReadOnlySet<T>)_set).GetEnumerator();
+        }
+
+        public void Validate()
+        {
+            // This can fail only if we modified a copy of this struct
+            Assert.Equal(_count, _set.Count);
+        }
+    }
+#endif
+
     internal struct StructDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary
     {
         private Dictionary<TKey, TValue> _dict = new();
diff --git a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.GenericCollections.cs b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.GenericCollections.cs
index 92ea12e8089455..8c3e658559f251 100644
--- a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.GenericCollections.cs
+++ b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.GenericCollections.cs
@@ -114,6 +114,26 @@ public void Initialize()
         }
     }
 
+#if NET
+    public class SimpleTestClassWithStringIReadOnlySetWrapper
+    {
+        public WrapperForIReadOnlySetOfT<string> MyStringIReadOnlySetWrapper { get; set; }
+
+        public static readonly string s_json =
+            @"{" +
+            @"""MyStringIReadOnlySetWrapper"" : [""Hello""]" +
+            @"}";
+
+        public static readonly byte[] s_data = Encoding.UTF8.GetBytes(s_json);
+
+        // Call only when testing serialization.
+        public void Initialize()
+        {
+            MyStringIReadOnlySetWrapper = new WrapperForIReadOnlySetOfT<string>(new HashSet<string> { "Hello" });
+        }
+    }
+#endif
+
     public class SimpleTestClassWithStringIReadOnlyListWrapper
     {
         public StringIReadOnlyListWrapper MyStringIReadOnlyListWrapper { get; set; }
@@ -438,6 +458,70 @@ IEnumerator IEnumerable.GetEnumerator()
         }
     }
 
+#if NET
+    public class WrapperForIReadOnlySetOfT<T> : IReadOnlySet<T>
+    {
+        private readonly HashSet<T> _hashset;
+
+        public WrapperForIReadOnlySetOfT()
+        {
+            _hashset = new HashSet<T>();
+        }
+
+        public WrapperForIReadOnlySetOfT(IEnumerable<T> items)
+        {
+            _hashset = new HashSet<T>(items);
+        }
+
+        public int Count => _hashset.Count;
+
+        public bool Contains(T item)
+        {
+            return _hashset.Contains(item);
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return ((IReadOnlySet<T>)_hashset).GetEnumerator();
+        }
+
+        public bool IsProperSubsetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsProperSubsetOf(other);
+        }
+
+        public bool IsProperSupersetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsProperSupersetOf(other);
+        }
+
+        public bool IsSubsetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsSubsetOf(other);
+        }
+
+        public bool IsSupersetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsSupersetOf(other);
+        }
+
+        public bool Overlaps(IEnumerable<T> other)
+        {
+            return _hashset.Overlaps(other);
+        }
+
+        public bool SetEquals(IEnumerable<T> other)
+        {
+            return _hashset.SetEquals(other);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IReadOnlySet<T>)_hashset).GetEnumerator();
+        }
+    }
+#endif
+
     public class GenericIReadOnlyCollectionWrapper<T> : IReadOnlyCollection<T>
     {
         private readonly List<T> _list = new List<T>();
@@ -727,6 +811,146 @@ public class GenericISetWrapperInternalConstructor<T> : GenericISetWrapper<T>
         internal GenericISetWrapperInternalConstructor() { }
     }
 
+#if NET
+    public class StringIReadOnlySetWrapper : IReadOnlySet<string>
+    {
+        private readonly HashSet<string> _hashset = new HashSet<string>();
+        public int Count => _hashset.Count;
+
+        /// <remarks>
+        /// This method is used to initialize the HashSet because IReadOnlySet<T> does not have an Add method.
+        /// We use this instead of a constructor to allow for parameterless construction, which is important for some tests.
+        /// </remarks>
+        public StringIReadOnlySetWrapper Initialize(HashSet<string> items)
+        {
+            foreach (string item in items)
+            {
+                _hashset.Add(item);
+            }
+
+            return this;
+        }
+        public bool Contains(string item)
+        {
+            return _hashset.Contains(item);
+        }
+        public IEnumerator<string> GetEnumerator()
+        {
+            return ((IReadOnlySet<string>)_hashset).GetEnumerator();
+        }
+
+        public bool IsProperSubsetOf(IEnumerable<string> other)
+        {
+            return _hashset.IsProperSubsetOf(other);
+        }
+
+        public bool IsProperSupersetOf(IEnumerable<string> other)
+        {
+            return _hashset.IsProperSupersetOf(other);
+        }
+
+        public bool IsSubsetOf(IEnumerable<string> other)
+        {
+            return _hashset.IsSubsetOf(other);
+        }
+
+        public bool IsSupersetOf(IEnumerable<string> other)
+        {
+            return _hashset.IsSupersetOf(other);
+        }
+
+        public bool Overlaps(IEnumerable<string> other)
+        {
+            return _hashset.Overlaps(other);
+        }
+        public bool SetEquals(IEnumerable<string> other)
+        {
+            return _hashset.SetEquals(other);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IReadOnlySet<string>)_hashset).GetEnumerator();
+        }
+    }
+
+    public class GenericIReadOnlySetWrapper<T> : IReadOnlySet<T>
+    {
+        private readonly HashSet<T> _hashset = new HashSet<T>();
+
+        public int Count => _hashset.Count;
+
+        /// <remarks>
+        /// This method is used to initialize the HashSet because IReadOnlySet<T> does not have an Add method.
+        /// We use this instead of a constructor to allow for parameterless construction, which is important for some tests.
+        /// </remarks>
+        public GenericIReadOnlySetWrapper<T> Initialize(HashSet<T> items)
+        {
+            foreach (T item in items)
+            {
+                _hashset.Add(item);
+            }
+
+            return this;
+        }
+
+        public bool Contains(T item)
+        {
+            return _hashset.Contains(item);
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return ((IReadOnlySet<T>)_hashset).GetEnumerator();
+        }
+
+        public bool IsProperSubsetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsProperSubsetOf(other);
+        }
+
+        public bool IsProperSupersetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsProperSupersetOf(other);
+        }
+
+        public bool IsSubsetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsSubsetOf(other);
+        }
+
+        public bool IsSupersetOf(IEnumerable<T> other)
+        {
+            return _hashset.IsSupersetOf(other);
+        }
+
+        public bool Overlaps(IEnumerable<T> other)
+        {
+            return _hashset.Overlaps(other);
+        }
+
+        public bool SetEquals(IEnumerable<T> other)
+        {
+            return _hashset.SetEquals(other);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IReadOnlySet<T>)_hashset).GetEnumerator();
+        }
+    }
+
+    public class GenericIReadOnlySetWrapperPrivateConstructor<T> : GenericIReadOnlySetWrapper<T>
+    {
+        private GenericIReadOnlySetWrapperPrivateConstructor() { }
+    }
+
+    public class GenericIReadOnlySetWrapperInternalConstructor<T> : GenericIReadOnlySetWrapper<T>
+    {
+        internal GenericIReadOnlySetWrapperInternalConstructor() { }
+    }
+#endif
+
     public class GenericIDictionaryWrapper<TKey, TValue> : IDictionary<TKey, TValue>
     {
         private readonly Dictionary<TKey, TValue> _dict;
@@ -1175,6 +1399,10 @@ public interface IDerivedIDictionaryOfTKeyTValue<TKey, TValue> : IDictionary<TKe
 
     public interface IDerivedISetOfT<T> : ISet<T> { }
 
+#if NET
+    public interface IDerivedIReadOnlySetOfT<T> : IReadOnlySet<T> { }
+#endif
+
     public struct GenericStructIListWrapper<T> : IList<T>
     {
         private List<T> _list;
@@ -1449,6 +1677,89 @@ IEnumerator IEnumerable.GetEnumerator()
         }
     }
 
+#if NET
+    public struct GenericStructIReadOnlySetWrapper<T> : IReadOnlySet<T>
+    {
+        private HashSet<T> _hashset;
+
+        /// <remarks>
+        /// This method is used to initialize the HashSet because IReadOnlySet<T> does not have an Add method.
+        /// We use this instead of a constructor to allow for parameterless construction, which is important for some tests.
+        /// </remarks>
+        public GenericStructIReadOnlySetWrapper<T> Initialize(HashSet<T> items)
+        {
+            InitializeIfNull();
+            foreach (T item in items)
+            {
+                _hashset.Add(item);
+            }
+
+            return this;
+        }
+
+        private void InitializeIfNull()
+        {
+            if (_hashset == null)
+            {
+                _hashset = new HashSet<T>();
+            }
+        }
+
+        public int Count => _hashset == null ? 0 : _hashset.Count;
+
+        public bool Contains(T item)
+        {
+            InitializeIfNull();
+            return _hashset.Contains(item);
+        }
+        public IEnumerator<T> GetEnumerator()
+        {
+            InitializeIfNull();
+            return ((ISet<T>)_hashset).GetEnumerator();
+        }
+
+        public bool IsProperSubsetOf(IEnumerable<T> other)
+        {
+            InitializeIfNull();
+            return _hashset.IsProperSubsetOf(other);
+        }
+
+        public bool IsProperSupersetOf(IEnumerable<T> other)
+        {
+            InitializeIfNull();
+            return _hashset.IsProperSupersetOf(other);
+        }
+
+        public bool IsSubsetOf(IEnumerable<T> other)
+        {
+            InitializeIfNull();
+            return _hashset.IsSubsetOf(other);
+        }
+
+        public bool IsSupersetOf(IEnumerable<T> other)
+        {
+            InitializeIfNull();
+            return _hashset.IsSupersetOf(other);
+        }
+
+        public bool Overlaps(IEnumerable<T> other)
+        {
+            InitializeIfNull();
+            return _hashset.Overlaps(other);
+        }
+        public bool SetEquals(IEnumerable<T> other)
+        {
+            InitializeIfNull();
+            return _hashset.SetEquals(other);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            InitializeIfNull();
+            return ((ISet<T>)_hashset).GetEnumerator();
+        }
+    }
+#endif
     public struct GenericStructIDictionaryWrapper<TKey, TValue> : IDictionary<TKey, TValue>
     {
         private Dictionary<TKey, TValue> _dict;
diff --git a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.Polymorphic.cs b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.Polymorphic.cs
index f4f2394d12b09e..b53d1d61b18149 100644
--- a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.Polymorphic.cs
+++ b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.Polymorphic.cs
@@ -136,6 +136,7 @@ public class ObjectWithObjectProperties
         public object? /*IReadOnlyCollection<string>*/ IReadOnlyCollectionT { get; set; }
         public object? /*IReadOnlyList<string>*/ IReadOnlyListT { get; set; }
         public object? /*ISet<string>*/ ISetT { get; set; }
+        public object? /*IReadOnlySet<string>*/ IReadOnlySetT { get; set; }
         public object? /*Stack<string>*/ StackT { get; set; }
         public object? /*Queue<string>*/ QueueT { get; set; }
         public object? /*HashSet<string>*/ HashSetT { get; set; }
@@ -171,6 +172,7 @@ public ObjectWithObjectProperties()
             IReadOnlyCollectionT = new List<string> { "Hello", "World" };
             IReadOnlyListT = new List<string> { "Hello", "World" };
             ISetT = new HashSet<string> { "Hello", "World" };
+            IReadOnlySetT = new HashSet<string> { "Hello", "World" };
             StackT = new Stack<string>(new List<string> { "Hello", "World" });
             QueueT = new Queue<string>(new List<string> { "Hello", "World" });
             HashSetT = new HashSet<string>(new List<string> { "Hello", "World" });
diff --git a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.cs b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.cs
index e77d766398b8b8..9b16ef6ea52d44 100644
--- a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.cs
+++ b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestClasses.cs
@@ -685,6 +685,42 @@ public void Verify()
         }
     }
 
+#if NET
+    public class TestClassWithObjectIReadOnlySetT : ITestClass
+    {
+        public IReadOnlySet<SimpleTestClass> MyData { get; set; }
+
+        public static readonly byte[] s_data = Encoding.UTF8.GetBytes(
+            @"{" +
+                @"""MyData"":[" +
+                    SimpleTestClass.s_json + "," +
+                    SimpleTestClass.s_json +
+                @"]" +
+            @"}");
+
+        public void Initialize()
+        {
+            SimpleTestClass obj1 = new SimpleTestClass();
+            obj1.Initialize();
+
+            SimpleTestClass obj2 = new SimpleTestClass();
+            obj2.Initialize();
+
+            MyData = new HashSet<SimpleTestClass> { obj1, obj2 };
+        }
+
+        public void Verify()
+        {
+            Assert.Equal(2, MyData.Count);
+
+            foreach (SimpleTestClass obj in MyData)
+            {
+                obj.Verify();
+            }
+        }
+    }
+#endif
+
     public class TestClassWithInitializedArray
     {
         public int[] Values { get; set; }
@@ -1117,6 +1153,53 @@ public void Verify()
         }
     }
 
+#if NET
+    public class TestClassWithGenericIReadOnlySetT : ITestClass
+    {
+        public IReadOnlySet<string> MyData { get; set; }
+
+        public static readonly byte[] s_data = Encoding.UTF8.GetBytes(
+            @"{" +
+                @"""MyData"":[" +
+                    @"""Hello""," +
+                    @"""World""" +
+                @"]" +
+            @"}");
+
+        public void Initialize()
+        {
+            MyData = new HashSet<string>
+            {
+                "Hello",
+                "World"
+            };
+            Assert.Equal(2, MyData.Count);
+        }
+
+        public void Verify()
+        {
+            Assert.Equal(2, MyData.Count);
+
+            bool helloSeen = false;
+            bool worldSeen = false;
+
+            foreach (string data in MyData)
+            {
+                if (data == "Hello")
+                {
+                    helloSeen = true;
+                }
+                else if (data == "World")
+                {
+                    worldSeen = true;
+                }
+            }
+
+            Assert.True(helloSeen && worldSeen);
+        }
+    }
+#endif
+
     public class TestClassWithStringToPrimitiveDictionary : ITestClass
     {
         public Dictionary<string, int> MyInt32Dict { get; set; }
diff --git a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestData.cs b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestData.cs
index 1228d1171a1c03..6df6e80e905953 100644
--- a/src/libraries/System.Text.Json/tests/Common/TestClasses/TestData.cs
+++ b/src/libraries/System.Text.Json/tests/Common/TestClasses/TestData.cs
@@ -33,6 +33,11 @@ public static IEnumerable<object[]> ReadSuccessCases
                 yield return new object[] { typeof(TestClassWithObjectIReadOnlyCollectionT), TestClassWithObjectIReadOnlyCollectionT.s_data };
                 yield return new object[] { typeof(TestClassWithObjectIReadOnlyListT), TestClassWithObjectIReadOnlyListT.s_data };
                 yield return new object[] { typeof(TestClassWithObjectISetT), TestClassWithObjectISetT.s_data };
+
+#if NET
+                yield return new object[] { typeof(TestClassWithObjectIReadOnlySetT), TestClassWithObjectIReadOnlySetT.s_data };
+#endif
+
                 yield return new object[] { typeof(TestClassWithStringArray), TestClassWithStringArray.s_data };
                 yield return new object[] { typeof(TestClassWithGenericList), TestClassWithGenericList.s_data };
                 yield return new object[] { typeof(TestClassWithGenericIEnumerable), TestClassWithGenericIEnumerable.s_data };
@@ -44,6 +49,11 @@ public static IEnumerable<object[]> ReadSuccessCases
                 yield return new object[] { typeof(TestClassWithGenericIReadOnlyCollectionT), TestClassWithGenericIReadOnlyCollectionT.s_data };
                 yield return new object[] { typeof(TestClassWithGenericIReadOnlyListT), TestClassWithGenericIReadOnlyListT.s_data };
                 yield return new object[] { typeof(TestClassWithGenericISetT), TestClassWithGenericISetT.s_data };
+
+#if NET
+                yield return new object[] { typeof(TestClassWithGenericIReadOnlySetT), TestClassWithGenericIReadOnlySetT.s_data };
+#endif
+
                 yield return new object[] { typeof(TestClassWithStringToPrimitiveDictionary), TestClassWithStringToPrimitiveDictionary.s_data };
                 yield return new object[] { typeof(TestClassWithObjectIEnumerableConstructibleTypes), TestClassWithObjectIEnumerableConstructibleTypes.s_data };
                 yield return new object[] { typeof(TestClassWithObjectImmutableTypes), TestClassWithObjectImmutableTypes.s_data };
@@ -79,6 +89,11 @@ public static IEnumerable<object[]> WriteSuccessCases
                 yield return new object[] { new TestClassWithObjectIReadOnlyCollectionT() };
                 yield return new object[] { new TestClassWithObjectIReadOnlyListT() };
                 yield return new object[] { new TestClassWithObjectISetT() };
+
+#if NET
+                yield return new object[] { new TestClassWithObjectIReadOnlySetT() };
+#endif
+
                 yield return new object[] { new TestClassWithStringArray() };
                 yield return new object[] { new TestClassWithGenericList() };
                 yield return new object[] { new TestClassWithGenericIEnumerable() };
@@ -90,6 +105,11 @@ public static IEnumerable<object[]> WriteSuccessCases
                 yield return new object[] { new TestClassWithGenericIReadOnlyCollectionT() };
                 yield return new object[] { new TestClassWithGenericIReadOnlyListT() };
                 yield return new object[] { new TestClassWithGenericISetT() };
+
+#if NET
+                yield return new object[] { new TestClassWithGenericIReadOnlySetT() };
+#endif
+
                 yield return new object[] { new TestClassWithStringToPrimitiveDictionary() };
                 yield return new object[] { new TestClassWithObjectIEnumerableConstructibleTypes() };
                 yield return new object[] { new TestClassWithObjectImmutableTypes() };
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/CollectionTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/CollectionTests.cs
index cb88437b6b552a..5a8d6a81e91092 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/CollectionTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/CollectionTests.cs
@@ -204,6 +204,19 @@ public async Task DeserializeAsyncEnumerable()
         [JsonSerializable(typeof(ISet<int[]>))]
         [JsonSerializable(typeof(ISet<int>[]), TypeInfoPropertyName = "ArrayOfIntISet")]
         [JsonSerializable(typeof(ISet<int>))]
+
+#if NET
+        [JsonSerializable(typeof(IReadOnlySet<IReadOnlySet<int>>))]
+        [JsonSerializable(typeof(GenericIReadOnlySetWrapper<StringIReadOnlySetWrapper>))]
+        [JsonSerializable(typeof(GenericStructIReadOnlySetWrapper<int>))]
+        [JsonSerializable(typeof(GenericStructIReadOnlySetWrapper<int>?))]
+        [JsonSerializable(typeof(IReadOnlySet<HashSet<int>>))]
+        [JsonSerializable(typeof(HashSet<IReadOnlySet<int>>))]
+        [JsonSerializable(typeof(IReadOnlySet<int[]>))]
+        [JsonSerializable(typeof(IReadOnlySet<int>[]), TypeInfoPropertyName = "ArrayOfIntIReadOnlySet")]
+        [JsonSerializable(typeof(IReadOnlySet<int>))]
+#endif
+
         [JsonSerializable(typeof(Stack<Stack<int>>))]
         [JsonSerializable(typeof(GenericStackWrapper<StringStackWrapper>))]
         [JsonSerializable(typeof(Stack<int[]>))]
@@ -401,6 +414,12 @@ public async Task DeserializeAsyncEnumerable()
         [JsonSerializable(typeof(GenericIListWrapperInternalConstructor<string>))]
         [JsonSerializable(typeof(GenericISetWrapperPrivateConstructor<string>))]
         [JsonSerializable(typeof(GenericISetWrapperInternalConstructor<string>))]
+
+#if NET
+        [JsonSerializable(typeof(GenericIReadOnlySetWrapperPrivateConstructor<string>))]
+        [JsonSerializable(typeof(GenericIReadOnlySetWrapperInternalConstructor<string>))]
+#endif
+
         [JsonSerializable(typeof(GenericIDictionaryWrapperPrivateConstructor<string, string>))]
         [JsonSerializable(typeof(GenericIDictionaryWrapperInternalConstructor<string, string>))]
         [JsonSerializable(typeof(StringToStringIReadOnlyDictionaryWrapperPrivateConstructor))]
@@ -641,6 +660,19 @@ public CollectionTests_Default()
         [JsonSerializable(typeof(ISet<int[]>))]
         [JsonSerializable(typeof(ISet<int>[]), TypeInfoPropertyName = "ArrayOfIntISet")]
         [JsonSerializable(typeof(ISet<int>))]
+
+#if NET
+        [JsonSerializable(typeof(IReadOnlySet<IReadOnlySet<int>>))]
+        [JsonSerializable(typeof(GenericIReadOnlySetWrapper<StringIReadOnlySetWrapper>))]
+        [JsonSerializable(typeof(GenericStructIReadOnlySetWrapper<int>))]
+        [JsonSerializable(typeof(GenericStructIReadOnlySetWrapper<int>?))]
+        [JsonSerializable(typeof(IReadOnlySet<HashSet<int>>))]
+        [JsonSerializable(typeof(HashSet<IReadOnlySet<int>>))]
+        [JsonSerializable(typeof(IReadOnlySet<int[]>))]
+        [JsonSerializable(typeof(IReadOnlySet<int>[]), TypeInfoPropertyName = "ArrayOfIntIReadOnlySet")]
+        [JsonSerializable(typeof(IReadOnlySet<int>))]
+#endif
+
         [JsonSerializable(typeof(Stack<Stack<int>>))]
         [JsonSerializable(typeof(GenericStackWrapper<StringStackWrapper>))]
         [JsonSerializable(typeof(Stack<int[]>))]
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/JsonCreationHandlingTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/JsonCreationHandlingTests.cs
index 5862387200f6a4..95d77fc1f6c492 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/JsonCreationHandlingTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/JsonCreationHandlingTests.cs
@@ -118,6 +118,9 @@ public sealed class JsonCreationHandlingTests_AsyncStreamWithSmallBuffer()
     [JsonSerializable(typeof(ClassWithReadOnlyPropertyISetOfInt_BackedBy_StructSetOfIntWithNumberHandling))]
     [JsonSerializable(typeof(ClassWithReadOnlyPropertyISetOfInt_BackedBy_StructSetOfIntWithNumberHandlingWithAttributeOnType))]
     [JsonSerializable(typeof(ClassWithReadOnlyPropertyISetOfInt_BackedBy_StructSetOfIntWithNumberHandlingWithoutPopulateAttribute))]
+    // TODO: Should these cases also be tested (L121 - L129) for IReadOnlySet?
+    // This goes for here, and JsonCreationHandlingTests.Enumerable.cs as well.
+    // The tests ABOVE these tests in JsonCreationHandlingTests.Enumerable.cs are for ISet, which I thought are more relevant, so I didn't add them here yet.
     [JsonSerializable(typeof(StructWithWritablePropertyStructSetOfInt))]
     [JsonSerializable(typeof(StructWithWritablePropertyStructSetOfIntWithAttributeOnType))]
     [JsonSerializable(typeof(StructWithWritablePropertyStructSetOfIntWithoutPopulateAttribute))]
@@ -127,7 +130,6 @@ public sealed class JsonCreationHandlingTests_AsyncStreamWithSmallBuffer()
     [JsonSerializable(typeof(StructWithWritableFieldNullableStructSetOfInt))]
     [JsonSerializable(typeof(StructWithWritableFieldNullableStructSetOfIntWithAttributeOnType))]
     [JsonSerializable(typeof(StructWithWritableFieldNullableStructSetOfIntWithoutPopulateAttribute))]
-
     [JsonSerializable(typeof(ClassWithReadOnlyPropertyDictionaryOfStringToInt))]
     [JsonSerializable(typeof(ClassWithReadOnlyPropertyDictionaryOfStringToIntWithAttributeOnType))]
     [JsonSerializable(typeof(ClassWithReadOnlyPropertyDictionaryOfStringToIntWithoutPopulateAttribute))]
@@ -222,6 +224,11 @@ public sealed class JsonCreationHandlingTests_AsyncStreamWithSmallBuffer()
     [JsonSerializable(typeof(ClassWithWritableProperty<ConcurrentStack<int>>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<ICollection<int>>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<ISet<int>>))]
+
+#if NET
+    [JsonSerializable(typeof(ClassWithWritableProperty<IReadOnlySet<int>>))]
+#endif
+
     [JsonSerializable(typeof(ClassWithWritableProperty<Dictionary<string, int>>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<IDictionary<string, int>>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<IDictionary>))]
@@ -230,6 +237,11 @@ public sealed class JsonCreationHandlingTests_AsyncStreamWithSmallBuffer()
     [JsonSerializable(typeof(ClassWithWritableProperty<StructList<int>?>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<StructCollection<int>?>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<StructSet<int>?>))]
+
+#if NET
+    [JsonSerializable(typeof(ClassWithWritableProperty<StructReadOnlySet<int>?>))]
+#endif
+
     [JsonSerializable(typeof(ClassWithWritableProperty<StructDictionary<string, int>?>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<Stack<int>>))]
     [JsonSerializable(typeof(ClassWithWritableProperty<Stack>))]
@@ -248,6 +260,11 @@ public sealed class JsonCreationHandlingTests_AsyncStreamWithSmallBuffer()
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<ConcurrentStack<int>>))]
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<ICollection<int>>))]
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<ISet<int>>))]
+
+#if NET
+    [JsonSerializable(typeof(ClassWithReadOnlyProperty<IReadOnlySet<int>>))]
+#endif
+
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<Dictionary<string, int>>))]
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<IDictionary<string, int>>))]
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<IDictionary>))]
@@ -259,9 +276,14 @@ public sealed class JsonCreationHandlingTests_AsyncStreamWithSmallBuffer()
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<StructCollection<int>?>))]
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<StructSet<int>>))]
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<StructSet<int>?>))]
+
+#if NET
+    [JsonSerializable(typeof(ClassWithReadOnlyProperty<StructReadOnlySet<int>>))]
+    [JsonSerializable(typeof(ClassWithReadOnlyProperty<StructReadOnlySet<int>?>))]
+#endif
+
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<StructDictionary<string, int>>))]
     [JsonSerializable(typeof(ClassWithReadOnlyProperty<StructDictionary<string, int>?>))]
-
     [JsonSerializable(typeof(ClassWithReadOnlyInitializedField<SimpleClass>))]
     [JsonSerializable(typeof(ClassWithInitializedField<SimpleClass>))]
     [JsonSerializable(typeof(ClassWithReadOnlyInitializedProperty<SimpleClass>))]
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs
index 36cb8c42f4efda..20c2aae7fa3b8c 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs
@@ -100,6 +100,11 @@ public ReferenceHandlerTests_Metadata(JsonSerializerWrapper serializer)
         [JsonSerializable(typeof(TestClassWithObjectIReadOnlyCollectionT))]
         [JsonSerializable(typeof(TestClassWithObjectIReadOnlyListT))]
         [JsonSerializable(typeof(TestClassWithObjectISetT))]
+
+#if NET
+        [JsonSerializable(typeof(TestClassWithObjectIReadOnlySetT))]
+#endif
+
         [JsonSerializable(typeof(TestClassWithStringArray))]
         [JsonSerializable(typeof(TestClassWithGenericList))]
         [JsonSerializable(typeof(TestClassWithGenericIEnumerable))]
@@ -111,6 +116,11 @@ public ReferenceHandlerTests_Metadata(JsonSerializerWrapper serializer)
         [JsonSerializable(typeof(TestClassWithGenericIReadOnlyCollectionT))]
         [JsonSerializable(typeof(TestClassWithGenericIReadOnlyListT))]
         [JsonSerializable(typeof(TestClassWithGenericISetT))]
+
+#if NET
+        [JsonSerializable(typeof(TestClassWithGenericIReadOnlySetT))]
+#endif
+
         [JsonSerializable(typeof(TestClassWithStringToPrimitiveDictionary))]
         [JsonSerializable(typeof(TestClassWithObjectIEnumerableConstructibleTypes))]
         [JsonSerializable(typeof(TestClassWithObjectImmutableTypes))]
@@ -247,6 +257,11 @@ public ReferenceHandlerTests_Default(JsonSerializerWrapper serializer)
         [JsonSerializable(typeof(TestClassWithObjectIReadOnlyCollectionT))]
         [JsonSerializable(typeof(TestClassWithObjectIReadOnlyListT))]
         [JsonSerializable(typeof(TestClassWithObjectISetT))]
+
+#if NET
+        [JsonSerializable(typeof(TestClassWithObjectIReadOnlySetT))]
+#endif
+
         [JsonSerializable(typeof(TestClassWithStringArray))]
         [JsonSerializable(typeof(TestClassWithGenericList))]
         [JsonSerializable(typeof(TestClassWithGenericIEnumerable))]
@@ -258,6 +273,11 @@ public ReferenceHandlerTests_Default(JsonSerializerWrapper serializer)
         [JsonSerializable(typeof(TestClassWithGenericIReadOnlyCollectionT))]
         [JsonSerializable(typeof(TestClassWithGenericIReadOnlyListT))]
         [JsonSerializable(typeof(TestClassWithGenericISetT))]
+
+#if NET
+        [JsonSerializable(typeof(TestClassWithGenericIReadOnlySetT))]
+#endif
+
         [JsonSerializable(typeof(TestClassWithStringToPrimitiveDictionary))]
         [JsonSerializable(typeof(TestClassWithObjectIEnumerableConstructibleTypes))]
         [JsonSerializable(typeof(TestClassWithObjectImmutableTypes))]
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/NewtonsoftTests/ImmutableCollectionsTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/NewtonsoftTests/ImmutableCollectionsTests.cs
index c0c0900468191f..2100b128ed84db 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/NewtonsoftTests/ImmutableCollectionsTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/NewtonsoftTests/ImmutableCollectionsTests.cs
@@ -292,6 +292,25 @@ public void DeserializeHashSetInterface()
             Assert.True(data.Contains("II"));
             Assert.True(data.Contains("One"));
         }
+
+#if NET
+        [Fact]
+        public void DeserializeIReadOnlySetInterface()
+        {
+            string json = @"[
+                              ""One"",
+                              ""II"",
+                              ""3""
+                            ]";
+
+            IReadOnlySet<string> data = JsonSerializer.Deserialize<IReadOnlySet<string>>(json);
+
+            Assert.Equal(3, data.Count);
+            Assert.True(data.Contains("3"));
+            Assert.True(data.Contains("II"));
+            Assert.True(data.Contains("One"));
+        }
+#endif
         #endregion
 
         #region SortedSet
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Array.ReadTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Array.ReadTests.cs
index d06465de159395..0ca339a486f3e1 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Array.ReadTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Array.ReadTests.cs
@@ -370,6 +370,15 @@ public static void ReadClassWithObjectISetT()
             obj.Verify();
         }
 
+#if NET
+        [Fact]
+        public static void ReadClassWithObjectIReadOnlySetT()
+        {
+            TestClassWithObjectIReadOnlySetT obj = JsonSerializer.Deserialize<TestClassWithObjectIReadOnlySetT>(TestClassWithObjectIReadOnlySetT.s_data);
+            obj.Verify();
+        }
+#endif
+
         [Fact]
         public static void ReadClassWithGenericIEnumerableT()
         {
@@ -412,6 +421,15 @@ public static void ReadClassWithGenericISetT()
             obj.Verify();
         }
 
+#if NET
+        [Fact]
+        public static void ReadClassWithGenericIReadOnlySetT()
+        {
+            TestClassWithGenericIReadOnlySetT obj = JsonSerializer.Deserialize<TestClassWithGenericIReadOnlySetT>(TestClassWithGenericIReadOnlySetT.s_data);
+            obj.Verify();
+        }
+#endif
+
         [Fact]
         public static void ReadClassWithObjectIEnumerableConstructibleTypes()
         {
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Null.WriteTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Null.WriteTests.cs
index 7de51c9146c54f..5a2b82bb6f4e4a 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Null.WriteTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Null.WriteTests.cs
@@ -141,6 +141,7 @@ public static void NullReferences()
             obj.StackT = null;
             obj.QueueT = null;
             obj.HashSetT = null;
+            obj.IReadOnlySetT = null;
             obj.LinkedListT = null;
             obj.SortedSetT = null;
             obj.NullableInt = null;
@@ -159,6 +160,7 @@ public static void NullReferences()
             Assert.Contains(@"""StackT"":null", json);
             Assert.Contains(@"""QueueT"":null", json);
             Assert.Contains(@"""HashSetT"":null", json);
+            Assert.Contains(@"""IReadOnlySetT"":null", json);
             Assert.Contains(@"""LinkedListT"":null", json);
             Assert.Contains(@"""SortedSetT"":null", json);
             Assert.Contains(@"""NullableInt"":null", json);
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs
index 33707fb41c0eca..b4f657e4dfac44 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs
@@ -358,6 +358,7 @@ void Verify(string json)
                 Assert.Contains(@"""IReadOnlyCollectionT"":[""Hello"",""World""]", json);
                 Assert.Contains(@"""IReadOnlyListT"":[""Hello"",""World""]", json);
                 Assert.Contains(@"""ISetT"":[""Hello"",""World""]", json);
+                Assert.Contains(@"""IReadOnlySetT"":[""Hello"",""World""]", json);
                 Assert.Contains(@"""StackT"":[""World"",""Hello""]", json);
                 Assert.Contains(@"""QueueT"":[""Hello"",""World""]", json);
                 Assert.Contains(@"""HashSetT"":[""Hello"",""World""]", json);