Merge branch 'master' into fix-mbd-reloading

.github/workflows/ci-nativelibs.yml

···
-on: workflow_dispatch
-name: Continuous Integration - NativeLibs
-
-jobs:
-  check-if-tag:
-    name: Set Package Version
-    runs-on: ubuntu-latest
-    outputs:
-      version: ${{steps.deployment.outputs.version}}
-    steps:
-      - name: Set Variables
-        id: deployment
-        shell: bash
-        run: |
-          if [ $(echo ${{github.ref}} | grep -q "refs/tags/"; echo $?) == 0 ]; then
-            echo "::set-output name=VERSION::${GITHUB_REF#/refs\/tags\//}"
-          else
-            echo "::set-output name=VERSION::0.0.0+${{github.run_id}}"
-          fi
-  deploy:
-    name: Deploy
-    runs-on: ubuntu-latest
-    needs: check-if-tag
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set Artifacts Directory
-        id: artifactsPath
-        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}/artifacts"
-
-      - name: Setup .NET 5.0.x
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "5.0.x"
-
-      - name: Build NativeLibs
-        run: dotnet pack -c Release osu.Framework.NativeLibs /p:Configuration=Release /p:Version=${{needs.check-if-tag.outputs.version}} /p:GenerateDocumentationFile=true -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
-
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v2
-        with:
-          name: osu-framework-nativelibs
-          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
-
-      - name: Deploy
-        run: |
-          if [ $(echo ${{needs.check-if-tag.outputs.version}} | grep -q "0.0.0+${{github.run_id}}"; echo $?) == 0 ]; then
-            echo "Skipping publish, no tag detected."
-            exit 0;
-          else
-            dotnet nuget add source https://api.nuget.org/v3/index.json -n authed-nuget -u ${{secrets.NUGET_USER_NAME}} -p ${{secrets.NUGET_AUTH_TOKEN}}
-            dotnet nuget push ${{github.workspace}}/artifacts/*.nupkg --skip-duplicate --source authed-nuget
-          fi

.github/workflows/ci.yml

···
 name: Continuous Integration
 
 jobs:
-  check-if-tag:
-    name: Set Package Version
-    runs-on: ubuntu-latest
-    outputs:
-      version: ${{steps.deployment.outputs.version}}
-    steps:
-      - name: Set Variables
-        id: deployment
-        shell: bash
-        run: |
-          if [ $(echo ${{github.ref}} | grep -q "refs/tags/"; echo $?) == 0 ]; then
-            echo "::set-output name=VERSION::${GITHUB_REF#/refs\/tags\//}"
-          else
-            echo "::set-output name=VERSION::0.0.0+${{github.run_id}}"
-          fi
   test:
     name: Test
-    runs-on: windows-latest
+    runs-on: ${{matrix.os.fullname}}
+    env:
+      OSU_EXECUTION_MODE: ${{matrix.threadingMode}}
+    strategy:
+       fail-fast: false
+       matrix:
+          os:
+            - { prettyname: Windows, fullname: windows-latest }
+            - { prettyname: macOS, fullname: macos-latest }
+            - { prettyname: Linux, fullname: ubuntu-latest }
+          threadingMode: ['SingleThread', 'MultiThreaded']
     steps:
       - name: Checkout
         uses: actions/checkout@v2
···
         with:
           dotnet-version: "5.0.x"
 
+      # FIXME: libavformat is not included in Ubuntu. Let's fix that.
+      # https://github.com/ppy/osu-framework/issues/4349
+      # Remove this once https://github.com/actions/virtual-environments/issues/3306 has been resolved.
+      - name: Install libavformat-dev
+        if: ${{matrix.os.fullname == 'ubuntu-latest'}}
+        run: |
+         sudo apt-get update && \
+         sudo apt-get -y install libavformat-dev
+
       - name: Compile
-        run: dotnet build -c Debug build/Desktop.proj
+        run: dotnet build -c Debug -warnaserror build/Desktop.proj
 
       - name: Test
-        run: dotnet test $pwd/*.Tests/bin/Debug/*/*.Tests.dll --settings $pwd/build/vstestconfig.runsettings --logger "trx;LogFileName=TestResults.trx"
-        shell: powershell
+        run: dotnet test $pwd/*.Tests/bin/Debug/*/*.Tests.dll --settings $pwd/build/vstestconfig.runsettings --logger "trx;LogFileName=TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx"
+        shell: pwsh
 
       # Attempt to upload results even if test fails.
       # https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#always
···
         uses: actions/upload-artifact@v2
         if: ${{ always() }}
         with:
-          name: osu-framework-test-results
-          path: ${{github.workspace}}\TestResults\TestResults.trx
+          name: osu-framework-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}
+          path: ${{github.workspace}}/TestResults/TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx
 
   inspect-code:
     name: Code Quality
···
         uses: glassechidna/resharper-action@master
         with:
           report: ${{github.workspace}}/inspectcodereport.xml
-
-  pack-framework:
-    name: Pack (Framework)
-    runs-on: windows-latest
-    needs: [test, inspect-code, check-if-tag]
-    defaults:
-      run:
-        shell: powershell
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set Artifacts Directory
-        id: artifactsPath
-        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}\artifacts"
-
-      # FIXME: 3.1 LTS is required here because iOS builds refuse to build without it.
-      # https://itnext.io/how-to-support-multiple-net-sdks-in-github-actions-workflows-b988daa884e
-      - name: Install .NET 3.1.x LTS
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "3.1.x"
-
-      - name: Install .NET 5.0.x
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "5.0.x"
-
-      - name: Pack (Framework)
-        run: dotnet pack -c Release osu.Framework /p:Version=${{needs.check-if-tag.outputs.version}} /p:GenerateDocumentationFile=true  -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
-
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v2
-        with:
-          name: osu-framework
-          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}\*.nupkg
-
-  pack-template:
-    name: Pack (Templates)
-    runs-on: windows-latest
-    needs: [test, inspect-code, check-if-tag]
-    defaults:
-      run:
-        shell: powershell
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set Artifacts Directory
-        id: artifactsPath
-        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}\artifacts"
-
-      - name: Install .NET 5.0.x
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "5.0.x"
-
-      - name: Pack (Template)
-        run: dotnet pack -c Release osu.Framework.Templates /p:Configuration=Release /p:Version=${{needs.check-if-tag.outputs.version}} /p:GenerateDocumentationFile=true /p:NoDefaultExcludes=true -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
-
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v2
-        with:
-          name: osu-framework-templates
-          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}\*.nupkg
-
-  pack-android:
-    name: Pack (Android)
-    runs-on: windows-latest
-    needs: [test, inspect-code, check-if-tag]
-    defaults:
-      run:
-        shell: powershell
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set Artifacts Directory
-        id: artifactsPath
-        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}\artifacts"
-
-      - name: Add msbuild to PATH
-        uses: microsoft/setup-msbuild@v1.0.2
-
-      - name: Pack (Android Framework)
-        run: msbuild -bl:msbuildlog.binlog -v:m -target:Pack -r osu.Framework.Android/osu.Framework.Android.csproj -p:Configuration=Release -p:Version=${{needs.check-if-tag.outputs.version}} -p:PackageOutputPath=${{steps.artifactsPath.outputs.nuget_artifacts}}
-
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v2
-        with:
-          name: osu-framework-android
-          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}\*.nupkg
-
-  pack-ios:
-    name: Pack (iOS)
-    runs-on: macos-latest
-    needs: [test, inspect-code, check-if-tag]
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set Artifacts Directory
-        id: artifactsPath
-        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}/artifacts"
-
-      - name: Pack (iOS Framework)
-        run: msbuild -bl:msbuildlog.binlog -v:m -target:Pack -r osu.Framework.iOS/osu.Framework.iOS.csproj -p:Configuration=Release -p:Version=${{needs.check-if-tag.outputs.version}} -p:PackageOutputPath=${{steps.artifactsPath.outputs.nuget_artifacts}}
-
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v2
-        with:
-          name: osu-framework-ios
-          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
-
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    needs: [check-if-tag, pack-android, pack-framework, pack-template, pack-ios]
-    if: ${{ github.event != 'pull_request' }}
-    steps:
-      - name: Create Artifact Directory
-        run: mkdir ${{github.workspace}}/artifacts/
-
-      - name: Download Artifacts
-        uses: actions/download-artifact@v2
-        with:
-          path: ${{github.workspace}}/artifacts/
-
-        # Artifacts create their own directories. Let's fix that!
-        # https://github.com/actions/download-artifact#download-all-artifacts
-      - name: Move Artifacts to root of subdirectory
-        working-directory: ${{github.workspace}}/artifacts/
-        run: |
-          mv -v **/*.nupkg $(pwd)
-          rm -rfv */
-
-      - name: Deploy
-        run: |
-          if [ $(echo ${{needs.check-if-tag.outputs.version}} | grep -q "0.0.0+${{github.run_id}}"; echo $?) == 0 ]; then
-            echo "Skipping publish, no tag detected."
-            exit 0;
-          else
-            dotnet nuget add source https://api.nuget.org/v3/index.json -n authed-nuget -u ${{secrets.NUGET_USER_NAME}} -p ${{secrets.NUGET_AUTH_TOKEN}}
-            dotnet nuget push ${{github.workspace}}/artifacts/*.nupkg --skip-duplicate --source authed-nuget
-          fi

.github/workflows/deploy-nativelibs.yml

···
+# There is no manual way to call this out to run this on tags via UI.
+# See: https://github.community/t/workflow-dispatch-from-a-tag-in-actions-tab/130561
+on: workflow_dispatch
+name: Deploy - NativeLibs
+
+jobs:
+  check-if-tag:
+    name: Set Package Version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{steps.deployment.outputs.version}}
+    steps:
+      - name: Checkout
+        run: |
+          REPOSITORY="https://${{ github.actor }}:${{ github.token }}@github.com/${{ github.repository }}.git"
+          BRANCH="${GITHUB_REF/#refs\/heads\//}"
+
+          git version
+          git clone --no-checkout ${REPOSITORY} .
+          git config --local gc.auto 0
+
+          git -c protocol.version=2 fetch --no-tags --prune --progress --depth=2 origin +${GITHUB_SHA}:refs/remotes/origin/${BRANCH}
+          git checkout --progress --force -B $BRANCH refs/remotes/origin/$BRANCH
+
+
+      - name: Set Variables
+        id: deployment
+        shell: bash
+        run: |
+          if [ $(git describe --exact-match --tags HEAD &> /dev/null; echo $?) == 0 ]; then
+            echo "::set-output name=VERSION::$(git describe --exact-match --tags HEAD)"
+          else
+            echo "fatal: no tag detected for HEAD. Workflow will now stop."
+            exit 128;
+          fi
+
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    needs: check-if-tag
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Set Artifacts Directory
+        id: artifactsPath
+        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}/artifacts"
+
+      - name: Setup .NET 5.0.x
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "5.0.x"
+
+      - name: Build NativeLibs
+        run: dotnet pack -c Release osu.Framework.NativeLibs /p:Configuration=Release /p:Version=${{needs.check-if-tag.outputs.version}} /p:GenerateDocumentationFile=true -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: osu-framework-nativelibs
+          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
+
+      - name: Deploy
+        run: |
+            dotnet nuget add source https://api.nuget.org/v3/index.json -n authed-nuget -u ${{secrets.NUGET_USER_NAME}} -p ${{secrets.NUGET_AUTH_TOKEN}}
+            dotnet nuget push ${{github.workspace}}/artifacts/*.nupkg --skip-duplicate --source authed-nuget

.github/workflows/deploy-pack.yml

···
+# There is no manual way to call this out to run this on tags via UI.
+# See: https://github.community/t/workflow-dispatch-from-a-tag-in-actions-tab/130561
+on: workflow_dispatch
+name: Deploy - Framework
+
+jobs:
+  check-if-tag:
+    name: Set Package Version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{steps.deployment.outputs.version}}
+    steps:
+      - name: Checkout
+        run: |
+          REPOSITORY="https://${{ github.actor }}:${{ github.token }}@github.com/${{ github.repository }}.git"
+          BRANCH="${GITHUB_REF/#refs\/heads\//}"
+
+          git version
+          git clone --no-checkout ${REPOSITORY} .
+          git config --local gc.auto 0
+
+          git -c protocol.version=2 fetch --no-tags --prune --progress --depth=2 origin +${GITHUB_SHA}:refs/remotes/origin/${BRANCH}
+          git checkout --progress --force -B $BRANCH refs/remotes/origin/$BRANCH
+
+
+      - name: Set Variables
+        id: deployment
+        shell: bash
+        run: |
+          if [ $(git describe --exact-match --tags HEAD &> /dev/null; echo $?) == 0 ]; then
+            echo "::set-output name=VERSION::$(git describe --exact-match --tags HEAD)"
+          else
+            echo "fatal: no tag detected for HEAD. Workflow will now stop."
+            exit 128;
+          fi
+
+  pack-framework:
+    name: Pack (Framework)
+    runs-on: windows-latest
+    needs: [check-if-tag]
+    defaults:
+      run:
+        shell: powershell
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Set Artifacts Directory
+        id: artifactsPath
+        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}\artifacts"
+
+      # FIXME: 3.1 LTS is required here because iOS builds refuse to build without it.
+      # https://itnext.io/how-to-support-multiple-net-sdks-in-github-actions-workflows-b988daa884e
+      - name: Install .NET 3.1.x LTS
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "3.1.x"
+
+      - name: Install .NET 5.0.x
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "5.0.x"
+
+      - name: Pack (Framework)
+        run: dotnet pack -c Release osu.Framework /p:Version=${{needs.check-if-tag.outputs.version}} /p:GenerateDocumentationFile=true  -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: osu-framework
+          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}\*.nupkg
+
+  pack-template:
+    name: Pack (Templates)
+    runs-on: windows-latest
+    needs: [check-if-tag]
+    defaults:
+      run:
+        shell: powershell
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Set Artifacts Directory
+        id: artifactsPath
+        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}\artifacts"
+
+      - name: Install .NET 5.0.x
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "5.0.x"
+
+      - name: Pack (Template)
+        run: dotnet pack -c Release osu.Framework.Templates /p:Configuration=Release /p:Version=${{needs.check-if-tag.outputs.version}} /p:GenerateDocumentationFile=true /p:NoDefaultExcludes=true -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: osu-framework-templates
+          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}\*.nupkg
+
+  pack-android:
+    name: Pack (Android)
+    runs-on: windows-latest
+    needs: [check-if-tag]
+    defaults:
+      run:
+        shell: powershell
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Set Artifacts Directory
+        id: artifactsPath
+        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}\artifacts"
+
+      - name: Add msbuild to PATH
+        uses: microsoft/setup-msbuild@v1.0.2
+
+      - name: Pack (Android Framework)
+        run: msbuild -bl:msbuildlog.binlog -v:m -target:Pack -r osu.Framework.Android/osu.Framework.Android.csproj -p:Configuration=Release -p:Version=${{needs.check-if-tag.outputs.version}} -p:PackageOutputPath=${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: osu-framework-android
+          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}\*.nupkg
+
+  pack-ios:
+    name: Pack (iOS)
+    runs-on: macos-latest
+    needs: [check-if-tag]
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Set Artifacts Directory
+        id: artifactsPath
+        run: echo "::set-output name=NUGET_ARTIFACTS::${{github.workspace}}/artifacts"
+
+      - name: Pack (iOS Framework)
+        run: msbuild -bl:msbuildlog.binlog -v:m -target:Pack -r osu.Framework.iOS/osu.Framework.iOS.csproj -p:Configuration=Release -p:Version=${{needs.check-if-tag.outputs.version}} -p:PackageOutputPath=${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: osu-framework-ios
+          path: ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs: [check-if-tag, pack-android, pack-framework, pack-template, pack-ios]
+    steps:
+      - name: Create Artifact Directory
+        run: mkdir ${{github.workspace}}/artifacts/
+
+      - name: Download Artifacts
+        uses: actions/download-artifact@v2
+        with:
+          path: ${{github.workspace}}/artifacts/
+
+        # Artifacts create their own directories. Let's fix that!
+        # https://github.com/actions/download-artifact#download-all-artifacts
+      - name: Move Artifacts to root of subdirectory
+        working-directory: ${{github.workspace}}/artifacts/
+        run: |
+          mv -v **/*.nupkg $(pwd)
+          rm -rfv */
+
+      - name: Deploy
+        run: |
+            dotnet nuget add source https://api.nuget.org/v3/index.json -n authed-nuget -u ${{secrets.NUGET_USER_NAME}} -p ${{secrets.NUGET_AUTH_TOKEN}}
+            dotnet nuget push ${{github.workspace}}/artifacts/*.nupkg --skip-duplicate --source authed-nuget

.github/workflows/report-nunit.yml

···
   report:
     runs-on: ubuntu-latest
     if: ${{ github.event.workflow_run.conclusion != 'cancelled' }}
+    strategy:
+       fail-fast: false
+       matrix:
+          os:
+            - { prettyname: Windows }
+            - { prettyname: macOS }
+            - { prettyname: Linux }
+          threadingMode: ['SingleThread', 'MultiThreaded']
     steps:
       - name: Continuous Integration Test Report
         uses: dorny/test-reporter@v1.4.2
         with:
-          artifact: osu-framework-test-results
-          name: Test Results
+          artifact: osu-framework-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}
+          name: Test Results (${{matrix.os.prettyname}}, ${{matrix.threadingMode}})
           path: "*.trx"
           reporter: dotnet-trx

osu.Framework.Tests/Bindables/BindableNumberTest.cs

···
             Assert.That(bindable1ValueChange, Is.EqualTo(4));
         }
 
-        /// <summary>
-        /// Tests that the value of a bindable is updated when the maximum value is changed.
-        /// </summary>
-        [Test]
-        public void TestValueUpdatedOnMaxValueChange()
-        {
-            var bindable = new BindableInt(2)
-            {
-                MaxValue = 1
-            };
-
-            Assert.That(bindable.Value, Is.EqualTo(1));
-        }
-
-        /// <summary>
-        /// Tests that the order of maximum value vs value changed events follows the order:
-        /// MaxValue (bound) -> MaxValue -> Value (bound) -> Value
-        /// </summary>
-        [Test]
-        public void TestValueChangeEventOccursAfterMaxValueChangeEvent()
-        {
-            var bindable1 = new BindableInt(2);
-            var bindable2 = new BindableInt { BindTarget = bindable1 };
-            int counter = 0, bindable1ValueChange = 0, bindable1MaxChange = 0, bindable2ValueChange = 0, bindable2MaxChange = 0;
-            bindable1.ValueChanged += _ => bindable1ValueChange = ++counter;
-            bindable1.MaxValueChanged += _ => bindable1MaxChange = ++counter;
-            bindable2.ValueChanged += _ => bindable2ValueChange = ++counter;
-            bindable2.MaxValueChanged += _ => bindable2MaxChange = ++counter;
-
-            bindable1.MaxValue = 1;
-
-            Assert.That(bindable2MaxChange, Is.EqualTo(1));
-            Assert.That(bindable1MaxChange, Is.EqualTo(2));
-            Assert.That(bindable2ValueChange, Is.EqualTo(3));
-            Assert.That(bindable1ValueChange, Is.EqualTo(4));
-        }
-
-        [Test]
-        public void TestDefaultMaxValueAppliedInConstructor()
-        {
-            var bindable = new BindableNumberWithDefaultMaxValue(2);
-
-            Assert.That(bindable.Value, Is.EqualTo(1));
-        }
-
-        /// <summary>
-        /// Tests that the value of a bindable is updated when the minimum value is changed.
-        /// </summary>
-        [Test]
-        public void TestValueUpdatedOnMinValueChange()
-        {
-            var bindable = new BindableInt(2)
-            {
-                MinValue = 3
-            };
-
-            Assert.That(bindable.Value, Is.EqualTo(3));
-        }
-
-        /// <summary>
-        /// Tests that the order of minimum value vs value changed events follows the order:
-        /// MinValue (bound) -> MinValue -> Value (bound) -> Value
-        /// </summary>
-        [Test]
-        public void TestValueChangeEventOccursAfterMinValueChangeEvent()
-        {
-            var bindable1 = new BindableInt(2);
-            var bindable2 = new BindableInt { BindTarget = bindable1 };
-            int counter = 0, bindable1ValueChange = 0, bindable1MinChange = 0, bindable2ValueChange = 0, bindable2MinChange = 0;
-            bindable1.ValueChanged += _ => bindable1ValueChange = ++counter;
-            bindable1.MinValueChanged += _ => bindable1MinChange = ++counter;
-            bindable2.ValueChanged += _ => bindable2ValueChange = ++counter;
-            bindable2.MinValueChanged += _ => bindable2MinChange = ++counter;
-
-            bindable1.MinValue = 3;
-
-            Assert.That(bindable2MinChange, Is.EqualTo(1));
-            Assert.That(bindable1MinChange, Is.EqualTo(2));
-            Assert.That(bindable2ValueChange, Is.EqualTo(3));
-            Assert.That(bindable1ValueChange, Is.EqualTo(4));
-        }
-
-        [Test]
-        public void TestDefaultMinValueAppliedInConstructor()
-        {
-            var bindable = new BindableNumberWithDefaultMinValue(2);
-
-            Assert.That(bindable.Value, Is.EqualTo(3));
-        }
-
         private object createBindable(Type type) => Activator.CreateInstance(typeof(BindableNumber<>).MakeGenericType(type), Convert.ChangeType(0, type));
-
-        private class BindableNumberWithDefaultMaxValue : BindableInt
-        {
-            public BindableNumberWithDefaultMaxValue(int value = 0)
-                : base(value)
-            {
-            }
-
-            protected override int DefaultMaxValue => 1;
-        }
-
-        private class BindableNumberWithDefaultMinValue : BindableInt
-        {
-            public BindableNumberWithDefaultMinValue(int value = 0)
-                : base(value)
-            {
-            }
-
-            protected override int DefaultMinValue => 3;
-        }
     }
 }

osu.Framework.Tests/Bindables/RangeConstrainedBindableTest.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Bindables;
+
+namespace osu.Framework.Tests.Bindables
+{
+    [TestFixture]
+    public class RangeConstrainedBindableTest
+    {
+        /// <summary>
+        /// Tests that the value of a bindable is updated when the maximum value is changed.
+        /// </summary>
+        [Test]
+        public void TestValueUpdatedOnMaxValueChange()
+        {
+            var bindable = new BindableInt(2)
+            {
+                MaxValue = 1
+            };
+
+            Assert.That(bindable.Value, Is.EqualTo(1));
+        }
+
+        /// <summary>
+        /// Tests that the order of maximum value vs value changed events follows the order:
+        /// MaxValue (bound) -> MaxValue -> Value (bound) -> Value
+        /// </summary>
+        [Test]
+        public void TestValueChangeEventOccursAfterMaxValueChangeEvent()
+        {
+            var bindable1 = new BindableInt(2);
+            var bindable2 = new BindableInt { BindTarget = bindable1 };
+            int counter = 0, bindable1ValueChange = 0, bindable1MaxChange = 0, bindable2ValueChange = 0, bindable2MaxChange = 0;
+            bindable1.ValueChanged += _ => bindable1ValueChange = ++counter;
+            bindable1.MaxValueChanged += _ => bindable1MaxChange = ++counter;
+            bindable2.ValueChanged += _ => bindable2ValueChange = ++counter;
+            bindable2.MaxValueChanged += _ => bindable2MaxChange = ++counter;
+
+            bindable1.MaxValue = 1;
+
+            Assert.That(bindable2MaxChange, Is.EqualTo(1));
+            Assert.That(bindable1MaxChange, Is.EqualTo(2));
+            Assert.That(bindable2ValueChange, Is.EqualTo(3));
+            Assert.That(bindable1ValueChange, Is.EqualTo(4));
+        }
+
+        [Test]
+        public void TestDefaultMaxValueAppliedInConstructor()
+        {
+            var bindable = new BindableNumberWithDefaultMaxValue(2);
+
+            Assert.That(bindable.Value, Is.EqualTo(1));
+        }
+
+        /// <summary>
+        /// Tests that the value of a bindable is updated when the minimum value is changed.
+        /// </summary>
+        [Test]
+        public void TestValueUpdatedOnMinValueChange()
+        {
+            var bindable = new BindableInt(2)
+            {
+                MinValue = 3
+            };
+
+            Assert.That(bindable.Value, Is.EqualTo(3));
+        }
+
+        /// <summary>
+        /// Tests that the order of minimum value vs value changed events follows the order:
+        /// MinValue (bound) -> MinValue -> Value (bound) -> Value
+        /// </summary>
+        [Test]
+        public void TestValueChangeEventOccursAfterMinValueChangeEvent()
+        {
+            var bindable1 = new BindableInt(2);
+            var bindable2 = new BindableInt { BindTarget = bindable1 };
+            int counter = 0, bindable1ValueChange = 0, bindable1MinChange = 0, bindable2ValueChange = 0, bindable2MinChange = 0;
+            bindable1.ValueChanged += _ => bindable1ValueChange = ++counter;
+            bindable1.MinValueChanged += _ => bindable1MinChange = ++counter;
+            bindable2.ValueChanged += _ => bindable2ValueChange = ++counter;
+            bindable2.MinValueChanged += _ => bindable2MinChange = ++counter;
+
+            bindable1.MinValue = 3;
+
+            Assert.That(bindable2MinChange, Is.EqualTo(1));
+            Assert.That(bindable1MinChange, Is.EqualTo(2));
+            Assert.That(bindable2ValueChange, Is.EqualTo(3));
+            Assert.That(bindable1ValueChange, Is.EqualTo(4));
+        }
+
+        [Test]
+        public void TestDefaultMinValueAppliedInConstructor()
+        {
+            var bindable = new BindableNumberWithDefaultMinValue(2);
+
+            Assert.That(bindable.Value, Is.EqualTo(3));
+        }
+
+        private class BindableNumberWithDefaultMaxValue : BindableInt
+        {
+            public BindableNumberWithDefaultMaxValue(int value = 0)
+                : base(value)
+            {
+            }
+
+            protected override int DefaultMaxValue => 1;
+        }
+
+        private class BindableNumberWithDefaultMinValue : BindableInt
+        {
+            public BindableNumberWithDefaultMinValue(int value = 0)
+                : base(value)
+            {
+            }
+
+            protected override int DefaultMinValue => 3;
+        }
+    }
+}

osu.Framework.Tests/Platform/GameHostSuspendTest.cs

···
 
             host.Suspend();
 
-            completed.Reset();
+            // in single-threaded execution, the main thread may already be in the process of updating one last time.
+            int gameUpdates = 0;
+            game.Scheduler.AddDelayed(() => ++gameUpdates, 0, true);
+            Assert.That(() => gameUpdates, Is.LessThan(2).After(timeout / 10));
 
             // check that scheduler doesn't process while suspended..
+            completed.Reset();
             game.Schedule(() => completed.Set());
             Assert.IsFalse(completed.Wait(timeout / 10));
 
+            // ..and does after resume.
             host.Resume();
-
-            // ..and does after resume.
             Assert.IsTrue(completed.Wait(timeout / 10));
 
             game.Exit();
-
             Assert.IsTrue(task.Wait(timeout));
         }
 

osu.Framework.Tests/Visual/Audio/TestSceneSampleChannels.cs

···
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Platform;
+using osu.Framework.Threading;
 
 namespace osu.Framework.Tests.Visual.Audio
 {
···
     {
         [Resolved]
         private ISampleStore sampleStore { get; set; }
+
+        [Resolved]
+        private GameHost host { get; set; }
 
         private Sample sample;
 
···
             AddUntilStep("wait for channel 1 to end", () => !channel.Playing);
             AddStep("play channel 1 again", () => channel.Play());
 
-            // Create another channel purely for tracking purposes in order to avoid timing issues.
-            // When this channel is playing, the audio thread is guaranteed to have processed the above channel.
-            SampleChannel channel2 = null;
-            AddStep("play a silent channel 2", () =>
+            int audioFrames = 0;
+            AddStep("begin tracking audio frames", () =>
             {
-                channel2 = sample.GetChannel();
-                channel2.Volume.Value = 0;
-                channel2.Play();
+                audioFrames = 0;
+
+                ScheduledDelegate del = null;
+                del = host.AudioThread.Scheduler.AddDelayed(() =>
+                {
+                    // ReSharper disable once AccessToModifiedClosure
+                    if (++audioFrames >= 2)
+                        del?.Cancel();
+                }, 0, true);
             });
 
-            AddUntilStep("channel 2 playing", () => channel2.Playing);
+            AddUntilStep("wait for two audio frames", () => audioFrames >= 2);
             AddAssert("channel 1 not playing", () => !channel.Playing);
         }
 

osu.Framework.Tests/Visual/Drawables/TestSceneDelayedLoadWrapper.cs

···
             AddUntilStep("repeating schedulers removed", () => !scroll.Scheduler.HasPendingTasks);
         }
 
-        [Test]
-        public void TestLifetimeOutwardsPropagation()
-        {
-            Container wrapped = null;
-            DelayedLoadWrapper wrapper = null;
-
-            AddStep("create child", () =>
-            {
-                flow.Add(new Container
-                {
-                    Size = new Vector2(128),
-                    Children = new Drawable[]
-                    {
-                        wrapper = new DelayedLoadWrapper(wrapped = new Container
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Children = new Drawable[]
-                            {
-                                new TestBox(() => loaded++) { RelativeSizeAxes = Axes.Both }
-                            }
-                        }),
-                    }
-                });
-
-                wrapper.DelayedLoadComplete += content => content.FadeOut(500).Expire();
-            });
-
-            AddAssert("wrapper lifetime equals content lifetime", () => wrapper.LifetimeEnd == wrapped.LifetimeEnd);
-
-            AddUntilStep("wrapper expired", () => !wrapper.IsAlive);
-        }
-
-        [Test]
-        public void TestLifetimeInwardsPropagation()
-        {
-            Container wrapped = null;
-            DelayedLoadWrapper wrapper = null;
-            double lifetimeEnd = 0;
-
-            AddStep("create child", () =>
-            {
-                flow.Add(new Container
-                {
-                    Size = new Vector2(128),
-                    Children = new Drawable[]
-                    {
-                        wrapper = new DelayedLoadWrapper(wrapped = new Container
-                        {
-                            // this lifetime will be overwritten by the one on the wrapper.
-                            LifetimeEnd = Time.Current + 4000,
-                            RelativeSizeAxes = Axes.Both,
-                            Children = new Drawable[]
-                            {
-                                new TestBox(() => loaded++) { RelativeSizeAxes = Axes.Both }
-                            }
-                        })
-                        {
-                            LifetimeEnd = lifetimeEnd = Time.Current + 2000,
-                        }
-                    }
-                });
-            });
-
-            AddUntilStep("wait for load", () => wrapper.DelayedLoadCompleted);
-
-            AddAssert("wrapper lifetime is correct", () => wrapper.LifetimeEnd == lifetimeEnd);
-            AddAssert("content lifetime is correct", () => wrapped.LifetimeEnd == lifetimeEnd);
-
-            AddUntilStep("wrapper expired", () => !wrapper.IsAlive);
-        }
-
         [TestCase(false)]
         [TestCase(true)]
         public void TestManyChildrenFunction(bool instant)

osu.Framework.Tests/Visual/UserInterface/TestSceneDropdown.cs

···
         private float calculatedHeight;
         private readonly TestDropdown testDropdown, testDropdownMenu, bindableDropdown, emptyDropdown, disabledDropdown;
         private readonly PlatformActionContainer platformActionContainerKeyboardSelection, platformActionContainerKeyboardPreselection, platformActionContainerEmptyDropdown;
-        private readonly BindableList<string> bindableList = new BindableList<string>();
+        private readonly BindableList<TestModel> bindableList = new BindableList<TestModel>();
 
         private int previousIndex;
         private int lastVisibleIndexOnTheCurrentPage, lastVisibleIndexOnTheNextPage;
···
 
         public TestSceneDropdown()
         {
-            var testItems = new string[10];
+            var testItems = new TestModel[10];
             int i = 0;
             while (i < items_to_add)
                 testItems[i] = @"test " + i++;
···
         }
 
         [Test]
+        public void TestExternalBindableChangeKeepsSelection()
+        {
+            toggleDropdownViaClick(testDropdown, "dropdown1");
+            AddStep("click item 4", () => testDropdown.SelectItem(testDropdown.Menu.Items[4]));
+
+            AddAssert("item 4 is selected", () => testDropdown.Current.Value.Identifier == "test 4");
+
+            AddStep("replace items", () =>
+            {
+                testDropdown.Items = testDropdown.Items.Select(i => new TestModel(i.ToString())).ToArray();
+            });
+
+            AddAssert("item 4 is selected", () => testDropdown.Current.Value.Identifier == "test 4");
+        }
+
+        [Test]
         public void TestBasic()
         {
             var i = items_to_add;
···
             AddStep("click item 13", () => testDropdown.SelectItem(testDropdown.Menu.Items[13]));
 
             AddAssert("dropdown1 is closed", () => testDropdown.Menu.State == MenuState.Closed);
-            AddAssert("item 13 is selected", () => testDropdown.Current.Value == testDropdown.Items.ElementAt(13));
+            AddAssert("item 13 is selected", () => testDropdown.Current.Value.Equals(testDropdown.Items.ElementAt(13)));
 
             AddStep("select item 15", () => testDropdown.Current.Value = testDropdown.Items.ElementAt(15));
-            AddAssert("item 15 is selected", () => testDropdown.Current.Value == testDropdown.Items.ElementAt(15));
+            AddAssert("item 15 is selected", () => testDropdown.Current.Value.Equals(testDropdown.Items.ElementAt(15)));
 
             toggleDropdownViaClick(testDropdown, "dropdown1");
             AddAssert("dropdown1 is open", () => testDropdown.Menu.State == MenuState.Open);
···
 
             AddStep("select 'invalid'", () => testDropdown.Current.Value = "invalid");
 
-            AddAssert("'invalid' is selected", () => testDropdown.Current.Value == "invalid");
+            AddAssert("'invalid' is selected", () => testDropdown.Current.Value.Identifier == "invalid");
             AddAssert("label shows 'invalid'", () => testDropdown.Header.Label.ToString() == "invalid");
 
             AddStep("select item 2", () => testDropdown.Current.Value = testDropdown.Items.ElementAt(2));
-            AddAssert("item 2 is selected", () => testDropdown.Current.Value == testDropdown.Items.ElementAt(2));
+            AddAssert("item 2 is selected", () => testDropdown.Current.Value.Equals(testDropdown.Items.ElementAt(2)));
 
             AddStep("clear bindable list", () => bindableList.Clear());
             toggleDropdownViaClick(bindableDropdown, "dropdown3");
             AddAssert("no elements in bindable dropdown", () => !bindableDropdown.Items.Any());
 
-            AddStep("add items to bindable", () => bindableList.AddRange(new[] { "one", "two", "three" }));
-            AddAssert("three items in dropdown", () => bindableDropdown.Items.Count() == 3);
-
+            AddStep("add items to bindable", () => bindableList.AddRange(new[] { "one", "two", "three" }.Select(s => new TestModel(s))));
             AddStep("select three", () => bindableDropdown.Current.Value = "three");
             AddStep("remove first item from bindable", () => bindableList.RemoveAt(0));
             AddAssert("two items in dropdown", () => bindableDropdown.Items.Count() == 2);
-            AddAssert("current value still three", () => bindableDropdown.Current.Value == "three");
+            AddAssert("current value still three", () => bindableDropdown.Current.Value.Identifier == "three");
 
             AddStep("remove three", () => bindableList.Remove("three"));
-            AddAssert("current value should be two", () => bindableDropdown.Current.Value == "two");
+            AddAssert("current value should be two", () => bindableDropdown.Current.Value.Identifier == "two");
         }
 
         private void performKeypress(Drawable drawable, Key key)
···
         public void TestSelectNull()
         {
             AddStep("select item 1", () => testDropdown.Current.Value = testDropdown.Items.ElementAt(1));
-            AddAssert("item 1 is selected", () => testDropdown.Current.Value == testDropdown.Items.ElementAt(1));
+            AddAssert("item 1 is selected", () => testDropdown.Current.Value.Equals(testDropdown.Items.ElementAt(1)));
             AddStep("select item null", () => testDropdown.Current.Value = null);
             AddAssert("null is selected", () => testDropdown.Current.Value == null);
         }
···
         [Test]
         public void TestDisabledCurrent()
         {
-            string originalValue = null;
+            TestModel originalValue = null;
 
             AddStep("store original value", () => originalValue = disabledDropdown.Current.Value);
 
···
             AddStep("disable current", () => disabledDropdown.Current.Disabled = true);
             assertDropdownIsClosed(disabledDropdown);
 
-            void valueIsUnchanged() => AddAssert("value is unchanged", () => disabledDropdown.Current.Value == originalValue);
+            void valueIsUnchanged() => AddAssert("value is unchanged", () => disabledDropdown.Current.Value.Equals(originalValue));
         }
 
         private void toggleDropdownViaClick(TestDropdown dropdown, string dropdownName = null) => AddStep($"click {dropdownName ?? "dropdown"}", () =>
···
 
         private void assertDropdownIsClosed(TestDropdown dropdown) => AddAssert("dropdown is closed", () => dropdown.Menu.State == MenuState.Closed);
 
-        private class TestDropdown : BasicDropdown<string>
+        private class TestModel : IEquatable<TestModel>
+        {
+            public readonly string Identifier;
+
+            public TestModel(string identifier)
+            {
+                Identifier = identifier;
+            }
+
+            public bool Equals(TestModel other)
+            {
+                if (other == null)
+                    return false;
+
+                return other.Identifier == Identifier;
+            }
+
+            public override string ToString() => Identifier;
+
+            public static implicit operator TestModel(string str) => new TestModel(str);
+        }
+
+        private class TestDropdown : BasicDropdown<TestModel>
         {
             public new DropdownMenu Menu => base.Menu;
 
···
                     .TriggerEvent(new ClickEvent(GetContainingInputManager().CurrentState, MouseButton.Left));
             }
 
-            internal new DropdownMenuItem<string> SelectedItem => base.SelectedItem;
+            internal new DropdownMenuItem<TestModel> SelectedItem => base.SelectedItem;
 
             public int SelectedIndex => Menu.DrawableMenuItems.Select(d => d.Item).ToList().IndexOf(SelectedItem);
             public int PreselectedIndex => Menu.DrawableMenuItems.ToList().IndexOf(Menu.PreselectedItem);

osu.Framework.Tests/Visual/UserInterface/TestSceneMarkdownContainer.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Containers.Markdown;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.IO.Network;
 
 namespace osu.Framework.Tests.Visual.UserInterface
···
             {
                 UrlAdded = url => Links.Add(url)
             };
+
+            public override SpriteText CreateSpriteText() => base.CreateSpriteText().With(t => t.Font = t.Font.With("OpenSans", weight: "Regular"));
 
             private class TestMarkdownTextFlowContainer : MarkdownTextFlowContainer
             {

osu.Framework/Audio/AudioManager.cs

···
             if (!device.IsEnabled)
                 return false;
 
-            // same device
-            if (device.IsInitialized && deviceIndex == Bass.CurrentDevice)
-                return true;
-
             // initialize new device
             bool initSuccess = InitBass(deviceIndex);
             if (Bass.LastError != Errors.Already && BassUtils.CheckFaulted(false))

osu.Framework/Audio/Sample/SampleChannelBass.cs

···
                 if (Played && Bass.ChannelIsActive(channel) == PlaybackState.Stopped)
                     return;
 
-                if (relativeFrequencyHandler.IsFrequencyZero)
-                    return;
+                playing = true;
 
-                Bass.ChannelPlay(channel);
-                playing = true;
+                if (!relativeFrequencyHandler.IsFrequencyZero)
+                    Bass.ChannelPlay(channel);
             }
             finally
             {

osu.Framework/Bindables/BindableMarginPadding.cs

···
 
 namespace osu.Framework.Bindables
 {
-    public class BindableMarginPadding : Bindable<MarginPadding>
+    public class BindableMarginPadding : RangeConstrainedBindable<MarginPadding>
     {
-        public BindableMarginPadding(MarginPadding value = default)
-            : base(value)
-        {
-            MinValue = DefaultMinValue;
-            MaxValue = DefaultMaxValue;
-        }
+        protected override MarginPadding DefaultMinValue => new MarginPadding(float.MinValue);
+        protected override MarginPadding DefaultMaxValue => new MarginPadding(float.MaxValue);
 
-        public MarginPadding MinValue { get; set; }
-        public MarginPadding MaxValue { get; set; }
-
-        protected MarginPadding DefaultMinValue => new MarginPadding(float.MinValue);
-        protected MarginPadding DefaultMaxValue => new MarginPadding(float.MaxValue);
-
-        public override MarginPadding Value
+        public BindableMarginPadding(MarginPadding defaultValue = default)
+            : base(defaultValue)
         {
-            get => base.Value;
-            set => base.Value = clamp(value, MinValue, MaxValue);
-        }
-
-        public override void BindTo(Bindable<MarginPadding> them)
-        {
-            if (them is BindableMarginPadding other)
-            {
-                MinValue = new MarginPadding
-                {
-                    Top = Math.Max(MinValue.Top, other.MinValue.Top),
-                    Left = Math.Max(MinValue.Left, other.MinValue.Left),
-                    Bottom = Math.Max(MinValue.Bottom, other.MinValue.Bottom),
-                    Right = Math.Max(MinValue.Right, other.MinValue.Right)
-                };
-
-                MaxValue = new MarginPadding
-                {
-                    Top = Math.Min(MaxValue.Top, other.MaxValue.Top),
-                    Left = Math.Min(MaxValue.Left, other.MaxValue.Left),
-                    Bottom = Math.Min(MaxValue.Bottom, other.MaxValue.Bottom),
-                    Right = Math.Min(MaxValue.Right, other.MaxValue.Right)
-                };
-
-                if (MinValue.Top > MaxValue.Top || MinValue.Left > MaxValue.Left || MinValue.Bottom > MaxValue.Bottom || MinValue.Right > MaxValue.Right)
-                {
-                    throw new ArgumentOutOfRangeException(
-                        nameof(them),
-                        $"Can not weld BindableMarginPaddings with non-overlapping min/max-ranges. The ranges were [{MinValue} - {MaxValue}] and [{other.MinValue} - {other.MaxValue}]."
-                    );
-                }
-            }
-
-            base.BindTo(them);
         }
 
         public override string ToString() => Value.ToString();
···
             }
         }
 
-        private static MarginPadding clamp(MarginPadding value, MarginPadding minValue, MarginPadding maxValue) =>
-            new MarginPadding
+        protected sealed override MarginPadding ClampValue(MarginPadding value, MarginPadding minValue, MarginPadding maxValue)
+        {
+            return new MarginPadding
             {
-                Top = Math.Max(minValue.Top, Math.Min(maxValue.Top, value.Top)),
-                Left = Math.Max(minValue.Left, Math.Min(maxValue.Left, value.Left)),
-                Bottom = Math.Max(minValue.Bottom, Math.Min(maxValue.Bottom, value.Bottom)),
-                Right = Math.Max(minValue.Right, Math.Min(maxValue.Right, value.Right))
+                Top = Math.Clamp(value.Top, minValue.Top, maxValue.Top),
+                Left = Math.Clamp(value.Left, minValue.Left, maxValue.Left),
+                Bottom = Math.Clamp(value.Bottom, minValue.Bottom, maxValue.Bottom),
+                Right = Math.Clamp(value.Right, minValue.Right, maxValue.Right)
             };
+        }
+
+        protected sealed override bool IsValidRange(MarginPadding min, MarginPadding max)
+        {
+            return min.Top <= max.Top &&
+                   min.Left <= max.Left &&
+                   min.Bottom <= max.Bottom &&
+                   min.Right <= max.Right;
+        }
     }
 }

osu.Framework/Bindables/BindableNumber.cs

···
 
 namespace osu.Framework.Bindables
 {
-    public class BindableNumber<T> : Bindable<T>, IBindableNumber<T>
+    public class BindableNumber<T> : RangeConstrainedBindable<T>, IBindableNumber<T>
         where T : struct, IComparable<T>, IConvertible, IEquatable<T>
     {
         public event Action<T> PrecisionChanged;
 
-        public event Action<T> MinValueChanged;
-
-        public event Action<T> MaxValueChanged;
-
         public BindableNumber(T defaultValue = default)
             : base(defaultValue)
         {
···
                     $"{nameof(BindableNumber<T>)} only accepts the primitive numeric types (except for {typeof(decimal).FullName}) as type arguments. You provided {typeof(T).FullName}.");
             }
 
-            minValue = DefaultMinValue;
-            maxValue = DefaultMaxValue;
             precision = DefaultPrecision;
 
-            // Re-apply the current value to apply the default min/max/precision values
-            SetValue(Value);
+            // Re-apply the current value to apply the default precision value
+            setValue(Value);
         }
 
         private T precision;
···
             if (updateCurrentValue)
             {
                 // Re-apply the current value to apply the new precision
-                SetValue(Value);
+                setValue(Value);
             }
         }
 
         public override T Value
         {
             get => base.Value;
-            set => SetValue(value);
+            set => setValue(value);
         }
 
-        internal void SetValue(T value)
+        private void setValue(T value)
         {
             if (Precision.CompareTo(DefaultPrecision) > 0)
             {
-                double doubleValue = clamp(value, MinValue, MaxValue).ToDouble(NumberFormatInfo.InvariantInfo);
+                double doubleValue = ClampValue(value, MinValue, MaxValue).ToDouble(NumberFormatInfo.InvariantInfo);
                 doubleValue = Math.Round(doubleValue / Precision.ToDouble(NumberFormatInfo.InvariantInfo)) * Precision.ToDouble(NumberFormatInfo.InvariantInfo);
 
                 base.Value = (T)Convert.ChangeType(doubleValue, typeof(T), CultureInfo.InvariantCulture);
             }
             else
-                base.Value = clamp(value, MinValue, MaxValue);
-        }
-
-        private T minValue;
-
-        public T MinValue
-        {
-            get => minValue;
-            set
-            {
-                if (minValue.Equals(value))
-                    return;
-
-                SetMinValue(value, true, this);
-            }
-        }
-
-        /// <summary>
-        /// Sets the minimum value. This method does no equality comparisons.
-        /// </summary>
-        /// <param name="minValue">The new minimum value.</param>
-        /// <param name="updateCurrentValue">Whether to update the current value after the minimum value is set.</param>
-        /// <param name="source">The bindable that triggered this. A null value represents the current bindable instance.</param>
-        internal void SetMinValue(T minValue, bool updateCurrentValue, BindableNumber<T> source)
-        {
-            this.minValue = minValue;
-            TriggerMinValueChange(source);
-
-            if (updateCurrentValue)
-            {
-                // Re-apply the current value to apply the new minimum value
-                SetValue(Value);
-            }
-        }
-
-        private T maxValue;
-
-        public T MaxValue
-        {
-            get => maxValue;
-            set
-            {
-                if (maxValue.Equals(value))
-                    return;
-
-                SetMaxValue(value, true, this);
-            }
-        }
-
-        /// <summary>
-        /// Sets the maximum value. This method does no equality comparisons.
-        /// </summary>
-        /// <param name="maxValue">The new maximum value.</param>
-        /// <param name="updateCurrentValue">Whether to update the current value after the maximum value is set.</param>
-        /// <param name="source">The bindable that triggered this. A null value represents the current bindable instance.</param>
-        internal void SetMaxValue(T maxValue, bool updateCurrentValue, BindableNumber<T> source)
-        {
-            this.maxValue = maxValue;
-            TriggerMaxValueChange(source);
-
-            if (updateCurrentValue)
-            {
-                // Re-apply the current value to apply the new maximum value
-                SetValue(Value);
-            }
+                base.Value = value;
         }
 
-        /// <summary>
-        /// The default <see cref="MinValue"/>. This should be equal to the minimum value of type <typeparamref name="T"/>.
-        /// </summary>
-        protected virtual T DefaultMinValue
+        protected override T DefaultMinValue
         {
             get
             {
···
             }
         }
 
-        /// <summary>
-        /// The default <see cref="MaxValue"/>. This should be equal to the maximum value of type <typeparamref name="T"/>.
-        /// </summary>
-        protected virtual T DefaultMaxValue
+        protected override T DefaultMaxValue
         {
             get
             {
···
             base.TriggerChange();
 
             TriggerPrecisionChange(this, false);
-            TriggerMinValueChange(this, false);
-            TriggerMaxValueChange(this, false);
         }
 
         protected void TriggerPrecisionChange(BindableNumber<T> source = null, bool propagateToBindings = true)
···
                 PrecisionChanged?.Invoke(precision);
         }
 
-        protected void TriggerMinValueChange(BindableNumber<T> source = null, bool propagateToBindings = true)
-        {
-            // check a bound bindable hasn't changed the value again (it will fire its own event)
-            T beforePropagation = minValue;
-
-            if (propagateToBindings && Bindings != null)
-            {
-                foreach (var b in Bindings)
-                {
-                    if (b == source) continue;
-
-                    if (b is BindableNumber<T> bn)
-                        bn.SetMinValue(minValue, false, this);
-                }
-            }
-
-            if (beforePropagation.Equals(minValue))
-                MinValueChanged?.Invoke(minValue);
-        }
-
-        protected void TriggerMaxValueChange(BindableNumber<T> source = null, bool propagateToBindings = true)
-        {
-            // check a bound bindable hasn't changed the value again (it will fire its own event)
-            T beforePropagation = maxValue;
-
-            if (propagateToBindings && Bindings != null)
-            {
-                foreach (var b in Bindings)
-                {
-                    if (b == source) continue;
-
-                    if (b is BindableNumber<T> bn)
-                        bn.SetMaxValue(maxValue, false, this);
-                }
-            }
-
-            if (beforePropagation.Equals(maxValue))
-                MaxValueChanged?.Invoke(maxValue);
-        }
-
         public override void BindTo(Bindable<T> them)
         {
             if (them is BindableNumber<T> other)
-            {
                 Precision = other.Precision;
-                MinValue = other.MinValue;
-                MaxValue = other.MaxValue;
-
-                if (MinValue.CompareTo(MaxValue) > 0)
-                {
-                    throw new ArgumentOutOfRangeException(
-                        nameof(them), $"Can not weld bindable longs with non-overlapping min/max-ranges. The ranges were [{MinValue} - {MaxValue}] and [{other.MinValue} - {other.MaxValue}].");
-                }
-            }
 
             base.BindTo(them);
         }
-
-        /// <summary>
-        /// Whether this bindable has a user-defined range that is not the full range of the <typeparamref name="T"/> type.
-        /// </summary>
-        public bool HasDefinedRange => !MinValue.Equals(DefaultMinValue) || !MaxValue.Equals(DefaultMaxValue);
 
         public bool IsInteger =>
             typeof(T) != typeof(float) &&
···
             }
         }
 
+        protected sealed override T ClampValue(T value, T minValue, T maxValue) => max(minValue, min(maxValue, value));
+
+        protected sealed override bool IsValidRange(T min, T max) => min.CompareTo(max) <= 0;
+
         private static T max(T value1, T value2)
         {
             var comparison = value1.CompareTo(value2);
···
             var comparison = value1.CompareTo(value2);
             return comparison > 0 ? value2 : value1;
         }
-
-        private static T clamp(T value, T minValue, T maxValue)
-            => max(minValue, min(maxValue, value));
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool isSupportedType() =>

osu.Framework/Bindables/BindableSize.cs

···
 
 namespace osu.Framework.Bindables
 {
-    public class BindableSize : Bindable<Size>
+    /// <summary>
+    /// Represents a <see cref="Size"/> bindable with defined component-wise constraints applied to it.
+    /// </summary>
+    public class BindableSize : RangeConstrainedBindable<Size>
     {
-        public BindableSize(Size value = default)
-            : base(value)
-        {
-            MinValue = DefaultMinValue;
-            MaxValue = DefaultMaxValue;
-        }
+        protected override Size DefaultMinValue => new Size(int.MinValue, int.MinValue);
+        protected override Size DefaultMaxValue => new Size(int.MaxValue, int.MaxValue);
 
-        public Size MinValue { get; set; }
-        public Size MaxValue { get; set; }
-
-        protected Size DefaultMinValue => new Size(int.MinValue, int.MinValue);
-        protected Size DefaultMaxValue => new Size(int.MaxValue, int.MaxValue);
-
-        public override Size Value
+        public BindableSize(Size defaultValue = default)
+            : base(defaultValue)
         {
-            get => base.Value;
-            set => base.Value = clamp(value, MinValue, MaxValue);
-        }
-
-        public override void BindTo(Bindable<Size> them)
-        {
-            if (them is BindableSize other)
-            {
-                MinValue = new Size(Math.Max(MinValue.Width, other.MinValue.Width), Math.Max(MinValue.Height, other.MinValue.Height));
-                MaxValue = new Size(Math.Min(MaxValue.Width, other.MaxValue.Width), Math.Min(MaxValue.Height, other.MaxValue.Height));
-
-                if (MinValue.Width > MaxValue.Width || MinValue.Height > MaxValue.Height)
-                {
-                    throw new ArgumentOutOfRangeException(
-                        nameof(them),
-                        $"Can not weld BindableSizes with non-overlapping min/max-ranges. The ranges were [{MinValue} - {MaxValue}] and [{other.MinValue} - {other.MaxValue}]."
-                    );
-                }
-            }
-
-            base.BindTo(them);
         }
 
         public override string ToString() => $"{Value.Width}x{Value.Height}";
···
             }
         }
 
-        private static Size clamp(Size value, Size minValue, Size maxValue) =>
-            new Size(
-                Math.Max(minValue.Width, Math.Min(value.Width, maxValue.Width)),
-                Math.Max(minValue.Height, Math.Min(value.Height, maxValue.Height))
-            );
+        protected sealed override Size ClampValue(Size value, Size minValue, Size maxValue)
+        {
+            return new Size
+            {
+                Width = Math.Clamp(value.Width, minValue.Width, maxValue.Width),
+                Height = Math.Clamp(value.Height, minValue.Height, maxValue.Height)
+            };
+        }
+
+        protected sealed override bool IsValidRange(Size min, Size max) => min.Width <= max.Width && min.Height <= max.Height;
     }
 }

osu.Framework/Bindables/RangeConstrainedBindable.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+
+namespace osu.Framework.Bindables
+{
+    public abstract class RangeConstrainedBindable<T> : Bindable<T>
+    {
+        public event Action<T> MinValueChanged;
+
+        public event Action<T> MaxValueChanged;
+
+        private T minValue;
+
+        public T MinValue
+        {
+            get => minValue;
+            set
+            {
+                if (EqualityComparer<T>.Default.Equals(value, minValue))
+                    return;
+
+                SetMinValue(value, true, this);
+            }
+        }
+
+        private T maxValue;
+
+        public T MaxValue
+        {
+            get => maxValue;
+            set
+            {
+                if (EqualityComparer<T>.Default.Equals(value, maxValue))
+                    return;
+
+                SetMaxValue(value, true, this);
+            }
+        }
+
+        public override T Value
+        {
+            get => base.Value;
+            set => setValue(value);
+        }
+
+        /// <summary>
+        /// The default <see cref="MinValue"/>. This should be equal to the minimum value of type <typeparamref name="T"/>.
+        /// </summary>
+        protected abstract T DefaultMinValue { get; }
+
+        /// <summary>
+        /// The default <see cref="MaxValue"/>. This should be equal to the maximum value of type <typeparamref name="T"/>.
+        /// </summary>
+        protected abstract T DefaultMaxValue { get; }
+
+        /// <summary>
+        /// Whether this bindable has a user-defined range that is not the full range of the <typeparamref name="T"/> type.
+        /// </summary>
+        public bool HasDefinedRange => !EqualityComparer<T>.Default.Equals(MinValue, DefaultMinValue) ||
+                                       !EqualityComparer<T>.Default.Equals(MaxValue, DefaultMaxValue);
+
+        protected RangeConstrainedBindable(T defaultValue = default)
+            : base(defaultValue)
+        {
+            minValue = DefaultMinValue;
+            maxValue = DefaultMaxValue;
+
+            // Reapply the default value here for respecting the defined default min/max values.
+            setValue(defaultValue);
+        }
+
+        /// <summary>
+        /// Sets the minimum value. This method does no equality comparisons.
+        /// </summary>
+        /// <param name="minValue">The new minimum value.</param>
+        /// <param name="updateCurrentValue">Whether to update the current value after the minimum value is set.</param>
+        /// <param name="source">The bindable that triggered this. A null value represents the current bindable instance.</param>
+        internal void SetMinValue(T minValue, bool updateCurrentValue, RangeConstrainedBindable<T> source)
+        {
+            this.minValue = minValue;
+            TriggerMinValueChange(source);
+
+            if (updateCurrentValue)
+            {
+                // Reapply the current value to respect the new minimum value.
+                setValue(Value);
+            }
+        }
+
+        /// <summary>
+        /// Sets the maximum value. This method does no equality comparisons.
+        /// </summary>
+        /// <param name="maxValue">The new maximum value.</param>
+        /// <param name="updateCurrentValue">Whether to update the current value after the maximum value is set.</param>
+        /// <param name="source">The bindable that triggered this. A null value represents the current bindable instance.</param>
+        internal void SetMaxValue(T maxValue, bool updateCurrentValue, RangeConstrainedBindable<T> source)
+        {
+            this.maxValue = maxValue;
+            TriggerMaxValueChange(source);
+
+            if (updateCurrentValue)
+            {
+                // Reapply the current value to respect the new maximum value.
+                setValue(Value);
+            }
+        }
+
+        public override void TriggerChange()
+        {
+            base.TriggerChange();
+
+            TriggerMinValueChange(this, false);
+            TriggerMaxValueChange(this, false);
+        }
+
+        protected void TriggerMinValueChange(RangeConstrainedBindable<T> source = null, bool propagateToBindings = true)
+        {
+            // check a bound bindable hasn't changed the value again (it will fire its own event)
+            T beforePropagation = minValue;
+
+            if (propagateToBindings && Bindings != null)
+            {
+                foreach (var b in Bindings)
+                {
+                    if (b == source) continue;
+
+                    if (b is RangeConstrainedBindable<T> cb)
+                        cb.SetMinValue(minValue, false, this);
+                }
+            }
+
+            if (EqualityComparer<T>.Default.Equals(beforePropagation, minValue))
+                MinValueChanged?.Invoke(minValue);
+        }
+
+        protected void TriggerMaxValueChange(RangeConstrainedBindable<T> source = null, bool propagateToBindings = true)
+        {
+            // check a bound bindable hasn't changed the value again (it will fire its own event)
+            T beforePropagation = maxValue;
+
+            if (propagateToBindings && Bindings != null)
+            {
+                foreach (var b in Bindings)
+                {
+                    if (b == source) continue;
+
+                    if (b is RangeConstrainedBindable<T> cb)
+                        cb.SetMaxValue(maxValue, false, this);
+                }
+            }
+
+            if (EqualityComparer<T>.Default.Equals(beforePropagation, maxValue))
+                MaxValueChanged?.Invoke(maxValue);
+        }
+
+        public override void BindTo(Bindable<T> them)
+        {
+            if (them is RangeConstrainedBindable<T> other)
+            {
+                if (!IsValidRange(other.MinValue, other.MaxValue))
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(them), $"The target bindable has specified an invalid range of [{other.MinValue} - {other.MaxValue}].");
+                }
+
+                MinValue = other.MinValue;
+                MaxValue = other.MaxValue;
+            }
+
+            base.BindTo(them);
+        }
+
+        public new RangeConstrainedBindable<T> GetBoundCopy() => (RangeConstrainedBindable<T>)base.GetBoundCopy();
+
+        public new RangeConstrainedBindable<T> GetUnboundCopy() => (RangeConstrainedBindable<T>)base.GetUnboundCopy();
+
+        /// <summary>
+        /// Clamps <paramref name="value"/> to the range defined by <paramref name="minValue"/> and <paramref name="maxValue"/>.
+        /// </summary>
+        protected abstract T ClampValue(T value, T minValue, T maxValue);
+
+        /// <summary>
+        /// Whether <paramref name="min"/> and <paramref name="max"/> constitute a valid range
+        /// (usually used to check that <paramref name="min"/> is indeed lesser than or equal to <paramref name="max"/>).
+        /// </summary>
+        /// <param name="min">The range's minimum value.</param>
+        /// <param name="max">The range's maximum value.</param>
+        protected abstract bool IsValidRange(T min, T max);
+
+        private void setValue(T value) => base.Value = ClampValue(value, minValue, maxValue);
+    }
+}

osu.Framework/Graphics/Containers/ContainerExtensions.cs

···
 
             drawable.Position = Vector2.Zero;
             drawable.Rotation = 0;
-            drawable.Anchor = Anchor.TopLeft;
-            drawable.Origin = Anchor.TopLeft;
 
             // For anchor/origin positioning to be preserved correctly,
             // relatively sized axes must be lifted to the wrapping container.

osu.Framework/Graphics/Containers/DelayedLoadWrapper.cs

···
     /// Has the ability to delay the loading until it has been visible on-screen for a specified duration.
     /// In order to benefit from delayed load, we must be inside a <see cref="ScrollContainer{T}"/>.
     /// </summary>
-    /// <remarks>
-    /// <see cref="LifetimeStart"/> and <see cref="LifetimeEnd"/> are propagated from the wrapper to the content on content load.
-    /// After load, the content's lifetime is preferred, meaning any changes to content's lifetime post-load will be respected.
-    /// </remarks>
     public class DelayedLoadWrapper : CompositeDrawable
     {
         [Resolved]
···
 
             AddLayout(optimisingContainerCache);
             AddLayout(isIntersectingCache);
-        }
-
-        private double lifetimeStart = double.MinValue;
-
-        public override double LifetimeStart
-        {
-            get => Content?.LifetimeStart ?? lifetimeStart;
-            set
-            {
-                if (Content != null)
-                    Content.LifetimeStart = value;
-                lifetimeStart = value;
-            }
-        }
-
-        private double lifetimeEnd = double.MaxValue;
-
-        public override double LifetimeEnd
-        {
-            get => Content?.LifetimeEnd ?? lifetimeEnd;
-            set
-            {
-                if (Content != null)
-                    Content.LifetimeEnd = value;
-                lifetimeEnd = value;
-            }
         }
 
         private Drawable content;
···
             // This code is running on the game's scheduler, while this DLW may have been async disposed, so the addition is scheduled locally to prevent adding to disposed DLWs.
             scheduledAddition = Schedule(() =>
             {
-                content.LifetimeStart = lifetimeStart;
-                content.LifetimeEnd = lifetimeEnd;
-
                 AddInternal(content);
 
                 DelayedLoadCompleted = true;

osu.Framework/Graphics/Containers/Markdown/MarkdownTableCell.cs

···
             }
         }
 
-        public MarkdownTextFlowContainer CreateTextFlow()
+        public virtual MarkdownTextFlowContainer CreateTextFlow()
         {
             var flow = parentFlowComponent.CreateTextFlow();
             flow.Padding = new MarginPadding(10);

osu.Framework/Graphics/Containers/Markdown/MarkdownTextFlowContainer.cs

···
             AddDrawable(textDrawable);
         }
 
+        protected override SpriteText CreateSpriteText() => parentTextComponent.CreateSpriteText();
+
         /// <summary>
         /// Creates an emphasised <see cref="SpriteText"/>.
         /// </summary>

osu.Framework/Graphics/UserInterface/Dropdown.cs

···
             foreach (var entry in items)
                 addDropdownItem(GenerateItemText(entry), entry);
 
-            if (Current.Value == null || !itemMap.Keys.Contains(Current.Value))
+            if (Current.Value == null || !itemMap.Keys.Contains(Current.Value, EqualityComparer<T>.Default))
                 Current.Value = itemMap.Keys.FirstOrDefault();
             else
                 Current.TriggerChange();

osu.Framework/Platform/GameHost.cs

···
 
                 ExecutionState = ExecutionState.Running;
 
-                initialiseInputHandlers();
+                populateInputHandlers();
 
                 SetupConfig(game.GetFrameworkConfigDefaults() ?? new Dictionary<FrameworkSetting, object>());
+
+                initialiseInputHandlers();
 
                 if (Window != null)
                 {
···
             Logger.Storage = Storage.GetStorageForDirectory("logs");
         }
 
-        private void initialiseInputHandlers()
+        private void populateInputHandlers()
         {
             AvailableInputHandlers = CreateAvailableInputHandlers().ToImmutableArray();
+        }
 
+        private void initialiseInputHandlers()
+        {
             foreach (var handler in AvailableInputHandlers)
             {
-                (handler as IHasCursorSensitivity)?.Sensitivity.BindTo(cursorSensitivity);
-
                 if (!handler.Initialize(this))
                     handler.Enabled.Value = false;
             }
···
             };
 
 #pragma warning disable 618
+            // pragma region can be removed 20210911
             ignoredInputHandlers = Config.GetBindable<string>(FrameworkSetting.IgnoredInputHandlers);
             ignoredInputHandlers.ValueChanged += e =>
             {
···
 
             Config.BindWith(FrameworkSetting.CursorSensitivity, cursorSensitivity);
 
-            // one way binding to preserve compatibility.
+            var cursorSensitivityHandlers = AvailableInputHandlers.OfType<IHasCursorSensitivity>();
+
+            // one way bindings to preserve compatibility.
             cursorSensitivity.BindValueChanged(val =>
             {
-                foreach (var h in AvailableInputHandlers.OfType<IHasCursorSensitivity>())
+                foreach (var h in cursorSensitivityHandlers)
                     h.Sensitivity.Value = val.NewValue;
             }, true);
+
+            foreach (var h in cursorSensitivityHandlers)
+                h.Sensitivity.BindValueChanged(s => cursorSensitivity.Value = s.NewValue);
 #pragma warning restore 618
 
             PerformanceLogging.BindValueChanged(logging =>
···
                 CultureInfo.DefaultThreadCurrentCulture = culture;
                 CultureInfo.DefaultThreadCurrentUICulture = culture;
 
-                foreach (var t in Threads)
-                {
-                    t.Scheduler.Add(() => { t.CurrentCulture = culture; });
-                }
+                threadRunner.SetCulture(culture);
             }, true);
 
             // intentionally done after everything above to ensure the new configuration location has priority over obsoleted values.

osu.Framework/Platform/HeadlessGameHost.cs

···
             defaultOverrides[FrameworkSetting.AudioDevice] = "No sound";
 
             base.SetupConfig(defaultOverrides);
+
+            if (Enum.TryParse<ExecutionMode>(Environment.GetEnvironmentVariable("OSU_EXECUTION_MODE"), out var mode))
+            {
+                Config.SetValue(FrameworkSetting.ExecutionMode, mode);
+                Logger.Log($"Startup execution mode set to {mode} from envvar");
+            }
         }
 
         protected override void SetupForRun()

osu.Framework/Platform/ThreadRunner.cs

···
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Globalization;
 using System.Linq;
+using System.Threading;
 using osu.Framework.Development;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Logging;
···
 
             // if null, we have not yet got an execution mode, so set this early to allow usage in GameThread.Initialize overrides.
             activeExecutionMode ??= ThreadSafety.ExecutionMode = ExecutionMode;
+            Logger.Log($"Execution mode changed to {activeExecutionMode}");
 
             pauseAllThreads();
 
···
             {
                 mainThread.ActiveHz = GameThread.DEFAULT_ACTIVE_HZ;
                 mainThread.InactiveHz = GameThread.DEFAULT_INACTIVE_HZ;
+            }
+        }
+
+        /// <summary>
+        /// Sets the current culture of all threads to the supplied <paramref name="culture"/>.
+        /// </summary>
+        public void SetCulture(CultureInfo culture)
+        {
+            // for single-threaded mode, switch the current (assumed to be main) thread's culture, since it's actually the one that's running the frames.
+            Thread.CurrentThread.CurrentCulture = culture;
+
+            // for multi-threaded mode, schedule the culture change on all threads.
+            // note that if the threads haven't been created yet (e.g. if the game started single-threaded), this will only store the culture in GameThread.CurrentCulture.
+            // in that case, the stored value will be set on the actual threads after the next Start() call.
+            foreach (var t in Threads)
+            {
+                t.Scheduler.Add(() => t.CurrentCulture = culture);
             }
         }
     }

osu.Framework/osu.Framework.csproj

···
     <PackageReference Include="JetBrains.Annotations" Version="2021.1.0" />
     <PackageReference Include="ppy.osuTK.NS20" Version="1.0.173" />
     <PackageReference Include="StbiSharp" Version="1.0.13" />
-    <PackageReference Include="ppy.SDL2-CS" Version="1.0.225-alpha" />
+    <PackageReference Include="ppy.SDL2-CS" Version="1.0.238-alpha" />
   </ItemGroup>
   <ItemGroup Condition="$(TargetFrameworkIdentifier) == '.NETCoreApp'">
     <!-- DO NOT use ProjectReference for native packaging project.