diff --git a/docs/tools/illink/data-formats.md b/docs/tools/illink/data-formats.md
index 06490e3e3308d9..7756d91728c440 100644
--- a/docs/tools/illink/data-formats.md
+++ b/docs/tools/illink/data-formats.md
@@ -253,6 +253,21 @@ Entire method body is replaces with `throw` instruction when method is reference
 </linker>
 ```
 
+### Throw PlatformNotSupportedException
+
+
+Entire method body is replaces with `throw new PlatformNotSupportedException()` instruction when method is referenced.
+
+```xml
+<linker>
+  <assembly fullname="Assembly">
+    <type fullname="Assembly.A">
+      <method signature="System.String TestMethod()" body="pnse" />
+    </type>
+  </assembly>
+</linker>
+```
+
 ### Remove embedded resources
 
 ```xml
diff --git a/src/libraries/System.Threading/src/System.Threading.csproj b/src/libraries/System.Threading/src/System.Threading.csproj
index e09ac58c61c410..613c3a16dace2a 100644
--- a/src/libraries/System.Threading/src/System.Threading.csproj
+++ b/src/libraries/System.Threading/src/System.Threading.csproj
@@ -8,6 +8,7 @@
     <UseCompilerGeneratedDocXmlFile>false</UseCompilerGeneratedDocXmlFile>
     <FeatureWasmManagedThreads Condition="'$(WasmEnableThreads)' == 'true'">true</FeatureWasmManagedThreads>
     <DefineConstants Condition="'$(FeatureWasmManagedThreads)' == 'true'">$(DefineConstants);FEATURE_WASM_MANAGED_THREADS</DefineConstants>
+    <_ExtraTrimmerArgs Condition="'$(TargetsBrowser)' == 'true'">$(_ExtraTrimmerArgs) --target-os browser</_ExtraTrimmerArgs>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/libraries/sfx-finish.proj b/src/libraries/sfx-finish.proj
index 742bafb20541d6..4cf2dcee7eedd5 100644
--- a/src/libraries/sfx-finish.proj
+++ b/src/libraries/sfx-finish.proj
@@ -127,6 +127,7 @@
       <!-- update debug symbols -->
       <SharedFrameworkILLinkArgs>$(SharedFrameworkILLinkArgs) -b true</SharedFrameworkILLinkArgs>
       <SharedFrameworkILLinkArgs Condition="'@(SharedFrameworkSuppressionsXml)' != ''" >$(SharedFrameworkILLinkArgs) --link-attributes "@(SharedFrameworkSuppressionsXml, '" --link-attributes "')"</SharedFrameworkILLinkArgs>
+      <SharedFrameworkILLinkArgs Condition="'$(TargetsBrowser)' == 'true'">$(SharedFrameworkILLinkArgs) --target-os browser</SharedFrameworkILLinkArgs>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/src/tools/illink/src/ILLink.Shared/TypeSystemProxy/WellKnownType.cs b/src/tools/illink/src/ILLink.Shared/TypeSystemProxy/WellKnownType.cs
index 9b4d435f9d5731..ab8b19d3d74247 100644
--- a/src/tools/illink/src/ILLink.Shared/TypeSystemProxy/WellKnownType.cs
+++ b/src/tools/illink/src/ILLink.Shared/TypeSystemProxy/WellKnownType.cs
@@ -19,6 +19,7 @@ public enum WellKnownType
         System_Object,
         System_Attribute,
         System_NotSupportedException,
+        System_PlatformNotSupportedException,
         System_Runtime_CompilerServices_DisablePrivateReflectionAttribute,
         System_Void
     }
@@ -37,6 +38,7 @@ public static (string Namespace, string Name) GetNamespaceAndName(this WellKnown
                 WellKnownType.System_Object => ("System", "Object"),
                 WellKnownType.System_Attribute => ("System", "Attribute"),
                 WellKnownType.System_NotSupportedException => ("System", "NotSupportedException"),
+                WellKnownType.System_PlatformNotSupportedException => ("System", "PlatformNotSupportedException"),
                 WellKnownType.System_Runtime_CompilerServices_DisablePrivateReflectionAttribute => ("System.Runtime.CompilerServices", "DisablePrivateReflectionAttribute"),
                 WellKnownType.System_Void => ("System", "Void"),
                 _ => throw new System.ArgumentException(type.ToString())
@@ -57,6 +59,7 @@ public static (string Namespace, string Name) GetNamespaceAndName(this WellKnown
                     "Attribute" => WellKnownType.System_Attribute,
                     "Object" => WellKnownType.System_Object,
                     "NotSupportedException" => WellKnownType.System_NotSupportedException,
+                    "PlatformNotSupportedException" => WellKnownType.System_PlatformNotSupportedException,
                     "Void" => WellKnownType.System_Void,
                     _ => null
                 },
diff --git a/src/tools/illink/src/ILLink.Tasks/build/Microsoft.NET.ILLink.targets b/src/tools/illink/src/ILLink.Tasks/build/Microsoft.NET.ILLink.targets
index 16198390f88f7b..7c7bb02e9660ec 100644
--- a/src/tools/illink/src/ILLink.Tasks/build/Microsoft.NET.ILLink.targets
+++ b/src/tools/illink/src/ILLink.Tasks/build/Microsoft.NET.ILLink.targets
@@ -90,6 +90,10 @@ Copyright (c) .NET Foundation. All rights reserved.
     <NoWarn>$(NoWarn);IL2121</NoWarn>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(TargetsBrowser)' == 'true'">
+    <_ExtraTrimmerArgs>$(_ExtraTrimmerArgs) --target-os browser</_ExtraTrimmerArgs>
+  </PropertyGroup>
+
   <!--
     ============================================================
                      ILLink
diff --git a/src/tools/illink/src/linker/CompatibilitySuppressions.xml b/src/tools/illink/src/linker/CompatibilitySuppressions.xml
index 1834d95fe9f446..b59f80794022ce 100644
--- a/src/tools/illink/src/linker/CompatibilitySuppressions.xml
+++ b/src/tools/illink/src/linker/CompatibilitySuppressions.xml
@@ -637,6 +637,10 @@
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>F:Mono.Linker.LinkContext.PInvokesListFile</Target>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>F:Mono.Linker.MethodAction.ConvertToPNSE</Target>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>F:Mono.Linker.MessageCategory.WarningAsError</Target>
@@ -989,6 +993,10 @@
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Mono.Linker.LinkContext.get_IgnoreLinkAttributes</Target>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Mono.Linker.LinkContext.get_TargetOS</Target>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Mono.Linker.LinkContext.get_IgnoreSubstitutions</Target>
@@ -1301,6 +1309,10 @@
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Mono.Linker.LinkContext.set_IgnoreLinkAttributes(System.Boolean)</Target>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Mono.Linker.LinkContext.set_TargetOS(System.String)</Target>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Mono.Linker.LinkContext.set_IgnoreSubstitutions(System.Boolean)</Target>
diff --git a/src/tools/illink/src/linker/Linker.Steps/BodySubstitutionParser.cs b/src/tools/illink/src/linker/Linker.Steps/BodySubstitutionParser.cs
index cd66e40bbed111..942aa9e0cb39f3 100644
--- a/src/tools/illink/src/linker/Linker.Steps/BodySubstitutionParser.cs
+++ b/src/tools/illink/src/linker/Linker.Steps/BodySubstitutionParser.cs
@@ -68,6 +68,9 @@ protected override void ProcessMethod(TypeDefinition type, XPathNavigator method
                 case "remove":
                     _substitutionInfo.SetMethodAction(method, MethodAction.ConvertToThrow);
                     return;
+                case "pnse":
+                    _substitutionInfo.SetMethodAction(method, MethodAction.ConvertToPNSE);
+                    return;
                 case "stub":
                     string value = GetAttribute(methodNav, "value");
                     if (!string.IsNullOrEmpty(value))
diff --git a/src/tools/illink/src/linker/Linker.Steps/CheckSuppressionsStep.cs b/src/tools/illink/src/linker/Linker.Steps/CheckSuppressionsStep.cs
index 6245aff4d7a605..e2828f301afe06 100644
--- a/src/tools/illink/src/linker/Linker.Steps/CheckSuppressionsStep.cs
+++ b/src/tools/illink/src/linker/Linker.Steps/CheckSuppressionsStep.cs
@@ -40,7 +40,8 @@ public override void ProcessField(FieldDefinition field)
 
         public override void ProcessMethod(MethodDefinition method)
         {
-            if (Context.Annotations.GetAction(method) != MethodAction.ConvertToThrow)
+            if (Context.Annotations.GetAction(method) != MethodAction.ConvertToThrow
+                && Context.Annotations.GetAction(method) != MethodAction.ConvertToPNSE)
                 Context.Suppressions.GatherSuppressions(method);
         }
 
diff --git a/src/tools/illink/src/linker/Linker.Steps/CodeRewriterStep.cs b/src/tools/illink/src/linker/Linker.Steps/CodeRewriterStep.cs
index 7938f488fbc321..0011421c1f0734 100644
--- a/src/tools/illink/src/linker/Linker.Steps/CodeRewriterStep.cs
+++ b/src/tools/illink/src/linker/Linker.Steps/CodeRewriterStep.cs
@@ -54,6 +54,9 @@ void ProcessMethod(MethodDefinition method)
                 case MethodAction.ConvertToThrow:
                     RewriteBodyToLinkedAway(method);
                     break;
+                case MethodAction.ConvertToPNSE:
+                    RewriteBodyToPNSE(method);
+                    break;
             }
         }
 
@@ -67,6 +70,16 @@ protected virtual void RewriteBodyToLinkedAway(MethodDefinition method)
             method.ClearDebugInformation();
         }
 
+        protected virtual void RewriteBodyToPNSE(MethodDefinition method)
+        {
+            method.ImplAttributes &= ~(MethodImplAttributes.AggressiveInlining | MethodImplAttributes.Synchronized);
+            method.ImplAttributes |= MethodImplAttributes.NoInlining;
+
+            method.Body = CreateThrowPNSEBody(method);
+
+            method.ClearDebugInformation();
+        }
+
         protected virtual void RewriteBodyToStub(MethodDefinition method)
         {
             if (!method.IsIL)
@@ -103,6 +116,31 @@ MethodBody CreateThrowLinkedAwayBody(MethodDefinition method)
             return body;
         }
 
+        MethodBody CreateThrowPNSEBody(MethodDefinition method)
+        {
+            var body = new MethodBody(method);
+            var il = body.GetLinkerILProcessor();
+            MethodReference? ctor;
+
+            // Makes the body verifiable
+            if (method.IsConstructor && !method.DeclaringType.IsValueType)
+            {
+                ctor = Assembly.MainModule.ImportReference(Context.MarkedKnownMembers.ObjectCtor);
+
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(OpCodes.Call, ctor);
+            }
+
+            // import the method into the current assembly
+            ctor = Context.MarkedKnownMembers.PlatformNotSupportedExceptionCtor;
+            ctor = Assembly.MainModule.ImportReference(ctor);
+
+            il.Emit(OpCodes.Newobj, ctor);
+            il.Emit(OpCodes.Throw);
+
+            return body;
+        }
+
         MethodBody CreateStubBody(MethodDefinition method)
         {
             var body = new MethodBody(method);
diff --git a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs
index 11058cae769996..8d3c4bce04d481 100644
--- a/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs
+++ b/src/tools/illink/src/linker/Linker.Steps/MarkStep.cs
@@ -3350,6 +3350,9 @@ protected virtual void ProcessMethod(MethodDefinition method, in DependencyInfo
 #endif
             var methodOrigin = new MessageOrigin(method);
 
+            // Check for [UnsupportedOSPlatform] early to potentially skip body scanning
+            TryMarkMethodForUnsupportedPlatform(method);
+
             bool markedForCall =
                 reason.Kind == DependencyKind.DirectCall ||
                 reason.Kind == DependencyKind.VirtualCall ||
@@ -3582,7 +3585,71 @@ void MarkNewCodeDependencies(MethodDefinition method, MessageOrigin origin)
                 case MethodAction.ConvertToThrow:
                     MarkAndCacheConvertToThrowExceptionCtor(new DependencyInfo(DependencyKind.UnreachableBodyRequirement, method), origin);
                     break;
+
+                case MethodAction.ConvertToPNSE:
+                    MarkAndCacheConvertToThrowPNSECtor(new DependencyInfo(DependencyKind.UnreachableBodyRequirement, method), origin);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the method has [UnsupportedOSPlatform] attribute matching the target OS
+        /// and marks it for PNSE conversion if so.
+        /// </summary>
+        /// <returns>True if the method was marked for PNSE conversion.</returns>
+        bool TryMarkMethodForUnsupportedPlatform(MethodDefinition method)
+        {
+            if (Context.TargetOS is null)
+                return false;
+
+            // Check method-level attributes
+            if (HasMatchingUnsupportedOSPlatformAttribute(method))
+            {
+                Annotations.SetAction(method, MethodAction.ConvertToPNSE);
+                return true;
             }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Checks if the property has [UnsupportedOSPlatform] attribute matching the target OS
+        /// and marks its getter/setter for PNSE conversion if so.
+        /// </summary>
+        void TryMarkPropertyForUnsupportedPlatform(PropertyDefinition property)
+        {
+            if (Context.TargetOS is null)
+                return;
+
+            if (!HasMatchingUnsupportedOSPlatformAttribute(property))
+                return;
+
+            if (property.GetMethod is not null)
+                Annotations.SetAction(property.GetMethod, MethodAction.ConvertToPNSE);
+
+            if (property.SetMethod is not null)
+                Annotations.SetAction(property.SetMethod, MethodAction.ConvertToPNSE);
+        }
+
+        /// <summary>
+        /// Checks if the provider has [UnsupportedOSPlatform] attribute matching the target OS.
+        /// </summary>
+        bool HasMatchingUnsupportedOSPlatformAttribute(ICustomAttributeProvider provider)
+        {
+            if (!provider.HasCustomAttributes)
+                return false;
+
+            foreach (var attribute in Context.CustomAttributes.GetCustomAttributes(provider, "System.Runtime.Versioning", "UnsupportedOSPlatformAttribute"))
+            {
+                if (attribute.ConstructorArguments.Count > 0 &&
+                    attribute.ConstructorArguments[0].Value is string platformName &&
+                    string.Equals(platformName, Context.TargetOS, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+
+            return false;
         }
 
         protected virtual void MarkAndCacheConvertToThrowExceptionCtor(DependencyInfo reason, MessageOrigin origin)
@@ -3611,6 +3678,32 @@ protected virtual void MarkAndCacheConvertToThrowExceptionCtor(DependencyInfo re
                     throw new LinkerFatalErrorException(MessageContainer.CreateErrorMessage(null, DiagnosticId.CouldNotFindConstructor, objectType.GetDisplayName()));
         }
 
+        protected virtual void MarkAndCacheConvertToThrowPNSECtor(DependencyInfo reason, MessageOrigin origin)
+        {
+            if (Context.MarkedKnownMembers.PlatformNotSupportedExceptionCtor != null)
+                return;
+
+            var pnse = BCL.FindPredefinedType(WellKnownType.System_PlatformNotSupportedException, Context);
+            if (pnse == null)
+                throw new LinkerFatalErrorException(MessageContainer.CreateErrorMessage(null, DiagnosticId.CouldNotFindType, "System.PlatformNotSupportedException"));
+
+            MarkType(pnse, reason, origin);
+
+            var pnseCtor = MarkMethodIf(pnse.Methods, KnownMembers.IsPlatformNotSupportedExceptionCtor, reason, origin);
+            Context.MarkedKnownMembers.PlatformNotSupportedExceptionCtor = pnseCtor ??
+                throw new LinkerFatalErrorException(MessageContainer.CreateErrorMessage(null, DiagnosticId.CouldNotFindConstructor, pnse.GetDisplayName()));
+
+            var objectType = BCL.FindPredefinedType(WellKnownType.System_Object, Context);
+            if (objectType == null)
+                throw new NotSupportedException("Missing predefined 'System.Object' type");
+
+            MarkType(objectType, reason, origin);
+
+            var objectCtor = MarkMethodIf(objectType.Methods, MethodDefinitionExtensions.IsDefaultConstructor, reason, origin);
+            Context.MarkedKnownMembers.ObjectCtor = objectCtor ??
+                    throw new LinkerFatalErrorException(MessageContainer.CreateErrorMessage(null, DiagnosticId.CouldNotFindConstructor, objectType.GetDisplayName()));
+        }
+
         bool MarkDisablePrivateReflectionAttribute()
         {
             if (Context.MarkedKnownMembers.DisablePrivateReflectionAttributeCtor != null)
@@ -3743,6 +3836,11 @@ protected virtual bool ShouldParseMethodBody(MethodDefinition method)
                         default:
                             return false;
                     }
+                // Skip body scanning for methods that will be stubbed - their bodies will be replaced
+                case MethodAction.ConvertToStub:
+                case MethodAction.ConvertToThrow:
+                case MethodAction.ConvertToPNSE:
+                    return false;
                 default:
                     return false;
             }
@@ -3755,6 +3853,9 @@ protected internal void MarkProperty(PropertyDefinition prop, in DependencyInfo
 
             var propertyOrigin = new MessageOrigin(prop);
 
+            // Check for [UnsupportedOSPlatform] on the property and mark getter/setter for PNSE
+            TryMarkPropertyForUnsupportedPlatform(prop);
+
             // Consider making this more similar to MarkEvent method?
             MarkCustomAttributes(prop, new DependencyInfo(DependencyKind.CustomAttribute, prop), propertyOrigin);
             DoAdditionalPropertyProcessing(prop);
diff --git a/src/tools/illink/src/linker/Linker/Driver.cs b/src/tools/illink/src/linker/Linker/Driver.cs
index c1934fbf2ba7d8..2fc3221c947290 100644
--- a/src/tools/illink/src/linker/Linker/Driver.cs
+++ b/src/tools/illink/src/linker/Linker/Driver.cs
@@ -597,6 +597,13 @@ protected int SetupContext(ILogger? customLogger = null)
                             context.WarningSuppressionWriter = new WarningSuppressionWriter(context, fileOutputKind);
                             continue;
 
+                        case "--target-os":
+                            if (!GetStringParam(token, out string? targetOS))
+                                return -1;
+
+                            context.TargetOS = targetOS;
+                            continue;
+
                         case "--notrimwarn":
                             context.NoTrimWarn = true;
                             continue;
@@ -1545,6 +1552,8 @@ static void Usage()
             Console.WriteLine("  --link-attributes FILE         Supplementary custom attribute definitions for attributes controlling the trimming behavior.");
             Console.WriteLine("  --ignore-link-attributes       Skips reading embedded attributes. Defaults to false");
             Console.WriteLine("  --strip-link-attributes        Remove XML link attributes resources for linked assemblies. Defaults to true");
+            Console.WriteLine("  --target-os NAME               Target OS platform name (e.g., browser, ios, windows). Methods with matching");
+            Console.WriteLine("                                   [UnsupportedOSPlatform] attribute will be stubbed with PlatformNotSupportedException.");
 
             Console.WriteLine();
             Console.WriteLine("Analyzer");
diff --git a/src/tools/illink/src/linker/Linker/KnownMembers.cs b/src/tools/illink/src/linker/Linker/KnownMembers.cs
index e1959d7e22eb12..509e38b9ccd920 100644
--- a/src/tools/illink/src/linker/Linker/KnownMembers.cs
+++ b/src/tools/illink/src/linker/Linker/KnownMembers.cs
@@ -9,6 +9,7 @@ namespace Mono.Linker
     public class KnownMembers
     {
         public MethodDefinition? NotSupportedExceptionCtorString { get; set; }
+        public MethodDefinition? PlatformNotSupportedExceptionCtor { get; set; }
         public MethodDefinition? DisablePrivateReflectionAttributeCtor { get; set; }
         public MethodDefinition? ObjectCtor { get; set; }
 
@@ -25,6 +26,17 @@ public static bool IsNotSupportedExceptionCtorString(MethodDefinition method)
             return true;
         }
 
+        public static bool IsPlatformNotSupportedExceptionCtor(MethodDefinition method)
+        {
+            if (!method.IsConstructor || method.IsStatic)
+                return false;
+
+            if (method.GetMetadataParametersCount() != 0)
+                return false;
+
+            return true;
+        }
+
         public static bool IsSatelliteAssemblyMarker(MethodDefinition method)
         {
             if (!method.IsConstructor || method.IsStatic)
diff --git a/src/tools/illink/src/linker/Linker/LinkContext.cs b/src/tools/illink/src/linker/Linker/LinkContext.cs
index 7ed63e024f3d81..9f75c8ca6dc58a 100644
--- a/src/tools/illink/src/linker/Linker/LinkContext.cs
+++ b/src/tools/illink/src/linker/Linker/LinkContext.cs
@@ -135,6 +135,8 @@ public Pipeline Pipeline
 
         public bool IgnoreLinkAttributes { get; set; }
 
+        public string? TargetOS { get; set; }
+
         public Dictionary<string, bool> FeatureSettings { get; init; }
 
         public List<PInvokeInfo> PInvokes { get; private set; }
diff --git a/src/tools/illink/src/linker/Linker/MethodAction.cs b/src/tools/illink/src/linker/Linker/MethodAction.cs
index 7b44a654d86c7b..b4d0a7be5ea256 100644
--- a/src/tools/illink/src/linker/Linker/MethodAction.cs
+++ b/src/tools/illink/src/linker/Linker/MethodAction.cs
@@ -39,5 +39,6 @@ public enum MethodAction
         ForceParse,
         ConvertToStub,
         ConvertToThrow,
+        ConvertToPNSE,
     }
 }
diff --git a/src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/generated/ILLink.RoslynAnalyzer.Tests.Generator/ILLink.RoslynAnalyzer.Tests.TestCaseGenerator/SubstitutionsTests.g.cs b/src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/generated/ILLink.RoslynAnalyzer.Tests.Generator/ILLink.RoslynAnalyzer.Tests.TestCaseGenerator/SubstitutionsTests.g.cs
index 35ec9a25061fa4..159d808c5f8189 100644
--- a/src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/generated/ILLink.RoslynAnalyzer.Tests.Generator/ILLink.RoslynAnalyzer.Tests.TestCaseGenerator/SubstitutionsTests.g.cs
+++ b/src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/generated/ILLink.RoslynAnalyzer.Tests.Generator/ILLink.RoslynAnalyzer.Tests.TestCaseGenerator/SubstitutionsTests.g.cs
@@ -91,5 +91,11 @@ public Task SubstitutionsErrorCases()
             return RunTest(allowMissingWarnings: true);
         }
 
+        [Fact]
+        public Task UnsupportedOSPlatformSubstitution()
+        {
+            return RunTest(allowMissingWarnings: true);
+        }
+
     }
 }
diff --git a/src/tools/illink/test/Mono.Linker.Tests.Cases/Substitutions/UnsupportedOSPlatformSubstitution.cs b/src/tools/illink/test/Mono.Linker.Tests.Cases/Substitutions/UnsupportedOSPlatformSubstitution.cs
new file mode 100644
index 00000000000000..2ed168005560b7
--- /dev/null
+++ b/src/tools/illink/test/Mono.Linker.Tests.Cases/Substitutions/UnsupportedOSPlatformSubstitution.cs
@@ -0,0 +1,97 @@
+// 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.Runtime.Versioning;
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Expectations.Metadata;
+
+namespace Mono.Linker.Tests.Cases.Substitutions
+{
+	/// <summary>
+	/// Test that methods with [UnsupportedOSPlatform] attribute matching --target-os
+	/// are stubbed with PlatformNotSupportedException.
+	/// </summary>
+	[SetupLinkerArgument ("--target-os", "browser")]
+	public class UnsupportedOSPlatformSubstitution
+	{
+		public static void Main ()
+		{
+			// This method should be kept and stubbed with PNSE
+			UnsupportedOnBrowser ();
+
+			// This method should be kept intact - different platform
+			UnsupportedOnWindows ();
+
+			// This method should be kept intact - no attribute
+			SupportedEverywhere ();
+
+			// Test property with attribute
+			var x = PropertyUnsupportedOnBrowser;
+			PropertyUnsupportedOnBrowser = x;
+
+			// Test property without attribute (should be kept intact)
+			var y = PropertySupportedEverywhere;
+			PropertySupportedEverywhere = y;
+		}
+
+		[Kept]
+		[ExpectedInstructionSequence (new[] {
+			"newobj System.Void System.PlatformNotSupportedException::.ctor()",
+			"throw",
+		})]
+		[KeptAttributeAttribute (typeof (UnsupportedOSPlatformAttribute))]
+		[UnsupportedOSPlatform ("browser")]
+		static void UnsupportedOnBrowser ()
+		{
+			// This body should be replaced with throw new PlatformNotSupportedException()
+			Console.WriteLine ("This should not appear");
+		}
+
+		[Kept]
+		[KeptAttributeAttribute (typeof (UnsupportedOSPlatformAttribute))]
+		[UnsupportedOSPlatform ("windows")]
+		static void UnsupportedOnWindows ()
+		{
+			// This method targets windows, not browser, so should be kept intact
+			Console.WriteLine ("This should be kept");
+		}
+
+		[Kept]
+		static void SupportedEverywhere ()
+		{
+			// No UnsupportedOSPlatform attribute, should be kept intact
+			Console.WriteLine ("This should be kept");
+		}
+
+		[Kept]
+		[KeptAttributeAttribute (typeof (UnsupportedOSPlatformAttribute))]
+		[UnsupportedOSPlatform ("browser")]
+		static int PropertyUnsupportedOnBrowser
+		{
+			[Kept]
+			[ExpectedInstructionSequence (new[] {
+				"newobj System.Void System.PlatformNotSupportedException::.ctor()",
+				"throw",
+			})]
+			get => 42;
+
+			[Kept]
+			[ExpectedInstructionSequence (new[] {
+				"newobj System.Void System.PlatformNotSupportedException::.ctor()",
+				"throw",
+			})]
+			set { }
+		}
+
+		[Kept]
+		static int PropertySupportedEverywhere
+		{
+			[Kept]
+			get => 42;
+
+			[Kept]
+			set { }
+		}
+	}
+}