[Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

Description

@elinor-fung

Description

When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

PR: dotnet/runtime#84100
Related issue: dotnet/runtime#83246
Related design: dotnet/designs#260

Version

.NET 8 Preview 5

Previous behavior

The process for selecting RID-specific assets was:

  1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
  2. Compute the current RID at run-time and try to find an entry for it in the RID graph
    • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
  3. Starting from the entry found in the RID graph, look for assets matching that RID.
  4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

New behavior

By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

Linux

  • linux-x64
  • linux
  • unix-x64
  • unix
  • any

Windows

  • win-x64
  • win
  • any

macOS

  • osx-x64
  • osx
  • unix-x64
  • unix

For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

Type of breaking change

  • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
  • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
  • Behavioral change: Existing binaries may behave differently at run time.

Reason for change

The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

Recommended action

Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

Feature area

Deployment

Affected APIs

AssemblyDependencyResolver


Associated WorkItem - 97016

Activity

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

Labels

🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

Type

No type

Projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions

    , 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all
     blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
    }
    } catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
    })();
    (function(){
    try {
    var __m = "github.com";
    var __re = new RegExp('^' + "github\\.com" + '
    
    Skip to content

    [Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

    Description

    @elinor-fung

    Description

    When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

    Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

    PR: dotnet/runtime#84100
    Related issue: dotnet/runtime#83246
    Related design: dotnet/designs#260

    Version

    .NET 8 Preview 5

    Previous behavior

    The process for selecting RID-specific assets was:

    1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
    2. Compute the current RID at run-time and try to find an entry for it in the RID graph
      • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
    3. Starting from the entry found in the RID graph, look for assets matching that RID.
    4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

    This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

    New behavior

    By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

    Linux

    • linux-x64
    • linux
    • unix-x64
    • unix
    • any

    Windows

    • win-x64
    • win
    • any

    macOS

    • osx-x64
    • osx
    • unix-x64
    • unix

    For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

    Type of breaking change

    • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
    • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
    • Behavioral change: Existing binaries may behave differently at run time.

    Reason for change

    The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

    Recommended action

    Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

    A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

    Feature area

    Deployment

    Affected APIs

    AssemblyDependencyResolver


    Associated WorkItem - 97016

    Activity

    Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

    Metadata

    Metadata

    Assignees

    Labels

    🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

    Type

    No type

    Projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions

      , 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix"); } } catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
      Skip to content

      [Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

      Description

      @elinor-fung

      Description

      When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

      Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

      PR: dotnet/runtime#84100
      Related issue: dotnet/runtime#83246
      Related design: dotnet/designs#260

      Version

      .NET 8 Preview 5

      Previous behavior

      The process for selecting RID-specific assets was:

      1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
      2. Compute the current RID at run-time and try to find an entry for it in the RID graph
        • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
      3. Starting from the entry found in the RID graph, look for assets matching that RID.
      4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

      This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

      New behavior

      By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

      Linux

      • linux-x64
      • linux
      • unix-x64
      • unix
      • any

      Windows

      • win-x64
      • win
      • any

      macOS

      • osx-x64
      • osx
      • unix-x64
      • unix

      For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

      Type of breaking change

      • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
      • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
      • Behavioral change: Existing binaries may behave differently at run time.

      Reason for change

      The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

      Recommended action

      Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

      A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

      Feature area

      Deployment

      Affected APIs

      AssemblyDependencyResolver


      Associated WorkItem - 97016

      Activity

      Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

      Metadata

      Metadata

      Assignees

      Labels

      🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

      Type

      No type

      Projects

        Milestone

        No milestone

        Relationships

        None yet

        Development

        No branches or pull requests

        Issue actions

        , 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms"); } } catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
        Skip to content

        [Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

        Description

        @elinor-fung

        Description

        When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

        Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

        PR: dotnet/runtime#84100
        Related issue: dotnet/runtime#83246
        Related design: dotnet/designs#260

        Version

        .NET 8 Preview 5

        Previous behavior

        The process for selecting RID-specific assets was:

        1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
        2. Compute the current RID at run-time and try to find an entry for it in the RID graph
          • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
        3. Starting from the entry found in the RID graph, look for assets matching that RID.
        4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

        This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

        New behavior

        By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

        Linux

        • linux-x64
        • linux
        • unix-x64
        • unix
        • any

        Windows

        • win-x64
        • win
        • any

        macOS

        • osx-x64
        • osx
        • unix-x64
        • unix

        For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

        Type of breaking change

        • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
        • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
        • Behavioral change: Existing binaries may behave differently at run time.

        Reason for change

        The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

        Recommended action

        Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

        A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

        Feature area

        Deployment

        Affected APIs

        AssemblyDependencyResolver


        Associated WorkItem - 97016

        Activity

        Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

        Metadata

        Metadata

        Assignees

        Labels

        🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

        Type

        No type

        Projects

          Milestone

          No milestone

          Relationships

          None yet

          Development

          No branches or pull requests

          Issue actions

          , 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links"); } } catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); } })(); (function(){ try { var __m = "youtube.com"; var __re = new RegExp('^' + "youtube\\.com" + '
          Skip to content

          [Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

          Description

          @elinor-fung

          Description

          When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

          Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

          PR: dotnet/runtime#84100
          Related issue: dotnet/runtime#83246
          Related design: dotnet/designs#260

          Version

          .NET 8 Preview 5

          Previous behavior

          The process for selecting RID-specific assets was:

          1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
          2. Compute the current RID at run-time and try to find an entry for it in the RID graph
            • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
          3. Starting from the entry found in the RID graph, look for assets matching that RID.
          4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

          This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

          New behavior

          By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

          Linux

          • linux-x64
          • linux
          • unix-x64
          • unix
          • any

          Windows

          • win-x64
          • win
          • any

          macOS

          • osx-x64
          • osx
          • unix-x64
          • unix

          For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

          Type of breaking change

          • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
          • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
          • Behavioral change: Existing binaries may behave differently at run time.

          Reason for change

          The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

          Recommended action

          Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

          A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

          Feature area

          Deployment

          Affected APIs

          AssemblyDependencyResolver


          Associated WorkItem - 97016

          Activity

          Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

          Metadata

          Metadata

          Assignees

          Labels

          🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

          Type

          No type

          Projects

            Milestone

            No milestone

            Relationships

            None yet

            Development

            No branches or pull requests

            Issue actions

            , 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default"); } } catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
            Skip to content

            [Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

            Description

            @elinor-fung

            Description

            When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

            Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

            PR: dotnet/runtime#84100
            Related issue: dotnet/runtime#83246
            Related design: dotnet/designs#260

            Version

            .NET 8 Preview 5

            Previous behavior

            The process for selecting RID-specific assets was:

            1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
            2. Compute the current RID at run-time and try to find an entry for it in the RID graph
              • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
            3. Starting from the entry found in the RID graph, look for assets matching that RID.
            4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

            This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

            New behavior

            By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

            Linux

            • linux-x64
            • linux
            • unix-x64
            • unix
            • any

            Windows

            • win-x64
            • win
            • any

            macOS

            • osx-x64
            • osx
            • unix-x64
            • unix

            For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

            Type of breaking change

            • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
            • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
            • Behavioral change: Existing binaries may behave differently at run time.

            Reason for change

            The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

            Recommended action

            Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

            A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

            Feature area

            Deployment

            Affected APIs

            AssemblyDependencyResolver


            Associated WorkItem - 97016

            Activity

            Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

            Metadata

            Metadata

            Assignees

            Labels

            🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

            Type

            No type

            Projects

              Milestone

              No milestone

              Relationships

              None yet

              Development

              No branches or pull requests

              Issue actions

              , 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers"); } } catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
              Skip to content

              [Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

              Description

              @elinor-fung

              Description

              When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

              Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

              PR: dotnet/runtime#84100
              Related issue: dotnet/runtime#83246
              Related design: dotnet/designs#260

              Version

              .NET 8 Preview 5

              Previous behavior

              The process for selecting RID-specific assets was:

              1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
              2. Compute the current RID at run-time and try to find an entry for it in the RID graph
                • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
              3. Starting from the entry found in the RID graph, look for assets matching that RID.
              4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

              This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

              New behavior

              By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

              Linux

              • linux-x64
              • linux
              • unix-x64
              • unix
              • any

              Windows

              • win-x64
              • win
              • any

              macOS

              • osx-x64
              • osx
              • unix-x64
              • unix

              For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

              Type of breaking change

              • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
              • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
              • Behavioral change: Existing binaries may behave differently at run time.

              Reason for change

              The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

              Recommended action

              Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

              A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

              Feature area

              Deployment

              Affected APIs

              AssemblyDependencyResolver


              Associated WorkItem - 97016

              Activity

              Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

              Metadata

              Metadata

              Assignees

              Labels

              🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

              Type

              No type

              Projects

                Milestone

                No milestone

                Relationships

                None yet

                Development

                No branches or pull requests

                Issue actions

                , 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode"); } } catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); } })(); })();
                Skip to content

                [Breaking change]: Runtime host looks for RID-specific assets via a known list instead of RID graph by default #35398

                Description

                @elinor-fung

                Description

                When running an application with RID-specific assets, the host determines which assets are relevant for the platform on which it is running. This applies to both the application itself and the resolution logic used by AssemblyDependencyResolver.

                Previously, it tried to compute the RID at runtime and then read the RID graph to determine which RID-specific assets match or are compatible with the computed RID. Now, the default behaviour no longer uses the RID graph and a computed RID, relying instead on a known list of RIDs based on how the runtime itself was built.

                PR: dotnet/runtime#84100
                Related issue: dotnet/runtime#83246
                Related design: dotnet/designs#260

                Version

                .NET 8 Preview 5

                Previous behavior

                The process for selecting RID-specific assets was:

                1. Read the RID graph from the .deps.json of the root framework (Microsoft.NetCore.App)
                2. Compute the current RID at run-time and try to find an entry for it in the RID graph
                  • If it doesn't exist, check for a fallback RID (built into the host at compile-time)
                3. Starting from the entry found in the RID graph, look for assets matching that RID.
                4. Continue down the list of RIDs in the RID graph entry until an asset match is found or the list ends.

                This had the effect where if the RID graph didn't have the computed RID or the fallback RID, RID assets would not be properly resolved.

                New behavior

                By default, the process no longer relies on the RID graph and now checks for a known set of portable RIDs based on how the host was built. For example:

                Linux

                • linux-x64
                • linux
                • unix-x64
                • unix
                • any

                Windows

                • win-x64
                • win
                • any

                macOS

                • osx-x64
                • osx
                • unix-x64
                • unix

                For non-portable builds of the host/runtime, the build may also set a non-portable RID that will be checked first.

                Type of breaking change

                • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
                • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
                • Behavioral change: Existing binaries may behave differently at run time.

                Reason for change

                The RID graph has consistently been costly to maintain and understand, requiring .NET itself to be distro-aware in a fragile manner. The .NET team and the community spend a non-trivial amount of time updating the graph and backporting such updates to previous releases. The long-term goal is to stop updating the RID graph, stop reading it, and eventually remove it. This breaking change is a step towards that goal.

                Recommended action

                Using portable RIDs (for example, linux, linux-musl, osx, win) is recommended path forwards. For specialized use cases, APIs like NativeLibrary.SetDllImportResolver or AssemblyLoadContext.ResolvingUnmanagedDll can be used for custom loading logic.

                A backwards compat switch is also provided to revert to the previous behaviour. Setting the runtime config propertySystem.Runtime.Loader.UseRidGraph to true in a runtimeconfig.json or MSBuild property will use the previous method of reading the RID graph.

                Feature area

                Deployment

                Affected APIs

                AssemblyDependencyResolver


                Associated WorkItem - 97016

                Activity

                Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

                Metadata

                Metadata

                Assignees

                Labels

                🏁 Release: .NET 8Work items for the .NET 8 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.binary incompatibleExisting binaries may encounter a breaking change in behavior.breaking-changeIndicates a .NET Core breaking change

                Type

                No type

                Projects

                  Milestone

                  No milestone

                  Relationships

                  None yet

                  Development

                  No branches or pull requests

                  Issue actions