From 2353349fe5ad613f6efdb832daef19375acffb6c Mon Sep 17 00:00:00 2001
From: Leonard Hecker <lhecker@microsoft.com>
Date: Sat, 13 Nov 2021 01:10:06 +0100
Subject: [PATCH 1/2] Introduce AtlasEngine - A new text rendering prototype
 (#11623)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit introduces "AtlasEngine", a new text renderer based on DxEngine.
But unlike it, DirectWrite and Direct2D are only used to rasterize glyphs.
Blending and placing these glyphs into the target view is being done using
Direct3D and a simple HLSL shader. Since this new renderer more aggressively
assumes that the text is monospace, it simplifies the implementation:
The viewport is divided into cells, and its data is stored as a simple matrix.
Modifications to this matrix involve only simple pointer arithmetic and is easy
to understand. But just like with DxEngine however, DirectWrite
related code remains extremely complex and hard to understand.

Supported features:
* Basic text rendering with grayscale AA
* Foreground and background colors
* Emojis, including zero width joiners
* Underline, dotted underline, strikethrough
* Custom font axes and features
* Selections
* All cursor styles
* Full alpha support for all colors
* _Should_ work with Windows 7

Unsupported features:
* A more conservative GPU memory usage
  The backing texture atlas for glyphs is grow-only and will not shrink.
  After 256MB of memory is used up (~20k glyphs) text output
  will be broken until the renderer is restarted.
* ClearType
* Remaining gridlines (left, right, top, bottom, double underline)
* Hyperlinks don't get full underlines if hovered in WT
* Softfonts
* Non-default line renditions

Performance:
* Runs at up to native display refresh rate
  Unfortunately the frame rate often drops below refresh rate, due us
  fighting over the buffer lock with other parts of the application.
* CPU consumption is up to halved compared to DxEngine
  AtlasEngine is still highly unoptimized. Glyph hashing
  consumes up to a third of the current CPU time.
* No regressions in WT performance
  VT parsing and related buffer management takes up most of the CPU time (~85%),
  due to which the AtlasEngine can't show any further improvements.
* ~2x improvement in raw text throughput in OpenConsole
  compared to DxEngine running at 144 FPS
* ≥10x improvement in colored VT output in WT/OpenConsole
  compared to DxEngine running at 144 FPS
---
 .github/actions/spelling/allow/allow.txt      |   11 +-
 .github/actions/spelling/excludes.txt         |    1 +
 OpenConsole.sln                               |   43 +
 .../PublicTerminalCore.vcxproj                |    3 +
 src/cascadia/TerminalControl/ControlCore.cpp  |   48 +-
 src/cascadia/TerminalControl/ControlCore.h    |    7 +-
 .../TerminalControl/ControlInteractivity.h    |    1 +
 .../TerminalControl/IControlSettings.idl      |    2 +-
 src/cascadia/TerminalControl/TermControl.cpp  |   67 +-
 src/cascadia/TerminalControl/TermControl.h    |    8 +-
 .../TerminalControlLib.vcxproj                |    1 +
 .../TerminalCore/lib/terminalcore-lib.vcxproj |    3 +
 .../TerminalSettingsEditor/Profiles.cpp       |   13 +-
 .../TerminalSettingsEditor/Profiles.h         |    5 +-
 .../TerminalSettingsEditor/Profiles.idl       |    2 +
 .../TerminalSettingsEditor/Profiles.xaml      |   11 +-
 .../Resources/en-US/Resources.resw            |    4 +
 .../TerminalSettingsModel/MTSMSettings.h      |    3 +-
 .../TerminalSettingsModel/Profile.idl         |    1 +
 .../TerminalSettings.cpp                      |    1 +
 .../TerminalSettingsModel/TerminalSettings.h  |    1 +
 .../UnitTests_Control/MockControlSettings.h   |    1 +
 src/features.xml                              |   10 +
 src/host/exe/Host.EXE.vcxproj                 |    3 +
 src/host/ft_fuzzer/Host.FuzzWrapper.vcxproj   |    4 +
 src/host/ft_host/CJK_DbcsTests.cpp            |    3 -
 src/host/globals.h                            |    7 +-
 src/host/settings.cpp                         |   11 +-
 src/host/settings.hpp                         |   11 +-
 src/host/ut_host/Host.UnitTests.vcxproj       |    3 +
 src/interactivity/win32/lib/win32.LIB.vcxproj |    5 +-
 .../Interactivity.Win32.UnitTests.vcxproj     |    5 +-
 .../UiaTextRangeTests.cpp                     |    4 -
 src/interactivity/win32/window.cpp            |   41 +-
 src/propslib/RegistrySerialization.cpp        |    5 +-
 src/renderer/atlas/AtlasEngine.api.cpp        |  605 +++++++
 src/renderer/atlas/AtlasEngine.cpp            | 1458 +++++++++++++++++
 src/renderer/atlas/AtlasEngine.h              |  761 +++++++++
 src/renderer/atlas/AtlasEngine.r.cpp          |  460 ++++++
 src/renderer/atlas/atlas.vcxproj              |   55 +
 src/renderer/atlas/pch.cpp                    |    4 +
 src/renderer/atlas/pch.h                      |   52 +
 src/renderer/atlas/shader_ps.hlsl             |  182 ++
 src/renderer/atlas/shader_vs.hlsl             |   17 +
 src/renderer/base/RenderEngineBase.cpp        |    3 +-
 src/renderer/base/thread.cpp                  |    6 -
 src/renderer/base/thread.hpp                  |    2 -
 src/renderer/dx/CustomTextLayout.cpp          |    8 +-
 src/renderer/dx/CustomTextRenderer.cpp        |    1 +
 src/renderer/dx/DxRenderer.cpp                |   35 +-
 src/renderer/dx/DxRenderer.hpp                |   42 +-
 src/renderer/inc/IRenderEngine.hpp            |  119 +-
 src/renderer/uia/UiaRenderer.cpp              |    7 +
 src/renderer/uia/UiaRenderer.hpp              |   29 +-
 src/renderer/vt/vtrenderer.hpp                |   69 +-
 src/renderer/wddmcon/WddmConRenderer.hpp      |    2 +-
 56 files changed, 3966 insertions(+), 300 deletions(-)
 create mode 100644 src/renderer/atlas/AtlasEngine.api.cpp
 create mode 100644 src/renderer/atlas/AtlasEngine.cpp
 create mode 100644 src/renderer/atlas/AtlasEngine.h
 create mode 100644 src/renderer/atlas/AtlasEngine.r.cpp
 create mode 100644 src/renderer/atlas/atlas.vcxproj
 create mode 100644 src/renderer/atlas/pch.cpp
 create mode 100644 src/renderer/atlas/pch.h
 create mode 100644 src/renderer/atlas/shader_ps.hlsl
 create mode 100644 src/renderer/atlas/shader_vs.hlsl

diff --git a/.github/actions/spelling/allow/allow.txt b/.github/actions/spelling/allow/allow.txt
index 085ff6682..f23f8a581 100644
--- a/.github/actions/spelling/allow/allow.txt
+++ b/.github/actions/spelling/allow/allow.txt
@@ -1,12 +1,13 @@
 apc
+Apc
+bsd
 calt
 ccmp
 changelog
-cybersecurity
-Apc
 clickable
 clig
 copyable
+cybersecurity
 dalet
 dcs
 Dcs
@@ -34,17 +35,17 @@ It'd
 kje
 liga
 lje
-locl
-lorem
 Llast
 Lmid
+locl
+lorem
 Lorigin
 maxed
 mkmk
 mnt
 mru
-noreply
 nje
+noreply
 ogonek
 ok'd
 overlined
diff --git a/.github/actions/spelling/excludes.txt b/.github/actions/spelling/excludes.txt
index 8d751a187..7d64932c9 100644
--- a/.github/actions/spelling/excludes.txt
+++ b/.github/actions/spelling/excludes.txt
@@ -61,6 +61,7 @@ SUMS$
 ^src/host/runft\.bat$
 ^src/host/runut\.bat$
 ^src/interactivity/onecore/BgfxEngine\.
+^src/renderer/atlas/
 ^src/renderer/wddmcon/WddmConRenderer\.
 ^src/terminal/adapter/ut_adapter/run\.bat$
 ^src/terminal/parser/delfuzzpayload\.bat$
diff --git a/OpenConsole.sln b/OpenConsole.sln
index 493cba041..d1f99131d 100644
--- a/OpenConsole.sln
+++ b/OpenConsole.sln
@@ -400,6 +400,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WindowsTerminal.UIA.Tests",
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "api-ms-win-core-synch-l1-2-0", "src\api-ms-win-core-synch-l1-2-0\api-ms-win-core-synch-l1-2-0.vcxproj", "{9CF74355-F018-4C19-81AD-9DC6B7F2C6F5}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RendererAtlas", "src\renderer\atlas\atlas.vcxproj", "{8222900C-8B6C-452A-91AC-BE95DB04B95F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		AuditMode|Any CPU = AuditMode|Any CPU
@@ -3339,6 +3341,46 @@ Global
 		{9CF74355-F018-4C19-81AD-9DC6B7F2C6F5}.Release|x64.Build.0 = Release|x64
 		{9CF74355-F018-4C19-81AD-9DC6B7F2C6F5}.Release|x86.ActiveCfg = Release|Win32
 		{9CF74355-F018-4C19-81AD-9DC6B7F2C6F5}.Release|x86.Build.0 = Release|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|Any CPU.ActiveCfg = AuditMode|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|ARM.ActiveCfg = AuditMode|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|ARM64.ActiveCfg = AuditMode|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|ARM64.Build.0 = AuditMode|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|DotNet_x64Test.ActiveCfg = AuditMode|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|DotNet_x86Test.ActiveCfg = AuditMode|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|x64.ActiveCfg = AuditMode|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|x64.Build.0 = AuditMode|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|x86.ActiveCfg = AuditMode|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.AuditMode|x86.Build.0 = AuditMode|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|ARM.ActiveCfg = Debug|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|ARM64.Build.0 = Debug|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|DotNet_x64Test.ActiveCfg = Debug|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|DotNet_x86Test.ActiveCfg = Debug|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|x64.ActiveCfg = Debug|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|x64.Build.0 = Debug|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|x86.ActiveCfg = Debug|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Debug|x86.Build.0 = Debug|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|Any CPU.ActiveCfg = Fuzzing|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|ARM.ActiveCfg = Fuzzing|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|ARM64.ActiveCfg = Fuzzing|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|ARM64.Build.0 = Fuzzing|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|DotNet_x64Test.ActiveCfg = Fuzzing|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|DotNet_x86Test.ActiveCfg = Fuzzing|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|x64.ActiveCfg = Fuzzing|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|x64.Build.0 = Fuzzing|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|x86.ActiveCfg = Fuzzing|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Fuzzing|x86.Build.0 = Fuzzing|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|Any CPU.ActiveCfg = Release|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|ARM.ActiveCfg = Release|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|ARM64.ActiveCfg = Release|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|ARM64.Build.0 = Release|ARM64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|DotNet_x64Test.ActiveCfg = Release|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|DotNet_x86Test.ActiveCfg = Release|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|x64.ActiveCfg = Release|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|x64.Build.0 = Release|x64
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|x86.ActiveCfg = Release|Win32
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F}.Release|x86.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -3438,6 +3480,7 @@ Global
 		{C323DAEE-B307-4C7B-ACE5-7293CBEFCB5B} = {BDB237B6-1D1D-400F-84CC-40A58FA59C8E}
 		{F19DACD5-0C6E-40DC-B6E4-767A3200542C} = {BDB237B6-1D1D-400F-84CC-40A58FA59C8E}
 		{9CF74355-F018-4C19-81AD-9DC6B7F2C6F5} = {89CDCC5C-9F53-4054-97A4-639D99F169CD}
+		{8222900C-8B6C-452A-91AC-BE95DB04B95F} = {05500DEF-2294-41E3-AF9A-24E580B82836}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {3140B1B7-C8EE-43D1-A772-D82A7061A271}
diff --git a/src/cascadia/PublicTerminalCore/PublicTerminalCore.vcxproj b/src/cascadia/PublicTerminalCore/PublicTerminalCore.vcxproj
index 1665034e1..a7063bb9b 100644
--- a/src/cascadia/PublicTerminalCore/PublicTerminalCore.vcxproj
+++ b/src/cascadia/PublicTerminalCore/PublicTerminalCore.vcxproj
@@ -29,6 +29,9 @@
     <ProjectReference Include="$(SolutionDir)src\types\lib\types.vcxproj">
       <Project>{18D09A24-8240-42D6-8CB6-236EEE820263}</Project>
     </ProjectReference>
+    <ProjectReference Include="$(SolutionDir)src\renderer\atlas\atlas.vcxproj">
+      <Project>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</Project>
+    </ProjectReference>
     <ProjectReference Include="$(SolutionDir)src\renderer\base\lib\base.vcxproj">
       <Project>{af0a096a-8b3a-4949-81ef-7df8f0fee91f}</Project>
     </ProjectReference>
diff --git a/src/cascadia/TerminalControl/ControlCore.cpp b/src/cascadia/TerminalControl/ControlCore.cpp
index a402a2d5e..b08e4c474 100644
--- a/src/cascadia/TerminalControl/ControlCore.cpp
+++ b/src/cascadia/TerminalControl/ControlCore.cpp
@@ -3,16 +3,18 @@
 
 #include "pch.h"
 #include "ControlCore.h"
-#include <argb.h>
+
 #include <DefaultSettings.h>
 #include <unicode.hpp>
 #include <Utf16Parser.hpp>
-#include <Utils.h>
 #include <WinUser.h>
 #include <LibraryResources.h>
+
+#include "EventArgs.h"
 #include "../../types/inc/GlyphWidth.hpp"
-#include "../../types/inc/Utils.hpp"
 #include "../../buffer/out/search.h"
+#include "../../renderer/atlas/AtlasEngine.h"
+#include "../../renderer/dx/DxRenderer.hpp"
 
 #include "ControlCore.g.cpp"
 
@@ -202,6 +204,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                  const double actualHeight,
                                  const double compositionScale)
     {
+        assert(_settings);
+
         _panelWidth = actualWidth;
         _panelHeight = actualHeight;
         _compositionScale = compositionScale;
@@ -222,10 +226,16 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 return false;
             }
 
-            // Set up the DX Engine
-            auto dxEngine = std::make_unique<::Microsoft::Console::Render::DxEngine>();
-            _renderer->AddRenderEngine(dxEngine.get());
-            _renderEngine = std::move(dxEngine);
+            if (Feature_AtlasEngine::IsEnabled() && _settings.UseAtlasEngine())
+            {
+                _renderEngine = std::make_unique<::Microsoft::Console::Render::AtlasEngine>();
+            }
+            else
+            {
+                _renderEngine = std::make_unique<::Microsoft::Console::Render::DxEngine>();
+            }
+
+            _renderer->AddRenderEngine(_renderEngine.get());
 
             // Initialize our font with the renderer
             // We don't have to care about DPI. We'll get a change message immediately if it's not 96
@@ -271,11 +281,12 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             _renderEngine->SetSoftwareRendering(_settings.SoftwareRendering());
             _renderEngine->SetIntenseIsBold(_settings.IntenseIsBold());
 
-            _updateAntiAliasingMode(_renderEngine.get());
+            _updateAntiAliasingMode();
 
             // GH#5098: Inform the engine of the opacity of the default text background.
             // GH#11315: Always do this, even if they don't have acrylic on.
-            _renderEngine->SetDefaultTextBackgroundOpacity(::base::saturated_cast<float>(_settings.Opacity()));
+            const auto backgroundIsOpaque = _settings.Opacity() == 1.0 && _settings.BackgroundImage().empty();
+            _renderEngine->SetDefaultTextBackgroundOpacity(static_cast<float>(backgroundIsOpaque));
 
             THROW_IF_FAILED(_renderEngine->Enable());
 
@@ -616,7 +627,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _renderEngine->SetForceFullRepaintRendering(_settings.ForceFullRepaintRendering());
         _renderEngine->SetSoftwareRendering(_settings.SoftwareRendering());
 
-        _updateAntiAliasingMode(_renderEngine.get());
+        _updateAntiAliasingMode();
 
         // Refresh our font with the renderer
         const auto actualFontOldSize = _actualFont.GetSize();
@@ -650,22 +661,24 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
     }
 
-    void ControlCore::_updateAntiAliasingMode(::Microsoft::Console::Render::DxEngine* const dxEngine)
+    void ControlCore::_updateAntiAliasingMode()
     {
-        // Update DxEngine's AntialiasingMode
+        D2D1_TEXT_ANTIALIAS_MODE mode;
+
         switch (_settings.AntialiasingMode())
         {
         case TextAntialiasingMode::Cleartype:
-            dxEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE);
+            mode = D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
             break;
         case TextAntialiasingMode::Aliased:
-            dxEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_ALIASED);
+            mode = D2D1_TEXT_ANTIALIAS_MODE_ALIASED;
             break;
-        case TextAntialiasingMode::Grayscale:
         default:
-            dxEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE);
+            mode = D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE;
             break;
         }
+
+        _renderEngine->SetAntialiasingMode(mode);
     }
 
     // Method Description:
@@ -1296,7 +1309,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         if (_renderEngine)
         {
             auto lock = _terminal->LockForWriting();
-            _renderEngine->SetDefaultTextBackgroundOpacity(::base::saturated_cast<float>(opacity));
+            const auto backgroundIsOpaque = opacity == 1.0 && _settings.BackgroundImage().empty();
+            _renderEngine->SetDefaultTextBackgroundOpacity(static_cast<float>(backgroundIsOpaque));
         }
     }
 
diff --git a/src/cascadia/TerminalControl/ControlCore.h b/src/cascadia/TerminalControl/ControlCore.h
index 5beebf9e9..e9fca4644 100644
--- a/src/cascadia/TerminalControl/ControlCore.h
+++ b/src/cascadia/TerminalControl/ControlCore.h
@@ -15,11 +15,8 @@
 
 #pragma once
 
-#include "EventArgs.h"
 #include "ControlCore.g.h"
 #include "../../renderer/base/Renderer.hpp"
-#include "../../renderer/dx/DxRenderer.hpp"
-#include "../../renderer/uia/UiaRenderer.hpp"
 #include "../../cascadia/TerminalCore/Terminal.hpp"
 #include "../buffer/out/search.h"
 #include "cppwinrt_utils.h"
@@ -188,7 +185,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         // As _renderer has a dependency on _renderEngine (through a raw pointer)
         // we must ensure the _renderer is deallocated first.
         // (C++ class members are destroyed in reverse order.)
-        std::unique_ptr<::Microsoft::Console::Render::DxEngine> _renderEngine{ nullptr };
+        std::unique_ptr<::Microsoft::Console::Render::IRenderEngine> _renderEngine{ nullptr };
         std::unique_ptr<::Microsoft::Console::Render::Renderer> _renderer{ nullptr };
 
         IControlSettings _settings{ nullptr };
@@ -248,7 +245,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 #pragma endregion
 
         void _raiseReadOnlyWarning();
-        void _updateAntiAliasingMode(::Microsoft::Console::Render::DxEngine* const dxEngine);
+        void _updateAntiAliasingMode();
         void _connectionOutputHandler(const hstring& hstr);
         void _updateHoveredCell(const std::optional<til::point> terminalPosition);
 
diff --git a/src/cascadia/TerminalControl/ControlInteractivity.h b/src/cascadia/TerminalControl/ControlInteractivity.h
index 71312afc3..5dd818d9d 100644
--- a/src/cascadia/TerminalControl/ControlInteractivity.h
+++ b/src/cascadia/TerminalControl/ControlInteractivity.h
@@ -22,6 +22,7 @@
 #include "cppwinrt_utils.h"
 
 #include "ControlCore.h"
+#include "../../renderer/uia/UiaRenderer.hpp"
 
 namespace ControlUnitTests
 {
diff --git a/src/cascadia/TerminalControl/IControlSettings.idl b/src/cascadia/TerminalControl/IControlSettings.idl
index 2b16e7334..e51a34c56 100644
--- a/src/cascadia/TerminalControl/IControlSettings.idl
+++ b/src/cascadia/TerminalControl/IControlSettings.idl
@@ -31,7 +31,7 @@ namespace Microsoft.Terminal.Control
 
         Boolean UseAcrylic;
         ScrollbarState ScrollState;
-
+        Boolean UseAtlasEngine;
         String FontFace;
         Int32 FontSize;
         Windows.UI.Text.FontWeight FontWeight;
diff --git a/src/cascadia/TerminalControl/TermControl.cpp b/src/cascadia/TerminalControl/TermControl.cpp
index 7da2257b4..25fd6d2d4 100644
--- a/src/cascadia/TerminalControl/TermControl.cpp
+++ b/src/cascadia/TerminalControl/TermControl.cpp
@@ -3,17 +3,16 @@
 
 #include "pch.h"
 #include "TermControl.h"
-#include <argb.h>
-#include <DefaultSettings.h>
+
 #include <unicode.hpp>
 #include <Utf16Parser.hpp>
-#include <Utils.h>
 #include <LibraryResources.h>
+
+#include "TermControlAutomationPeer.h"
 #include "../../types/inc/GlyphWidth.hpp"
-#include "../../types/inc/Utils.hpp"
+#include "../../renderer/atlas/AtlasEngine.h"
 
 #include "TermControl.g.cpp"
-#include "TermControlAutomationPeer.h"
 
 using namespace ::Microsoft::Console::Types;
 using namespace ::Microsoft::Console::VirtualTerminal;
@@ -1828,13 +1827,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         const winrt::Windows::Foundation::Size initialSize{ cols, rows };
 
-        return GetProposedDimensions(initialSize,
-                                     settings.FontSize(),
-                                     settings.FontWeight(),
-                                     settings.FontFace(),
-                                     settings.ScrollState(),
-                                     settings.Padding(),
-                                     dpi);
+        return GetProposedDimensions(settings, dpi, initialSize);
     }
 
     // Function Description:
@@ -1855,16 +1848,15 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     //   caller knows what monitor the control is about to appear on.
     // Return Value:
     // - a size containing the requested dimensions in pixels.
-    winrt::Windows::Foundation::Size TermControl::GetProposedDimensions(const winrt::Windows::Foundation::Size& initialSizeInChars,
-                                                                        const int32_t& fontHeight,
-                                                                        const winrt::Windows::UI::Text::FontWeight& fontWeight,
-                                                                        const winrt::hstring& fontFace,
-                                                                        const ScrollbarState& scrollState,
-                                                                        const winrt::hstring& padding,
-                                                                        const uint32_t dpi)
+    winrt::Windows::Foundation::Size TermControl::GetProposedDimensions(IControlSettings const& settings, const uint32_t dpi, const winrt::Windows::Foundation::Size& initialSizeInChars)
     {
         const auto cols = ::base::saturated_cast<int>(initialSizeInChars.Width);
         const auto rows = ::base::saturated_cast<int>(initialSizeInChars.Height);
+        const auto fontSize = settings.FontSize();
+        const auto fontWeight = settings.FontWeight();
+        const auto fontFace = settings.FontFace();
+        const auto scrollState = settings.ScrollState();
+        const auto padding = settings.Padding();
 
         // Initialize our font information.
         // The font width doesn't terribly matter, we'll only be using the
@@ -1873,28 +1865,39 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         //      The family is only used to determine if the font is truetype or
         //      not, but DX doesn't use that info at all.
         //      The Codepage is additionally not actually used by the DX engine at all.
-        FontInfo actualFont = { fontFace, 0, fontWeight.Weight, { 0, gsl::narrow_cast<short>(fontHeight) }, CP_UTF8, false };
+        FontInfo actualFont = { fontFace, 0, fontWeight.Weight, { 0, gsl::narrow_cast<short>(fontSize) }, CP_UTF8, false };
         FontInfoDesired desiredFont = { actualFont };
 
         // Create a DX engine and initialize it with our font and DPI. We'll
         // then use it to measure how much space the requested rows and columns
         // will take up.
         // TODO: MSFT:21254947 - use a static function to do this instead of
-        // instantiating a DxEngine
+        // instantiating a DxEngine/AtlasEngine.
         // GH#10211 - UNDER NO CIRCUMSTANCE should this fail. If it does, the
         // whole app will crash instantaneously on launch, which is no good.
-        auto dxEngine = std::make_unique<::Microsoft::Console::Render::DxEngine>();
-        LOG_IF_FAILED(dxEngine->UpdateDpi(dpi));
-        LOG_IF_FAILED(dxEngine->UpdateFont(desiredFont, actualFont));
+        double scale;
+        if (Feature_AtlasEngine::IsEnabled() && settings.UseAtlasEngine())
+        {
+            auto engine = std::make_unique<::Microsoft::Console::Render::AtlasEngine>();
+            LOG_IF_FAILED(engine->UpdateDpi(dpi));
+            LOG_IF_FAILED(engine->UpdateFont(desiredFont, actualFont));
+            scale = engine->GetScaling();
+        }
+        else
+        {
+            auto engine = std::make_unique<::Microsoft::Console::Render::DxEngine>();
+            LOG_IF_FAILED(engine->UpdateDpi(dpi));
+            LOG_IF_FAILED(engine->UpdateFont(desiredFont, actualFont));
+            scale = engine->GetScaling();
+        }
 
-        const auto scale = dxEngine->GetScaling();
-        const auto fontSize = actualFont.GetSize();
+        const auto actualFontSize = actualFont.GetSize();
 
         // UWP XAML scrollbars aren't guaranteed to be the same size as the
         // ComCtl scrollbars, but it's certainly close enough.
         const auto scrollbarSize = GetSystemMetricsForDpi(SM_CXVSCROLL, dpi);
 
-        double width = cols * fontSize.X;
+        double width = cols * actualFontSize.X;
 
         // Reserve additional space if scrollbar is intended to be visible
         if (scrollState == ScrollbarState::Visible)
@@ -1902,7 +1905,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             width += scrollbarSize;
         }
 
-        double height = rows * fontSize.Y;
+        double height = rows * actualFontSize.Y;
         const auto thickness = ParseThicknessFromPadding(padding);
         // GH#2061 - make sure to account for the size the padding _will be_ scaled to
         width += scale * (thickness.Left + thickness.Right);
@@ -1962,13 +1965,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             const winrt::Windows::Foundation::Size minSize{ 1, 1 };
             const double scaleFactor = DisplayInformation::GetForCurrentView().RawPixelsPerViewPixel();
             const auto dpi = ::base::saturated_cast<uint32_t>(USER_DEFAULT_SCREEN_DPI * scaleFactor);
-            return GetProposedDimensions(minSize,
-                                         _settings.FontSize(),
-                                         _settings.FontWeight(),
-                                         _settings.FontFace(),
-                                         _settings.ScrollState(),
-                                         _settings.Padding(),
-                                         dpi);
+            return GetProposedDimensions(_settings, dpi, minSize);
         }
     }
 
diff --git a/src/cascadia/TerminalControl/TermControl.h b/src/cascadia/TerminalControl/TermControl.h
index 8f758fb69..cde51ec12 100644
--- a/src/cascadia/TerminalControl/TermControl.h
+++ b/src/cascadia/TerminalControl/TermControl.h
@@ -92,13 +92,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void Settings(IControlSettings newSettings);
 
         static Windows::Foundation::Size GetProposedDimensions(IControlSettings const& settings, const uint32_t dpi);
-        static Windows::Foundation::Size GetProposedDimensions(const winrt::Windows::Foundation::Size& initialSizeInChars,
-                                                               const int32_t& fontSize,
-                                                               const winrt::Windows::UI::Text::FontWeight& fontWeight,
-                                                               const winrt::hstring& fontFace,
-                                                               const ScrollbarState& scrollState,
-                                                               const winrt::hstring& padding,
-                                                               const uint32_t dpi);
+        static Windows::Foundation::Size GetProposedDimensions(IControlSettings const& settings, const uint32_t dpi, const winrt::Windows::Foundation::Size& initialSizeInChars);
 
         void BellLightOn();
 
diff --git a/src/cascadia/TerminalControl/TerminalControlLib.vcxproj b/src/cascadia/TerminalControl/TerminalControlLib.vcxproj
index 3ce1d8a52..a366650fc 100644
--- a/src/cascadia/TerminalControl/TerminalControlLib.vcxproj
+++ b/src/cascadia/TerminalControl/TerminalControlLib.vcxproj
@@ -147,6 +147,7 @@
     <ProjectReference Include="..\..\types\lib\types.vcxproj" />
     <ProjectReference Include="..\..\buffer\out\lib\bufferout.vcxproj" />
     <ProjectReference Include="$(OpenConsoleDir)src\renderer\base\lib\base.vcxproj" />
+    <ProjectReference Include="..\..\renderer\atlas\atlas.vcxproj" />
     <ProjectReference Include="..\..\renderer\dx\lib\dx.vcxproj" />
     <ProjectReference Include="..\..\renderer\uia\lib\uia.vcxproj" />
     <ProjectReference Include="..\..\terminal\parser\lib\parser.vcxproj" />
diff --git a/src/cascadia/TerminalCore/lib/terminalcore-lib.vcxproj b/src/cascadia/TerminalCore/lib/terminalcore-lib.vcxproj
index 9ced8ea9f..2f750978b 100644
--- a/src/cascadia/TerminalCore/lib/terminalcore-lib.vcxproj
+++ b/src/cascadia/TerminalCore/lib/terminalcore-lib.vcxproj
@@ -37,6 +37,9 @@
     <ProjectReference Include="$(OpenConsoleDir)src\terminal\parser\lib\parser.vcxproj">
       <Project>{3ae13314-1939-4dfa-9c14-38ca0834050c}</Project>
     </ProjectReference>
+    <ProjectReference Include="$(OpenConsoleDir)src\renderer\atlas\atlas.vcxproj">
+      <Project>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</Project>
+    </ProjectReference>
     <ProjectReference Include="$(OpenConsoleDir)src\renderer\dx\lib\dx.vcxproj">
       <Project>{48d21369-3d7b-4431-9967-24e81292cf62}</Project>
     </ProjectReference>
diff --git a/src/cascadia/TerminalSettingsEditor/Profiles.cpp b/src/cascadia/TerminalSettingsEditor/Profiles.cpp
index 6c507ecf4..9c476fc3b 100644
--- a/src/cascadia/TerminalSettingsEditor/Profiles.cpp
+++ b/src/cascadia/TerminalSettingsEditor/Profiles.cpp
@@ -246,13 +246,9 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
         return _profile.HasUnfocusedAppearance();
     }
 
-    bool ProfileViewModel::EditableUnfocusedAppearance()
+    bool ProfileViewModel::EditableUnfocusedAppearance() const noexcept
     {
-        if constexpr (Feature_EditableUnfocusedAppearance::IsEnabled())
-        {
-            return true;
-        }
-        return false;
+        return Feature_EditableUnfocusedAppearance::IsEnabled();
     }
 
     bool ProfileViewModel::ShowUnfocusedAppearance()
@@ -286,6 +282,11 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
         return _unfocusedAppearanceViewModel;
     }
 
+    bool ProfileViewModel::AtlasEngineAvailable() const noexcept
+    {
+        return Feature_AtlasEngine::IsEnabled();
+    }
+
     bool ProfileViewModel::UseParentProcessDirectory()
     {
         return StartingDirectory().empty();
diff --git a/src/cascadia/TerminalSettingsEditor/Profiles.h b/src/cascadia/TerminalSettingsEditor/Profiles.h
index 40ecd9c45..7c12d9752 100644
--- a/src/cascadia/TerminalSettingsEditor/Profiles.h
+++ b/src/cascadia/TerminalSettingsEditor/Profiles.h
@@ -61,12 +61,12 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
         Editor::AppearanceViewModel DefaultAppearance();
         Editor::AppearanceViewModel UnfocusedAppearance();
         bool HasUnfocusedAppearance();
-        bool EditableUnfocusedAppearance();
+        bool EditableUnfocusedAppearance() const noexcept;
         bool ShowUnfocusedAppearance();
-
         void CreateUnfocusedAppearance(const Windows::Foundation::Collections::IMapView<hstring, Model::ColorScheme>& schemes,
                                        const IHostedInWindow& windowRoot);
         void DeleteUnfocusedAppearance();
+        bool AtlasEngineAvailable() const noexcept;
 
         WINRT_PROPERTY(bool, IsBaseLayer, false);
 
@@ -95,6 +95,7 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
         OBSERVABLE_PROJECTED_SETTING(_profile, SnapOnInput);
         OBSERVABLE_PROJECTED_SETTING(_profile, AltGrAliasing);
         OBSERVABLE_PROJECTED_SETTING(_profile, BellStyle);
+        OBSERVABLE_PROJECTED_SETTING(_profile, UseAtlasEngine);
 
     private:
         Model::Profile _profile;
diff --git a/src/cascadia/TerminalSettingsEditor/Profiles.idl b/src/cascadia/TerminalSettingsEditor/Profiles.idl
index 5d45a612c..a4746d560 100644
--- a/src/cascadia/TerminalSettingsEditor/Profiles.idl
+++ b/src/cascadia/TerminalSettingsEditor/Profiles.idl
@@ -32,6 +32,7 @@ namespace Microsoft.Terminal.Settings.Editor
         Boolean EditableUnfocusedAppearance { get; };
         Boolean ShowUnfocusedAppearance { get; };
         AppearanceViewModel UnfocusedAppearance { get; };
+        Boolean AtlasEngineAvailable { get; };
 
         void CreateUnfocusedAppearance(Windows.Foundation.Collections.IMapView<String, Microsoft.Terminal.Settings.Model.ColorScheme> Schemes, IHostedInWindow WindowRoot);
         void DeleteUnfocusedAppearance();
@@ -61,6 +62,7 @@ namespace Microsoft.Terminal.Settings.Editor
         OBSERVABLE_PROJECTED_PROFILE_SETTING(Boolean, SnapOnInput);
         OBSERVABLE_PROJECTED_PROFILE_SETTING(Boolean, AltGrAliasing);
         OBSERVABLE_PROJECTED_PROFILE_SETTING(Microsoft.Terminal.Settings.Model.BellStyle, BellStyle);
+        OBSERVABLE_PROJECTED_PROFILE_SETTING(Boolean, UseAtlasEngine);
     }
 
     runtimeclass DeleteProfileEventArgs
diff --git a/src/cascadia/TerminalSettingsEditor/Profiles.xaml b/src/cascadia/TerminalSettingsEditor/Profiles.xaml
index 230cfc2e8..c860578aa 100644
--- a/src/cascadia/TerminalSettingsEditor/Profiles.xaml
+++ b/src/cascadia/TerminalSettingsEditor/Profiles.xaml
@@ -319,7 +319,7 @@
                         </StackPanel>
                         <StackPanel>
                             <StackPanel Orientation="Horizontal"
-                                        Visibility="{x:Bind State.Profile.EditableUnfocusedAppearance, Mode=OneWay}">
+                                        Visibility="{x:Bind State.Profile.EditableUnfocusedAppearance}">
                                 <TextBlock x:Uid="Profile_UnfocusedAppearanceTextBlock"
                                            Style="{StaticResource TitleTextBlockStyle}" />
                                 <Button x:Uid="Profile_CreateUnfocusedAppearanceButton"
@@ -477,6 +477,15 @@
                                           IsChecked="{x:Bind IsBellStyleFlagSet(4), BindBack=SetBellStyleTaskbar, Mode=TwoWay}" />
                             </StackPanel>
                         </local:SettingContainer>
+
+                        <!--  AtlasEngine  -->
+                        <local:SettingContainer x:Uid="Profile_UseAtlasEngine"
+                                                ClearSettingValue="{x:Bind State.Profile.ClearUseAtlasEngine}"
+                                                HasSettingValue="{x:Bind State.Profile.HasUseAtlasEngine, Mode=OneWay}"
+                                                SettingOverrideSource="{x:Bind State.Profile.UseAtlasEngineOverrideSource, Mode=OneWay}"
+                                                Visibility="{x:Bind State.Profile.AtlasEngineAvailable}">
+                            <ToggleSwitch IsOn="{x:Bind State.Profile.UseAtlasEngine, Mode=TwoWay}" />
+                        </local:SettingContainer>
                     </StackPanel>
                 </ScrollViewer>
             </PivotItem>
diff --git a/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw b/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw
index 0ebd1cef4..6304be967 100644
--- a/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw
+++ b/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw
@@ -927,6 +927,10 @@
     <value>Controls what happens when the application emits a BEL character.</value>
     <comment>A description for what the "bell style" setting does. Presented near "Profile_BellStyle".{Locked="BEL"}</comment>
   </data>
+  <data name="Profile_UseAtlasEngine.Header" xml:space="preserve">
+    <value>Enable experimental text rendering engine</value>
+    <comment>An option to enable an experimental text rendering engine</comment>
+  </data>
   <data name="Profile_BellStyleAudible.Content" xml:space="preserve">
     <value>Audible</value>
     <comment>An option to choose from for the "bell style" setting. When selected, an audible cue is used to notify the user.</comment>
diff --git a/src/cascadia/TerminalSettingsModel/MTSMSettings.h b/src/cascadia/TerminalSettingsModel/MTSMSettings.h
index 6719818e7..a190e0166 100644
--- a/src/cascadia/TerminalSettingsModel/MTSMSettings.h
+++ b/src/cascadia/TerminalSettingsModel/MTSMSettings.h
@@ -73,7 +73,8 @@ Author(s):
     X(hstring, Icon, "icon", L"\uE756")                                                                                                                        \
     X(CloseOnExitMode, CloseOnExit, "closeOnExit", CloseOnExitMode::Graceful)                                                                                  \
     X(hstring, TabTitle, "tabTitle")                                                                                                                           \
-    X(Model::BellStyle, BellStyle, "bellStyle", BellStyle::Audible)
+    X(Model::BellStyle, BellStyle, "bellStyle", BellStyle::Audible)                                                                                            \
+    X(bool, UseAtlasEngine, "experimental.useAtlasEngine", false)
 
 #define MTSM_FONT_SETTINGS(X)                                                          \
     X(hstring, FontFace, "face", DEFAULT_FONT_FACE)                                    \
diff --git a/src/cascadia/TerminalSettingsModel/Profile.idl b/src/cascadia/TerminalSettingsModel/Profile.idl
index 746caad25..35df44683 100644
--- a/src/cascadia/TerminalSettingsModel/Profile.idl
+++ b/src/cascadia/TerminalSettingsModel/Profile.idl
@@ -79,5 +79,6 @@ namespace Microsoft.Terminal.Settings.Model
         INHERITABLE_PROFILE_SETTING(Boolean, SnapOnInput);
         INHERITABLE_PROFILE_SETTING(Boolean, AltGrAliasing);
         INHERITABLE_PROFILE_SETTING(BellStyle, BellStyle);
+        INHERITABLE_PROFILE_SETTING(Boolean, UseAtlasEngine);
     }
 }
diff --git a/src/cascadia/TerminalSettingsModel/TerminalSettings.cpp b/src/cascadia/TerminalSettingsModel/TerminalSettings.cpp
index ae9953986..a8575a976 100644
--- a/src/cascadia/TerminalSettingsModel/TerminalSettings.cpp
+++ b/src/cascadia/TerminalSettingsModel/TerminalSettings.cpp
@@ -298,6 +298,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
             _SuppressApplicationTitle = profile.SuppressApplicationTitle();
         }
 
+        _UseAtlasEngine = profile.UseAtlasEngine();
         _ScrollState = profile.ScrollState();
 
         _AntialiasingMode = profile.AntialiasingMode();
diff --git a/src/cascadia/TerminalSettingsModel/TerminalSettings.h b/src/cascadia/TerminalSettingsModel/TerminalSettings.h
index 096f18f79..12b318d70 100644
--- a/src/cascadia/TerminalSettingsModel/TerminalSettings.h
+++ b/src/cascadia/TerminalSettingsModel/TerminalSettings.h
@@ -148,6 +148,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         INHERITABLE_SETTING(Model::TerminalSettings, hstring, EnvironmentVariables);
 
         INHERITABLE_SETTING(Model::TerminalSettings, Microsoft::Terminal::Control::ScrollbarState, ScrollState, Microsoft::Terminal::Control::ScrollbarState::Visible);
+        INHERITABLE_SETTING(Model::TerminalSettings, bool, UseAtlasEngine, false);
 
         INHERITABLE_SETTING(Model::TerminalSettings, Microsoft::Terminal::Control::TextAntialiasingMode, AntialiasingMode, Microsoft::Terminal::Control::TextAntialiasingMode::Grayscale);
 
diff --git a/src/cascadia/UnitTests_Control/MockControlSettings.h b/src/cascadia/UnitTests_Control/MockControlSettings.h
index 983d7a9d7..9a5767946 100644
--- a/src/cascadia/UnitTests_Control/MockControlSettings.h
+++ b/src/cascadia/UnitTests_Control/MockControlSettings.h
@@ -76,6 +76,7 @@ namespace ControlUnitTests
         WINRT_PROPERTY(winrt::hstring, EnvironmentVariables);
 
         WINRT_PROPERTY(winrt::Microsoft::Terminal::Control::ScrollbarState, ScrollState, winrt::Microsoft::Terminal::Control::ScrollbarState::Visible);
+        WINRT_PROPERTY(bool, UseAtlasEngine, false);
 
         WINRT_PROPERTY(winrt::Microsoft::Terminal::Control::TextAntialiasingMode, AntialiasingMode, winrt::Microsoft::Terminal::Control::TextAntialiasingMode::Grayscale);
 
diff --git a/src/features.xml b/src/features.xml
index 86fd1e2d3..8f489117b 100644
--- a/src/features.xml
+++ b/src/features.xml
@@ -79,4 +79,14 @@
         <!-- This feature will not ship to Stable until it is complete. -->
         <alwaysDisabledReleaseTokens />
     </feature>
+
+    <feature>
+        <name>Feature_AtlasEngine</name>
+        <description>If enabled, AtlasEngine and the experimental.useAtlasEngine setting are compiled into the project</description>
+        <stage>AlwaysEnabled</stage>
+        <alwaysDisabledBrandingTokens>
+            <brandingToken>Release</brandingToken>
+            <brandingToken>WindowsInbox</brandingToken>
+        </alwaysDisabledBrandingTokens>
+    </feature>
 </featureStaging>
diff --git a/src/host/exe/Host.EXE.vcxproj b/src/host/exe/Host.EXE.vcxproj
index 3967d752f..c21bb27c8 100644
--- a/src/host/exe/Host.EXE.vcxproj
+++ b/src/host/exe/Host.EXE.vcxproj
@@ -43,6 +43,9 @@
     <ProjectReference Include="..\..\renderer\base\lib\base.vcxproj">
       <Project>{af0a096a-8b3a-4949-81ef-7df8f0fee91f}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\renderer\atlas\atlas.vcxproj">
+      <Project>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\renderer\dx\lib\dx.vcxproj">
       <Project>{48d21369-3d7b-4431-9967-24e81292cf62}</Project>
     </ProjectReference>
diff --git a/src/host/ft_fuzzer/Host.FuzzWrapper.vcxproj b/src/host/ft_fuzzer/Host.FuzzWrapper.vcxproj
index e35131781..8486a9e48 100644
--- a/src/host/ft_fuzzer/Host.FuzzWrapper.vcxproj
+++ b/src/host/ft_fuzzer/Host.FuzzWrapper.vcxproj
@@ -38,6 +38,9 @@
     <ProjectReference Include="..\..\renderer\base\lib\base.vcxproj">
       <Project>{af0a096a-8b3a-4949-81ef-7df8f0fee91f}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\renderer\atlas\atlas.vcxproj">
+      <Project>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\renderer\dx\lib\dx.vcxproj">
       <Project>{48d21369-3d7b-4431-9967-24e81292cf62}</Project>
     </ProjectReference>
@@ -71,6 +74,7 @@
       <AdditionalIncludeDirectories>..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
+      <AdditionalDependencies>winmm.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
diff --git a/src/host/ft_host/CJK_DbcsTests.cpp b/src/host/ft_host/CJK_DbcsTests.cpp
index 499549944..aa98a3f64 100644
--- a/src/host/ft_host/CJK_DbcsTests.cpp
+++ b/src/host/ft_host/CJK_DbcsTests.cpp
@@ -2320,9 +2320,6 @@ void ReadStringWithReadConsoleInputAHelper(HANDLE hIn, PCSTR pszExpectedText, si
 
     while (cchRead < cchExpectedText)
     {
-        // expected read is either the size of the buffer or the number of characters remaining, whichever is smaller.
-        DWORD const dwReadExpected = (DWORD)std::min(cbBuffer, cchExpectedText - cchRead);
-
         DWORD dwRead;
         if (!VERIFY_WIN32_BOOL_SUCCEEDED(ReadConsoleInputA(hIn, irRead, (DWORD)cbBuffer, &dwRead), L"Attempt to read input into buffer."))
         {
diff --git a/src/host/globals.h b/src/host/globals.h
index a955e991f..3b116ea8e 100644
--- a/src/host/globals.h
+++ b/src/host/globals.h
@@ -22,10 +22,7 @@ Revision History:
 #include "ConsoleArguments.hpp"
 #include "ApiRoutines.h"
 
-#include "../renderer/inc/IRenderData.hpp"
-#include "../renderer/inc/IRenderEngine.hpp"
-#include "../renderer/inc/IRenderer.hpp"
-#include "../renderer/inc/IFontDefaultList.hpp"
+#include "../renderer/base/Renderer.hpp"
 
 #include "../server/DeviceComm.h"
 #include "../server/ConDrvDeviceComm.h"
@@ -62,7 +59,7 @@ public:
 
     std::vector<wchar_t> WordDelimiters;
 
-    Microsoft::Console::Render::IRenderer* pRender;
+    Microsoft::Console::Render::Renderer* pRender;
 
     Microsoft::Console::Render::IFontDefaultList* pFontDefaultList;
 
diff --git a/src/host/settings.cpp b/src/host/settings.cpp
index d1443cb32..d59181668 100644
--- a/src/host/settings.cpp
+++ b/src/host/settings.cpp
@@ -58,7 +58,7 @@ Settings::Settings() :
     _fInterceptCopyPaste(0),
     _DefaultForeground(INVALID_COLOR),
     _DefaultBackground(INVALID_COLOR),
-    _fUseDx(false),
+    _fUseDx(UseDx::Disabled),
     _fCopyColor(false)
 {
     _dwScreenBufferSize.X = 80;
@@ -820,12 +820,9 @@ void Settings::SetTerminalScrolling(const bool terminalScrollingEnabled) noexcep
     _TerminalScrolling = terminalScrollingEnabled;
 }
 
-// Routine Description:
-// - Determines whether our primary renderer should be DirectX or GDI.
-// - This is based on user preference and velocity hold back state.
-// Return Value:
-// - True means use DirectX renderer. False means use GDI renderer.
-bool Settings::GetUseDx() const noexcept
+// Determines whether our primary renderer should be DirectX or GDI.
+// This is based on user preference and velocity hold back state.
+UseDx Settings::GetUseDx() const noexcept
 {
     return _fUseDx;
 }
diff --git a/src/host/settings.hpp b/src/host/settings.hpp
index 896de0e20..3963be4bc 100644
--- a/src/host/settings.hpp
+++ b/src/host/settings.hpp
@@ -26,6 +26,13 @@ constexpr unsigned short MIN_WINDOW_OPACITY = 0x4D; // 0x4D is approximately 30%
 #include "ConsoleArguments.hpp"
 #include "../inc/conattrs.hpp"
 
+enum class UseDx : DWORD
+{
+    Disabled = 0,
+    DxEngine,
+    AtlasEngine,
+};
+
 class Settings
 {
 public:
@@ -188,7 +195,7 @@ public:
     bool IsTerminalScrolling() const noexcept;
     void SetTerminalScrolling(const bool terminalScrollingEnabled) noexcept;
 
-    bool GetUseDx() const noexcept;
+    UseDx GetUseDx() const noexcept;
     bool GetCopyColor() const noexcept;
 
 private:
@@ -232,7 +239,7 @@ private:
     bool _fAutoReturnOnNewline;
     bool _fRenderGridWorldwide;
     bool _fScreenReversed;
-    bool _fUseDx;
+    UseDx _fUseDx;
     bool _fCopyColor;
 
     std::array<COLORREF, XTERM_COLOR_TABLE_SIZE> _colorTable;
diff --git a/src/host/ut_host/Host.UnitTests.vcxproj b/src/host/ut_host/Host.UnitTests.vcxproj
index 486965b2f..6b5bedf1b 100644
--- a/src/host/ut_host/Host.UnitTests.vcxproj
+++ b/src/host/ut_host/Host.UnitTests.vcxproj
@@ -52,6 +52,9 @@
     <ProjectReference Include="..\..\internal\internal.vcxproj">
       <Project>{ef3e32a7-5ff6-42b4-b6e2-96cd7d033f00}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\renderer\atlas\atlas.vcxproj">
+      <Project>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\renderer\dx\lib\dx.vcxproj">
       <Project>{48d21369-3d7b-4431-9967-24e81292cf62}</Project>
     </ProjectReference>
diff --git a/src/interactivity/win32/lib/win32.LIB.vcxproj b/src/interactivity/win32/lib/win32.LIB.vcxproj
index da8965739..a29cec645 100644
--- a/src/interactivity/win32/lib/win32.LIB.vcxproj
+++ b/src/interactivity/win32/lib/win32.LIB.vcxproj
@@ -6,7 +6,7 @@
     <RootNamespace>win32</RootNamespace>
     <ProjectName>InteractivityWin32</ProjectName>
     <TargetName>ConInteractivityWin32Lib</TargetName>
-    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
   </PropertyGroup>
   <Import Project="$(SolutionDir)src\common.build.pre.props" />
   <ItemDefinitionGroup>
@@ -61,6 +61,9 @@
     <ClInclude Include="..\windowUiaProvider.hpp" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\..\renderer\atlas\atlas.vcxproj">
+      <Project>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\renderer\dx\lib\dx.vcxproj">
       <Project>{48d21369-3d7b-4431-9967-24e81292cf62}</Project>
     </ProjectReference>
diff --git a/src/interactivity/win32/ut_interactivity_win32/Interactivity.Win32.UnitTests.vcxproj b/src/interactivity/win32/ut_interactivity_win32/Interactivity.Win32.UnitTests.vcxproj
index 2330bee3a..fa2fa30b0 100644
--- a/src/interactivity/win32/ut_interactivity_win32/Interactivity.Win32.UnitTests.vcxproj
+++ b/src/interactivity/win32/ut_interactivity_win32/Interactivity.Win32.UnitTests.vcxproj
@@ -22,6 +22,9 @@
     <ProjectReference Include="..\..\..\internal\internal.vcxproj">
       <Project>{ef3e32a7-5ff6-42b4-b6e2-96cd7d033f00}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\renderer\atlas\atlas.vcxproj">
+      <Project>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\renderer\dx\lib\dx.vcxproj">
       <Project>{48d21369-3d7b-4431-9967-24e81292cf62}</Project>
     </ProjectReference>
@@ -76,4 +79,4 @@
   <!-- Careful reordering these. Some default props (contained in these files) are order sensitive. -->
   <Import Project="$(SolutionDir)src\common.build.post.props" />
   <Import Project="$(SolutionDir)src\common.build.tests.props" />
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/interactivity/win32/ut_interactivity_win32/UiaTextRangeTests.cpp b/src/interactivity/win32/ut_interactivity_win32/UiaTextRangeTests.cpp
index 99ae12628..518dc8747 100644
--- a/src/interactivity/win32/ut_interactivity_win32/UiaTextRangeTests.cpp
+++ b/src/interactivity/win32/ut_interactivity_win32/UiaTextRangeTests.cpp
@@ -735,7 +735,6 @@ class UiaTextRangeTests
     TEST_METHOD(CanMoveByCharacter)
     {
         const SHORT lastColumnIndex = _pScreenInfo->GetBufferSize().RightInclusive();
-        const SHORT bottomRow = gsl::narrow<SHORT>(_pTextBuffer->TotalRowCount() - 1);
 
         // GH#6986: This is used as the "end of the buffer" to help screen readers run faster
         //          instead of parsing through thousands of empty lines of text.
@@ -824,7 +823,6 @@ class UiaTextRangeTests
     TEST_METHOD(CanMoveByLine)
     {
         const SHORT lastColumnIndex = _pScreenInfo->GetBufferSize().Width() - 1;
-        const SHORT bottomRow = gsl::narrow<SHORT>(_pTextBuffer->TotalRowCount() - 1);
 
         // GH#6986: This is used as the "end of the buffer" to help screen readers run faster
         //          instead of parsing through thousands of empty lines of text.
@@ -913,7 +911,6 @@ class UiaTextRangeTests
     TEST_METHOD(CanMoveEndpointByUnitCharacter)
     {
         const SHORT lastColumnIndex = _pScreenInfo->GetBufferSize().Width() - 1;
-        const SHORT bottomRow = static_cast<SHORT>(_pTextBuffer->TotalRowCount() - 1);
 
         // GH#6986: This is used as the "end of the buffer" to help screen readers run faster
         //          instead of parsing through thousands of empty lines of text.
@@ -1197,7 +1194,6 @@ class UiaTextRangeTests
 
     TEST_METHOD(CanMoveEndpointByUnitDocument)
     {
-        const SHORT lastColumnIndex = _pScreenInfo->GetBufferSize().Width() - 1;
         const SHORT bottomRow = gsl::narrow<SHORT>(_pTextBuffer->TotalRowCount() - 1);
 
         // GH#6986: This is used as the "end of the buffer" to help screen readers run faster
diff --git a/src/interactivity/win32/window.cpp b/src/interactivity/win32/window.cpp
index e5ea81735..560a48c04 100644
--- a/src/interactivity/win32/window.cpp
+++ b/src/interactivity/win32/window.cpp
@@ -9,17 +9,14 @@
 #include "window.hpp"
 #include "windowio.hpp"
 #include "windowdpiapi.hpp"
-#include "windowmetrics.hpp"
+#include "WindowMetrics.hpp"
 
 #include "../../inc/conint.h"
 
 #include "../../host/globals.h"
 #include "../../host/dbcs.h"
-#include "../../host/getset.h"
 #include "../../host/misc.h"
-#include "../../host/_output.h"
 #include "../../host/output.h"
-#include "../../host/renderData.hpp"
 #include "../../host/scrolling.hpp"
 #include "../../host/srvinit.h"
 #include "../../host/stream.h"
@@ -29,6 +26,9 @@
 #include "../../renderer/base/renderer.hpp"
 #include "../../renderer/gdi/gdirenderer.hpp"
 
+#if TIL_FEATURE_ATLASENGINE_ENABLED
+#include "../../renderer/atlas/AtlasEngine.h"
+#endif
 #if TIL_FEATURE_CONHOSTDXENGINE_ENABLED
 #include "../../renderer/dx/DxRenderer.hpp"
 #endif
@@ -209,16 +209,20 @@ void Window::_UpdateSystemMetrics() const
     // Ensure we have appropriate system metrics before we start constructing the window.
     _UpdateSystemMetrics();
 
-    const bool useDx = pSettings->GetUseDx();
+    const auto useDx = pSettings->GetUseDx();
     GdiEngine* pGdiEngine = nullptr;
 #if TIL_FEATURE_CONHOSTDXENGINE_ENABLED
-    [[maybe_unused]] DxEngine* pDxEngine = nullptr;
+    DxEngine* pDxEngine = nullptr;
+#endif
+#if TIL_FEATURE_ATLASENGINE_ENABLED
+    AtlasEngine* pAtlasEngine = nullptr;
 #endif
     try
     {
-#if TIL_FEATURE_CONHOSTDXENGINE_ENABLED
-        if (useDx)
+        switch (useDx)
         {
+#if TIL_FEATURE_CONHOSTDXENGINE_ENABLED
+        case UseDx::DxEngine:
             pDxEngine = new DxEngine();
             // TODO: MSFT:21255595 make this less gross
             // Manually set the Dx Engine to Hwnd mode. When we're trying to
@@ -227,12 +231,18 @@ void Window::_UpdateSystemMetrics() const
             // math in the hwnd mode, not the Composition mode.
             THROW_IF_FAILED(pDxEngine->SetHwnd(nullptr));
             g.pRender->AddRenderEngine(pDxEngine);
-        }
-        else
+            break;
 #endif
-        {
+#if TIL_FEATURE_ATLASENGINE_ENABLED
+        case UseDx::AtlasEngine:
+            pAtlasEngine = new AtlasEngine();
+            g.pRender->AddRenderEngine(pAtlasEngine);
+            break;
+#endif
+        default:
             pGdiEngine = new GdiEngine();
             g.pRender->AddRenderEngine(pGdiEngine);
+            break;
         }
     }
     catch (...)
@@ -324,7 +334,7 @@ void Window::_UpdateSystemMetrics() const
             _hWnd = hWnd;
 
 #if TIL_FEATURE_CONHOSTDXENGINE_ENABLED
-            if (useDx)
+            if (pDxEngine)
             {
                 status = NTSTATUS_FROM_WIN32(HRESULT_CODE((pDxEngine->SetHwnd(hWnd))));
 
@@ -334,6 +344,13 @@ void Window::_UpdateSystemMetrics() const
                 }
             }
             else
+#endif
+#if TIL_FEATURE_ATLASENGINE_ENABLED
+                if (pAtlasEngine)
+            {
+                status = NTSTATUS_FROM_WIN32(HRESULT_CODE((pAtlasEngine->SetHwnd(hWnd))));
+            }
+            else
 #endif
             {
                 status = NTSTATUS_FROM_WIN32(HRESULT_CODE((pGdiEngine->SetHwnd(hWnd))));
diff --git a/src/propslib/RegistrySerialization.cpp b/src/propslib/RegistrySerialization.cpp
index 09995d680..d9e9bcfbe 100644
--- a/src/propslib/RegistrySerialization.cpp
+++ b/src/propslib/RegistrySerialization.cpp
@@ -63,7 +63,7 @@ const RegistrySerialization::_RegPropertyMap RegistrySerialization::s_PropertyMa
     { _RegPropertyType::Dword,          CONSOLE_REGISTRY_DEFAULTFOREGROUND,             SET_FIELD_AND_SIZE(_DefaultForeground)           },
     { _RegPropertyType::Dword,          CONSOLE_REGISTRY_DEFAULTBACKGROUND,             SET_FIELD_AND_SIZE(_DefaultBackground)           },
     { _RegPropertyType::Boolean,        CONSOLE_REGISTRY_TERMINALSCROLLING,             SET_FIELD_AND_SIZE(_TerminalScrolling)           },
-    { _RegPropertyType::Boolean,        CONSOLE_REGISTRY_USEDX,                         SET_FIELD_AND_SIZE(_fUseDx)                      },
+    { _RegPropertyType::Dword,          CONSOLE_REGISTRY_USEDX,                         SET_FIELD_AND_SIZE(_fUseDx)                      },
     { _RegPropertyType::Boolean,        CONSOLE_REGISTRY_COPYCOLOR,                     SET_FIELD_AND_SIZE(_fCopyColor)                  }
 
 };
@@ -251,7 +251,8 @@ NTSTATUS RegistrySerialization::s_OpenKey(_In_opt_ HKEY const hKey, _In_ PCWSTR
 [[nodiscard]]
 NTSTATUS RegistrySerialization::s_DeleteValue(const HKEY hKey, _In_ PCWSTR const pwszValueName)
 {
-    return NTSTATUS_FROM_WIN32(RegDeleteKeyValueW(hKey, nullptr, pwszValueName));
+    const auto result = RegDeleteKeyValueW(hKey, nullptr, pwszValueName);
+    return result == ERROR_FILE_NOT_FOUND ? S_OK : NTSTATUS_FROM_WIN32(result);
 }
 
 // Routine Description:
diff --git a/src/renderer/atlas/AtlasEngine.api.cpp b/src/renderer/atlas/AtlasEngine.api.cpp
new file mode 100644
index 000000000..f4b3ac9e1
--- /dev/null
+++ b/src/renderer/atlas/AtlasEngine.api.cpp
@@ -0,0 +1,605 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "AtlasEngine.h"
+
+// #### NOTE ####
+// If you see any code in here that contains "_r." you might be seeing a race condition.
+// The AtlasEngine::Present() method is called on a background thread without any locks,
+// while any of the API methods (like AtlasEngine::Invalidate) might be called concurrently.
+// The usage of _r fields is unsafe as those are accessed and written to by the Present() method.
+
+#pragma warning(disable : 4100) // '...': unreferenced formal parameter
+// Disable a bunch of warnings which get in the way of writing performant code.
+#pragma warning(disable : 26429) // Symbol 'data' is never tested for nullness, it can be marked as not_null (f.23).
+#pragma warning(disable : 26446) // Prefer to use gsl::at() instead of unchecked subscript operator (bounds.4).
+#pragma warning(disable : 26481) // Don't use pointer arithmetic. Use span instead (bounds.1).
+#pragma warning(disable : 26482) // Only index into arrays using constant expressions (bounds.2).
+
+using namespace Microsoft::Console::Render;
+
+// Like gsl::narrow but returns a HRESULT.
+#pragma warning(push)
+#pragma warning(disable : 26472) // Don't use a static_cast for arithmetic conversions. Use brace initialization, gsl::narrow_cast or gsl::narrow (type.1).
+template<typename T, typename U>
+constexpr HRESULT api_narrow(U val, T& out) noexcept
+{
+    out = static_cast<T>(val);
+    return static_cast<U>(out) != val || (std::is_signed_v<T> != std::is_signed_v<U> && out < T{} != val < U{}) ? HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW) : S_OK;
+}
+#pragma warning(pop)
+
+template<typename T, typename U>
+constexpr HRESULT vec2_narrow(U x, U y, AtlasEngine::vec2<T>& out) noexcept
+{
+    return api_narrow(x, out.x) | api_narrow(y, out.y);
+}
+
+#pragma region IRenderEngine
+
+[[nodiscard]] HRESULT AtlasEngine::Invalidate(const SMALL_RECT* const psrRegion) noexcept
+{
+    //assert(psrRegion->Top < psrRegion->Bottom && psrRegion->Top >= 0 && psrRegion->Bottom <= _api.cellCount.y);
+
+    // BeginPaint() protects against invalid out of bounds numbers.
+    _api.invalidatedRows.x = std::min(_api.invalidatedRows.x, gsl::narrow_cast<u16>(psrRegion->Top));
+    _api.invalidatedRows.y = std::max(_api.invalidatedRows.y, gsl::narrow_cast<u16>(psrRegion->Bottom));
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::InvalidateCursor(const SMALL_RECT* const psrRegion) noexcept
+{
+    //assert(psrRegion->Left <= psrRegion->Right && psrRegion->Left >= 0 && psrRegion->Right <= _api.cellCount.x);
+    //assert(psrRegion->Top <= psrRegion->Bottom && psrRegion->Top >= 0 && psrRegion->Bottom <= _api.cellCount.y);
+
+    const auto left = gsl::narrow_cast<u16>(psrRegion->Left);
+    const auto top = gsl::narrow_cast<u16>(psrRegion->Top);
+    const auto right = gsl::narrow_cast<u16>(psrRegion->Right);
+    const auto bottom = gsl::narrow_cast<u16>(psrRegion->Bottom);
+
+    // BeginPaint() protects against invalid out of bounds numbers.
+    _api.invalidatedCursorArea.left = std::min(_api.invalidatedCursorArea.left, left);
+    _api.invalidatedCursorArea.top = std::min(_api.invalidatedCursorArea.top, top);
+    _api.invalidatedCursorArea.right = std::max(_api.invalidatedCursorArea.right, right);
+    _api.invalidatedCursorArea.bottom = std::max(_api.invalidatedCursorArea.bottom, bottom);
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::InvalidateSystem(const RECT* const prcDirtyClient) noexcept
+{
+    const auto top = prcDirtyClient->top / _api.fontMetrics.cellSize.y;
+    const auto bottom = prcDirtyClient->bottom / _api.fontMetrics.cellSize.y;
+
+    // BeginPaint() protects against invalid out of bounds numbers.
+    SMALL_RECT rect;
+    rect.Top = gsl::narrow_cast<SHORT>(top);
+    rect.Bottom = gsl::narrow_cast<SHORT>(bottom);
+    return Invalidate(&rect);
+}
+
+[[nodiscard]] HRESULT AtlasEngine::InvalidateSelection(const std::vector<SMALL_RECT>& rectangles) noexcept
+{
+    for (const auto& rect : rectangles)
+    {
+        // BeginPaint() protects against invalid out of bounds numbers.
+        // TODO: rect can contain invalid out of bounds coordinates when the selection is being
+        // dragged outside of the viewport (and the window begins scrolling automatically).
+        _api.invalidatedRows.x = gsl::narrow_cast<u16>(std::min<int>(_api.invalidatedRows.x, std::max<int>(0, rect.Top)));
+        _api.invalidatedRows.y = gsl::narrow_cast<u16>(std::max<int>(_api.invalidatedRows.y, std::max<int>(0, rect.Bottom)));
+    }
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::InvalidateScroll(const COORD* const pcoordDelta) noexcept
+{
+    const auto delta = pcoordDelta->Y;
+    if (delta == 0)
+    {
+        return S_OK;
+    }
+
+    _api.scrollOffset = gsl::narrow_cast<i16>(clamp<int>(_api.scrollOffset + delta, i16min, i16max));
+
+    // InvalidateScroll() is a "synchronous" API. Any Invalidate()s after
+    // a InvalidateScroll() refer to the new viewport after the scroll.
+    // --> We need to shift the current invalidation rectangles as well.
+
+    _api.invalidatedCursorArea.top = gsl::narrow_cast<u16>(clamp<int>(_api.invalidatedCursorArea.top + delta, u16min, u16max));
+    _api.invalidatedCursorArea.bottom = gsl::narrow_cast<u16>(clamp<int>(_api.invalidatedCursorArea.bottom + delta, u16min, u16max));
+
+    if (delta < 0)
+    {
+        _api.invalidatedRows.x = gsl::narrow_cast<u16>(clamp<int>(_api.invalidatedRows.x + delta, u16min, u16max));
+        _api.invalidatedRows.y = _api.cellCount.y;
+    }
+    else
+    {
+        _api.invalidatedRows.x = 0;
+        _api.invalidatedRows.y = gsl::narrow_cast<u16>(clamp<int>(_api.invalidatedRows.y + delta, u16min, u16max));
+    }
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::InvalidateAll() noexcept
+{
+    _api.invalidatedRows = invalidatedRowsAll;
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::InvalidateCircling(_Out_ bool* const pForcePaint) noexcept
+{
+    RETURN_HR_IF_NULL(E_INVALIDARG, pForcePaint);
+    *pForcePaint = false;
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::InvalidateTitle(const std::wstring_view proposedTitle) noexcept
+{
+    WI_SetFlag(_api.invalidations, ApiInvalidations::Title);
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::UpdateFont(const FontInfoDesired& fontInfoDesired, _Out_ FontInfo& fontInfo) noexcept
+{
+    return UpdateFont(fontInfoDesired, fontInfo, {}, {});
+}
+
+[[nodiscard]] HRESULT AtlasEngine::UpdateSoftFont(const gsl::span<const uint16_t> bitPattern, const SIZE cellSize, const size_t centeringHint) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::UpdateDpi(const int dpi) noexcept
+{
+    u16 newDPI;
+    RETURN_IF_FAILED(api_narrow(dpi, newDPI));
+
+    if (_api.dpi != newDPI)
+    {
+        _api.dpi = newDPI;
+        WI_SetFlag(_api.invalidations, ApiInvalidations::Font);
+    }
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::UpdateViewport(const SMALL_RECT srNewViewport) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::GetProposedFont(const FontInfoDesired& fontInfoDesired, _Out_ FontInfo& fontInfo, const int dpi) noexcept
+try
+{
+    // One day I'm going to implement GDI for AtlasEngine...
+    // Until then this code is work in progress.
+#if 0
+    wil::unique_hfont hfont;
+
+    // This block of code (for GDI fonts) is unfinished.
+    if (fontInfoDesired.IsDefaultRasterFont())
+    {
+        hfont.reset(static_cast<HFONT>(GetStockObject(OEM_FIXED_FONT)));
+        RETURN_HR_IF(E_FAIL, !hfont);
+    }
+    else if (requestedFaceName == DEFAULT_RASTER_FONT_FACENAME)
+    {
+        // GDI Windows Font Mapping reference:
+        // https://msdn.microsoft.com/en-us/library/ms969909.aspx
+
+        LOGFONTW lf;
+        lf.lfHeight = -MulDiv(requestedSize.Y, dpi, 72);
+        lf.lfWidth = 0;
+        lf.lfEscapement = 0;
+        lf.lfOrientation = 0;
+        lf.lfWeight = requestedWeight;
+        lf.lfItalic = FALSE;
+        lf.lfUnderline = FALSE;
+        lf.lfStrikeOut = FALSE;
+        lf.lfCharSet = OEM_CHARSET;
+        lf.lfOutPrecision = OUT_RASTER_PRECIS;
+        lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
+        lf.lfQuality = PROOF_QUALITY; // disables scaling for rasterized fonts
+        lf.lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
+        // .size() only includes regular characters, but we also want to copy the trailing \0, so +1 it is.
+        memcpy(&lf.lfFaceName[0], &DEFAULT_RASTER_FONT_FACENAME[0], sizeof(DEFAULT_RASTER_FONT_FACENAME));
+
+        hfont.reset(CreateFontIndirectW(&lf));
+        RETURN_HR_IF(E_FAIL, !hfont);
+    }
+
+    if (hfont)
+    {
+// wil::unique_any_t's constructor says: "should not be WI_NOEXCEPT (may forward to a throwing constructor)".
+// The constructor we use by default doesn't throw.
+#pragma warning(suppress : 26447) // The function is declared 'noexcept' but calls function '...' which may throw exceptions (f.6).
+        wil::unique_hdc hdc{ CreateCompatibleDC(nullptr) };
+        RETURN_HR_IF(E_FAIL, !hdc);
+
+        DeleteObject(SelectObject(hdc.get(), hfont.get()));
+
+        SIZE sz;
+        RETURN_HR_IF(E_FAIL, !GetTextExtentPoint32W(hdc.get(), L"M", 1, &sz));
+        resultingCellSize.X = gsl::narrow<SHORT>(sz.cx);
+        resultingCellSize.Y = gsl::narrow<SHORT>(sz.cy);
+    }
+#endif
+
+    _resolveFontMetrics(fontInfoDesired, fontInfo);
+    return S_OK;
+}
+CATCH_RETURN()
+
+[[nodiscard]] HRESULT AtlasEngine::GetDirtyArea(gsl::span<const til::rectangle>& area) noexcept
+{
+    area = gsl::span{ &_api.dirtyRect, 1 };
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::GetFontSize(_Out_ COORD* const pFontSize) noexcept
+{
+    RETURN_HR_IF_NULL(E_INVALIDARG, pFontSize);
+    pFontSize->X = gsl::narrow_cast<SHORT>(_api.fontMetrics.cellSize.x);
+    pFontSize->Y = gsl::narrow_cast<SHORT>(_api.fontMetrics.cellSize.y);
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::IsGlyphWideByFont(const std::wstring_view glyph, _Out_ bool* const pResult) noexcept
+{
+    RETURN_HR_IF_NULL(E_INVALIDARG, pResult);
+
+    wil::com_ptr<IDWriteTextLayout> textLayout;
+    RETURN_IF_FAILED(_sr.dwriteFactory->CreateTextLayout(glyph.data(), gsl::narrow_cast<uint32_t>(glyph.size()), _getTextFormat(false, false), FLT_MAX, FLT_MAX, textLayout.addressof()));
+
+    DWRITE_TEXT_METRICS metrics;
+    RETURN_IF_FAILED(textLayout->GetMetrics(&metrics));
+
+    *pResult = static_cast<unsigned int>(std::ceil(metrics.width)) > _api.fontMetrics.cellSize.x;
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::UpdateTitle(const std::wstring_view newTitle) noexcept
+{
+    return S_OK;
+}
+
+#pragma endregion
+
+#pragma region DxRenderer
+
+HRESULT AtlasEngine::Enable() noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] bool AtlasEngine::GetRetroTerminalEffect() const noexcept
+{
+    return false;
+}
+
+[[nodiscard]] float AtlasEngine::GetScaling() const noexcept
+{
+    return static_cast<float>(_api.dpi) / static_cast<float>(USER_DEFAULT_SCREEN_DPI);
+}
+
+[[nodiscard]] HANDLE AtlasEngine::GetSwapChainHandle()
+{
+    if (WI_IsFlagSet(_api.invalidations, ApiInvalidations::Device))
+    {
+        _createResources();
+        WI_ClearFlag(_api.invalidations, ApiInvalidations::Device);
+    }
+
+    return _api.swapChainHandle.get();
+}
+
+[[nodiscard]] Microsoft::Console::Types::Viewport AtlasEngine::GetViewportInCharacters(const Types::Viewport& viewInPixels) const noexcept
+{
+    assert(_api.fontMetrics.cellSize.x != 0);
+    assert(_api.fontMetrics.cellSize.y != 0);
+    return Types::Viewport::FromDimensions(viewInPixels.Origin(), COORD{ gsl::narrow_cast<short>(viewInPixels.Width() / _api.fontMetrics.cellSize.x), gsl::narrow_cast<short>(viewInPixels.Height() / _api.fontMetrics.cellSize.y) });
+}
+
+[[nodiscard]] Microsoft::Console::Types::Viewport AtlasEngine::GetViewportInPixels(const Types::Viewport& viewInCharacters) const noexcept
+{
+    assert(_api.fontMetrics.cellSize.x != 0);
+    assert(_api.fontMetrics.cellSize.y != 0);
+    return Types::Viewport::FromDimensions(viewInCharacters.Origin(), COORD{ gsl::narrow_cast<short>(viewInCharacters.Width() * _api.fontMetrics.cellSize.x), gsl::narrow_cast<short>(viewInCharacters.Height() * _api.fontMetrics.cellSize.y) });
+}
+
+void AtlasEngine::SetAntialiasingMode(const D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept
+{
+    const auto mode = gsl::narrow_cast<u16>(antialiasingMode);
+    if (_api.antialiasingMode != mode)
+    {
+        _api.antialiasingMode = mode;
+        WI_SetFlag(_api.invalidations, ApiInvalidations::Font);
+    }
+}
+
+void AtlasEngine::SetCallback(std::function<void()> pfn) noexcept
+{
+    _api.swapChainChangedCallback = std::move(pfn);
+}
+
+void AtlasEngine::SetDefaultTextBackgroundOpacity(const float opacity) noexcept
+{
+    const auto mixin = opacity == 1.0f ? 0xff000000 : 0x00000000;
+    if (_api.backgroundOpaqueMixin != mixin)
+    {
+        _api.backgroundOpaqueMixin = mixin;
+        WI_SetFlag(_api.invalidations, ApiInvalidations::SwapChain);
+    }
+}
+
+void AtlasEngine::SetForceFullRepaintRendering(bool enable) noexcept
+{
+}
+
+[[nodiscard]] HRESULT AtlasEngine::SetHwnd(const HWND hwnd) noexcept
+{
+    if (_api.hwnd != hwnd)
+    {
+        _api.hwnd = hwnd;
+        WI_SetFlag(_api.invalidations, ApiInvalidations::SwapChain);
+    }
+    return S_OK;
+}
+
+void AtlasEngine::SetPixelShaderPath(std::wstring_view value) noexcept
+{
+}
+
+void AtlasEngine::SetRetroTerminalEffect(bool enable) noexcept
+{
+}
+
+void AtlasEngine::SetSelectionBackground(const COLORREF color, const float alpha) noexcept
+{
+    const u32 selectionColor = (color & 0xffffff) | gsl::narrow_cast<u32>(std::lroundf(alpha * 255.0f)) << 24;
+    if (_api.selectionColor != selectionColor)
+    {
+        _api.selectionColor = selectionColor;
+        WI_SetFlag(_api.invalidations, ApiInvalidations::Settings);
+    }
+}
+
+void AtlasEngine::SetSoftwareRendering(bool enable) noexcept
+{
+}
+
+void AtlasEngine::SetIntenseIsBold(bool enable) noexcept
+{
+}
+
+void AtlasEngine::SetWarningCallback(std::function<void(HRESULT)> pfn) noexcept
+{
+    _api.warningCallback = std::move(pfn);
+}
+
+[[nodiscard]] HRESULT AtlasEngine::SetWindowSize(const SIZE pixels) noexcept
+{
+    u16x2 newSize;
+    RETURN_IF_FAILED(vec2_narrow(pixels.cx, pixels.cy, newSize));
+
+    // At the time of writing:
+    // When Win+D is pressed, `TriggerRedrawCursor` is called and a render pass is initiated.
+    // As conhost is in the background, GetClientRect will return {0,0} and we'll get called with {0,0}.
+    // This isn't a valid value for _api.sizeInPixel and would crash _recreateSizeDependentResources().
+    if (_api.sizeInPixel != newSize && newSize != u16x2{})
+    {
+        _api.sizeInPixel = newSize;
+        _api.cellCount = _api.sizeInPixel / _api.fontMetrics.cellSize;
+        WI_SetFlag(_api.invalidations, ApiInvalidations::Size);
+    }
+
+    return S_OK;
+}
+
+void AtlasEngine::ToggleShaderEffects() noexcept
+{
+}
+
+[[nodiscard]] HRESULT AtlasEngine::UpdateFont(const FontInfoDesired& fontInfoDesired, FontInfo& fontInfo, const std::unordered_map<std::wstring_view, uint32_t>& features, const std::unordered_map<std::wstring_view, float>& axes) noexcept
+try
+{
+    std::vector<DWRITE_FONT_FEATURE> fontFeatures;
+    if (!features.empty())
+    {
+        fontFeatures.reserve(features.size() + 3);
+
+        // All of these features are enabled by default by DirectWrite.
+        // If you want to (and can) peek into the source of DirectWrite
+        // you can look for the "GenericDefaultGsubFeatures" and "GenericDefaultGposFeatures" arrays.
+        // Gsub is for GetGlyphs() and Gpos for GetGlyphPlacements().
+        //
+        // GH#10774: Apparently specifying all of the features is just redundant.
+        fontFeatures.emplace_back(DWRITE_FONT_FEATURE{ DWRITE_FONT_FEATURE_TAG_STANDARD_LIGATURES, 1 });
+        fontFeatures.emplace_back(DWRITE_FONT_FEATURE{ DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_LIGATURES, 1 });
+        fontFeatures.emplace_back(DWRITE_FONT_FEATURE{ DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_ALTERNATES, 1 });
+
+        for (const auto& p : features)
+        {
+            if (p.first.size() == 4)
+            {
+                const auto s = p.first.data();
+                switch (const auto tag = DWRITE_MAKE_FONT_FEATURE_TAG(s[0], s[1], s[2], s[3]))
+                {
+                case DWRITE_FONT_FEATURE_TAG_STANDARD_LIGATURES:
+                    fontFeatures[0].parameter = p.second;
+                    break;
+                case DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_LIGATURES:
+                    fontFeatures[1].parameter = p.second;
+                    break;
+                case DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_ALTERNATES:
+                    fontFeatures[2].parameter = p.second;
+                    break;
+                default:
+                    fontFeatures.emplace_back(DWRITE_FONT_FEATURE{ tag, p.second });
+                    break;
+                }
+            }
+        }
+    }
+
+    std::vector<DWRITE_FONT_AXIS_VALUE> fontAxisValues;
+    if (!axes.empty())
+    {
+        fontAxisValues.reserve(axes.size() + 3);
+
+        // AtlasEngine::_recreateFontDependentResources() relies on these fields to
+        // exist in this particular order in order to create appropriate default axes.
+        fontAxisValues.emplace_back(DWRITE_FONT_AXIS_VALUE{ DWRITE_FONT_AXIS_TAG_WEIGHT, -1.0f });
+        fontAxisValues.emplace_back(DWRITE_FONT_AXIS_VALUE{ DWRITE_FONT_AXIS_TAG_ITALIC, -1.0f });
+        fontAxisValues.emplace_back(DWRITE_FONT_AXIS_VALUE{ DWRITE_FONT_AXIS_TAG_SLANT, -1.0f });
+
+        for (const auto& p : axes)
+        {
+            if (p.first.size() == 4)
+            {
+                const auto s = p.first.data();
+                switch (const auto tag = DWRITE_MAKE_FONT_AXIS_TAG(s[0], s[1], s[2], s[3]))
+                {
+                case DWRITE_FONT_AXIS_TAG_WEIGHT:
+                    fontAxisValues[0].value = p.second;
+                    break;
+                case DWRITE_FONT_AXIS_TAG_ITALIC:
+                    fontAxisValues[1].value = p.second;
+                    break;
+                case DWRITE_FONT_AXIS_TAG_SLANT:
+                    fontAxisValues[2].value = p.second;
+                    break;
+                default:
+                    fontAxisValues.emplace_back(DWRITE_FONT_AXIS_VALUE{ tag, p.second });
+                    break;
+                }
+            }
+        }
+    }
+
+    const auto previousCellSize = _api.fontMetrics.cellSize;
+    _resolveFontMetrics(fontInfoDesired, fontInfo, &_api.fontMetrics);
+    _api.fontFeatures = std::move(fontFeatures);
+    _api.fontAxisValues = std::move(fontAxisValues);
+
+    WI_SetFlag(_api.invalidations, ApiInvalidations::Font);
+
+    if (previousCellSize != _api.fontMetrics.cellSize)
+    {
+        _api.cellCount = _api.sizeInPixel / _api.fontMetrics.cellSize;
+        WI_SetFlag(_api.invalidations, ApiInvalidations::Size);
+    }
+
+    return S_OK;
+}
+CATCH_RETURN()
+
+void AtlasEngine::UpdateHyperlinkHoveredId(const uint16_t hoveredId) noexcept
+{
+}
+
+#pragma endregion
+
+void AtlasEngine::_resolveFontMetrics(const FontInfoDesired& fontInfoDesired, FontInfo& fontInfo, FontMetrics* fontMetrics) const
+{
+    auto requestedFaceName = fontInfoDesired.GetFaceName().c_str();
+    const auto requestedFamily = fontInfoDesired.GetFamily();
+    auto requestedWeight = fontInfoDesired.GetWeight();
+    auto requestedSize = fontInfoDesired.GetEngineSize();
+
+    if (!requestedFaceName)
+    {
+        requestedFaceName = L"Consolas";
+    }
+    if (!requestedSize.Y)
+    {
+        requestedSize = { 0, 12 };
+    }
+    if (!requestedWeight)
+    {
+        requestedWeight = DWRITE_FONT_WEIGHT_NORMAL;
+    }
+
+    wil::com_ptr<IDWriteFontCollection> systemFontCollection;
+    THROW_IF_FAILED(_sr.dwriteFactory->GetSystemFontCollection(systemFontCollection.addressof(), false));
+
+    u32 index = 0;
+    BOOL exists = false;
+    THROW_IF_FAILED(systemFontCollection->FindFamilyName(requestedFaceName, &index, &exists));
+    THROW_HR_IF(DWRITE_E_NOFONT, !exists);
+
+    wil::com_ptr<IDWriteFontFamily> fontFamily;
+    THROW_IF_FAILED(systemFontCollection->GetFontFamily(index, fontFamily.addressof()));
+
+    wil::com_ptr<IDWriteFont> font;
+    THROW_IF_FAILED(fontFamily->GetFirstMatchingFont(static_cast<DWRITE_FONT_WEIGHT>(requestedWeight), DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, font.addressof()));
+
+    wil::com_ptr<IDWriteFontFace> fontFace;
+    THROW_IF_FAILED(font->CreateFontFace(fontFace.addressof()));
+
+    DWRITE_FONT_METRICS metrics;
+    fontFace->GetMetrics(&metrics);
+
+    // According to Wikipedia:
+    // > One em was traditionally defined as the width of the capital 'M' in the current typeface and point size,
+    // > because the 'M' was commonly cast the full-width of the square blocks [...] which are used in printing presses.
+    // Even today M is often the widest character in a font that supports ASCII.
+    // In the future a more robust solution could be written, until then this simple solution works for most cases.
+    static constexpr u32 codePoint = L'M';
+    u16 glyphIndex;
+    THROW_IF_FAILED(fontFace->GetGlyphIndicesW(&codePoint, 1, &glyphIndex));
+
+    DWRITE_GLYPH_METRICS glyphMetrics;
+    THROW_IF_FAILED(fontFace->GetDesignGlyphMetrics(&glyphIndex, 1, &glyphMetrics));
+
+    // Point sizes are commonly treated at a 72 DPI scale
+    // (including by OpenType), whereas DirectWrite uses 96 DPI.
+    // Since we want the height in px we multiply by the display's DPI.
+    const auto fontSizeInPx = std::ceil(requestedSize.Y / 72.0 * _api.dpi);
+
+    const auto designUnitsPerPx = fontSizeInPx / static_cast<double>(metrics.designUnitsPerEm);
+    const auto ascentInPx = static_cast<double>(metrics.ascent) * designUnitsPerPx;
+    const auto descentInPx = static_cast<double>(metrics.descent) * designUnitsPerPx;
+    const auto lineGapInPx = static_cast<double>(metrics.lineGap) * designUnitsPerPx;
+    const auto advanceWidthInPx = static_cast<double>(glyphMetrics.advanceWidth) * designUnitsPerPx;
+
+    const auto halfGapInPx = lineGapInPx / 2.0;
+    const auto baseline = std::ceil(ascentInPx + halfGapInPx);
+    const auto cellWidth = gsl::narrow<u16>(std::ceil(advanceWidthInPx));
+    const auto cellHeight = gsl::narrow<u16>(std::ceil(baseline + descentInPx + halfGapInPx));
+
+    {
+        COORD resultingCellSize;
+        resultingCellSize.X = gsl::narrow<SHORT>(cellWidth);
+        resultingCellSize.Y = gsl::narrow<SHORT>(cellHeight);
+        fontInfo.SetFromEngine(requestedFaceName, requestedFamily, requestedWeight, false, resultingCellSize, requestedSize);
+    }
+
+    if (fontMetrics)
+    {
+        const auto underlineOffsetInPx = static_cast<double>(-metrics.underlinePosition) * designUnitsPerPx;
+        const auto underlineThicknessInPx = static_cast<double>(metrics.underlineThickness) * designUnitsPerPx;
+        const auto strikethroughOffsetInPx = static_cast<double>(-metrics.strikethroughPosition) * designUnitsPerPx;
+        const auto strikethroughThicknessInPx = static_cast<double>(metrics.strikethroughThickness) * designUnitsPerPx;
+        const auto lineThickness = gsl::narrow<u16>(std::round(std::min(underlineThicknessInPx, strikethroughThicknessInPx)));
+        const auto underlinePos = gsl::narrow<u16>(std::round(baseline + underlineOffsetInPx - lineThickness / 2.0));
+        const auto strikethroughPos = gsl::narrow<u16>(std::round(baseline + strikethroughOffsetInPx - lineThickness / 2.0));
+
+        auto fontName = wil::make_process_heap_string(requestedFaceName);
+        const auto fontWeight = gsl::narrow<u16>(requestedWeight);
+
+        // NOTE: From this point onward no early returns or throwing code should exist,
+        // as we might cause _api to be in an inconsistent state otherwise.
+
+        fontMetrics->fontName = std::move(fontName);
+        fontMetrics->fontSizeInDIP = static_cast<float>(fontSizeInPx / static_cast<double>(_api.dpi) * 96.0);
+        fontMetrics->baselineInDIP = static_cast<float>(baseline / static_cast<double>(_api.dpi) * 96.0);
+        fontMetrics->cellSize = { cellWidth, cellHeight };
+        fontMetrics->fontWeight = fontWeight;
+        fontMetrics->underlinePos = underlinePos;
+        fontMetrics->strikethroughPos = strikethroughPos;
+        fontMetrics->lineThickness = lineThickness;
+    }
+}
diff --git a/src/renderer/atlas/AtlasEngine.cpp b/src/renderer/atlas/AtlasEngine.cpp
new file mode 100644
index 000000000..ac187dadc
--- /dev/null
+++ b/src/renderer/atlas/AtlasEngine.cpp
@@ -0,0 +1,1458 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "AtlasEngine.h"
+
+#include <shader_ps.h>
+#include <shader_vs.h>
+
+#include "../../interactivity/win32/CustomWindowMessages.h"
+
+#define SHADER_SOURCE_DIRECTORY LR"(..\..\renderer\atlas\)"
+
+// #### NOTE ####
+// This file should only contain methods that are only accessed by the caller of Present() (the "Renderer" class).
+// Basically this file poses the "synchronization" point between the concurrently running
+// general IRenderEngine API (like the Invalidate*() methods) and the Present() method
+// and thus may access both _r and _api.
+
+#pragma warning(disable : 4100) // '...': unreferenced formal parameter
+// Disable a bunch of warnings which get in the way of writing performant code.
+#pragma warning(disable : 26429) // Symbol 'data' is never tested for nullness, it can be marked as not_null (f.23).
+#pragma warning(disable : 26446) // Prefer to use gsl::at() instead of unchecked subscript operator (bounds.4).
+#pragma warning(disable : 26481) // Don't use pointer arithmetic. Use span instead (bounds.1).
+#pragma warning(disable : 26482) // Only index into arrays using constant expressions (bounds.2).
+
+using namespace Microsoft::Console::Render;
+
+#pragma warning(push)
+#pragma warning(disable : 26447) // The function is declared 'noexcept' but calls function 'operator()()' which may throw exceptions (f.6).
+__declspec(noinline) static void showOOMWarning() noexcept
+{
+    [[maybe_unused]] static const auto once = []() {
+        std::thread t{ []() noexcept {
+            MessageBoxW(nullptr, L"This application is using a highly experimental text rendering engine and has run out of memory. Text rendering will start to behave irrationally and you should restart this process.", L"Out Of Memory", MB_ICONERROR | MB_OK);
+        } };
+        t.detach();
+        return false;
+    }();
+}
+#pragma warning(pop)
+
+struct TextAnalyzer final : IDWriteTextAnalysisSource, IDWriteTextAnalysisSink
+{
+    constexpr TextAnalyzer(const std::vector<wchar_t>& text, std::vector<AtlasEngine::TextAnalyzerResult>& results) noexcept :
+        _text{ text }, _results{ results }
+    {
+        Ensures(_text.size() <= UINT32_MAX);
+    }
+
+    // TextAnalyzer will be allocated on the stack and reference counting is pointless because of that.
+    // The debug version will assert that we don't leak any references though.
+#ifdef NDEBUG
+    ULONG __stdcall AddRef() noexcept override
+    {
+        return 1;
+    }
+
+    ULONG __stdcall Release() noexcept override
+    {
+        return 1;
+    }
+#else
+    ULONG _refCount = 1;
+
+    ~TextAnalyzer()
+    {
+        assert(_refCount == 1);
+    }
+
+    ULONG __stdcall AddRef() noexcept override
+    {
+        return ++_refCount;
+    }
+
+    ULONG __stdcall Release() noexcept override
+    {
+        return --_refCount;
+    }
+#endif
+
+    HRESULT __stdcall QueryInterface(const IID& riid, void** ppvObject) noexcept override
+    {
+        __assume(ppvObject != nullptr);
+
+        if (IsEqualGUID(riid, __uuidof(IDWriteTextAnalysisSource)) || IsEqualGUID(riid, __uuidof(IDWriteTextAnalysisSink)))
+        {
+            *ppvObject = this;
+            return S_OK;
+        }
+
+        *ppvObject = nullptr;
+        return E_NOINTERFACE;
+    }
+
+    HRESULT __stdcall GetTextAtPosition(UINT32 textPosition, const WCHAR** textString, UINT32* textLength) noexcept override
+    {
+        // Writing to address 0 is a crash in practice. Just what we want.
+        __assume(textString != nullptr);
+        __assume(textLength != nullptr);
+
+        const auto size = gsl::narrow_cast<UINT32>(_text.size());
+        textPosition = std::min(textPosition, size);
+        *textString = _text.data() + textPosition;
+        *textLength = size - textPosition;
+        return S_OK;
+    }
+
+    HRESULT __stdcall GetTextBeforePosition(UINT32 textPosition, const WCHAR** textString, UINT32* textLength) noexcept override
+    {
+        // Writing to address 0 is a crash in practice. Just what we want.
+        __assume(textString != nullptr);
+        __assume(textLength != nullptr);
+
+        const auto size = gsl::narrow_cast<UINT32>(_text.size());
+        textPosition = std::min(textPosition, size);
+        *textString = _text.data();
+        *textLength = textPosition;
+        return S_OK;
+    }
+
+    DWRITE_READING_DIRECTION __stdcall GetParagraphReadingDirection() noexcept override
+    {
+        return DWRITE_READING_DIRECTION_LEFT_TO_RIGHT;
+    }
+
+    HRESULT __stdcall GetLocaleName(UINT32 textPosition, UINT32* textLength, const WCHAR** localeName) noexcept override
+    {
+        // Writing to address 0 is a crash in practice. Just what we want.
+        __assume(textLength != nullptr);
+        __assume(localeName != nullptr);
+
+        *textLength = gsl::narrow_cast<UINT32>(_text.size()) - textPosition;
+        *localeName = nullptr;
+        return S_OK;
+    }
+
+    HRESULT __stdcall GetNumberSubstitution(UINT32 textPosition, UINT32* textLength, IDWriteNumberSubstitution** numberSubstitution) noexcept override
+    {
+        return E_NOTIMPL;
+    }
+
+    HRESULT __stdcall SetScriptAnalysis(UINT32 textPosition, UINT32 textLength, const DWRITE_SCRIPT_ANALYSIS* scriptAnalysis) noexcept override
+    try
+    {
+        _results.emplace_back(AtlasEngine::TextAnalyzerResult{ textPosition, textLength, scriptAnalysis->script, static_cast<UINT8>(scriptAnalysis->shapes), 0 });
+        return S_OK;
+    }
+    CATCH_RETURN()
+
+    HRESULT __stdcall SetLineBreakpoints(UINT32 textPosition, UINT32 textLength, const DWRITE_LINE_BREAKPOINT* lineBreakpoints) noexcept override
+    {
+        return E_NOTIMPL;
+    }
+
+    HRESULT __stdcall SetBidiLevel(UINT32 textPosition, UINT32 textLength, UINT8 explicitLevel, UINT8 resolvedLevel) noexcept override
+    {
+        return E_NOTIMPL;
+    }
+
+    HRESULT __stdcall SetNumberSubstitution(UINT32 textPosition, UINT32 textLength, IDWriteNumberSubstitution* numberSubstitution) noexcept override
+    {
+        return E_NOTIMPL;
+    }
+
+private:
+    const std::vector<wchar_t>& _text;
+    std::vector<AtlasEngine::TextAnalyzerResult>& _results;
+};
+
+#pragma warning(suppress : 26455) // Default constructor may not throw. Declare it 'noexcept' (f.6).
+AtlasEngine::AtlasEngine()
+{
+#ifdef NDEBUG
+    THROW_IF_FAILED(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, _sr.d2dFactory.addressof()));
+#else
+    static constexpr D2D1_FACTORY_OPTIONS options{ D2D1_DEBUG_LEVEL_INFORMATION };
+    THROW_IF_FAILED(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, options, _sr.d2dFactory.addressof()));
+#endif
+
+    THROW_IF_FAILED(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(_sr.dwriteFactory), reinterpret_cast<::IUnknown**>(_sr.dwriteFactory.addressof())));
+    if (const auto factory2 = _sr.dwriteFactory.try_query<IDWriteFactory2>())
+    {
+        THROW_IF_FAILED(factory2->GetSystemFontFallback(_sr.systemFontFallback.addressof()));
+    }
+    {
+        wil::com_ptr<IDWriteTextAnalyzer> textAnalyzer;
+        THROW_IF_FAILED(_sr.dwriteFactory->CreateTextAnalyzer(textAnalyzer.addressof()));
+        _sr.textAnalyzer = textAnalyzer.query<IDWriteTextAnalyzer1>();
+    }
+
+    _sr.isWindows10OrGreater = IsWindows10OrGreater();
+
+#ifndef NDEBUG
+    // If you run the Host.EXE project inside Visual Studio it'll have a working directory of
+    // $(SolutionDir)\src\host\exe. This relative path will thus end up in this source directory.
+    _sr.sourceCodeWatcher = wil::make_folder_change_reader_nothrow(SHADER_SOURCE_DIRECTORY, false, wil::FolderChangeEvents::FileName | wil::FolderChangeEvents::LastWriteTime, [this](wil::FolderChangeEvent, PCWSTR path) {
+        if (til::ends_with(path, L".hlsl"))
+        {
+            auto expected = INT64_MAX;
+            const auto invalidationTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
+            _sr.sourceCodeInvalidationTime.compare_exchange_strong(expected, invalidationTime.time_since_epoch().count(), std::memory_order_relaxed);
+        }
+    });
+#endif
+}
+
+#pragma region IRenderEngine
+
+// StartPaint() is called while the console buffer lock is being held.
+// --> Put as little in here as possible.
+[[nodiscard]] HRESULT AtlasEngine::StartPaint() noexcept
+try
+{
+    if (_api.hwnd)
+    {
+        RECT rect;
+        LOG_IF_WIN32_BOOL_FALSE(GetClientRect(_api.hwnd, &rect));
+        std::ignore = SetWindowSize({ rect.right - rect.left, rect.bottom - rect.top });
+
+        if (WI_IsFlagSet(_api.invalidations, ApiInvalidations::Title))
+        {
+            LOG_IF_WIN32_BOOL_FALSE(PostMessageW(_api.hwnd, CM_UPDATE_TITLE, 0, 0));
+            WI_ClearFlag(_api.invalidations, ApiInvalidations::Title);
+        }
+    }
+
+    // It's important that we invalidate here instead of in Present() with the rest.
+    // Other functions, those called before Present(), might depend on _r fields.
+    // But most of the time _invalidations will be ::none, making this very cheap.
+    if (_api.invalidations != ApiInvalidations::None)
+    {
+        RETURN_HR_IF(E_UNEXPECTED, _api.cellCount == u16x2{});
+
+        if (WI_IsFlagSet(_api.invalidations, ApiInvalidations::Device))
+        {
+            _createResources();
+        }
+        if (WI_IsFlagSet(_api.invalidations, ApiInvalidations::SwapChain))
+        {
+            _createSwapChain();
+        }
+        if (WI_IsFlagSet(_api.invalidations, ApiInvalidations::Size))
+        {
+            _recreateSizeDependentResources();
+        }
+        if (WI_IsFlagSet(_api.invalidations, ApiInvalidations::Font))
+        {
+            _recreateFontDependentResources();
+        }
+        if (WI_IsFlagSet(_api.invalidations, ApiInvalidations::Settings))
+        {
+            _r.selectionColor = _api.selectionColor;
+            WI_SetFlag(_r.invalidations, RenderInvalidations::ConstBuffer);
+        }
+
+        // Equivalent to InvalidateAll().
+        _api.invalidatedRows = invalidatedRowsAll;
+    }
+
+#ifndef NDEBUG
+    if (const auto invalidationTime = _sr.sourceCodeInvalidationTime.load(std::memory_order_relaxed); invalidationTime != INT64_MAX && invalidationTime <= std::chrono::steady_clock::now().time_since_epoch().count())
+    {
+        _sr.sourceCodeInvalidationTime.store(INT64_MAX, std::memory_order_relaxed);
+
+        try
+        {
+            static const auto compile = [](const wchar_t* path, const char* target) {
+                const wil::unique_hfile fileHandle{ CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr) };
+                THROW_LAST_ERROR_IF(!fileHandle);
+
+                const auto fileSize = GetFileSize(fileHandle.get(), nullptr);
+                const wil::unique_handle mappingHandle{ CreateFileMappingW(fileHandle.get(), nullptr, PAGE_READONLY, 0, fileSize, nullptr) };
+                THROW_LAST_ERROR_IF(!mappingHandle);
+
+                const wil::unique_mapview_ptr<void> dataBeg{ MapViewOfFile(mappingHandle.get(), FILE_MAP_READ, 0, 0, 0) };
+                THROW_LAST_ERROR_IF(!dataBeg);
+
+                wil::com_ptr<ID3DBlob> error;
+                wil::com_ptr<ID3DBlob> blob;
+                const auto hr = D3DCompile(
+                    /* pSrcData    */ dataBeg.get(),
+                    /* SrcDataSize */ fileSize,
+                    /* pFileName   */ nullptr,
+                    /* pDefines    */ nullptr,
+                    /* pInclude    */ D3D_COMPILE_STANDARD_FILE_INCLUDE,
+                    /* pEntrypoint */ "main",
+                    /* pTarget     */ target,
+                    /* Flags1      */ D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS,
+                    /* Flags2      */ 0,
+                    /* ppCode      */ blob.addressof(),
+                    /* ppErrorMsgs */ error.addressof());
+
+                if (error)
+                {
+                    std::thread t{ [error = std::move(error)]() noexcept {
+                        MessageBoxA(nullptr, static_cast<const char*>(error->GetBufferPointer()), "Compilation error", MB_ICONERROR | MB_OK);
+                    } };
+                    t.detach();
+                }
+
+                THROW_IF_FAILED(hr);
+                return blob;
+            };
+
+            const auto vs = compile(SHADER_SOURCE_DIRECTORY "shader_vs.hlsl", "vs_4_1");
+            const auto ps = compile(SHADER_SOURCE_DIRECTORY "shader_ps.hlsl", "ps_4_1");
+
+            THROW_IF_FAILED(_r.device->CreateVertexShader(vs->GetBufferPointer(), vs->GetBufferSize(), nullptr, _r.vertexShader.put()));
+            THROW_IF_FAILED(_r.device->CreatePixelShader(ps->GetBufferPointer(), ps->GetBufferSize(), nullptr, _r.pixelShader.put()));
+            _setShaderResources();
+        }
+        CATCH_LOG()
+    }
+#endif
+
+    if (_api.invalidatedRows == invalidatedRowsAll)
+    {
+        // Skip all the partial updates, since we redraw everything anyways.
+        _api.invalidatedCursorArea = invalidatedAreaNone;
+        _api.invalidatedRows = { 0, _api.cellCount.y };
+        _api.scrollOffset = 0;
+    }
+    else
+    {
+        // Clamp invalidation rects into valid value ranges.
+        {
+            _api.invalidatedCursorArea.left = std::min(_api.invalidatedCursorArea.left, _api.cellCount.x);
+            _api.invalidatedCursorArea.top = std::min(_api.invalidatedCursorArea.top, _api.cellCount.y);
+            _api.invalidatedCursorArea.right = clamp(_api.invalidatedCursorArea.right, _api.invalidatedCursorArea.left, _api.cellCount.x);
+            _api.invalidatedCursorArea.bottom = clamp(_api.invalidatedCursorArea.bottom, _api.invalidatedCursorArea.top, _api.cellCount.y);
+        }
+        {
+            _api.invalidatedRows.x = std::min(_api.invalidatedRows.x, _api.cellCount.y);
+            _api.invalidatedRows.y = clamp(_api.invalidatedRows.y, _api.invalidatedRows.x, _api.cellCount.y);
+        }
+        {
+            const auto limit = gsl::narrow_cast<i16>(_api.cellCount.y & 0x7fff);
+            _api.scrollOffset = gsl::narrow_cast<i16>(clamp<int>(_api.scrollOffset, -limit, limit));
+        }
+
+        // Scroll the buffer by the given offset and mark the newly uncovered rows as "invalid".
+        if (_api.scrollOffset != 0)
+        {
+            const auto nothingInvalid = _api.invalidatedRows.x == _api.invalidatedRows.y;
+            const auto offset = static_cast<ptrdiff_t>(_api.scrollOffset) * _api.cellCount.x;
+            const auto data = _r.cells.data();
+            auto count = _r.cells.size();
+#pragma warning(suppress : 26494) // Variable 'dst' is uninitialized. Always initialize an object (type.5).
+            Cell* dst;
+#pragma warning(suppress : 26494) // Variable 'src' is uninitialized. Always initialize an object (type.5).
+            Cell* src;
+
+            if (_api.scrollOffset < 0)
+            {
+                // Scroll up (for instance when new text is being written at the end of the buffer).
+                dst = data;
+                src = data - offset;
+                count += offset;
+
+                const u16 endRow = _api.cellCount.y + _api.scrollOffset;
+                _api.invalidatedRows.x = nothingInvalid ? endRow : std::min<u16>(_api.invalidatedRows.x, endRow);
+                _api.invalidatedRows.y = _api.cellCount.y;
+            }
+            else
+            {
+                // Scroll down.
+                dst = data + offset;
+                src = data;
+                count -= offset;
+
+                _api.invalidatedRows.x = 0;
+                _api.invalidatedRows.y = nothingInvalid ? _api.scrollOffset : std::max<u16>(_api.invalidatedRows.y, _api.scrollOffset);
+            }
+
+            memmove(dst, src, count * sizeof(Cell));
+        }
+    }
+
+    _api.dirtyRect = til::rectangle{
+        static_cast<ptrdiff_t>(0),
+        static_cast<ptrdiff_t>(_api.invalidatedRows.x),
+        static_cast<ptrdiff_t>(_api.cellCount.x),
+        static_cast<ptrdiff_t>(_api.invalidatedRows.y),
+    };
+
+    return S_OK;
+}
+catch (const wil::ResultException& exception)
+{
+    return _handleException(exception);
+}
+CATCH_RETURN()
+
+[[nodiscard]] HRESULT AtlasEngine::EndPaint() noexcept
+try
+{
+    _flushBufferLine();
+
+    _api.invalidatedCursorArea = invalidatedAreaNone;
+    _api.invalidatedRows = invalidatedRowsNone;
+    _api.scrollOffset = 0;
+    return S_OK;
+}
+CATCH_RETURN()
+
+[[nodiscard]] bool AtlasEngine::RequiresContinuousRedraw() noexcept
+{
+    return continuousRedraw;
+}
+
+void AtlasEngine::WaitUntilCanRender() noexcept
+{
+    if constexpr (!debugGeneralPerformance)
+    {
+        if (_r.frameLatencyWaitableObject)
+        {
+            WaitForSingleObjectEx(_r.frameLatencyWaitableObject.get(), 100, true);
+#ifndef NDEBUG
+            _r.frameLatencyWaitableObjectUsed = true;
+#endif
+        }
+        else
+        {
+            Sleep(8);
+        }
+    }
+}
+
+[[nodiscard]] HRESULT AtlasEngine::PrepareForTeardown(_Out_ bool* const pForcePaint) noexcept
+{
+    RETURN_HR_IF_NULL(E_INVALIDARG, pForcePaint);
+    *pForcePaint = false;
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::ScrollFrame() noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::PrepareRenderInfo(const RenderFrameInfo& info) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::ResetLineTransform() noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::PrepareLineTransform(const LineRendition lineRendition, const size_t targetRow, const size_t viewportLeft) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::PaintBackground() noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::PaintBufferLine(const gsl::span<const Cluster> clusters, const COORD coord, const bool fTrimLeft, const bool lineWrapped) noexcept
+try
+{
+    const auto x = gsl::narrow_cast<u16>(clamp<int>(coord.X, 0, _api.cellCount.x));
+    const auto y = gsl::narrow_cast<u16>(clamp<int>(coord.Y, 0, _api.cellCount.y));
+
+    if (_api.currentRow != y)
+    {
+        _flushBufferLine();
+    }
+
+    _api.currentRow = y;
+
+    // Due to the current IRenderEngine interface (that wasn't refactored yet) we need to assemble
+    // the current buffer line first as the remaining function operates on whole lines of text.
+    {
+        if (!_api.bufferLineColumn.empty())
+        {
+            _api.bufferLineColumn.pop_back();
+        }
+
+        u16 column = x;
+        for (const auto& cluster : clusters)
+        {
+            for (const auto& ch : cluster.GetText())
+            {
+                _api.bufferLine.emplace_back(ch);
+                _api.bufferLineColumn.emplace_back(column);
+            }
+
+            column += gsl::narrow_cast<u16>(cluster.GetColumns());
+        }
+
+        _api.bufferLineColumn.emplace_back(column);
+
+        const BufferLineMetadata metadata{ _api.currentColor, _api.flags };
+        std::fill_n(_api.bufferLineMetadata.data() + x, column - x, metadata);
+    }
+
+    return S_OK;
+}
+CATCH_RETURN()
+
+[[nodiscard]] HRESULT AtlasEngine::PaintBufferGridLines(const GridLineSet lines, const COLORREF color, const size_t cchLine, const COORD coordTarget) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT AtlasEngine::PaintSelection(SMALL_RECT rect) noexcept
+try
+{
+    // Unfortunately there's no step after Renderer::_PaintBufferOutput that
+    // would inform us that it's done with the last AtlasEngine::PaintBufferLine.
+    // As such we got to call _flushBufferLine() here just to be sure.
+    _flushBufferLine();
+    _setCellFlags(rect, CellFlags::Selected, CellFlags::Selected);
+    return S_OK;
+}
+CATCH_RETURN()
+
+[[nodiscard]] HRESULT AtlasEngine::PaintCursor(const CursorOptions& options) noexcept
+try
+{
+    // Unfortunately there's no step after Renderer::_PaintBufferOutput that
+    // would inform us that it's done with the last AtlasEngine::PaintBufferLine.
+    // As such we got to call _flushBufferLine() here just to be sure.
+    _flushBufferLine();
+
+    {
+        const CachedCursorOptions cachedOptions{
+            gsl::narrow_cast<u32>(options.fUseColor ? options.cursorColor | 0xff000000 : INVALID_COLOR),
+            gsl::narrow_cast<u16>(options.cursorType),
+            gsl::narrow_cast<u8>(options.ulCursorHeightPercent),
+        };
+        if (_r.cursorOptions != cachedOptions)
+        {
+            _r.cursorOptions = cachedOptions;
+            WI_SetFlag(_r.invalidations, RenderInvalidations::Cursor);
+        }
+    }
+
+    // Clear the previous cursor
+    if (_api.invalidatedCursorArea.non_empty())
+    {
+        _setCellFlags(til::bit_cast<SMALL_RECT>(_api.invalidatedCursorArea), CellFlags::Cursor, CellFlags::None);
+    }
+
+    if (options.isOn)
+    {
+        const auto point = options.coordCursor;
+        // TODO: options.coordCursor can contain invalid out of bounds coordinates when
+        // the window is being resized and the cursor is on the last line of the viewport.
+        const auto x = gsl::narrow_cast<SHORT>(std::min<int>(point.X, _r.cellCount.x - 1));
+        const auto y = gsl::narrow_cast<SHORT>(std::min<int>(point.Y, _r.cellCount.y - 1));
+        const SHORT right = x + 1 + (options.fIsDoubleWidth & (options.cursorType != CursorType::VerticalBar));
+        const SHORT bottom = y + 1;
+        _setCellFlags({ x, y, right, bottom }, CellFlags::Cursor, CellFlags::Cursor);
+    }
+
+    return S_OK;
+}
+CATCH_RETURN()
+
+[[nodiscard]] HRESULT AtlasEngine::UpdateDrawingBrushes(const TextAttribute& textAttributes, const gsl::not_null<IRenderData*> pData, const bool usingSoftFont, const bool isSettingDefaultBrushes) noexcept
+try
+{
+    const auto [fg, bg] = pData->GetAttributeColors(textAttributes);
+
+    if (!isSettingDefaultBrushes)
+    {
+        auto flags = CellFlags::None;
+        WI_SetFlagIf(flags, CellFlags::BorderLeft, textAttributes.IsLeftVerticalDisplayed());
+        WI_SetFlagIf(flags, CellFlags::BorderTop, textAttributes.IsTopHorizontalDisplayed());
+        WI_SetFlagIf(flags, CellFlags::BorderRight, textAttributes.IsRightVerticalDisplayed());
+        WI_SetFlagIf(flags, CellFlags::BorderBottom, textAttributes.IsBottomHorizontalDisplayed());
+        WI_SetFlagIf(flags, CellFlags::Underline, textAttributes.IsUnderlined());
+        WI_SetFlagIf(flags, CellFlags::UnderlineDotted, textAttributes.IsHyperlink());
+        WI_SetFlagIf(flags, CellFlags::UnderlineDouble, textAttributes.IsDoublyUnderlined());
+        WI_SetFlagIf(flags, CellFlags::Strikethrough, textAttributes.IsCrossedOut());
+
+        const u32x2 newColors{ gsl::narrow_cast<u32>(fg | 0xff000000), gsl::narrow_cast<u32>(bg | _api.backgroundOpaqueMixin) };
+        const AtlasKeyAttributes attributes{ 0, textAttributes.IsBold(), textAttributes.IsItalic(), 0 };
+
+        if (_api.attributes != attributes)
+        {
+            _flushBufferLine();
+        }
+
+        _api.currentColor = newColors;
+        _api.attributes = attributes;
+        _api.flags = flags;
+    }
+    else if (textAttributes.BackgroundIsDefault() && bg != _r.backgroundColor)
+    {
+        _r.backgroundColor = bg | _api.backgroundOpaqueMixin;
+        WI_SetFlag(_r.invalidations, RenderInvalidations::ConstBuffer);
+    }
+
+    return S_OK;
+}
+CATCH_RETURN()
+
+#pragma endregion
+
+[[nodiscard]] HRESULT AtlasEngine::_handleException(const wil::ResultException& exception) noexcept
+{
+    const auto hr = exception.GetErrorCode();
+    if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET || hr == D2DERR_RECREATE_TARGET)
+    {
+        WI_SetFlag(_api.invalidations, ApiInvalidations::Device);
+        return E_PENDING; // Indicate a retry to the renderer
+    }
+
+    // NOTE: This isn't thread safe, as _handleException is called by AtlasEngine.r.cpp.
+    // However it's not too much of a concern at the moment as SetWarningCallback()
+    // is only called once during construction in practice.
+    if (_api.warningCallback)
+    {
+        try
+        {
+            _api.warningCallback(hr);
+        }
+        CATCH_LOG()
+    }
+
+    return hr;
+}
+
+void AtlasEngine::_createResources()
+{
+    _releaseSwapChain();
+    _r = {};
+
+#ifdef NDEBUG
+    static constexpr
+#endif
+        auto deviceFlags = D3D11_CREATE_DEVICE_SINGLETHREADED | D3D11_CREATE_DEVICE_BGRA_SUPPORT;
+
+#ifndef NDEBUG
+    // DXGI debug messages + enabling D3D11_CREATE_DEVICE_DEBUG if the Windows SDK was installed.
+    if (const wil::unique_hmodule module{ LoadLibraryExW(L"dxgi.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32) })
+    {
+        deviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
+
+        if (const auto DXGIGetDebugInterface1 = GetProcAddressByFunctionDeclaration(module.get(), DXGIGetDebugInterface1))
+        {
+            if (wil::com_ptr<IDXGIInfoQueue> infoQueue; SUCCEEDED(DXGIGetDebugInterface1(0, IID_PPV_ARGS(infoQueue.addressof()))))
+            {
+                // I didn't want to link with dxguid.lib just for getting DXGI_DEBUG_ALL. This GUID is publicly documented.
+                static constexpr GUID dxgiDebugAll = { 0xe48ae283, 0xda80, 0x490b, { 0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x8 } };
+                for (const auto severity : std::array{ DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_WARNING })
+                {
+                    infoQueue->SetBreakOnSeverity(dxgiDebugAll, severity, true);
+                }
+            }
+
+            if (wil::com_ptr<IDXGIDebug1> debug; SUCCEEDED(DXGIGetDebugInterface1(0, IID_PPV_ARGS(debug.addressof()))))
+            {
+                debug->EnableLeakTrackingForThread();
+            }
+        }
+    }
+#endif // NDEBUG
+
+    // D3D device setup (basically a D3D class factory)
+    {
+        wil::com_ptr<ID3D11DeviceContext> deviceContext;
+
+        // Why D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS:
+        // This flag prevents the driver from creating a large thread pool for things like shader computations
+        // that would be advantageous for games. For us this has only a minimal performance benefit,
+        // but comes with a large memory usage overhead. At the time of writing the Nvidia
+        // driver launches $cpu_thread_count more worker threads without this flag.
+        static constexpr std::array driverTypes{
+            std::pair{ D3D_DRIVER_TYPE_HARDWARE, D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS },
+            std::pair{ D3D_DRIVER_TYPE_WARP, static_cast<D3D11_CREATE_DEVICE_FLAG>(0) },
+        };
+        static constexpr std::array featureLevels{
+            D3D_FEATURE_LEVEL_11_1,
+            D3D_FEATURE_LEVEL_11_0,
+            D3D_FEATURE_LEVEL_10_1,
+        };
+
+        HRESULT hr = S_OK;
+        for (const auto& [driverType, additionalFlags] : driverTypes)
+        {
+            hr = D3D11CreateDevice(
+                /* pAdapter */ nullptr,
+                /* DriverType */ driverType,
+                /* Software */ nullptr,
+                /* Flags */ deviceFlags | additionalFlags,
+                /* pFeatureLevels */ featureLevels.data(),
+                /* FeatureLevels */ gsl::narrow_cast<UINT>(featureLevels.size()),
+                /* SDKVersion */ D3D11_SDK_VERSION,
+                /* ppDevice */ _r.device.put(),
+                /* pFeatureLevel */ nullptr,
+                /* ppImmediateContext */ deviceContext.put());
+            if (SUCCEEDED(hr))
+            {
+                break;
+            }
+        }
+        THROW_IF_FAILED(hr);
+
+        _r.deviceContext = deviceContext.query<ID3D11DeviceContext1>();
+    }
+
+#ifndef NDEBUG
+    // D3D debug messages
+    if (deviceFlags & D3D11_CREATE_DEVICE_DEBUG)
+    {
+        const auto infoQueue = _r.device.query<ID3D11InfoQueue>();
+        for (const auto severity : std::array{ D3D11_MESSAGE_SEVERITY_CORRUPTION, D3D11_MESSAGE_SEVERITY_ERROR, D3D11_MESSAGE_SEVERITY_WARNING })
+        {
+            infoQueue->SetBreakOnSeverity(severity, true);
+        }
+    }
+#endif // NDEBUG
+
+    // Our constant buffer will never get resized
+    {
+        D3D11_BUFFER_DESC desc{};
+        desc.ByteWidth = sizeof(ConstBuffer);
+        desc.Usage = D3D11_USAGE_DEFAULT;
+        desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+        THROW_IF_FAILED(_r.device->CreateBuffer(&desc, nullptr, _r.constantBuffer.put()));
+    }
+
+    THROW_IF_FAILED(_r.device->CreateVertexShader(&shader_vs[0], sizeof(shader_vs), nullptr, _r.vertexShader.put()));
+    THROW_IF_FAILED(_r.device->CreatePixelShader(&shader_ps[0], sizeof(shader_ps), nullptr, _r.pixelShader.put()));
+
+    WI_ClearFlag(_api.invalidations, ApiInvalidations::Device);
+    WI_SetAllFlags(_api.invalidations, ApiInvalidations::SwapChain);
+}
+
+void AtlasEngine::_releaseSwapChain()
+{
+    // Flush() docs:
+    //   However, if an application must actually destroy an old swap chain and create a new swap chain,
+    //   the application must force the destruction of all objects that the application freed.
+    //   To force the destruction, call ID3D11DeviceContext::ClearState (or otherwise ensure
+    //   no views are bound to pipeline state), and then call Flush on the immediate context.
+    if (_r.swapChain && _r.deviceContext)
+    {
+        _r.frameLatencyWaitableObject.reset();
+        _r.swapChain.reset();
+        _r.renderTargetView.reset();
+        _r.deviceContext->ClearState();
+        _r.deviceContext->Flush();
+    }
+}
+
+void AtlasEngine::_createSwapChain()
+{
+    _releaseSwapChain();
+
+    // D3D swap chain setup (the thing that allows us to present frames on the screen)
+    {
+        const auto supportsFrameLatencyWaitableObject = IsWindows8Point1OrGreater();
+
+        // With C++20 we'll finally have designated initializers.
+        DXGI_SWAP_CHAIN_DESC1 desc{};
+        desc.Width = _api.sizeInPixel.x;
+        desc.Height = _api.sizeInPixel.y;
+        desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+        desc.SampleDesc.Count = 1;
+        desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+        desc.BufferCount = 2; // TODO: 3?
+        desc.Scaling = DXGI_SCALING_NONE;
+        desc.SwapEffect = _sr.isWindows10OrGreater ? DXGI_SWAP_EFFECT_FLIP_DISCARD : DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+        // * HWND swap chains can't do alpha.
+        // * If our background is opaque we can enable "independent" flips by setting DXGI_SWAP_EFFECT_FLIP_DISCARD and DXGI_ALPHA_MODE_IGNORE.
+        //   As our swap chain won't have to compose with DWM anymore it reduces the display latency dramatically.
+        desc.AlphaMode = _api.hwnd || _api.backgroundOpaqueMixin ? DXGI_ALPHA_MODE_IGNORE : DXGI_ALPHA_MODE_PREMULTIPLIED;
+        desc.Flags = supportsFrameLatencyWaitableObject ? DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT : 0;
+
+        wil::com_ptr<IDXGIFactory2> dxgiFactory;
+        THROW_IF_FAILED(CreateDXGIFactory1(IID_PPV_ARGS(dxgiFactory.addressof())));
+
+        if (_api.hwnd)
+        {
+            desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
+
+            if (FAILED(dxgiFactory->CreateSwapChainForHwnd(_r.device.get(), _api.hwnd, &desc, nullptr, nullptr, _r.swapChain.put())))
+            {
+                // Platform Update for Windows 7:
+                // DXGI_SCALING_NONE is not supported on Windows 7 or Windows Server 2008 R2 with the Platform Update for
+                // Windows 7 installed and causes CreateSwapChainForHwnd to return DXGI_ERROR_INVALID_CALL when called.
+                desc.Scaling = DXGI_SCALING_STRETCH;
+                THROW_IF_FAILED(dxgiFactory->CreateSwapChainForHwnd(_r.device.get(), _api.hwnd, &desc, nullptr, nullptr, _r.swapChain.put()));
+            }
+        }
+        else
+        {
+            // We can't link with dcomp.lib as dcomp.dll doesn't exist on Windows 7.
+            const wil::unique_hmodule module{ LoadLibraryExW(L"dcomp.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32) };
+            THROW_LAST_ERROR_IF(!module);
+            const auto DCompositionCreateSurfaceHandle = GetProcAddressByFunctionDeclaration(module.get(), DCompositionCreateSurfaceHandle);
+            THROW_LAST_ERROR_IF(!DCompositionCreateSurfaceHandle);
+
+            // As per: https://docs.microsoft.com/en-us/windows/win32/api/dcomp/nf-dcomp-dcompositioncreatesurfacehandle
+            static constexpr DWORD COMPOSITIONSURFACE_ALL_ACCESS = 0x0003L;
+            THROW_IF_FAILED(DCompositionCreateSurfaceHandle(COMPOSITIONSURFACE_ALL_ACCESS, nullptr, _api.swapChainHandle.put()));
+            THROW_IF_FAILED(dxgiFactory.query<IDXGIFactoryMedia>()->CreateSwapChainForCompositionSurfaceHandle(_r.device.get(), _api.swapChainHandle.get(), &desc, nullptr, _r.swapChain.put()));
+        }
+
+        if (supportsFrameLatencyWaitableObject)
+        {
+            const auto swapChain2 = _r.swapChain.query<IDXGISwapChain2>();
+            THROW_IF_FAILED(swapChain2->SetMaximumFrameLatency(1)); // TODO: 2?
+            _r.frameLatencyWaitableObject.reset(swapChain2->GetFrameLatencyWaitableObject());
+            THROW_LAST_ERROR_IF(!_r.frameLatencyWaitableObject);
+        }
+    }
+
+    // See documentation for IDXGISwapChain2::GetFrameLatencyWaitableObject method:
+    // > For every frame it renders, the app should wait on this handle before starting any rendering operations.
+    // > Note that this requirement includes the first frame the app renders with the swap chain.
+    WaitUntilCanRender();
+
+    if (_api.swapChainChangedCallback)
+    {
+        try
+        {
+            _api.swapChainChangedCallback();
+        }
+        CATCH_LOG();
+    }
+
+    WI_ClearFlag(_api.invalidations, ApiInvalidations::SwapChain);
+    WI_SetAllFlags(_api.invalidations, ApiInvalidations::Size | ApiInvalidations::Font);
+}
+
+void AtlasEngine::_recreateSizeDependentResources()
+{
+    // ResizeBuffer() docs:
+    //   Before you call ResizeBuffers, ensure that the application releases all references [...].
+    //   You can use ID3D11DeviceContext::ClearState to ensure that all [internal] references are released.
+    if (_r.renderTargetView)
+    {
+        _r.renderTargetView.reset();
+        _r.deviceContext->ClearState();
+        _r.deviceContext->Flush();
+        THROW_IF_FAILED(_r.swapChain->ResizeBuffers(0, _api.sizeInPixel.x, _api.sizeInPixel.y, DXGI_FORMAT_UNKNOWN, DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT));
+    }
+
+    // The RenderTargetView is later used with OMSetRenderTargets
+    // to tell D3D where stuff is supposed to be rendered at.
+    {
+        wil::com_ptr<ID3D11Texture2D> buffer;
+        THROW_IF_FAILED(_r.swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), buffer.put_void()));
+        THROW_IF_FAILED(_r.device->CreateRenderTargetView(buffer.get(), nullptr, _r.renderTargetView.put()));
+    }
+
+    // Tell D3D which parts of the render target will be visible.
+    // Everything outside of the viewport will be black.
+    //
+    // In the future this should cover the entire _api.sizeInPixel.x/_api.sizeInPixel.y.
+    // The pixel shader should draw the remaining content in the configured background color.
+    {
+        D3D11_VIEWPORT viewport{};
+        viewport.Width = static_cast<float>(_api.sizeInPixel.x);
+        viewport.Height = static_cast<float>(_api.sizeInPixel.y);
+        _r.deviceContext->RSSetViewports(1, &viewport);
+    }
+
+    if (_api.cellCount != _r.cellCount)
+    {
+        const auto totalCellCount = static_cast<size_t>(_api.cellCount.x) * static_cast<size_t>(_api.cellCount.y);
+        // Let's guess that every cell consists of a surrogate pair.
+        const auto projectedTextSize = static_cast<size_t>(_api.cellCount.x) * 2;
+        // IDWriteTextAnalyzer::GetGlyphs says:
+        //   The recommended estimate for the per-glyph output buffers is (3 * textLength / 2 + 16).
+        // We already set the textLength to twice the cell count.
+        const auto projectedGlyphSize = 3 * projectedTextSize + 16;
+
+        // This buffer is a bit larger than the others (multiple MB).
+        // Prevent a memory usage spike, by first deallocating and then allocating.
+        _r.cells = {};
+        // Our render loop heavily relies on memcpy() which is between 1.5x
+        // and 40x faster for allocations with an alignment of 32 or greater.
+        // (40x on AMD Zen1-3, which have a rep movsb performance issue. MSFT:33358259.)
+        _r.cells = Buffer<Cell, 32>{ totalCellCount };
+        _r.cellCount = _api.cellCount;
+
+        // .clear() doesn't free the memory of these buffers.
+        // This code allows them to shrink again.
+        _api.bufferLine = {};
+        _api.bufferLine.reserve(projectedTextSize);
+        _api.bufferLineColumn.reserve(projectedTextSize + 1);
+        _api.bufferLineMetadata = Buffer<BufferLineMetadata>{ _api.cellCount.x };
+        _api.analysisResults = {};
+
+        _api.clusterMap = Buffer<u16>{ projectedTextSize };
+        _api.textProps = Buffer<DWRITE_SHAPING_TEXT_PROPERTIES>{ projectedTextSize };
+        _api.glyphIndices = Buffer<u16>{ projectedGlyphSize };
+        _api.glyphProps = Buffer<DWRITE_SHAPING_GLYPH_PROPERTIES>{ projectedGlyphSize };
+
+        D3D11_BUFFER_DESC desc;
+        desc.ByteWidth = gsl::narrow<u32>(totalCellCount * sizeof(Cell)); // totalCellCount can theoretically be UINT32_MAX!
+        desc.Usage = D3D11_USAGE_DYNAMIC;
+        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+        desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
+        desc.StructureByteStride = sizeof(Cell);
+        THROW_IF_FAILED(_r.device->CreateBuffer(&desc, nullptr, _r.cellBuffer.put()));
+        THROW_IF_FAILED(_r.device->CreateShaderResourceView(_r.cellBuffer.get(), nullptr, _r.cellView.put()));
+    }
+
+    // We have called _r.deviceContext->ClearState() in the beginning and lost all D3D state.
+    // This forces us to set up everything up from scratch again.
+    _setShaderResources();
+
+    WI_ClearFlag(_api.invalidations, ApiInvalidations::Size);
+    WI_SetAllFlags(_r.invalidations, RenderInvalidations::ConstBuffer);
+}
+
+void AtlasEngine::_recreateFontDependentResources()
+{
+    {
+        // We're likely resizing the atlas anyways and can
+        // thus also release any of these buffers prematurely.
+        _r.d2dRenderTarget.reset(); // depends on _r.atlasScratchpad
+        _r.atlasScratchpad.reset();
+        _r.atlasView.reset();
+        _r.atlasBuffer.reset();
+    }
+
+    // D3D
+    {
+        // TODO: Consider using IDXGIAdapter3::QueryVideoMemoryInfo() and IDXGIAdapter3::RegisterVideoMemoryBudgetChangeNotificationEvent()
+        // That way we can make better to use of a user's available video memory.
+
+        static constexpr size_t sizePerPixel = 4;
+        static constexpr size_t sizeLimit = D3D10_REQ_RESOURCE_SIZE_IN_MEGABYTES * 1024 * 1024;
+        const size_t dimensionLimit = _r.device->GetFeatureLevel() >= D3D_FEATURE_LEVEL_11_0 ? D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION : D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION;
+        const size_t csx = _api.fontMetrics.cellSize.x;
+        const size_t csy = _api.fontMetrics.cellSize.y;
+        const auto xLimit = (dimensionLimit / csx) * csx;
+        const auto pixelsPerCellRow = xLimit * csy;
+        const auto yLimitDueToDimension = (dimensionLimit / csy) * csy;
+        const auto yLimitDueToSize = ((sizeLimit / sizePerPixel) / pixelsPerCellRow) * csy;
+        const auto yLimit = std::min(yLimitDueToDimension, yLimitDueToSize);
+        const auto scaling = GetScaling();
+
+        _r.cellSizeDIP.x = static_cast<float>(_api.fontMetrics.cellSize.x) / scaling;
+        _r.cellSizeDIP.y = static_cast<float>(_api.fontMetrics.cellSize.y) / scaling;
+        _r.cellSize = _api.fontMetrics.cellSize;
+        _r.cellCount = _api.cellCount;
+        // x/yLimit are strictly smaller than dimensionLimit, which is smaller than a u16.
+        _r.atlasSizeInPixelLimit = u16x2{ gsl::narrow_cast<u16>(xLimit), gsl::narrow_cast<u16>(yLimit) };
+        _r.atlasSizeInPixel = { 0, 0 };
+        // The first Cell at {0, 0} is always our cursor texture.
+        // --> The first glyph starts at {1, 0}.
+        _r.atlasPosition.x = _api.fontMetrics.cellSize.x;
+        _r.atlasPosition.y = 0;
+
+        _r.glyphs = {};
+        _r.glyphQueue = {};
+        _r.glyphQueue.reserve(64);
+    }
+    // D3D specifically for UpdateDpi()
+    // This compensates for the built in scaling factor in a XAML SwapChainPanel (CompositionScaleX/Y).
+    if (!_api.hwnd)
+    {
+        if (const auto swapChain2 = _r.swapChain.try_query<IDXGISwapChain2>())
+        {
+            const auto inverseScale = static_cast<float>(USER_DEFAULT_SCREEN_DPI) / static_cast<float>(_api.dpi);
+            DXGI_MATRIX_3X2_F matrix{};
+            matrix._11 = inverseScale;
+            matrix._22 = inverseScale;
+            THROW_IF_FAILED(swapChain2->SetMatrixTransform(&matrix));
+        }
+    }
+
+    // D2D
+    {
+        _r.underlinePos = _api.fontMetrics.underlinePos;
+        _r.strikethroughPos = _api.fontMetrics.strikethroughPos;
+        _r.lineThickness = _api.fontMetrics.lineThickness;
+        _r.dpi = _api.dpi;
+        _r.maxEncounteredCellCount = 0;
+        _r.scratchpadCellWidth = 0;
+    }
+    {
+        // See AtlasEngine::UpdateFont.
+        // It hardcodes indices 0/1/2 in fontAxisValues to the weight/italic/slant axes.
+        // If they're -1.0f they haven't been set by the user and must be filled by us.
+        // When we call SetFontAxisValues() we basically override (disable) DirectWrite's internal font axes,
+        // and if either of the 3 aren't set we'd make it impossible for the user to see bold/italic text.
+#pragma warning(suppress : 26494) // Variable 'standardAxes' is uninitialized. Always initialize an object (type.5).
+        std::array<DWRITE_FONT_AXIS_VALUE, 3> standardAxes;
+
+        if (!_api.fontAxisValues.empty())
+        {
+            Expects(_api.fontAxisValues.size() >= standardAxes.size());
+            memcpy(standardAxes.data(), _api.fontAxisValues.data(), sizeof(standardAxes));
+        }
+
+        const auto restoreFontAxisValues = wil::scope_exit([&]() noexcept {
+            if (!_api.fontAxisValues.empty())
+            {
+                memcpy(_api.fontAxisValues.data(), standardAxes.data(), sizeof(standardAxes));
+            }
+        });
+
+        for (auto italic = 0; italic < 2; ++italic)
+        {
+            for (auto bold = 0; bold < 2; ++bold)
+            {
+                const auto fontWeight = bold ? DWRITE_FONT_WEIGHT_BOLD : static_cast<DWRITE_FONT_WEIGHT>(_api.fontMetrics.fontWeight);
+                const auto fontStyle = italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
+                auto& textFormat = _r.textFormats[italic][bold];
+
+                THROW_IF_FAILED(_sr.dwriteFactory->CreateTextFormat(_api.fontMetrics.fontName.get(), nullptr, fontWeight, fontStyle, DWRITE_FONT_STRETCH_NORMAL, _api.fontMetrics.fontSizeInDIP, L"", textFormat.put()));
+                textFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
+                textFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
+
+                // DWRITE_LINE_SPACING_METHOD_UNIFORM:
+                // > Lines are explicitly set to uniform spacing, regardless of contained font sizes.
+                // > This can be useful to avoid the uneven appearance that can occur from font fallback.
+                // We want that. Otherwise fallback fonts might be rendered with an incorrect baseline and get cut off vertically.
+                THROW_IF_FAILED(textFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, _r.cellSizeDIP.y, _api.fontMetrics.baselineInDIP));
+
+                if (!_api.fontAxisValues.empty())
+                {
+                    if (const auto textFormat3 = textFormat.try_query<IDWriteTextFormat3>())
+                    {
+                        // The wght axis defaults to the font weight.
+                        _api.fontAxisValues[0].value = bold || standardAxes[0].value == -1.0f ? static_cast<float>(fontWeight) : standardAxes[0].value;
+                        // The ital axis defaults to 1 if this is italic and 0 otherwise.
+                        _api.fontAxisValues[1].value = italic ? 1.0f : (standardAxes[1].value == -1.0f ? 0.0f : standardAxes[1].value);
+                        // The slnt axis defaults to -12 if this is italic and 0 otherwise.
+                        _api.fontAxisValues[2].value = italic ? -12.0f : (standardAxes[2].value == -1.0f ? 0.0f : standardAxes[2].value);
+
+                        THROW_IF_FAILED(textFormat3->SetFontAxisValues(_api.fontAxisValues.data(), gsl::narrow_cast<u32>(_api.fontAxisValues.size())));
+                        _r.textFormatAxes[italic][bold] = { _api.fontAxisValues.data(), _api.fontAxisValues.size() };
+                    }
+                }
+            }
+        }
+    }
+    {
+        _r.typography.reset();
+
+        if (!_api.fontFeatures.empty())
+        {
+            _sr.dwriteFactory->CreateTypography(_r.typography.addressof());
+            for (const auto& v : _api.fontFeatures)
+            {
+                THROW_IF_FAILED(_r.typography->AddFontFeature(v));
+            }
+        }
+    }
+
+    WI_ClearFlag(_api.invalidations, ApiInvalidations::Font);
+    WI_SetAllFlags(_r.invalidations, RenderInvalidations::Cursor | RenderInvalidations::ConstBuffer);
+}
+
+IDWriteTextFormat* AtlasEngine::_getTextFormat(bool bold, bool italic) const noexcept
+{
+    return _r.textFormats[italic][bold].get();
+}
+
+const AtlasEngine::Buffer<DWRITE_FONT_AXIS_VALUE>& AtlasEngine::_getTextFormatAxis(bool bold, bool italic) const noexcept
+{
+    return _r.textFormatAxes[italic][bold];
+}
+
+AtlasEngine::Cell* AtlasEngine::_getCell(u16 x, u16 y) noexcept
+{
+    assert(x < _r.cellCount.x);
+    assert(y < _r.cellCount.y);
+    return _r.cells.data() + static_cast<size_t>(_r.cellCount.x) * y + x;
+}
+
+void AtlasEngine::_setCellFlags(SMALL_RECT coords, CellFlags mask, CellFlags bits) noexcept
+{
+    assert(coords.Left <= coords.Right);
+    assert(coords.Top <= coords.Bottom);
+    assert(coords.Right <= _r.cellCount.x);
+    assert(coords.Bottom <= _r.cellCount.y);
+
+    const auto filter = ~mask;
+    const auto width = static_cast<size_t>(coords.Right) - coords.Left;
+    const auto height = static_cast<size_t>(coords.Bottom) - coords.Top;
+    const auto stride = static_cast<size_t>(_r.cellCount.x);
+    auto row = _r.cells.data() + static_cast<size_t>(_r.cellCount.x) * coords.Top + coords.Left;
+    const auto end = row + height * stride;
+
+    for (; row != end; row += stride)
+    {
+        const auto dataEnd = row + width;
+        for (auto data = row; data != dataEnd; ++data)
+        {
+            const auto current = data->flags;
+            data->flags = (current & filter) | bits;
+        }
+    }
+}
+
+AtlasEngine::u16x2 AtlasEngine::_allocateAtlasTile() noexcept
+{
+    const auto ret = _r.atlasPosition;
+
+    _r.atlasPosition.x += _r.cellSize.x;
+    if (_r.atlasPosition.x >= _r.atlasSizeInPixelLimit.x)
+    {
+        _r.atlasPosition.x = 0;
+        _r.atlasPosition.y += _r.cellSize.y;
+        if (_r.atlasPosition.y >= _r.atlasSizeInPixelLimit.y)
+        {
+            _r.atlasPosition.x = _r.cellSize.x;
+            _r.atlasPosition.y = 0;
+            showOOMWarning();
+        }
+    }
+
+    return ret;
+}
+
+void AtlasEngine::_flushBufferLine()
+{
+    if (_api.bufferLine.empty())
+    {
+        return;
+    }
+
+    const auto cleanup = wil::scope_exit([this]() noexcept {
+        _api.bufferLine.clear();
+        _api.bufferLineColumn.clear();
+    });
+
+    // This would seriously blow us up otherwise.
+    Expects(_api.bufferLineColumn.size() == _api.bufferLine.size() + 1);
+
+    // NOTE:
+    // This entire function is one huge hack to see if it works.
+
+    // UH OH UNICODE MADNESS AHEAD
+    //
+    // # What do we want?
+    //
+    // Segment a line of text (_api.bufferLine) into unicode "clusters".
+    // Each cluster is one "whole" glyph with diacritics, ligatures, zero width joiners
+    // and whatever else, that should be cached as a whole in our texture atlas.
+    //
+    // # How do we get that?
+    //
+    // ## The unfortunate preface
+    //
+    // DirectWrite can be "reluctant" to segment text into clusters and I found no API which offers simply that.
+    // What it offers are a large number of low level APIs that can sort of be used in combination to do this.
+    // The resulting text parsing is very slow unfortunately, consuming up to 95% of rendering time in extreme cases.
+    //
+    // ## The actual approach
+    //
+    // DirectWrite has 2 APIs which can segment text properly (including ligatures and zero width joiners):
+    // * IDWriteTextAnalyzer1::GetTextComplexity
+    // * IDWriteTextAnalyzer::GetGlyphs
+    //
+    // Both APIs require us to attain an IDWriteFontFace as the functions themselves don't handle font fallback.
+    // This forces us to call IDWriteFontFallback::MapCharacters first.
+    //
+    // Additionally IDWriteTextAnalyzer::GetGlyphs requires an instance of DWRITE_SCRIPT_ANALYSIS,
+    // which can only be attained by running IDWriteTextAnalyzer::AnalyzeScript first.
+    //
+    // Font fallback with IDWriteFontFallback::MapCharacters is very slow.
+
+    const auto textFormat = _getTextFormat(_api.attributes.bold, _api.attributes.italic);
+    const auto& textFormatAxis = _getTextFormatAxis(_api.attributes.bold, _api.attributes.italic);
+
+    TextAnalyzer atlasAnalyzer{ _api.bufferLine, _api.analysisResults };
+
+    wil::com_ptr<IDWriteFontCollection> fontCollection;
+    THROW_IF_FAILED(textFormat->GetFontCollection(fontCollection.addressof()));
+
+    wil::com_ptr<IDWriteFontFace> mappedFontFace;
+
+#pragma warning(suppress : 26494) // Variable 'mappedEnd' is uninitialized. Always initialize an object (type.5).
+    for (u32 idx = 0, mappedEnd; idx < _api.bufferLine.size(); idx = mappedEnd)
+    {
+        float scale = 1.0f;
+
+        if (_sr.systemFontFallback)
+        {
+            u32 mappedLength = 0;
+
+            if (textFormatAxis)
+            {
+                wil::com_ptr<IDWriteFontFace5> fontFace5;
+                THROW_IF_FAILED(_sr.systemFontFallback.query<IDWriteFontFallback1>()->MapCharacters(
+                    /* analysisSource */ &atlasAnalyzer,
+                    /* textPosition */ idx,
+                    /* textLength */ gsl::narrow_cast<u32>(_api.bufferLine.size()) - idx,
+                    /* baseFontCollection */ fontCollection.get(),
+                    /* baseFamilyName */ _api.fontMetrics.fontName.get(),
+                    /* fontAxisValues */ textFormatAxis.data(),
+                    /* fontAxisValueCount */ gsl::narrow_cast<u32>(textFormatAxis.size()),
+                    /* mappedLength */ &mappedLength,
+                    /* scale */ &scale,
+                    /* mappedFontFace */ fontFace5.put()));
+                mappedFontFace = std::move(fontFace5);
+            }
+            else
+            {
+                const auto baseWeight = _api.attributes.bold ? DWRITE_FONT_WEIGHT_BOLD : static_cast<DWRITE_FONT_WEIGHT>(_api.fontMetrics.fontWeight);
+                const auto baseStyle = _api.attributes.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
+                wil::com_ptr<IDWriteFont> font;
+
+                THROW_IF_FAILED(_sr.systemFontFallback->MapCharacters(
+                    /* analysisSource     */ &atlasAnalyzer,
+                    /* textPosition       */ idx,
+                    /* textLength         */ gsl::narrow_cast<u32>(_api.bufferLine.size()) - idx,
+                    /* baseFontCollection */ fontCollection.get(),
+                    /* baseFamilyName     */ _api.fontMetrics.fontName.get(),
+                    /* baseWeight         */ baseWeight,
+                    /* baseStyle          */ baseStyle,
+                    /* baseStretch        */ DWRITE_FONT_STRETCH_NORMAL,
+                    /* mappedLength       */ &mappedLength,
+                    /* mappedFont         */ font.addressof(),
+                    /* scale              */ &scale));
+
+                mappedFontFace.reset();
+                if (font)
+                {
+                    THROW_IF_FAILED(font->CreateFontFace(mappedFontFace.addressof()));
+                }
+            }
+
+            mappedEnd = idx + mappedLength;
+
+            if (!mappedFontFace)
+            {
+                // Task: Replace all characters in this range with unicode replacement characters.
+                // Input (where "n" is a narrow and "ww" is a wide character):
+                //    _api.bufferLine       = "nwwnnw"
+                //    _api.bufferLineColumn = {0, 1, 1, 2, 3, 4, 4, 5}
+                //                             n  w  w  n  n  w  w
+                // Solution:
+                //   Iterate through bufferLineColumn until the value changes, because this indicates we passed over a
+                //   complete (narrow or wide) cell. To do so we'll use col1 (previous column) and col2 (next column).
+                //   Then we emit a replacement character by telling _emplaceGlyph that this range has no font face.
+                auto pos1 = idx;
+                auto col1 = _api.bufferLineColumn[pos1];
+                for (auto pos2 = idx + 1; pos2 <= mappedEnd; ++pos2)
+                {
+                    if (const auto col2 = _api.bufferLineColumn[pos2]; col1 != col2)
+                    {
+                        _emplaceGlyph(nullptr, scale, pos1, pos2);
+                        pos1 = pos2;
+                        col1 = col2;
+                    }
+                }
+
+                continue;
+            }
+        }
+        else
+        {
+            if (!mappedFontFace)
+            {
+                const auto baseWeight = _api.attributes.bold ? DWRITE_FONT_WEIGHT_BOLD : static_cast<DWRITE_FONT_WEIGHT>(_api.fontMetrics.fontWeight);
+                const auto baseStyle = _api.attributes.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
+
+                wil::com_ptr<IDWriteFontFamily> fontFamily;
+                THROW_IF_FAILED(fontCollection->GetFontFamily(0, fontFamily.addressof()));
+
+                wil::com_ptr<IDWriteFont> font;
+                THROW_IF_FAILED(fontFamily->GetFirstMatchingFont(baseWeight, DWRITE_FONT_STRETCH_NORMAL, baseStyle, font.addressof()));
+
+                THROW_IF_FAILED(font->CreateFontFace(mappedFontFace.put()));
+            }
+
+            mappedEnd = gsl::narrow_cast<u32>(_api.bufferLine.size());
+        }
+
+        // We can reuse idx here, as it'll be reset to "idx = mappedEnd" in the outer loop anyways.
+        for (u32 complexityLength = 0; idx < mappedEnd; idx += complexityLength)
+        {
+            BOOL isTextSimple;
+            THROW_IF_FAILED(_sr.textAnalyzer->GetTextComplexity(_api.bufferLine.data() + idx, mappedEnd - idx, mappedFontFace.get(), &isTextSimple, &complexityLength, _api.glyphIndices.data()));
+
+            if (isTextSimple)
+            {
+                for (size_t i = 0; i < complexityLength; ++i)
+                {
+                    _emplaceGlyph(mappedFontFace.get(), scale, idx + i, idx + i + 1u);
+                }
+            }
+            else
+            {
+                _api.analysisResults.clear();
+                THROW_IF_FAILED(_sr.textAnalyzer->AnalyzeScript(&atlasAnalyzer, idx, complexityLength, &atlasAnalyzer));
+                //_sr.textAnalyzer->AnalyzeBidi(&atlasAnalyzer, idx, complexityLength, &atlasAnalyzer);
+
+                for (const auto& a : _api.analysisResults)
+                {
+                    DWRITE_SCRIPT_ANALYSIS scriptAnalysis{ a.script, static_cast<DWRITE_SCRIPT_SHAPES>(a.shapes) };
+                    u32 actualGlyphCount = 0;
+
+#pragma warning(push)
+#pragma warning(disable : 26494) // Variable '...' is uninitialized. Always initialize an object (type.5).
+                    // None of these variables need to be initialized.
+                    // features/featureRangeLengths are marked _In_reads_opt_(featureRanges).
+                    // featureRanges is only > 0 when we also initialize all these variables.
+                    DWRITE_TYPOGRAPHIC_FEATURES feature;
+                    const DWRITE_TYPOGRAPHIC_FEATURES* features;
+                    u32 featureRangeLengths;
+#pragma warning(pop)
+                    u32 featureRanges = 0;
+
+                    if (!_api.fontFeatures.empty())
+                    {
+                        feature.features = _api.fontFeatures.data();
+                        feature.featureCount = gsl::narrow_cast<u32>(_api.fontFeatures.size());
+                        features = &feature;
+                        featureRangeLengths = a.textLength;
+                        featureRanges = 1;
+                    }
+
+                    if (_api.clusterMap.size() < a.textLength)
+                    {
+                        _api.clusterMap = Buffer<u16>{ a.textLength };
+                        _api.textProps = Buffer<DWRITE_SHAPING_TEXT_PROPERTIES>{ a.textLength };
+                    }
+
+                    for (auto retry = 0;;)
+                    {
+                        const auto hr = _sr.textAnalyzer->GetGlyphs(
+                            /* textString          */ _api.bufferLine.data() + a.textPosition,
+                            /* textLength          */ a.textLength,
+                            /* fontFace            */ mappedFontFace.get(),
+                            /* isSideways          */ false,
+                            /* isRightToLeft       */ a.bidiLevel & 1,
+                            /* scriptAnalysis      */ &scriptAnalysis,
+                            /* localeName          */ nullptr,
+                            /* numberSubstitution  */ nullptr,
+                            /* features            */ &features,
+                            /* featureRangeLengths */ &featureRangeLengths,
+                            /* featureRanges       */ featureRanges,
+                            /* maxGlyphCount       */ gsl::narrow_cast<u32>(_api.glyphProps.size()),
+                            /* clusterMap          */ _api.clusterMap.data(),
+                            /* textProps           */ _api.textProps.data(),
+                            /* glyphIndices        */ _api.glyphIndices.data(),
+                            /* glyphProps          */ _api.glyphProps.data(),
+                            /* actualGlyphCount    */ &actualGlyphCount);
+
+                        if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) && ++retry < 8)
+                        {
+                            // Grow factor 1.5x.
+                            auto size = _api.glyphProps.size();
+                            size = size + (size >> 1);
+                            // Overflow check.
+                            Expects(size > _api.glyphProps.size());
+                            _api.glyphIndices = Buffer<u16>{ size };
+                            _api.glyphProps = Buffer<DWRITE_SHAPING_GLYPH_PROPERTIES>(size);
+                            continue;
+                        }
+
+                        THROW_IF_FAILED(hr);
+                        break;
+                    }
+
+                    _api.textProps[a.textLength - 1].canBreakShapingAfter = 1;
+
+                    size_t beg = 0;
+                    for (size_t i = 0; i < a.textLength; ++i)
+                    {
+                        if (_api.textProps[i].canBreakShapingAfter)
+                        {
+                            _emplaceGlyph(mappedFontFace.get(), scale, a.textPosition + beg, a.textPosition + i + 1);
+                            beg = i + 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+void AtlasEngine::_emplaceGlyph(IDWriteFontFace* fontFace, float scale, size_t bufferPos1, size_t bufferPos2)
+{
+    static constexpr auto replacement = L'\uFFFD';
+
+    // This would seriously blow us up otherwise.
+    Expects(bufferPos1 < bufferPos2 && bufferPos2 <= _api.bufferLine.size());
+
+    const auto chars = fontFace ? &_api.bufferLine[bufferPos1] : &replacement;
+    const auto charCount = fontFace ? bufferPos2 - bufferPos1 : 1;
+
+    // _flushBufferLine() ensures that bufferLineColumn.size() > bufferLine.size().
+    const auto x1 = _api.bufferLineColumn[bufferPos1];
+    const auto x2 = _api.bufferLineColumn[bufferPos2];
+
+    Expects(x1 < x2 && x2 <= _api.cellCount.x);
+
+    const u16 cellCount = x2 - x1;
+
+    auto attributes = _api.attributes;
+    attributes.cellCount = cellCount;
+
+    const auto [it, inserted] = _r.glyphs.emplace(std::piecewise_construct, std::forward_as_tuple(attributes, gsl::narrow<u16>(charCount), chars), std::forward_as_tuple());
+    const auto& key = it->first;
+    auto& value = it->second;
+
+    if (inserted)
+    {
+        // Do fonts exist *in practice* which contain both colored and uncolored glyphs? I'm pretty sure...
+        // However doing it properly means using either of:
+        // * IDWriteFactory2::TranslateColorGlyphRun
+        // * IDWriteFactory4::TranslateColorGlyphRun
+        // * IDWriteFontFace4::GetGlyphImageData
+        //
+        // For the first two I wonder how one is supposed to restitch the 27 required parameters from a
+        // partial (!) text range returned by GetGlyphs(). Our caller breaks the GetGlyphs() result up
+        // into runs of characters up until the first canBreakShapingAfter == true after all.
+        // There's no documentation for it and I'm sure I'd mess it up.
+        // For very obvious reasons I didn't want to write this code.
+        //
+        // IDWriteFontFace4::GetGlyphImageData seems like the best approach and DirectWrite uses the
+        // same code that GetGlyphImageData uses to implement TranslateColorGlyphRun (well partially).
+        // However, it's a heavy operation and parses the font file on disk on every call (TranslateColorGlyphRun doesn't).
+        // For less obvious reasons I didn't want to write this code either.
+        //
+        // So this is a job for future me/someone.
+        // Bonus points for doing it without impacting performance.
+        auto flags = CellFlags::None;
+        if (fontFace)
+        {
+            const auto fontFace2 = wil::try_com_query<IDWriteFontFace2>(fontFace);
+            WI_SetFlagIf(flags, CellFlags::ColoredGlyph, fontFace2 && fontFace2->IsColorFont());
+        }
+
+        const auto coords = value.initialize(flags, cellCount);
+        for (u16 i = 0; i < cellCount; ++i)
+        {
+            coords[i] = _allocateAtlasTile();
+        }
+
+        _r.glyphQueue.push_back(AtlasQueueItem{ &key, &value, scale });
+        _r.maxEncounteredCellCount = std::max(_r.maxEncounteredCellCount, cellCount);
+    }
+
+    const auto valueData = value.data();
+    const auto coords = &valueData->coords[0];
+    const auto flags = valueData->flags | _api.bufferLineMetadata[x1].flags;
+    const auto color = _api.bufferLineMetadata[x1].colors;
+    const auto data = _getCell(x1, _api.currentRow);
+
+    for (u32 i = 0; i < cellCount; ++i)
+    {
+        data[i].tileIndex = coords[i];
+        data[i].flags = flags;
+        data[i].color = color;
+    }
+}
diff --git a/src/renderer/atlas/AtlasEngine.h b/src/renderer/atlas/AtlasEngine.h
new file mode 100644
index 000000000..8b9b6d0ca
--- /dev/null
+++ b/src/renderer/atlas/AtlasEngine.h
@@ -0,0 +1,761 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+#include <d2d1.h>
+#include <d3d11_1.h>
+#include <dwrite_3.h>
+
+#include "../../renderer/inc/IRenderEngine.hpp"
+
+namespace Microsoft::Console::Render
+{
+    class AtlasEngine final : public IRenderEngine
+    {
+    public:
+        explicit AtlasEngine();
+
+        AtlasEngine(const AtlasEngine&) = delete;
+        AtlasEngine& operator=(const AtlasEngine&) = delete;
+
+        // IRenderEngine
+        [[nodiscard]] HRESULT StartPaint() noexcept override;
+        [[nodiscard]] HRESULT EndPaint() noexcept override;
+        [[nodiscard]] bool RequiresContinuousRedraw() noexcept override;
+        void WaitUntilCanRender() noexcept override;
+        [[nodiscard]] HRESULT Present() noexcept override;
+        [[nodiscard]] HRESULT PrepareForTeardown(_Out_ bool* pForcePaint) noexcept override;
+        [[nodiscard]] HRESULT ScrollFrame() noexcept override;
+        [[nodiscard]] HRESULT Invalidate(const SMALL_RECT* psrRegion) noexcept override;
+        [[nodiscard]] HRESULT InvalidateCursor(const SMALL_RECT* psrRegion) noexcept override;
+        [[nodiscard]] HRESULT InvalidateSystem(const RECT* prcDirtyClient) noexcept override;
+        [[nodiscard]] HRESULT InvalidateSelection(const std::vector<SMALL_RECT>& rectangles) noexcept override;
+        [[nodiscard]] HRESULT InvalidateScroll(const COORD* pcoordDelta) noexcept override;
+        [[nodiscard]] HRESULT InvalidateAll() noexcept override;
+        [[nodiscard]] HRESULT InvalidateCircling(_Out_ bool* pForcePaint) noexcept override;
+        [[nodiscard]] HRESULT InvalidateTitle(std::wstring_view proposedTitle) noexcept override;
+        [[nodiscard]] HRESULT PrepareRenderInfo(const RenderFrameInfo& info) noexcept override;
+        [[nodiscard]] HRESULT ResetLineTransform() noexcept override;
+        [[nodiscard]] HRESULT PrepareLineTransform(LineRendition lineRendition, size_t targetRow, size_t viewportLeft) noexcept override;
+        [[nodiscard]] HRESULT PaintBackground() noexcept override;
+        [[nodiscard]] HRESULT PaintBufferLine(gsl::span<const Cluster> clusters, COORD coord, bool fTrimLeft, bool lineWrapped) noexcept override;
+        [[nodiscard]] HRESULT PaintBufferGridLines(GridLineSet lines, COLORREF color, size_t cchLine, COORD coordTarget) noexcept override;
+        [[nodiscard]] HRESULT PaintSelection(SMALL_RECT rect) noexcept override;
+        [[nodiscard]] HRESULT PaintCursor(const CursorOptions& options) noexcept override;
+        [[nodiscard]] HRESULT UpdateDrawingBrushes(const TextAttribute& textAttributes, gsl::not_null<IRenderData*> pData, bool usingSoftFont, bool isSettingDefaultBrushes) noexcept override;
+        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo) noexcept override;
+        [[nodiscard]] HRESULT UpdateSoftFont(gsl::span<const uint16_t> bitPattern, SIZE cellSize, size_t centeringHint) noexcept override;
+        [[nodiscard]] HRESULT UpdateDpi(int iDpi) noexcept override;
+        [[nodiscard]] HRESULT UpdateViewport(SMALL_RECT srNewViewport) noexcept override;
+        [[nodiscard]] HRESULT GetProposedFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo, int iDpi) noexcept override;
+        [[nodiscard]] HRESULT GetDirtyArea(gsl::span<const til::rectangle>& area) noexcept override;
+        [[nodiscard]] HRESULT GetFontSize(_Out_ COORD* pFontSize) noexcept override;
+        [[nodiscard]] HRESULT IsGlyphWideByFont(std::wstring_view glyph, _Out_ bool* pResult) noexcept override;
+        [[nodiscard]] HRESULT UpdateTitle(std::wstring_view newTitle) noexcept override;
+
+        // DxRenderer - getter
+        HRESULT Enable() noexcept override;
+        [[nodiscard]] bool GetRetroTerminalEffect() const noexcept override;
+        [[nodiscard]] float GetScaling() const noexcept override;
+        [[nodiscard]] HANDLE GetSwapChainHandle() override;
+        [[nodiscard]] Types::Viewport GetViewportInCharacters(const Types::Viewport& viewInPixels) const noexcept override;
+        [[nodiscard]] Types::Viewport GetViewportInPixels(const Types::Viewport& viewInCharacters) const noexcept override;
+        // DxRenderer - setter
+        void SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept override;
+        void SetCallback(std::function<void()> pfn) noexcept override;
+        void SetDefaultTextBackgroundOpacity(float opacity) noexcept override;
+        void SetForceFullRepaintRendering(bool enable) noexcept override;
+        [[nodiscard]] HRESULT SetHwnd(HWND hwnd) noexcept override;
+        void SetPixelShaderPath(std::wstring_view value) noexcept override;
+        void SetRetroTerminalEffect(bool enable) noexcept override;
+        void SetSelectionBackground(COLORREF color, float alpha = 0.5f) noexcept override;
+        void SetSoftwareRendering(bool enable) noexcept override;
+        void SetIntenseIsBold(bool enable) noexcept override;
+        void SetWarningCallback(std::function<void(HRESULT)> pfn) noexcept override;
+        [[nodiscard]] HRESULT SetWindowSize(SIZE pixels) noexcept override;
+        void ToggleShaderEffects() noexcept override;
+        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& pfiFontInfoDesired, FontInfo& fiFontInfo, const std::unordered_map<std::wstring_view, uint32_t>& features, const std::unordered_map<std::wstring_view, float>& axes) noexcept override;
+        void UpdateHyperlinkHoveredId(uint16_t hoveredId) noexcept override;
+
+        // Some helper classes for the implementation.
+        // public because I don't want to sprinkle the code with friends.
+    public:
+#define ATLAS_POD_OPS(type)                                    \
+    constexpr bool operator==(const type& rhs) const noexcept  \
+    {                                                          \
+        return __builtin_memcmp(this, &rhs, sizeof(rhs)) == 0; \
+    }                                                          \
+                                                               \
+    constexpr bool operator!=(const type& rhs) const noexcept  \
+    {                                                          \
+        return __builtin_memcmp(this, &rhs, sizeof(rhs)) != 0; \
+    }
+
+#define ATLAS_FLAG_OPS(type, underlying)                                                                                                                    \
+    friend constexpr type operator~(type v) noexcept { return static_cast<type>(~static_cast<underlying>(v)); }                                             \
+    friend constexpr type operator|(type lhs, type rhs) noexcept { return static_cast<type>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs)); } \
+    friend constexpr type operator&(type lhs, type rhs) noexcept { return static_cast<type>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs)); } \
+    friend constexpr void operator|=(type& lhs, type rhs) noexcept { lhs = lhs | rhs; }                                                                     \
+    friend constexpr void operator&=(type& lhs, type rhs) noexcept { lhs = lhs & rhs; }
+
+        template<typename T>
+        struct vec2
+        {
+            T x{};
+            T y{};
+
+            ATLAS_POD_OPS(vec2)
+
+            constexpr vec2 operator/(const vec2& rhs) noexcept
+            {
+                assert(rhs.x != 0 && rhs.y != 0);
+                return { gsl::narrow_cast<T>(x / rhs.x), gsl::narrow_cast<T>(y / rhs.y) };
+            }
+        };
+
+        template<typename T>
+        struct vec4
+        {
+            T x{};
+            T y{};
+            T z{};
+            T w{};
+
+            ATLAS_POD_OPS(vec4)
+        };
+
+        template<typename T>
+        struct rect
+        {
+            T left{};
+            T top{};
+            T right{};
+            T bottom{};
+
+            ATLAS_POD_OPS(rect)
+
+            constexpr bool non_empty() noexcept
+            {
+                return (left < right) & (top < bottom);
+            }
+        };
+
+        using u8 = uint8_t;
+
+        using u16 = uint16_t;
+        using u16x2 = vec2<u16>;
+        using u16r = rect<u16>;
+
+        using i16 = int16_t;
+
+        using u32 = uint32_t;
+        using u32x2 = vec2<u32>;
+
+        using i32 = int32_t;
+
+        using f32 = float;
+        using f32x2 = vec2<f32>;
+        using f32x4 = vec4<f32>;
+
+        struct TextAnalyzerResult
+        {
+            u32 textPosition = 0;
+            u32 textLength = 0;
+
+            // These 2 fields represent DWRITE_SCRIPT_ANALYSIS.
+            // Not using DWRITE_SCRIPT_ANALYSIS drops the struct size from 20 down to 12 bytes.
+            u16 script = 0;
+            u8 shapes = 0;
+
+            u8 bidiLevel = 0;
+        };
+
+    private:
+        template<typename T, size_t Alignment = alignof(T)>
+        struct Buffer
+        {
+            constexpr Buffer() noexcept = default;
+
+            explicit Buffer(size_t size) :
+                _data{ allocate(size) },
+                _size{ size }
+            {
+            }
+
+            Buffer(const T* data, size_t size) :
+                _data{ allocate(size) },
+                _size{ size }
+            {
+                static_assert(std::is_trivially_copyable_v<T>);
+                memcpy(_data, data, size * sizeof(T));
+            }
+
+            ~Buffer()
+            {
+                deallocate(_data);
+            }
+
+            Buffer(Buffer&& other) noexcept :
+                _data{ std::exchange(other._data, nullptr) },
+                _size{ std::exchange(other._size, 0) }
+            {
+            }
+
+#pragma warning(suppress : 26432) // If you define or delete any default operation in the type '...', define or delete them all (c.21).
+            Buffer& operator=(Buffer&& other) noexcept
+            {
+                deallocate(_data);
+                _data = std::exchange(other._data, nullptr);
+                _size = std::exchange(other._size, 0);
+                return *this;
+            }
+
+            explicit operator bool() const noexcept
+            {
+                return _data != nullptr;
+            }
+
+            T& operator[](size_t index) noexcept
+            {
+                assert(index < _size);
+                return _data[index];
+            }
+
+            const T& operator[](size_t index) const noexcept
+            {
+                assert(index < _size);
+                return _data[index];
+            }
+
+            T* data() noexcept
+            {
+                return _data;
+            }
+
+            const T* data() const noexcept
+            {
+                return _data;
+            }
+
+            size_t size() const noexcept
+            {
+                return _size;
+            }
+
+        private:
+            // These two functions don't need to use scoped objects or standard allocators,
+            // since this class is in fact an scoped allocator object itself.
+#pragma warning(push)
+#pragma warning(disable : 26402) // Return a scoped object instead of a heap-allocated if it has a move constructor (r.3).
+#pragma warning(disable : 26409) // Avoid calling new and delete explicitly, use std::make_unique<T> instead (r.11).
+            static T* allocate(size_t size)
+            {
+                if constexpr (Alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                {
+                    return static_cast<T*>(::operator new(size * sizeof(T)));
+                }
+                else
+                {
+                    return static_cast<T*>(::operator new(size * sizeof(T), static_cast<std::align_val_t>(Alignment)));
+                }
+            }
+
+            static void deallocate(T* data) noexcept
+            {
+                if constexpr (Alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                {
+                    ::operator delete(data);
+                }
+                else
+                {
+                    ::operator delete(data, static_cast<std::align_val_t>(Alignment));
+                }
+            }
+#pragma warning(pop)
+
+            T* _data = nullptr;
+            size_t _size = 0;
+        };
+
+        // This structure works similar to how std::string works:
+        // You can think of a std::string as a structure consisting of:
+        //   char*  data;
+        //   size_t size;
+        //   size_t capacity;
+        // where data is some backing memory allocated on the heap.
+        //
+        // But std::string employs an optimization called "small string optimization" (SSO).
+        // To simplify things it could be explained as:
+        // If the string capacity is small, then the characters are stored inside the "data"
+        // pointer and you make sure to set the lowest bit in the pointer one way or another.
+        // Heap allocations are always aligned by at least 4-8 bytes on any platform.
+        // If the address of the "data" pointer is not even you know data is stored inline.
+        template<typename T>
+        union SmallObjectOptimizer
+        {
+            static_assert(std::is_trivially_copyable_v<T>);
+            static_assert(std::has_unique_object_representations_v<T>);
+
+            T* allocated = nullptr;
+            T inlined;
+
+            constexpr SmallObjectOptimizer() = default;
+
+            SmallObjectOptimizer(const SmallObjectOptimizer& other)
+            {
+                const auto otherData = other.data();
+                const auto otherSize = other.size();
+                const auto data = initialize(otherSize);
+                memcpy(data, otherData, otherSize);
+            }
+
+            SmallObjectOptimizer& operator=(const SmallObjectOptimizer& other)
+            {
+                if (this != &other)
+                {
+                    delete this;
+                    new (this) SmallObjectOptimizer(other);
+                }
+                return &this;
+            }
+
+            SmallObjectOptimizer(SmallObjectOptimizer&& other) noexcept
+            {
+                memcpy(this, &other, std::max(sizeof(allocated), sizeof(inlined)));
+                other.allocated = nullptr;
+            }
+
+            SmallObjectOptimizer& operator=(SmallObjectOptimizer&& other) noexcept
+            {
+                return *new (this) SmallObjectOptimizer(other);
+            }
+
+            ~SmallObjectOptimizer()
+            {
+                if (!is_inline())
+                {
+#pragma warning(suppress : 26408) // Avoid malloc() and free(), prefer the nothrow version of new with delete (r.10).
+                    free(allocated);
+                }
+            }
+
+            T* initialize(size_t byteSize)
+            {
+                if (would_inline(byteSize))
+                {
+                    return &inlined;
+                }
+
+#pragma warning(suppress : 26408) // Avoid malloc() and free(), prefer the nothrow version of new with delete (r.10).
+                allocated = THROW_IF_NULL_ALLOC(static_cast<T*>(malloc(byteSize)));
+                return allocated;
+            }
+
+            constexpr bool would_inline(size_t byteSize) const noexcept
+            {
+                return byteSize <= sizeof(T);
+            }
+
+            bool is_inline() const noexcept
+            {
+                return (__builtin_bit_cast(uintptr_t, allocated) & 1) != 0;
+            }
+
+            const T* data() const noexcept
+            {
+                return is_inline() ? &inlined : allocated;
+            }
+
+            size_t size() const noexcept
+            {
+                return is_inline() ? sizeof(inlined) : _msize(allocated);
+            }
+        };
+
+        struct FontMetrics
+        {
+            wil::unique_process_heap_string fontName;
+            float baselineInDIP = 0.0f;
+            float fontSizeInDIP = 0.0f;
+            u16x2 cellSize;
+            u16 fontWeight = 0;
+            u16 underlinePos = 0;
+            u16 strikethroughPos = 0;
+            u16 lineThickness = 0;
+        };
+
+        // These flags are shared with shader_ps.hlsl.
+        // If you change this be sure to copy it over to shader_ps.hlsl.
+        //
+        // clang-format off
+        enum class CellFlags : u32
+        {
+            None            = 0x00000000,
+            Inlined         = 0x00000001,
+
+            ColoredGlyph    = 0x00000002,
+            ThinFont        = 0x00000004,
+
+            Cursor          = 0x00000008,
+            Selected        = 0x00000010,
+
+            BorderLeft      = 0x00000020,
+            BorderTop       = 0x00000040,
+            BorderRight     = 0x00000080,
+            BorderBottom    = 0x00000100,
+            Underline       = 0x00000200,
+            UnderlineDotted = 0x00000400,
+            UnderlineDouble = 0x00000800,
+            Strikethrough   = 0x00001000,
+        };
+        // clang-format on
+        ATLAS_FLAG_OPS(CellFlags, u32)
+
+        // This structure is shared with the GPU shader and needs to follow certain alignment rules.
+        // You can generally assume that only u32 or types of that alignment are allowed.
+        struct Cell
+        {
+            alignas(u32) u16x2 tileIndex;
+            alignas(u32) CellFlags flags = CellFlags::None;
+            u32x2 color;
+        };
+
+        struct AtlasKeyAttributes
+        {
+            u16 inlined : 1;
+            u16 bold : 1;
+            u16 italic : 1;
+            u16 cellCount : 13;
+
+            ATLAS_POD_OPS(AtlasKeyAttributes)
+        };
+
+        struct AtlasKeyData
+        {
+            AtlasKeyAttributes attributes;
+            u16 charCount;
+            wchar_t chars[14];
+        };
+
+        struct AtlasKey
+        {
+            AtlasKey(AtlasKeyAttributes attributes, u16 charCount, const wchar_t* chars)
+            {
+                const auto size = dataSize(charCount);
+                const auto data = _data.initialize(size);
+                attributes.inlined = _data.would_inline(size);
+                data->attributes = attributes;
+                data->charCount = charCount;
+                memcpy(&data->chars[0], chars, static_cast<size_t>(charCount) * sizeof(AtlasKeyData::chars[0]));
+            }
+
+            const AtlasKeyData* data() const noexcept
+            {
+                return _data.data();
+            }
+
+            size_t hash() const noexcept
+            {
+                const auto d = data();
+#pragma warning(suppress : 26490) // Don't use reinterpret_cast (type.1).
+                return std::_Fnv1a_append_bytes(std::_FNV_offset_basis, reinterpret_cast<const u8*>(d), dataSize(d->charCount));
+            }
+
+            bool operator==(const AtlasKey& rhs) const noexcept
+            {
+                const auto a = data();
+                const auto b = rhs.data();
+                return a->charCount == b->charCount && memcmp(a, b, dataSize(a->charCount)) == 0;
+            }
+
+        private:
+            SmallObjectOptimizer<AtlasKeyData> _data;
+
+            static constexpr size_t dataSize(u16 charCount) noexcept
+            {
+                // This returns the actual byte size of a AtlasKeyData struct for the given charCount.
+                // The `wchar_t chars[2]` is only a buffer for the inlined variant after
+                // all and the actual charCount can be smaller or larger. Due to this we
+                // remove the size of the `chars` array and add it's true length on top.
+                return sizeof(AtlasKeyData) - sizeof(AtlasKeyData::chars) + static_cast<size_t>(charCount) * sizeof(AtlasKeyData::chars[0]);
+            }
+        };
+
+        struct AtlasKeyHasher
+        {
+            size_t operator()(const AtlasKey& key) const noexcept
+            {
+                return key.hash();
+            }
+        };
+
+        struct AtlasValueData
+        {
+            CellFlags flags = CellFlags::None;
+            u16x2 coords[7];
+        };
+
+        struct AtlasValue
+        {
+            constexpr AtlasValue() = default;
+
+            u16x2* initialize(CellFlags flags, u16 cellCount)
+            {
+                const auto size = dataSize(cellCount);
+                const auto data = _data.initialize(size);
+                WI_SetFlagIf(flags, CellFlags::Inlined, _data.would_inline(size));
+                data->flags = flags;
+                return &data->coords[0];
+            }
+
+            const AtlasValueData* data() const noexcept
+            {
+                return _data.data();
+            }
+
+        private:
+            SmallObjectOptimizer<AtlasValueData> _data;
+
+            static constexpr size_t dataSize(u16 coordCount) noexcept
+            {
+                return sizeof(AtlasValueData) - sizeof(AtlasValueData::coords) + static_cast<size_t>(coordCount) * sizeof(AtlasValueData::coords[0]);
+            }
+        };
+
+        struct AtlasQueueItem
+        {
+            const AtlasKey* key;
+            const AtlasValue* value;
+            float scale;
+        };
+
+        struct CachedCursorOptions
+        {
+            u32 cursorColor = INVALID_COLOR;
+            u16 cursorType = gsl::narrow_cast<u16>(CursorType::Legacy);
+            u8 heightPercentage = 20;
+
+            ATLAS_POD_OPS(CachedCursorOptions)
+        };
+
+        struct BufferLineMetadata
+        {
+            u32x2 colors;
+            CellFlags flags = CellFlags::None;
+        };
+
+        // NOTE: D3D constant buffers sizes must be a multiple of 16 bytes.
+        struct alignas(16) ConstBuffer
+        {
+            // WARNING: Modify this carefully after understanding how HLSL struct packing works.
+            // The gist is:
+            // * Minimum alignment is 4 bytes (like `#pragma pack 4`)
+            // * Members cannot straddle 16 byte boundaries
+            //   This means a structure like {u32; u32; u32; u32x2} would require
+            //   padding so that it is {u32; u32; u32; <4 byte padding>; u32x2}.
+            alignas(sizeof(f32x4)) f32x4 viewport;
+            alignas(sizeof(f32x4)) f32x4 gammaRatios;
+            alignas(sizeof(f32)) f32 grayscaleEnhancedContrast = 0;
+            alignas(sizeof(u32)) u32 cellCountX = 0;
+            alignas(sizeof(u32x2)) u32x2 cellSize;
+            alignas(sizeof(u32x2)) u32x2 underlinePos;
+            alignas(sizeof(u32x2)) u32x2 strikethroughPos;
+            alignas(sizeof(u32)) u32 backgroundColor = 0;
+            alignas(sizeof(u32)) u32 cursorColor = 0;
+            alignas(sizeof(u32)) u32 selectionColor = 0;
+#pragma warning(suppress : 4324) // 'ConstBuffer': structure was padded due to alignment specifier
+        };
+
+        // Handled in BeginPaint()
+        enum class ApiInvalidations : u8
+        {
+            None = 0,
+            Title = 1 << 0,
+            Device = 1 << 1,
+            SwapChain = 1 << 2,
+            Size = 1 << 3,
+            Font = 1 << 4,
+            Settings = 1 << 5,
+        };
+        ATLAS_FLAG_OPS(ApiInvalidations, u8)
+
+        // Handled in Present()
+        enum class RenderInvalidations : u8
+        {
+            None = 0,
+            Cursor = 1 << 0,
+            ConstBuffer = 1 << 1,
+        };
+        ATLAS_FLAG_OPS(RenderInvalidations, u8)
+
+        // MSVC STL (version 22000) implements std::clamp<T>(T, T, T) in terms of the generic
+        // std::clamp<T, Predicate>(T, T, T, Predicate) with std::less{} as the argument,
+        // which introduces branching. While not perfect, this is still better than std::clamp.
+        template<typename T>
+        static constexpr T clamp(T val, T min, T max)
+        {
+            return std::max(min, std::min(max, val));
+        }
+
+        // AtlasEngine.cpp
+        [[nodiscard]] HRESULT _handleException(const wil::ResultException& exception) noexcept;
+        __declspec(noinline) void _createResources();
+        void _releaseSwapChain();
+        __declspec(noinline) void _createSwapChain();
+        __declspec(noinline) void _recreateSizeDependentResources();
+        __declspec(noinline) void _recreateFontDependentResources();
+        IDWriteTextFormat* _getTextFormat(bool bold, bool italic) const noexcept;
+        const Buffer<DWRITE_FONT_AXIS_VALUE>& _getTextFormatAxis(bool bold, bool italic) const noexcept;
+        Cell* _getCell(u16 x, u16 y) noexcept;
+        void _setCellFlags(SMALL_RECT coords, CellFlags mask, CellFlags bits) noexcept;
+        u16x2 _allocateAtlasTile() noexcept;
+        void _flushBufferLine();
+        void _emplaceGlyph(IDWriteFontFace* fontFace, float scale, size_t bufferPos1, size_t bufferPos2);
+
+        // AtlasEngine.api.cpp
+        void _resolveFontMetrics(const FontInfoDesired& fontInfoDesired, FontInfo& fontInfo, FontMetrics* fontMetrics = nullptr) const;
+
+        // AtlasEngine.r.cpp
+        void _setShaderResources() const;
+        static f32x4 _getGammaRatios(float gamma) noexcept;
+        void _updateConstantBuffer() const noexcept;
+        void _adjustAtlasSize();
+        void _reserveScratchpadSize(u16 minWidth);
+        void _processGlyphQueue();
+        void _drawGlyph(const AtlasQueueItem& item) const;
+        void _drawCursor();
+        void _copyScratchpadTile(uint32_t scratchpadIndex, u16x2 target, uint32_t copyFlags = 0) const noexcept;
+
+        static constexpr bool debugGlyphGenerationPerformance = false;
+        static constexpr bool debugGeneralPerformance = false || debugGlyphGenerationPerformance;
+        static constexpr bool continuousRedraw = false || debugGeneralPerformance;
+
+        static constexpr u16 u16min = 0x0000;
+        static constexpr u16 u16max = 0xffff;
+        static constexpr i16 i16min = -0x8000;
+        static constexpr i16 i16max = 0x7fff;
+        static constexpr u16r invalidatedAreaNone = { u16max, u16max, u16min, u16min };
+        static constexpr u16x2 invalidatedRowsNone{ u16max, u16min };
+        static constexpr u16x2 invalidatedRowsAll{ u16min, u16max };
+
+        struct StaticResources
+        {
+            wil::com_ptr<ID2D1Factory> d2dFactory;
+            wil::com_ptr<IDWriteFactory1> dwriteFactory;
+            wil::com_ptr<IDWriteFontFallback> systemFontFallback;
+            wil::com_ptr<IDWriteTextAnalyzer1> textAnalyzer;
+            bool isWindows10OrGreater = true;
+
+#ifndef NDEBUG
+            wil::unique_folder_change_reader_nothrow sourceCodeWatcher;
+            std::atomic<int64_t> sourceCodeInvalidationTime{ INT64_MAX };
+#endif
+        } _sr;
+
+        struct Resources
+        {
+            // D3D resources
+            wil::com_ptr<ID3D11Device> device;
+            wil::com_ptr<ID3D11DeviceContext1> deviceContext;
+            wil::com_ptr<IDXGISwapChain1> swapChain;
+            wil::unique_handle frameLatencyWaitableObject;
+            wil::com_ptr<ID3D11RenderTargetView> renderTargetView;
+            wil::com_ptr<ID3D11VertexShader> vertexShader;
+            wil::com_ptr<ID3D11PixelShader> pixelShader;
+            wil::com_ptr<ID3D11Buffer> constantBuffer;
+            wil::com_ptr<ID3D11Buffer> cellBuffer;
+            wil::com_ptr<ID3D11ShaderResourceView> cellView;
+
+            // D2D resources
+            wil::com_ptr<ID3D11Texture2D> atlasBuffer;
+            wil::com_ptr<ID3D11ShaderResourceView> atlasView;
+            wil::com_ptr<ID3D11Texture2D> atlasScratchpad;
+            wil::com_ptr<ID2D1RenderTarget> d2dRenderTarget;
+            wil::com_ptr<ID2D1Brush> brush;
+            wil::com_ptr<IDWriteTextFormat> textFormats[2][2];
+            Buffer<DWRITE_FONT_AXIS_VALUE> textFormatAxes[2][2];
+            wil::com_ptr<IDWriteTypography> typography;
+
+            Buffer<Cell, 32> cells; // invalidated by ApiInvalidations::Size
+            f32x2 cellSizeDIP; // invalidated by ApiInvalidations::Font, caches _api.cellSize but in DIP
+            u16x2 cellSize; // invalidated by ApiInvalidations::Font, caches _api.cellSize
+            u16x2 cellCount; // invalidated by ApiInvalidations::Font|Size, caches _api.cellCount
+            u16 underlinePos = 0;
+            u16 strikethroughPos = 0;
+            u16 lineThickness = 0;
+            u16 dpi = USER_DEFAULT_SCREEN_DPI; // invalidated by ApiInvalidations::Font, caches _api.dpi
+            u16 maxEncounteredCellCount = 0;
+            u16 scratchpadCellWidth = 0;
+            u16x2 atlasSizeInPixelLimit; // invalidated by ApiInvalidations::Font
+            u16x2 atlasSizeInPixel; // invalidated by ApiInvalidations::Font
+            u16x2 atlasPosition;
+            std::unordered_map<AtlasKey, AtlasValue, AtlasKeyHasher> glyphs;
+            std::vector<AtlasQueueItem> glyphQueue;
+
+            f32 gamma = 0;
+            f32 grayscaleEnhancedContrast = 0;
+            u32 backgroundColor = 0xff000000;
+            u32 selectionColor = 0x7fffffff;
+
+            CachedCursorOptions cursorOptions;
+            RenderInvalidations invalidations = RenderInvalidations::None;
+
+#ifndef NDEBUG
+            // See documentation for IDXGISwapChain2::GetFrameLatencyWaitableObject method:
+            // > For every frame it renders, the app should wait on this handle before starting any rendering operations.
+            // > Note that this requirement includes the first frame the app renders with the swap chain.
+            bool frameLatencyWaitableObjectUsed = false;
+#endif
+        } _r;
+
+        struct ApiState
+        {
+            // This structure is loosely sorted in chunks from "very often accessed together"
+            // to seldom accessed and/or usually not together.
+
+            std::vector<wchar_t> bufferLine;
+            std::vector<u16> bufferLineColumn;
+            Buffer<BufferLineMetadata> bufferLineMetadata;
+            std::vector<TextAnalyzerResult> analysisResults;
+            Buffer<u16> clusterMap;
+            Buffer<DWRITE_SHAPING_TEXT_PROPERTIES> textProps;
+            Buffer<u16> glyphIndices;
+            Buffer<DWRITE_SHAPING_GLYPH_PROPERTIES> glyphProps;
+            std::vector<DWRITE_FONT_FEATURE> fontFeatures; // changes are flagged as ApiInvalidations::Font|Size
+            std::vector<DWRITE_FONT_AXIS_VALUE> fontAxisValues; // changes are flagged as ApiInvalidations::Font|Size
+            FontMetrics fontMetrics; // changes are flagged as ApiInvalidations::Font|Size
+
+            u16x2 cellCount; // caches `sizeInPixel / cellSize`
+            u16x2 sizeInPixel; // changes are flagged as ApiInvalidations::Size
+
+            // UpdateDrawingBrushes()
+            u32 backgroundOpaqueMixin = 0xff000000; // changes are flagged as ApiInvalidations::Device
+            u32x2 currentColor;
+            AtlasKeyAttributes attributes{};
+            u16 currentRow = 0;
+            CellFlags flags = CellFlags::None;
+            // SetSelectionBackground()
+            u32 selectionColor = 0x7fffffff;
+
+            // dirtyRect is a computed value based on invalidatedRows.
+            til::rectangle dirtyRect;
+            // These "invalidation" fields are reset in EndPaint()
+            u16r invalidatedCursorArea = invalidatedAreaNone;
+            u16x2 invalidatedRows = invalidatedRowsNone; // x is treated as "top" and y as "bottom"
+            i16 scrollOffset = 0;
+
+            std::function<void(HRESULT)> warningCallback;
+            std::function<void()> swapChainChangedCallback;
+            wil::unique_handle swapChainHandle;
+            HWND hwnd = nullptr;
+            u16 dpi = USER_DEFAULT_SCREEN_DPI; // changes are flagged as ApiInvalidations::Font|Size
+            u16 antialiasingMode = D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE; // changes are flagged as ApiInvalidations::Font
+
+            ApiInvalidations invalidations = ApiInvalidations::Device;
+        } _api;
+
+#undef ATLAS_POD_OPS
+#undef ATLAS_FLAG_OPS
+    };
+}
diff --git a/src/renderer/atlas/AtlasEngine.r.cpp b/src/renderer/atlas/AtlasEngine.r.cpp
new file mode 100644
index 000000000..4a3f3a239
--- /dev/null
+++ b/src/renderer/atlas/AtlasEngine.r.cpp
@@ -0,0 +1,460 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "AtlasEngine.h"
+
+// #### NOTE ####
+// If you see any code in here that contains "_api." you might be seeing a race condition.
+// The AtlasEngine::Present() method is called on a background thread without any locks,
+// while any of the API methods (like AtlasEngine::Invalidate) might be called concurrently.
+// The usage of the _r field is safe as its members are in practice
+// only ever written to by the caller of Present() (the "Renderer" class).
+// The _api fields on the other hand are concurrently written to by others.
+
+#pragma warning(disable : 4100) // '...': unreferenced formal parameter
+// Disable a bunch of warnings which get in the way of writing performant code.
+#pragma warning(disable : 26429) // Symbol 'data' is never tested for nullness, it can be marked as not_null (f.23).
+#pragma warning(disable : 26446) // Prefer to use gsl::at() instead of unchecked subscript operator (bounds.4).
+#pragma warning(disable : 26481) // Don't use pointer arithmetic. Use span instead (bounds.1).
+#pragma warning(disable : 26482) // Only index into arrays using constant expressions (bounds.2).
+
+using namespace Microsoft::Console::Render;
+
+#pragma region IRenderEngine
+
+// Present() is called without the console buffer lock being held.
+// --> Put as much in here as possible.
+[[nodiscard]] HRESULT AtlasEngine::Present() noexcept
+try
+{
+    _adjustAtlasSize();
+    _reserveScratchpadSize(_r.maxEncounteredCellCount);
+    _processGlyphQueue();
+
+    if (WI_IsFlagSet(_r.invalidations, RenderInvalidations::Cursor))
+    {
+        _drawCursor();
+        WI_ClearFlag(_r.invalidations, RenderInvalidations::Cursor);
+    }
+
+    // The values the constant buffer depends on are potentially updated after BeginPaint().
+    if (WI_IsFlagSet(_r.invalidations, RenderInvalidations::ConstBuffer))
+    {
+        _updateConstantBuffer();
+        WI_ClearFlag(_r.invalidations, RenderInvalidations::ConstBuffer);
+    }
+
+    {
+#pragma warning(suppress : 26494) // Variable 'mapped' is uninitialized. Always initialize an object (type.5).
+        D3D11_MAPPED_SUBRESOURCE mapped;
+        THROW_IF_FAILED(_r.deviceContext->Map(_r.cellBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped));
+        assert(mapped.RowPitch >= _r.cells.size() * sizeof(Cell));
+        memcpy(mapped.pData, _r.cells.data(), _r.cells.size() * sizeof(Cell));
+        _r.deviceContext->Unmap(_r.cellBuffer.get(), 0);
+    }
+
+    // After Present calls, the back buffer needs to explicitly be
+    // re-bound to the D3D11 immediate context before it can be used again.
+    _r.deviceContext->OMSetRenderTargets(1, _r.renderTargetView.addressof(), nullptr);
+    _r.deviceContext->Draw(3, 0);
+
+    // See documentation for IDXGISwapChain2::GetFrameLatencyWaitableObject method:
+    // > For every frame it renders, the app should wait on this handle before starting any rendering operations.
+    // > Note that this requirement includes the first frame the app renders with the swap chain.
+    assert(_r.frameLatencyWaitableObjectUsed);
+
+    // > IDXGISwapChain::Present: Partial Presentation (using a dirty rects or scroll) is not supported
+    // > for SwapChains created with DXGI_SWAP_EFFECT_DISCARD or DXGI_SWAP_EFFECT_FLIP_DISCARD.
+    // ---> No need to call IDXGISwapChain1::Present1.
+    //      TODO: Would IDXGISwapChain1::Present1 and its dirty rects have benefits for remote desktop?
+    THROW_IF_FAILED(_r.swapChain->Present(1, 0));
+
+    // On some GPUs with tile based deferred rendering (TBDR) architectures, binding
+    // RenderTargets that already have contents in them (from previous rendering) incurs a
+    // cost for having to copy the RenderTarget contents back into tile memory for rendering.
+    //
+    // On Windows 10 with DXGI_SWAP_EFFECT_FLIP_DISCARD we get this for free.
+    if (!_sr.isWindows10OrGreater)
+    {
+        _r.deviceContext->DiscardView(_r.renderTargetView.get());
+    }
+
+    return S_OK;
+}
+catch (const wil::ResultException& exception)
+{
+    return _handleException(exception);
+}
+CATCH_RETURN()
+
+#pragma endregion
+
+void AtlasEngine::_setShaderResources() const
+{
+    _r.deviceContext->VSSetShader(_r.vertexShader.get(), nullptr, 0);
+    _r.deviceContext->PSSetShader(_r.pixelShader.get(), nullptr, 0);
+
+    // Our vertex shader uses a trick from Bill Bilodeau published in
+    // "Vertex Shader Tricks" at GDC14 to draw a fullscreen triangle
+    // without vertex/index buffers. This prepares our context for this.
+    _r.deviceContext->IASetVertexBuffers(0, 0, nullptr, nullptr, nullptr);
+    _r.deviceContext->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0);
+    _r.deviceContext->IASetInputLayout(nullptr);
+    _r.deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+
+    _r.deviceContext->PSSetConstantBuffers(0, 1, _r.constantBuffer.addressof());
+
+    const std::array resources{ _r.cellView.get(), _r.atlasView.get() };
+    _r.deviceContext->PSSetShaderResources(0, gsl::narrow_cast<UINT>(resources.size()), resources.data());
+}
+
+AtlasEngine::f32x4 AtlasEngine::_getGammaRatios(float gamma) noexcept
+{
+    static constexpr f32x4 gammaIncorrectTargetRatios[13]{
+        { 0.0000f / 4.f, 0.0000f / 4.f, 0.0000f / 4.f, 0.0000f / 4.f }, // gamma = 1.0
+        { 0.0166f / 4.f, -0.0807f / 4.f, 0.2227f / 4.f, -0.0751f / 4.f }, // gamma = 1.1
+        { 0.0350f / 4.f, -0.1760f / 4.f, 0.4325f / 4.f, -0.1370f / 4.f }, // gamma = 1.2
+        { 0.0543f / 4.f, -0.2821f / 4.f, 0.6302f / 4.f, -0.1876f / 4.f }, // gamma = 1.3
+        { 0.0739f / 4.f, -0.3963f / 4.f, 0.8167f / 4.f, -0.2287f / 4.f }, // gamma = 1.4
+        { 0.0933f / 4.f, -0.5161f / 4.f, 0.9926f / 4.f, -0.2616f / 4.f }, // gamma = 1.5
+        { 0.1121f / 4.f, -0.6395f / 4.f, 1.1588f / 4.f, -0.2877f / 4.f }, // gamma = 1.6
+        { 0.1300f / 4.f, -0.7649f / 4.f, 1.3159f / 4.f, -0.3080f / 4.f }, // gamma = 1.7
+        { 0.1469f / 4.f, -0.8911f / 4.f, 1.4644f / 4.f, -0.3234f / 4.f }, // gamma = 1.8
+        { 0.1627f / 4.f, -1.0170f / 4.f, 1.6051f / 4.f, -0.3347f / 4.f }, // gamma = 1.9
+        { 0.1773f / 4.f, -1.1420f / 4.f, 1.7385f / 4.f, -0.3426f / 4.f }, // gamma = 2.0
+        { 0.1908f / 4.f, -1.2652f / 4.f, 1.8650f / 4.f, -0.3476f / 4.f }, // gamma = 2.1
+        { 0.2031f / 4.f, -1.3864f / 4.f, 1.9851f / 4.f, -0.3501f / 4.f }, // gamma = 2.2
+    };
+    static constexpr auto norm13 = static_cast<float>(static_cast<double>(0x10000) / (255 * 255) * 4);
+    static constexpr auto norm24 = static_cast<float>(static_cast<double>(0x100) / (255) * 4);
+
+    gamma = clamp(gamma, 1.0f, 2.2f);
+
+    const size_t index = gsl::narrow_cast<size_t>(std::round((gamma - 1.0f) / 1.2f * 12.0f));
+    const auto& ratios = gammaIncorrectTargetRatios[index];
+    return { norm13 * ratios.x, norm24 * ratios.y, norm13 * ratios.z, norm24 * ratios.w };
+}
+
+void AtlasEngine::_updateConstantBuffer() const noexcept
+{
+    ConstBuffer data;
+    data.viewport.x = 0;
+    data.viewport.y = 0;
+    data.viewport.z = static_cast<float>(_r.cellCount.x * _r.cellSize.x);
+    data.viewport.w = static_cast<float>(_r.cellCount.y * _r.cellSize.y);
+    data.gammaRatios = _getGammaRatios(_r.gamma);
+    data.grayscaleEnhancedContrast = _r.grayscaleEnhancedContrast;
+    data.cellCountX = _r.cellCount.x;
+    data.cellSize.x = _r.cellSize.x;
+    data.cellSize.y = _r.cellSize.y;
+    data.underlinePos.x = _r.underlinePos;
+    data.underlinePos.y = _r.underlinePos + _r.lineThickness;
+    data.strikethroughPos.x = _r.strikethroughPos;
+    data.strikethroughPos.y = _r.strikethroughPos + _r.lineThickness;
+    data.backgroundColor = _r.backgroundColor;
+    data.cursorColor = _r.cursorOptions.cursorColor;
+    data.selectionColor = _r.selectionColor;
+#pragma warning(suppress : 26447) // The function is declared 'noexcept' but calls function '...' which may throw exceptions (f.6).
+    _r.deviceContext->UpdateSubresource(_r.constantBuffer.get(), 0, nullptr, &data, 0, 0);
+}
+
+void AtlasEngine::_adjustAtlasSize()
+{
+    if (_r.atlasPosition.y < _r.atlasSizeInPixel.y && _r.atlasPosition.x < _r.atlasSizeInPixel.x)
+    {
+        return;
+    }
+
+    const u32 limitX = _r.atlasSizeInPixelLimit.x;
+    const u32 limitY = _r.atlasSizeInPixelLimit.y;
+    const u32 posX = _r.atlasPosition.x;
+    const u32 posY = _r.atlasPosition.y;
+    const u32 cellX = _r.cellSize.x;
+    const u32 cellY = _r.cellSize.y;
+    const auto perCellArea = cellX * cellY;
+
+    // The texture atlas is filled like this:
+    //   x →
+    // y +--------------+
+    // ↓ |XXXXXXXXXXXXXX|
+    //   |XXXXXXXXXXXXXX|
+    //   |XXXXX↖        |
+    //   |      |       |
+    //   +------|-------+
+    // This is where _r.atlasPosition points at.
+    //
+    // Each X is a glyph texture tile that's occupied.
+    // We can compute the area of pixels consumed by adding the first
+    // two lines of X (rectangular) together with the last line of X.
+    const auto currentArea = posY * limitX + posX * cellY;
+    // minArea reserves enough room for 64 cells in all cases (mainly during startup).
+    const auto minArea = 64 * perCellArea;
+    auto newArea = std::max(minArea, currentArea);
+
+    // I want the texture to grow exponentially similar to std::vector, as this
+    // ensures we don't need to resize the texture again right after having done.
+    // This rounds newArea up to the next power of 2.
+    unsigned long int index;
+    _BitScanReverse(&index, newArea); // newArea can't be 0
+    newArea = u32{ 1 } << (index + 1);
+
+    const auto pixelPerRow = limitX * cellY;
+    // newArea might be just large enough that it spans N full rows of cells and one additional row
+    // just barely. This algorithm rounds up newArea to the _next_ multiple of cellY.
+    const auto wantedHeight = (newArea + pixelPerRow - 1) / pixelPerRow * cellY;
+    // The atlas might either be a N rows of full width (xLimit) or just one
+    // row (where wantedHeight == cellY) that doesn't quite fill it's maximum width yet.
+    const auto wantedWidth = wantedHeight != cellY ? limitX : newArea / perCellArea * cellX;
+
+    // We know that limitX/limitY were u16 originally, and thus it's safe to narrow_cast it back.
+    const auto height = gsl::narrow_cast<u16>(std::min(limitY, wantedHeight));
+    const auto width = gsl::narrow_cast<u16>(std::min(limitX, wantedWidth));
+
+    assert(width != 0);
+    assert(height != 0);
+
+    wil::com_ptr<ID3D11Texture2D> atlasBuffer;
+    wil::com_ptr<ID3D11ShaderResourceView> atlasView;
+    {
+        D3D11_TEXTURE2D_DESC desc{};
+        desc.Width = width;
+        desc.Height = height;
+        desc.MipLevels = 1;
+        desc.ArraySize = 1;
+        desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+        desc.SampleDesc = { 1, 0 };
+        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+        THROW_IF_FAILED(_r.device->CreateTexture2D(&desc, nullptr, atlasBuffer.addressof()));
+        THROW_IF_FAILED(_r.device->CreateShaderResourceView(atlasBuffer.get(), nullptr, atlasView.addressof()));
+    }
+
+    // If a _r.atlasBuffer already existed, we can copy its glyphs
+    // over to the new texture without re-rendering everything.
+    const auto copyFromExisting = _r.atlasSizeInPixel != u16x2{};
+    if (copyFromExisting)
+    {
+        D3D11_BOX box;
+        box.left = 0;
+        box.top = 0;
+        box.front = 0;
+        box.right = _r.atlasSizeInPixel.x;
+        box.bottom = _r.atlasSizeInPixel.y;
+        box.back = 1;
+        _r.deviceContext->CopySubresourceRegion1(atlasBuffer.get(), 0, 0, 0, 0, _r.atlasBuffer.get(), 0, &box, D3D11_COPY_NO_OVERWRITE);
+    }
+
+    _r.atlasSizeInPixel = u16x2{ width, height };
+    _r.atlasBuffer = std::move(atlasBuffer);
+    _r.atlasView = std::move(atlasView);
+    _setShaderResources();
+
+    WI_SetFlagIf(_r.invalidations, RenderInvalidations::Cursor, !copyFromExisting);
+}
+
+void AtlasEngine::_reserveScratchpadSize(u16 minWidth)
+{
+    if (minWidth <= _r.scratchpadCellWidth)
+    {
+        return;
+    }
+
+    // The new size is the greater of ... cells wide:
+    // * 2
+    // * minWidth
+    // * current size * 1.5
+    const auto newWidth = std::max<UINT>(std::max<UINT>(2, minWidth), _r.scratchpadCellWidth + (_r.scratchpadCellWidth >> 1));
+
+    _r.d2dRenderTarget.reset();
+    _r.atlasScratchpad.reset();
+
+    {
+        D3D11_TEXTURE2D_DESC desc{};
+        desc.Width = _r.cellSize.x * newWidth;
+        desc.Height = _r.cellSize.y;
+        desc.MipLevels = 1;
+        desc.ArraySize = 1;
+        desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+        desc.SampleDesc = { 1, 0 };
+        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
+        THROW_IF_FAILED(_r.device->CreateTexture2D(&desc, nullptr, _r.atlasScratchpad.put()));
+    }
+    {
+        const auto surface = _r.atlasScratchpad.query<IDXGISurface>();
+
+        wil::com_ptr<IDWriteRenderingParams1> defaultParams;
+        THROW_IF_FAILED(_sr.dwriteFactory->CreateRenderingParams(reinterpret_cast<IDWriteRenderingParams**>(defaultParams.addressof())));
+        wil::com_ptr<IDWriteRenderingParams1> renderingParams;
+        THROW_IF_FAILED(_sr.dwriteFactory->CreateCustomRenderingParams(1.0f, 0.0f, 0.0f, defaultParams->GetClearTypeLevel(), defaultParams->GetPixelGeometry(), defaultParams->GetRenderingMode(), renderingParams.addressof()));
+
+        _r.gamma = defaultParams->GetGamma();
+        _r.grayscaleEnhancedContrast = defaultParams->GetGrayscaleEnhancedContrast();
+
+        D2D1_RENDER_TARGET_PROPERTIES props{};
+        props.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
+        props.pixelFormat = { DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED };
+        props.dpiX = static_cast<float>(_r.dpi);
+        props.dpiY = static_cast<float>(_r.dpi);
+        THROW_IF_FAILED(_sr.d2dFactory->CreateDxgiSurfaceRenderTarget(surface.get(), &props, _r.d2dRenderTarget.put()));
+
+        // We don't really use D2D for anything except DWrite, but it
+        // can't hurt to ensure that everything it does is pixel aligned.
+        _r.d2dRenderTarget->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
+        // Ensure that D2D uses the exact same gamma as our shader uses.
+        _r.d2dRenderTarget->SetTextRenderingParams(renderingParams.get());
+        // We can't set the antialiasingMode here, as D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE
+        // will force the alpha channel to be 0 for _all_ text.
+        //_r.d2dRenderTarget->SetTextAntialiasMode(static_cast<D2D1_TEXT_ANTIALIAS_MODE>(_api.antialiasingMode));
+    }
+    {
+        static constexpr D2D1_COLOR_F color{ 1, 1, 1, 1 };
+        wil::com_ptr<ID2D1SolidColorBrush> brush;
+        THROW_IF_FAILED(_r.d2dRenderTarget->CreateSolidColorBrush(&color, nullptr, brush.addressof()));
+        _r.brush = brush.query<ID2D1Brush>();
+    }
+
+    _r.scratchpadCellWidth = _r.maxEncounteredCellCount;
+    WI_SetAllFlags(_r.invalidations, RenderInvalidations::ConstBuffer);
+}
+
+void AtlasEngine::_processGlyphQueue()
+{
+    if (_r.glyphQueue.empty())
+    {
+        return;
+    }
+
+    for (const auto& pair : _r.glyphQueue)
+    {
+        _drawGlyph(pair);
+    }
+
+    _r.glyphQueue.clear();
+}
+
+void AtlasEngine::_drawGlyph(const AtlasQueueItem& item) const
+{
+    const auto key = item.key->data();
+    const auto value = item.value->data();
+    const auto coords = &value->coords[0];
+    const auto charsLength = key->charCount;
+    const auto cells = static_cast<u32>(key->attributes.cellCount);
+    const auto textFormat = _getTextFormat(key->attributes.bold, key->attributes.italic);
+
+    // See D2DFactory::DrawText
+    wil::com_ptr<IDWriteTextLayout> textLayout;
+    THROW_IF_FAILED(_sr.dwriteFactory->CreateTextLayout(&key->chars[0], charsLength, textFormat, cells * _r.cellSizeDIP.x, _r.cellSizeDIP.y, textLayout.addressof()));
+    if (item.scale != 1.0f)
+    {
+        const auto f = textFormat->GetFontSize();
+        textLayout->SetFontSize(f * item.scale, { 0, charsLength });
+    }
+    if (_r.typography)
+    {
+        textLayout->SetTypography(_r.typography.get(), { 0, charsLength });
+    }
+
+    auto options = D2D1_DRAW_TEXT_OPTIONS_NONE;
+    // D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT enables a bunch of internal machinery
+    // which doesn't have to run if we know we can't use it anyways in the shader.
+    WI_SetFlagIf(options, D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT, WI_IsFlagSet(value->flags, CellFlags::ColoredGlyph));
+
+    _r.d2dRenderTarget->BeginDraw();
+    // We could call
+    //   _r.d2dRenderTarget->PushAxisAlignedClip(&rect, D2D1_ANTIALIAS_MODE_ALIASED);
+    // now to reduce the surface that needs to be cleared, but this decreases
+    // performance by 10% (tested using debugGlyphGenerationPerformance).
+    _r.d2dRenderTarget->Clear();
+    _r.d2dRenderTarget->DrawTextLayout({}, textLayout.get(), _r.brush.get(), options);
+    THROW_IF_FAILED(_r.d2dRenderTarget->EndDraw());
+
+    for (uint32_t i = 0; i < cells; ++i)
+    {
+        // Specifying NO_OVERWRITE means that the system can assume that existing references to the surface that
+        // may be in flight on the GPU will not be affected by the update, so the copy can proceed immediately
+        // (avoiding either a batch flush or the system maintaining multiple copies of the resource behind the scenes).
+        //
+        // Since our shader only draws whatever is in the atlas, and since we don't replace glyph tiles that are in use,
+        // we can safely (?) tell the GPU that we don't overwrite parts of our atlas that are in use.
+        _copyScratchpadTile(i, coords[i], D3D11_COPY_NO_OVERWRITE);
+    }
+}
+
+void AtlasEngine::_drawCursor()
+{
+    _reserveScratchpadSize(1);
+
+    // lineWidth is in D2D's DIPs. For instance if we have a 150-200% zoom scale we want to draw a 2px wide line.
+    // At 150% scale lineWidth thus needs to be 1.33333... because at a zoom scale of 1.5 this results in a 2px wide line.
+    const auto lineWidth = std::max(1.0f, static_cast<float>((_r.dpi + USER_DEFAULT_SCREEN_DPI / 2) / USER_DEFAULT_SCREEN_DPI * USER_DEFAULT_SCREEN_DPI) / static_cast<float>(_r.dpi));
+    const auto cursorType = static_cast<CursorType>(_r.cursorOptions.cursorType);
+    D2D1_RECT_F rect;
+    rect.left = 0.0f;
+    rect.top = 0.0f;
+    rect.right = _r.cellSizeDIP.x;
+    rect.bottom = _r.cellSizeDIP.y;
+
+    switch (cursorType)
+    {
+    case CursorType::Legacy:
+        rect.top = _r.cellSizeDIP.y * static_cast<float>(100 - _r.cursorOptions.heightPercentage) / 100.0f;
+        break;
+    case CursorType::VerticalBar:
+        rect.right = lineWidth;
+        break;
+    case CursorType::EmptyBox:
+    {
+        // EmptyBox is drawn as a line and unlike filled rectangles those are drawn centered on their
+        // coordinates in such a way that the line border extends half the width to each side.
+        // --> Our coordinates have to be 0.5 DIP off in order to draw a 2px line on a 200% scaling.
+        const auto halfWidth = lineWidth / 2.0f;
+        rect.left = halfWidth;
+        rect.top = halfWidth;
+        rect.right -= halfWidth;
+        rect.bottom -= halfWidth;
+        break;
+    }
+    case CursorType::Underscore:
+    case CursorType::DoubleUnderscore:
+        rect.top = _r.cellSizeDIP.y - lineWidth;
+        break;
+    default:
+        break;
+    }
+
+    _r.d2dRenderTarget->BeginDraw();
+    _r.d2dRenderTarget->Clear();
+
+    if (cursorType == CursorType::EmptyBox)
+    {
+        _r.d2dRenderTarget->DrawRectangle(&rect, _r.brush.get(), lineWidth);
+    }
+    else
+    {
+        _r.d2dRenderTarget->FillRectangle(&rect, _r.brush.get());
+    }
+
+    if (cursorType == CursorType::DoubleUnderscore)
+    {
+        rect.top -= 2.0f;
+        rect.bottom -= 2.0f;
+        _r.d2dRenderTarget->FillRectangle(&rect, _r.brush.get());
+    }
+
+    THROW_IF_FAILED(_r.d2dRenderTarget->EndDraw());
+
+    _copyScratchpadTile(0, {});
+}
+
+void AtlasEngine::_copyScratchpadTile(uint32_t scratchpadIndex, u16x2 target, uint32_t copyFlags) const noexcept
+{
+    D3D11_BOX box;
+    box.left = scratchpadIndex * _r.cellSize.x;
+    box.top = 0;
+    box.front = 0;
+    box.right = box.left + _r.cellSize.x;
+    box.bottom = _r.cellSize.y;
+    box.back = 1;
+#pragma warning(suppress : 26447) // The function is declared 'noexcept' but calls function '...' which may throw exceptions (f.6).
+    _r.deviceContext->CopySubresourceRegion1(_r.atlasBuffer.get(), 0, target.x, target.y, 0, _r.atlasScratchpad.get(), 0, &box, copyFlags);
+}
diff --git a/src/renderer/atlas/atlas.vcxproj b/src/renderer/atlas/atlas.vcxproj
new file mode 100644
index 000000000..f94dfe800
--- /dev/null
+++ b/src/renderer/atlas/atlas.vcxproj
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectGuid>{8222900C-8B6C-452A-91AC-BE95DB04B95F}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>atlas</RootNamespace>
+    <ProjectName>RendererAtlas</ProjectName>
+    <TargetName>ConRenderAtlas</TargetName>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)src\common.build.pre.props" />
+  <ItemGroup>
+    <ClCompile Include="AtlasEngine.api.cpp" />
+    <ClCompile Include="AtlasEngine.r.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="AtlasEngine.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="AtlasEngine.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <FxCompile Include="shader_ps.hlsl">
+      <ShaderType>Pixel</ShaderType>
+      <ShaderModel>4.1</ShaderModel>
+      <AllResourcesBound>true</AllResourcesBound>
+      <VariableName>shader_ps</VariableName>
+      <ObjectFileOutput />
+      <HeaderFileOutput>$(OutDir)$(ProjectName)\%(Filename).h</HeaderFileOutput>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <AdditionalOptions>/Zpc %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions Condition="'$(Configuration)'=='Release'">/O3 /Qstrip_debug /Qstrip_reflect %(AdditionalOptions)</AdditionalOptions>
+    </FxCompile>
+    <FxCompile Include="shader_vs.hlsl">
+      <ShaderType>Vertex</ShaderType>
+      <ShaderModel>4.1</ShaderModel>
+      <AllResourcesBound>true</AllResourcesBound>
+      <VariableName>shader_vs</VariableName>
+      <ObjectFileOutput />
+      <HeaderFileOutput>$(OutDir)$(ProjectName)\%(Filename).h</HeaderFileOutput>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <AdditionalOptions>/Zpc %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions Condition="'$(Configuration)'=='Release'">/O3 /Qstrip_debug /Qstrip_reflect %(AdditionalOptions)</AdditionalOptions>
+    </FxCompile>
+  </ItemGroup>
+  <Import Project="$(SolutionDir)src\common.build.post.props" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>$(OutDir)$(ProjectName)\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+</Project>
diff --git a/src/renderer/atlas/pch.cpp b/src/renderer/atlas/pch.cpp
new file mode 100644
index 000000000..398a99f66
--- /dev/null
+++ b/src/renderer/atlas/pch.cpp
@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
diff --git a/src/renderer/atlas/pch.h b/src/renderer/atlas/pch.h
new file mode 100644
index 000000000..e6ede9efe
--- /dev/null
+++ b/src/renderer/atlas/pch.h
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+#define NOMINMAX
+#define WIN32_LEAN_AND_MEAN
+
+#include <array>
+#include <iomanip>
+#include <optional>
+#include <sstream>
+#include <string_view>
+#include <thread>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <d2d1.h>
+#include <d3d11_1.h>
+#include <d3dcompiler.h>
+#include <dwrite_3.h>
+#include <dcomp.h>
+#include <dxgi1_3.h>
+#include <dxgidebug.h>
+#include <VersionHelpers.h>
+
+#include <gsl/gsl_util>
+#include <gsl/pointers>
+#include <gsl/span>
+#include <wil/com.h>
+#include <wil/filesystem.h>
+#include <wil/result_macros.h>
+#include <wil/stl.h>
+#include <wil/win32_helpers.h>
+
+// Dynamic Bitset (optional dependency on LibPopCnt for perf at bit counting)
+// Variable-size compressed-storage header-only bit flag storage library.
+#pragma warning(push)
+#pragma warning(disable : 4702) // unreachable code
+#include <dynamic_bitset.hpp>
+#pragma warning(pop)
+
+// Chromium Numerics (safe math)
+#pragma warning(push)
+#pragma warning(disable : 4100) // '...': unreferenced formal parameter
+#pragma warning(disable : 26812) // The enum type '...' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
+#include <base/numerics/safe_math.h>
+#pragma warning(pop)
+
+#include <til.h>
+#include <til/bit.h>
diff --git a/src/renderer/atlas/shader_ps.hlsl b/src/renderer/atlas/shader_ps.hlsl
new file mode 100644
index 000000000..36090fd6c
--- /dev/null
+++ b/src/renderer/atlas/shader_ps.hlsl
@@ -0,0 +1,182 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#define INVALID_COLOR 0xffffffff
+
+// These flags are shared with AtlasEngine::CellFlags.
+//
+// clang-format off
+#define CellFlags_None            0x00000000
+#define CellFlags_Inlined         0x00000001
+
+#define CellFlags_ColoredGlyph    0x00000002
+#define CellFlags_ThinFont        0x00000004
+
+#define CellFlags_Cursor          0x00000008
+#define CellFlags_Selected        0x00000010
+
+#define CellFlags_BorderLeft      0x00000020
+#define CellFlags_BorderTop       0x00000040
+#define CellFlags_BorderRight     0x00000080
+#define CellFlags_BorderBottom    0x00000100
+#define CellFlags_Underline       0x00000200
+#define CellFlags_UnderlineDotted 0x00000400
+#define CellFlags_UnderlineDouble 0x00000800
+#define CellFlags_Strikethrough   0x00001000
+// clang-format on
+
+// According to Nvidia's "Understanding Structured Buffer Performance" guide
+// one should aim for structures with sizes divisible by 128 bits (16 bytes).
+// This prevents elements from spanning cache lines.
+struct Cell
+{
+    uint glyphPos;
+    uint flags;
+    uint2 color; // x: foreground, y: background
+};
+
+cbuffer ConstBuffer : register(b0)
+{
+    float4 viewport;
+    float4 gammaRatios;
+    float grayscaleEnhancedContrast;
+    uint cellCountX;
+    uint2 cellSize;
+    uint2 underlinePos;
+    uint2 strikethroughPos;
+    uint backgroundColor;
+    uint cursorColor;
+    uint selectionColor;
+};
+StructuredBuffer<Cell> cells : register(t0);
+Texture2D<float4> glyphs : register(t1);
+
+float4 decodeRGBA(uint i)
+{
+    uint r = i & 0xff;
+    uint g = (i >> 8) & 0xff;
+    uint b = (i >> 16) & 0xff;
+    uint a = i >> 24;
+    float4 c = float4(r, g, b, a) / 255.0f;
+    // Convert to premultiplied alpha for simpler alpha blending.
+    c.rgb *= c.a;
+    return c;
+}
+
+uint2 decodeU16x2(uint i)
+{
+    return uint2(i & 0xffff, i >> 16);
+}
+
+float4 alphaBlendPremultiplied(float4 bottom, float4 top)
+{
+    float ia = 1 - top.a;
+    return float4(bottom.rgb * ia + top.rgb, bottom.a * ia + top.a);
+}
+
+float applyLightOnDarkContrastAdjustment(float3 color)
+{
+    float lightness = 0.30f * color.r + 0.59f * color.g + 0.11f * color.b;
+    float multiplier = saturate(4.0f * (0.75f - lightness));
+    return grayscaleEnhancedContrast * multiplier;
+}
+
+float calcColorIntensity(float3 color)
+{
+    return (color.r + color.g + color.g + color.b) / 4.0f;
+}
+
+float enhanceContrast(float alpha, float k)
+{
+    return alpha * (k + 1.0f) / (alpha * k + 1.0f);
+}
+
+float applyAlphaCorrection(float a, float f, float4 g)
+{
+    return a + a * (1 - a) * ((g.x * f + g.y) * a + (g.z * f + g.w));
+}
+
+// clang-format off
+float4 main(float4 pos: SV_Position): SV_Target
+// clang-format on
+{
+    if (any(pos.xy < viewport.xy) || any(pos.xy >= viewport.zw))
+    {
+        return decodeRGBA(backgroundColor);
+    }
+
+    // If you want to write test a before/after change simultaneously
+    // you can turn the image into a checkerboard by writing:
+    //   if ((uint(pos.x) ^ uint(pos.y)) / 4 & 1) { return float4(1, 0, 0, 1); }
+    // This will generate a checkerboard of 4*4px red squares.
+    // Of course you wouldn't just return a red color there, but instead
+    // for instance run your new code and compare it with the old.
+
+    uint2 viewportPos = pos.xy - viewport.xy;
+    uint2 cellIndex = viewportPos / cellSize;
+    uint2 cellPos = viewportPos % cellSize;
+    Cell cell = cells[cellIndex.y * cellCountX + cellIndex.x];
+
+    // Layer 0:
+    // The cell's background color
+    float4 color = decodeRGBA(cell.color.y);
+    float4 fg = decodeRGBA(cell.color.x);
+
+    // Layer 1 (optional):
+    // Colored cursors are drawn "in between" the background color and the text of a cell.
+    if ((cell.flags & CellFlags_Cursor) && cursorColor != INVALID_COLOR)
+    {
+        // The cursor texture is stored at the top-left-most glyph cell.
+        // Cursor pixels are either entirely transparent or opaque.
+        // --> We can just use .a as a mask to flip cursor pixels on or off.
+        color = alphaBlendPremultiplied(color, decodeRGBA(cursorColor) * glyphs[cellPos].a);
+    }
+
+    // Layer 2:
+    // Step 1: Underlines
+    if ((cell.flags & CellFlags_Underline) && cellPos.y >= underlinePos.x && cellPos.y < underlinePos.y)
+    {
+        color = alphaBlendPremultiplied(color, fg);
+    }
+    if ((cell.flags & CellFlags_UnderlineDotted) && cellPos.y >= underlinePos.x && cellPos.y < underlinePos.y && (viewportPos.x / (underlinePos.y - underlinePos.x) & 1))
+    {
+        color = alphaBlendPremultiplied(color, fg);
+    }
+    // Step 2: The cell's glyph, potentially drawn in the foreground color
+    {
+        float4 glyph = glyphs[decodeU16x2(cell.glyphPos) + cellPos];
+
+        if (!(cell.flags & CellFlags_ColoredGlyph))
+        {
+            float contrastBoost = (cell.flags & CellFlags_ThinFont) == 0 ? 0.0f : 0.5f;
+            float enhancedContrast = contrastBoost + applyLightOnDarkContrastAdjustment(fg.rgb);
+            float intensity = calcColorIntensity(fg.rgb);
+            float contrasted = enhanceContrast(glyph.a, enhancedContrast);
+            float correctedAlpha = applyAlphaCorrection(contrasted, intensity, gammaRatios);
+            glyph = fg * correctedAlpha;
+        }
+
+        color = alphaBlendPremultiplied(color, glyph);
+    }
+    // Step 3: Lines, but not "under"lines
+    if ((cell.flags & CellFlags_Strikethrough) && cellPos.y >= strikethroughPos.x && cellPos.y < strikethroughPos.y)
+    {
+        color = alphaBlendPremultiplied(color, fg);
+    }
+
+    // Layer 3 (optional):
+    // Uncolored cursors invert the cells color.
+    if ((cell.flags & CellFlags_Cursor) && cursorColor == INVALID_COLOR)
+    {
+        color.rgb = abs(glyphs[cellPos].rgb - color.rgb);
+    }
+
+    // Layer 4:
+    // The current selection is drawn semi-transparent on top.
+    if (cell.flags & CellFlags_Selected)
+    {
+        color = alphaBlendPremultiplied(color, decodeRGBA(selectionColor));
+    }
+
+    return color;
+}
diff --git a/src/renderer/atlas/shader_vs.hlsl b/src/renderer/atlas/shader_vs.hlsl
new file mode 100644
index 000000000..e4c75b3e9
--- /dev/null
+++ b/src/renderer/atlas/shader_vs.hlsl
@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+// clang-format off
+float4 main(uint id: SV_VERTEXID): SV_POSITION
+// clang-format on
+{
+    // The algorithm below is a fast way to generate a full screen triangle,
+    // published by Bill Bilodeau "Vertex Shader Tricks" at GDC14.
+    // It covers the entire viewport and is faster for the GPU than a quad/rectangle.
+    return float4(
+        float(id / 2) * 4.0 - 1.0,
+        float(id % 2) * 4.0 - 1.0,
+        0.0,
+        1.0
+    );
+}
diff --git a/src/renderer/base/RenderEngineBase.cpp b/src/renderer/base/RenderEngineBase.cpp
index a32b4b525..cba14c726 100644
--- a/src/renderer/base/RenderEngineBase.cpp
+++ b/src/renderer/base/RenderEngineBase.cpp
@@ -74,5 +74,6 @@ HRESULT RenderEngineBase::PrepareLineTransform(const LineRendition /*lineRenditi
 // - Blocks until the engine is able to render without blocking.
 void RenderEngineBase::WaitUntilCanRender() noexcept
 {
-    // do nothing by default
+    // Throttle the render loop a bit by default (~60 FPS), improving throughput.
+    Sleep(8);
 }
diff --git a/src/renderer/base/thread.cpp b/src/renderer/base/thread.cpp
index 8bd9a1bd8..1aa45e7b5 100644
--- a/src/renderer/base/thread.cpp
+++ b/src/renderer/base/thread.cpp
@@ -213,12 +213,6 @@ DWORD WINAPI RenderThread::_ThreadProc()
         LOG_IF_FAILED(_pRenderer->PaintFrame());
 
         SetEvent(_hPaintCompletedEvent);
-
-        // extra check before we sleep since it's a "long" activity, relatively speaking.
-        if (_fKeepRunning)
-        {
-            Sleep(s_FrameLimitMilliseconds);
-        }
     }
 
     return S_OK;
diff --git a/src/renderer/base/thread.hpp b/src/renderer/base/thread.hpp
index e65bb1771..62ffb42ce 100644
--- a/src/renderer/base/thread.hpp
+++ b/src/renderer/base/thread.hpp
@@ -37,8 +37,6 @@ namespace Microsoft::Console::Render
         static DWORD WINAPI s_ThreadProc(_In_ LPVOID lpParameter);
         DWORD WINAPI _ThreadProc();
 
-        static DWORD const s_FrameLimitMilliseconds = 8;
-
         HANDLE _hThread;
         HANDLE _hEvent;
 
diff --git a/src/renderer/dx/CustomTextLayout.cpp b/src/renderer/dx/CustomTextLayout.cpp
index d0b789131..a0c0804c4 100644
--- a/src/renderer/dx/CustomTextLayout.cpp
+++ b/src/renderer/dx/CustomTextLayout.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
 #include "precomp.h"
@@ -404,9 +404,9 @@ CATCH_RETURN()
         std::vector<DWRITE_SHAPING_GLYPH_PROPERTIES> glyphProps(maxGlyphCount);
 
         // Get the features to apply to the font
-        auto features = _fontRenderData->DefaultFontFeatures();
-        DWRITE_FONT_FEATURE* featureList = features.data();
-        DWRITE_TYPOGRAPHIC_FEATURES typographicFeatures = { &featureList[0], gsl::narrow<uint32_t>(features.size()) };
+        const auto& features = _fontRenderData->DefaultFontFeatures();
+#pragma warning(suppress : 26492) // Don't use const_cast to cast away const or volatile (type.3).
+        DWRITE_TYPOGRAPHIC_FEATURES typographicFeatures = { const_cast<DWRITE_FONT_FEATURE*>(features.data()), gsl::narrow<uint32_t>(features.size()) };
         DWRITE_TYPOGRAPHIC_FEATURES const* typographicFeaturesPointer = &typographicFeatures;
         const uint32_t fontFeatureLengths[] = { textLength };
 
diff --git a/src/renderer/dx/CustomTextRenderer.cpp b/src/renderer/dx/CustomTextRenderer.cpp
index c00c05624..b1f7b7638 100644
--- a/src/renderer/dx/CustomTextRenderer.cpp
+++ b/src/renderer/dx/CustomTextRenderer.cpp
@@ -487,6 +487,7 @@ CATCH_RETURN()
 {
     // Color glyph rendering sourced from https://github.com/Microsoft/Windows-universal-samples/tree/master/Samples/DWriteColorGlyph
 
+#pragma warning(suppress : 26429) // Symbol 'drawingContext' is never tested for nullness, it can be marked as not_null (f.23).
     DrawingContext* drawingContext = static_cast<DrawingContext*>(clientDrawingContext);
 
     // Since we've delegated the drawing of the background of the text into this function, the origin passed in isn't actually the baseline.
diff --git a/src/renderer/dx/DxRenderer.cpp b/src/renderer/dx/DxRenderer.cpp
index bbbdb8b20..4a99dbfac 100644
--- a/src/renderer/dx/DxRenderer.cpp
+++ b/src/renderer/dx/DxRenderer.cpp
@@ -244,10 +244,11 @@ bool DxEngine::_HasTerminalEffects() const noexcept
 // Arguments:
 // Return Value:
 // - Void
-void DxEngine::ToggleShaderEffects()
+void DxEngine::ToggleShaderEffects() noexcept
 {
     _terminalEffectsEnabled = !_terminalEffectsEnabled;
     _recreateDeviceRequested = true;
+#pragma warning(suppress : 26447) // The function is declared 'noexcept' but calls function 'Log_IfFailed()' which may throw exceptions (f.6).
     LOG_IF_FAILED(InvalidateAll());
 }
 
@@ -969,14 +970,14 @@ try
 }
 CATCH_RETURN();
 
-void DxEngine::SetCallback(std::function<void()> pfn)
+void DxEngine::SetCallback(std::function<void()> pfn) noexcept
 {
-    _pfn = pfn;
+    _pfn = std::move(pfn);
 }
 
-void DxEngine::SetWarningCallback(std::function<void(const HRESULT)> pfn)
+void DxEngine::SetWarningCallback(std::function<void(const HRESULT)> pfn) noexcept
 {
-    _pfnWarningCallback = pfn;
+    _pfnWarningCallback = std::move(pfn);
 }
 
 bool DxEngine::GetRetroTerminalEffect() const noexcept
@@ -1046,11 +1047,12 @@ try
 }
 CATCH_LOG()
 
-HANDLE DxEngine::GetSwapChainHandle()
+HANDLE DxEngine::GetSwapChainHandle() noexcept
 {
     if (!_swapChainHandle)
     {
-        THROW_IF_FAILED(_CreateDeviceResources(true));
+#pragma warning(suppress : 26447) // The function is declared 'noexcept' but calls function 'Log_IfFailed()' which may throw exceptions (f.6).
+        LOG_IF_FAILED(_CreateDeviceResources(true));
     }
 
     return _swapChainHandle.get();
@@ -1498,18 +1500,13 @@ CATCH_RETURN()
 // - See https://docs.microsoft.com/en-us/windows/uwp/gaming/reduce-latency-with-dxgi-1-3-swap-chains.
 void DxEngine::WaitUntilCanRender() noexcept
 {
-    if (!_swapChainFrameLatencyWaitableObject)
-    {
-        return;
-    }
+    // Throttle the DxEngine a bit down to ~60 FPS.
+    // This improves throughput for rendering complex or colored text.
+    Sleep(8);
 
-    const auto ret = WaitForSingleObjectEx(
-        _swapChainFrameLatencyWaitableObject.get(),
-        1000, // 1 second timeout (shouldn't ever occur)
-        true);
-    if (ret != WAIT_OBJECT_0)
+    if (_swapChainFrameLatencyWaitableObject)
     {
-        LOG_WIN32_MSG(ret, "Waiting for swap chain frame latency waitable object returned error or timeout.");
+        WaitForSingleObjectEx(_swapChainFrameLatencyWaitableObject.get(), 100, true);
     }
 }
 
@@ -2023,7 +2020,7 @@ try
 }
 CATCH_RETURN();
 
-[[nodiscard]] Viewport DxEngine::GetViewportInCharacters(const Viewport& viewInPixels) noexcept
+[[nodiscard]] Viewport DxEngine::GetViewportInCharacters(const Viewport& viewInPixels) const noexcept
 {
     const short widthInChars = base::saturated_cast<short>(viewInPixels.Width() / _fontRenderData->GlyphCell().width());
     const short heightInChars = base::saturated_cast<short>(viewInPixels.Height() / _fontRenderData->GlyphCell().height());
@@ -2031,7 +2028,7 @@ CATCH_RETURN();
     return Viewport::FromDimensions(viewInPixels.Origin(), { widthInChars, heightInChars });
 }
 
-[[nodiscard]] Viewport DxEngine::GetViewportInPixels(const Viewport& viewInCharacters) noexcept
+[[nodiscard]] Viewport DxEngine::GetViewportInPixels(const Viewport& viewInCharacters) const noexcept
 {
     const short widthInPixels = base::saturated_cast<short>(viewInCharacters.Width() * _fontRenderData->GlyphCell().width());
     const short heightInPixels = base::saturated_cast<short>(viewInCharacters.Height() * _fontRenderData->GlyphCell().height());
diff --git a/src/renderer/dx/DxRenderer.hpp b/src/renderer/dx/DxRenderer.hpp
index de9c69fd0..22aa0132c 100644
--- a/src/renderer/dx/DxRenderer.hpp
+++ b/src/renderer/dx/DxRenderer.hpp
@@ -49,28 +49,28 @@ namespace Microsoft::Console::Render
         // Used to release device resources so that another instance of
         // conhost can render to the screen (i.e. only one DirectX
         // application may control the screen at a time.)
-        [[nodiscard]] HRESULT Enable() noexcept;
+        [[nodiscard]] HRESULT Enable() noexcept override;
         [[nodiscard]] HRESULT Disable() noexcept;
 
-        [[nodiscard]] HRESULT SetHwnd(const HWND hwnd) noexcept;
+        [[nodiscard]] HRESULT SetHwnd(const HWND hwnd) noexcept override;
 
-        [[nodiscard]] HRESULT SetWindowSize(const SIZE pixels) noexcept;
+        [[nodiscard]] HRESULT SetWindowSize(const SIZE pixels) noexcept override;
 
-        void SetCallback(std::function<void()> pfn);
-        void SetWarningCallback(std::function<void(const HRESULT)> pfn);
+        void SetCallback(std::function<void()> pfn) noexcept override;
+        void SetWarningCallback(std::function<void(const HRESULT)> pfn) noexcept override;
 
-        void ToggleShaderEffects();
+        void ToggleShaderEffects() noexcept override;
 
-        bool GetRetroTerminalEffect() const noexcept;
-        void SetRetroTerminalEffect(bool enable) noexcept;
+        bool GetRetroTerminalEffect() const noexcept override;
+        void SetRetroTerminalEffect(bool enable) noexcept override;
 
-        void SetPixelShaderPath(std::wstring_view value) noexcept;
+        void SetPixelShaderPath(std::wstring_view value) noexcept override;
 
-        void SetForceFullRepaintRendering(bool enable) noexcept;
+        void SetForceFullRepaintRendering(bool enable) noexcept override;
 
-        void SetSoftwareRendering(bool enable) noexcept;
+        void SetSoftwareRendering(bool enable) noexcept override;
 
-        HANDLE GetSwapChainHandle();
+        HANDLE GetSwapChainHandle() noexcept override;
 
         // IRenderEngine Members
         [[nodiscard]] HRESULT Invalidate(const SMALL_RECT* const psrRegion) noexcept override;
@@ -110,7 +110,7 @@ namespace Microsoft::Console::Render
                                                    const bool usingSoftFont,
                                                    const bool isSettingDefaultBrushes) noexcept override;
         [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& fiFontInfoDesired, FontInfo& fiFontInfo) noexcept override;
-        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& fiFontInfoDesired, FontInfo& fiFontInfo, const std::unordered_map<std::wstring_view, uint32_t>& features, const std::unordered_map<std::wstring_view, float>& axes) noexcept;
+        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& fiFontInfoDesired, FontInfo& fiFontInfo, const std::unordered_map<std::wstring_view, uint32_t>& features, const std::unordered_map<std::wstring_view, float>& axes) noexcept override;
         [[nodiscard]] HRESULT UpdateDpi(int const iDpi) noexcept override;
         [[nodiscard]] HRESULT UpdateViewport(const SMALL_RECT srNewViewport) noexcept override;
 
@@ -121,17 +121,17 @@ namespace Microsoft::Console::Render
         [[nodiscard]] HRESULT GetFontSize(_Out_ COORD* const pFontSize) noexcept override;
         [[nodiscard]] HRESULT IsGlyphWideByFont(const std::wstring_view glyph, _Out_ bool* const pResult) noexcept override;
 
-        [[nodiscard]] ::Microsoft::Console::Types::Viewport GetViewportInCharacters(const ::Microsoft::Console::Types::Viewport& viewInPixels) noexcept;
-        [[nodiscard]] ::Microsoft::Console::Types::Viewport GetViewportInPixels(const ::Microsoft::Console::Types::Viewport& viewInCharacters) noexcept;
+        [[nodiscard]] ::Microsoft::Console::Types::Viewport GetViewportInCharacters(const ::Microsoft::Console::Types::Viewport& viewInPixels) const noexcept override;
+        [[nodiscard]] ::Microsoft::Console::Types::Viewport GetViewportInPixels(const ::Microsoft::Console::Types::Viewport& viewInCharacters) const noexcept override;
 
-        float GetScaling() const noexcept;
+        float GetScaling() const noexcept override;
 
-        void SetSelectionBackground(const COLORREF color, const float alpha = 0.5f) noexcept;
-        void SetAntialiasingMode(const D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept;
-        void SetDefaultTextBackgroundOpacity(const float opacity) noexcept;
-        void SetIntenseIsBold(const bool opacity) noexcept;
+        void SetSelectionBackground(const COLORREF color, const float alpha = 0.5f) noexcept override;
+        void SetAntialiasingMode(const D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept override;
+        void SetDefaultTextBackgroundOpacity(const float opacity) noexcept override;
+        void SetIntenseIsBold(const bool opacity) noexcept override;
 
-        void UpdateHyperlinkHoveredId(const uint16_t hoveredId) noexcept;
+        void UpdateHyperlinkHoveredId(const uint16_t hoveredId) noexcept override;
 
     protected:
         [[nodiscard]] HRESULT _DoUpdateTitle(_In_ const std::wstring_view newTitle) noexcept override;
diff --git a/src/renderer/inc/IRenderEngine.hpp b/src/renderer/inc/IRenderEngine.hpp
index 4dd69be8a..30844b217 100644
--- a/src/renderer/inc/IRenderEngine.hpp
+++ b/src/renderer/inc/IRenderEngine.hpp
@@ -14,12 +14,16 @@ Author(s):
 
 #pragma once
 
+#include <d2d1.h>
+
 #include "CursorOptions.h"
 #include "Cluster.hpp"
 #include "FontInfoDesired.hpp"
 #include "IRenderData.hpp"
 #include "../../buffer/out/LineRendition.hpp"
 
+#pragma warning(push)
+#pragma warning(disable : 4100) // '...': unreferenced formal parameter
 namespace Microsoft::Console::Render
 {
     struct RenderFrameInfo
@@ -44,78 +48,75 @@ namespace Microsoft::Console::Render
         };
         using GridLineSet = til::enumset<GridLines>;
 
-        virtual ~IRenderEngine() = 0;
+#pragma warning(suppress : 26432) // If you define or delete any default operation in the type '...', define or delete them all (c.21).
+        virtual ~IRenderEngine()
+        {
+        }
 
-    protected:
-        IRenderEngine() = default;
-        IRenderEngine(const IRenderEngine&) = default;
-        IRenderEngine(IRenderEngine&&) = default;
-        IRenderEngine& operator=(const IRenderEngine&) = default;
-        IRenderEngine& operator=(IRenderEngine&&) = default;
-
-    public:
         [[nodiscard]] virtual HRESULT StartPaint() noexcept = 0;
         [[nodiscard]] virtual HRESULT EndPaint() noexcept = 0;
-
         [[nodiscard]] virtual bool RequiresContinuousRedraw() noexcept = 0;
         virtual void WaitUntilCanRender() noexcept = 0;
         [[nodiscard]] virtual HRESULT Present() noexcept = 0;
-
-        [[nodiscard]] virtual HRESULT PrepareForTeardown(_Out_ bool* const pForcePaint) noexcept = 0;
-
+        [[nodiscard]] virtual HRESULT PrepareForTeardown(_Out_ bool* pForcePaint) noexcept = 0;
         [[nodiscard]] virtual HRESULT ScrollFrame() noexcept = 0;
-
-        [[nodiscard]] virtual HRESULT Invalidate(const SMALL_RECT* const psrRegion) noexcept = 0;
-        [[nodiscard]] virtual HRESULT InvalidateCursor(const SMALL_RECT* const psrRegion) noexcept = 0;
-        [[nodiscard]] virtual HRESULT InvalidateSystem(const RECT* const prcDirtyClient) noexcept = 0;
+        [[nodiscard]] virtual HRESULT Invalidate(const SMALL_RECT* psrRegion) noexcept = 0;
+        [[nodiscard]] virtual HRESULT InvalidateCursor(const SMALL_RECT* psrRegion) noexcept = 0;
+        [[nodiscard]] virtual HRESULT InvalidateSystem(const RECT* prcDirtyClient) noexcept = 0;
         [[nodiscard]] virtual HRESULT InvalidateSelection(const std::vector<SMALL_RECT>& rectangles) noexcept = 0;
-        [[nodiscard]] virtual HRESULT InvalidateScroll(const COORD* const pcoordDelta) noexcept = 0;
+        [[nodiscard]] virtual HRESULT InvalidateScroll(const COORD* pcoordDelta) noexcept = 0;
         [[nodiscard]] virtual HRESULT InvalidateAll() noexcept = 0;
-        [[nodiscard]] virtual HRESULT InvalidateCircling(_Out_ bool* const pForcePaint) noexcept = 0;
-
-        [[nodiscard]] virtual HRESULT InvalidateTitle(const std::wstring_view proposedTitle) noexcept = 0;
-
+        [[nodiscard]] virtual HRESULT InvalidateCircling(_Out_ bool* pForcePaint) noexcept = 0;
+        [[nodiscard]] virtual HRESULT InvalidateTitle(std::wstring_view proposedTitle) noexcept = 0;
         [[nodiscard]] virtual HRESULT PrepareRenderInfo(const RenderFrameInfo& info) noexcept = 0;
-
         [[nodiscard]] virtual HRESULT ResetLineTransform() noexcept = 0;
-        [[nodiscard]] virtual HRESULT PrepareLineTransform(const LineRendition lineRendition,
-                                                           const size_t targetRow,
-                                                           const size_t viewportLeft) noexcept = 0;
-
+        [[nodiscard]] virtual HRESULT PrepareLineTransform(LineRendition lineRendition, size_t targetRow, size_t viewportLeft) noexcept = 0;
         [[nodiscard]] virtual HRESULT PaintBackground() noexcept = 0;
-        [[nodiscard]] virtual HRESULT PaintBufferLine(gsl::span<const Cluster> const clusters,
-                                                      const COORD coord,
-                                                      const bool fTrimLeft,
-                                                      const bool lineWrapped) noexcept = 0;
-        [[nodiscard]] virtual HRESULT PaintBufferGridLines(const GridLineSet lines,
-                                                           const COLORREF color,
-                                                           const size_t cchLine,
-                                                           const COORD coordTarget) noexcept = 0;
-        [[nodiscard]] virtual HRESULT PaintSelection(const SMALL_RECT rect) noexcept = 0;
-
+        [[nodiscard]] virtual HRESULT PaintBufferLine(gsl::span<const Cluster> clusters, COORD coord, bool fTrimLeft, bool lineWrapped) noexcept = 0;
+        [[nodiscard]] virtual HRESULT PaintBufferGridLines(GridLineSet lines, COLORREF color, size_t cchLine, COORD coordTarget) noexcept = 0;
+        [[nodiscard]] virtual HRESULT PaintSelection(SMALL_RECT rect) noexcept = 0;
         [[nodiscard]] virtual HRESULT PaintCursor(const CursorOptions& options) noexcept = 0;
-
-        [[nodiscard]] virtual HRESULT UpdateDrawingBrushes(const TextAttribute& textAttributes,
-                                                           const gsl::not_null<IRenderData*> pData,
-                                                           const bool usingSoftFont,
-                                                           const bool isSettingDefaultBrushes) noexcept = 0;
-        [[nodiscard]] virtual HRESULT UpdateFont(const FontInfoDesired& FontInfoDesired,
-                                                 _Out_ FontInfo& FontInfo) noexcept = 0;
-        [[nodiscard]] virtual HRESULT UpdateSoftFont(const gsl::span<const uint16_t> bitPattern,
-                                                     const SIZE cellSize,
-                                                     const size_t centeringHint) noexcept = 0;
-        [[nodiscard]] virtual HRESULT UpdateDpi(const int iDpi) noexcept = 0;
-        [[nodiscard]] virtual HRESULT UpdateViewport(const SMALL_RECT srNewViewport) noexcept = 0;
-
-        [[nodiscard]] virtual HRESULT GetProposedFont(const FontInfoDesired& FontInfoDesired,
-                                                      _Out_ FontInfo& FontInfo,
-                                                      const int iDpi) noexcept = 0;
-
+        [[nodiscard]] virtual HRESULT UpdateDrawingBrushes(const TextAttribute& textAttributes, gsl::not_null<IRenderData*> pData, bool usingSoftFont, bool isSettingDefaultBrushes) noexcept = 0;
+        [[nodiscard]] virtual HRESULT UpdateFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo) noexcept = 0;
+        [[nodiscard]] virtual HRESULT UpdateSoftFont(gsl::span<const uint16_t> bitPattern, SIZE cellSize, size_t centeringHint) noexcept = 0;
+        [[nodiscard]] virtual HRESULT UpdateDpi(int iDpi) noexcept = 0;
+        [[nodiscard]] virtual HRESULT UpdateViewport(SMALL_RECT srNewViewport) noexcept = 0;
+        [[nodiscard]] virtual HRESULT GetProposedFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo, int iDpi) noexcept = 0;
         [[nodiscard]] virtual HRESULT GetDirtyArea(gsl::span<const til::rectangle>& area) noexcept = 0;
-        [[nodiscard]] virtual HRESULT GetFontSize(_Out_ COORD* const pFontSize) noexcept = 0;
-        [[nodiscard]] virtual HRESULT IsGlyphWideByFont(const std::wstring_view glyph, _Out_ bool* const pResult) noexcept = 0;
-        [[nodiscard]] virtual HRESULT UpdateTitle(const std::wstring_view newTitle) noexcept = 0;
-    };
+        [[nodiscard]] virtual HRESULT GetFontSize(_Out_ COORD* pFontSize) noexcept = 0;
+        [[nodiscard]] virtual HRESULT IsGlyphWideByFont(std::wstring_view glyph, _Out_ bool* pResult) noexcept = 0;
+        [[nodiscard]] virtual HRESULT UpdateTitle(std::wstring_view newTitle) noexcept = 0;
 
-    inline Microsoft::Console::Render::IRenderEngine::~IRenderEngine() {}
+        // The following functions used to be specific to the DxRenderer and they should
+        // be abstracted away and integrated into the above or simply get removed.
+
+        // DxRenderer - getter
+        virtual HRESULT Enable() noexcept { return S_OK; }
+        virtual [[nodiscard]] bool GetRetroTerminalEffect() const noexcept { return false; }
+        virtual [[nodiscard]] float GetScaling() const noexcept { return 1; }
+#pragma warning(suppress : 26440) // Function '...' can be declared 'noexcept' (f.6).
+        virtual [[nodiscard]] HANDLE GetSwapChainHandle()
+        {
+            return nullptr;
+        }
+        virtual [[nodiscard]] Types::Viewport GetViewportInCharacters(const Types::Viewport& viewInPixels) const noexcept { return Types::Viewport::Empty(); }
+        virtual [[nodiscard]] Types::Viewport GetViewportInPixels(const Types::Viewport& viewInCharacters) const noexcept { return Types::Viewport::Empty(); }
+        // DxRenderer - setter
+        virtual void SetAntialiasingMode(const D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept {}
+        virtual void SetCallback(std::function<void()> pfn) noexcept {}
+        virtual void SetDefaultTextBackgroundOpacity(const float opacity) noexcept {}
+        virtual void SetForceFullRepaintRendering(bool enable) noexcept {}
+        virtual [[nodiscard]] HRESULT SetHwnd(const HWND hwnd) noexcept { return E_NOTIMPL; }
+        virtual void SetPixelShaderPath(std::wstring_view value) noexcept {}
+        virtual void SetRetroTerminalEffect(bool enable) noexcept {}
+        virtual void SetSelectionBackground(const COLORREF color, const float alpha = 0.5f) noexcept {}
+        virtual void SetSoftwareRendering(bool enable) noexcept {}
+        virtual void SetIntenseIsBold(bool enable) noexcept {}
+        virtual void SetWarningCallback(std::function<void(HRESULT)> pfn) noexcept {}
+        virtual [[nodiscard]] HRESULT SetWindowSize(const SIZE pixels) noexcept { return E_NOTIMPL; }
+        virtual void ToggleShaderEffects() noexcept {}
+        virtual [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& pfiFontInfoDesired, FontInfo& fiFontInfo, const std::unordered_map<std::wstring_view, uint32_t>& features, const std::unordered_map<std::wstring_view, float>& axes) noexcept { return E_NOTIMPL; }
+        virtual void UpdateHyperlinkHoveredId(const uint16_t hoveredId) noexcept {}
+    };
 }
+#pragma warning(pop)
diff --git a/src/renderer/uia/UiaRenderer.cpp b/src/renderer/uia/UiaRenderer.cpp
index f3206e79d..8349d710a 100644
--- a/src/renderer/uia/UiaRenderer.cpp
+++ b/src/renderer/uia/UiaRenderer.cpp
@@ -261,6 +261,13 @@ CATCH_RETURN();
     return S_OK;
 }
 
+// RenderEngineBase defines a WaitUntilCanRender() that sleeps for 8ms to throttle rendering.
+// But UiaEngine is never the only engine running. Overriding this function prevents
+// us from sleeping 16ms per frame, when the other engine also sleeps for 8ms.
+void UiaEngine::WaitUntilCanRender() noexcept
+{
+}
+
 // Routine Description:
 // - Used to perform longer running presentation steps outside the lock so the
 //      other threads can continue.
diff --git a/src/renderer/uia/UiaRenderer.hpp b/src/renderer/uia/UiaRenderer.hpp
index 8c438f055..3b187f646 100644
--- a/src/renderer/uia/UiaRenderer.hpp
+++ b/src/renderer/uia/UiaRenderer.hpp
@@ -30,18 +30,16 @@ namespace Microsoft::Console::Render
         // Only one UiaEngine may present information at a time.
         // This ensures that an automation client isn't overwhelmed
         // by events when there are multiple TermControls
-        [[nodiscard]] HRESULT Enable() noexcept;
+        [[nodiscard]] HRESULT Enable() noexcept override;
         [[nodiscard]] HRESULT Disable() noexcept;
 
         // IRenderEngine Members
         [[nodiscard]] HRESULT StartPaint() noexcept override;
         [[nodiscard]] HRESULT EndPaint() noexcept override;
+        void WaitUntilCanRender() noexcept override;
         [[nodiscard]] HRESULT Present() noexcept override;
-
         [[nodiscard]] HRESULT PrepareForTeardown(_Out_ bool* const pForcePaint) noexcept override;
-
         [[nodiscard]] HRESULT ScrollFrame() noexcept override;
-
         [[nodiscard]] HRESULT Invalidate(const SMALL_RECT* const psrRegion) noexcept override;
         [[nodiscard]] HRESULT InvalidateCursor(const SMALL_RECT* const psrRegion) noexcept override;
         [[nodiscard]] HRESULT InvalidateSystem(const RECT* const prcDirtyClient) noexcept override;
@@ -49,27 +47,16 @@ namespace Microsoft::Console::Render
         [[nodiscard]] HRESULT InvalidateScroll(const COORD* const pcoordDelta) noexcept override;
         [[nodiscard]] HRESULT InvalidateAll() noexcept override;
         [[nodiscard]] HRESULT InvalidateCircling(_Out_ bool* const pForcePaint) noexcept override;
-
         [[nodiscard]] HRESULT PaintBackground() noexcept override;
-        [[nodiscard]] HRESULT PaintBufferLine(gsl::span<const Cluster> const clusters,
-                                              COORD const coord,
-                                              bool const fTrimLeft,
-                                              const bool lineWrapped) noexcept override;
-        [[nodiscard]] HRESULT PaintBufferGridLines(GridLineSet const lines, COLORREF const color, size_t const cchLine, COORD const coordTarget) noexcept override;
+        [[nodiscard]] HRESULT PaintBufferLine(gsl::span<const Cluster> const clusters, const COORD coord, const bool fTrimLeft, const bool lineWrapped) noexcept override;
+        [[nodiscard]] HRESULT PaintBufferGridLines(const GridLineSet lines, const COLORREF color, const size_t cchLine, const COORD coordTarget) noexcept override;
         [[nodiscard]] HRESULT PaintSelection(const SMALL_RECT rect) noexcept override;
-
         [[nodiscard]] HRESULT PaintCursor(const CursorOptions& options) noexcept override;
-
-        [[nodiscard]] HRESULT UpdateDrawingBrushes(const TextAttribute& textAttributes,
-                                                   const gsl::not_null<IRenderData*> pData,
-                                                   const bool usingSoftFont,
-                                                   const bool isSettingDefaultBrushes) noexcept override;
-        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& fiFontInfoDesired, FontInfo& fiFontInfo) noexcept override;
-        [[nodiscard]] HRESULT UpdateDpi(int const iDpi) noexcept override;
+        [[nodiscard]] HRESULT UpdateDrawingBrushes(const TextAttribute& textAttributes, const gsl::not_null<IRenderData*> pData, const bool usingSoftFont, const bool isSettingDefaultBrushes) noexcept override;
+        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo) noexcept override;
+        [[nodiscard]] HRESULT UpdateDpi(const int iDpi) noexcept override;
         [[nodiscard]] HRESULT UpdateViewport(const SMALL_RECT srNewViewport) noexcept override;
-
-        [[nodiscard]] HRESULT GetProposedFont(const FontInfoDesired& fiFontInfoDesired, FontInfo& fiFontInfo, int const iDpi) noexcept override;
-
+        [[nodiscard]] HRESULT GetProposedFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo, const int iDpi) noexcept override;
         [[nodiscard]] HRESULT GetDirtyArea(gsl::span<const til::rectangle>& area) noexcept override;
         [[nodiscard]] HRESULT GetFontSize(_Out_ COORD* const pFontSize) noexcept override;
         [[nodiscard]] HRESULT IsGlyphWideByFont(const std::wstring_view glyph, _Out_ bool* const pResult) noexcept override;
diff --git a/src/renderer/vt/vtrenderer.hpp b/src/renderer/vt/vtrenderer.hpp
index f78adf647..9a39f5599 100644
--- a/src/renderer/vt/vtrenderer.hpp
+++ b/src/renderer/vt/vtrenderer.hpp
@@ -43,70 +43,41 @@ namespace Microsoft::Console::Render
         VtEngine(_In_ wil::unique_hfile hPipe,
                  const Microsoft::Console::Types::Viewport initialViewport);
 
-        virtual ~VtEngine() override = default;
-
+        // IRenderEngine
+        [[nodiscard]] HRESULT StartPaint() noexcept override;
+        [[nodiscard]] HRESULT EndPaint() noexcept override;
+        [[nodiscard]] HRESULT Present() noexcept override;
+        [[nodiscard]] HRESULT PrepareForTeardown(_Out_ bool* pForcePaint) noexcept override;
+        [[nodiscard]] HRESULT Invalidate(const SMALL_RECT* psrRegion) noexcept override;
+        [[nodiscard]] HRESULT InvalidateCursor(const SMALL_RECT* psrRegion) noexcept override;
+        [[nodiscard]] HRESULT InvalidateSystem(const RECT* prcDirtyClient) noexcept override;
         [[nodiscard]] HRESULT InvalidateSelection(const std::vector<SMALL_RECT>& rectangles) noexcept override;
-        [[nodiscard]] virtual HRESULT InvalidateScroll(const COORD* const pcoordDelta) noexcept = 0;
-        [[nodiscard]] HRESULT InvalidateSystem(const RECT* const prcDirtyClient) noexcept override;
-        [[nodiscard]] HRESULT Invalidate(const SMALL_RECT* const psrRegion) noexcept override;
-        [[nodiscard]] HRESULT InvalidateCursor(const SMALL_RECT* const psrRegion) noexcept override;
         [[nodiscard]] HRESULT InvalidateAll() noexcept override;
-        [[nodiscard]] HRESULT InvalidateCircling(_Out_ bool* const pForcePaint) noexcept override;
-        [[nodiscard]] HRESULT PrepareForTeardown(_Out_ bool* const pForcePaint) noexcept override;
-
-        [[nodiscard]] virtual HRESULT StartPaint() noexcept override;
-        [[nodiscard]] virtual HRESULT EndPaint() noexcept override;
-        [[nodiscard]] virtual HRESULT Present() noexcept override;
-
-        [[nodiscard]] virtual HRESULT ScrollFrame() noexcept = 0;
-
+        [[nodiscard]] HRESULT InvalidateCircling(_Out_ bool* pForcePaint) noexcept override;
         [[nodiscard]] HRESULT PaintBackground() noexcept override;
-        [[nodiscard]] virtual HRESULT PaintBufferLine(gsl::span<const Cluster> const clusters,
-                                                      const COORD coord,
-                                                      const bool trimLeft,
-                                                      const bool lineWrapped) noexcept override;
-        [[nodiscard]] HRESULT PaintBufferGridLines(const GridLineSet lines,
-                                                   const COLORREF color,
-                                                   const size_t cchLine,
-                                                   const COORD coordTarget) noexcept override;
-        [[nodiscard]] HRESULT PaintSelection(const SMALL_RECT rect) noexcept override;
-
-        [[nodiscard]] virtual HRESULT PaintCursor(const CursorOptions& options) noexcept override;
-
-        [[nodiscard]] virtual HRESULT UpdateDrawingBrushes(const TextAttribute& textAttributes,
-                                                           const gsl::not_null<IRenderData*> pData,
-                                                           const bool usingSoftFont,
-                                                           const bool isSettingDefaultBrushes) noexcept = 0;
-        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& pfiFontInfoDesired,
-                                         _Out_ FontInfo& pfiFontInfo) noexcept override;
-        [[nodiscard]] HRESULT UpdateDpi(const int iDpi) noexcept override;
-        [[nodiscard]] HRESULT UpdateViewport(const SMALL_RECT srNewViewport) noexcept override;
-
-        [[nodiscard]] HRESULT GetProposedFont(const FontInfoDesired& FontDesired,
-                                              _Out_ FontInfo& Font,
-                                              const int iDpi) noexcept override;
-
+        [[nodiscard]] HRESULT PaintBufferLine(gsl::span<const Cluster> clusters, COORD coord, bool fTrimLeft, bool lineWrapped) noexcept override;
+        [[nodiscard]] HRESULT PaintBufferGridLines(GridLineSet lines, COLORREF color, size_t cchLine, COORD coordTarget) noexcept override;
+        [[nodiscard]] HRESULT PaintSelection(SMALL_RECT rect) noexcept override;
+        [[nodiscard]] HRESULT PaintCursor(const CursorOptions& options) noexcept override;
+        [[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo) noexcept override;
+        [[nodiscard]] HRESULT UpdateDpi(int iDpi) noexcept override;
+        [[nodiscard]] HRESULT UpdateViewport(SMALL_RECT srNewViewport) noexcept override;
+        [[nodiscard]] HRESULT GetProposedFont(const FontInfoDesired& FontInfoDesired, _Out_ FontInfo& FontInfo, int iDpi) noexcept override;
         [[nodiscard]] HRESULT GetDirtyArea(gsl::span<const til::rectangle>& area) noexcept override;
-        [[nodiscard]] HRESULT GetFontSize(_Out_ COORD* const pFontSize) noexcept override;
-        [[nodiscard]] HRESULT IsGlyphWideByFont(const std::wstring_view glyph, _Out_ bool* const pResult) noexcept override;
+        [[nodiscard]] HRESULT GetFontSize(_Out_ COORD* pFontSize) noexcept override;
+        [[nodiscard]] HRESULT IsGlyphWideByFont(std::wstring_view glyph, _Out_ bool* pResult) noexcept override;
 
+        // VtEngine
         [[nodiscard]] HRESULT SuppressResizeRepaint() noexcept;
-
         [[nodiscard]] HRESULT RequestCursor() noexcept;
         [[nodiscard]] HRESULT InheritCursor(const COORD coordCursor) noexcept;
-
         [[nodiscard]] HRESULT WriteTerminalUtf8(const std::string_view str) noexcept;
-
         [[nodiscard]] virtual HRESULT WriteTerminalW(const std::wstring_view str) noexcept = 0;
-
         void SetTerminalOwner(Microsoft::Console::ITerminalOwner* const terminalOwner);
         void BeginResizeRequest();
         void EndResizeRequest();
-
         void SetResizeQuirk(const bool resizeQuirk);
-
         [[nodiscard]] virtual HRESULT ManuallyClearScrollback() noexcept;
-
         [[nodiscard]] HRESULT RequestWin32Input() noexcept;
 
     protected:
diff --git a/src/renderer/wddmcon/WddmConRenderer.hpp b/src/renderer/wddmcon/WddmConRenderer.hpp
index 0da9f5cba..de564c001 100644
--- a/src/renderer/wddmcon/WddmConRenderer.hpp
+++ b/src/renderer/wddmcon/WddmConRenderer.hpp
@@ -19,7 +19,7 @@ namespace Microsoft::Console::Render
         // Used to release device resources so that another instance of
         // conhost can render to the screen (i.e. only one DirectX
         // application may control the screen at a time.)
-        [[nodiscard]] HRESULT Enable() noexcept;
+        [[nodiscard]] HRESULT Enable() noexcept override;
         [[nodiscard]] HRESULT Disable() noexcept;
 
         RECT GetDisplaySize();

From c79334ffbbcbb0d0483579035328aebd27f517f4 Mon Sep 17 00:00:00 2001
From: Mike Griese <migrie@microsoft.com>
Date: Fri, 12 Nov 2021 18:58:43 -0600
Subject: [PATCH 2/2] Add a file for storing elevated-only state (#11222)

## Summary of the Pull Request

This creates an `elevated-state.json` that lives in `%LOCALAPPDATA%` next to `state.json`, that's only writable when elevated. It doesn't _use_ this file for anything, it just puts the framework down for use later.

It's _just like `ApplicationState`_. We'll use it the same way.

It's readable when unelevated, which is nice, but not writable. If you're dumb and try to write to the file when unelevated, it'll just silently do nothing.

If we try opening the file and find out the permissions are different, we'll _blow the file away entirely_. This is to prevent someone from renaming the original file (which they can do unelevated), then slapping a new file that's writable by them down in it's place.

## References
* We're going to use this in #11096, but these PRs need to be broken up.

## PR Checklist
* [x] Closes nothing
* [x] I work here
* [x] Tests added/passed
* [ ] Requires documentation to be updated - maybe? not sure we have docs on `state.json` at all yet

## Validation Steps Performed
I've played with this much more in `dev/migrie/f/non-terminal-content-elevation-warning`

###### followed by #11308, #11310
---
 .github/actions/spelling/allow/allow.txt      |   1 +
 .github/actions/spelling/allow/apis.txt       |   7 +
 .github/actions/spelling/allow/names.txt      |   1 +
 src/cascadia/TerminalApp/AppLogic.cpp         |  59 ++-
 src/cascadia/TerminalApp/TerminalPage.cpp     |   3 -
 .../ApplicationState.cpp                      | 335 +++++++++++++-----
 .../TerminalSettingsModel/ApplicationState.h  |  65 ++--
 .../ApplicationState.idl                      |   5 +-
 .../TerminalSettingsModel/FileUtils.cpp       | 219 +++++++-----
 .../TerminalSettingsModel/FileUtils.h         |  36 +-
 .../TerminalSettingsModel/JsonUtils.h         |   1 -
 src/cascadia/TerminalSettingsModel/pch.h      |   3 +
 src/cascadia/WindowsTerminal/AppHost.cpp      |  32 +-
 src/types/inc/utils.hpp                       |   1 +
 src/types/utils.cpp                           |  32 ++
 15 files changed, 523 insertions(+), 277 deletions(-)

diff --git a/.github/actions/spelling/allow/allow.txt b/.github/actions/spelling/allow/allow.txt
index f23f8a581..6025abf76 100644
--- a/.github/actions/spelling/allow/allow.txt
+++ b/.github/actions/spelling/allow/allow.txt
@@ -1,3 +1,4 @@
+admins
 apc
 Apc
 bsd
diff --git a/.github/actions/spelling/allow/apis.txt b/.github/actions/spelling/allow/apis.txt
index 45f4e02f1..83ca55178 100644
--- a/.github/actions/spelling/allow/apis.txt
+++ b/.github/actions/spelling/allow/apis.txt
@@ -1,5 +1,7 @@
 ACCEPTFILES
 ACCESSDENIED
+acl
+aclapi
 alignas
 alignof
 APPLYTOSUBMENUS
@@ -21,6 +23,7 @@ commandlinetoargv
 cstdint
 CXICON
 CYICON
+Dacl
 dataobject
 dcomp
 DERR
@@ -117,15 +120,19 @@ OSVERSIONINFOEXW
 otms
 OUTLINETEXTMETRICW
 overridable
+PACL
 PAGESCROLL
+PEXPLICIT
 PICKFOLDERS
 pmr
+ptstr
 rcx
 REGCLS
 RETURNCMD
 rfind
 roundf
 RSHIFT
+SACL
 schandle
 semver
 serializer
diff --git a/.github/actions/spelling/allow/names.txt b/.github/actions/spelling/allow/names.txt
index 3635d3723..2a13d67ba 100644
--- a/.github/actions/spelling/allow/names.txt
+++ b/.github/actions/spelling/allow/names.txt
@@ -9,6 +9,7 @@ Diviness
 dsafa
 duhowett
 ekg
+eryksun
 ethanschoonover
 Firefox
 Gatta
diff --git a/src/cascadia/TerminalApp/AppLogic.cpp b/src/cascadia/TerminalApp/AppLogic.cpp
index 7e5949577..ebc92d505 100644
--- a/src/cascadia/TerminalApp/AppLogic.cpp
+++ b/src/cascadia/TerminalApp/AppLogic.cpp
@@ -12,6 +12,8 @@
 #include <WtExeUtils.h>
 #include <wil/token_helpers.h >
 
+#include "../../types/inc/utils.hpp"
+
 using namespace winrt::Windows::ApplicationModel;
 using namespace winrt::Windows::ApplicationModel::DataTransfer;
 using namespace winrt::Windows::UI::Xaml;
@@ -131,38 +133,6 @@ static Documents::Run _BuildErrorRun(const winrt::hstring& text, const ResourceD
     return textRun;
 }
 
-// Method Description:
-// - Returns whether the user is either a member of the Administrators group or
-//   is currently elevated.
-// - This will return **FALSE** if the user has UAC disabled entirely, because
-//   there's no separation of power between the user and an admin in that case.
-// Return Value:
-// - true if the user is an administrator
-static bool _isUserAdmin() noexcept
-try
-{
-    wil::unique_handle processToken{ GetCurrentProcessToken() };
-    const auto elevationType = wil::get_token_information<TOKEN_ELEVATION_TYPE>(processToken.get());
-    const auto elevationState = wil::get_token_information<TOKEN_ELEVATION>(processToken.get());
-    if (elevationType == TokenElevationTypeDefault && elevationState.TokenIsElevated)
-    {
-        // In this case, the user has UAC entirely disabled. This is sort of
-        // weird, we treat this like the user isn't an admin at all. There's no
-        // separation of powers, so the things we normally want to gate on
-        // "having special powers" doesn't apply.
-        //
-        // See GH#7754, GH#11096
-        return false;
-    }
-
-    return wil::test_token_membership(nullptr, SECURITY_NT_AUTHORITY, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS);
-}
-catch (...)
-{
-    LOG_CAUGHT_EXCEPTION();
-    return false;
-}
-
 namespace winrt::TerminalApp::implementation
 {
     // Function Description:
@@ -214,7 +184,7 @@ namespace winrt::TerminalApp::implementation
         // The TerminalPage has to be constructed during our construction, to
         // make sure that there's a terminal page for callers of
         // SetTitleBarContent
-        _isElevated = _isUserAdmin();
+        _isElevated = ::Microsoft::Console::Utils::IsElevated();
         _root = winrt::make_self<TerminalPage>();
 
         _reloadSettings = std::make_shared<ThrottledFuncTrailing<>>(winrt::Windows::System::DispatcherQueue::GetForCurrentThread(), std::chrono::milliseconds(100), [weakSelf = get_weak()]() {
@@ -910,8 +880,6 @@ namespace winrt::TerminalApp::implementation
     void AppLogic::_RegisterSettingsChange()
     {
         const std::filesystem::path settingsPath{ std::wstring_view{ CascadiaSettings::SettingsPath() } };
-        const std::filesystem::path statePath{ std::wstring_view{ ApplicationState::SharedInstance().FilePath() } };
-
         _reader.create(
             settingsPath.parent_path().c_str(),
             false,
@@ -920,14 +888,29 @@ namespace winrt::TerminalApp::implementation
             // editors, who will write a temp file, then rename it to be the
             // actual file you wrote. So listen for that too.
             wil::FolderChangeEvents::FileName | wil::FolderChangeEvents::LastWriteTime,
-            [this, settingsBasename = settingsPath.filename(), stateBasename = statePath.filename()](wil::FolderChangeEvent, PCWSTR fileModified) {
-                const auto modifiedBasename = std::filesystem::path{ fileModified }.filename();
+            [this, settingsBasename = settingsPath.filename()](wil::FolderChangeEvent, PCWSTR fileModified) {
+                // DO NOT create a static reference to ApplicationState::SharedInstance here.
+                //
+                // ApplicationState::SharedInstance already caches its own
+                // static ref. If _we_ keep a static ref to the member in
+                // AppState, then our reference will keep ApplicationState alive
+                // after the `ActionToStringMap` gets cleaned up. Then, when we
+                // try to persist the actions in the window state, we won't be
+                // able to. We'll try to look up the action and the map just
+                // won't exist. We'll explode, even though the Terminal is
+                // tearing down anyways. So we'll just die, but still invoke
+                // WinDBG's post-mortem debugger, who won't be able to attach to
+                // the process that's already exiting.
+                //
+                // So DON'T ~give a mouse a cookie~ take a static ref here.
+
+                const winrt::hstring modifiedBasename{ std::filesystem::path{ fileModified }.filename().c_str() };
 
                 if (modifiedBasename == settingsBasename)
                 {
                     _reloadSettings->Run();
                 }
-                else if (modifiedBasename == stateBasename)
+                else if (ApplicationState::SharedInstance().IsStatePath(modifiedBasename))
                 {
                     _reloadState();
                 }
diff --git a/src/cascadia/TerminalApp/TerminalPage.cpp b/src/cascadia/TerminalApp/TerminalPage.cpp
index bd9787f04..81e2bc517 100644
--- a/src/cascadia/TerminalApp/TerminalPage.cpp
+++ b/src/cascadia/TerminalApp/TerminalPage.cpp
@@ -300,10 +300,7 @@ namespace winrt::TerminalApp::implementation
     // - true if the ApplicationState should be used.
     bool TerminalPage::ShouldUsePersistedLayout(CascadiaSettings& settings) const
     {
-        // GH#5000 Until there is a separate state file for elevated sessions we should just not
-        // save at all while in an elevated window.
         return Feature_PersistedWindowLayout::IsEnabled() &&
-               !IsElevated() &&
                settings.GlobalSettings().FirstWindowPreference() == FirstWindowPreference::PersistedWindowLayout;
     }
 
diff --git a/src/cascadia/TerminalSettingsModel/ApplicationState.cpp b/src/cascadia/TerminalSettingsModel/ApplicationState.cpp
index 7e5bc1da3..d623ced29 100644
--- a/src/cascadia/TerminalSettingsModel/ApplicationState.cpp
+++ b/src/cascadia/TerminalSettingsModel/ApplicationState.cpp
@@ -9,8 +9,11 @@
 #include "ActionAndArgs.h"
 #include "JsonUtils.h"
 #include "FileUtils.h"
+#include "../../types/inc/utils.hpp"
 
 static constexpr std::wstring_view stateFileName{ L"state.json" };
+static constexpr std::wstring_view elevatedStateFileName{ L"elevated-state.json" };
+
 static constexpr std::string_view TabLayoutKey{ "tabLayout" };
 static constexpr std::string_view InitialPositionKey{ "initialPosition" };
 static constexpr std::string_view InitialSizeKey{ "initialSize" };
@@ -85,15 +88,9 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         return trait.FromJson(root);
     }
 
-    // Returns the application-global ApplicationState object.
-    Microsoft::Terminal::Settings::Model::ApplicationState ApplicationState::SharedInstance()
-    {
-        static auto state = winrt::make_self<ApplicationState>(GetBaseSettingsPath() / stateFileName);
-        return *state;
-    }
-
-    ApplicationState::ApplicationState(std::filesystem::path path) noexcept :
-        _path{ std::move(path) },
+    ApplicationState::ApplicationState(const std::filesystem::path& stateRoot) noexcept :
+        _sharedPath{ stateRoot / stateFileName },
+        _elevatedPath{ stateRoot / elevatedStateFileName },
         _throttler{ std::chrono::seconds(1), [this]() { _write(); } }
     {
         _read();
@@ -102,9 +99,21 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
     // The destructor ensures that the last write is flushed to disk before returning.
     ApplicationState::~ApplicationState()
     {
+        TraceLoggingWrite(g_hSettingsModelProvider,
+                          "ApplicationState_Dtor_Start",
+                          TraceLoggingDescription("Event at the start of the ApplicationState destructor"),
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                          TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+
         // This will ensure that we not just cancel the last outstanding timer,
         // but instead force it to run as soon as possible and wait for it to complete.
         _throttler.flush();
+
+        TraceLoggingWrite(g_hSettingsModelProvider,
+                          "ApplicationState_Dtor_End",
+                          TraceLoggingDescription("Event at the end of the ApplicationState destructor"),
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                          TraceLoggingKeyword(TIL_KEYWORD_TRACE));
     }
 
     // Re-read the state.json from disk.
@@ -113,34 +122,13 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         _read();
     }
 
-    // Returns the state.json path on the disk.
-    winrt::hstring ApplicationState::FilePath() const noexcept
+    bool ApplicationState::IsStatePath(const winrt::hstring& filename)
     {
-        return winrt::hstring{ _path.wstring() };
+        static const auto sharedPath{ _sharedPath.filename() };
+        static const auto elevatedPath{ _elevatedPath.filename() };
+        return filename == sharedPath || filename == elevatedPath;
     }
 
-    // Generate all getter/setters
-#define MTSM_APPLICATION_STATE_GEN(type, name, key, ...)    \
-    type ApplicationState::name() const noexcept            \
-    {                                                       \
-        const auto state = _state.lock_shared();            \
-        const auto& value = state->name;                    \
-        return value ? *value : type{ __VA_ARGS__ };        \
-    }                                                       \
-                                                            \
-    void ApplicationState::name(const type& value) noexcept \
-    {                                                       \
-        {                                                   \
-            auto state = _state.lock();                     \
-            state->name.emplace(value);                     \
-            state->name##Changed = true;                    \
-        }                                                   \
-                                                            \
-        _throttler();                                       \
-    }
-    MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
-#undef MTSM_APPLICATION_STATE_GEN
-
     // Method Description:
     // - See GH#11119. Removes all of the data in this ApplicationState object
     //   and resets it to the defaults. This will delete the state file! That's
@@ -156,57 +144,58 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
     void ApplicationState::Reset() noexcept
     try
     {
-        LOG_LAST_ERROR_IF(!DeleteFile(_path.c_str()));
+        LOG_LAST_ERROR_IF(!DeleteFile(_sharedPath.c_str()));
+        LOG_LAST_ERROR_IF(!DeleteFile(_elevatedPath.c_str()));
         *_state.lock() = {};
     }
     CATCH_LOG()
 
-    Json::Value ApplicationState::_getRoot(const locked_hfile& file) const noexcept
-    {
-        Json::Value root;
-        try
-        {
-            const auto data = ReadUTF8FileLocked(file);
-            if (data.empty())
-            {
-                return root;
-            }
-
-            std::string errs;
-            std::unique_ptr<Json::CharReader> reader{ Json::CharReaderBuilder::CharReaderBuilder().newCharReader() };
-
-            if (!reader->parse(data.data(), data.data() + data.size(), &root, &errs))
-            {
-                throw winrt::hresult_error(WEB_E_INVALID_JSON_STRING, winrt::to_hstring(errs));
-            }
-        }
-        CATCH_LOG()
-
-        return root;
-    }
-
-    // Deserializes the state.json at _path into this ApplicationState.
+    // Deserializes the state.json and user-state (or elevated-state if
+    // elevated) into this ApplicationState.
     // * ANY errors during app state will result in the creation of a new empty state.
     // * ANY errors during runtime will result in changes being partially ignored.
     void ApplicationState::_read() const noexcept
     try
     {
-        auto state = _state.lock();
-        const auto file = OpenFileReadSharedLocked(_path);
+        std::string errs;
+        std::unique_ptr<Json::CharReader> reader{ Json::CharReaderBuilder::CharReaderBuilder().newCharReader() };
 
-        auto root = _getRoot(file);
-        // GetValueForKey() comes in two variants:
-        // * take a std::optional<T> reference
-        // * return std::optional<T> by value
-        // At the time of writing the former version skips missing fields in the json,
-        // but we want to explicitly clear state fields that were removed from state.json.
-#define MTSM_APPLICATION_STATE_GEN(type, name, key, ...)                         \
-    if (!state->name##Changed)                                                   \
-    {                                                                            \
-        state->name = JsonUtils::GetValueForKey<std::optional<type>>(root, key); \
-    }
-        MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
-#undef MTSM_APPLICATION_STATE_GEN
+        // First get shared state out of `state.json`.
+        const auto sharedData = _readSharedContents().value_or(std::string{});
+        if (!sharedData.empty())
+        {
+            Json::Value root;
+            if (!reader->parse(sharedData.data(), sharedData.data() + sharedData.size(), &root, &errs))
+            {
+                throw winrt::hresult_error(WEB_E_INVALID_JSON_STRING, winrt::to_hstring(errs));
+            }
+
+            // - If we're elevated, we want to only load the Shared properties
+            //   from state.json. We'll then load the Local props from
+            //   `elevated-state.json`
+            // - If we're unelevated, then load _everything_ from state.json.
+            if (::Microsoft::Console::Utils::IsElevated())
+            {
+                // Only load shared properties if we're elevated
+                FromJson(root, FileSource::Shared);
+
+                // Then, try and get anything in elevated-state
+                if (const auto localData{ _readLocalContents().value_or(std::string{}) }; !localData.empty())
+                {
+                    Json::Value root;
+                    if (!reader->parse(localData.data(), localData.data() + localData.size(), &root, &errs))
+                    {
+                        throw winrt::hresult_error(WEB_E_INVALID_JSON_STRING, winrt::to_hstring(errs));
+                    }
+                    FromJson(root, FileSource::Local);
+                }
+            }
+            else
+            {
+                // If we're unelevated, then load everything.
+                FromJson(root, FileSource::Shared | FileSource::Local);
+            }
+        }
     }
     CATCH_LOG()
 
@@ -214,29 +203,191 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
     // * Errors are only logged.
     // * _state->_writeScheduled is set to false, signaling our
     //   setters that _synchronize() needs to be called again.
-    void ApplicationState::_write() noexcept
+    void ApplicationState::_write() const noexcept
     try
     {
-        // re-read the state so that we can only update the properties that were changed.
-        Json::Value root{};
+        Json::StreamWriterBuilder wbuilder;
+
+        // When we're elevated, we've got to be tricky. We don't want to write
+        // our window state, allowed commandlines, and other Local properties
+        // into the shared `state.json`. But, if we only serialize the Shared
+        // properties to a json blob, then we'll omit windowState entirely,
+        // _removing_ the window state of the unelevated instance. Oh no!
+        //
+        // So, to be tricky, we'll first _load_ the shared state to a json blob.
+        // We'll then serialize our view of the shared properties on top of that
+        // blob. Then we'll write that blob back to the file. This will
+        // round-trip the Local properties for the unelevated instances
+        // untouched in state.json
+        //
+        // After that's done, we'll write our Local properties into
+        // elevated-state.json.
+        if (::Microsoft::Console::Utils::IsElevated())
         {
-            auto state = _state.lock();
-            const auto file = OpenFileRWExclusiveLocked(_path);
-            root = _getRoot(file);
+            std::string errs;
+            std::unique_ptr<Json::CharReader> reader{ Json::CharReaderBuilder::CharReaderBuilder().newCharReader() };
+            Json::Value root;
 
-#define MTSM_APPLICATION_STATE_GEN(type, name, key, ...)   \
-    if (state->name##Changed)                              \
-    {                                                      \
-        JsonUtils::SetValueForKey(root, key, state->name); \
-        state->name##Changed = false;                      \
-    }
-            MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
-#undef MTSM_APPLICATION_STATE_GEN
+            // First load the contents of state.json into a json blob. This will
+            // contain the Shared properties and the unelevated instance's Local
+            // properties.
+            const auto sharedData = _readSharedContents().value_or(std::string{});
+            if (!sharedData.empty())
+            {
+                if (!reader->parse(sharedData.data(), sharedData.data() + sharedData.size(), &root, &errs))
+                {
+                    throw winrt::hresult_error(WEB_E_INVALID_JSON_STRING, winrt::to_hstring(errs));
+                }
+            }
+            // Layer our shared properties on top of the blob from state.json,
+            // and write it back out.
+            _writeSharedContents(Json::writeString(wbuilder, _toJsonWithBlob(root, FileSource::Shared)));
 
-            Json::StreamWriterBuilder wbuilder;
-            const auto content = Json::writeString(wbuilder, root);
-            WriteUTF8FileLocked(file, content);
+            // Finally, write our Local properties back to elevated-state.json
+            _writeLocalContents(Json::writeString(wbuilder, ToJson(FileSource::Local)));
+        }
+        else
+        {
+            // We're unelevated, this is easy. Just write everything back out.
+            _writeLocalContents(Json::writeString(wbuilder, ToJson(FileSource::Local | FileSource::Shared)));
         }
     }
     CATCH_LOG()
+
+    // Returns the application-global ApplicationState object.
+    Microsoft::Terminal::Settings::Model::ApplicationState ApplicationState::SharedInstance()
+    {
+        std::filesystem::path root{ GetBaseSettingsPath() };
+        static auto state = winrt::make_self<ApplicationState>(root);
+        return *state;
+    }
+
+    // Method Description:
+    // - Loads data from the given json blob. Will only read the data that's in
+    //   the specified parseSource - so if we're reading the Local state file,
+    //   we won't destroy previously parsed Shared data.
+    // - READ: there's no layering for app state.
+    void ApplicationState::FromJson(const Json::Value& root, FileSource parseSource) const noexcept
+    {
+        auto state = _state.lock();
+        // GetValueForKey() comes in two variants:
+        // * take a std::optional<T> reference
+        // * return std::optional<T> by value
+        // At the time of writing the former version skips missing fields in the json,
+        // but we want to explicitly clear state fields that were removed from state.json.
+        //
+        // GH#11222: We only load properties that are of the same type (Local or
+        // Shared) which we requested. If we didn't want to load this type of
+        // property, just skip it.
+#define MTSM_APPLICATION_STATE_GEN(source, type, name, key, ...) \
+    if (WI_IsFlagSet(parseSource, source))                       \
+        state->name = JsonUtils::GetValueForKey<std::optional<type>>(root, key);
+
+        MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
+#undef MTSM_APPLICATION_STATE_GEN
+    }
+
+    Json::Value ApplicationState::ToJson(FileSource parseSource) const noexcept
+    {
+        Json::Value root{ Json::objectValue };
+        return _toJsonWithBlob(root, parseSource);
+    }
+
+    Json::Value ApplicationState::_toJsonWithBlob(Json::Value& root, FileSource parseSource) const noexcept
+    {
+        {
+            auto state = _state.lock_shared();
+
+            // GH#11222: We only write properties that are of the same type (Local
+            // or Shared) which we requested. If we didn't want to serialize this
+            // type of property, just skip it.
+#define MTSM_APPLICATION_STATE_GEN(source, type, name, key, ...) \
+    if (WI_IsFlagSet(parseSource, source))                       \
+        JsonUtils::SetValueForKey(root, key, state->name);
+
+            MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
+#undef MTSM_APPLICATION_STATE_GEN
+        }
+        return root;
+    }
+
+    // Generate all getter/setters
+#define MTSM_APPLICATION_STATE_GEN(source, type, name, key, ...) \
+    type ApplicationState::name() const noexcept                 \
+    {                                                            \
+        const auto state = _state.lock_shared();                 \
+        const auto& value = state->name;                         \
+        return value ? *value : type{ __VA_ARGS__ };             \
+    }                                                            \
+                                                                 \
+    void ApplicationState::name(const type& value) noexcept      \
+    {                                                            \
+        {                                                        \
+            auto state = _state.lock();                          \
+            state->name.emplace(value);                          \
+        }                                                        \
+                                                                 \
+        _throttler();                                            \
+    }
+    MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
+#undef MTSM_APPLICATION_STATE_GEN
+
+    // Method Description:
+    // - Read the contents of our "shared" state - state that should be shared
+    //   for elevated and unelevated instances. This is things like the list of
+    //   generated profiles, the command palette commandlines.
+    std::optional<std::string> ApplicationState::_readSharedContents() const
+    {
+        return ReadUTF8FileIfExists(_sharedPath);
+    }
+
+    // Method Description:
+    // - Read the contents of our "local" state - state that should be kept in
+    //   separate files for elevated and unelevated instances. This is things
+    //   like the persisted window state, and the approved commandlines (though,
+    //   those don't matter when unelevated).
+    // - When elevated, this will DELETE `elevated-state.json` if it has bad
+    //   permissions, so we don't potentially read malicious data.
+    std::optional<std::string> ApplicationState::_readLocalContents() const
+    {
+        return ::Microsoft::Console::Utils::IsElevated() ?
+                   ReadUTF8FileIfExists(_elevatedPath, true) :
+                   ReadUTF8FileIfExists(_sharedPath, false);
+    }
+
+    // Method Description:
+    // - Write the contents of our "shared" state - state that should be shared
+    //   for elevated and unelevated instances. This will atomically write to
+    //   `state.json`
+    void ApplicationState::_writeSharedContents(const std::string_view content) const
+    {
+        WriteUTF8FileAtomic(_sharedPath, content);
+    }
+
+    // Method Description:
+    // - Write the contents of our "local" state - state that should be kept in
+    //   separate files for elevated and unelevated instances. When elevated,
+    //   this will write to `elevated-state.json`, and when unelevated, this
+    //   will atomically write to `user-state.json`
+    void ApplicationState::_writeLocalContents(const std::string_view content) const
+    {
+        if (::Microsoft::Console::Utils::IsElevated())
+        {
+            // DON'T use WriteUTF8FileAtomic, which will write to a temporary file
+            // then rename that file to the final filename. That actually lets us
+            // overwrite the elevate file's contents even when unelevated, because
+            // we're effectively deleting the original file, then renaming a
+            // different file in it's place.
+            //
+            // We're not worried about someone else doing that though, if they do
+            // that with the wrong permissions, then we'll just ignore the file and
+            // start over.
+            WriteUTF8File(_elevatedPath, content, true);
+        }
+        else
+        {
+            WriteUTF8FileAtomic(_sharedPath, content);
+        }
+    }
+
 }
diff --git a/src/cascadia/TerminalSettingsModel/ApplicationState.h b/src/cascadia/TerminalSettingsModel/ApplicationState.h
index d6d2d1749..1c0943cfe 100644
--- a/src/cascadia/TerminalSettingsModel/ApplicationState.h
+++ b/src/cascadia/TerminalSettingsModel/ApplicationState.h
@@ -16,21 +16,30 @@ Abstract:
 #include "WindowLayout.g.h"
 
 #include <inc/cppwinrt_utils.h>
-#include <til/mutex.h>
-#include <til/throttled_func.h>
-#include "FileUtils.h"
 #include <JsonUtils.h>
 
+namespace winrt::Microsoft::Terminal::Settings::Model::implementation
+{
+    // If a property is Shared, then it'll be stored in `state.json`, and used
+    // in both elevated and unelevated instances of the Terminal. If a property
+    // is marked Local, then it will have separate values for elevated and
+    // unelevated instances.
+    enum FileSource : int
+    {
+        Shared = 0x1,
+        Local = 0x2
+    };
+    DEFINE_ENUM_FLAG_OPERATORS(FileSource);
+
 // This macro generates all getters and setters for ApplicationState.
 // It provides X with the following arguments:
-//   (type, function name, JSON key, ...variadic construction arguments)
-namespace winrt::Microsoft::Terminal::Settings::Model::implementation
-{
-#define MTSM_APPLICATION_STATE_FIELDS(X)                                                                                \
-    X(std::unordered_set<winrt::guid>, GeneratedProfiles, "generatedProfiles")                                          \
-    X(Windows::Foundation::Collections::IVector<Model::WindowLayout>, PersistedWindowLayouts, "persistedWindowLayouts") \
-    X(Windows::Foundation::Collections::IVector<hstring>, RecentCommands, "recentCommands")                             \
-    X(Windows::Foundation::Collections::IVector<winrt::Microsoft::Terminal::Settings::Model::InfoBarMessage>, DismissedMessages, "dismissedMessages")
+//   (source, type, function name, JSON key, ...variadic construction arguments)
+#define MTSM_APPLICATION_STATE_FIELDS(X)                                                                                                                                  \
+    X(FileSource::Shared, std::unordered_set<winrt::guid>, GeneratedProfiles, "generatedProfiles")                                                                        \
+    X(FileSource::Local, Windows::Foundation::Collections::IVector<Model::WindowLayout>, PersistedWindowLayouts, "persistedWindowLayouts")                                \
+    X(FileSource::Shared, Windows::Foundation::Collections::IVector<hstring>, RecentCommands, "recentCommands")                                                           \
+    X(FileSource::Shared, Windows::Foundation::Collections::IVector<winrt::Microsoft::Terminal::Settings::Model::InfoBarMessage>, DismissedMessages, "dismissedMessages") \
+    X(FileSource::Local, Windows::Foundation::Collections::IVector<hstring>, AllowedCommandlines, "allowedCommandlines")
 
     struct WindowLayout : WindowLayoutT<WindowLayout>
     {
@@ -44,23 +53,26 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         friend ::Microsoft::Terminal::Settings::Model::JsonUtils::ConversionTrait<Model::WindowLayout>;
     };
 
-    struct ApplicationState : ApplicationStateT<ApplicationState>
+    struct ApplicationState : public ApplicationStateT<ApplicationState>
     {
         static Microsoft::Terminal::Settings::Model::ApplicationState SharedInstance();
 
-        ApplicationState(std::filesystem::path path) noexcept;
+        ApplicationState(const std::filesystem::path& stateRoot) noexcept;
         ~ApplicationState();
 
         // Methods
         void Reload() const noexcept;
         void Reset() noexcept;
 
+        void FromJson(const Json::Value& root, FileSource parseSource) const noexcept;
+        Json::Value ToJson(FileSource parseSource) const noexcept;
+
         // General getters/setters
-        winrt::hstring FilePath() const noexcept;
+        bool IsStatePath(const winrt::hstring& filename);
 
         // State getters/setters
-#define MTSM_APPLICATION_STATE_GEN(type, name, key, ...) \
-    type name() const noexcept;                          \
+#define MTSM_APPLICATION_STATE_GEN(source, type, name, key, ...) \
+    type name() const noexcept;                                  \
     void name(const type& value) noexcept;
         MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
 #undef MTSM_APPLICATION_STATE_GEN
@@ -68,21 +80,24 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
     private:
         struct state_t
         {
-#define MTSM_APPLICATION_STATE_GEN(type, name, key, ...) \
-    std::optional<type> name{ __VA_ARGS__ };             \
-    bool name##Changed = false;
-
+#define MTSM_APPLICATION_STATE_GEN(source, type, name, key, ...) std::optional<type> name{ __VA_ARGS__ };
             MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
 #undef MTSM_APPLICATION_STATE_GEN
         };
+        til::shared_mutex<state_t> _state;
+        std::filesystem::path _sharedPath;
+        std::filesystem::path _elevatedPath;
+        til::throttled_func_trailing<> _throttler;
 
-        Json::Value _getRoot(const winrt::Microsoft::Terminal::Settings::Model::locked_hfile& file) const noexcept;
-        void _write() noexcept;
+        void _write() const noexcept;
         void _read() const noexcept;
 
-        std::filesystem::path _path;
-        til::shared_mutex<state_t> _state;
-        til::throttled_func_trailing<> _throttler;
+        Json::Value _toJsonWithBlob(Json::Value& root, FileSource parseSource) const noexcept;
+
+        std::optional<std::string> _readSharedContents() const;
+        void _writeSharedContents(const std::string_view content) const;
+        std::optional<std::string> _readLocalContents() const;
+        void _writeLocalContents(const std::string_view content) const;
     };
 }
 
diff --git a/src/cascadia/TerminalSettingsModel/ApplicationState.idl b/src/cascadia/TerminalSettingsModel/ApplicationState.idl
index 7890b58c6..b88ec144a 100644
--- a/src/cascadia/TerminalSettingsModel/ApplicationState.idl
+++ b/src/cascadia/TerminalSettingsModel/ApplicationState.idl
@@ -30,12 +30,15 @@ namespace Microsoft.Terminal.Settings.Model
         void Reload();
         void Reset();
 
-        String FilePath { get; };
+        Boolean IsStatePath(String filename);
 
         Windows.Foundation.Collections.IVector<WindowLayout> PersistedWindowLayouts { get; set; };
 
         Windows.Foundation.Collections.IVector<String> RecentCommands { get; set; };
 
         Windows.Foundation.Collections.IVector<InfoBarMessage> DismissedMessages { get; set; };
+
+        Windows.Foundation.Collections.IVector<String> AllowedCommandlines { get; set; };
+
     }
 }
diff --git a/src/cascadia/TerminalSettingsModel/FileUtils.cpp b/src/cascadia/TerminalSettingsModel/FileUtils.cpp
index 599d29a55..4535c23be 100644
--- a/src/cascadia/TerminalSettingsModel/FileUtils.cpp
+++ b/src/cascadia/TerminalSettingsModel/FileUtils.cpp
@@ -8,6 +8,10 @@
 #include <shlobj.h>
 #include <WtExeUtils.h>
 
+#include <aclapi.h>
+#include <sddl.h>
+#include <wil/token_helpers.h>
+
 static constexpr std::string_view Utf8Bom{ u8"\uFEFF" };
 static constexpr std::wstring_view UnpackagedSettingsFolderName{ L"Microsoft\\Windows Terminal\\" };
 
@@ -39,86 +43,44 @@ namespace winrt::Microsoft::Terminal::Settings::Model
         return baseSettingsPath;
     }
 
-    locked_hfile OpenFileReadSharedLocked(const std::filesystem::path& path)
+    // Function Description:
+    // - Checks the permissions on this file, to make sure it can only be opened
+    //   for writing by admins. We will be checking to see if the file is owned
+    //   by the Builtin\Administrators group. If it's not, then it was likely
+    //   tampered with.
+    // Arguments:
+    // - handle: a HANDLE to the file to check
+    // Return Value:
+    // - true if it had the expected permissions. False otherwise.
+    static bool _isOwnedByAdministrators(const HANDLE& handle)
     {
-        wil::unique_hfile file{ CreateFileW(path.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr) };
-        THROW_LAST_ERROR_IF(!file);
-        // just lock the entire file
-        OVERLAPPED sOverlapped;
-        sOverlapped.Offset = 0;
-        sOverlapped.OffsetHigh = 0;
-        // Shared lock
-        THROW_LAST_ERROR_IF(!LockFileEx(file.get(),
-                                        0, // lock shared, wait to return until lock is obtained
-                                        0, // reserved, does nothing
-                                        INT_MAX, // lock INT_MAX bytes
-                                        0, // higher-order bytes, if our state file is greater than 2GB I guess this will be a problem
-                                        &sOverlapped));
-        return { std::move(file), sOverlapped };
+        // If the file is owned by the administrators group, trust the
+        // administrators instead of checking the DACL permissions. It's simpler
+        // and more flexible.
+
+        wil::unique_hlocal_security_descriptor sd;
+        PSID psidOwner{ nullptr };
+        // The psidOwner pointer references the security descriptor, so it
+        // doesn't have to be freed separate from sd.
+        const auto status = GetSecurityInfo(handle,
+                                            SE_FILE_OBJECT,
+                                            OWNER_SECURITY_INFORMATION,
+                                            &psidOwner,
+                                            nullptr,
+                                            nullptr,
+                                            nullptr,
+                                            wil::out_param_ptr<PSECURITY_DESCRIPTOR*>(sd));
+        THROW_IF_WIN32_ERROR(status);
+
+        wil::unique_any_psid psidAdmins{ nullptr };
+        THROW_IF_WIN32_BOOL_FALSE(
+            ConvertStringSidToSidW(L"BA", wil::out_param_ptr<PSID*>(psidAdmins)));
+
+        return EqualSid(psidOwner, psidAdmins.get());
     }
-
-    locked_hfile OpenFileRWExclusiveLocked(const std::filesystem::path& path)
-    {
-        wil::unique_hfile file{ CreateFileW(path.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr) };
-        THROW_LAST_ERROR_IF(!file);
-        // just lock the entire file
-        OVERLAPPED sOverlapped;
-        sOverlapped.Offset = 0;
-        sOverlapped.OffsetHigh = 0;
-        // Shared lock
-        THROW_LAST_ERROR_IF(!LockFileEx(file.get(),
-                                        LOCKFILE_EXCLUSIVE_LOCK, // lock exclusive, wait to return until lock is obtained
-                                        0, // reserved, does nothing
-                                        INT_MAX, // lock INT_MAX bytes
-                                        0, // higher-order bytes, if our state file is greater than 2GB I guess this will be a problem
-                                        &sOverlapped));
-        return { std::move(file), sOverlapped };
-    }
-
-    std::string ReadUTF8FileLocked(const locked_hfile& file)
-    {
-        const auto fileSize = GetFileSize(file.get(), nullptr);
-        THROW_LAST_ERROR_IF(fileSize == INVALID_FILE_SIZE);
-
-        // By making our buffer just slightly larger we can detect if
-        // the file size changed and we've failed to read the full file.
-        std::string buffer(static_cast<size_t>(fileSize) + 1, '\0');
-        DWORD bytesRead = 0;
-        THROW_IF_WIN32_BOOL_FALSE(ReadFile(file.get(), buffer.data(), gsl::narrow<DWORD>(buffer.size()), &bytesRead, nullptr));
-
-        // As mentioned before our buffer was allocated oversized.
-        buffer.resize(bytesRead);
-
-        if (til::starts_with(buffer, Utf8Bom))
-        {
-            // Yeah this memmove()s the entire content.
-            // But I don't really want to deal with UTF8 BOMs any more than necessary,
-            // as basically not a single editor writes a BOM for UTF8.
-            buffer.erase(0, Utf8Bom.size());
-        }
-
-        return buffer;
-    }
-
-    void WriteUTF8FileLocked(const locked_hfile& file, const std::string_view& content)
-    {
-        // truncate the file because we want to overwrite it
-        SetFilePointer(file.get(), 0, nullptr, FILE_BEGIN);
-        THROW_IF_WIN32_BOOL_FALSE(SetEndOfFile(file.get()));
-
-        const auto fileSize = gsl::narrow<DWORD>(content.size());
-        DWORD bytesWritten = 0;
-        THROW_IF_WIN32_BOOL_FALSE(WriteFile(file.get(), content.data(), fileSize, &bytesWritten, nullptr));
-
-        if (bytesWritten != fileSize)
-        {
-            THROW_WIN32_MSG(ERROR_WRITE_FAULT, "failed to write whole file");
-        }
-    }
-
     // Tries to read a file somewhat atomically without locking it.
     // Strips the UTF8 BOM if it exists.
-    std::string ReadUTF8File(const std::filesystem::path& path)
+    std::string ReadUTF8File(const std::filesystem::path& path, const bool elevatedOnly)
     {
         // From some casual observations we can determine that:
         // * ReadFile() always returns the requested amount of data (unless the file is smaller)
@@ -126,9 +88,40 @@ namespace winrt::Microsoft::Terminal::Settings::Model
         // -> Lets add a retry-loop just in case, to not fail if the file size changed while reading.
         for (int i = 0; i < 3; ++i)
         {
-            wil::unique_hfile file{ CreateFileW(path.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr) };
+            wil::unique_hfile file{ CreateFileW(path.c_str(),
+                                                GENERIC_READ,
+                                                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                                nullptr,
+                                                OPEN_EXISTING,
+                                                FILE_ATTRIBUTE_NORMAL,
+                                                nullptr) };
             THROW_LAST_ERROR_IF(!file);
 
+            // Open the file _first_, then check if it has the right
+            // permissions. This prevents a "Time-of-check to time-of-use"
+            // vulnerability where a malicious exe could delete the file and
+            // replace it between us checking the permissions, and reading the
+            // contents. We've got a handle to the file now, which means we're
+            // going to read the contents of that instance of the file
+            // regardless. If someone replaces the file on us before we get to
+            // the GetSecurityInfo call below, then only the subsequent call to
+            // ReadUTF8File will notice it.
+            if (elevatedOnly)
+            {
+                const bool hadExpectedPermissions{ _isOwnedByAdministrators(file.get()) };
+                if (!hadExpectedPermissions)
+                {
+                    // Close the handle
+                    file.reset();
+
+                    // delete the file. It's been compromised.
+                    LOG_LAST_ERROR_IF(!DeleteFile(path.c_str()));
+
+                    // Exit early, because obviously there's nothing to read from the deleted file.
+                    return "";
+                }
+            }
+
             const auto fileSize = GetFileSize(file.get(), nullptr);
             THROW_LAST_ERROR_IF(fileSize == INVALID_FILE_SIZE);
 
@@ -166,11 +159,11 @@ namespace winrt::Microsoft::Terminal::Settings::Model
     }
 
     // Same as ReadUTF8File, but returns an empty optional, if the file couldn't be opened.
-    std::optional<std::string> ReadUTF8FileIfExists(const std::filesystem::path& path)
+    std::optional<std::string> ReadUTF8FileIfExists(const std::filesystem::path& path, const bool elevatedOnly)
     {
         try
         {
-            return { ReadUTF8File(path) };
+            return { ReadUTF8File(path, elevatedOnly) };
         }
         catch (const wil::ResultException& exception)
         {
@@ -183,9 +176,70 @@ namespace winrt::Microsoft::Terminal::Settings::Model
         }
     }
 
-    void WriteUTF8File(const std::filesystem::path& path, const std::string_view& content)
+    void WriteUTF8File(const std::filesystem::path& path,
+                       const std::string_view& content,
+                       const bool elevatedOnly)
     {
-        wil::unique_hfile file{ CreateFileW(path.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr) };
+        SECURITY_ATTRIBUTES sa;
+        // stash the security descriptor here, so it will stay in context until
+        // after the call to CreateFile. If it gets cleaned up before that, then
+        // CreateFile will fail
+        wil::unique_hlocal_security_descriptor sd;
+        if (elevatedOnly)
+        {
+            // Initialize the security descriptor so only admins can write the
+            // file. We'll initialize the SECURITY_DESCRIPTOR with a
+            // single entry (ACE) -- a mandatory label (i.e. a
+            // LABEL_SECURITY_INFORMATION) that sets the file integrity level to
+            // "high",  with a no-write-up policy.
+            //
+            // When accessed from a security context at a lower integrity level,
+            // the no-write-up policy filters out rights that aren't in the
+            // object type's generic read and execute set (for the file type,
+            // that's FILE_GENERIC_READ | FILE_GENERIC_EXECUTE).
+            //
+            // Another option we considered here was manually setting the ACLs
+            // on this file such that Builtin\Admins could read&write the file,
+            // and all users could only read.
+            //
+            // Big thanks to @eryksun in GH#11222 for helping with this. This
+            // alternative method was chosen because it's considerably simpler.
+
+            // The required security descriptor can be created easily from the
+            // SDDL string: "S:(ML;;NW;;;HI)"
+            // (i.e. SACL:mandatory label;;no write up;;;high integrity level)
+            unsigned long cb;
+            THROW_IF_WIN32_BOOL_FALSE(
+                ConvertStringSecurityDescriptorToSecurityDescriptor(L"S:(ML;;NW;;;HI)",
+                                                                    SDDL_REVISION_1,
+                                                                    wil::out_param_ptr<PSECURITY_DESCRIPTOR*>(sd),
+                                                                    &cb));
+
+            // Initialize a security attributes structure.
+            sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+            sa.lpSecurityDescriptor = sd.get();
+            sa.bInheritHandle = false;
+
+            // If we're running in an elevated context, when this file is
+            // created, it will automatically be owned by
+            // Builtin\Administrators, which will pass the above
+            // _isOwnedByAdministrators check.
+            //
+            // Programs running in an elevated context will be free to write the
+            // file, and unelevated processes will be able to read the file. An
+            // unelevated process could always delete the file and rename a new
+            // file in it's place (a la the way `vim.exe` saves files), but if
+            // they do that, the new file _won't_ be owned by Administrators,
+            // failing the above check.
+        }
+
+        wil::unique_hfile file{ CreateFileW(path.c_str(),
+                                            GENERIC_WRITE,
+                                            FILE_SHARE_READ | FILE_SHARE_DELETE,
+                                            elevatedOnly ? &sa : nullptr,
+                                            CREATE_ALWAYS,
+                                            FILE_ATTRIBUTE_NORMAL,
+                                            nullptr) };
         THROW_LAST_ERROR_IF(!file);
 
         const auto fileSize = gsl::narrow<DWORD>(content.size());
@@ -198,7 +252,8 @@ namespace winrt::Microsoft::Terminal::Settings::Model
         }
     }
 
-    void WriteUTF8FileAtomic(const std::filesystem::path& path, const std::string_view& content)
+    void WriteUTF8FileAtomic(const std::filesystem::path& path,
+                             const std::string_view& content)
     {
         // GH#10787: rename() will replace symbolic links themselves and not the path they point at.
         // It's thus important that we first resolve them before generating temporary path.
diff --git a/src/cascadia/TerminalSettingsModel/FileUtils.h b/src/cascadia/TerminalSettingsModel/FileUtils.h
index 187051e7c..082da6611 100644
--- a/src/cascadia/TerminalSettingsModel/FileUtils.h
+++ b/src/cascadia/TerminalSettingsModel/FileUtils.h
@@ -1,41 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-#pragma once
-
 namespace winrt::Microsoft::Terminal::Settings::Model
 {
-    // I couldn't find a wil helper for this so I made it myself
-    class locked_hfile
-    {
-    public:
-        wil::unique_hfile file;
-        OVERLAPPED lockedRegion;
-
-        ~locked_hfile()
-        {
-            if (file)
-            {
-                // Need to unlock the file before it is closed
-                UnlockFileEx(file.get(), 0, INT_MAX, 0, &lockedRegion);
-            }
-        }
-
-        HANDLE get() const noexcept
-        {
-            return file.get();
-        }
-    };
-
     std::filesystem::path GetBaseSettingsPath();
-
-    locked_hfile OpenFileReadSharedLocked(const std::filesystem::path& path);
-    locked_hfile OpenFileRWExclusiveLocked(const std::filesystem::path& path);
-    std::string ReadUTF8FileLocked(const locked_hfile& file);
-    void WriteUTF8FileLocked(const locked_hfile& file, const std::string_view& content);
-
-    std::string ReadUTF8File(const std::filesystem::path& path);
-    std::optional<std::string> ReadUTF8FileIfExists(const std::filesystem::path& path);
-    void WriteUTF8File(const std::filesystem::path& path, const std::string_view& content);
+    std::string ReadUTF8File(const std::filesystem::path& path, const bool elevatedOnly = false);
+    std::optional<std::string> ReadUTF8FileIfExists(const std::filesystem::path& path, const bool elevatedOnly = false);
+    void WriteUTF8File(const std::filesystem::path& path, const std::string_view& content, const bool elevatedOnly = false);
     void WriteUTF8FileAtomic(const std::filesystem::path& path, const std::string_view& content);
 }
diff --git a/src/cascadia/TerminalSettingsModel/JsonUtils.h b/src/cascadia/TerminalSettingsModel/JsonUtils.h
index cea006b2b..be29f15de 100644
--- a/src/cascadia/TerminalSettingsModel/JsonUtils.h
+++ b/src/cascadia/TerminalSettingsModel/JsonUtils.h
@@ -382,7 +382,6 @@ namespace Microsoft::Terminal::Settings::Model::JsonUtils
     };
 
     template<typename T>
-
     struct ConversionTrait<std::unordered_map<std::string, T>>
     {
         std::unordered_map<std::string, T> FromJson(const Json::Value& json) const
diff --git a/src/cascadia/TerminalSettingsModel/pch.h b/src/cascadia/TerminalSettingsModel/pch.h
index d5473939c..25773a45d 100644
--- a/src/cascadia/TerminalSettingsModel/pch.h
+++ b/src/cascadia/TerminalSettingsModel/pch.h
@@ -53,3 +53,6 @@ TRACELOGGING_DECLARE_PROVIDER(g_hSettingsModelProvider);
 
 // Manually include til after we include Windows.Foundation to give it winrt superpowers
 #include "til.h"
+
+#include <til/mutex.h>
+#include <til/throttled_func.h>
diff --git a/src/cascadia/WindowsTerminal/AppHost.cpp b/src/cascadia/WindowsTerminal/AppHost.cpp
index 544c33e55..36d489212 100644
--- a/src/cascadia/WindowsTerminal/AppHost.cpp
+++ b/src/cascadia/WindowsTerminal/AppHost.cpp
@@ -845,8 +845,30 @@ winrt::Windows::Foundation::IAsyncAction AppHost::_SaveWindowLayouts()
 
     if (_logic.ShouldUsePersistedLayout())
     {
-        const auto layoutJsons = _windowManager.GetAllWindowLayouts();
-        _logic.SaveWindowLayoutJsons(layoutJsons);
+        try
+        {
+            TraceLoggingWrite(g_hWindowsTerminalProvider,
+                              "AppHost_SaveWindowLayouts_Collect",
+                              TraceLoggingDescription("Logged when collecting window state"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                              TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+            const auto layoutJsons = _windowManager.GetAllWindowLayouts();
+            TraceLoggingWrite(g_hWindowsTerminalProvider,
+                              "AppHost_SaveWindowLayouts_Save",
+                              TraceLoggingDescription("Logged when writing window state"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                              TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+            _logic.SaveWindowLayoutJsons(layoutJsons);
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+            TraceLoggingWrite(g_hWindowsTerminalProvider,
+                              "AppHost_SaveWindowLayouts_Failed",
+                              TraceLoggingDescription("An error occurred when collecting or writing window state"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                              TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+        }
     }
 
     co_return;
@@ -867,6 +889,12 @@ winrt::fire_and_forget AppHost::_SaveWindowLayoutsRepeat()
     // per 10 seconds, if a save is requested by another source simultaneously.
     if (_getWindowLayoutThrottler.has_value())
     {
+        TraceLoggingWrite(g_hWindowsTerminalProvider,
+                          "AppHost_requestGetLayout",
+                          TraceLoggingDescription("Logged when triggering a throttled write of the window state"),
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                          TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+
         _getWindowLayoutThrottler.value()();
     }
 }
diff --git a/src/types/inc/utils.hpp b/src/types/inc/utils.hpp
index a2a2c6cac..9bd1c3141 100644
--- a/src/types/inc/utils.hpp
+++ b/src/types/inc/utils.hpp
@@ -94,4 +94,5 @@ namespace Microsoft::Console::Utils
 
     GUID CreateV5Uuid(const GUID& namespaceGuid, const gsl::span<const gsl::byte> name);
 
+    bool IsElevated();
 }
diff --git a/src/types/utils.cpp b/src/types/utils.cpp
index d8af05c2e..1dc18a68e 100644
--- a/src/types/utils.cpp
+++ b/src/types/utils.cpp
@@ -5,6 +5,8 @@
 #include "inc/utils.hpp"
 #include "inc/colorTable.hpp"
 
+#include <wil/token_helpers.h>
+
 using namespace Microsoft::Console;
 
 // Routine Description:
@@ -559,3 +561,33 @@ GUID Utils::CreateV5Uuid(const GUID& namespaceGuid, const gsl::span<const gsl::b
     ::memcpy_s(&newGuid, sizeof(GUID), buffer.data(), sizeof(GUID));
     return EndianSwap(newGuid);
 }
+
+bool Utils::IsElevated()
+{
+    static bool isElevated = []() {
+        try
+        {
+            wil::unique_handle processToken{ GetCurrentProcessToken() };
+            const auto elevationType = wil::get_token_information<TOKEN_ELEVATION_TYPE>(processToken.get());
+            const auto elevationState = wil::get_token_information<TOKEN_ELEVATION>(processToken.get());
+            if (elevationType == TokenElevationTypeDefault && elevationState.TokenIsElevated)
+            {
+                // In this case, the user has UAC entirely disabled. This is sort of
+                // weird, we treat this like the user isn't an admin at all. There's no
+                // separation of powers, so the things we normally want to gate on
+                // "having special powers" doesn't apply.
+                //
+                // See GH#7754, GH#11096
+                return false;
+            }
+
+            return wil::test_token_membership(nullptr, SECURITY_NT_AUTHORITY, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS);
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+            return false;
+        }
+    }();
+    return isElevated;
+}