Version: 230.1.0-pvsdebug

* Add bool array support to shaders

* better setUniform

* less unsafe

* stackalloc, less pointer

.editorconfig

@@ -7,8 +7,23 @@ indent_size = 4
 trim_trailing_whitespace = true
 charset = utf-8
 
+max_line_length = 120
+
+# ReSharper properties
+resharper_csharp_max_line_length = 120
+resharper_csharp_wrap_after_declaration_lpar = true
+resharper_csharp_wrap_arguments_style = chop_if_long
+resharper_csharp_wrap_parameters_style = chop_if_long
+resharper_keep_existing_attribute_arrangement = true
+resharper_place_field_attribute_on_same_line = if_owner_is_single_line
+resharper_wrap_chained_binary_patterns = chop_if_long
+resharper_wrap_chained_method_calls = chop_if_long
+
 [*.{csproj,xml,yml,dll.config,targets,props}]
 indent_size = 2
 
+[nuget.config]
+indent_size = 2
+
 [*.gdsl]
 indent_style = tab

.github/CODEOWNERS

@@ -7,3 +7,6 @@
 **/Toolshed/** @moonheart08
 *Command.cs @moonheart08
 *Commands.cs @moonheart08
+
+# Physics
+**/Robust.Shared/Physics/** @metalgearsloth

.github/workflows/build-docfx.yml

@@ -14,7 +14,7 @@ jobs:
     - name: Setup .NET Core
       uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 7.0.x
+        dotnet-version: 8.0.x
 
     - name: Install dependencies
       run: dotnet restore

.github/workflows/build-test.yml

@@ -10,7 +10,7 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest ] # , macos-latest] - temporarily disabled due to libfreetype.dll errors.
 
     runs-on: ${{ matrix.os }}
 
@@ -22,12 +22,13 @@ jobs:
     - name: Setup .NET Core
       uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 7.0.x
+        dotnet-version: 8.0.x
     - name: Install dependencies
       run: dotnet restore
     - name: Build
       run: dotnet build --no-restore /p:WarningsAsErrors=nullable
-    - name: Test Engine
+    - name: Robust.UnitTesting
       run: dotnet test --no-build Robust.UnitTesting/Robust.UnitTesting.csproj -- NUnit.ConsoleOut=0
-
+    - name: Robust.Analyzers.Tests
+      run: dotnet test --no-build Robust.Analyzers.Tests/Robust.Analyzers.Tests.csproj -- NUnit.ConsoleOut=0
 

.github/workflows/publish-client.yml

@@ -23,7 +23,7 @@ jobs:
     - name: Setup .NET Core
       uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 7.0.x
+        dotnet-version: 8.0.x
 
     - name: Package client
       run: Tools/package_client_build.py -p windows mac linux
@@ -33,10 +33,10 @@ jobs:
         mkdir "release/${{ steps.parse_version.outputs.version }}"
         mv release/*.zip "release/${{ steps.parse_version.outputs.version }}"
 
-    - name: Upload files to centcomm
+    - name: Upload files to Suns
       uses: appleboy/scp-action@master
       with:
-        host: centcomm.spacestation14.io
+        host: suns.spacestation14.com
         username: robust-build-push
         key: ${{ secrets.CENTCOMM_ROBUST_BUILDS_PUSH_KEY }}
         source: "release/${{ steps.parse_version.outputs.version }}"
@@ -46,7 +46,7 @@ jobs:
     - name: Update manifest JSON
       uses: appleboy/ssh-action@master
       with:
-        host: centcomm.spacestation14.io
+        host: suns.spacestation14.com
         username: robust-build-push
         key: ${{ secrets.CENTCOMM_ROBUST_BUILDS_PUSH_KEY }}
         script: /home/robust-build-push/push.ps1 ${{ steps.parse_version.outputs.version }}

.github/workflows/test-content.yml

@@ -21,7 +21,7 @@ jobs:
     - name: Setup .NET Core
       uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 7.0.x
+        dotnet-version: 8.0.x
     - name: Disable submodule autoupdate
       run: touch BuildChecker/DISABLE_SUBMODULE_AUTOUPDATE
 

Directory.Packages.props

@@ -0,0 +1,75 @@
+<Project>
+  <PropertyGroup>
+    <!--
+    We actually set ManagePackageVersionsCentrally manually in another import file.
+    Since .NET SDK 8.0.300, ManagePackageVersionsCentrally is automatically set if Directory.Packages.props exists.
+    https://github.com/NuGet/NuGet.Client/pull/5572
+    We actively negate this here, as we have some packages in tree we don't want such automatic behavior for.
+    We use Directory.Build.props to get copy the state *after* our MSBuild config but before Nuget's config.
+    -->
+    <ManagePackageVersionsCentrally />
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageVersion Include="BenchmarkDotNet" Version="0.13.12" />
+    <PackageVersion Include="DiscordRichPresence" Version="1.2.1.24" />
+    <PackageVersion Include="ILReader.Core" Version="1.0.0.4" />
+    <PackageVersion Include="JetBrains.Annotations" Version="2023.3.0" />
+    <PackageVersion Include="JetBrains.Profiler.Api" Version="1.4.0" />
+    <PackageVersion Include="Linguini.Bundle" Version="0.8.1" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzer.Testing" Version="1.1.1" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.NUnit" Version="1.1.1" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.NUnit" Version="1.1.1" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeCoverage" Version="17.8.0" />
+    <PackageVersion Include="Microsoft.Data.Sqlite.Core" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.DotNet.RemoteExecutor" Version="8.0.0-beta.24059.4" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.ObjectPool" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Primitives" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.ILVerification" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.0" />
+    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageVersion Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageVersion Include="Moq" Version="4.20.70" />
+    <PackageVersion Include="NUnit" Version="4.0.1" />
+    <PackageVersion Include="NUnit.Analyzers" Version="3.10.0" />
+    <PackageVersion Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageVersion Include="Nett" Version="0.15.0" />
+    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.0" />
+    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.7" />
+    <PackageVersion Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" />
+    <PackageVersion Include="Pidgin" Version="3.2.2" />
+    <PackageVersion Include="Robust.Natives" Version="0.1.1" />
+    <PackageVersion Include="Robust.Natives.Cef" Version="120.1.9" />
+    <PackageVersion Include="Robust.Shared.AuthLib" Version="0.1.2" />
+    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.7" />
+    <PackageVersion Include="SQLitePCLRaw.provider.sqlite3" Version="2.1.7" />
+    <PackageVersion Include="Serilog" Version="3.1.1" />
+    <PackageVersion Include="Serilog.Sinks.Loki" Version="4.0.0-beta3" />
+    <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.5" />
+    <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
+    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
+    <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
+    <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
+    <PackageVersion Include="System.Numerics.Vectors" Version="4.5.0" />
+    <PackageVersion Include="System.Memory" Version="4.5.5" />
+    <PackageVersion Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    <PackageVersion Include="TerraFX.Interop.Windows" Version="10.0.22621.5" />
+    <PackageVersion Include="TerraFX.Interop.Xlib" Version="6.4.0" />
+    <PackageVersion Include="VorbisPizza" Version="1.3.0" />
+    <PackageVersion Include="YamlDotNet" Version="13.7.1" />
+    <PackageVersion Include="prometheus-net" Version="8.2.1" />
+    <PackageVersion Include="prometheus-net.DotNetRuntime" Version="4.4.0" />
+    <PackageVersion Include="PolySharp" Version="1.14.1" />
+  </ItemGroup>
+</Project>

Lidgren.Network/CursedHorrorsBeyondOurWildestImagination.cs

@@ -0,0 +1,9 @@
+using System.Runtime.CompilerServices;
+
+// So I wanted to mess with NetIncomingMessage and NetOutgoingMessage from tests.
+// Now.. the instructors are internal...
+// Unless...
+// I mean we have this project here from the weird way we're compiling Lidgren.
+// I could just put this in here... it wouldn't touch the main Lidgren repo at all...
+[assembly: InternalsVisibleTo("Robust.UnitTesting")]
+

Lidgren.Network/Lidgren.Network.csproj

@@ -10,9 +10,14 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 
     <SkipRobustAnalyzer>true</SkipRobustAnalyzer>
+
+    <Nullable>enable</Nullable>
+    <LangVersion>12.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Include="CursedHorrorsBeyondOurWildestImagination.cs" />
+
     <Compile Include="Lidgren.Network\Lidgren.Network\**\*.cs">
      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
     </Compile>

MSBuild/Robust.Engine.Version.props

@@ -1,4 +1,4 @@
 <Project>
 
-    <!-- This file automatically reset by Tools/version.py -->
+    <!-- This file automatically reset by Tools/version.py -->
 

MSBuild/Robust.Engine.props

@@ -1,8 +1,8 @@
 <Project>
     <!-- Engine-specific properties. Content should not use this file. -->
     <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
-        <LangVersion>11</LangVersion>
+        <TargetFramework>net8.0</TargetFramework>
+        <LangVersion>12</LangVersion>
         <Nullable>enable</Nullable>
         <WarningsAsErrors>nullable</WarningsAsErrors>
     </PropertyGroup>

MSBuild/Robust.Properties.targets

@@ -3,7 +3,8 @@
   <!-- Import this at the end of any project files in Robust and Content. -->
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
 
   <Import Project="Robust.Custom.targets" Condition="Exists('Robust.Custom.targets')"/>
@@ -27,5 +28,5 @@
   <Import Project="Robust.Analyzers.targets" Condition="'$(SkipRobustAnalyzer)' != 'true'" />
 
   <!-- serialization generator -->
-  <Import Project="Robust.Serialization.Generator.targets" />
+  <Import Project="Robust.Serialization.Generator.targets" Condition="'$(SkipRobustAnalyzer)' != 'true'" />
 </Project>

MSBuild/XamlIL.targets

@@ -24,12 +24,16 @@
     <RobustInjectorsConfiguration>$(Configuration)</RobustInjectorsConfiguration>
     <RobustInjectorsConfiguration Condition="'$(Configuration)' == 'DebugOpt'">Debug</RobustInjectorsConfiguration>
     <RobustInjectorsConfiguration Condition="'$(Configuration)' == 'Tools'">Release</RobustInjectorsConfiguration>
+    <RobustInjectorsConfiguration Condition="'$(UseArtifactsOutput)' == 'true' And '$(RuntimeIdentifier)' != ''">$(RobustInjectorsConfiguration)_$(RuntimeIdentifier)</RobustInjectorsConfiguration>
+    <RobustInjectorsConfiguration Condition="'$(UseArtifactsOutput)' == 'true'">$(RobustInjectorsConfiguration.ToLower())</RobustInjectorsConfiguration>
+    <CompileRobustXamlTaskAssemblyFile Condition="'$(UseArtifactsOutput)' != 'true'">$(MSBuildThisFileDirectory)\..\Robust.Client.Injectors\bin\$(RobustInjectorsConfiguration)\netstandard2.0\Robust.Client.Injectors.dll</CompileRobustXamlTaskAssemblyFile>
+    <CompileRobustXamlTaskAssemblyFile Condition="'$(UseArtifactsOutput)' == 'true'">$(MSBuildThisFileDirectory)\..\..\artifacts\bin\Robust.Client.Injectors\$(RobustInjectorsConfiguration)\Robust.Client.Injectors.dll</CompileRobustXamlTaskAssemblyFile>
   </PropertyGroup>
 
   <UsingTask
     Condition="'$(_RobustUseExternalMSBuild)' != 'true' And $(DesignTimeBuild) != true"
     TaskName="CompileRobustXamlTask"
-    AssemblyFile="$(MSBuildThisFileDirectory)\..\Robust.Client.Injectors\bin\$(RobustInjectorsConfiguration)\netstandard2.0\Robust.Client.Injectors.dll"/>
+    AssemblyFile="$(CompileRobustXamlTaskAssemblyFile)"/>
   <Target
     Name="CompileRobustXaml"
     Condition="Exists('@(IntermediateAssembly)')"

OpenToolkit.GraphicsLibraryFramework/GLFWException.cs

@@ -61,18 +61,5 @@ namespace OpenToolkit.GraphicsLibraryFramework
             : base(message, innerException)
         {
         }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="GLFWException"/> class with the specified context
-        /// and the serialization information.
-        /// </summary>
-        /// <param name="info">The <see cref="SerializationInfo"/> associated with this exception.</param>
-        /// <param name="context">
-        /// A <see cref="StreamingContext"/> that represents the context of this exception.
-        /// </param>
-        protected GLFWException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-        {
-        }
     }
 }

Resources/EnginePrototypes/Audio/audio_entities.yml

@@ -0,0 +1,8 @@
+- type: entity
+  id: Audio
+  name: Audio
+  description: Audio entity used by engine
+  save: false
+  components:
+    - type: Transform
+      gridTraversal: false

Resources/EnginePrototypes/Debug/rotation.yml

@@ -1,7 +1,7 @@
 - type: entity
   id: debugRotation
   abstract: true
-  categories: [ debug ]
+  categories: [ Debug ]
   components:
   - type: Sprite
     netsync: false

Resources/EnginePrototypes/Shaders/stockshaders.yml

@@ -12,3 +12,8 @@
   id: bgra
   kind: source
   path: "/Shaders/Internal/bgra.swsl"
+
+- type: shader
+  id: ColorPicker
+  kind: source
+  path: "/Shaders/color_picker.swsl"

Resources/EnginePrototypes/entityCategory.yml

@@ -1,17 +1,20 @@
 # debug related entities
 - type: entityCategory
-  id: debug
+  id: Debug
   name: entity-category-name-debug
   description: entity-category-desc-debug
+  suffix: entity-category-suffix-debug
 
 # entities that spawn other entities
 - type: entityCategory
-  id: spawner
+  id: Spawner
   name: entity-category-name-spawner
   description: entity-category-desc-spawner
 
-# entities that should be hidden from the spawn menu
+# simple category that just exists to hide prototypes in spawn menus
 - type: entityCategory
-  id: hideSpawnMenu
+  id: HideSpawnMenu
   name: entity-category-name-hide
   description: entity-category-desc-hide
+  hideSpawnMenu: true
+  inheritable: false

Resources/Locale/en-US/commands.ftl

@@ -9,7 +9,10 @@ cmd-parse-failure-float = {$arg} is not a valid float.
 cmd-parse-failure-bool = {$arg} is not a valid bool.
 cmd-parse-failure-uid = {$arg} is not a valid entity UID.
 cmd-parse-failure-mapid = {$arg} is not a valid MapId.
+cmd-parse-failure-enum = {$arg} is not a {$enum} Enum.
+cmd-parse-failure-grid = {$arg} is not a valid grid.
 cmd-parse-failure-entity-exist = UID {$arg} does not correspond to an existing entity.
+cmd-parse-failure-session = There is no session with username: {$username}
 
 cmd-error-file-not-found = Could not find file: {$file}.
 cmd-error-dir-not-found = Could not find directory: {$dir}.
@@ -17,15 +20,15 @@ cmd-error-dir-not-found = Could not find directory: {$dir}.
 cmd-failure-no-attached-entity = There is no entity attached to this shell.
 
 ## 'help' command
-cmd-oldhelp-desc = Display general help or help text for a specific command
-cmd-oldhelp-help = Usage: help [command name]
+cmd-help-desc = Display general help or help text for a specific command
+cmd-help-help = Usage: help [command name]
     When no command name is provided, displays general-purpose help text. If a command name is provided, displays help text for that command.
 
-cmd-oldhelp-no-args = To display help for a specific command, write 'help <command>'. To list all available commands, write 'list'. To search for commands, use 'list <filter>'.
-cmd-oldhelp-unknown = Unknown command: { $command }
-cmd-oldhelp-top = { $command } - { $description }
-cmd-oldhelp-invalid-args = Invalid amount of arguments.
-cmd-oldhelp-arg-cmdname = [command name]
+cmd-help-no-args = To display help for a specific command, write 'help <command>'. To list all available commands, write 'list'. To search for commands, use 'list <filter>'.
+cmd-help-unknown = Unknown command: { $command }
+cmd-help-top = { $command } - { $description }
+cmd-help-invalid-args = Invalid amount of arguments.
+cmd-help-arg-cmdname = [command name]
 
 ## 'cvar' command
 cmd-cvar-desc = Gets or sets a CVar.
@@ -41,6 +44,13 @@ cmd-cvar-compl-list = List available CVars
 cmd-cvar-arg-name = <name | ?>
 cmd-cvar-value-hidden = <value hidden>
 
+## 'cvar_subs' command
+cmd-cvar_subs-desc = Lists the OnValueChanged subscriptions for a CVar.
+cmd-cvar_subs-help = Usage: cvar_subs <name>
+
+cmd-cvar_subs-invalid-args = Must provide exactly one argument.
+cmd-cvar_subs-arg-name = <name>
+
 ## 'list' command
 cmd-list-desc = Lists available commands, with optional search filter
 cmd-list-help = Usage: list [filter]
@@ -243,9 +253,6 @@ cmd-bind-arg-command = <InputCommand>
 cmd-net-draw-interp-desc = Toggles the debug drawing of the network interpolation.
 cmd-net-draw-interp-help = Usage: net_draw_interp
 
-cmd-net-draw-interp-desc = Toggles the debug drawing of the network interpolation.
-cmd-net-draw-interp-help = Usage: net_draw_interp
-
 cmd-net-watch-ent-desc = Dumps all network updates for an EntityId to the console.
 cmd-net-watch-ent-help = Usage: net_watchent <0|EntityUid>
 
@@ -297,16 +304,9 @@ cmd-savegrid-help = savegrid <gridID> <Path>
 cmd-testbed-desc = Loads a physics testbed on the specified map.
 cmd-testbed-help = testbed <mapid> <test>
 
-cmd-saveconfig-desc = Saves the client configuration to the config file.
-cmd-saveconfig-help = saveconfig
-
 ## 'flushcookies' command
 # Note: the flushcookies command is from Robust.Client.WebView, it's not in the main engine code.
 
-cmd-flushcookies-desc = Flush CEF cookie storage to disk
-cmd-flushcookies-help = This ensure cookies are properly saved to disk in the event of unclean shutdowns.
-    Note that the actual operation is asynchronous.
-
 ## 'addcomp' command
 cmd-addcomp-desc = Adds a component to an entity.
 cmd-addcomp-help = addcomp <uid> <componentName>
@@ -382,9 +382,9 @@ cmd-tp-desc = Teleports a player to any location in the round.
 cmd-tp-help = tp <x> <y> [<mapID>]
 
 cmd-tpto-desc = Teleports the current player or the specified players/entities to the location of the first player/entity.
-cmd-tpto-help = tpto <username|uid> [username|uid]...
-cmd-tpto-destination-hint = destination (uid or username)
-cmd-tpto-victim-hint = entity to teleport (uid or username)
+cmd-tpto-help = tpto <username|uid> [username|NetEntity]...
+cmd-tpto-destination-hint = destination (NetEntity or username)
+cmd-tpto-victim-hint = entity to teleport (NetEntity or username)
 cmd-tpto-parse-error = Cant resolve entity or player: {$str}
 
 cmd-listplayers-desc = Lists all players currently connected.
@@ -444,9 +444,6 @@ cmd-showanchored-help = Usage: showanchored
 cmd-dmetamem-desc = Dumps a type's members in a format suitable for the sandbox configuration file.
 cmd-dmetamem-help = Usage: dmetamem <type>
 
-cmd-dmetamem-desc = Displays chunk bounds for the purposes of rendering.
-cmd-dmetamem-help = Usage: showchunkbb <type>
-
 cmd-launchauth-desc = Load authentication tokens from launcher data to aid in testing of live servers.
 cmd-launchauth-help = Usage: launchauth <account name>
 
@@ -489,7 +486,7 @@ cmd-net_entityreport-help = Usage: net_entityreport
 cmd-net_refresh-desc = Requests a full server state.
 cmd-net_refresh-help = Usage: net_refresh
 
-cmd-net_graph-desc = Toggles the net statistics pannel.
+cmd-net_graph-desc = Toggles the net statistics panel.
 cmd-net_graph-help = Usage: net_graph
 
 cmd-net_watchent-desc = Dumps all network updates for an EntityId to the console.
@@ -513,9 +510,6 @@ cmd-profsnap-help = Usage: profsnap
 cmd-devwindow-desc = Dev Window
 cmd-devwindow-help = Usage: devwindow
 
-cmd-devwindow-desc = Open file
-cmd-devwindow-help = Usage: testopenfile
-
 cmd-scene-desc = Immediately changes the UI scene/state.
 cmd-scene-help = Usage: scene <className>
 
@@ -526,14 +520,11 @@ cmd-hwid-desc = Returns the current HWID (HardWare ID).
 cmd-hwid-help = Usage: hwid
 
 cmd-vvread-desc = Retrieve a path's value using VV (View Variables).
-cmd-vvread-desc = Usage: vvread <path>
+cmd-vvread-help = Usage: vvread <path>
 
 cmd-vvwrite-desc = Modify a path's value using VV (View Variables).
 cmd-vvwrite-help = Usage: vvwrite <path>
 
-cmd-vv-desc = Opens View Variables (VV).
-cmd-vv-help = Usage: vv <path|entity ID|guihover>
-
 cmd-vvinvoke-desc = Invoke/Call a path with arguments using VV.
 cmd-vvinvoke-help = Usage: vvinvoke <path> [arguments...]
 
@@ -561,3 +552,13 @@ cmd-vfs_ls-hint-path = <path>
 
 cmd-reloadtiletextures-desc = Reloads the tile texture atlas to allow hot reloading tile sprites
 cmd-reloadtiletextures-help = Usage: reloadtiletextures
+
+cmd-audio_length-desc = Shows the length of an audio file
+cmd-audio_length-help = Usage: audio_length { cmd-audio_length-arg-file-name }
+cmd-audio_length-arg-file-name = <file name>
+
+## PVS
+cmd-pvs-override-info-desc = Prints information about any PVS overrides associated with an entity.
+cmd-pvs-override-info-empty = Entity {$nuid} has no PVS overrides.
+cmd-pvs-override-info-global = Entity {$nuid} has a global override.
+cmd-pvs-override-info-clients = Entity {$nuid} has a session override for {$clients}.

Resources/Locale/en-US/entity-category.ftl

@@ -1,8 +1,9 @@
 entity-category-name-debug = Debug
 entity-category-desc-debug = Entity prototypes intended for debugging & testing.
+entity-category-suffix-debug = Debug
 
 entity-category-name-spawner = Spawner
 entity-category-desc-spawner = Entity prototypes that spawn other entities.
 
 entity-category-name-hide = Hidden
-entity-category-desc-hide = Entity prototypes that should be hidden from the spawn menu
+entity-category-desc-hide = Entity prototypes that should be hidden from entity spawn menus

Resources/Locale/en-US/physics/grid_merging.ftl

@@ -0,0 +1,8 @@
+cmd-merge_grids-desc = Combines 2 grids into 1 grid
+cmd-merge_grids-help = merge_grids <gridUid1> <gridUid2> <offsetX> <offsetY> [angle]
+
+cmd-merge_grids-hintA = Grid A
+cmd-merge_grids-hintB = Grid B
+cmd-merge_grids-xOffset = X offset
+cmd-merge_grids-yOffset = Y offset
+cmd-merge_grids-angle = [Angle]

Resources/Locale/en-US/toolshed-commands.ftl

@@ -70,9 +70,9 @@ command-description-ls-in =
 command-description-methods-get =
     Returns all methods associated with the input type.
 command-description-methods-overrides =
-    Returns all methods overriden on the input type.
+    Returns all methods overridden on the input type.
 command-description-methods-overridesfrom =
-    Returns all methods overriden from the given type on the input type.
+    Returns all methods overridden from the given type on the input type.
 command-description-cmd-moo =
     Asks the important questions.
 command-description-cmd-descloc =
@@ -418,6 +418,6 @@ command-description-tee =
     This essentially lets you have a branch in your code to do multiple operations on one value.
 command-description-cmd-info =
     Returns a CommandSpec for the given command.
-    On it's own, this means it'll print the comamnd's help message.
+    On its own, this means it'll print the command's help message.
 command-description-comp-rm =
     Removes the given component from the entity.

Resources/Locale/en-US/userinterface.ftl

@@ -0,0 +1,2 @@
+popup-copy-button = Copy
+popup-title = Alert!

Resources/Locale/en-US/view-variables.ftl

@@ -10,3 +10,18 @@ view-variable-instance-entity-client-components-search-bar-placeholder = Search
 view-variable-instance-entity-server-components-search-bar-placeholder = Search
 view-variable-instance-entity-add-window-server-components = Add Component [S]
 view-variable-instance-entity-add-window-client-components = Add Component [C]
+
+
+## SoundSpecifier
+vv-sound-none = None
+vv-sound-path = Path
+vv-sound-collection = Collection
+
+vv-sound-volume = volume
+vv-sound-pitch = Pitch
+vv-sound-max-distance = Max Distance
+vv-sound-rolloff-factor = Rolloff Factor
+vv-sound-reference-distance = Reference Distance
+vv-sound-loop = Loop
+vv-sound-play-offset = Play Offset (s)
+vv-sound-variation = Pitch variation

Resources/Shaders/color_picker.swsl

@@ -0,0 +1,46 @@
+// Simple shader for creating a box with colours varying along the x and y axes.
+
+uniform highp vec2 size;
+uniform highp vec2 offset;
+
+uniform highp vec4 xAxis;
+uniform highp vec4 yAxis;
+uniform highp vec4 baseColor;
+
+uniform bool hsv;
+
+void fragment() 
+{
+    // Calculate local uv coordinates.
+    // I.e., if using this shader to draw a box to the screen, (0,0) is the bottom left of the box.
+    
+    highp float yCoords = 1.0/SCREEN_PIXEL_SIZE.y - FRAGCOORD.y;
+    highp vec2 uv = vec2(FRAGCOORD.x - offset.x,  yCoords - offset.y);
+    uv /= size;
+    uv.y = 1.0 - uv.y;
+    
+    highp vec4 modulate = baseColor + uv.x * xAxis + uv.y * yAxis;
+    
+    if (hsv)
+    {
+        modulate.xyz = hsv2rgb(modulate.xyz);
+    }
+    
+    // The UV used for the texture lookup is the TEXTURE UV coordinate, which is different from the coordinates computed above.
+	COLOR = zTexture(UV) * modulate;
+}
+
+
+// hsv to RGB conversion taken from www.shadertoy.com/view/MsS3Wc
+
+// The MIT License
+// Copyright © 2014 Inigo Quilez
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// https://www.youtube.com/c/InigoQuilez
+// https://iquilezles.org
+
+highp vec3 hsv2rgb( in highp vec3 c )
+{
+    highp vec3 rgb = clamp( abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0 );
+	return c.z * mix( vec3(1.0), rgb, c.y);
+}

Robust.Analyzers.Tests/AccessAnalyzer_Test.cs

@@ -20,11 +20,16 @@ public sealed class AccessAnalyzer_Test
         {
             TestState =
             {
-                AdditionalReferences = { typeof(AccessAnalyzer).Assembly },
                 Sources = { code }
             },
         };
 
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.AccessAttribute.cs",
+            "Robust.Shared.Analyzers.AccessPermissions.cs"
+        );
+
         // ExpectedDiagnostics cannot be set, so we need to AddRange here...
         test.TestState.ExpectedDiagnostics.AddRange(expected);
 

Robust.Analyzers.Tests/Aliases.cs

@@ -0,0 +1,8 @@
+// OH BOY. TURNS OUT IT GETS EVEN MORE CURSED.
+//
+// So because we're compiling a copy of Robust.Roslyn.Shared into every analyzer project,
+// the test project sees multiple copies of it. This would make it impossible to use.
+// UNLESS you use this obscure C# feature called "extern alias"
+// that I guarantee you you've never heard of before, and are now concerned about.
+
+extern alias SerializationGenerator;

Robust.Analyzers.Tests/ComponentPauseGeneratorTest.cs

@@ -0,0 +1,340 @@
+extern alias SerializationGenerator;
+using System.Linq;
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+using NUnit.Framework;
+using SerializationGenerator::Robust.Roslyn.Shared;
+using SerializationGenerator::Robust.Serialization.Generator;
+
+namespace Robust.Analyzers.Tests;
+
+[TestFixture]
+[TestOf(typeof(ComponentPauseGenerator))]
+[Parallelizable(ParallelScope.All)]
+public sealed class ComponentPauseGeneratorTest
+{
+    private const string TypesCode = """
+        global using System;
+        global using Robust.Shared.Analyzers;
+        global using Robust.Shared.GameObjects;
+
+        namespace Robust.Shared.Analyzers
+        {
+            [AttributeUsage(AttributeTargets.Class, Inherited = false)]
+            public sealed class AutoGenerateComponentPauseAttribute : Attribute
+            {
+                public bool Dirty = false;
+            }
+
+            [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+            public sealed class AutoPausedFieldAttribute : Attribute;
+
+            [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+            public sealed class AutoNetworkedFieldAttribute : Attribute
+            {
+            }
+        }
+
+        namespace Robust.Shared.GameObjects
+        {
+            public interface IComponent;
+        }
+        """;
+
+    [Test]
+    public void TestBasic()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    component.Foo += args.PausedTime;
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestNullable()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan? Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    if (component.Foo.HasValue)
+                        component.Foo = component.Foo.Value + args.PausedTime;
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestAutoState()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField, AutoNetworkedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    component.Foo += args.PausedTime;
+                    Dirty(uid, component);
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestExplicitDirty()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause(Dirty = true)]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    component.Foo += args.PausedTime;
+                    Dirty(uid, component);
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestDiagnosticNotIComponent()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseNotComponent, new LinePositionSpan(new LinePosition(1, 28), new LinePosition(1, 40)))
+        ]);
+    }
+
+    [Test]
+    public void TestDiagnosticNoFields()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseNoFields, new LinePositionSpan(new LinePosition(1, 28), new LinePosition(1, 40)))
+        ]);
+    }
+
+    [Test]
+    public void TestDiagnosticNoParentAttribute()
+    {
+        var result = RunGenerator("""
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo, Fooz;
+
+                [AutoPausedField]
+                public TimeSpan Bar { get; set; }
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseNoParentAttribute, new LinePositionSpan(new LinePosition(3, 20), new LinePosition(3, 23))),
+            (Diagnostics.IdComponentPauseNoParentAttribute, new LinePositionSpan(new LinePosition(3, 25), new LinePosition(3, 29))),
+            (Diagnostics.IdComponentPauseNoParentAttribute, new LinePositionSpan(new LinePosition(6, 20), new LinePosition(6, 23)))
+        ]);
+    }
+
+    [Test]
+    public void TestDiagnosticWrongType()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public int Foo, Fooz;
+
+                [AutoPausedField]
+                public int Bar { get; set; }
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseWrongTypeAttribute, new LinePositionSpan(new LinePosition(4, 15), new LinePosition(4, 18))),
+            (Diagnostics.IdComponentPauseWrongTypeAttribute, new LinePositionSpan(new LinePosition(4, 20), new LinePosition(4, 24))),
+            (Diagnostics.IdComponentPauseWrongTypeAttribute, new LinePositionSpan(new LinePosition(7, 15), new LinePosition(7, 18)))
+        ]);
+    }
+
+    private static void ExpectSource(GeneratorRunResult result, string expected)
+    {
+        Assert.That(result.GeneratedSources, Has.Length.EqualTo(1));
+
+        var source = result.GeneratedSources[0];
+
+        Assert.That(source.SourceText.ToString(), Is.EqualTo(expected));
+    }
+
+    private static void ExpectNoSource(GeneratorRunResult result)
+    {
+        Assert.That(result.GeneratedSources, Is.Empty);
+    }
+
+    private static void ExpectNoDiagnostics(GeneratorRunResult result)
+    {
+        Assert.That(result.Diagnostics, Is.Empty);
+    }
+
+    private static void ExpectDiagnostics(GeneratorRunResult result, (string code, LinePositionSpan span)[] diagnostics)
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Diagnostics, Has.Length.EqualTo(diagnostics.Length));
+            foreach (var (code, span) in diagnostics)
+            {
+                Assert.That(
+                    result.Diagnostics.Any(x => x.Id == code && x.Location.GetLineSpan().Span == span),
+                    $"Expected diagnostic with code {code} and location {span}");
+            }
+        });
+    }
+
+    private static GeneratorRunResult RunGenerator(string source)
+    {
+        var compilation = (Compilation)CSharpCompilation.Create("compilation",
+            new[]
+            {
+                CSharpSyntaxTree.ParseText(source, path: "Source.cs"),
+                CSharpSyntaxTree.ParseText(TypesCode, path: "Types.cs")
+            },
+            new[] { MetadataReference.CreateFromFile(typeof(Binder).GetTypeInfo().Assembly.Location) },
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+        var generator = new ComponentPauseGenerator();
+        GeneratorDriver driver = CSharpGeneratorDriver.Create(generator);
+        driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var newCompilation, out _);
+        var result = driver.GetRunResult();
+
+        return result.Results[0];
+    }
+}

Robust.Analyzers.Tests/DataDefinitionAnalyzerTest.cs

@@ -0,0 +1,91 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.DataDefinitionAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class DataDefinitionAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<DataDefinitionAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using System;
+            using Robust.Shared.ViewVariables;
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            namespace Robust.Shared.ViewVariables
+            {
+                public sealed class ViewVariablesAttribute : Attribute
+                {
+                    public readonly VVAccess Access = VVAccess.ReadOnly;
+
+                    public ViewVariablesAttribute() { }
+
+                    public ViewVariablesAttribute(VVAccess access)
+                    {
+                        Access = access;
+                    }
+                }
+                public enum VVAccess : byte
+                {
+                    ReadOnly = 0,
+                    ReadWrite = 1,
+                }
+            }
+
+            namespace Robust.Shared.Serialization.Manager.Attributes
+            {
+                public class DataFieldBaseAttribute : Attribute;
+                public class DataFieldAttribute : DataFieldBaseAttribute;
+                public sealed class DataDefinitionAttribute : Attribute;
+            }
+
+            [DataDefinition]
+            public sealed partial class Foo
+            {
+                [DataField, ViewVariables(VVAccess.ReadWrite)]
+                public int Bad;
+
+                [DataField]
+                public int Good;
+
+                [DataField, ViewVariables]
+                public int Good2;
+
+                [DataField, ViewVariables(VVAccess.ReadOnly)]
+                public int Good3;
+
+                [ViewVariables]
+                public int Good4;
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(35,17): info RA0028: Data field Bad in data definition Foo has ViewVariables attribute with ReadWrite access, which is redundant
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldNoVVReadWriteRule).WithSpan(35, 17, 35, 50).WithArguments("Bad", "Foo")
+        );
+    }
+}

Robust.Analyzers.Tests/DependencyAssignAnalyzerTest.cs

@@ -0,0 +1,58 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.DependencyAssignAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class DependencyAssignAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<DependencyAssignAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.IoC.DependencyAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.IoC;
+
+            public sealed class Foo
+            {
+                [Dependency]
+                private object? Field;
+
+                public Foo()
+                {
+                    Field = "A";
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(10,9): warning RA0025: Tried to assign to [Dependency] field 'Field'. Remove [Dependency] or inject it via field injection instead.
+            VerifyCS.Diagnostic().WithSpan(10, 9, 10, 20).WithArguments("Field"));
+    }
+}

Robust.Analyzers.Tests/MustCallBaseAnalyzerTest.cs

@@ -0,0 +1,92 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.MustCallBaseAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class MustCallBaseAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<MustCallBaseAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.IoC.MustCallBaseAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class Foo
+            {
+                [MustCallBase]
+                public virtual void Function()
+                {
+
+                }
+
+                [MustCallBase(true)]
+                public virtual void Function2()
+                {
+
+                }
+            }
+
+            public class Bar : Foo
+            {
+                public override void Function()
+                {
+
+                }
+
+                public override void Function2()
+                {
+
+                }
+            }
+
+            public class Baz : Foo
+            {
+                public override void Function()
+                {
+                    base.Function();
+                }
+            }
+
+            public class Bal : Bar
+            {
+                public override void Function2()
+                {
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(20,26): warning RA0028: Overriders of this function must always call the base function
+            VerifyCS.Diagnostic().WithSpan(20, 26, 20, 34),
+            // /0/Test0.cs(41,26): warning RA0028: Overriders of this function must always call the base function
+            VerifyCS.Diagnostic().WithSpan(41, 26, 41, 35));
+    }
+}

Robust.Analyzers.Tests/NoUncachedRegexAnalyzerTest.cs

@@ -0,0 +1,57 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.NoUncachedRegexAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class NoUncachedRegexAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<NoUncachedRegexAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using System.Text.RegularExpressions;
+
+            public static class Foo
+            {
+                public static void Bad()
+                {
+                    Regex.Replace("foo", "bar", "baz");
+                }
+
+                public static void Good()
+                {
+                    var r = new Regex("bar");
+                    r.Replace("foo", "baz");
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(7,9): warning RA0026: Usage of a static Regex function that takes in a pattern string. This can cause constant re-parsing of the pattern.
+            VerifyCS.Diagnostic().WithSpan(7, 9, 7, 43)
+        );
+    }
+}

Robust.Analyzers.Tests/PreferNonGenericVariantForTest.cs

@@ -0,0 +1,71 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.PreferNonGenericVariantForAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class PreferNonGenericVariantForTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<PreferNonGenericVariantForAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code },
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class Bar { };
+            public class Baz { };
+            public class Okay { };
+
+            public static class Foo
+            {
+                [PreferNonGenericVariantFor(typeof(Bar), typeof(Baz))]
+                public static void DoFoo<T>() { }
+            }
+
+            public class Test
+            {
+                public void DoBad()
+                {
+                    Foo.DoFoo<Bar>();
+                }
+
+                public void DoGood()
+                {
+                    Foo.DoFoo<Okay>();
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(17,9): warning RA0029: Use the non-generic variant of this method for type Bar
+            VerifyCS.Diagnostic().WithSpan(17, 9, 17, 25).WithArguments("Bar")
+        );
+    }
+}

Robust.Analyzers.Tests/PreferOtherTypeAnalyzerTest.cs

@@ -0,0 +1,62 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.PreferOtherTypeAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class PreferOtherTypeAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<PreferOtherTypeAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code },
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class EntityPrototype { };
+            public class EntProtoId { };
+            public class ReagentPrototype { };
+
+            [PreferOtherType(typeof(EntityPrototype), typeof(EntProtoId))]
+            public class ProtoId<T> { };
+
+            public class Test
+            {
+                public ProtoId<EntityPrototype> Bad = new();
+
+                public ProtoId<ReagentPrototype> Good = new();
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(12,12): warning RA0031: Use the specific type EntProtoId instead of ProtoId when the type argument is EntityPrototype
+            VerifyCS.Diagnostic().WithSpan(12, 12, 12, 48).WithArguments("EntProtoId", "ProtoId", "EntityPrototype")
+        );
+    }
+}

Robust.Analyzers.Tests/PreferOtherTypeFixerTest.cs

@@ -0,0 +1,81 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.PreferOtherTypeAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+public sealed class PreferOtherTypeFixerTest
+{
+    private static Task Verifier(string code, string fixedCode, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpCodeFixTest<PreferOtherTypeAnalyzer, PreferOtherTypeFixer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code },
+            },
+            FixedState =
+            {
+                Sources = { fixedCode },
+            }
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs"
+        );
+
+        TestHelper.AddEmbeddedSources(
+            test.FixedState,
+            "Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs"
+        );
+
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class EntityPrototype { };
+            public class EntProtoId { };
+            public class ReagentPrototype { };
+
+            [PreferOtherType(typeof(EntityPrototype), typeof(EntProtoId))]
+            public class ProtoId<T> { };
+
+            public class Test
+            {
+                public ProtoId<EntityPrototype> Foo = new();
+            }
+            """;
+
+        const string fixedCode = """
+            using Robust.Shared.Analyzers;
+
+            public class EntityPrototype { };
+            public class EntProtoId { };
+            public class ReagentPrototype { };
+
+            [PreferOtherType(typeof(EntityPrototype), typeof(EntProtoId))]
+            public class ProtoId<T> { };
+
+            public class Test
+            {
+                public EntProtoId Foo = new();
+            }
+            """;
+
+        await Verifier(code, fixedCode,
+        // /0/Test0.cs(12,12): error RA0031: Use the specific type EntProtoId instead of ProtoId when the type argument is EntityPrototype
+        VerifyCS.Diagnostic().WithSpan(12, 12, 12, 48).WithArguments("EntProtoId", "ProtoId", "EntityPrototype"));
+    }
+}

Robust.Analyzers.Tests/Robust.Analyzers.Tests.csproj

@@ -1,24 +1,43 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="..\MSBuild\Robust.Properties.targets" />
-  <Import Project="..\MSBuild\Robust.Engine.props" />
-  
+  <PropertyGroup>
+    <SkipRobustAnalyzer>true</SkipRobustAnalyzer>
+  </PropertyGroup>
+
+  <Import Project="..\MSBuild\Robust.Properties.targets"/>
+  <Import Project="..\MSBuild\Robust.Engine.props"/>
+
+  <!-- Engine source files needed to make the tests work -->
+  <ItemGroup>
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\AccessAttribute.cs" LogicalName="Robust.Shared.Analyzers.AccessAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\AccessPermissions.cs" LogicalName="Robust.Shared.Analyzers.AccessPermissions.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\MustCallBaseAttribute.cs" LogicalName="Robust.Shared.IoC.MustCallBaseAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferNonGenericVariantForAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferOtherTypeAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\IoC\DependencyAttribute.cs" LogicalName="Robust.Shared.IoC.DependencyAttribute.cs" LinkBase="Implementations" />
+  </ItemGroup>
+
   <PropertyGroup>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
-  
+
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzer.Testing" Version="1.1.1"/>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1"/>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.NUnit" Version="1.1.1"/>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1"/>
-    <PackageReference Include="NUnit" Version="3.13.2"/>
-    <PackageReference Include="NUnit.ConsoleRunner" Version="3.15.0"/>
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.1"/>
-    <PackageReference Include="NUnit.Analyzers" Version="3.3.0"/>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageVersion Update="NUnit" Version="3.14.0" />
   </ItemGroup>
-  
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzer.Testing"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.NUnit"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.NUnit"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces"/>
+    <PackageReference Include="NUnit"/>
+    <PackageReference Include="NUnit3TestAdapter"/>
+    <PackageReference Include="NUnit.Analyzers"/>
+    <PackageReference Include="Microsoft.NET.Test.Sdk"/>
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Robust.Analyzers\Robust.Analyzers.csproj"/>
+    <ProjectReference Include="..\Robust.Serialization.Generator\Robust.Serialization.Generator.csproj" Aliases="SerializationGenerator" />
   </ItemGroup>
 </Project>

Robust.Analyzers.Tests/TestHelper.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Robust.Analyzers.Tests;
+
+public static class TestHelper
+{
+    public static void AddEmbeddedSources(SolutionState state, params string[] embeddedFiles)
+    {
+        AddEmbeddedSources(state, (IEnumerable<string>) embeddedFiles);
+    }
+
+    public static void AddEmbeddedSources(SolutionState state, IEnumerable<string> embeddedFiles)
+    {
+        foreach (var fileName in embeddedFiles)
+        {
+            using var stream = typeof(AccessAnalyzer_Test).Assembly.GetManifestResourceStream(fileName)!;
+            state.Sources.Add((fileName, SourceText.From(stream)));
+        }
+    }
+}

Robust.Analyzers/AccessAnalyzer.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 using Robust.Shared.Analyzers.Implementation;
 
 namespace Robust.Analyzers

Robust.Analyzers/ByRefEventAnalyzer.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 using static Microsoft.CodeAnalysis.SymbolEqualityComparer;
 
 namespace Robust.Analyzers;
@@ -16,27 +17,17 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor ByRefEventSubscribedByValueRule = new(
         Diagnostics.IdByRefEventSubscribedByValue,
         "By-ref event subscribed to by value",
-        "Tried to subscribe to a by-ref event '{0}' by value.",
+        "Tried to subscribe to a by-ref event '{0}' by value",
         "Usage",
         DiagnosticSeverity.Error,
         true,
         "Make sure that methods subscribing to a ref event have the ref keyword for the event argument."
     );
 
-    private static readonly DiagnosticDescriptor ByValueEventSubscribedByRefRule = new(
-        Diagnostics.IdValueEventRaisedByRef,
-        "Value event subscribed to by-ref",
-        "Tried to subscribe to a value event '{0}' by-ref.",
-        "Usage",
-        DiagnosticSeverity.Error,
-        true,
-        "Make sure that methods subscribing to value events do not have the ref keyword for the event argument."
-    );
-
     private static readonly DiagnosticDescriptor ByRefEventRaisedByValueRule = new(
         Diagnostics.IdByRefEventRaisedByValue,
         "By-ref event raised by value",
-        "Tried to raise a by-ref event '{0}' by value.",
+        "Tried to raise a by-ref event '{0}' by value",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -46,7 +37,7 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor ByValueEventRaisedByRefRule = new(
         Diagnostics.IdValueEventRaisedByRef,
         "Value event raised by-ref",
-        "Tried to raise a value event '{0}' by-ref.",
+        "Tried to raise a value event '{0}' by-ref",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -55,7 +46,6 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
         ByRefEventSubscribedByValueRule,
-        ByValueEventSubscribedByRefRule,
         ByRefEventRaisedByValueRule,
         ByValueEventRaisedByRefRule
     );
@@ -64,71 +54,9 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
         context.EnableConcurrentExecution();
-        context.RegisterOperationAction(CheckEventSubscription, OperationKind.Invocation);
         context.RegisterOperationAction(CheckEventRaise, OperationKind.Invocation);
     }
 
-    private void CheckEventSubscription(OperationAnalysisContext context)
-    {
-        if (context.Operation is not IInvocationOperation operation)
-            return;
-
-        var subscribeMethods = context.Compilation
-            .GetTypeByMetadataName("Robust.Shared.GameObjects.EntitySystem")?
-            .GetMembers()
-            .Where(m => m.Name.Contains("SubscribeLocalEvent"))
-            .Cast<IMethodSymbol>();
-
-        if (subscribeMethods == null)
-            return;
-
-        if (!subscribeMethods.Any(m => m.Equals(operation.TargetMethod.OriginalDefinition, Default)))
-            return;
-
-        var typeArguments = operation.TargetMethod.TypeArguments;
-        if (typeArguments.Length < 1 || typeArguments.Length > 2)
-            return;
-
-        if (operation.Arguments.First().Value is not IDelegateCreationOperation delegateCreation)
-            return;
-
-        if (delegateCreation.Target is not IMethodReferenceOperation methodReference)
-            return;
-
-        var eventParameter = methodReference.Method.Parameters.LastOrDefault();
-        if (eventParameter == null)
-            return;
-
-        ITypeSymbol eventArgument;
-        switch (typeArguments.Length)
-        {
-            case 1:
-                eventArgument = typeArguments[0];
-                break;
-            case 2:
-                eventArgument = typeArguments[1];
-                break;
-            default:
-                return;
-        }
-
-        var byRefAttribute = context.Compilation.GetTypeByMetadataName(ByRefAttribute);
-        if (byRefAttribute == null)
-            return;
-
-        var isByRefEventType = eventArgument
-            .GetAttributes()
-            .Any(attribute => attribute.AttributeClass?.Equals(byRefAttribute, Default) ?? false);
-        var parameterIsRef = eventParameter.RefKind == RefKind.Ref;
-
-        if (isByRefEventType != parameterIsRef)
-        {
-            var descriptor = isByRefEventType ? ByRefEventSubscribedByValueRule : ByValueEventSubscribedByRefRule;
-            var diagnostic = Diagnostic.Create(descriptor, operation.Syntax.GetLocation(), eventArgument);
-            context.ReportDiagnostic(diagnostic);
-        }
-    }
-
     private void CheckEventRaise(OperationAnalysisContext context)
     {
         if (context.Operation is not IInvocationOperation operation)

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -5,6 +5,9 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+using Robust.Shared.Serialization.Manager.Definition;
+using Robust.Shared.ViewVariables;
 
 namespace Robust.Analyzers;
 
@@ -14,11 +17,14 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private const string DataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataDefinitionAttribute";
     private const string ImplicitDataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.ImplicitDataDefinitionForInheritorsAttribute";
     private const string DataFieldBaseNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataFieldBaseAttribute";
+    private const string ViewVariablesNamespace = "Robust.Shared.ViewVariables.ViewVariablesAttribute";
+    private const string DataFieldAttributeName = "DataField";
+    private const string ViewVariablesAttributeName = "ViewVariables";
 
     private static readonly DiagnosticDescriptor DataDefinitionPartialRule = new(
         Diagnostics.IdDataDefinitionPartial,
         "Type must be partial",
-        "Type {0} is a DataDefinition but is not partial.",
+        "Type {0} is a DataDefinition but is not partial",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -28,7 +34,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor NestedDataDefinitionPartialRule = new(
         Diagnostics.IdNestedDataDefinitionPartial,
         "Type must be partial",
-        "Type {0} contains nested data definition {1} but is not partial.",
+        "Type {0} contains nested data definition {1} but is not partial",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -38,7 +44,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor DataFieldWritableRule = new(
         Diagnostics.IdDataFieldWritable,
         "Data field must not be readonly",
-        "Data field {0} in data definition {1} is readonly.",
+        "Data field {0} in data definition {1} is readonly",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -48,15 +54,36 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
         Diagnostics.IdDataFieldPropertyWritable,
         "Data field property must have a setter",
-        "Data field property {0} in data definition {1} does not have a setter.",
+        "Data field property {0} in data definition {1} does not have a setter",
         "Usage",
         DiagnosticSeverity.Error,
         true,
         "Make sure to add a setter."
     );
 
+    private static readonly DiagnosticDescriptor DataFieldRedundantTagRule = new(
+        Diagnostics.IdDataFieldRedundantTag,
+        "Data field has redundant tag specified",
+        "Data field {0} in data definition {1} has an explicitly set tag that matches autogenerated tag",
+        "Usage",
+        DiagnosticSeverity.Info,
+        true,
+        "Make sure to remove the tag string from the data field attribute."
+    );
+
+    public static readonly DiagnosticDescriptor DataFieldNoVVReadWriteRule = new(
+        Diagnostics.IdDataFieldNoVVReadWrite,
+        "Data field has VV ReadWrite",
+        "Data field {0} in data definition {1} has ViewVariables attribute with ReadWrite access, which is redundant",
+        "Usage",
+        DiagnosticSeverity.Info,
+        true,
+        "Make sure to remove the ViewVariables attribute."
+    );
+
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
-        DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule
+        DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule,
+        DataFieldRedundantTagRule, DataFieldNoVVReadWriteRule
     );
 
     public override void Initialize(AnalysisContext context)
@@ -124,6 +151,18 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
             {
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, context.Node.GetLocation(), fieldSymbol.Name, type.Name));
             }
+
+            if (HasRedundantTag(fieldSymbol))
+            {
+                TryGetAttributeLocation(field, DataFieldAttributeName, out var location);
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, fieldSymbol.Name, type.Name));
+            }
+
+            if (HasVVReadWrite(fieldSymbol))
+            {
+                TryGetAttributeLocation(field, ViewVariablesAttributeName, out var location);
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldNoVVReadWriteRule, location, fieldSymbol.Name, type.Name));
+            }
         }
     }
 
@@ -148,6 +187,18 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         {
             context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, context.Node.GetLocation(), propertySymbol.Name, type.Name));
         }
+
+        if (HasRedundantTag(propertySymbol))
+        {
+            TryGetAttributeLocation(property, DataFieldAttributeName, out var location);
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, propertySymbol.Name, type.Name));
+        }
+
+        if (HasVVReadWrite(propertySymbol))
+        {
+            TryGetAttributeLocation(property, ViewVariablesAttributeName, out var location);
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldNoVVReadWriteRule, location, propertySymbol.Name, type.Name));
+        }
     }
 
     private static bool IsReadOnlyDataField(ITypeSymbol type, ISymbol field)
@@ -216,6 +267,24 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
+    private static bool TryGetAttributeLocation(MemberDeclarationSyntax syntax, string attributeName, out Location location)
+    {
+        foreach (var attributeList in syntax.AttributeLists)
+        {
+            foreach (var attribute in attributeList.Attributes)
+            {
+                if (attribute.Name.ToString() != attributeName)
+                    continue;
+
+                location = attribute.GetLocation();
+                return true;
+            }
+        }
+        // Default to the declaration syntax's location
+        location = syntax.GetLocation();
+        return false;
+    }
+
     private static bool IsReadOnlyMember(ITypeSymbol type, ISymbol member)
     {
         if (member is IFieldSymbol field)
@@ -247,6 +316,57 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
+    private static bool HasRedundantTag(ISymbol symbol)
+    {
+        if (!IsDataField(symbol, out var _, out var attribute))
+            return false;
+
+        // No args, no problem
+        if (attribute.ConstructorArguments.Length == 0)
+            return false;
+
+        // If a tag is explicitly specified, it will be the first argument...
+        var tagArgument = attribute.ConstructorArguments[0];
+        // ...but the first arg could also something else, since tag is optional
+        // so we make sure that it's a string
+        if (tagArgument.Value is not string explicitName)
+            return false;
+
+        // Get the name that sourcegen would provide
+        var automaticName = DataDefinitionUtility.AutoGenerateTag(symbol.Name);
+
+        // If the explicit name matches the sourcegen name, we have a redundancy
+        return explicitName == automaticName;
+    }
+
+    private static bool HasVVReadWrite(ISymbol symbol)
+    {
+        if (!IsDataField(symbol, out _, out _))
+            return false;
+
+        // Make sure it has ViewVariablesAttribute
+        AttributeData? viewVariablesAttribute = null;
+        foreach (var attr in symbol.GetAttributes())
+        {
+            if (attr.AttributeClass?.ToDisplayString() == ViewVariablesNamespace)
+            {
+                viewVariablesAttribute = attr;
+            }
+        }
+        if (viewVariablesAttribute == null)
+            return false;
+
+        // Default is ReadOnly, which is fine
+        if (viewVariablesAttribute.ConstructorArguments.Length == 0)
+            return false;
+
+        var accessArgument = viewVariablesAttribute.ConstructorArguments[0];
+        if (accessArgument.Value is not byte accessByte)
+            return false;
+
+        return (VVAccess)accessByte == VVAccess.ReadWrite;
+    }
+
     private static bool IsImplicitDataDefinition(ITypeSymbol type)
     {
         if (HasAttribute(type, ImplicitDataDefinitionNamespace))

Robust.Analyzers/DataDefinitionFixer.cs

@@ -1,23 +1,25 @@
 #nullable enable
 using System.Collections.Immutable;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxKind;
-using static Robust.Analyzers.Diagnostics;
+using static Robust.Roslyn.Shared.Diagnostics;
 
 namespace Robust.Analyzers;
 
 [ExportCodeFixProvider(LanguageNames.CSharp)]
 public sealed class DefinitionFixer : CodeFixProvider
 {
+    private const string DataFieldAttributeName = "DataField";
+
+    private const string ViewVariablesAttributeName = "ViewVariables";
+
     public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
-        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable
+        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable,
+        IdDataFieldRedundantTag, IdDataFieldNoVVReadWrite
     );
 
     public override Task RegisterCodeFixesAsync(CodeFixContext context)
@@ -34,6 +36,10 @@ public sealed class DefinitionFixer : CodeFixProvider
                     return RegisterDataFieldFix(context, diagnostic);
                 case IdDataFieldPropertyWritable:
                     return RegisterDataFieldPropertyFix(context, diagnostic);
+                case IdDataFieldRedundantTag:
+                    return RegisterRedundantTagFix(context, diagnostic);
+                case IdDataFieldNoVVReadWrite:
+                    return RegisterVVReadWriteFix(context, diagnostic);
             }
         }
 
@@ -72,6 +78,110 @@ public sealed class DefinitionFixer : CodeFixProvider
         return document.WithSyntaxRoot(root);
     }
 
+    private static async Task RegisterRedundantTagFix(CodeFixContext context, Diagnostic diagnostic)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+        var span = diagnostic.Location.SourceSpan;
+        var token = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<MemberDeclarationSyntax>().First();
+
+        if (token == null)
+            return;
+
+        // Find the DataField attribute
+        AttributeSyntax? dataFieldAttribute = null;
+        foreach (var attributeList in token.AttributeLists)
+        {
+            foreach (var attribute in attributeList.Attributes)
+            {
+                if (attribute.Name.ToString() == DataFieldAttributeName)
+                {
+                    dataFieldAttribute = attribute;
+                    break;
+                }
+            }
+            if (dataFieldAttribute != null)
+                break;
+        }
+
+        if (dataFieldAttribute == null)
+            return;
+
+        context.RegisterCodeFix(CodeAction.Create(
+            "Remove explicitly set tag",
+            c => RemoveRedundantTag(context.Document, dataFieldAttribute, c),
+            "Remove explicitly set tag"
+        ), diagnostic);
+    }
+
+    private static async Task<Document> RemoveRedundantTag(Document document, AttributeSyntax syntax, CancellationToken cancellation)
+    {
+        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
+
+        if (syntax.ArgumentList == null)
+            return document;
+
+        AttributeSyntax? newSyntax;
+        if (syntax.ArgumentList.Arguments.Count == 1)
+        {
+            // If this is the only argument, delete the ArgumentList so we don't leave empty parentheses
+            newSyntax = syntax.RemoveNode(syntax.ArgumentList, SyntaxRemoveOptions.KeepNoTrivia);
+        }
+        else
+        {
+            // Remove the first argument, which is the tag
+            var newArgs = syntax.ArgumentList.Arguments.RemoveAt(0);
+            var newArgList = syntax.ArgumentList.WithArguments(newArgs);
+            // Construct a new attribute with the tag removed
+            newSyntax = syntax.WithArgumentList(newArgList);
+        }
+
+        root = root!.ReplaceNode(syntax, newSyntax!);
+
+        return document.WithSyntaxRoot(root);
+    }
+
+    private static async Task RegisterVVReadWriteFix(CodeFixContext context, Diagnostic diagnostic)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+        var span = diagnostic.Location.SourceSpan;
+        var token = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<MemberDeclarationSyntax>().First();
+
+        if (token == null)
+            return;
+
+        context.RegisterCodeFix(CodeAction.Create(
+            "Remove ViewVariables attribute",
+            c => RemoveVVAttribute(context.Document, token, c),
+            "Remove ViewVariables attribute"
+        ), diagnostic);
+    }
+
+    private static async Task<Document> RemoveVVAttribute(Document document, MemberDeclarationSyntax syntax, CancellationToken cancellation)
+    {
+        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
+
+        var newLists = new SyntaxList<AttributeListSyntax>();
+        foreach (var attributeList in syntax.AttributeLists)
+        {
+            var attributes = new SeparatedSyntaxList<AttributeSyntax>();
+            foreach (var attribute in attributeList.Attributes)
+            {
+                if (attribute.Name.ToString() != ViewVariablesAttributeName)
+                {
+                    attributes = attributes.Add(attribute);
+                }
+            }
+            // Don't add empty lists []
+            if (attributes.Count > 0)
+                newLists = newLists.Add(attributeList.WithAttributes(attributes));
+        }
+        var newSyntax = syntax.WithAttributeLists(newLists);
+
+        root = root!.ReplaceNode(syntax, newSyntax);
+
+        return document.WithSyntaxRoot(root);
+    }
+
     private static async Task RegisterDataFieldFix(CodeFixContext context, Diagnostic diagnostic)
     {
         var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);

Robust.Analyzers/DependencyAssignAnalyzer.cs

@@ -0,0 +1,61 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class DependencyAssignAnalyzer : DiagnosticAnalyzer
+{
+    private const string DependencyAttributeType = "Robust.Shared.IoC.DependencyAttribute";
+
+    private static readonly DiagnosticDescriptor Rule = new (
+        Diagnostics.IdDependencyFieldAssigned,
+        "Assignment to dependency field",
+        "Tried to assign to [Dependency] field '{0}'. Remove [Dependency] or inject it via field injection instead.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.RegisterOperationAction(CheckAssignment, OperationKind.SimpleAssignment);
+    }
+
+    private static void CheckAssignment(OperationAnalysisContext context)
+    {
+        if (context.Operation is not ISimpleAssignmentOperation assignment)
+            return;
+
+        if (assignment.Target is not IFieldReferenceOperation fieldRef)
+            return;
+
+        var field = fieldRef.Field;
+        var attributes = field.GetAttributes();
+        if (attributes.Length == 0)
+            return;
+
+        var depAttribute = context.Compilation.GetTypeByMetadataName(DependencyAttributeType);
+        if (!HasAttribute(attributes, depAttribute))
+            return;
+
+        context.ReportDiagnostic(Diagnostic.Create(Rule, assignment.Syntax.GetLocation(), field.Name));
+    }
+
+    private static bool HasAttribute(ImmutableArray<AttributeData> attributes, ISymbol symbol)
+    {
+        foreach (var attribute in attributes)
+        {
+            if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, symbol))
+                return true;
+        }
+
+        return false;
+    }
+}

Robust.Analyzers/ExplicitInterfaceAnalyzer.cs

@@ -10,6 +10,7 @@ using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 using Document = Microsoft.CodeAnalysis.Document;
 
 namespace Robust.Analyzers

Robust.Analyzers/ExplicitVirtualAnalyzer.cs

@@ -5,6 +5,7 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 

Robust.Analyzers/MeansImplicitAssigmentSuppressor.cs

@@ -2,6 +2,7 @@ using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers
 {

Robust.Analyzers/MustCallBaseAnalyzer.cs

@@ -0,0 +1,111 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+#nullable enable
+
+/// <summary>
+/// Enforces <c>MustCallBaseAttribute</c>.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class MustCallBaseAnalyzer : DiagnosticAnalyzer
+{
+    private const string Attribute = "Robust.Shared.Analyzers.MustCallBaseAttribute";
+
+    private static readonly DiagnosticDescriptor Rule = new(
+        Diagnostics.IdMustCallBase,
+        "No base call in overriden function",
+        "Overriders of this function must always call the base function",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);
+    }
+
+    private static void AnalyzeSymbol(SymbolAnalysisContext context)
+    {
+        if (context.Symbol is not IMethodSymbol { IsOverride: true } method)
+            return;
+
+        var attrSymbol = context.Compilation.GetTypeByMetadataName(Attribute);
+        if (attrSymbol == null)
+            return;
+
+        if (DoesMethodOverriderHaveAttribute(method, attrSymbol) is not { } data)
+            return;
+
+        if (data is { onlyOverrides: true, depth: < 2 })
+            return;
+
+        var syntax = (MethodDeclarationSyntax) method.DeclaringSyntaxReferences[0].GetSyntax();
+        if (HasBaseCall(syntax))
+            return;
+
+        var diag = Diagnostic.Create(Rule, syntax.Identifier.GetLocation());
+        context.ReportDiagnostic(diag);
+    }
+
+    private static (int depth, bool onlyOverrides)? DoesMethodOverriderHaveAttribute(
+        IMethodSymbol method,
+        INamedTypeSymbol attributeSymbol)
+    {
+        var depth = 0;
+        while (method.OverriddenMethod != null)
+        {
+            depth += 1;
+            method = method.OverriddenMethod;
+            if (GetAttribute(method, attributeSymbol) is not { } attribute)
+                continue;
+
+            var onlyOverrides = attribute.ConstructorArguments is [{Kind: TypedConstantKind.Primitive, Value: true}];
+            return (depth, onlyOverrides);
+        }
+
+        return null;
+    }
+
+    private static bool HasBaseCall(MethodDeclarationSyntax syntax)
+    {
+        return syntax.Accept(new BaseCallLocator());
+    }
+
+    private static AttributeData? GetAttribute(ISymbol namedTypeSymbol, INamedTypeSymbol attrSymbol)
+    {
+        return namedTypeSymbol.GetAttributes()
+            .SingleOrDefault(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attrSymbol));
+    }
+
+    private sealed class BaseCallLocator : CSharpSyntaxVisitor<bool>
+    {
+        public override bool VisitBaseExpression(BaseExpressionSyntax node)
+        {
+            return true;
+        }
+
+        public override bool DefaultVisit(SyntaxNode node)
+        {
+            foreach (var childNode in node.ChildNodes())
+            {
+                if (childNode is not CSharpSyntaxNode cSharpSyntax)
+                    continue;
+
+                if (cSharpSyntax.Accept(this))
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}

Robust.Analyzers/NoUncachedRegexAnalyzer.cs

@@ -0,0 +1,66 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class NoUncachedRegexAnalyzer : DiagnosticAnalyzer
+{
+    private const string RegexTypeName = "Regex";
+    private const string RegexType = $"System.Text.RegularExpressions.{RegexTypeName}";
+
+    private static readonly DiagnosticDescriptor Rule = new (
+        Diagnostics.IdUncachedRegex,
+        "Use of uncached static Regex function",
+        "Usage of a static Regex function that takes in a pattern string. This can cause constant re-parsing of the pattern.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public static readonly HashSet<string> BadFunctions =
+    [
+        "Count",
+        "EnumerateMatches",
+        "IsMatch",
+        "Match",
+        "Matches",
+        "Replace",
+        "Split"
+    ];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.RegisterOperationAction(CheckInvocation, OperationKind.Invocation);
+    }
+
+    private static void CheckInvocation(OperationAnalysisContext context)
+    {
+        if (context.Operation is not IInvocationOperation invocation)
+            return;
+
+        // All Regex functions we care about are static.
+        var targetMethod = invocation.TargetMethod;
+        if (!targetMethod.IsStatic)
+            return;
+
+        // Bail early.
+        if (targetMethod.ContainingType.Name != "Regex")
+            return;
+
+        var regexType = context.Compilation.GetTypeByMetadataName(RegexType);
+        if (!SymbolEqualityComparer.Default.Equals(regexType, targetMethod.ContainingType))
+            return;
+
+        if (!BadFunctions.Contains(targetMethod.Name))
+            return;
+
+        context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.Syntax.GetLocation()));
+    }
+}

Robust.Analyzers/NotNullableFlagAnalyzer.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 
@@ -31,7 +32,7 @@ public sealed class NotNullableFlagAnalyzer : DiagnosticAnalyzer
 
     private static readonly DiagnosticDescriptor InvalidNotNullableImplementationRule = new (
         Diagnostics.IdInvalidNotNullableFlagImplementation,
-        "Invalid NotNullable flag implementation.",
+        "Invalid NotNullable flag implementation",
         "NotNullable flag is either not typed as bool, or does not have a default value equaling false",
         "Usage",
         DiagnosticSeverity.Error,
@@ -41,7 +42,7 @@ public sealed class NotNullableFlagAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor InvalidNotNullableTypeRule = new (
         Diagnostics.IdInvalidNotNullableFlagType,
         "Failed to resolve type parameter",
-        "Failed to resolve type parameter \"{0}\".",
+        "Failed to resolve type parameter \"{0}\"",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -49,7 +50,7 @@ public sealed class NotNullableFlagAnalyzer : DiagnosticAnalyzer
 
     private static readonly DiagnosticDescriptor NotNullableFlagValueTypeRule = new (
         Diagnostics.IdNotNullableFlagValueType,
-        "NotNullable flag not supported for value types.",
+        "NotNullable flag not supported for value types",
         "Value types as generic arguments are not supported for NotNullable flags",
         "Usage",
         DiagnosticSeverity.Error,

Robust.Analyzers/PreferGenericVariantAnalyzer.cs

@@ -11,6 +11,7 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 

Robust.Analyzers/PreferNonGenericVariantForAnalyzer.cs

@@ -0,0 +1,65 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class PreferNonGenericVariantForAnalyzer : DiagnosticAnalyzer
+{
+    private const string AttributeType = "Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute";
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
+        UseNonGenericVariantDescriptor
+    );
+
+    private static readonly DiagnosticDescriptor UseNonGenericVariantDescriptor = new(
+        Diagnostics.IdUseNonGenericVariant,
+        "Consider using the non-generic variant of this method",
+        "Use the non-generic variant of this method for type {0}",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true,
+        "Use the generic variant of this method.");
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.ReportDiagnostics | GeneratedCodeAnalysisFlags.Analyze);
+        context.EnableConcurrentExecution();
+        context.RegisterOperationAction(CheckForNonGenericVariant, OperationKind.Invocation);
+    }
+
+    private void CheckForNonGenericVariant(OperationAnalysisContext obj)
+    {
+        if (obj.Operation is not IInvocationOperation invocationOperation) return;
+
+        var preferNonGenericAttribute = obj.Compilation.GetTypeByMetadataName(AttributeType);
+
+        HashSet<ITypeSymbol> forTypes = [];
+        foreach (var attribute in invocationOperation.TargetMethod.GetAttributes())
+        {
+            if (!SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, preferNonGenericAttribute))
+                continue;
+
+            foreach (var type in attribute.ConstructorArguments[0].Values)
+                forTypes.Add((ITypeSymbol)type.Value);
+
+            break;
+        }
+
+        if (forTypes == null)
+            return;
+
+        foreach (var typeArg in invocationOperation.TargetMethod.TypeArguments)
+        {
+            if (forTypes.Contains(typeArg))
+            {
+                obj.ReportDiagnostic(
+                Diagnostic.Create(UseNonGenericVariantDescriptor,
+                    invocationOperation.Syntax.GetLocation(), typeArg.Name));
+            }
+        }
+    }
+}

Robust.Analyzers/PreferOtherTypeAnalyzer.cs

@@ -0,0 +1,75 @@
+#nullable enable
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class PreferOtherTypeAnalyzer : DiagnosticAnalyzer
+{
+    private const string AttributeType = "Robust.Shared.Analyzers.PreferOtherTypeAttribute";
+
+    private static readonly DiagnosticDescriptor PreferOtherTypeDescriptor = new(
+        Diagnostics.IdPreferOtherType,
+        "Use the specific type",
+        "Use the specific type {0} instead of {1} when the type argument is {2}",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true,
+        "Use the specific type.");
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
+        PreferOtherTypeDescriptor
+    );
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.ReportDiagnostics | GeneratedCodeAnalysisFlags.Analyze);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeField, SyntaxKind.VariableDeclaration);
+    }
+
+    private void AnalyzeField(SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node is not VariableDeclarationSyntax node)
+            return;
+
+        // Get the type of the generic being used
+        if (node.Type is not GenericNameSyntax genericName)
+            return;
+        var genericSyntax = genericName.TypeArgumentList.Arguments[0];
+        if (context.SemanticModel.GetSymbolInfo(genericSyntax).Symbol is not { } genericType)
+            return;
+
+        // Look for the PreferOtherTypeAttribute
+        var symbolInfo = context.SemanticModel.GetSymbolInfo(node.Type);
+        if (symbolInfo.Symbol?.GetAttributes() is not { } attributes)
+            return;
+
+        var preferOtherTypeAttribute = context.Compilation.GetTypeByMetadataName(AttributeType);
+
+        foreach (var attribute in attributes)
+        {
+            if (!SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, preferOtherTypeAttribute))
+                continue;
+
+            // See if the generic type argument matches the type the attribute specifies
+            if (attribute.ConstructorArguments[0].Value is not ITypeSymbol checkedType)
+                return;
+            if (!SymbolEqualityComparer.Default.Equals(checkedType, genericType))
+                continue;
+
+            if (attribute.ConstructorArguments[1].Value is not ITypeSymbol replacementType)
+                continue;
+            context.ReportDiagnostic(Diagnostic.Create(PreferOtherTypeDescriptor,
+                context.Node.GetLocation(),
+                replacementType.Name,
+                symbolInfo.Symbol.Name,
+                genericType.Name));
+        }
+    }
+}

Robust.Analyzers/PreferOtherTypeFixer.cs

@@ -0,0 +1,97 @@
+#nullable enable
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using static Robust.Roslyn.Shared.Diagnostics;
+
+namespace Robust.Analyzers;
+
+[ExportCodeFixProvider(LanguageNames.CSharp)]
+public sealed class PreferOtherTypeFixer : CodeFixProvider
+{
+    private const string PreferOtherTypeAttributeName = "PreferOtherTypeAttribute";
+
+    public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
+        IdPreferOtherType
+    );
+
+    public override FixAllProvider GetFixAllProvider()
+    {
+        return WellKnownFixAllProviders.BatchFixer;
+    }
+
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        foreach (var diagnostic in context.Diagnostics)
+        {
+            switch (diagnostic.Id)
+            {
+                case IdPreferOtherType:
+                    return RegisterReplaceType(context, diagnostic);
+            }
+        }
+
+        return Task.CompletedTask;
+    }
+
+    private static async Task RegisterReplaceType(CodeFixContext context, Diagnostic diagnostic)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+        var span = diagnostic.Location.SourceSpan;
+        var token = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<VariableDeclarationSyntax>().First();
+
+        if (token == null)
+            return;
+
+        context.RegisterCodeFix(CodeAction.Create(
+            "Replace type",
+            c => ReplaceType(context.Document, token, c),
+            "Replace type"
+        ), diagnostic);
+    }
+
+    private static async Task<Document> ReplaceType(Document document, VariableDeclarationSyntax syntax, CancellationToken cancellation)
+    {
+        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
+        var model = await document.GetSemanticModelAsync(cancellation);
+
+        if (model == null)
+            return document;
+
+        if (syntax.Type is not GenericNameSyntax genericNameSyntax)
+            return document;
+        var genericTypeSyntax = genericNameSyntax.TypeArgumentList.Arguments[0];
+        if (model.GetSymbolInfo(genericTypeSyntax).Symbol is not {} genericTypeSymbol)
+            return document;
+
+        var symbolInfo = model.GetSymbolInfo(syntax.Type);
+        if (symbolInfo.Symbol?.GetAttributes() is not { } attributes)
+            return document;
+
+        foreach (var attribute in attributes)
+        {
+            if (attribute.AttributeClass?.Name != PreferOtherTypeAttributeName)
+                continue;
+
+            if (attribute.ConstructorArguments[0].Value is not ITypeSymbol checkedTypeSymbol)
+                continue;
+
+            if (!SymbolEqualityComparer.Default.Equals(checkedTypeSymbol, genericTypeSymbol))
+                continue;
+
+            if (attribute.ConstructorArguments[1].Value is not ITypeSymbol replacementTypeSymbol)
+                continue;
+
+            var replacementIdentifier = SyntaxFactory.IdentifierName(replacementTypeSymbol.Name);
+            var replacementSyntax = syntax.WithType(replacementIdentifier);
+
+            root = root!.ReplaceNode(syntax, replacementSyntax);
+            return document.WithSyntaxRoot(root);
+        }
+
+        return document;
+    }
+}

Robust.Analyzers/Robust.Analyzers.csproj

@@ -1,30 +1,47 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <LangVersion>10</LangVersion>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.0.1" />
-  </ItemGroup>
-
   <ItemGroup>
     <!-- Needed for NotNullableFlagAnalyzer. -->
-    <Compile Include="..\Robust.Shared\Analyzers\NotNullableFlagAttribute.cs" />
+    <Compile Include="..\Robust.Shared\Analyzers\NotNullableFlagAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
-  
+
   <ItemGroup>
     <!-- Needed for FriendAnalyzer. -->
-    <Compile Include="..\Robust.Shared\Analyzers\AccessAttribute.cs" />
-    <Compile Include="..\Robust.Shared\Analyzers\AccessPermissions.cs" />
+    <Compile Include="..\Robust.Shared\Analyzers\AccessAttribute.cs" LinkBase="Implementations" />
+    <Compile Include="..\Robust.Shared\Analyzers\AccessPermissions.cs" LinkBase="Implementations" />
   </ItemGroup>
 
   <ItemGroup>
     <!-- Needed for PreferGenericVariantAnalyzer. -->
-    <Compile Include="..\Robust.Shared\Analyzers\PreferGenericVariantAttribute.cs" />
+    <Compile Include="..\Robust.Shared\Analyzers\PreferGenericVariantAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
+  <ItemGroup>
+    <!-- Needed for PreferNonGenericVariantAnalyzer. -->
+    <Compile Include="..\Robust.Shared\Analyzers\PreferNonGenericVariantForAttribute.cs" LinkBase="Implementations" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- Needed for PreferOtherTypeAnalyzer. -->
+    <Compile Include="..\Robust.Shared\Analyzers\PreferOtherTypeAttribute.cs" LinkBase="Implementations" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- Needed for DataDefinitionAnalyzer. -->
+    <Compile Include="..\Robust.Shared\Serialization\Manager\Definition\DataDefinitionUtility.cs" LinkBase="Implementations" />
+    <Compile Include="..\Robust.Shared\ViewVariables\ViewVariablesAttribute.cs" LinkBase="Implementations" />
+    <Compile Include="..\Robust.Shared\Serialization\NetSerializableAttribute.cs" LinkBase="Implementations" />
+  </ItemGroup>
+
+  <Import Project="../Robust.Roslyn.Shared/Robust.Roslyn.Shared.props" />
+
+  <PropertyGroup>
+    <Nullable>disable</Nullable>
+    <!--
+    Rider seems to get really confused with hot reload if we directly compile in the above-linked classes.
+    As such, they have an #if to change their namespace in this project.
+    -->
+    <DefineConstants>$(DefineConstants);ROBUST_ANALYZERS_IMPL</DefineConstants>
+  </PropertyGroup>
+
 </Project>

Robust.Analyzers/SerializableAnalyzer.cs

@@ -10,6 +10,7 @@ using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers
 {

Robust.Analyzers/TaskResultAnalyzer.cs

@@ -3,6 +3,7 @@ using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 

Robust.Benchmarks/Collections/ValueListEnumerationBenchmarks.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
+using Robust.Shared.Collections;
+
+namespace Robust.Benchmarks.Collections;
+
+[Virtual]
+public class ValueListEnumerationBenchmarks
+{
+    [Params(4, 16, 64)]
+    public int N { get; set; }
+
+    private sealed class Data(int i)
+    {
+        public readonly int I = i;
+    }
+
+    private ValueList<Data> _valueList;
+    private Data[] _array = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var list = new List<Data>(N);
+        for (var i = 0; i < N; i++)
+        {
+            list.Add(new(i));
+        }
+
+        _array = list.ToArray();
+        _valueList = new(list.ToArray());
+    }
+
+    [Benchmark]
+    public int ValueList()
+    {
+        var total = 0;
+        foreach (var ev in _valueList)
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+
+    [Benchmark]
+    public int ValueListSpan()
+    {
+        var total = 0;
+        foreach (var ev in _valueList.Span)
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+
+    [Benchmark]
+    public int Array()
+    {
+        var total = 0;
+        foreach (var ev in _array)
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+
+    [Benchmark]
+    public int Span()
+    {
+        var total = 0;
+        foreach (var ev in _array.AsSpan())
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+}

Robust.Benchmarks/Configs/DefaultSQLConfig.cs

@@ -1,15 +1,18 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Globalization;
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Validators;
 using Robust.Benchmarks.Exporters;
 
@@ -23,7 +26,8 @@ public sealed class DefaultSQLConfig : IConfig
 
     public IEnumerable<IExporter> GetExporters()
     {
-        yield return SQLExporter.Default;
+        //yield return SQLExporter.Default;
+        yield break;
     }
 
     public IEnumerable<IColumnProvider> GetColumnProviders() => DefaultConfig.Instance.GetColumnProviders();
@@ -44,10 +48,16 @@ public sealed class DefaultSQLConfig : IConfig
 
     public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => DefaultConfig.Instance.GetLogicalGroupRules();
 
+    public IEnumerable<EventProcessor> GetEventProcessors() => DefaultConfig.Instance.GetEventProcessors();
+
+    public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => DefaultConfig.Instance.GetColumnHidingRules();
     public IOrderer Orderer => DefaultConfig.Instance.Orderer!;
+    public ICategoryDiscoverer? CategoryDiscoverer => DefaultConfig.Instance.CategoryDiscoverer;
     public SummaryStyle SummaryStyle => DefaultConfig.Instance.SummaryStyle;
     public ConfigUnionRule UnionRule => DefaultConfig.Instance.UnionRule;
     public string ArtifactsPath => DefaultConfig.Instance.ArtifactsPath;
     public CultureInfo CultureInfo => DefaultConfig.Instance.CultureInfo!;
     public ConfigOptions Options => DefaultConfig.Instance.Options;
+    public TimeSpan BuildTimeout => DefaultConfig.Instance.BuildTimeout;
+    public IReadOnlyList<Conclusion> ConfigAnalysisConclusion => DefaultConfig.Instance.ConfigAnalysisConclusion;
 }

Robust.Benchmarks/EntityManager/AddRemoveComponentBenchmark.cs

@@ -26,9 +26,8 @@ public partial class AddRemoveComponentBenchmark
             .InitializeInstance();
 
         _entityManager = _simulation.Resolve<IEntityManager>();
-
-        var coords = new MapCoordinates(0, 0, new MapId(1));
-        _simulation.AddMap(coords.MapId);
+        var map = _simulation.CreateMap().Uid;
+        var coords = new EntityCoordinates(map, default);
 
         for (var i = 0; i < N; i++)
         {

Robust.Benchmarks/EntityManager/ComponentIteratorBenchmark.cs

@@ -29,8 +29,8 @@ public partial class ComponentIteratorBenchmark
 
         Comps = new A[N+2];
 
-        var coords = new MapCoordinates(0, 0, new MapId(1));
-        _simulation.AddMap(coords.MapId);
+        var map = _simulation.CreateMap().MapId;
+        var coords = new MapCoordinates(default, map);
 
         for (var i = 0; i < N; i++)
         {

Robust.Benchmarks/EntityManager/GetComponentBenchmark.cs

@@ -31,8 +31,8 @@ public partial class GetComponentBenchmark
 
         Comps = new A[N+2];
 
-        var coords = new MapCoordinates(0, 0, new MapId(1));
-        _simulation.AddMap(coords.MapId);
+        var map = _simulation.CreateMap().Uid;
+        var coords = new EntityCoordinates(map, default);
 
         for (var i = 0; i < N; i++)
         {

Robust.Benchmarks/EntityManager/SpawnDeleteEntityBenchmark.cs

@@ -29,10 +29,9 @@ public partial class SpawnDeleteEntityBenchmark
             .InitializeInstance();
 
         _entityManager = _simulation.Resolve<IEntityManager>();
-
-        _mapCoords = new MapCoordinates(0, 0, new MapId(1));
-        var uid = _simulation.AddMap(_mapCoords.MapId);
-        _entCoords = new EntityCoordinates(uid, 0, 0);
+        var (map, mapId) = _simulation.CreateMap();
+        _mapCoords = new MapCoordinates(default, mapId);
+        _entCoords = new EntityCoordinates(map, 0, 0);
     }
 
     [Benchmark(Baseline = true)]

Robust.Benchmarks/Exporters/SQLExporter.cs

@@ -15,11 +15,10 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Design;
 using Npgsql;
 using Npgsql.Internal;
-using Npgsql.Internal.TypeHandlers;
-using Npgsql.Internal.TypeHandling;
 
 namespace Robust.Benchmarks.Exporters;
 
+/*
 public sealed class SQLExporter : IExporter
 {
     private static readonly JsonSerializerOptions JsonSerializerOptions = new JsonSerializerOptions
@@ -98,7 +97,9 @@ public sealed class SQLExporter : IExporter
 
     public string Name => "sql";
 }
+*/
 
+/*
 // https://github.com/npgsql/efcore.pg/issues/1107#issuecomment-945126627
 class JsonOverrideTypeHandlerResolverFactory : TypeHandlerResolverFactory
 {
@@ -138,6 +139,7 @@ class JsonOverrideTypeHandlerResolverFactory : TypeHandlerResolverFactory
             => null; // Let the built-in resolver do this
     }
 }
+*/
 
 public sealed class DesignTimeContextFactoryPostgres : IDesignTimeDbContextFactory<BenchmarkContext>
 {

Robust.Benchmarks/Robust.Benchmarks.csproj

@@ -13,12 +13,12 @@
     <ProjectReference Include="..\Robust.UnitTesting\Robust.UnitTesting.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.0">
+    <PackageReference Include="BenchmarkDotNet" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.4" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
   </ItemGroup>
 
   <Import Project="..\MSBuild\Robust.Properties.targets" />

Robust.Benchmarks/Transform/RecursiveMoveBenchmark.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Numerics;
+using System.Threading.Tasks;
 using BenchmarkDotNet.Attributes;
 using Robust.Server.Containers;
 using Robust.Server.GameStates;
@@ -11,7 +12,9 @@ using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
-using Robust.UnitTesting.Server;
+using Robust.Shared.Network;
+using Robust.Shared.Player;
+using Robust.UnitTesting;
 
 namespace Robust.Benchmarks.Transform;
 
@@ -19,114 +22,176 @@ namespace Robust.Benchmarks.Transform;
 /// This benchmark tests various transform/move related functions with an entity that has many children.
 /// </summary>
 [Virtual, MemoryDiagnoser]
-public class RecursiveMoveBenchmark
+public class RecursiveMoveBenchmark : RobustIntegrationTest
 {
-    private ISimulation _simulation = default!;
     private IEntityManager _entMan = default!;
     private SharedTransformSystem _transform = default!;
     private ContainerSystem _container = default!;
     private PvsSystem _pvs = default!;
     private EntityCoordinates _mapCoords;
     private EntityCoordinates _gridCoords;
+    private EntityCoordinates _gridCoords2;
     private EntityUid _ent;
     private EntityUid _child;
     private TransformComponent _childXform = default!;
     private EntityQuery<TransformComponent> _query;
+    private ICommonSession[] _players = default!;
+    private PvsSession _session = default!;
 
     [GlobalSetup]
     public void GlobalSetup()
     {
-        _simulation = RobustServerSimulation
-            .NewSimulation()
-            .InitializeInstance();
+        ProgramShared.PathOffset = "../../../../";
+        var server = StartServer();
+        var client = StartClient();
 
-        if (!_simulation.Resolve<IConfigurationManager>().GetCVar(CVars.NetPVS))
-            throw new InvalidOperationException("PVS must be enabled");
+        Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()).Wait();
+
+        var mapMan = server.ResolveDependency<IMapManager>();
+        _entMan = server.ResolveDependency<IEntityManager>();
+        var confMan = server.ResolveDependency<IConfigurationManager>();
+        var sPlayerMan = server.ResolveDependency<ISharedPlayerManager>();
 
-        _entMan = _simulation.Resolve<IEntityManager>();
         _transform = _entMan.System<SharedTransformSystem>();
         _container = _entMan.System<ContainerSystem>();
         _pvs = _entMan.System<PvsSystem>();
         _query = _entMan.GetEntityQuery<TransformComponent>();
-
-        // Create map & grid
-        var mapMan = _simulation.Resolve<IMapManager>();
         var mapSys = _entMan.System<SharedMapSystem>();
-        var mapId = mapMan.CreateMap();
-        var map = mapMan.GetMapEntityId(mapId);
-        var gridComp = mapMan.CreateGrid(mapId);
-        var grid = gridComp.Owner;
-        _gridCoords = new EntityCoordinates(grid, .5f, .5f);
-        _mapCoords = new EntityCoordinates(map, 100, 100);
-        mapSys.SetTile(grid, gridComp, Vector2i.Zero, new Tile(1));
 
-        // Next, we will spawn our test entity. This entity will have a  complex transform/container hierarchy.
-        // This is intended to be representative of a typical SS14 player entity, with organs. clothing, and a full backpack.
-        _ent = _entMan.Spawn();
+        var netMan = client.ResolveDependency<IClientNetManager>();
+        client.SetConnectTarget(server);
+        client.Post(() => netMan.ClientConnect(null!, 0, null!));
+        server.Post(() => confMan.SetCVar(CVars.NetPVS, true));
 
-        // Quick check that SetCoordinates actually changes the parent as expected
-        // I.e., ensure that grid-traversal code doesn't just dump the entity on the map.
-        _transform.SetCoordinates(_ent, _gridCoords);
-        if (_query.GetComponent(_ent).ParentUid != _gridCoords.EntityId)
-            throw new Exception("Grid traversal error.");
-
-        _transform.SetCoordinates(_ent, _mapCoords);
-        if (_query.GetComponent(_ent).ParentUid != _mapCoords.EntityId)
-            throw new Exception("Grid traversal error.");
-
-        // Add 5 direct children in slots to represent clothing.
-        for (var i = 0; i < 5; i++)
+        for (int i = 0; i < 10; i++)
         {
-            var id = $"inventory{i}";
-            _container.EnsureContainer<ContainerSlot>(_ent, id);
-            if (!_entMan.TrySpawnInContainer(null, _ent, id, out _))
-                throw new Exception($"Failed to setup entity");
+            server.WaitRunTicks(1).Wait();
+            client.WaitRunTicks(1).Wait();
         }
 
-        // body parts
-        _container.EnsureContainer<Container>(_ent, "body");
-        for (var i = 0; i < 5; i++)
+        // Ensure client & server ticks are synced.
+        // Client runs 1 tick ahead
         {
-            // Simple organ
-            if (!_entMan.TrySpawnInContainer(null, _ent, "body", out _))
-                throw new Exception($"Failed to setup entity");
+            var sTick = (int)server.Timing.CurTick.Value;
+            var cTick = (int)client.Timing.CurTick.Value;
+            var delta = cTick - sTick;
 
-            // body part that has another body part / limb
-            if (!_entMan.TrySpawnInContainer(null, _ent, "body", out var limb))
-                throw new Exception($"Failed to setup entity");
+            if (delta > 1)
+                server.WaitRunTicks(delta - 1).Wait();
+            else if (delta < 1)
+                client.WaitRunTicks(1 - delta).Wait();
 
-            _container.EnsureContainer<ContainerSlot>(limb.Value, "limb");
-            if (!_entMan.TrySpawnInContainer(null, limb.Value, "limb", out _))
-                throw new Exception($"Failed to setup entity");
+            sTick = (int)server.Timing.CurTick.Value;
+            cTick = (int)client.Timing.CurTick.Value;
+            delta = cTick - sTick;
+            if (delta != 1)
+                throw new Exception("Failed setup");
         }
 
-        // Backpack
-        _container.EnsureContainer<ContainerSlot>(_ent, "inventory-backpack");
-        if (!_entMan.TrySpawnInContainer(null, _ent, "inventory-backpack", out var backpack))
-            throw new Exception($"Failed to setup entity");
-
-        // Misc backpack contents.
-        var backpackStorage = _container.EnsureContainer<Container>(backpack.Value, "storage");
-        for (var i = 0; i < 10; i++)
+        // Set up map and spawn player
+        server.WaitPost(() =>
         {
-            if (!_entMan.TrySpawnInContainer(null, backpack.Value, "storage", out _))
+            var map = server.ResolveDependency<SharedMapSystem>().CreateMap(out var mapId);
+            var gridComp = mapMan.CreateGridEntity(mapId);
+            var grid = gridComp.Owner;
+            mapSys.SetTile(grid, gridComp, Vector2i.Zero, new Tile(1));
+            _gridCoords = new EntityCoordinates(grid, .5f, .5f);
+            _gridCoords2 = new EntityCoordinates(grid, .5f, .6f);
+            _mapCoords = new EntityCoordinates(map, 100, 100);
+
+            var playerUid = _entMan.SpawnEntity(null, _mapCoords);
+
+            // Attach player.
+            var session = sPlayerMan.Sessions.First();
+            server.PlayerMan.SetAttachedEntity(session, playerUid);
+            sPlayerMan.JoinGame(session);
+
+            // Next, we will spawn our test entity. This entity will have a  complex transform/container hierarchy.
+            // This is intended to be representative of a typical SS14 player entity, with organs. clothing, and a full backpack.
+            _ent = _entMan.Spawn();
+
+            // Quick check that SetCoordinates actually changes the parent as expected
+            // I.e., ensure that grid-traversal code doesn't just dump the entity on the map.
+            _transform.SetCoordinates(_ent, _gridCoords);
+            if (_query.GetComponent(_ent).ParentUid != _gridCoords.EntityId)
+                throw new Exception("Grid traversal error.");
+
+            _transform.SetCoordinates(_ent, _mapCoords);
+            if (_query.GetComponent(_ent).ParentUid != _mapCoords.EntityId)
+                throw new Exception("Grid traversal error.");
+
+            // Add 5 direct children in slots to represent clothing.
+            for (var i = 0; i < 5; i++)
+            {
+                var id = $"inventory{i}";
+                _container.EnsureContainer<ContainerSlot>(_ent, id);
+                if (!_entMan.TrySpawnInContainer(null, _ent, id, out _))
+                    throw new Exception($"Failed to setup entity");
+            }
+
+            // body parts
+            _container.EnsureContainer<Container>(_ent, "body");
+            for (var i = 0; i < 5; i++)
+            {
+                // Simple organ
+                if (!_entMan.TrySpawnInContainer(null, _ent, "body", out _))
+                    throw new Exception($"Failed to setup entity");
+
+                // body part that has another body part / limb
+                if (!_entMan.TrySpawnInContainer(null, _ent, "body", out var limb))
+                    throw new Exception($"Failed to setup entity");
+
+                _container.EnsureContainer<ContainerSlot>(limb.Value, "limb");
+                if (!_entMan.TrySpawnInContainer(null, limb.Value, "limb", out _))
+                    throw new Exception($"Failed to setup entity");
+            }
+
+            // Backpack
+            _container.EnsureContainer<ContainerSlot>(_ent, "inventory-backpack");
+            if (!_entMan.TrySpawnInContainer(null, _ent, "inventory-backpack", out var backpack))
                 throw new Exception($"Failed to setup entity");
+
+            // Misc backpack contents.
+            var backpackStorage = _container.EnsureContainer<Container>(backpack.Value, "storage");
+            for (var i = 0; i < 10; i++)
+            {
+                if (!_entMan.TrySpawnInContainer(null, backpack.Value, "storage", out _))
+                    throw new Exception($"Failed to setup entity");
+            }
+
+            // Emergency box inside of the backpack
+            var box = backpackStorage.ContainedEntities.First();
+            var boxContainer = _container.EnsureContainer<Container>(box, "storage");
+            for (var i = 0; i < 10; i++)
+            {
+                if (!_entMan.TrySpawnInContainer(null, box, "storage", out _))
+                    throw new Exception($"Failed to setup entity");
+            }
+
+            // Deepest child.
+            _child = boxContainer.ContainedEntities.First();
+            _childXform = _query.GetComponent(_child);
+
+            _players = new[] {session};
+            _session = _pvs.PlayerData[session];
+        }).Wait();
+
+        for (int i = 0; i < 10; i++)
+        {
+            server.WaitRunTicks(1).Wait();
+            client.WaitRunTicks(1).Wait();
         }
 
-        // Emergency box inside of the backpack
-        var box = backpackStorage.ContainedEntities.First();
-        var boxContainer = _container.EnsureContainer<Container>(box, "storage");
-        for (var i = 0; i < 10; i++)
-        {
-            if (!_entMan.TrySpawnInContainer(null, box, "storage", out _))
-                throw new Exception($"Failed to setup entity");
-        }
+        PvsTick();
+        PvsTick();
+    }
 
-        // Deepest child.
-        _child = boxContainer.ContainedEntities.First();
-        _childXform = _query.GetComponent(_child);
-
-        _pvs.ProcessCollections();
+    private void PvsTick()
+    {
+        _session.ClearState();
+        _pvs.CacheSessionData(_players);
+        _pvs.GetVisibleChunks();
+        _pvs.ProcessVisibleChunksSequential();
     }
 
     /// <summary>
@@ -140,6 +205,13 @@ public class RecursiveMoveBenchmark
         _transform.SetCoordinates(_ent, _mapCoords);
     }
 
+    [Benchmark]
+    public void MoveEntityASmidge()
+    {
+        _transform.SetCoordinates(_ent, _gridCoords);
+        _transform.SetCoordinates(_ent, _gridCoords2);
+    }
+
     /// <summary>
     /// Like <see cref="MoveEntity"/>, but also processes queued PVS chunk updates.
     /// </summary>
@@ -147,9 +219,18 @@ public class RecursiveMoveBenchmark
     public void MoveAndUpdateChunks()
     {
         _transform.SetCoordinates(_ent, _gridCoords);
-        _pvs.ProcessCollections();
+        PvsTick();
         _transform.SetCoordinates(_ent, _mapCoords);
-        _pvs.ProcessCollections();
+        PvsTick();
+    }
+
+    [Benchmark]
+    public void MoveASmidgeAndUpdateChunk()
+    {
+        _transform.SetCoordinates(_ent, _gridCoords);
+        PvsTick();
+        _transform.SetCoordinates(_ent, _gridCoords2);
+        PvsTick();
     }
 
     [Benchmark]

Robust.Client.Injectors/Robust.Client.Injectors.csproj

@@ -6,8 +6,8 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.Build.Framework" Version="17.0.0" />
-      <PackageReference Include="Mono.Cecil" Version="0.11.3" />
+      <PackageReference Include="Microsoft.Build.Framework" Version="17.8.3" />
+      <PackageReference Include="Mono.Cecil" Version="0.11.5" />
       <PackageReference Include="Pidgin" Version="2.5.0" />
     </ItemGroup>
 

Robust.Client.Injectors/XamlCompiler.cs

@@ -239,6 +239,7 @@ namespace Robust.Build.Tasks
                         engine.LogErrorEvent(new BuildErrorEventArgs("XAMLIL", "", res.FilePath, 0, 0, 0, 0,
                             $"{res.FilePath}: {e.Message}", "", "CompileRobustXaml"));
                     }
+                    res.Remove();
                 }
                 return true;
             }

Robust.Client.NameGenerator/Robust.Client.NameGenerator.csproj

@@ -1,18 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-    <PropertyGroup>
-        <TargetFramework>netstandard2.0</TargetFramework>
-    </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" PrivateAssets="all" />
-  </ItemGroup>
-
   <ItemGroup>
     <Compile Link="XamlX\filename" Include="../XamlX/src/XamlX/**/*.cs" />
     <Compile Remove="../XamlX/src/XamlX/**/SreTypeSystem.cs" />
     <Compile Remove="../XamlX/src/XamlX/obj/**" />
     <Compile Include="..\Robust.Client\UserInterface\ControlPropertyAccess.cs" />
   </ItemGroup>
+
+  <Import Project="../Robust.Roslyn.Shared/Robust.Roslyn.Shared.props" />
+
+  <PropertyGroup>
+    <!-- XamlX doesn't do NRTs. -->
+    <Nullable>disable</Nullable>
+  </PropertyGroup>
+
 </Project>

Robust.Client.WebView/Cef/BaseRobustCefClient.cs

@@ -0,0 +1,85 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView.Cef;
+
+/// <summary>
+/// Shared functionality for all <see cref="CefClient"/> implementations.
+/// </summary>
+/// <remarks>
+/// Locks down a bunch of CEF functionality we absolutely do not need content to do right now.
+/// </remarks>
+internal abstract class BaseRobustCefClient : CefClient
+{
+    private readonly RobustCefPrintHandler _printHandler = new();
+    private readonly RobustCefPermissionHandler _permissionHandler = new();
+    private readonly RobustCefDialogHandler _dialogHandler = new();
+    private readonly RobustCefDragHandler _dragHandler = new();
+
+    protected override CefPrintHandler GetPrintHandler() => _printHandler;
+    protected override CefPermissionHandler GetPermissionHandler() => _permissionHandler;
+    protected override CefDialogHandler GetDialogHandler() => _dialogHandler;
+    protected override CefDragHandler GetDragHandler() => _dragHandler;
+
+    private sealed class RobustCefPrintHandler : CefPrintHandler
+    {
+        protected override void OnPrintSettings(CefBrowser browser, CefPrintSettings settings, bool getDefaults)
+        {
+        }
+
+        protected override bool OnPrintDialog(CefBrowser browser, bool hasSelection, CefPrintDialogCallback callback)
+        {
+            return false;
+        }
+
+        protected override bool OnPrintJob(CefBrowser browser, string documentName, string pdfFilePath, CefPrintJobCallback callback)
+        {
+            return false;
+        }
+
+        protected override void OnPrintReset(CefBrowser browser)
+        {
+        }
+    }
+
+    private sealed class RobustCefPermissionHandler : CefPermissionHandler
+    {
+        protected override bool OnRequestMediaAccessPermission(
+            CefBrowser browser,
+            CefFrame frame,
+            string requestingOrigin,
+            CefMediaAccessPermissionTypes requestedPermissions,
+            CefMediaAccessCallback callback)
+        {
+            callback.Cancel();
+
+            return true;
+        }
+    }
+
+    private sealed class RobustCefDialogHandler : CefDialogHandler
+    {
+        protected override bool OnFileDialog(
+            CefBrowser browser,
+            CefFileDialogMode mode,
+            string title,
+            string defaultFilePath,
+            string[] acceptFilters,
+            CefFileDialogCallback callback)
+        {
+            callback.Cancel();
+            return true;
+        }
+    }
+
+    private sealed class RobustCefDragHandler : CefDragHandler
+    {
+        protected override bool OnDragEnter(CefBrowser browser, CefDragData dragData, CefDragOperationsMask mask)
+        {
+            return true;
+        }
+
+        protected override void OnDraggableRegionsChanged(CefBrowser browser, CefFrame frame, CefDraggableRegion[] regions)
+        {
+        }
+    }
+}

Robust.Client.WebView/Cef/Program.cs

@@ -1,4 +1,7 @@
 using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.Threading;
 using Xilium.CefGlue;
 
 namespace Robust.Client.WebView.Cef
@@ -19,6 +22,8 @@ namespace Robust.Client.WebView.Cef
 
             var mainArgs = new CefMainArgs(argv);
 
+            StartWatchThread();
+
             // This will block executing until the subprocess is shut down.
             var code = CefRuntime.ExecuteProcess(mainArgs, new RobustCefApp(null), IntPtr.Zero);
 
@@ -29,5 +34,44 @@ namespace Robust.Client.WebView.Cef
 
             return code;
         }
+
+        private static void StartWatchThread()
+        {
+            //
+            // CEF has this nasty habit of not shutting down all its processes if the parent crashes.
+            // Great!
+            //
+            // We use a separate thread in each CEF child process to watch the main PID.
+            // If it exits, we kill ourselves after a couple seconds.
+            //
+
+            if (Environment.GetEnvironmentVariable("ROBUST_CEF_BROWSER_PROCESS_ID") is not { } parentIdString)
+                return;
+
+            if (Environment.GetEnvironmentVariable("ROBUST_CEF_BROWSER_PROCESS_MODULE") is not { } parentModuleString)
+                return;
+
+            if (!int.TryParse(parentIdString, CultureInfo.InvariantCulture, out var parentId))
+                return;
+
+            var process = Process.GetProcessById(parentId);
+            if ((process.MainModule?.FileName ?? "") != parentModuleString)
+            {
+                process.Dispose();
+                return;
+            }
+
+            new Thread(() => WatchThread(process)) { Name = "CEF Watch Thread", IsBackground = true }
+                .Start();
+        }
+
+        private static void WatchThread(Process p)
+        {
+            p.WaitForExit();
+
+            Thread.Sleep(3000);
+
+            Environment.Exit(1);
+        }
     }
 }

Robust.Client.WebView/Cef/RequestResults.cs

@@ -76,12 +76,9 @@ namespace Robust.Client.WebView.Cef
                 return true;
             }
 
-            protected override unsafe bool Read(IntPtr dataOut, int bytesToRead, out int bytesRead, CefResourceReadCallback callback)
+            protected override bool Read(Span<byte> response, out int bytesRead, CefResourceReadCallback callback)
             {
-                var byteSpan = new Span<byte>((void*) dataOut, bytesToRead);
-
-                bytesRead = _stream.Read(byteSpan);
-
+                bytesRead = _stream.Read(response);
                 return bytesRead != 0;
             }
 

Robust.Client.WebView/Cef/RobustCefApp.cs

@@ -31,10 +31,12 @@ namespace Robust.Client.WebView.Cef
             // Disable zygote on Linux.
             commandLine.AppendSwitch("--no-zygote");
 
-            // Work around https://bitbucket.org/chromiumembedded/cef/issues/3213/ozone-egl-initialization-does-not-have
+            // Work around https://github.com/chromiumembedded/cef/issues/3213
             // Desktop GL force makes Chromium not try to load its own ANGLE/Swiftshader so load paths aren't problematic.
-            if (OperatingSystem.IsLinux())
-                commandLine.AppendSwitch("--use-gl", "desktop");
+            // UPDATE: That bug got fixed and now this workaround breaks CEF.
+            // Keeping all this comment history in case I ever wanan remember what the `--use-gl` flag is.
+            //if (OperatingSystem.IsLinux())
+            //    commandLine.AppendSwitch("--use-gl", "desktop");
 
             // commandLine.AppendSwitch("--single-process");
 

Robust.Client.WebView/Cef/RobustCefClient.cs

@@ -3,7 +3,7 @@ using Xilium.CefGlue;
 namespace Robust.Client.WebView.Cef
 {
     // Simple CEF client.
-    internal sealed class RobustCefClient : CefClient
+    internal sealed class RobustCefClient : BaseRobustCefClient
     {
         private readonly CefRenderHandler _renderHandler;
         private readonly CefRequestHandler _requestHandler;

Robust.Client.WebView/Cef/WebViewManagerCef.BrowserWindow.cs

@@ -150,7 +150,7 @@ namespace Robust.Client.WebView.Cef
             }
         }
 
-        private sealed class WindowCefClient : CefClient
+        private sealed class WindowCefClient : BaseRobustCefClient
         {
             private readonly CefLifeSpanHandler _lifeSpanHandler;
             private readonly CefRequestHandler _requestHandler;

Robust.Client.WebView/Cef/WebViewManagerCef.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Net;
 using System.Reflection;
@@ -85,6 +86,10 @@ namespace Robust.Client.WebView.Cef
 
             _app = new RobustCefApp(_sawmill);
 
+            var process = Process.GetCurrentProcess();
+            Environment.SetEnvironmentVariable("ROBUST_CEF_BROWSER_PROCESS_ID", process.Id.ToString());
+            Environment.SetEnvironmentVariable("ROBUST_CEF_BROWSER_PROCESS_MODULE", process.MainModule?.FileName ?? "");
+
             // So these arguments look like nonsense, but it turns out CEF is just *like that*.
             // The first argument is literally nonsense, but it needs to be there as otherwise the second argument doesn't apply
             // The second argument turns off CEF's bullshit error handling, which breaks dotnet's error handling.

Robust.Client.WebView/Robust.Client.WebView.csproj

@@ -8,8 +8,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" />
-    <PackageReference Include="Robust.Natives.Cef" Version="102.0.9" />
+    <PackageReference Include="JetBrains.Annotations" />
+    <PackageReference Include="Robust.Natives.Cef" />
   </ItemGroup>
 
   <ItemGroup>

Robust.Client.WebView/TestBrowseWindow.cs

@@ -0,0 +1,28 @@
+using System.Numerics;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Console;
+
+namespace Robust.Client.WebView;
+
+internal sealed class TestBrowseWindow : DefaultWindow
+{
+    protected override Vector2 ContentsMinimumSize => new Vector2(640, 480);
+
+    public TestBrowseWindow()
+    {
+        var wv = new WebViewControl();
+        wv.Url = "https://spacestation14.io";
+
+        Contents.AddChild(wv);
+    }
+}
+
+internal sealed class TestBrowseWindowCommand : LocalizedCommands
+{
+    public override string Command => "test_browse_window";
+
+    public override void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        new TestBrowseWindow().Open();
+    }
+}

Robust.Client.WebView/WebViewManager.cs

@@ -5,6 +5,7 @@ using Robust.Client.WebView.Headless;
 using Robust.Client.WebViewHook;
 using Robust.Shared.Configuration;
 using Robust.Shared.IoC;
+using Robust.Shared.Reflection;
 using Robust.Shared.Utility;
 
 [assembly: WebViewManagerImpl(typeof(WebViewManager))]
@@ -22,6 +23,9 @@ namespace Robust.Client.WebView
             var cfg = dependencies.Resolve<IConfigurationManagerInternal>();
             cfg.LoadCVarsFromAssembly(typeof(WebViewManager).Assembly);
 
+            var refl = dependencies.Resolve<IReflectionManager>();
+            refl.LoadAssemblies(typeof(WebViewManager).Assembly);
+
             dependencies.RegisterInstance<IWebViewManager>(this);
             dependencies.RegisterInstance<IWebViewManagerInternal>(this);
 

Robust.Client/Animations/AnimationTrackPlaySound.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using Robust.Client.Audio;
 using Robust.Client.GameObjects;
 using Robust.Shared.Audio;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 using Robust.Shared.Player;
 
 namespace Robust.Client.Animations
@@ -37,7 +39,12 @@ namespace Robust.Client.Animations
 
                 var keyFrame = KeyFrames[keyFrameIndex];
 
-                SoundSystem.Play(keyFrame.Resource, Filter.Local(), entity, keyFrame.AudioParamsFunc.Invoke());
+                var audioParams = keyFrame.AudioParamsFunc.Invoke();
+                var audio = new SoundPathSpecifier(keyFrame.Resource)
+                {
+                    Params = audioParams
+                };
+                IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<AudioSystem>().PlayEntity(audio, Filter.Local(), entity, true);
             }
 
             return (keyFrameIndex, playingTime);

Robust.Client/Audio/AudioManager.ALDisposeQueues.cs

@@ -0,0 +1,58 @@
+using System.Collections.Concurrent;
+using OpenTK.Audio.OpenAL;
+
+namespace Robust.Client.Audio;
+
+internal partial class AudioManager
+{
+    // Used to track audio sources that were disposed in the finalizer thread,
+    // so we need to properly send them off in the main thread.
+    private readonly ConcurrentQueue<(int sourceHandle, int filterHandle)> _sourceDisposeQueue = new();
+    private readonly ConcurrentQueue<(int sourceHandle, int filterHandle)> _bufferedSourceDisposeQueue = new();
+    private readonly ConcurrentQueue<int> _bufferDisposeQueue = new();
+
+    public void FlushALDisposeQueues()
+    {
+        // Clear out finalized audio sources.
+        while (_sourceDisposeQueue.TryDequeue(out var handles))
+        {
+            OpenALSawmill.Debug("Cleaning out source {0} which finalized in another thread.", handles.sourceHandle);
+            if (IsEfxSupported) RemoveEfx(handles);
+            AL.DeleteSource(handles.sourceHandle);
+            _checkAlError();
+            _audioSources.Remove(handles.sourceHandle);
+        }
+
+        // Clear out finalized buffered audio sources.
+        while (_bufferedSourceDisposeQueue.TryDequeue(out var handles))
+        {
+            OpenALSawmill.Debug("Cleaning out buffered source {0} which finalized in another thread.", handles.sourceHandle);
+            if (IsEfxSupported) RemoveEfx(handles);
+            AL.DeleteSource(handles.sourceHandle);
+            _checkAlError();
+            _bufferedAudioSources.Remove(handles.sourceHandle);
+        }
+
+        // Clear out finalized audio buffers.
+        while (_bufferDisposeQueue.TryDequeue(out var handle))
+        {
+            AL.DeleteBuffer(handle);
+            _checkAlError();
+        }
+    }
+
+    internal void DeleteSourceOnMainThread(int sourceHandle, int filterHandle)
+    {
+        _sourceDisposeQueue.Enqueue((sourceHandle, filterHandle));
+    }
+
+    internal void DeleteBufferedSourceOnMainThread(int bufferedSourceHandle, int filterHandle)
+    {
+        _bufferedSourceDisposeQueue.Enqueue((bufferedSourceHandle, filterHandle));
+    }
+
+    internal void DeleteAudioBufferOnMainThread(int bufferHandle)
+    {
+        _bufferDisposeQueue.Enqueue(bufferHandle);
+    }
+}

Robust.Client/Audio/AudioManager.Public.cs

@@ -0,0 +1,374 @@
+using System;
+using System.IO;
+using System.Numerics;
+using System.Threading;
+using OpenTK.Audio.OpenAL;
+using Robust.Client.Audio.Sources;
+using Robust.Client.Graphics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.AudioLoading;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio;
+
+internal partial class AudioManager
+{
+    private float _zOffset;
+
+    public void SetZOffset(float offset)
+    {
+        _zOffset = offset;
+    }
+
+    /// <inheritdoc />
+    public float GetAttenuationGain(float distance, float rolloffFactor, float referenceDistance, float maxDistance)
+    {
+        switch (_attenuation)
+        {
+            case Attenuation.LinearDistance:
+                return 1 - rolloffFactor * (distance - referenceDistance) / (maxDistance - referenceDistance);
+            case Attenuation.LinearDistanceClamped:
+                distance = MathF.Max(referenceDistance, MathF.Min(distance, maxDistance));
+                return 1 - rolloffFactor * (distance - referenceDistance) / (maxDistance - referenceDistance);
+            default:
+                // TODO: If you see this you can implement
+                throw new NotImplementedException();
+        }
+    }
+
+    public void InitializePostWindowing()
+    {
+        _gameThread = Thread.CurrentThread;
+        InitializeAudio();
+    }
+
+    public void Shutdown()
+    {
+        DisposeAllAudio();
+
+        if (_openALContext != ALContext.Null)
+        {
+            ALC.MakeContextCurrent(ALContext.Null);
+
+            ALC.DestroyContext(_openALContext);
+        }
+
+        if (_openALDevice != IntPtr.Zero)
+        {
+            ALC.CloseDevice(_openALDevice);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void SetVelocity(Vector2 velocity)
+    {
+        AL.Listener(ALListener3f.Velocity, velocity.X, velocity.Y, 0f);
+    }
+
+    /// <inheritdoc/>
+    public void SetPosition(Vector2 position)
+    {
+        AL.Listener(ALListener3f.Position, position.X, position.Y, _zOffset);
+    }
+
+    /// <inheritdoc/>
+    public void SetRotation(Angle angle)
+    {
+        var vec = angle.ToVec();
+
+        // Default orientation: at: (0, 0, -1)  up: (0, 1, 0)
+        var at = new OpenTK.Mathematics.Vector3(0f, 0f, -1f);
+        var up = new OpenTK.Mathematics.Vector3(vec.Y, vec.X, 0f);
+        AL.Listener(ALListenerfv.Orientation, new []{0, 0, -1, vec.X, vec.Y, 0});
+        AL.Listener(ALListenerfv.Orientation, ref at, ref up);
+    }
+
+    /// <inheritdoc/>
+    public AudioStream LoadAudioOggVorbis(Stream stream, string? name = null)
+    {
+        var vorbis = AudioLoaderOgg.LoadAudioData(stream);
+
+        var buffer = AL.GenBuffer();
+
+        ALFormat format;
+        // NVorbis only supports loading into floats.
+        // If this becomes a problem due to missing extension support (doubt it but ok),
+        // check the git history, I originally used libvorbisfile which worked and loaded 16 bit LPCM.
+        if (vorbis.Channels == 1)
+        {
+            format = ALFormat.Mono16;
+        }
+        else if (vorbis.Channels == 2)
+        {
+            format = ALFormat.Stereo16;
+        }
+        else
+        {
+            throw new InvalidOperationException("Unable to load audio with more than 2 channels.");
+        }
+
+        unsafe
+        {
+            fixed (short* ptr = vorbis.Data.Span)
+            {
+                AL.BufferData(buffer, format, (IntPtr) ptr, vorbis.Data.Length * sizeof(short),
+                    (int) vorbis.SampleRate);
+            }
+        }
+
+        _checkAlError();
+
+        var handle = new ClydeHandle(_audioSampleBuffers.Count);
+        _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
+        var length = TimeSpan.FromSeconds(vorbis.TotalSamples / (double) vorbis.SampleRate);
+        return new AudioStream(handle, length, (int) vorbis.Channels, name, vorbis.Title, vorbis.Artist);
+    }
+
+    /// <inheritdoc/>
+    public AudioStream LoadAudioWav(Stream stream, string? name = null)
+    {
+        var wav = AudioLoaderWav.LoadAudioData(stream);
+
+        var buffer = AL.GenBuffer();
+
+        ALFormat format;
+        if (wav.BitsPerSample == 16)
+        {
+            if (wav.NumChannels == 1)
+            {
+                format = ALFormat.Mono16;
+            }
+            else if (wav.NumChannels == 2)
+            {
+                format = ALFormat.Stereo16;
+            }
+            else
+            {
+                throw new InvalidOperationException("Unable to load audio with more than 2 channels.");
+            }
+        }
+        else if (wav.BitsPerSample == 8)
+        {
+            if (wav.NumChannels == 1)
+            {
+                format = ALFormat.Mono8;
+            }
+            else if (wav.NumChannels == 2)
+            {
+                format = ALFormat.Stereo8;
+            }
+            else
+            {
+                throw new InvalidOperationException("Unable to load audio with more than 2 channels.");
+            }
+        }
+        else
+        {
+            throw new InvalidOperationException("Unable to load wav with bits per sample different from 8 or 16");
+        }
+
+        unsafe
+        {
+            fixed (byte* ptr = wav.Data.Span)
+            {
+                AL.BufferData(buffer, format, (IntPtr) ptr, wav.Data.Length, wav.SampleRate);
+            }
+        }
+
+        _checkAlError();
+
+        var handle = new ClydeHandle(_audioSampleBuffers.Count);
+        _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
+        var length = TimeSpan.FromSeconds(wav.Data.Length / (double) wav.BlockAlign / wav.SampleRate);
+        return new AudioStream(handle, length, wav.NumChannels, name);
+    }
+
+    /// <inheritdoc/>
+    public AudioStream LoadAudioRaw(ReadOnlySpan<short> samples, int channels, int sampleRate, string? name = null)
+    {
+        var fmt = channels switch
+        {
+            1 => ALFormat.Mono16,
+            2 => ALFormat.Stereo16,
+            _ => throw new ArgumentOutOfRangeException(
+                nameof(channels), "Only stereo and mono is currently supported")
+        };
+
+        var buffer = AL.GenBuffer();
+        _checkAlError();
+
+        unsafe
+        {
+            fixed (short* ptr = samples)
+            {
+                AL.BufferData(buffer, fmt, (IntPtr) ptr, samples.Length * sizeof(short), sampleRate);
+            }
+        }
+
+        _checkAlError();
+
+        var handle = new ClydeHandle(_audioSampleBuffers.Count);
+        var length = TimeSpan.FromSeconds((double) samples.Length / channels / sampleRate);
+        _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
+        return new AudioStream(handle, length, channels, name);
+    }
+
+    public void SetMasterGain(float newGain)
+    {
+        if (newGain < 0f)
+        {
+            OpenALSawmill.Error("Tried to set master gain below 0, clamping to 0");
+            AL.Listener(ALListenerf.Gain, 0f);
+            return;
+        }
+
+
+        #region Platform hack for MacOS
+        // HACK/BUG: Apple's OpenAL implementation has a bug where values of 0f for listener gain don't actually
+        // HACK/BUG: prevent sound playback. Workaround is to cap the minimum gain at a value just above 0.
+        if (OperatingSystem.IsMacOS() && newGain == 0f)
+        {
+            OpenALSawmill.Verbose("Not setting gain to 0 because Apple can't write an OpenAL implementation");
+            AL.Listener(ALListenerf.Gain, float.Epsilon);
+            return;
+        }
+        #endregion Platform hack for MacOS
+
+        AL.Listener(ALListenerf.Gain, newGain);
+    }
+
+    public void SetAttenuation(Attenuation attenuation)
+    {
+        switch (attenuation)
+        {
+            case Attenuation.NoAttenuation:
+                AL.DistanceModel(ALDistanceModel.None);
+                break;
+            case Attenuation.InverseDistance:
+                AL.DistanceModel(ALDistanceModel.InverseDistance);
+                break;
+            case Attenuation.InverseDistanceClamped:
+                AL.DistanceModel(ALDistanceModel.InverseDistanceClamped);
+                break;
+            case Attenuation.LinearDistance:
+                AL.DistanceModel(ALDistanceModel.LinearDistance);
+                break;
+            case Attenuation.LinearDistanceClamped:
+                AL.DistanceModel(ALDistanceModel.LinearDistanceClamped);
+                break;
+            case Attenuation.ExponentDistance:
+                AL.DistanceModel(ALDistanceModel.ExponentDistance);
+                break;
+            case Attenuation.ExponentDistanceClamped:
+                AL.DistanceModel(ALDistanceModel.ExponentDistanceClamped);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"No implementation to set {attenuation.ToString()} for DistanceModel!");
+        }
+
+        _attenuation = attenuation;
+        OpenALSawmill.Info($"Set audio attenuation to {attenuation.ToString()}");
+    }
+
+    internal void RemoveAudioSource(int handle)
+    {
+        _audioSources.Remove(handle);
+    }
+
+    internal void RemoveBufferedAudioSource(int handle)
+    {
+        _bufferedAudioSources.Remove(handle);
+    }
+
+    public IAudioSource? CreateAudioSource(AudioStream stream)
+    {
+        var source = AL.GenSource();
+
+        if (!AL.IsSource(source))
+        {
+            OpenALSawmill.Error("Failed to generate source. Too many simultaneous audio streams? {0}", Environment.StackTrace);
+            return null;
+        }
+
+        // ReSharper disable once PossibleInvalidOperationException
+        // TODO: This really shouldn't be indexing based on the ClydeHandle...
+        AL.Source(source, ALSourcei.Buffer, _audioSampleBuffers[(int) stream.ClydeHandle!.Value].BufferHandle);
+
+        var audioSource = new AudioSource(this, source, stream);
+        _audioSources.Add(source, new WeakReference<BaseAudioSource>(audioSource));
+        ApplyDefaultParams(audioSource);
+        return audioSource;
+    }
+
+    /// <inheritdoc/>
+    IBufferedAudioSource? IAudioInternal.CreateBufferedAudioSource(int buffers, bool floatAudio)
+    {
+        var source = AL.GenSource();
+
+        if (!AL.IsSource(source))
+        {
+            OpenALSawmill.Error("Failed to generate source. Too many simultaneous audio streams? {0}", Environment.StackTrace);
+            return null;
+        }
+
+        // ReSharper disable once PossibleInvalidOperationException
+
+        var audioSource = new BufferedAudioSource(this, source, AL.GenBuffers(buffers), floatAudio);
+        _bufferedAudioSources.Add(source, new WeakReference<BufferedAudioSource>(audioSource));
+        ApplyDefaultParams(audioSource);
+        return audioSource;
+    }
+
+    private void ApplyDefaultParams(IAudioSource source)
+    {
+        source.MaxDistance = AudioParams.Default.MaxDistance;
+        source.Pitch = AudioParams.Default.Pitch;
+        source.ReferenceDistance = AudioParams.Default.ReferenceDistance;
+        source.RolloffFactor = AudioParams.Default.RolloffFactor;
+    }
+
+    /// <inheritdoc />
+    public void StopAllAudio()
+    {
+        foreach (var source in _audioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Playing = false;
+            }
+        }
+
+        foreach (var source in _bufferedAudioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Playing = false;
+            }
+        }
+    }
+
+    public void DisposeAllAudio()
+    {
+        // TODO: Do we even need to stop?
+        foreach (var source in _audioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Dispose();
+            }
+        }
+
+        _audioSources.Clear();
+
+        foreach (var source in _bufferedAudioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Dispose();
+            }
+        }
+
+        _bufferedAudioSources.Clear();
+    }
+}

Robust.Client/Audio/AudioManager.cs

@@ -0,0 +1,200 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using OpenTK.Audio.OpenAL;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Client.Audio.Sources;
+using Robust.Shared;
+using Robust.Shared.Audio;
+using Robust.Shared.Configuration;
+using Robust.Shared.Log;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Audio;
+
+internal sealed partial class AudioManager : IAudioInternal
+{
+    [Shared.IoC.Dependency] private readonly IConfigurationManager _cfg = default!;
+    [Shared.IoC.Dependency] private readonly ILogManager _logMan = default!;
+
+    private Thread? _gameThread;
+
+    private ALDevice _openALDevice;
+    private ALContext _openALContext;
+
+    private readonly List<LoadedAudioSample> _audioSampleBuffers = new();
+
+    private readonly Dictionary<int, WeakReference<BaseAudioSource>> _audioSources =
+        new();
+
+    private readonly Dictionary<int, WeakReference<BufferedAudioSource>> _bufferedAudioSources =
+        new();
+
+    private readonly HashSet<string> _alcDeviceExtensions = new();
+    private readonly HashSet<string> _alContextExtensions = new();
+    private Attenuation _attenuation;
+
+    public bool HasAlDeviceExtension(string extension) => _alcDeviceExtensions.Contains(extension);
+    public bool HasAlContextExtension(string extension) => _alContextExtensions.Contains(extension);
+
+    internal bool IsEfxSupported;
+
+    internal ISawmill OpenALSawmill = default!;
+
+    private void _audioCreateContext()
+    {
+        unsafe
+        {
+            _openALContext = ALC.CreateContext(_openALDevice, (int*) 0);
+        }
+
+        ALC.MakeContextCurrent(_openALContext);
+        _checkAlcError(_openALDevice);
+        _checkAlError();
+
+        // Load up AL context extensions.
+        var s = ALC.GetString(ALDevice.Null, AlcGetString.Extensions) ?? "";
+        foreach (var extension in s.Split(' '))
+        {
+            _alContextExtensions.Add(extension);
+        }
+
+        OpenALSawmill.Debug("OpenAL Vendor: {0}", AL.Get(ALGetString.Vendor));
+        OpenALSawmill.Debug("OpenAL Renderer: {0}", AL.Get(ALGetString.Renderer));
+        OpenALSawmill.Debug("OpenAL Version: {0}", AL.Get(ALGetString.Version));
+    }
+
+    private bool _audioOpenDevice()
+    {
+        var preferredDevice = _cfg.GetCVar(CVars.AudioDevice);
+
+        // Open device.
+        if (!string.IsNullOrEmpty(preferredDevice))
+        {
+            _openALDevice = ALC.OpenDevice(preferredDevice);
+            if (_openALDevice == IntPtr.Zero)
+            {
+                OpenALSawmill.Warning("Unable to open preferred audio device '{0}': {1}. Falling back default.",
+                    preferredDevice, ALC.GetError(ALDevice.Null));
+
+                _openALDevice = ALC.OpenDevice(null);
+            }
+        }
+        else
+        {
+            _openALDevice = ALC.OpenDevice(null);
+        }
+
+        _checkAlcError(_openALDevice);
+
+        if (_openALDevice == IntPtr.Zero)
+        {
+            OpenALSawmill.Error("Unable to open OpenAL device! {1}", ALC.GetError(ALDevice.Null));
+            return false;
+        }
+
+        // Load up ALC extensions.
+        var s = ALC.GetString(_openALDevice, AlcGetString.Extensions) ?? "";
+        foreach (var extension in s.Split(' '))
+        {
+            _alcDeviceExtensions.Add(extension);
+        }
+        return true;
+    }
+
+    private void InitializeAudio()
+    {
+        OpenALSawmill = _logMan.GetSawmill("clyde.oal");
+
+        if (!_audioOpenDevice())
+            return;
+
+        // Create OpenAL context.
+        _audioCreateContext();
+
+        IsEfxSupported = HasAlDeviceExtension("ALC_EXT_EFX");
+
+        _cfg.OnValueChanged(CVars.AudioMasterVolume, SetMasterGain, true);
+    }
+
+    internal bool IsMainThread()
+    {
+        return Thread.CurrentThread == _gameThread;
+    }
+
+    private static void RemoveEfx((int sourceHandle, int filterHandle) handles)
+    {
+        if (handles.filterHandle != 0)
+            EFX.DeleteFilter(handles.filterHandle);
+    }
+
+    private void _checkAlcError(ALDevice device,
+        [CallerMemberName] string callerMember = "",
+        [CallerLineNumber] int callerLineNumber = -1)
+    {
+        var error = ALC.GetError(device);
+        if (error != AlcError.NoError)
+        {
+            OpenALSawmill.Error("[{0}:{1}] ALC error: {2}", callerMember, callerLineNumber, error);
+        }
+    }
+
+    /// <summary>
+    /// Like _checkAlError but allows custom data to be passed in as relevant.
+    /// </summary>
+    internal void LogALError(ALErrorInterpolatedStringHandler message, [CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1)
+    {
+        if (message.Error != ALError.NoError)
+        {
+            OpenALSawmill.Error("[{0}:{1}] AL error: {2}, {3}. Stacktrace is {4}", callerMember, callerLineNumber, message.Error, message.ToStringAndClear(), Environment.StackTrace);
+        }
+    }
+
+    public void _checkAlError([CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1)
+    {
+        var error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            OpenALSawmill.Error("[{0}:{1}] AL error: {2}", callerMember, callerLineNumber, error);
+        }
+    }
+
+    private sealed class LoadedAudioSample
+    {
+        public readonly int BufferHandle;
+
+        public LoadedAudioSample(int bufferHandle)
+        {
+            BufferHandle = bufferHandle;
+        }
+    }
+
+    [InterpolatedStringHandler]
+    internal ref struct ALErrorInterpolatedStringHandler
+    {
+        private DefaultInterpolatedStringHandler _handler;
+        public ALError Error;
+
+        public ALErrorInterpolatedStringHandler(int literalLength, int formattedCount, out bool shouldAppend)
+        {
+            Error = AL.GetError();
+            if (Error == ALError.NoError)
+            {
+                shouldAppend = false;
+                _handler = default;
+            }
+            else
+            {
+                shouldAppend = true;
+                _handler = new DefaultInterpolatedStringHandler(literalLength, formattedCount);
+            }
+        }
+
+        public string ToStringAndClear() => _handler.ToStringAndClear();
+        public override string ToString() => _handler.ToString();
+        public void AppendLiteral(string value) => _handler.AppendLiteral(value);
+        public void AppendFormatted<T>(T value) => _handler.AppendFormatted(value);
+        public void AppendFormatted<T>(T value, string? format) => _handler.AppendFormatted(value, format);
+    }
+}

Robust.Client/Audio/AudioOverlay.cs

@@ -0,0 +1,91 @@
+using System.Numerics;
+using System.Text;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Audio;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using AudioComponent = Robust.Shared.Audio.Components.AudioComponent;
+
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Debug overlay for audio.
+/// </summary>
+public sealed class AudioOverlay : Overlay
+{
+    public override OverlaySpace Space => OverlaySpace.ScreenSpace;
+
+    private IEntityManager _entManager;
+    private IPlayerManager _playerManager;
+    private AudioSystem _audio;
+    private SharedTransformSystem _transform;
+
+    private Font _font;
+
+    public AudioOverlay(IEntityManager entManager, IPlayerManager playerManager, IResourceCache cache, AudioSystem audio, SharedTransformSystem transform)
+    {
+        _entManager = entManager;
+        _playerManager = playerManager;
+        _audio = audio;
+        _transform = transform;
+
+        _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+    }
+
+    protected internal override void Draw(in OverlayDrawArgs args)
+    {
+        var localPlayer = _playerManager.LocalEntity;
+
+        if (args.ViewportControl == null || localPlayer == null)
+            return;
+
+        var screenHandle = args.ScreenHandle;
+        var output = new StringBuilder();
+        var listenerPos = _transform.GetMapCoordinates(_entManager.GetComponent<TransformComponent>(localPlayer.Value));
+
+        if (listenerPos.MapId != args.MapId)
+            return;
+
+        var query = _entManager.AllEntityQueryEnumerator<AudioComponent>();
+
+        while (query.MoveNext(out var uid, out var comp))
+        {
+            var mapId = MapId.Nullspace;
+            var audioPos = Vector2.Zero;
+
+            if (_entManager.TryGetComponent<TransformComponent>(uid, out var xform))
+            {
+                mapId = xform.MapID;
+                audioPos = _transform.GetWorldPosition(uid);
+            }
+
+            if (mapId != args.MapId)
+                continue;
+
+            var screenPos = args.ViewportControl.WorldToScreen(audioPos);
+            var distance = audioPos - listenerPos.Position;
+            var posOcclusion = _audio.GetOcclusion(listenerPos, distance, distance.Length(), uid);
+
+            output.Clear();
+            output.AppendLine("Audio Source");
+            output.AppendLine("Runtime:");
+            output.AppendLine($"- Distance: {_audio.GetAudioDistance(distance.Length()):0.00}");
+            output.AppendLine($"- Occlusion: {posOcclusion:0.0000}");
+            output.AppendLine("Params:");
+            output.AppendLine($"- RolloffFactor: {comp.RolloffFactor:0.0000}");
+            output.AppendLine($"- Volume: {comp.Volume:0.0000}");
+            output.AppendLine($"- Reference distance: {comp.ReferenceDistance:0.00}");
+            output.AppendLine($"- Max distance: {comp.MaxDistance:0.00}");
+            var outputText = output.ToString().Trim();
+            var dimensions = screenHandle.GetDimensions(_font, outputText, 1f);
+            var buffer = new Vector2(3f, 3f);
+            screenHandle.DrawRect(new UIBox2(screenPos - buffer, screenPos + dimensions + buffer), new Color(39, 39, 48));
+            screenHandle.DrawString(_font, screenPos, outputText);
+        }
+    }
+}

Robust.Client/Audio/AudioStream.cs

@@ -1,18 +1,21 @@
 using System;
-using Robust.Client.Graphics;
+using Robust.Shared.Graphics;
 
 namespace Robust.Client.Audio;
 
+/// <summary>
+/// Has the metadata for a particular audio stream as well as the relevant internal handle to it.
+/// </summary>
 public sealed class AudioStream
 {
     public TimeSpan Length { get; }
-    internal ClydeHandle? ClydeHandle { get; }
+    internal IClydeHandle? ClydeHandle { get; }
     public string? Name { get; }
     public string? Title { get; }
     public string? Artist { get; }
     public int ChannelCount { get; }
 
-    internal AudioStream(ClydeHandle handle, TimeSpan length, int channelCount, string? name = null, string? title = null, string? artist = null)
+    internal AudioStream(IClydeHandle? handle, TimeSpan length, int channelCount, string? name = null, string? title = null, string? artist = null)
     {
         ClydeHandle = handle;
         Length = length;

Robust.Client/Audio/AudioSystem.Effects.cs

@@ -0,0 +1,76 @@
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Client.Audio.Effects;
+using Robust.Shared.Audio.Components;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Audio;
+
+public sealed partial class AudioSystem
+{
+    protected override void InitializeEffect()
+    {
+        base.InitializeEffect();
+        SubscribeLocalEvent<AudioEffectComponent, ComponentAdd>(OnEffectAdd);
+        SubscribeLocalEvent<AudioEffectComponent, ComponentShutdown>(OnEffectShutdown);
+
+        SubscribeLocalEvent<AudioAuxiliaryComponent, ComponentAdd>(OnAuxiliaryAdd);
+        SubscribeLocalEvent<AudioAuxiliaryComponent, AfterAutoHandleStateEvent>(OnAuxiliaryAuto);
+    }
+
+    private void OnEffectAdd(EntityUid uid, AudioEffectComponent component, ComponentAdd args)
+    {
+        var effect = new AudioEffect(_audio);
+        component.Effect = effect;
+    }
+
+    private void OnEffectShutdown(EntityUid uid, AudioEffectComponent component, ComponentShutdown args)
+    {
+        if (component.Effect is AudioEffect effect)
+        {
+            effect.Dispose();
+        }
+    }
+
+    private void OnAuxiliaryAdd(EntityUid uid, AudioAuxiliaryComponent component, ComponentAdd args)
+    {
+        component.Auxiliary = new AuxiliaryAudio();
+    }
+
+    private void OnAuxiliaryAuto(EntityUid uid, AudioAuxiliaryComponent component, ref AfterAutoHandleStateEvent args)
+    {
+        if (TryComp<AudioEffectComponent>(component.Effect, out var effectComp))
+        {
+            component.Auxiliary.SetEffect(effectComp.Effect);
+        }
+        else
+        {
+            component.Auxiliary.SetEffect(null);
+        }
+    }
+
+    public override void SetAuxiliary(EntityUid uid, AudioComponent audio, EntityUid? auxUid)
+    {
+        base.SetAuxiliary(uid, audio, auxUid);
+        if (TryComp<AudioAuxiliaryComponent>(audio.Auxiliary, out var auxComp))
+        {
+            audio.Source.SetAuxiliary(auxComp.Auxiliary);
+        }
+        else
+        {
+            audio.Source.SetAuxiliary(null);
+        }
+    }
+
+    public override void SetEffect(EntityUid auxUid, AudioAuxiliaryComponent aux, EntityUid? effectUid)
+    {
+        base.SetEffect(auxUid, aux, effectUid);
+        if (TryComp<AudioEffectComponent>(aux.Effect, out var effectComp))
+        {
+            aux.Auxiliary.SetEffect(effectComp.Effect);
+        }
+        else
+        {
+            aux.Auxiliary.SetEffect(null);
+        }
+    }
+}

Robust.Client/Audio/AudioSystem.Limits.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Robust.Shared;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Audio;
+
+public sealed partial class AudioSystem
+{
+    /*
+     * Handles limiting concurrent sounds for audio to avoid blowing the source budget on one sound getting spammed.
+     */
+
+    private readonly Dictionary<string, int> _playingCount = new();
+
+    private int _maxConcurrent;
+
+    private void InitializeLimit()
+    {
+        Subs.CVar(CfgManager, CVars.AudioDefaultConcurrent, SetConcurrentLimit, true);
+    }
+
+    private void SetConcurrentLimit(int obj)
+    {
+        _maxConcurrent = obj;
+    }
+
+    private bool TryAudioLimit(string sound)
+    {
+        if (string.IsNullOrEmpty(sound))
+            return true;
+
+        ref var count = ref CollectionsMarshal.GetValueRefOrAddDefault(_playingCount, sound, out _);
+
+        if (count >= _maxConcurrent)
+            return false;
+
+        count++;
+        return true;
+    }
+
+    private void RemoveAudioLimit(string sound)
+    {
+        if (!_playingCount.TryGetValue(sound, out var count))
+            return;
+
+        count--;
+
+        if (count <= 0)
+        {
+            _playingCount.Remove(sound);
+            return;
+        }
+
+        _playingCount[sound] = count;
+    }
+}

Robust.Client/Audio/AudioSystem.cs

@@ -0,0 +1,723 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Components;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Exceptions;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Systems;
+using Robust.Shared.Player;
+using Robust.Shared.Replays;
+using Robust.Shared.Threading;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Audio;
+
+public sealed partial class AudioSystem : SharedAudioSystem
+{
+    /*
+     * There's still a lot more OpenAL can do in terms of filters, auxiliary slots, etc.
+     * but exposing the whole thing in an easy way is a lot of effort.
+     */
+
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IResourceCache _resourceCache = default!;
+    [Dependency] private readonly IParallelManager _parMan = default!;
+    [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
+    [Dependency] private readonly IAudioInternal _audio = default!;
+    [Dependency] private readonly SharedMapSystem _maps = default!;
+    [Dependency] private readonly SharedTransformSystem _xformSys = default!;
+    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+
+    /// <summary>
+    /// Per-tick cache of relevant streams.
+    /// </summary>
+    private readonly List<(EntityUid Entity, AudioComponent Component, TransformComponent Xform)> _streams = new();
+    private UpdateAudioJob _updateAudioJob;
+
+    private float _audioFrameTime;
+    private float _audioFrameTimeRemaining;
+
+    private EntityQuery<PhysicsComponent> _physicsQuery;
+
+    private float _maxRayLength;
+
+    public override float ZOffset
+    {
+        get => _zOffset;
+        protected set
+        {
+            _zOffset = value;
+            _audio.SetZOffset(value);
+
+            var query = AllEntityQuery<AudioComponent>();
+
+            while (query.MoveNext(out var audio))
+            {
+                // Pythagoras back to normal then adjust.
+                var maxDistance = GetAudioDistance(audio.Params.MaxDistance);
+                var refDistance = GetAudioDistance(audio.Params.ReferenceDistance);
+
+                audio.MaxDistance = maxDistance;
+                audio.ReferenceDistance = refDistance;
+            }
+        }
+    }
+
+    private float _zOffset;
+
+    /// <inheritdoc />
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _updateAudioJob = new UpdateAudioJob
+        {
+            System = this,
+            Streams = _streams,
+        };
+
+        UpdatesOutsidePrediction = true;
+        // Need to run after Eye updates so we have an accurate listener position.
+        UpdatesAfter.Add(typeof(EyeSystem));
+
+        _physicsQuery = GetEntityQuery<PhysicsComponent>();
+
+        SubscribeLocalEvent<AudioComponent, ComponentStartup>(OnAudioStartup);
+        SubscribeLocalEvent<AudioComponent, ComponentShutdown>(OnAudioShutdown);
+        SubscribeLocalEvent<AudioComponent, EntityPausedEvent>(OnAudioPaused);
+        SubscribeLocalEvent<AudioComponent, AfterAutoHandleStateEvent>(OnAudioState);
+
+        // Replay stuff
+        SubscribeNetworkEvent<PlayAudioGlobalMessage>(OnGlobalAudio);
+        SubscribeNetworkEvent<PlayAudioEntityMessage>(OnEntityAudio);
+        SubscribeNetworkEvent<PlayAudioPositionalMessage>(OnEntityCoordinates);
+
+        Subs.CVar(CfgManager, CVars.AudioAttenuation, OnAudioAttenuation, true);
+        Subs.CVar(CfgManager, CVars.AudioRaycastLength, OnRaycastLengthChanged, true);
+        Subs.CVar(CfgManager, CVars.AudioTickRate, OnAudioTickRate, true);
+        InitializeLimit();
+    }
+
+    private void OnAudioTickRate(int obj)
+    {
+        _audioFrameTime = 1f / obj;
+        _audioFrameTimeRemaining = MathF.Min(_audioFrameTimeRemaining, _audioFrameTime);
+    }
+
+    private void OnAudioState(EntityUid uid, AudioComponent component, ref AfterAutoHandleStateEvent args)
+    {
+        ApplyAudioParams(component.Params, component);
+        component.Source.Global = component.Global;
+
+        if (TryComp<AudioAuxiliaryComponent>(component.Auxiliary, out var auxComp))
+        {
+            component.Source.SetAuxiliary(auxComp.Auxiliary);
+        }
+        else
+        {
+            component.Source.SetAuxiliary(null);
+        }
+
+        switch (component.State)
+        {
+            case AudioState.Playing:
+                component.StartPlaying();
+                break;
+            case AudioState.Paused:
+                component.Pause();
+                break;
+            case AudioState.Stopped:
+                component.StopPlaying();
+                component.PlaybackPosition = 0f;
+                break;
+        }
+
+        // If playback position changed then update it.
+        if (!string.IsNullOrEmpty(component.FileName))
+        {
+            var position = (float) ((component.PauseTime ?? Timing.CurTime) - component.AudioStart).TotalSeconds;
+            var currentPosition = component.Source.PlaybackPosition;
+            var diff = Math.Abs(position - currentPosition);
+
+            if (diff > 0.1f)
+            {
+                component.PlaybackPosition = position;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Sets the volume for the entire game.
+    /// </summary>
+    public void SetMasterVolume(float value)
+    {
+        _audio.SetMasterGain(value);
+    }
+
+    private void OnAudioPaused(EntityUid uid, AudioComponent component, ref EntityPausedEvent args)
+    {
+        component.Pause();
+    }
+
+    protected override void OnAudioUnpaused(EntityUid uid, AudioComponent component, ref EntityUnpausedEvent args)
+    {
+        base.OnAudioUnpaused(uid, component, ref args);
+        component.StartPlaying();
+    }
+
+    private void OnAudioStartup(EntityUid uid, AudioComponent component, ComponentStartup args)
+    {
+        if (!Timing.ApplyingState && !Timing.IsFirstTimePredicted)
+        {
+            return;
+        }
+
+        // Source has already been set
+        if (component.Loaded)
+        {
+            return;
+        }
+
+        if (!TryGetAudio(component.FileName, out var audioResource))
+        {
+            Log.Error($"Error creating audio source for {audioResource}, can't find file {component.FileName}");
+            return;
+        }
+
+        SetupSource((uid, component), audioResource);
+        component.Loaded = true;
+    }
+
+    private void SetupSource(Entity<AudioComponent> entity, AudioResource audioResource, TimeSpan? length = null)
+    {
+        var component = entity.Comp;
+
+        if (TryAudioLimit(component.FileName))
+        {
+            var newSource = _audio.CreateAudioSource(audioResource);
+
+            if (newSource == null)
+            {
+                Log.Error($"Error creating audio source for {audioResource}");
+                DebugTools.Assert(false);
+            }
+            else
+            {
+                component.Source = newSource;
+            }
+        }
+
+        // Need to set all initial data for first frame.
+        ApplyAudioParams(component.Params, component);
+        component.Source.Global = component.Global;
+
+        // Don't play until first frame so occlusion etc. are correct.
+        component.Gain = 0f;
+
+        length ??= GetAudioLength(component.FileName);
+
+        // If audio came into range then start playback at the correct position.
+        var offset = (Timing.CurTime - component.AudioStart).TotalSeconds % length.Value.TotalSeconds;
+
+        if (offset > 0)
+        {
+            component.PlaybackPosition = (float) offset;
+        }
+    }
+
+    private void OnAudioShutdown(EntityUid uid, AudioComponent component, ComponentShutdown args)
+    {
+        // Breaks with prediction?
+        component.Source.Dispose();
+
+        RemoveAudioLimit(component.FileName);
+    }
+
+    private void OnAudioAttenuation(int obj)
+    {
+        _audio.SetAttenuation((Attenuation) obj);
+    }
+
+    private void OnRaycastLengthChanged(float value)
+    {
+        _maxRayLength = value;
+    }
+
+    public override void FrameUpdate(float frameTime)
+    {
+        _audioFrameTimeRemaining -= frameTime;
+
+        if (_audioFrameTimeRemaining > 0f)
+            return;
+
+        // Clamp to 0 in case we have a really long frame.
+        _audioFrameTimeRemaining = MathF.Max(0f, _audioFrameTime + _audioFrameTimeRemaining);
+        var eye = _eyeManager.CurrentEye;
+        var localEntity = _playerManager.LocalEntity;
+        Vector2 listenerVelocity;
+
+        if (localEntity != null)
+            listenerVelocity = _physics.GetMapLinearVelocity(localEntity.Value);
+        else
+            listenerVelocity = Vector2.Zero;
+
+        _audio.SetVelocity(listenerVelocity);
+        _audio.SetRotation(eye.Rotation);
+        _audio.SetPosition(eye.Position.Position);
+
+        var ourPos = GetListenerCoordinates();
+
+        var query = AllEntityQuery<AudioComponent, TransformComponent>();
+        _streams.Clear();
+
+        while (query.MoveNext(out var uid, out var comp, out var xform))
+        {
+            _streams.Add((uid, comp, xform));
+        }
+
+        try
+        {
+            _updateAudioJob.OurPosition = ourPos;
+            _parMan.ProcessNow(_updateAudioJob, _streams.Count);
+        }
+        catch (Exception e)
+        {
+            Log.Error($"Caught exception while processing entity streams.");
+            _runtimeLog.LogException(e, $"{nameof(AudioSystem)}.{nameof(FrameUpdate)}");
+        }
+    }
+
+    public MapCoordinates GetListenerCoordinates()
+    {
+        return _eyeManager.CurrentEye.Position;
+    }
+
+    private void ProcessStream(EntityUid entity, AudioComponent component, TransformComponent xform, MapCoordinates listener)
+    {
+        // TODO:
+        // I Originally tried to be fancier here but it caused audio issues so just trying
+        // to replicate the old behaviour for now.
+        if (!component.Started)
+        {
+            component.Started = true;
+            component.StartPlaying();
+        }
+
+        // If it's global but on another map (that isn't nullspace) then stop playing it.
+        if (component.Global)
+        {
+            if (xform.MapID != MapId.Nullspace && listener.MapId != xform.MapID)
+            {
+                component.Gain = 0f;
+                return;
+            }
+
+            // Resume playing.
+            component.Volume = component.Params.Volume;
+            return;
+        }
+
+        // Non-global sounds, stop playing if on another map.
+        // Not relevant to us.
+        if (listener.MapId != xform.MapID)
+        {
+            component.Gain = 0f;
+            return;
+        }
+
+        Vector2 worldPos;
+        component.Volume = component.Params.Volume;
+
+        // Handle grid audio differently by using grid position.
+        if ((component.Flags & AudioFlags.GridAudio) != 0x0)
+        {
+            var parentUid = xform.ParentUid;
+            worldPos = _maps.GetGridPosition(parentUid);
+        }
+        else
+        {
+            worldPos = _xformSys.GetWorldPosition(entity);
+        }
+
+        // Max distance check
+        var delta = worldPos - listener.Position;
+        var distance = delta.Length();
+
+        // Out of range so just clip it for us.
+        if (GetAudioDistance(distance) > component.MaxDistance)
+        {
+            // Still keeps the source playing, just with no volume.
+            component.Gain = 0f;
+            return;
+        }
+
+        if (distance > 0f && distance < 0.01f)
+        {
+            worldPos = listener.Position;
+            delta = Vector2.Zero;
+            distance = 0f;
+        }
+
+        // Update audio occlusion
+        if ((component.Flags & AudioFlags.NoOcclusion) == AudioFlags.NoOcclusion)
+        {
+            component.Occlusion = 0f;
+        }
+        else
+        {
+            var occlusion = GetOcclusion(listener, delta, distance, entity);
+            component.Occlusion = occlusion;
+        }
+
+        // Update audio positions.
+        component.Position = worldPos;
+
+        // Make race cars go NYYEEOOOOOMMMMM
+        if (_physicsQuery.TryGetComponent(entity, out var physicsComp))
+        {
+            // This actually gets the tracked entity's xform & iterates up though the parents for the second time. Bit
+            // inefficient.
+            var velocity = _physics.GetMapLinearVelocity(entity, physicsComp, xform);
+            component.Velocity = velocity;
+        }
+    }
+
+    /// <summary>
+    /// Gets the audio occlusion from the target audio entity to the listener's position.
+    /// </summary>
+    public float GetOcclusion(MapCoordinates listener, Vector2 delta, float distance, EntityUid? ignoredEnt = null)
+    {
+        float occlusion = 0;
+
+        if (distance > 0.1)
+        {
+            var rayLength = MathF.Min(distance, _maxRayLength);
+            var ray = new CollisionRay(listener.Position, delta / distance, OcclusionCollisionMask);
+            occlusion = _physics.IntersectRayPenetration(listener.MapId, ray, rayLength, ignoredEnt);
+        }
+
+        return occlusion;
+    }
+
+    private bool TryGetAudio(string filename, [NotNullWhen(true)] out AudioResource? audio)
+    {
+        if (_resourceCache.TryGetResource(new ResPath(filename), out audio))
+            return true;
+
+        Log.Error($"Server tried to play audio file {filename} which does not exist.");
+        return false;
+    }
+
+    private bool TryGetAudio(AudioStream stream, [NotNullWhen(true)] out AudioResource? audio)
+    {
+        if (_resourceCache.TryGetResource(stream, out audio))
+            return true;
+
+        Log.Error($"Server failed to play audio stream {stream.Title}.");
+        return false;
+    }
+
+    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string? filename, EntityCoordinates coordinates,
+        AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, Filter.Local(), coordinates, true, audioParams);
+    }
+
+    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string? filename, EntityUid uid, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, Filter.Local(), uid, true, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayPredicted(SoundSpecifier? sound, EntityUid source, EntityUid? user, AudioParams? audioParams = null)
+    {
+        if (Timing.IsFirstTimePredicted && sound != null)
+            return PlayEntity(sound, Filter.Local(), source, false, audioParams);
+
+        return null; // uhh Lets hope predicted audio never needs to somehow store the playing audio....
+    }
+
+    public override (EntityUid Entity, AudioComponent Component)? PlayPredicted(SoundSpecifier? sound, EntityCoordinates coordinates, EntityUid? user, AudioParams? audioParams = null)
+    {
+        if (Timing.IsFirstTimePredicted && sound != null)
+            return PlayStatic(sound, Filter.Local(), coordinates, false, audioParams);
+
+        return null;
+    }
+
+    /// <summary>
+    ///     Play an audio file globally, without position.
+    /// </summary>
+    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
+    /// <param name="audioParams"></param>
+    private (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, AudioParams? audioParams = null, bool recordReplay = true)
+    {
+        if (string.IsNullOrEmpty(filename))
+            return null;
+
+        if (recordReplay && _replayRecording.IsRecording)
+        {
+            _replayRecording.RecordReplayMessage(new PlayAudioGlobalMessage
+            {
+                FileName = filename,
+                AudioParams = audioParams ?? AudioParams.Default
+            });
+        }
+
+        return TryGetAudio(filename, out var audio) ? PlayGlobal(audio, audioParams) : default;
+    }
+
+    /// <summary>
+    ///     Play an audio stream globally, without position.
+    /// </summary>
+    /// <param name="stream">The audio stream to play.</param>
+    /// <param name="audioParams"></param>
+    public (EntityUid Entity, AudioComponent Component)? PlayGlobal(AudioStream stream, AudioParams? audioParams = null)
+    {
+        var (entity, component) = CreateAndStartPlayingStream(audioParams, stream);
+        component.Global = true;
+        component.Source.Global = true;
+        Dirty(entity, component);
+        return (entity, component);
+    }
+
+    /// <summary>
+    ///     Play an audio file following an entity.
+    /// </summary>
+    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
+    /// <param name="entity">The entity "emitting" the audio.</param>
+    private (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, EntityUid entity, AudioParams? audioParams = null, bool recordReplay = true)
+    {
+        if (string.IsNullOrEmpty(filename))
+            return null;
+
+        if (recordReplay && _replayRecording.IsRecording)
+        {
+            _replayRecording.RecordReplayMessage(new PlayAudioEntityMessage
+            {
+                FileName = filename,
+                NetEntity = GetNetEntity(entity),
+                AudioParams = audioParams ?? AudioParams.Default
+            });
+        }
+
+        return TryGetAudio(filename, out var audio) ? PlayEntity(audio, entity, audioParams) : default;
+    }
+
+    /// <summary>
+    ///     Play an audio stream following an entity.
+    /// </summary>
+    /// <param name="stream">The audio stream to play.</param>
+    /// <param name="entity">The entity "emitting" the audio.</param>
+    /// <param name="audioParams"></param>
+    public (EntityUid Entity, AudioComponent Component)? PlayEntity(AudioStream stream, EntityUid entity, AudioParams? audioParams = null)
+    {
+        if (TerminatingOrDeleted(entity))
+        {
+            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(entity)}");
+            return null;
+        }
+
+        var playing = CreateAndStartPlayingStream(audioParams, stream);
+        _xformSys.SetCoordinates(playing.Entity, new EntityCoordinates(entity, Vector2.Zero));
+
+        return playing;
+    }
+
+    /// <summary>
+    ///     Play an audio file at a static position.
+    /// </summary>
+    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
+    /// <param name="coordinates">The coordinates at which to play the audio.</param>
+    /// <param name="audioParams"></param>
+    private (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, EntityCoordinates coordinates, AudioParams? audioParams = null, bool recordReplay = true)
+    {
+        if (string.IsNullOrEmpty(filename))
+            return null;
+
+        if (recordReplay && _replayRecording.IsRecording)
+        {
+            _replayRecording.RecordReplayMessage(new PlayAudioPositionalMessage
+            {
+                FileName = filename,
+                Coordinates = GetNetCoordinates(coordinates),
+                AudioParams = audioParams ?? AudioParams.Default
+            });
+        }
+
+        return TryGetAudio(filename, out var audio) ? PlayStatic(audio, coordinates, audioParams) : default;
+    }
+
+    /// <summary>
+    ///     Play an audio stream at a static position.
+    /// </summary>
+    /// <param name="stream">The audio stream to play.</param>
+    /// <param name="coordinates">The coordinates at which to play the audio.</param>
+    /// <param name="audioParams"></param>
+    public (EntityUid Entity, AudioComponent Component)? PlayStatic(AudioStream stream, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    {
+        if (TerminatingOrDeleted(coordinates.EntityId))
+        {
+            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(coordinates.EntityId)}");
+            return null;
+        }
+
+        var playing = CreateAndStartPlayingStream(audioParams, stream);
+        _xformSys.SetCoordinates(playing.Entity, coordinates);
+        return playing;
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, Filter playerFilter, bool recordReplay, AudioParams? audioParams = null)
+    {
+        return PlayGlobal(filename, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, Filter playerFilter, EntityUid entity, bool recordReplay, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, entity, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, Filter playerFilter, EntityCoordinates coordinates, bool recordReplay, AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, coordinates, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, ICommonSession recipient, AudioParams? audioParams = null)
+    {
+        return PlayGlobal(filename, audioParams);
+    }
+
+    public override void LoadStream<T>(Entity<AudioComponent> entity, T stream)
+    {
+        if (stream is AudioStream audioStream)
+        {
+            TryGetAudio(audioStream, out var audio);
+            SetupSource(entity, audio!, audioStream.Length);
+            entity.Comp.Loaded = true;
+        }
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, EntityUid recipient, AudioParams? audioParams = null)
+    {
+        return PlayGlobal(filename, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, ICommonSession recipient, EntityUid uid, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, uid, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, EntityUid recipient, EntityUid uid, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, uid, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, ICommonSession recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, coordinates, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, EntityUid recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, coordinates, audioParams);
+    }
+
+    private (EntityUid Entity, AudioComponent Component) CreateAndStartPlayingStream(AudioParams? audioParams, AudioStream stream)
+    {
+        var audioP = audioParams ?? AudioParams.Default;
+        var entity = SetupAudio(null, audioP, initialize: false, length: stream.Length);
+        LoadStream(entity, stream);
+        EntityManager.InitializeAndStartEntity(entity);
+        var comp = entity.Comp;
+        var source = comp.Source;
+
+        // TODO clamp the offset inside of SetPlaybackPosition() itself.
+        var offset = audioP.PlayOffsetSeconds;
+        offset = Math.Clamp(offset, 0f, (float) stream.Length.TotalSeconds - 0.01f);
+        source.PlaybackPosition = offset;
+
+        // For server we will rely on the adjusted one but locally we will have to adjust it ourselves.
+        ApplyAudioParams(comp.Params, comp);
+        source.StartPlaying();
+        return (entity, comp);
+    }
+
+    /// <summary>
+    /// Applies the audioparams to the underlying audio source.
+    /// </summary>
+    private void ApplyAudioParams(AudioParams audioParams, IAudioSource source)
+    {
+        source.Pitch = audioParams.Pitch;
+        source.Volume = audioParams.Volume;
+        source.RolloffFactor = audioParams.RolloffFactor;
+        source.MaxDistance = GetAudioDistance(audioParams.MaxDistance);
+        source.ReferenceDistance = GetAudioDistance(audioParams.ReferenceDistance);
+        source.Looping = audioParams.Loop;
+    }
+
+    private void OnEntityCoordinates(PlayAudioPositionalMessage ev)
+    {
+        PlayStatic(ev.FileName, GetCoordinates(ev.Coordinates), ev.AudioParams, false);
+    }
+
+    private void OnEntityAudio(PlayAudioEntityMessage ev)
+    {
+        PlayEntity(ev.FileName, GetEntity(ev.NetEntity), ev.AudioParams, false);
+    }
+
+    private void OnGlobalAudio(PlayAudioGlobalMessage ev)
+    {
+        PlayGlobal(ev.FileName, ev.AudioParams, false);
+    }
+
+    protected override TimeSpan GetAudioLengthImpl(string filename)
+    {
+        return _resourceCache.GetResource<AudioResource>(filename).AudioStream.Length;
+    }
+
+    #region Jobs
+
+    private record struct UpdateAudioJob : IParallelRobustJob
+    {
+        public int BatchSize => 2;
+
+        public AudioSystem System;
+
+        public MapCoordinates OurPosition;
+        public List<(EntityUid Entity, AudioComponent Component, TransformComponent Xform)> Streams;
+
+        public void Execute(int index)
+        {
+            var comp = Streams[index];
+
+            System.ProcessStream(comp.Entity, comp.Component, comp.Xform, OurPosition);
+        }
+    }
+
+    #endregion
+}

Robust.Client/Audio/Effects/AudioEffect.cs

@@ -0,0 +1,455 @@
+using System;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Effects;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio.Effects;
+
+/// <inheritdoc />
+internal sealed class AudioEffect : IAudioEffect
+{
+    internal int Handle;
+
+    private readonly IAudioInternal _master;
+
+    public AudioEffect(IAudioInternal manager)
+    {
+        Handle = EFX.GenEffect();
+        _master = manager;
+        EFX.Effect(Handle, EffectInteger.EffectType, (int) EffectType.EaxReverb);
+    }
+
+    public void Dispose()
+    {
+        if (Handle != 0)
+        {
+            EFX.DeleteEffect(Handle);
+            Handle = 0;
+        }
+    }
+
+    private void _checkDisposed()
+    {
+        if (Handle == -1)
+        {
+            throw new ObjectDisposedException(nameof(AudioEffect));
+        }
+    }
+
+    /// <inheritdoc />
+    public float Density
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDensity, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDensity, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float Diffusion
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDiffusion, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDiffusion, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float Gain
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGain, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbGain, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float GainHF
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainHF, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbGainHF, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float GainLF
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainLF, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbGainLF, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float DecayTime
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayTime, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayTime, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float DecayHFRatio
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayHFRatio, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayHFRatio, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float DecayLFRatio
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayLFRatio, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayLFRatio, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ReflectionsGain
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsGain, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsGain, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ReflectionsDelay
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsDelay, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsDelay, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public Vector3 ReflectionsPan
+    {
+        get
+        {
+            _checkDisposed();
+            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbReflectionsPan);
+            _master._checkAlError();
+            return new Vector3(value.X, value.Z, value.Y);
+        }
+        set
+        {
+            _checkDisposed();
+            var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
+            EFX.Effect(Handle, EffectVector3.EaxReverbReflectionsPan, ref openVec);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float LateReverbGain
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbGain, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbGain, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float LateReverbDelay
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbDelay, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbDelay, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public Vector3 LateReverbPan
+    {
+        get
+        {
+            _checkDisposed();
+            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbLateReverbPan);
+            _master._checkAlError();
+            return new Vector3(value.X, value.Z, value.Y);
+        }
+        set
+        {
+            _checkDisposed();
+            var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
+            EFX.Effect(Handle, EffectVector3.EaxReverbLateReverbPan, ref openVec);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float EchoTime
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoTime, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbEchoTime, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float EchoDepth
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoDepth, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbEchoDepth, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ModulationTime
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationTime, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbModulationTime, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ModulationDepth
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationDepth, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbModulationDepth, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float AirAbsorptionGainHF
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float HFReference
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbHFReference, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbHFReference, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float LFReference
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLFReference, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbLFReference, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float RoomRolloffFactor
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public int DecayHFLimit
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectInteger.EaxReverbDecayHFLimit, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectInteger.EaxReverbDecayHFLimit, value);
+            _master._checkAlError();
+        }
+    }
+}

Robust.Client/Audio/Effects/AuxiliaryAudio.cs

@@ -0,0 +1,32 @@
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Shared.Audio.Effects;
+
+namespace Robust.Client.Audio.Effects;
+
+/// <inheritdoc />
+internal sealed class AuxiliaryAudio : IAuxiliaryAudio
+{
+    internal int Handle = EFX.GenAuxiliaryEffectSlot();
+
+    public void Dispose()
+    {
+        if (Handle != -1)
+        {
+            EFX.DeleteAuxiliaryEffectSlot(Handle);
+            Handle = -1;
+        }
+    }
+
+    /// <inheritdoc />
+    public void SetEffect(IAudioEffect? effect)
+    {
+        if (effect is AudioEffect audEffect)
+        {
+            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, audEffect.Handle);
+        }
+        else
+        {
+            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, 0);
+        }
+    }
+}

Robust.Client/Audio/HeadlessAudioManager.cs

@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using System.Numerics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.AudioLoading;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Headless client audio.
+/// </summary>
+internal sealed class HeadlessAudioManager : IAudioInternal
+{
+    /// <inheritdoc />
+    public void InitializePostWindowing()
+    {
+    }
+
+    /// <inheritdoc />
+    public void Shutdown()
+    {
+    }
+
+    /// <inheritdoc />
+    public void FlushALDisposeQueues()
+    {
+    }
+
+    /// <inheritdoc />
+    public IAudioSource CreateAudioSource(AudioStream stream)
+    {
+        return DummyAudioSource.Instance;
+    }
+
+    /// <inheritdoc />
+    public IBufferedAudioSource? CreateBufferedAudioSource(int buffers, bool floatAudio = false)
+    {
+        return DummyBufferedAudioSource.Instance;
+    }
+
+    /// <inheritdoc />
+    public void SetVelocity(Vector2 velocity)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetPosition(Vector2 position)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetRotation(Angle angle)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetMasterGain(float newGain)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetAttenuation(Attenuation attenuation)
+    {
+    }
+
+    /// <inheritdoc />
+    public void StopAllAudio()
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetZOffset(float f)
+    {
+    }
+
+    /// <inheritdoc />
+    public void _checkAlError(string callerMember = "", int callerLineNumber = -1)
+    {
+    }
+
+    /// <inheritdoc />
+    public float GetAttenuationGain(float distance, float rolloffFactor, float referenceDistance, float maxDistance)
+    {
+        return 0f;
+    }
+
+    public AudioStream LoadAudioOggVorbis(Stream stream, string? name = null)
+    {
+        var metadata = AudioLoaderOgg.LoadAudioMetadata(stream);
+        return AudioStreamFromMetadata(metadata, name);
+    }
+
+    public AudioStream LoadAudioWav(Stream stream, string? name = null)
+    {
+        var metadata = AudioLoaderWav.LoadAudioMetadata(stream);
+        return AudioStreamFromMetadata(metadata, name);
+    }
+
+    public AudioStream LoadAudioRaw(ReadOnlySpan<short> samples, int channels, int sampleRate, string? name = null)
+    {
+        var length = TimeSpan.FromSeconds((double) samples.Length / channels / sampleRate);
+        return new AudioStream(null, length, channels, name);
+    }
+
+    private static AudioStream AudioStreamFromMetadata(AudioMetadata metadata, string? name)
+    {
+        return new AudioStream(null, metadata.Length, metadata.ChannelCount, name, metadata.Title, metadata.Artist);
+    }
+}

Robust.Client/Audio/IAudioInternal.cs

@@ -0,0 +1,63 @@
+using System;
+using System.IO;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Handles clientside audio.
+/// </summary>
+internal interface IAudioInternal : IAudioManager
+{
+    void InitializePostWindowing();
+    void Shutdown();
+
+    /// <summary>
+    /// Flushes all pending queues for disposing of AL sources.
+    /// </summary>
+    void FlushALDisposeQueues();
+
+    /// <summary>
+    /// Returns a buffered audio source.
+    /// </summary>
+    /// <returns>null if unable to create the source.</returns>
+    IBufferedAudioSource? CreateBufferedAudioSource(int buffers, bool floatAudio=false);
+
+    /// <summary>
+    /// Sets the velocity for the audio listener.
+    /// </summary>
+    void SetVelocity(Vector2 velocity);
+
+    /// <summary>
+    /// Sets position for the audio listener.
+    /// </summary>
+    void SetPosition(Vector2 position);
+
+    /// <summary>
+    /// Sets rotation for the audio listener.
+    /// </summary>
+    void SetRotation(Angle angle);
+
+    void SetAttenuation(Attenuation attenuation);
+
+    /// <summary>
+    /// Stops all audio from playing.
+    /// </summary>
+    void StopAllAudio();
+
+    /// <summary>
+    /// Sets the Z-offset for the audio listener.
+    /// </summary>
+    void SetZOffset(float f);
+
+    void _checkAlError([CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1);
+
+    /// <summary>
+    /// Manually calculates the specified gain for an attenuation source with the specified distance.
+    /// </summary>
+    float GetAttenuationGain(float distance, float rolloffFactor, float referenceDistance, float maxDistance);
+}

Robust.Client/Audio/IAudioManager.cs

@@ -0,0 +1,22 @@
+using System;
+using System.IO;
+using Robust.Client.Audio.Sources;
+using Robust.Shared.Audio.Sources;
+
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Public audio API for stuff that can't go through <see cref="AudioSystem"/>
+/// </summary>
+public interface IAudioManager
+{
+    IAudioSource? CreateAudioSource(AudioStream stream);
+  
+    AudioStream LoadAudioOggVorbis(Stream stream, string? name = null);
+
+    AudioStream LoadAudioWav(Stream stream, string? name = null);
+
+    AudioStream LoadAudioRaw(ReadOnlySpan<short> samples, int channels, int sampleRate, string? name = null);
+
+    void SetMasterGain(float gain);
+}

Robust.Client/Audio/Midi/IMidiManager.cs

@@ -17,11 +17,9 @@ public interface IMidiManager
     bool IsAvailable { get; }
 
     /// <summary>
-    ///     Volume, in db.
+    ///     Gain of audio.
     /// </summary>
-    float Volume { get; set; }
-
-    public int OcclusionCollisionMask { get; set; }
+    float Gain { get; set; }
 
     /// <summary>
     ///     This method tries to return a midi renderer ready to be used.

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Audio.Midi;
+using Robust.Shared.Audio.Sources;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 
@@ -20,7 +21,7 @@ public interface IMidiRenderer : IDisposable
     /// <summary>
     ///     The buffered audio source of this renderer.
     /// </summary>
-    internal IClydeBufferedAudioSource Source { get; }
+    internal IBufferedAudioSource Source { get; }
 
     /// <summary>
     ///     Whether this renderer has been disposed or not.

Robust.Client/Audio/Midi/MidiManager.cs

@@ -1,16 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Numerics;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using NFluidsynth;
-using Robust.Client.GameObjects;
-using Robust.Client.Graphics;
-using Robust.Client.ResourceManagement;
 using Robust.Shared;
 using Robust.Shared.Asynchronous;
 using Robust.Shared.Audio.Midi;
+using Robust.Shared.Collections;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.Exceptions;
@@ -19,7 +18,6 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
-using Robust.Shared.Physics;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Systems;
 using Robust.Shared.Threading;
@@ -33,25 +31,19 @@ internal sealed partial class MidiManager : IMidiManager
 {
     public const string SoundfontEnvironmentVariable = "ROBUST_SOUNDFONT_OVERRIDE";
 
-    private int _minRendererParallel;
-    private float _occlusionUpdateDelay;
-    private float _positionUpdateDelay;
-
-    [ViewVariables] private TimeSpan _nextOcclusionUpdate = TimeSpan.Zero;
-    [ViewVariables] private TimeSpan _nextPositionUpdate = TimeSpan.Zero;
-
-    [Dependency] private readonly IEyeManager _eyeManager = default!;
-    [Dependency] private readonly IResourceCacheInternal _resourceManager = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IResourceManager _resourceManager = default!;
     [Dependency] private readonly IEntityManager _entityManager = default!;
     [Dependency] private readonly IConfigurationManager _cfgMan = default!;
-    [Dependency] private readonly IClydeAudio _clydeAudio = default!;
+    [Dependency] private readonly IAudioInternal _audio = default!;
     [Dependency] private readonly ITaskManager _taskManager = default!;
     [Dependency] private readonly ILogManager _logger = default!;
     [Dependency] private readonly IParallelManager _parallel = default!;
     [Dependency] private readonly IRuntimeLog _runtime = default!;
-    [Dependency] private readonly IGameTiming _timing = default!;
 
+    private AudioSystem _audioSys = default!;
     private SharedPhysicsSystem _broadPhaseSystem = default!;
+    private SharedTransformSystem _xformSystem = default!;
 
     public IReadOnlyList<IMidiRenderer> Renderers
     {
@@ -78,24 +70,32 @@ internal sealed partial class MidiManager : IMidiManager
 
     [ViewVariables] private readonly List<IMidiRenderer> _renderers = new();
 
+    // To avoid lock contention until some kind of MIDI refactor.
+    private TimeSpan _nextUpdate;
+    private TimeSpan _updateFrequency = TimeSpan.FromSeconds(0.25f);
+
+    private SemaphoreSlim _updateSemaphore = new(1);
+
     private bool _alive = true;
     [ViewVariables] private Settings? _settings;
     private Thread? _midiThread;
     private ISawmill _midiSawmill = default!;
-    private float _volume = 0f;
+    private float _gain = 0f;
     private bool _volumeDirty = true;
 
     // Not reliable until Fluidsynth is initialized!
     [ViewVariables(VVAccess.ReadWrite)]
-    public float Volume
+    public float Gain
     {
-        get => _volume;
+        get => _gain;
         set
         {
-            if (MathHelper.CloseToPercent(_volume, value))
+            var clamped = Math.Clamp(value, 0f, 1f);
+
+            if (MathHelper.CloseToPercent(_gain, clamped))
                 return;
 
-            _cfgMan.SetCVar(CVars.MidiVolume, value);
+            _cfgMan.SetCVar(CVars.MidiVolume, clamped);
             _volumeDirty = true;
         }
     }
@@ -114,7 +114,7 @@ internal sealed partial class MidiManager : IMidiManager
         "/usr/share/sounds/sf2/TimGM6mb.sf2",
     };
 
-    private const string WindowsSoundfont = @"C:\WINDOWS\system32\drivers\gm.dls";
+    private static readonly string WindowsSoundfont = $@"{Environment.GetEnvironmentVariable("SystemRoot")}\system32\drivers\gm.dls";
 
     private const string OsxSoundfont =
         "/System/Library/Components/CoreAudio.component/Contents/Resources/gs_instruments.dls";
@@ -132,10 +132,9 @@ internal sealed partial class MidiManager : IMidiManager
 
     private NFluidsynth.Logger.LoggerDelegate _loggerDelegate = default!;
     private ISawmill _fluidsynthSawmill = default!;
-    private float _maxCastLength;
 
-    [ViewVariables(VVAccess.ReadWrite)]
-    public int OcclusionCollisionMask { get; set; }
+    private MidiUpdateJob _updateJob;
+
 
     public MidiManager()
     {
@@ -148,19 +147,10 @@ internal sealed partial class MidiManager : IMidiManager
 
         _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
         {
-            _volume = value;
+            _gain = value;
             _volumeDirty = true;
         }, true);
 
-        _cfgMan.OnValueChanged(CVars.MidiMinRendererParallel,
-            value => _minRendererParallel = value, true);
-
-        _cfgMan.OnValueChanged(CVars.MidiOcclusionUpdateDelay,
-            value => _occlusionUpdateDelay = value, true);
-
-        _cfgMan.OnValueChanged(CVars.MidiPositionUpdateDelay,
-            value => _positionUpdateDelay = value, true);
-
         _midiSawmill = _logger.GetSawmill("midi");
 #if DEBUG
         _midiSawmill.Level = LogLevel.Debug;
@@ -202,7 +192,12 @@ internal sealed partial class MidiManager : IMidiManager
             _settings["synth.midi-bank-select"].StringValue = "gm";
             //_settings["synth.verbose"].IntValue = 1; // Useful for debugging.
 
-            _parallel.AddAndInvokeParallelCountChanged(UpdateParallelCount);
+            var midiParallel = _cfgMan.GetCVar(CVars.MidiParallelism);
+            _settings["synth.polyphony"].IntValue = Math.Clamp(1024 + (int)(Math.Log2(midiParallel) * 2048), 1, 65535);
+            _settings["synth.cpu-cores"].IntValue = Math.Clamp(midiParallel, 1, 256);
+
+            _midiSawmill.Debug($"Synth Cores: {_settings["synth.cpu-cores"].IntValue}");
+            _midiSawmill.Debug($"Synth Polyphony: {_settings["synth.polyphony"].IntValue}");
         }
         catch (Exception e)
         {
@@ -211,32 +206,27 @@ internal sealed partial class MidiManager : IMidiManager
             return;
         }
 
-        _midiThread = new Thread(ThreadUpdate);
+        _midiThread = new Thread(ThreadUpdate)
+        {
+            Name = "RobustToolbox MIDI Thread"
+        };
         _midiThread.Start();
 
+        _updateJob = new MidiUpdateJob()
+        {
+            Manager = this,
+            Renderers = _renderers,
+        };
+
+        _audioSys = _entityManager.EntitySysManager.GetEntitySystem<AudioSystem>();
         _broadPhaseSystem = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
-        _cfgMan.OnValueChanged(CVars.AudioRaycastLength, OnRaycastLengthChanged, true);
+        _xformSystem = _entityManager.System<SharedTransformSystem>();
+        _entityManager.GetEntityQuery<PhysicsComponent>();
+        _entityManager.GetEntityQuery<TransformComponent>();
 
         FluidsynthInitialized = true;
     }
 
-    private void UpdateParallelCount()
-    {
-        if (_settings == null)
-            return;
-
-        _settings["synth.polyphony"].IntValue = Math.Clamp(1024 + (int)(Math.Log2(_parallel.ParallelProcessCount) * 2048), 1, 65535);
-        _settings["synth.cpu-cores"].IntValue = Math.Clamp(_parallel.ParallelProcessCount, 1, 256);
-
-        _midiSawmill.Debug($"Synth Cores: {_settings["synth.cpu-cores"].IntValue}");
-        _midiSawmill.Debug($"Synth Polyphony: {_settings["synth.polyphony"].IntValue}");
-    }
-
-    private void OnRaycastLengthChanged(float value)
-    {
-        _maxCastLength = value;
-    }
-
     private void LoggerDelegate(NFluidsynth.Logger.LogLevel level, string message, IntPtr data)
     {
         var rLevel = level switch
@@ -273,7 +263,7 @@ internal sealed partial class MidiManager : IMidiManager
         {
             soundfontLoader.SetCallbacks(_soundfontLoaderCallbacks);
 
-            var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _clydeAudio, _taskManager, _midiSawmill);
+            var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _audio, _taskManager, _midiSawmill);
 
             _midiSawmill.Debug($"Loading fallback soundfont {FallbackSoundfont}");
             // Since the last loaded soundfont takes priority, we load the fallback soundfont before the soundfont.
@@ -351,7 +341,7 @@ internal sealed partial class MidiManager : IMidiManager
                 renderer.LoadSoundfont(file.ToString());
             }
 
-            renderer.Source.SetVolume(Volume);
+            renderer.Source.Gain = _gain;
 
             lock (_renderers)
             {
@@ -372,112 +362,125 @@ internal sealed partial class MidiManager : IMidiManager
             return;
         }
 
-        // Update positions of streams every frame.
+        if (_nextUpdate > _timing.RealTime)
+            return;
+
+        _nextUpdate = _timing.RealTime + _updateFrequency;
+
+        // Update positions of streams occasionally.
         // This has a lot of code duplication with AudioSystem.FrameUpdate(), and they should probably be combined somehow.
+        // so TRUE
 
-        lock (_renderers)
-        {
-            if (_renderers.Count == 0)
-                return;
+        _updateJob.OurPosition = _audioSys.GetListenerCoordinates();
 
-            var transQuery = _entityManager.GetEntityQuery<TransformComponent>();
-            var physicsQuery = _entityManager.GetEntityQuery<PhysicsComponent>();
-            var opts = new ParallelOptions { MaxDegreeOfParallelism = _parallel.ParallelProcessCount };
+        // This semaphore is here to avoid lock contention as much as possible.
+        _updateSemaphore.Wait();
 
-            if (_renderers.Count > _minRendererParallel)
-            {
-                Parallel.ForEach(_renderers, opts, renderer => UpdateRenderer(renderer, transQuery, physicsQuery));
-            }
-            else
-            {
-                foreach (var renderer in _renderers)
-                {
-                    UpdateRenderer(renderer, transQuery, physicsQuery);
-                }
-            }
+        // The ONLY time this should be contested is with ThreadUpdate.
+        // If that becomes NOT the case then just lock this, remove the semaphore, and drop the update frequency even harder.
+        // ReSharper disable once InconsistentlySynchronizedField
+        _parallel.ProcessNow(_updateJob, _renderers.Count);
 
-        }
-
-        if (_nextOcclusionUpdate < _timing.RealTime)
-            _nextOcclusionUpdate = _timing.RealTime.Add(TimeSpan.FromSeconds(_occlusionUpdateDelay));
-
-        if (_nextPositionUpdate < _timing.RealTime)
-            _nextPositionUpdate = _timing.RealTime.Add(TimeSpan.FromSeconds(_positionUpdateDelay));
+        _updateSemaphore.Release();
 
         _volumeDirty = false;
     }
-    private void UpdateRenderer(IMidiRenderer renderer, EntityQuery<TransformComponent> transQuery,
-        EntityQuery<PhysicsComponent> physicsQuery)
+
+    private void UpdateRenderer(IMidiRenderer renderer, MapCoordinates listener)
     {
+        // TODO: This should be sharing more code with AudioSystem.
         try
         {
             if (renderer.Disposed)
                 return;
 
             if (_volumeDirty)
-                renderer.Source.SetVolume(Volume);
+            {
+                renderer.Source.Gain = Gain;
+            }
 
             if (!renderer.Mono)
             {
-                renderer.Source.SetGlobal();
+                renderer.Source.Global = true;
                 return;
             }
 
-            if (_nextPositionUpdate < _timing.RealTime)
+            MapCoordinates mapPos;
+
+            if (renderer.TrackingEntity is {} trackedEntity && !_entityManager.Deleted(trackedEntity))
             {
-                if (renderer.TrackingEntity is {} trackedEntity && !_entityManager.Deleted(trackedEntity))
-                {
-                    renderer.TrackingCoordinates = transQuery.GetComponent(renderer.TrackingEntity!.Value).MapPosition;
-                }
-                else if (renderer.TrackingCoordinates == null)
+                renderer.TrackingCoordinates = _xformSystem.GetMapCoordinates(renderer.TrackingEntity.Value);
+
+                // Pause it if the attached entity is paused.
+                if (_entityManager.IsPaused(renderer.TrackingEntity))
                 {
+                    renderer.Source.Pause();
                     return;
                 }
-
-                if (!renderer.Source.SetPosition(renderer.TrackingCoordinates.Value.Position))
-                {
-                    return;
-                }
-
-                var vel = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity!.Value,
-                    xformQuery: transQuery, physicsQuery: physicsQuery);
-                renderer.Source.SetVelocity(vel);
+            }
+            else if (renderer.TrackingCoordinates == null)
+            {
+                renderer.Source.Pause();
+                return;
             }
 
-            if (renderer.TrackingCoordinates != null && renderer.TrackingCoordinates.Value.MapId == _eyeManager.CurrentMap)
+            mapPos = renderer.TrackingCoordinates.Value;
+
+            // If it's on a different map then just mute it, not pause.
+            if (mapPos.MapId == MapId.Nullspace || mapPos.MapId != listener.MapId)
             {
-                if (_nextOcclusionUpdate >= _timing.RealTime)
-                    return;
+                renderer.Source.Gain = 0f;
+                return;
+            }
 
-                var pos = renderer.TrackingCoordinates.Value;
+            // Was previously muted maybe so try unmuting it?
+            if (renderer.Source.Gain == 0f)
+            {
+                renderer.Source.Gain = Gain;
+            }
 
-                var sourceRelative = pos.Position - _eyeManager.CurrentEye.Position.Position;
-                var occlusion = 0f;
-                if (sourceRelative.Length() > 0)
-                {
-                    occlusion = _broadPhaseSystem.IntersectRayPenetration(
-                        pos.MapId,
-                        new CollisionRay(
-                            _eyeManager.CurrentEye.Position.Position,
-                            sourceRelative.Normalized(),
-                            OcclusionCollisionMask),
-                        MathF.Min(sourceRelative.Length(), _maxCastLength),
-                        renderer.TrackingEntity);
-                }
+            var worldPos = mapPos.Position;
+            var delta = worldPos - listener.Position;
+            var distance = delta.Length();
 
-                renderer.Source.SetOcclusion(occlusion);
+            // Update position
+            // Out of range so just clip it for us.
+            if (distance > renderer.Source.MaxDistance)
+            {
+                // Still keeps the source playing, just with no volume.
+                renderer.Source.Gain = 0f;
+                return;
+            }
+
+            // Same imprecision suppression as audiosystem.
+            if (distance > 0f && distance < 0.01f)
+            {
+                worldPos = listener.Position;
+                delta = Vector2.Zero;
+                distance = 0f;
+            }
+
+            renderer.Source.Position = worldPos;
+
+            // Update velocity (doppler).
+            if (!_entityManager.Deleted(renderer.TrackingEntity))
+            {
+                var velocity = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity.Value);
+                renderer.Source.Velocity = velocity;
             }
             else
             {
-                renderer.Source.SetOcclusion(float.MaxValue);
+                renderer.Source.Velocity = Vector2.Zero;
             }
 
+            // Update occlusion
+            var occlusion = _audioSys.GetOcclusion(listener, delta, distance, renderer.TrackingEntity);
+            renderer.Source.Occlusion = occlusion;
         }
         catch (Exception ex)
         {
             _runtime.LogException(ex, _midiSawmill.Name);
         }
-
     }
 
     /// <summary>
@@ -489,21 +492,39 @@ internal sealed partial class MidiManager : IMidiManager
         {
             lock (_renderers)
             {
+                var toRemove = new ValueList<IMidiRenderer>();
+
                 for (var i = 0; i < _renderers.Count; i++)
                 {
                     var renderer = _renderers[i];
-                    if (!renderer.Disposed)
-                    {
-                        if (renderer.Master is { Disposed: true })
-                            renderer.Master = null;
 
-                        renderer.Render();
+                    lock (renderer)
+                    {
+                        if (!renderer.Disposed)
+                        {
+                            if (renderer.Master is { Disposed: true })
+                                renderer.Master = null;
+
+                            renderer.Render();
+                        }
+                        else
+                        {
+                            toRemove.Add(renderer);
+                        }
                     }
-                    else
+                }
+
+                if (toRemove.Count > 0)
+                {
+                    _updateSemaphore.Wait();
+
+                    foreach (var renderer in toRemove)
                     {
                         renderer.InternalDispose();
                         _renderers.Remove(renderer);
                     }
+
+                    _updateSemaphore.Release();
                 }
             }
 
@@ -674,4 +695,31 @@ internal sealed partial class MidiManager : IMidiManager
 
         }
     }
+
+    #region Jobs
+
+    private record struct MidiUpdateJob : IParallelRobustJob
+    {
+        public int MinimumBatchParallel => 2;
+
+        public int BatchSize => 1;
+
+        public MidiManager Manager;
+
+        public MapCoordinates OurPosition;
+        public List<IMidiRenderer> Renderers;
+
+        public void Execute(int index)
+        {
+            // The indices shouldn't be able to be touched while this job is running, just the renderer itself getting locked.
+            var renderer = Renderers[index];
+
+            lock (renderer)
+            {
+                Manager.UpdateRenderer(renderer, OurPosition);
+            }
+        }
+    }
+
+    #endregion
 }

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -4,7 +4,9 @@ using JetBrains.Annotations;
 using NFluidsynth;
 using Robust.Client.Graphics;
 using Robust.Shared.Asynchronous;
+using Robust.Shared.Audio;
 using Robust.Shared.Audio.Midi;
+using Robust.Shared.Audio.Sources;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
@@ -36,6 +38,7 @@ internal sealed class MidiRenderer : IMidiRenderer
     private readonly Synth _synth;
     private readonly Sequencer _sequencer;
     private NFluidsynth.Player? _player;
+    private int _playerTotalTicks;
     private MidiDriver? _driver;
     private byte _midiProgram = 1;
     private byte _midiBank = 1;
@@ -52,8 +55,8 @@ internal sealed class MidiRenderer : IMidiRenderer
 
     private IMidiRenderer? _master;
     public MidiRendererState RendererState => _rendererState;
-    public IClydeBufferedAudioSource Source { get; set; }
-    IClydeBufferedAudioSource IMidiRenderer.Source => Source;
+    public IBufferedAudioSource Source { get; set; }
+    IBufferedAudioSource IMidiRenderer.Source => Source;
 
     [ViewVariables]
     public bool Disposed { get; private set; } = false;
@@ -142,7 +145,21 @@ internal sealed class MidiRenderer : IMidiRenderer
     public bool DisableProgramChangeEvent { get; set; } = true;
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public int PlayerTotalTick => _player?.GetTotalTicks ?? 0;
+    public int PlayerTotalTick
+    {
+        get
+        {
+            // GetTotalTicks is really expensive (has to iterate the entire file, not cached).
+            // Slight problem with caching it ourselves: the value only becomes available when the player loads the MIDI file.
+            // And that only happens after playback really starts, with the timer and synth and all that stuff.
+            // So we cache it "as soon as it's available", i.e. not 0.
+            // We don't care about playlists and such, so it shouldn't change anymore after.
+            if (_playerTotalTicks != 0)
+                return _playerTotalTicks;
+
+            return _playerTotalTicks = _player?.GetTotalTicks ?? 0;
+        }
+    }
 
     [ViewVariables(VVAccess.ReadWrite)]
     public int PlayerTick
@@ -247,13 +264,13 @@ internal sealed class MidiRenderer : IMidiRenderer
     public event Action? OnMidiPlayerFinished;
 
     internal MidiRenderer(Settings settings, SoundFontLoader soundFontLoader, bool mono,
-        IMidiManager midiManager, IClydeAudio clydeAudio, ITaskManager taskManager, ISawmill midiSawmill)
+        IMidiManager midiManager, IAudioInternal clydeAudio, ITaskManager taskManager, ISawmill midiSawmill)
     {
         _midiManager = midiManager;
         _taskManager = taskManager;
         _midiSawmill = midiSawmill;
 
-        Source = clydeAudio.CreateBufferedAudioSource(Buffers, true);
+        Source = clydeAudio.CreateBufferedAudioSource(Buffers, true) ?? DummyBufferedAudioSource.Instance;
         Source.SampleRate = SampleRate;
         _settings = settings;
         _soundFontLoader = soundFontLoader;
@@ -337,6 +354,7 @@ internal sealed class MidiRenderer : IMidiRenderer
                 return false;
             }
 
+            _playerTotalTicks = 0;
             _player?.Dispose();
             _player = new NFluidsynth.Player(_synth);
             _player.SetPlaybackCallback(MidiPlayerEventHandler);
@@ -375,6 +393,7 @@ internal sealed class MidiRenderer : IMidiRenderer
             _player?.Join();
             _player?.Dispose();
             _player = null;
+            _playerTotalTicks = 0;
         }
 
         StopAllNotes();
@@ -488,7 +507,7 @@ internal sealed class MidiRenderer : IMidiRenderer
             }
         }
 
-        if (!Source.IsPlaying) Source.StartPlaying();
+        Source.StartPlaying();
     }
 
     public void ApplyState(MidiRendererState state, bool filterChannels = false)

Robust.Client/Audio/ShowAudioCommand.cs

@@ -0,0 +1,34 @@
+using Robust.Client.Audio;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+
+namespace Robust.Client.Commands;
+
+/// <summary>
+/// Shows a debug overlay for audio sources.
+/// </summary>
+public sealed class ShowAudioCommand : LocalizedCommands
+{
+    [Dependency] private readonly IResourceCache _client = default!;
+    [Dependency] private readonly IEntityManager _entManager = default!;
+    [Dependency] private readonly IOverlayManager _overlayManager = default!;
+    [Dependency] private readonly IPlayerManager _playerMgr = default!;
+    public override string Command => "showaudio";
+    public override void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (_overlayManager.HasOverlay<AudioOverlay>())
+            _overlayManager.RemoveOverlay<AudioOverlay>();
+        else
+            _overlayManager.AddOverlay(new AudioOverlay(
+                _entManager,
+                _playerMgr,
+                _client,
+                _entManager.System<AudioSystem>(),
+                _entManager.System<SharedTransformSystem>()));
+    }
+}