diff --git a/Kits/ATGTK/imgui/imgui_atg.cpp b/Kits/ATGTK/imgui/imgui_atg.cpp
index 80319e54..1a075d1c 100644
--- a/Kits/ATGTK/imgui/imgui_atg.cpp
+++ b/Kits/ATGTK/imgui/imgui_atg.cpp
@@ -16,18 +16,54 @@
 #include <ShellScalingApi.h>
 #pragma comment(lib, "shcore.lib") // GetDpiForMonitor
 #endif
+#include <algorithm>
 #include <map>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace ImGuiAtg
 {
     //--------------------------------------------------------------------------------------
     // Input helpers
     //--------------------------------------------------------------------------------------
-    
+
+    namespace
+    {
+        std::vector<std::string> g_navigationGroups;
+        std::string g_currentNavigationGroup;
+        std::string g_requestedNavigationGroup;
+        int g_navigationGroupDepth = 0;
+        bool g_navigationGroupInputActive = false;
+    }
+
+    void BeginNavigationGroup(const char* id)
+    {
+        IM_ASSERT(id != nullptr && id[0] != '\0');
+        IM_ASSERT(g_navigationGroupDepth == 0);
+        IM_ASSERT(std::find(g_navigationGroups.cbegin(), g_navigationGroups.cend(), id) == g_navigationGroups.cend());
+        g_navigationGroupDepth++;
+        g_navigationGroups.emplace_back(id);
+
+        if (g_requestedNavigationGroup == id)
+        {
+            ImGui::SetNavCursorVisible(true);
+            ImGui::SetKeyboardFocusHere();
+            g_currentNavigationGroup = id;
+            g_requestedNavigationGroup.clear();
+        }
+    }
+
+    void EndNavigationGroup()
+    {
+        IM_ASSERT(g_navigationGroupDepth > 0);
+        g_navigationGroupDepth--;
+    }
+
     void HandleStandardInput()
     {
+        IM_ASSERT(g_navigationGroupDepth == 0);
+
         if ((!ImGui::GetIO().WantTextInput && ImGui::IsKeyPressed(ImGuiKey_F2, false)) ||
             (ImGui::IsKeyDown(ImGuiKey_GamepadL1) &&
              ImGui::IsKeyDown(ImGuiKey_GamepadR1) &&
@@ -43,6 +79,57 @@ namespace ImGuiAtg
         {
             PostQuitMessage(0);
         }
+
+        const bool groupNavigationChord = ImGui::IsKeyDown(ImGuiKey_GamepadL1)
+            && ImGui::IsKeyDown(ImGuiKey_GamepadR1);
+        const bool previousGroupPressed = groupNavigationChord
+            && ImGui::IsKeyPressed(ImGuiKey_GamepadDpadUp, false);
+        const bool nextGroupPressed = groupNavigationChord
+            && ImGui::IsKeyPressed(ImGuiKey_GamepadDpadDown, false);
+        const bool groupNavigationInputDown = groupNavigationChord
+            && (ImGui::IsKeyDown(ImGuiKey_GamepadDpadUp)
+                || ImGui::IsKeyDown(ImGuiKey_GamepadDpadDown));
+
+        if (!g_requestedNavigationGroup.empty()
+            && std::find(
+                g_navigationGroups.cbegin(),
+                g_navigationGroups.cend(),
+                g_requestedNavigationGroup) == g_navigationGroups.cend())
+        {
+            g_requestedNavigationGroup.clear();
+        }
+
+        if (!g_navigationGroups.empty() && (previousGroupPressed || nextGroupPressed))
+        {
+            auto currentGroup = std::find(
+                g_navigationGroups.cbegin(),
+                g_navigationGroups.cend(),
+                g_currentNavigationGroup);
+
+            size_t requestedGroupIndex = 0;
+            if (currentGroup == g_navigationGroups.cend())
+            {
+                requestedGroupIndex = previousGroupPressed ? g_navigationGroups.size() - 1 : 0;
+            }
+            else
+            {
+                const size_t currentGroupIndex = static_cast<size_t>(currentGroup - g_navigationGroups.cbegin());
+                requestedGroupIndex = previousGroupPressed
+                    ? (currentGroupIndex + g_navigationGroups.size() - 1) % g_navigationGroups.size()
+                    : (currentGroupIndex + 1) % g_navigationGroups.size();
+            }
+
+            g_requestedNavigationGroup = g_navigationGroups[requestedGroupIndex];
+            g_navigationGroupInputActive = true;
+            ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NavEnableGamepad;
+        }
+        else if (g_navigationGroupInputActive && !groupNavigationInputDown)
+        {
+            ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
+            g_navigationGroupInputActive = false;
+        }
+
+        g_navigationGroups.clear();
     }
 
     //--------------------------------------------------------------------------------------
@@ -324,11 +411,11 @@ namespace ImGuiAtg
         // with FooterItem() before calling EndFooter().
     }
 
-    bool FooterItem(const char* text)
+    bool FooterItem(const char* text, bool clickable)
     {
         ControllerText(text);
-        ImGui::SameLine(0, Scaled(80.0f));
-        if (ImGui::IsItemHovered())
+        ImGui::SameLine(0, Scaled(40.0f));
+        if (clickable && ImGui::IsItemHovered())
         {
             ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
             if (ImGui::IsMouseClicked(ImGuiMouseButton_Left))
diff --git a/Kits/ATGTK/imgui/imgui_atg.h b/Kits/ATGTK/imgui/imgui_atg.h
index 44d337d9..9137b368 100644
--- a/Kits/ATGTK/imgui/imgui_atg.h
+++ b/Kits/ATGTK/imgui/imgui_atg.h
@@ -76,7 +76,7 @@ namespace ImGuiAtg
     void EndFooter();
 
     // FooterItem() renders one footer hint between BeginFooter() and EndFooter().
-    bool FooterItem(const char* text);
+    bool FooterItem(const char* text, bool clickable = true);
 
     // Handles standard sample input -- the same shortcuts that DrawFooter() advertises:
     //
@@ -84,6 +84,17 @@ namespace ImGuiAtg
     //   F2     / LB+RB+Y            -- toggle light/dark theme
     void HandleStandardInput();
 
+    // Ordered gamepad navigation groups. LB+RB+D-pad up/down moves between the groups
+    // submitted during Draw(), in submission order. When a group is selected, its first
+    // navigable item receives focus.
+    //
+    // Group IDs must be unique within a frame. Groups cannot be nested, and every
+    // BeginNavigationGroup() must have a matching EndNavigationGroup(). Conditional groups
+    // participate only on frames where they are submitted. The standard frame loop must call
+    // HandleStandardInput() once after ImGui::NewFrame() and before submitting groups.
+    void BeginNavigationGroup(const char* id);
+    void EndNavigationGroup();
+
     // Splitter -- splits the current region into two resizable panels.
     //
     // Usage (horizontal -- top/bottom):
diff --git a/Kits/OpenSource/imgui/backends/imgui_impl_win32.cpp b/Kits/OpenSource/imgui/backends/imgui_impl_win32.cpp
index 8376e14d..03e3e3a5 100644
--- a/Kits/OpenSource/imgui/backends/imgui_impl_win32.cpp
+++ b/Kits/OpenSource/imgui/backends/imgui_impl_win32.cpp
@@ -99,6 +99,8 @@
 #include <dwmapi.h>
 #include <wrl.h>
 using Microsoft::WRL::ComPtr;
+#include <mutex>
+#include <vector>
 
 #include <GameInput.h>
 #if GAMEINPUT_API_VERSION == 1
@@ -124,21 +126,25 @@ using namespace GameInput::v3;
 
 struct ImGui_ImplWin32_Data
 {
-    HWND                        hWnd;
-    HWND                        MouseHwnd;
-    int                         MouseTrackedArea;   // 0: not tracked, 1: client area, 2: non-client area
-    int                         MouseButtonsDown;
-    INT64                       Time;
-    INT64                       TicksPerSecond;
-    ImGuiMouseCursor            LastMouseCursor;
-    UINT32                      KeyboardCodePage;
+    HWND                        hWnd = nullptr;
+    HWND                        MouseHwnd = nullptr;
+    int                         MouseTrackedArea = 0;   // 0: not tracked, 1: client area, 2: non-client area
+    int                         MouseButtonsDown = 0;
+    INT64                       Time = 0;
+    INT64                       TicksPerSecond = 0;
+    ImGuiMouseCursor            LastMouseCursor = ImGuiMouseCursor_Arrow;
+    UINT32                      KeyboardCodePage = 0;
 
 #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
-    bool                        HasGamepad;
-    ComPtr<IGameInput>          GameInput;
+    bool                        HasGamepad = false;
+    GameInputCallbackToken      DeviceCallbackToken = 0;
+
+    ComPtr<IGameInput>                    GameInput{};
+    std::vector<ComPtr<IGameInputDevice>> Gamepads{};
+    std::mutex                            GamepadsMutex{};
 #endif
 
-    ImGui_ImplWin32_Data()      { memset((void*)this, 0, sizeof(*this)); }
+    ImGui_ImplWin32_Data() = default;
 };
 
 // Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
@@ -169,6 +175,39 @@ static void ImGui_ImplWin32_UpdateKeyboardCodePage(ImGuiIO& io)
 #endif
 }
 
+static void CALLBACK ImGui_ImplWin32_DeviceCallback(
+    _In_ GameInputCallbackToken,
+    _In_ void* context,
+    _In_ IGameInputDevice* device,
+    _In_ uint64_t,
+    _In_ GameInputDeviceStatus current,
+    _In_ GameInputDeviceStatus previous) noexcept
+{
+    auto* bd = static_cast<ImGui_ImplWin32_Data*>(context);
+
+    const bool wasConnected = (previous & GameInputDeviceConnected) != 0;
+    const bool isConnected = (current & GameInputDeviceConnected) != 0;
+
+    std::lock_guard<std::mutex> lock(bd->GamepadsMutex);
+
+    // newly connected device, add to our list
+    if (isConnected && !wasConnected)
+    {
+        bd->Gamepads.emplace_back(device);
+    }
+
+    // newly disconnected device, remove from our list
+    else if (wasConnected && !isConnected)
+    {
+        bd->Gamepads.erase(
+            std::remove_if(bd->Gamepads.begin(), bd->Gamepads.end(), [device](ComPtr<IGameInputDevice> const& entry)
+            {
+                return entry.Get() == device;
+            }), bd->Gamepads.end()
+        );
+    }
+}
+
 static bool ImGui_ImplWin32_InitEx(void* hwnd, bool platform_has_own_dc)
 {
     ImGuiIO& io = ImGui::GetIO();
@@ -181,17 +220,44 @@ static bool ImGui_ImplWin32_InitEx(void* hwnd, bool platform_has_own_dc)
     if (!::QueryPerformanceCounter((LARGE_INTEGER*)&perf_counter))
         return false;
 
-    // Setup backend capabilities flags
     ImGui_ImplWin32_Data* bd = IM_NEW(ImGui_ImplWin32_Data)();
+    bd->hWnd = (HWND)hwnd;
+    bd->TicksPerSecond = perf_frequency;
+    bd->Time = perf_counter;
+    bd->LastMouseCursor = ImGuiMouseCursor_COUNT;
+
+    // Setup GameInput
+#ifndef IMGUI_IMPL_GDK_DISABLE_GAMEPAD
+    HRESULT hr = GameInputCreate(&bd->GameInput);
+    if (FAILED(hr))
+    {
+        IM_DELETE(bd);
+        return false;
+    }
+
+    hr = bd->GameInput->RegisterDeviceCallback(
+        nullptr,
+        GameInputKindGamepad,
+        GameInputDeviceConnected,
+        GameInputBlockingEnumeration,
+        bd,
+        ImGui_ImplWin32_DeviceCallback,
+        &bd->DeviceCallbackToken);
+
+    if (FAILED(hr))
+    {
+        IM_DELETE(bd);
+        return false;
+    }
+
+#endif // IMGUI_IMPL_GDK_DISABLE_GAMEPAD
+
+    // Setup backend capabilities flags
     io.BackendPlatformUserData = (void*)bd;
     io.BackendPlatformName = "imgui_impl_win32";
     io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;         // We can honor GetMouseCursor() values (optional)
     io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;          // We can honor io.WantSetMousePos requests (optional, rarely used)
 
-    bd->hWnd = (HWND)hwnd;
-    bd->TicksPerSecond = perf_frequency;
-    bd->Time = perf_counter;
-    bd->LastMouseCursor = ImGuiMouseCursor_COUNT;
     ImGui_ImplWin32_UpdateKeyboardCodePage(io);
 
     // Set platform dependent data in viewport
@@ -199,12 +265,6 @@ static bool ImGui_ImplWin32_InitEx(void* hwnd, bool platform_has_own_dc)
     main_viewport->PlatformHandle = main_viewport->PlatformHandleRaw = (void*)bd->hWnd;
     IM_UNUSED(platform_has_own_dc); // Used in 'docking' branch
 
-    // Setup GameInput
-#ifndef IMGUI_IMPL_GDK_DISABLE_GAMEPAD
-    if(GameInputCreate(&bd->GameInput) != S_OK)
-        return false;
-#endif // IMGUI_IMPL_GDK_DISABLE_GAMEPAD
-
     return true;
 }
 
@@ -226,6 +286,18 @@ void    ImGui_ImplWin32_Shutdown()
     ImGuiIO& io = ImGui::GetIO();
     ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
 
+#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
+    if (bd->GameInput != nullptr && bd->DeviceCallbackToken != 0)
+    {
+#if defined(GAMEINPUT_API_VERSION) && (GAMEINPUT_API_VERSION >= 1)
+        bd->GameInput->UnregisterCallback(bd->DeviceCallbackToken);
+#else
+        bd->GameInput->UnregisterCallback(bd->DeviceCallbackToken, UINT64_MAX);
+#endif
+        bd->DeviceCallbackToken = 0;
+    }
+#endif
+
     io.BackendPlatformName = nullptr;
     io.BackendPlatformUserData = nullptr;
     io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad);
@@ -344,8 +416,14 @@ static void ImGui_ImplWin32_UpdateGamepads(ImGuiIO& io)
 #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
     ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData(io);
 
-    if(bd->GameInput == nullptr)
+    std::lock_guard<std::mutex> lock(bd->GamepadsMutex);
+
+    if(bd->GameInput == nullptr || bd->Gamepads.empty() || bd->Gamepads.back() == nullptr)
+    {
+        io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
+        bd->HasGamepad = false;
         return;
+    }
 
 #if GAMEINPUT_API_VERSION == 1
     ComPtr<GameInput::v1::IGameInputReading> reading;
@@ -357,7 +435,7 @@ static void ImGui_ImplWin32_UpdateGamepads(ImGuiIO& io)
     ComPtr<IGameInputReading> reading;
 #endif
 
-    HRESULT hr = bd->GameInput->GetCurrentReading(GameInputKindGamepad, nullptr, &reading);
+    HRESULT hr = bd->GameInput->GetCurrentReading(GameInputKindGamepad, bd->Gamepads.back().Get(), &reading);
     bd->HasGamepad = hr == S_OK;
 
     io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
diff --git a/Samples/Graphics/FramePacing/Assets/LOGO_ATG.png b/Samples/Graphics/FramePacing/Assets/LOGO_ATG.png
new file mode 100644
index 00000000..bd455669
Binary files /dev/null and b/Samples/Graphics/FramePacing/Assets/LOGO_ATG.png differ
diff --git a/Samples/Graphics/FramePacing/Assets/LargeLogo.png b/Samples/Graphics/FramePacing/Assets/LargeLogo.png
new file mode 100644
index 00000000..ed4a935e
Binary files /dev/null and b/Samples/Graphics/FramePacing/Assets/LargeLogo.png differ
diff --git a/Samples/Graphics/FramePacing/Assets/Logo.png b/Samples/Graphics/FramePacing/Assets/Logo.png
new file mode 100644
index 00000000..2ca6c2e9
Binary files /dev/null and b/Samples/Graphics/FramePacing/Assets/Logo.png differ
diff --git a/Samples/Graphics/FramePacing/Assets/SmallLogo.png b/Samples/Graphics/FramePacing/Assets/SmallLogo.png
new file mode 100644
index 00000000..40dba78d
Binary files /dev/null and b/Samples/Graphics/FramePacing/Assets/SmallLogo.png differ
diff --git a/Samples/Graphics/FramePacing/Assets/SplashScreen.png b/Samples/Graphics/FramePacing/Assets/SplashScreen.png
new file mode 100644
index 00000000..4d4d8d33
Binary files /dev/null and b/Samples/Graphics/FramePacing/Assets/SplashScreen.png differ
diff --git a/Samples/Graphics/FramePacing/Assets/StoreLogo.png b/Samples/Graphics/FramePacing/Assets/StoreLogo.png
new file mode 100644
index 00000000..62cd3f2b
Binary files /dev/null and b/Samples/Graphics/FramePacing/Assets/StoreLogo.png differ
diff --git a/Samples/Graphics/FramePacing/Assets/UILayout.json b/Samples/Graphics/FramePacing/Assets/UILayout.json
new file mode 100644
index 00000000..6f69afd3
--- /dev/null
+++ b/Samples/Graphics/FramePacing/Assets/UILayout.json
@@ -0,0 +1,509 @@
+{
+  "styles": [
+    {
+      "classId": "SpriteStyle",
+      "id": "background_panel_gray",
+      "colorUsage": "override",
+      "color": [ 25, 25, 25, 0.75 ]
+    },
+    {
+      "classId": "SpriteStyle",
+      "id": "info_panel_gray",
+      "colorUsage": "override",
+      "color": [ 25, 25, 25, 0.80 ]
+    },
+    {
+      "classId": "SpriteStyle",
+      "id": "legend_panel_gray",
+      "colorUsage": "override",
+      "color": [ 25, 25, 25, 0.85 ]
+    },
+    {
+      "classId": "SpriteStyle",
+      "id": "graph_panel_gray",
+      "colorUsage": "override",
+      "color": [ 25, 25, 25, 0.95 ]
+    },
+    {
+      "classId": "TextStyle",
+      "id": "label_text",
+      "colorUsage": "override",
+      "color": [ 140, 198, 199, 1.0 ],
+      "verticalAlign": "middle"
+    },
+    {
+      "classId": "TextStyle",
+      "id": "highlight_label_text",
+      "colorUsage": "override",
+      "color": [ 219, 73, 28, 1.0 ],
+      "verticalAlign": "middle"
+    },
+    {
+      "classId": "TextStyle",
+      "id": "legend_text",
+      "colorUsage": "override",
+      "color": [ 140, 198, 199, 1.0 ],
+      "verticalAlign": "middle",
+      "horizontalAlign": "center",
+      "legendFont": "Assets/Fonts/XboxOneControllerLegendSmall"
+    }
+  ],
+  "layout": {
+    "classId": "Panel",
+    "id": "root",
+    "positioningAnchor": [ "left", "top" ],
+    "position": [ 0, 0 ],
+    "sizingAnchor": [ "left", "top" ],
+    "size": [ 1920, 1080 ],
+    "style": {
+      "classId": "SpriteStyle",
+      "colorUsage": "override",
+      "color": [ 0, 0, 0, 0.0 ]
+    },
+    "childElements": [
+      {
+        "classId": "Panel",
+        "id": "stats_panel",
+        "positioningAnchor": [ "left", "top" ],
+        "position": [ 785, 0 ],
+        "sizingAnchor": [ "left", "top" ],
+        "size": [ 946, 460 ],
+        "styleId": "background_panel_gray",
+        "childElements": [
+          {
+            "classId": "Panel",
+            "id": "frame_time_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 14, 14 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 570, 134 ],
+            "styleId": "graph_panel_gray"
+          },
+          {
+            "classId": "Panel",
+            "id": "fps_label_background",
+            "positioningAnchor": [ "right", "top" ],
+            "position": [ -199, 14 ],
+            "sizingAnchor": [ "right", "top" ],
+            "size": [ 149, 134 ],
+            "styleId": "info_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "fps_label",
+                "positioningAnchor": [ "right", "top" ],
+                "position": [ -10, 5 ],
+                "sizingAnchor": [ "right", "top" ],
+                "size": [ 100, 124 ],
+                "text": "average\nfps",
+                "style": {
+                  "classId": "TextStyle",
+                  "inheritsFromId": "label_text",
+                  "horizontalAlign": "right"
+                }
+              }
+            ]
+          },
+          {
+            "classId": "Panel",
+            "id": "fps_num_background",
+            "positioningAnchor": [ "right", "top" ],
+            "position": [ 0, 14 ],
+            "sizingAnchor": [ "right", "top" ],
+            "size": [ 199, 134 ],
+            "styleId": "graph_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "fps_num",
+                "positioningAnchor": [ "left", "top" ],
+                "position": [ 10, 5 ],
+                "sizingAnchor": [ "left", "top" ],
+                "size": [ 90, 124 ],
+                "text": "",
+                "style": {
+                  "classId": "TextStyle",
+                  "inheritsFromId": "highlight_label_text",
+                  "size": 48
+                }
+              }
+            ]
+          },
+          {
+            "classId": "Panel",
+            "id": "latency_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 14, 162 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 570, 134 ],
+            "styleId": "graph_panel_gray"
+          },
+          {
+            "classId": "Panel",
+            "id": "latency_label_background",
+            "positioningAnchor": [ "right", "top" ],
+            "position": [ -199, 162 ],
+            "sizingAnchor": [ "right", "top" ],
+            "size": [ 149, 134 ],
+            "styleId": "info_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "latency_label",
+                "positioningAnchor": [ "right", "top" ],
+                "position": [ -10, 5 ],
+                "sizingAnchor": [ "right", "top" ],
+                "size": [ 100, 124 ],
+                "text": "ideal\nlatency (ms)",
+                "style": {
+                  "classId": "TextStyle",
+                  "inheritsFromId": "label_text",
+                  "horizontalAlign": "right"
+                }
+              }
+            ]
+          },
+          {
+            "classId": "Panel",
+            "id": "latency_num_background",
+            "positioningAnchor": [ "right", "top" ],
+            "position": [ 0, 162 ],
+            "sizingAnchor": [ "right", "top" ],
+            "size": [ 199, 134 ],
+            "styleId": "graph_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "latency_num",
+                "positioningAnchor": [ "left", "top" ],
+                "position": [ 10, 5 ],
+                "sizingAnchor": [ "left", "top" ],
+                "size": [ 90, 124 ],
+                "text": "",
+                "style": {
+                  "classId": "TextStyle",
+                  "inheritsFromId": "highlight_label_text",
+                  "size": 48
+                }
+              }
+            ]
+          },
+          {
+            "classId": "Panel",
+            "id": "margin_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 14, 308 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 570, 134 ],
+            "styleId": "graph_panel_gray"
+          },
+          {
+            "classId": "Panel",
+            "id": "margin_label_background",
+            "positioningAnchor": [ "right", "top" ],
+            "position": [ -199, 308 ],
+            "sizingAnchor": [ "right", "top" ],
+            "size": [ 149, 134 ],
+            "styleId": "info_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "margin_label",
+                "positioningAnchor": [ "right", "top" ],
+                "position": [ -10, 5 ],
+                "sizingAnchor": [ "right", "top" ],
+                "size": [ 100, 124 ],
+                "text": "latency\nmargin (ms)",
+                "style": {
+                  "classId": "TextStyle",
+                  "inheritsFromId": "label_text",
+                  "horizontalAlign": "right"
+                }
+              }
+            ]
+          },
+          {
+            "classId": "Panel",
+            "id": "margin_num_background",
+            "positioningAnchor": [ "right", "top" ],
+            "position": [ 0, 308 ],
+            "sizingAnchor": [ "right", "top" ],
+            "size": [ 199, 134 ],
+            "styleId": "graph_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "margin_num",
+                "positioningAnchor": [ "left", "top" ],
+                "position": [ 10, 5 ],
+                "sizingAnchor": [ "left", "top" ],
+                "size": [ 90, 124 ],
+                "text": "",
+                "style": {
+                  "classId": "TextStyle",
+                  "inheritsFromId": "highlight_label_text",
+                  "size": 48
+                }
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "classId": "Panel",
+        "id": "timelines_panel",
+        "positioningAnchor": [ "left", "top" ],
+        "position": [ 15, 480 ],
+        "sizingAnchor": [ "left", "top" ],
+        "size": [ 1700, 515 ],
+        "styleId": "background_panel_gray",
+        "childElements": [
+          {
+            "classId": "Panel",
+            "id": "cpu_update_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 15, 15 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 1670, 85 ],
+            "styleId": "graph_panel_gray"
+          },
+          {
+            "classId": "Panel",
+            "id": "cpu_render_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 15, 115 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 1670, 85 ],
+            "styleId": "graph_panel_gray"
+          },
+          {
+            "classId": "Panel",
+            "id": "gpu_graphics_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 15, 215 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 1670, 85 ],
+            "styleId": "graph_panel_gray"
+          },
+          {
+            "classId": "Panel",
+            "id": "gpu_compute_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 15, 315 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 1670, 85 ],
+            "styleId": "graph_panel_gray"
+          },
+          {
+            "classId": "Panel",
+            "id": "flip_panel",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 15, 415 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 1670, 85 ],
+            "styleId": "graph_panel_gray"
+          }
+        ]
+      },
+      {
+        "classId": "Panel",
+        "id": "control_panel",
+        "positioningAnchor": [ "left", "top" ],
+        "position": [ 0, 0 ],
+        "sizingAnchor": [ "left", "top" ],
+        "size": [ 770, 460 ],
+        "styleId": "background_panel_gray",
+        "childElements": [
+          {
+            "classId": "Panel",
+            "id": "x_legend",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 15, 100 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 175, 145 ],
+            "styleId": "legend_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "x_legend_text",
+                "positioningAnchor": [ "left", "top" ],
+                "position": [ 0, 0 ],
+                "text": "Frame load\nauto/manual\n[X]",
+                "isLegend": true,
+                "styleId": "legend_text"
+              },
+              {
+                "classId": "Panel",
+                "id": "x_legend_border",
+                "positioningAnchor": [ "right", "top" ],
+                "position": [ 0, 0 ],
+                "sizingAnchor": [ "right", "top" ],
+                "size": [ 3, 145 ],
+                "style": {
+                  "classId": "SpriteStyle",
+                  "colorUsage": "override",
+                  "color": [ 122, 104, 238, 1.0 ]
+                }
+              }
+            ]
+          },
+          {
+            "classId": "Panel",
+            "id": "a_legend",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 15, 250 ],
+            "sizingAnchor": [ "left", "top" ],
+            "size": [ 175, 145 ],
+            "styleId": "legend_panel_gray",
+            "childElements": [
+              {
+                "classId": "StaticText",
+                "id": "a_legend_text",
+                "positioningAnchor": [ "left", "top" ],
+                "position": [ 0, 0 ],
+                "text": "Frame pacing\nauto/manual\n[A]",
+                "isLegend": true,
+                "styleId": "legend_text"
+              },
+              {
+                "classId": "Panel",
+                "id": "a_legend_border",
+                "positioningAnchor": [ "right", "top" ],
+                "position": [ 0, 0 ],
+                "sizingAnchor": [ "right", "top" ],
+                "size": [ 3, 145 ],
+                "style": {
+                  "classId": "SpriteStyle",
+                  "colorUsage": "override",
+                  "color": [ 34, 139, 34, 1.0 ]
+                }
+              }
+            ]
+          },
+          {
+            "classId": "Panel",
+            "id": "menu_panel",
+            "positioningAnchor": [ "right", "bottom" ],
+            "position": [ -15, -15 ],
+            "sizingAnchor": [ "right", "bottom" ],
+            "size": [ 550, 380 ],
+            "styleId": "legend_panel_gray"
+          },
+          {
+            "classId": "StaticText",
+            "id": "navigate_legend_text",
+            "positioningAnchor": [ "right", "top" ],
+            "position": [ -15, 10 ],
+            "sizingAnchor": [ "right", "top" ],
+            "size": [ 550, 50 ],
+            "text": "[LThumb] Navigate",
+            "isLegend": true,
+            "styleId": "legend_text"
+          }
+        ]
+      },
+      {
+        "classId": "Panel",
+        "id": "rs_legend",
+        "positioningAnchor": [ "left", "top" ],
+        "position": [ 593, 1007 ],
+        "sizingAnchor": [ "left", "top" ],
+        "size": [ 224, 52 ],
+        "styleId": "legend_panel_gray",
+        "childElements": [
+          {
+            "classId": "StaticText",
+            "id": "rs_legend_text",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 0, 0 ],
+            "text": "[RThumb] Pan left/right",
+            "isLegend": true,
+            "styleId": "legend_text"
+          }
+        ]
+      },
+      {
+        "classId": "Panel",
+        "id": "ltrt_legend",
+        "positioningAnchor": [ "left", "top" ],
+        "position": [ 905, 1007 ],
+        "sizingAnchor": [ "left", "top" ],
+        "size": [ 224, 52 ],
+        "styleId": "legend_panel_gray",
+        "childElements": [
+          {
+            "classId": "StaticText",
+            "id": "ltrt_legend_text",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 0, 0 ],
+            "text": "[LT]/[RT] Zoom out/in",
+            "isLegend": true,
+            "styleId": "legend_text"
+          }
+        ]
+      },
+      {
+        "classId": "Panel",
+        "id": "b_legend",
+        "positioningAnchor": [ "left", "top" ],
+        "position": [ 1217, 1007 ],
+        "sizingAnchor": [ "left", "top" ],
+        "size": [ 224, 52 ],
+        "styleId": "legend_panel_gray",
+        "childElements": [
+          {
+            "classId": "StaticText",
+            "id": "b_legend_text",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 0, 0 ],
+            "text": "[B] Pause/Resume",
+            "isLegend": true,
+            "styleId": "legend_text"
+          }
+        ]
+      },
+      {
+        "classId": "Panel",
+        "id": "exit_legend",
+        "positioningAnchor": [ "left", "top" ],
+        "position": [ 1529, 1007 ],
+        "sizingAnchor": [ "left", "top" ],
+        "size": [ 112, 52 ],
+        "styleId": "legend_panel_gray",
+        "childElements": [
+          {
+            "classId": "StaticText",
+            "id": "exit_legend_text",
+            "positioningAnchor": [ "left", "top" ],
+            "position": [ 0, 0 ],
+            "text": "[View] Exit",
+            "isLegend": true,
+            "styleId": "legend_text"
+          }
+        ]
+      },
+      {
+        "classId": "Panel",
+        "id": "tear_indicator_background",
+        "positioningAnchor": [ "right", "top" ],
+        "position": [ 0, 0 ],
+        "sizingAnchor": [ "right", "top" ],
+        "size": [ 189, 1080 ],
+        "styleId": "background_panel_gray"
+      },
+      {
+        "classId": "Panel",
+        "id": "tear_indicator_border",
+        "positioningAnchor": [ "right", "top" ],
+        "position": [ -189, 0 ],
+        "sizingAnchor": [ "right", "top" ],
+        "size": [ 3, 1080 ],
+        "style": {
+          "classId": "SpriteStyle",
+          "colorUsage": "override",
+          "color": [ 140, 198, 199, 1.0 ]
+        }
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/Samples/Graphics/FramePacing/EnforceGpuTime.hlsl b/Samples/Graphics/FramePacing/EnforceGpuTime.hlsl
new file mode 100644
index 00000000..8f907785
--- /dev/null
+++ b/Samples/Graphics/FramePacing/EnforceGpuTime.hlsl
@@ -0,0 +1,41 @@
+//--------------------------------------------------------------------------------------
+// File: EnforceGpuTime.hlsl
+//
+// This compute shader creates a repeatable GPU workload by spinning until a specified
+// time has passed. FramePacing uses it to demonstrate changing graphics and compute load.
+//
+// This should be compiled with /Od, or subsequent calls to __XB_MemTime() (in
+// GetTimeStamp()) may be optimized away.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#include "Time.hlsli"
+
+#define RS \
+[\
+    RootSignature\
+    (\
+       "RootConstants(num32BitConstants=2, b0),\
+        UAV(u0)"\
+    )\
+]
+
+cbuffer cb0
+{
+    uint64_t g_desiredFrameTime;
+}
+
+RWStructuredBuffer<Time> TimeBuffer : register(u0);
+
+[numthreads(1, 1, 1)]
+RS
+void main( uint3 DTid : SV_DispatchThreadID )
+{
+    do
+    {
+        // Use a buffer to prevent these calls from being optimized away
+        TimeBuffer[0].currentTime = GetTimeStamp();
+    }
+    while ((TimeBuffer[0].currentTime - TimeBuffer[0].startTime) < g_desiredFrameTime);
+}
diff --git a/Samples/Graphics/FramePacing/FrameLoads/GpuGlitch.txt b/Samples/Graphics/FramePacing/FrameLoads/GpuGlitch.txt
new file mode 100644
index 00000000..d1afeabe
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FrameLoads/GpuGlitch.txt
@@ -0,0 +1,7 @@
+// GPU graphics time goes over budget for a frame
+Period: 60
+CpuUpdate: 60 14.0
+CpuRender: 60 13.0
+CpuGpuLag: 60 2.0
+GpuGraphics: 1 20.0 59 15.0
+GpuCompute: 60 1.0
\ No newline at end of file
diff --git a/Samples/Graphics/FramePacing/FrameLoads/GpuJitter.txt b/Samples/Graphics/FramePacing/FrameLoads/GpuJitter.txt
new file mode 100644
index 00000000..1951f698
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FrameLoads/GpuJitter.txt
@@ -0,0 +1,7 @@
+// GPU graphics time jitters up and down
+Period: 2
+CpuUpdate: 2 10.0
+CpuRender: 2 13.0
+CpuGpuLag: 2 2.0
+GpuGraphics: 1 15.0 1 17.0
+GpuCompute: 2 1.0
\ No newline at end of file
diff --git a/Samples/Graphics/FramePacing/FrameLoads/GpuSawtooth.txt b/Samples/Graphics/FramePacing/FrameLoads/GpuSawtooth.txt
new file mode 100644
index 00000000..1b3468cd
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FrameLoads/GpuSawtooth.txt
@@ -0,0 +1,7 @@
+// GPU graphics time goes over based on a sawtooth pattern
+Period: 70
+CpuUpdate: 70 10.0
+CpuRender: 70 10.0
+CpuGpuLag: 70 2.0
+GpuGraphics: 10 16.0 10 17.0 10 18.0 10 19.0 10 18.0 10 17.0 10 16.0 
+GpuCompute: 70 1.0
diff --git a/Samples/Graphics/FramePacing/FrameLoads/GpuSpike.txt b/Samples/Graphics/FramePacing/FrameLoads/GpuSpike.txt
new file mode 100644
index 00000000..76236d19
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FrameLoads/GpuSpike.txt
@@ -0,0 +1,7 @@
+// GPU graphics time spikes periodically
+Period: 120
+CpuUpdate: 120 14.0
+CpuRender: 120 13.0
+CpuGpuLag: 120 2.0
+GpuGraphics: 10 20.0 110 15.0
+GpuCompute: 120 1.0
\ No newline at end of file
diff --git a/Samples/Graphics/FramePacing/FramePacing.cpp b/Samples/Graphics/FramePacing/FramePacing.cpp
new file mode 100644
index 00000000..03054afa
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FramePacing.cpp
@@ -0,0 +1,2139 @@
+//--------------------------------------------------------------------------------------
+// FramePacing.cpp
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#include "pch.h"
+#include "FramePacing.h"
+
+#include "ATGColors.h"
+#include "CommonStates.h"
+#include "Menu.h"
+#include "ReadData.h"
+
+extern void ExitSample() noexcept;
+
+using namespace DirectX;
+using namespace ATG::UITK;
+using namespace FramePacingUtils;
+
+using Microsoft::WRL::ComPtr;
+
+namespace
+{
+    // Will store frequency of QueryPerformanceCounter
+    static uint64_t g_cpuPerfFreq = 0ULL;
+
+    // Will store frequency of GetTimestampFrequency
+    static uint64_t g_gpuPerfFreq = 0ULL;
+    static uint64_t g_cpuAnchorTimestamp = 0ULL;
+    static uint64_t g_gpuAnchorTimestamp = 0ULL;
+
+    uint64_t ConvertGpuToCpuTimestamp(uint64_t gpuTimestamp)
+    {
+        return g_cpuAnchorTimestamp - ((g_gpuAnchorTimestamp - gpuTimestamp) * g_cpuPerfFreq / g_gpuPerfFreq);
+    }
+
+    // Fixed offsets into descriptor heaps
+    enum SRVDescriptorHeapIndex
+    {
+        SRV_Font = 0,
+        SRV_CtrlFont,
+        SRV_Count
+    };
+
+    PackedVector::XMCOLOR c_intervalColorsPacked[_countof(c_intervalColors)];
+};
+
+Sample::Sample() noexcept(false)
+    : m_fenceValue(0ULL)
+    , m_rtvDescriptorSize(0)
+    , m_screenViewport{}
+    , m_scissorRect{}
+    , m_backBufferFormat(DXGI_FORMAT_B8G8R8A8_UNORM)
+    , m_window(nullptr)
+    , m_outputSize{ 0, 0, 1920, 1080 }
+    , m_frame(0)
+    , m_nextFrameBufferIndex(0)
+    , m_nextFrameIndex(0)
+    , m_currentUpdateFrameBuffer{}
+    , m_currentRenderFrameBuffer{}
+    , m_eventUpdateDone(nullptr)
+    , m_eventRenderReceived(nullptr)
+    , m_renderThread(nullptr)
+    , m_fenceGraphicsToComputeValue(0)
+    , m_fenceComputeToGraphicsValue(0)
+    , m_enforceCpuUpdateTimeThread(nullptr)
+    , m_enforceCpuRenderTimeThread(nullptr)
+    , m_isExiting(false)
+    , m_startCpuUpdateSignal(true)
+    , m_updateThreadTimeInMs(0.0f)
+    , m_endCpuUpdateSignal(false)
+    , m_startCpuRenderSignal(true)
+    , m_renderThreadTimeInMs(0.0f)
+    , m_endCpuRenderSignal(false)
+    , m_desiredFrameLoad{}
+    , m_autoFrameLoad(false)
+    , m_currentFrameLoadSequence(0)
+    , m_framePacing{}
+    , m_autoPacing(false)
+    , m_frameEventsDirty(false)
+    , m_frameRateMeasured(60.0f)
+    , m_latencyMeasuredInMs(30.0f)
+    , m_marginMeasuredInMs(3.3f)
+    , m_tearLocation(0.0f)
+    , m_paused(false)
+    , m_graphZoom(1.0f)
+    , m_graphOffset(0.0f)
+    , m_queryCurrentFrame(0U)
+{
+    m_framePacing.m_frameRateTarget = FrameRate::Fps60;
+    m_framePacing.m_frameThreshold = 0;
+    m_framePacing.m_framePeriod = 2;
+    m_framePacing.m_frameBuffers = 3;
+    m_framePacing.m_frameOffsetInMs = 0;
+
+    m_deviceType = XSystemGetDeviceType();
+
+    LARGE_INTEGER freq;
+    if (!QueryPerformanceFrequency(&freq))
+    {
+        throw std::runtime_error("QueryPerformanceFrequency");
+    }
+    g_cpuPerfFreq = static_cast<uint64_t>(freq.QuadPart);
+
+    for (auto i = 0U; i < _countof(c_intervalColors); ++i)
+    {
+        PackedVector::XMStoreColor(&c_intervalColorsPacked[i], c_intervalColors[i]);
+    }
+}
+
+Sample::~Sample()
+{
+    m_isExiting = true;
+
+    if (m_eventUpdateDone)
+    {
+        SetEvent(m_eventUpdateDone);
+    }
+    if (m_eventRenderReceived)
+    {
+        SetEvent(m_eventRenderReceived);
+    }
+
+    if (m_renderThread)
+    {
+        m_renderThread->join();
+        delete m_renderThread;
+        m_renderThread = nullptr;
+    }
+
+    if (m_enforceCpuUpdateTimeThread)
+    {
+        m_enforceCpuUpdateTimeThread->join();
+        delete m_enforceCpuUpdateTimeThread;
+        m_enforceCpuUpdateTimeThread = nullptr;
+    }
+
+    if (m_enforceCpuRenderTimeThread)
+    {
+        m_enforceCpuRenderTimeThread->join();
+        delete m_enforceCpuRenderTimeThread;
+        m_enforceCpuRenderTimeThread = nullptr;
+    }
+
+    WaitForGpu();
+
+    // This sample can present from either queue, so clear both queues before
+    // member destruction releases the presentation resources.
+    if (m_commandQueueGraphics)
+    {
+        std::ignore = m_commandQueueGraphics->PresentX(0, nullptr, nullptr);
+    }
+    if (m_commandQueueCompute)
+    {
+        std::ignore = m_commandQueueCompute->PresentX(0, nullptr, nullptr);
+    }
+
+    if (m_eventUpdateDone)
+    {
+        CloseHandle(m_eventUpdateDone);
+    }
+    if (m_eventRenderReceived)
+    {
+        CloseHandle(m_eventRenderReceived);
+    }
+
+}
+
+// Initialize the Direct3D resources required to run.
+void Sample::Initialize(HWND window)
+{
+    m_gamePad = std::make_unique<GamePad>();
+
+    m_window = window;
+
+    CreateDeviceDependentResources();
+    RegisterFrameEvents();
+
+    CreateWindowSizeDependentResources();
+
+    InitializeUI();
+
+    CreateThreads();
+
+    CreateWorkers();
+
+    CreateGraphs();
+
+    CreateFrameLoadSequences();
+}
+
+void Sample::InitializeUI()
+{
+    auto layout = m_uiManager.LoadLayoutFromFile("Assets/UILayout.json");
+    m_uiManager.AttachTo(layout, m_uiManager.GetRootElement());
+
+    // Cache these for faster access
+    m_fpsText = m_uiManager.FindTypedById<UIStaticText>(ID("fps_num"));
+    m_latencyText = m_uiManager.FindTypedById<UIStaticText>(ID("latency_num"));
+    m_marginText = m_uiManager.FindTypedById<UIStaticText>(ID("margin_num"));
+    m_menuPanel = m_uiManager.FindTypedById<UIPanel>(ID("menu_panel"));
+
+    m_menu.SetItemStatus(UI_PARAM_FRAME_LOAD_SEQUENCE, UIParam::STATUS_AUTO);
+}
+
+void Sample::CreateThreads()
+{
+    m_eventUpdateDone = CreateEvent(nullptr, FALSE, FALSE, L"Update Done");
+    m_eventRenderReceived = CreateEvent(nullptr, FALSE, TRUE, L"Render Received");
+    if (!m_eventUpdateDone || !m_eventRenderReceived)
+    {
+        throw std::system_error(std::error_code(static_cast<int>(GetLastError()), std::system_category()), "CreateEvent");
+    }
+
+    // Rename the main thread as Update Thread
+    auto updateThreadName = L"Update Thread";
+    auto updateThreadHandle = GetCurrentThread();
+    auto updateCore = 0ULL;
+    (void)SetThreadDescription(updateThreadHandle, updateThreadName);
+    (void)SetThreadAffinityMask(updateThreadHandle, 1ULL << updateCore);   // Run on its own core
+    (void)SetThreadPriority(updateThreadHandle, THREAD_PRIORITY_NORMAL);
+
+    // Create Render Thread which loops over the rendering code
+    auto renderThreadName = L"Render Thread";
+    m_renderThread = new std::thread(&Sample::Render, this);
+    auto renderThreadHandle = m_renderThread->native_handle();
+    auto renderCore = 1ULL;
+    (void)SetThreadDescription(renderThreadHandle, renderThreadName);
+    (void)SetThreadAffinityMask(renderThreadHandle, 1ULL << renderCore);   // Run on its own core
+    (void)SetThreadPriority(renderThreadHandle, THREAD_PRIORITY_NORMAL);
+}
+
+void Sample::CreateWorkers()
+{
+    auto device = m_device;
+
+    // Create worker compute shaders to enforce GPU frame time
+    {
+        const D3D12_HEAP_PROPERTIES defaultHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
+        const D3D12_RESOURCE_DESC bufDesc = CD3DX12_RESOURCE_DESC::Buffer(2 * sizeof(uint64_t), D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
+        DX::ThrowIfFailed(
+            device->CreateCommittedResource(
+                &defaultHeapProperties,
+                D3D12_HEAP_FLAG_NONE,
+                &bufDesc,
+                D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
+                nullptr,
+                IID_GRAPHICS_PPV_ARGS(m_gpuTimeResourceGraphics.ReleaseAndGetAddressOf())));
+        m_gpuTimeResourceGraphics->SetName(L"Enforce GPU Time Resource Graphics");
+        DX::ThrowIfFailed(
+            device->CreateCommittedResource(
+                &defaultHeapProperties,
+                D3D12_HEAP_FLAG_NONE,
+                &bufDesc,
+                D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
+                nullptr,
+                IID_GRAPHICS_PPV_ARGS(m_gpuTimeResourceCompute.ReleaseAndGetAddressOf())));
+        m_gpuTimeResourceCompute->SetName(L"Enforce GPU Time Resource Compute");
+
+        // Shader to read frame start time
+        auto computeShaderBlob = DX::ReadData(L"GetStartTime.cso");
+
+        DX::ThrowIfFailed(
+            device->CreateRootSignature(0, computeShaderBlob.data(), computeShaderBlob.size(),
+                IID_GRAPHICS_PPV_ARGS(m_getStartTimeRS.ReleaseAndGetAddressOf())));
+        m_getStartTimeRS->SetName(L"Get GPU Time RS");
+
+        D3D12_COMPUTE_PIPELINE_STATE_DESC descComputePSO = {};
+        descComputePSO.pRootSignature = m_getStartTimeRS.Get();
+        descComputePSO.CS.pShaderBytecode = computeShaderBlob.data();
+        descComputePSO.CS.BytecodeLength = computeShaderBlob.size();
+
+        DX::ThrowIfFailed(
+            device->CreateComputePipelineState(&descComputePSO, IID_GRAPHICS_PPV_ARGS(m_getStartTimePSO.ReleaseAndGetAddressOf())));
+        m_getStartTimePSO->SetName(L"Enforce GPU Time PSO");
+
+
+
+        // Shader to wait until specified time
+        computeShaderBlob = DX::ReadData(L"EnforceGpuTime.cso");
+
+        DX::ThrowIfFailed(
+            device->CreateRootSignature(0, computeShaderBlob.data(), computeShaderBlob.size(),
+                IID_GRAPHICS_PPV_ARGS(m_gpuEnforceTimeRS.ReleaseAndGetAddressOf())));
+        m_gpuEnforceTimeRS->SetName(L"Enforce GPU Time RS");
+
+        // Create compute pipeline state
+        descComputePSO = {};
+        descComputePSO.pRootSignature = m_gpuEnforceTimeRS.Get();
+        descComputePSO.CS.pShaderBytecode = computeShaderBlob.data();
+        descComputePSO.CS.BytecodeLength = computeShaderBlob.size();
+
+        DX::ThrowIfFailed(
+            device->CreateComputePipelineState(&descComputePSO, IID_GRAPHICS_PPV_ARGS(m_gpuEnforceTimePSO.ReleaseAndGetAddressOf())));
+        m_gpuEnforceTimePSO->SetName(L"Enforce GPU Time PSO");
+    }
+
+    // Create worker threads to enforce CPU frame time
+    {
+        m_startCpuUpdateSignal = false; 
+        m_endCpuUpdateSignal = false;
+
+        auto cpuEnforceUpdateTimeThread = L"CPU Enforce Update Time Thread";
+        m_enforceCpuUpdateTimeThread = new std::thread(&Sample::EnforceCpuUpdateTime, this);
+        auto updateThreadHandle = m_enforceCpuUpdateTimeThread->native_handle();
+        auto updateCore = 2ULL;
+        (void)SetThreadDescription(updateThreadHandle, cpuEnforceUpdateTimeThread);
+        (void)SetThreadAffinityMask(updateThreadHandle, 1ULL << updateCore);   // Run on its own core
+        (void)SetThreadPriority(updateThreadHandle, THREAD_PRIORITY_NORMAL);   // Can bump priority if necessary to avoid preemption
+
+        m_startCpuRenderSignal = false;
+        m_endCpuRenderSignal = false;
+
+        auto cpuEnforceRenderTimeThread = L"CPU Enforce Render Time Thread";
+        m_enforceCpuRenderTimeThread = new std::thread(&Sample::EnforceCpuRenderTime, this);
+        auto renderThreadHandle = m_enforceCpuRenderTimeThread->native_handle();
+        auto renderCore = 3ULL;
+        (void)SetThreadDescription(renderThreadHandle, cpuEnforceRenderTimeThread);
+        (void)SetThreadAffinityMask(renderThreadHandle, 1ULL << renderCore);   // Run on its own core
+        (void)SetThreadPriority(renderThreadHandle, THREAD_PRIORITY_NORMAL);   // Can bump priority if necessary to avoid preemption
+    }
+}
+
+// Forces the CPU to wait until a predetermined time has elapsed.
+void Sample::EnforceCpuUpdateTime()
+{
+    while (!m_isExiting)
+    {
+        if (m_startCpuUpdateSignal)
+        {
+            PIXBeginEvent(0, L"CPU artificial Update workload");
+
+            assert(!m_endCpuUpdateSignal);
+
+            m_startCpuUpdateSignal = false;
+            LARGE_INTEGER startTime;
+            QueryPerformanceCounter(&startTime);
+
+            LARGE_INTEGER endTime;
+            endTime.QuadPart = startTime.QuadPart + static_cast<int64_t>(m_updateThreadTimeInMs / 1000.0 * g_cpuPerfFreq);
+            LARGE_INTEGER currentTime;
+            do
+            {
+                QueryPerformanceCounter(&currentTime);
+            } while (currentTime.QuadPart < endTime.QuadPart && !m_isExiting);
+
+            m_endCpuUpdateSignal = true;
+
+            PIXEndEvent();
+        }
+    }
+
+    m_endCpuUpdateSignal = true;
+}
+
+// Forces the CPU to wait until a predetermined time has elapsed.
+void Sample::EnforceCpuRenderTime()
+{
+    while (!m_isExiting)
+    {
+        if (m_startCpuRenderSignal)
+        {
+            PIXBeginEvent(0, L"CPU artificial Render workload");
+
+            assert(!m_endCpuRenderSignal);
+
+            m_startCpuRenderSignal = false;
+            LARGE_INTEGER startTime;
+            QueryPerformanceCounter(&startTime);
+
+            LARGE_INTEGER endTime;
+            endTime.QuadPart = startTime.QuadPart + static_cast<int64_t>(m_renderThreadTimeInMs / 1000.0 * g_cpuPerfFreq);
+            LARGE_INTEGER currentTime;
+            do
+            {
+                QueryPerformanceCounter(&currentTime);
+            } while (currentTime.QuadPart < endTime.QuadPart && !m_isExiting);
+
+            m_endCpuRenderSignal = true;
+
+            PIXEndEvent();
+        }
+    }
+
+    m_endCpuRenderSignal = true;
+}
+
+void Sample::CreateGraphs()
+{
+    for (uint32_t lineGraphIndex = 0; lineGraphIndex < LINE_GRAPH_COUNT; ++lineGraphIndex)
+    {
+        m_lineGraph[lineGraphIndex].m_name = c_lineGraphNames[lineGraphIndex];
+        m_lineGraphPanel[lineGraphIndex] = m_uiManager.FindTypedById<UIPanel>(ID(c_lineGraphLayoutNames[lineGraphIndex]));
+    }
+    m_lineGraph[LINE_GRAPH_FRAME_TIME_FLIP].m_maxX = 1.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_TIME_FLIP].m_minX = 0.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_TIME_FLIP].m_maxY = 50.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_TIME_FLIP].m_minY = 0.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_TIME_FLIP].m_tickInterval = 16.66f;
+    m_lineGraph[LINE_GRAPH_FRAME_TIME_FLIP].m_createData = [](const FrameStatistics* frameStats)->DataPoint
+    {
+        static FrameStatistics s_stats[2] = {};
+        s_stats[1] = *frameStats;
+
+        DataPoint dataPoint = {};
+        dataPoint.m_flipTimeInMs = 1000.0 * (frameStats->display.FlipTime / static_cast<double>(g_cpuPerfFreq));
+        if (0ULL != s_stats[0].display.FlipTime)    // Can't get a frame duration until the 2nd flip
+        {
+            dataPoint.m_value = 1000.0f * static_cast<float>((s_stats[1].display.FlipTime - s_stats[0].display.FlipTime) / static_cast<double>(g_cpuPerfFreq));
+        }
+
+        s_stats[0] = *frameStats;
+        return dataPoint;
+    };
+    m_lineGraph[LINE_GRAPH_FRAME_LATENCY].m_maxX = 1.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_LATENCY].m_minX = 0.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_LATENCY].m_maxY = 50.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_LATENCY].m_minY = 0.0f;
+    m_lineGraph[LINE_GRAPH_FRAME_LATENCY].m_tickInterval = 16.66f;
+    m_lineGraph[LINE_GRAPH_FRAME_LATENCY].m_createData = [](const FrameStatistics* frameStats)->DataPoint
+    {
+        DataPoint dataPoint = {};
+        dataPoint.m_flipTimeInMs = 1000.0 * (frameStats->display.FlipTime / static_cast<double>(g_cpuPerfFreq));
+        dataPoint.m_value = 1000.0f * static_cast<float>((frameStats->present.GPUProcessTime - frameStats->origin.SignalTime) / static_cast<double>(g_cpuPerfFreq));
+
+        return dataPoint;
+    };
+    m_lineGraph[LINE_GRAPH_LATENCY_MARGIN].m_maxX = 1.0f;
+    m_lineGraph[LINE_GRAPH_LATENCY_MARGIN].m_minX = 0.0f;
+    m_lineGraph[LINE_GRAPH_LATENCY_MARGIN].m_maxY = 16.67f;
+    m_lineGraph[LINE_GRAPH_LATENCY_MARGIN].m_minY = -16.67f;
+    m_lineGraph[LINE_GRAPH_LATENCY_MARGIN].m_tickInterval = 16.67f;
+    m_lineGraph[LINE_GRAPH_LATENCY_MARGIN].m_createData = [](const FrameStatistics* frameStats)->DataPoint
+    {
+        DataPoint dataPoint = {};
+        dataPoint.m_flipTimeInMs = 1000.0 * (frameStats->display.FlipTime / static_cast<double>(g_cpuPerfFreq));
+        auto frameOriginInMicroseconds = 1000.0 * 1000.0 * (frameStats->origin.SignalTime / static_cast<double>(g_cpuPerfFreq));
+        auto frameBudgetInMicroseconds = frameStats->interval.LengthInMicroseconds * frameStats->interval.PeriodInIntervals
+            - frameStats->origin.IntervalOffsetInMicroseconds;
+        auto frameDeadlineInMicroseconds = frameOriginInMicroseconds + frameBudgetInMicroseconds;
+        auto frameCompletionInMicroseconds = 1000.0 * 1000.0 * (frameStats->present.GPUProcessTime / static_cast<double>(g_cpuPerfFreq));
+            
+        dataPoint.m_value = static_cast<float>((frameDeadlineInMicroseconds - frameCompletionInMicroseconds) / 1000.0);
+
+       return dataPoint;
+    };
+
+    for (uint32_t intervalGraphIndex = 0; intervalGraphIndex < INTERVAL_GRAPH_COUNT; ++intervalGraphIndex)
+    {
+        m_intervalGraph[intervalGraphIndex].m_name = c_intervalGraphNames[intervalGraphIndex];
+        m_intervalGraphPanel[intervalGraphIndex] = m_uiManager.FindTypedById<UIPanel>(ID(c_intervalGraphLayoutNames[intervalGraphIndex]));
+    }
+    m_intervalGraph[INTERVAL_GRAPH_CPU_UPDATE].m_maxX = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_UPDATE].m_minX = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_UPDATE].m_maxY = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_UPDATE].m_minY = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_UPDATE].m_tickInterval = 1000.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_UPDATE].m_createData = [](const FrameTimestamps* frameTimestamps)->DataInterval
+    {
+        DataInterval dataInterval = {};
+        dataInterval.m_frameBuffer = frameTimestamps->m_frameBuffer;
+        dataInterval.m_flipTimeInMs = 1000.0 * frameTimestamps->m_flipTime / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_startInMs = 1000.0 * frameTimestamps->m_startCpuUpdate.QuadPart / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_stopInMs = 1000.0 * frameTimestamps->m_stopCpuUpdate.QuadPart / static_cast<double>(g_cpuPerfFreq);
+        return dataInterval;
+    };
+    m_intervalGraph[INTERVAL_GRAPH_CPU_RENDER].m_maxX = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_RENDER].m_minX = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_RENDER].m_maxY = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_RENDER].m_minY = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_RENDER].m_tickInterval = 1000.0f;
+    m_intervalGraph[INTERVAL_GRAPH_CPU_RENDER].m_createData = [](const FrameTimestamps* frameTimestamps)->DataInterval
+    {
+        DataInterval dataInterval = {};
+        dataInterval.m_frameBuffer = frameTimestamps->m_frameBuffer;
+        dataInterval.m_flipTimeInMs = 1000.0 * frameTimestamps->m_flipTime / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_startInMs = 1000.0 * frameTimestamps->m_startCpuRender.QuadPart / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_stopInMs = 1000.0 * frameTimestamps->m_stopCpuRender.QuadPart / static_cast<double>(g_cpuPerfFreq);
+        return dataInterval;
+    };
+    m_intervalGraph[INTERVAL_GRAPH_GPU_GRAPHICS].m_maxX = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_GRAPHICS].m_minX = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_GRAPHICS].m_maxY = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_GRAPHICS].m_minY = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_GRAPHICS].m_tickInterval = 1000.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_GRAPHICS].m_createData = [](const FrameTimestamps* frameTimestamps)->DataInterval
+    {
+        DataInterval dataInterval = {};
+        dataInterval.m_frameBuffer = frameTimestamps->m_frameBuffer;
+        dataInterval.m_flipTimeInMs = 1000.0 * frameTimestamps->m_flipTime / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_startInMs = 1000.0 * ConvertGpuToCpuTimestamp(frameTimestamps->m_startGpuGraphics) / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_stopInMs = 1000.0 * ConvertGpuToCpuTimestamp(frameTimestamps->m_stopGpuGraphics) / static_cast<double>(g_cpuPerfFreq);
+        return dataInterval;
+    };
+    m_intervalGraph[INTERVAL_GRAPH_GPU_COMPUTE].m_maxX = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_COMPUTE].m_minX = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_COMPUTE].m_maxY = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_COMPUTE].m_minY = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_COMPUTE].m_tickInterval = 1000.0f;
+    m_intervalGraph[INTERVAL_GRAPH_GPU_COMPUTE].m_createData = [](const FrameTimestamps* frameTimestamps)->DataInterval
+    {
+        DataInterval dataInterval = {};
+        dataInterval.m_frameBuffer = frameTimestamps->m_frameBuffer;
+        dataInterval.m_flipTimeInMs = 1000.0 * frameTimestamps->m_flipTime / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_startInMs = 1000.0 * ConvertGpuToCpuTimestamp(frameTimestamps->m_startGpuCompute) / static_cast<double>(g_cpuPerfFreq);
+        dataInterval.m_stopInMs = 1000.0 * ConvertGpuToCpuTimestamp(frameTimestamps->m_stopGpuCompute) / static_cast<double>(g_cpuPerfFreq);
+        return dataInterval;
+    };
+    m_intervalGraph[INTERVAL_GRAPH_FLIP].m_maxX = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_FLIP].m_minX = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_FLIP].m_maxY = 1.0f;
+    m_intervalGraph[INTERVAL_GRAPH_FLIP].m_minY = 0.0f;
+    m_intervalGraph[INTERVAL_GRAPH_FLIP].m_tickInterval = 1000.0f;
+    m_intervalGraph[INTERVAL_GRAPH_FLIP].m_createData = [](const FrameTimestamps* frameTimestamps)->DataInterval
+    {
+        static FrameTimestamps s_timestamps[2] = {};
+        s_timestamps[1] = *frameTimestamps;
+
+        DataInterval dataInterval = {};
+        dataInterval.m_flipTimeInMs = 1000.0 * frameTimestamps->m_flipTime / static_cast<double>(g_cpuPerfFreq);
+        if (0ULL != s_timestamps[0].m_flipTime)    // Can't get a frame duration until the 2nd flip
+        {
+            dataInterval.m_frameBuffer = s_timestamps[0].m_frameBuffer;
+            dataInterval.m_startInMs = 1000.0 * s_timestamps[0].m_flipTime / static_cast<double>(g_cpuPerfFreq);
+            dataInterval.m_stopInMs = 1000.0 * s_timestamps[1].m_flipTime / static_cast<double>(g_cpuPerfFreq);
+        }
+
+        s_timestamps[0] = *frameTimestamps;
+        return dataInterval;
+    };
+}
+
+// Reads text files which describe a repeating pattern of frame loads to simulate
+void Sample::CreateFrameLoadSequences()
+{
+    m_frameLoadSequences.resize(_countof(c_frameLoadSequenceNames));
+    for (auto sequence = 0U; sequence < _countof(c_frameLoadSequenceNames); ++sequence)
+    {
+        std::vector<FrameLoad>& frameLoadSequence = m_frameLoadSequences[sequence];
+
+        wchar_t filePath[256];
+        swprintf_s(filePath, L"FrameLoads\\%ls.txt", c_frameLoadSequenceFileNames[sequence]);
+        auto frameLoadRawData = DX::ReadData(filePath);
+        assert(frameLoadRawData.size() > 0ULL);   // Missing frame load sequence file
+
+        std::istringstream rawData(std::string(
+            reinterpret_cast<const char*>(frameLoadRawData.data()),
+            frameLoadRawData.size()));
+
+        char line[256] = "";
+        uint32_t period = 0U;
+        uint32_t linesFound = 0U;
+        while (!rawData.eof())
+        {
+            rawData.getline(line, _countof(line));
+
+            std::istringstream rawLine(line);
+
+            char lineHeader[256] = "";
+            rawLine >> lineHeader >> std::ws;
+
+            auto parseValues = [&](float FrameLoad::* value)
+            {
+                auto next = 0U;
+                uint32_t runLength = 0;
+                float runValue = 0.0f;
+                while (rawLine >> runLength >> runValue)
+                {
+                    if (runValue < 0.0f)
+                    {
+                        throw std::runtime_error("Frame load values must be non-negative");
+                    }
+
+                    for (auto i = 0U; i < runLength; ++i)
+                    {
+                        frameLoadSequence[next++].*value = runValue;
+                    }
+                }
+                assert(period == next); // Invalid frame load file
+            };
+
+            if (0 == strcmp(lineHeader, "//"))
+            {
+                // comment
+                continue;
+            }
+            else if (0 == strcmp(lineHeader, "Period:"))
+            {
+                ++linesFound;
+
+                rawLine >> period;
+
+                frameLoadSequence.resize(period);
+            }
+            else if (0 == strcmp(lineHeader, "CpuUpdate:"))
+            {
+                ++linesFound;
+                parseValues(&FrameLoad::m_cpuUpdateTimeInMs);
+            }
+            else if (0 == strcmp(lineHeader, "CpuRender:"))
+            {
+                ++linesFound;
+                parseValues(&FrameLoad::m_cpuRenderTimeInMs);
+            }
+            else if (0 == strcmp(lineHeader, "CpuGpuLag:"))
+            {
+                ++linesFound;
+                parseValues(&FrameLoad::m_cpuToGpuTimeInMs);
+            }
+            else if (0 == strcmp(lineHeader, "GpuGraphics:"))
+            {
+                ++linesFound;
+                parseValues(&FrameLoad::m_gpuGraphicsTimeInMs);
+            }
+            else if (0 == strcmp(lineHeader, "GpuCompute:"))
+            {
+                ++linesFound;
+                parseValues(&FrameLoad::m_gpuComputeTimeInMs);
+            }
+        }
+
+        assert(6U == linesFound); // Invalid frame load file
+    }
+}
+
+Sample::FrameLoad Sample::GetFrameLoad(uint32_t frameIndex) const
+{
+    std::scoped_lock lock(m_settingsMutex);
+
+    if (m_autoFrameLoad)
+    {
+        const auto& frameLoadSequence = m_frameLoadSequences[m_currentFrameLoadSequence];
+        return frameLoadSequence[frameIndex % frameLoadSequence.size()];
+    }
+
+    return m_desiredFrameLoad;
+}
+
+#pragma region Frame Update
+// Executes basic render loop.
+void Sample::Tick()
+{
+    PIXBeginEvent(PIX_COLOR_DEFAULT, L"Frame %llu", m_frame);
+
+    PIXBeginEvent(PIX_COLOR_DEFAULT, L"WaitFrameEventX");
+
+    // Prepare the command list to render a new frame.
+    BeginFrame();
+
+    PIXEndEvent();
+
+    m_timer.Tick([&]()
+    {
+        Update(m_timer);
+    });
+
+    // Game state is usually double-buffered, regardless of swap chain size
+    // so can't let Update signal Render until Render acknowledges previous signal
+    {
+        PIXScopedEvent(PIX_COLOR_DEFAULT, L"Throttle on Render");
+        auto result = WaitForSingleObject(m_eventRenderReceived, INFINITE);
+        if (WAIT_OBJECT_0 != result)
+        {
+            throw std::runtime_error("Expected thread to receive signal");
+        }
+    }
+
+    // Signal Render thread that a game state is available
+    {
+        auto result = SetEvent(m_eventUpdateDone);
+        if (!result)
+        {
+            throw std::runtime_error("Expected event to get signaled");
+        }
+    }
+
+    PIXEndEvent();
+    m_frame++;
+}
+
+// Updates the world.
+void Sample::Update(DX::StepTimer const& /*timer*/)
+{
+    static_assert(_countof(c_intervalColors) == c_maxBackBufferCount);
+    PIXBeginEvent(c_intervalColorsPacked[m_currentUpdateFrameBuffer.m_frameBuffer], L"Update %d", m_currentUpdateFrameBuffer.m_frame);
+
+    UpdateUI();
+
+    m_updateThreadTimeInMs = m_currentUpdateFrameBuffer.m_frameLoad.m_cpuUpdateTimeInMs;
+
+    // Start timer for artificial CPU load
+    m_startCpuUpdateSignal = true;
+
+    // Record timestamp with frame token
+    TaggedCpuTimestamp startCpuUpdate;
+    startCpuUpdate.m_token = m_currentUpdateFrameBuffer.m_token;
+    startCpuUpdate.m_frameBuffer = m_currentUpdateFrameBuffer.m_frameBuffer;
+    if (!QueryPerformanceCounter(&startCpuUpdate.m_time))
+    {
+        throw std::runtime_error("QueryPerformanceCounter");
+    }
+    m_startCpuUpdate.push(startCpuUpdate);
+
+    // Wait for artificial CPU load
+    PIXBeginEvent(PIX_COLOR_DEFAULT, L"Artificial CPU load");
+    while (!m_endCpuUpdateSignal)
+    {
+        _mm_pause();
+    }
+    m_endCpuUpdateSignal = false;
+
+    // Record timestamp with frame token
+    TaggedCpuTimestamp stopCpuUpdate;
+    stopCpuUpdate.m_token = m_currentUpdateFrameBuffer.m_token;
+    stopCpuUpdate.m_frameBuffer = m_currentUpdateFrameBuffer.m_frameBuffer;
+    if (!QueryPerformanceCounter(&stopCpuUpdate.m_time))
+    {
+        throw std::runtime_error("QueryPerformanceCounter");
+    }
+    m_stopCpuUpdate.push(stopCpuUpdate);
+
+    PIXEndEvent();
+
+    PIXEndEvent();
+}
+
+void Sample::UpdateUI()
+{
+    std::scoped_lock stateLock(m_settingsMutex, m_uiMutex);
+
+    float elapsedTime = float(m_timer.GetElapsedSeconds());
+
+    auto pad = m_gamePad->GetState(0);
+    if (pad.IsConnected())
+    {
+        m_gamePadButtons.Update(pad);
+
+        if (pad.IsViewPressed())
+        {
+            ExitSample();
+        }
+
+        if (m_gamePadButtons.a == GamePad::ButtonStateTracker::PRESSED)
+        {
+            m_autoPacing = !m_autoPacing;
+
+            // Store off manual settings for later restore
+            static FramePacing manualFramePacing = {};
+            if (m_autoPacing)
+            {
+                manualFramePacing = m_framePacing;
+            }
+            else
+            {
+                m_framePacing = manualFramePacing;
+
+                m_menu.SetItemValue< uint32_t >(UI_PARAM_FRAME_RATE, static_cast<uint32_t>(m_framePacing.m_frameRateTarget));
+                m_menu.SetItemValue<int>(UI_PARAM_FRAME_THRESHOLD, static_cast<int>(m_framePacing.m_frameThreshold));
+                m_menu.SetItemValue<int>(UI_PARAM_FRAME_PERIOD, static_cast<int>(m_framePacing.m_framePeriod));
+                m_menu.SetItemValue<int>(UI_PARAM_FRAME_BUFFERS, static_cast<int>(m_framePacing.m_frameBuffers));
+                m_menu.SetItemValue< float >(UI_PARAM_FRAME_OFFSET, m_framePacing.m_frameOffsetInMs);
+
+                m_frameEventsDirty = true;
+            }
+
+            m_menu.SetItemStatus(UI_PARAM_FRAME_RATE, UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_FRAME_THRESHOLD, UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_FRAME_PERIOD, m_autoPacing ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_FRAME_BUFFERS, m_autoPacing ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_FRAME_OFFSET, m_autoPacing ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+        }
+
+        if (m_gamePadButtons.x == GamePad::ButtonStateTracker::PRESSED)
+        {
+            m_autoFrameLoad = !m_autoFrameLoad;
+
+            // Store off manual settings for later restore
+            static FrameLoad manualFrameLoad = {};
+            if (m_autoFrameLoad)
+            {
+                manualFrameLoad = m_desiredFrameLoad;
+            }
+            else
+            {
+                m_desiredFrameLoad = manualFrameLoad;
+
+                m_menu.SetItemValue< float >(UI_PARAM_CPU_UPDATE_LOAD, static_cast<float>(m_desiredFrameLoad.m_cpuUpdateTimeInMs));
+                m_menu.SetItemValue< float >(UI_PARAM_CPU_RENDER_LOAD, static_cast<float>(m_desiredFrameLoad.m_cpuRenderTimeInMs));
+                m_menu.SetItemValue< float >(UI_PARAM_CPU_TO_GPU_LAG, static_cast<float>(m_desiredFrameLoad.m_cpuToGpuTimeInMs));
+                m_menu.SetItemValue< float >(UI_PARAM_GPU_GRAPHICS_LOAD, static_cast<float>(m_desiredFrameLoad.m_gpuGraphicsTimeInMs));
+                m_menu.SetItemValue< float >(UI_PARAM_GPU_COMPUTE_LOAD, static_cast<float>(m_desiredFrameLoad.m_gpuComputeTimeInMs));
+            }
+
+            m_menu.SetItemStatus(UI_PARAM_FRAME_LOAD_SEQUENCE, m_autoFrameLoad ? UIParam::STATUS_DEFAULT : UIParam::STATUS_AUTO);
+
+            m_menu.SetItemStatus(UI_PARAM_CPU_UPDATE_LOAD, m_autoFrameLoad ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_CPU_RENDER_LOAD, m_autoFrameLoad ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_CPU_TO_GPU_LAG, m_autoFrameLoad ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_GPU_GRAPHICS_LOAD, m_autoFrameLoad ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+            m_menu.SetItemStatus(UI_PARAM_GPU_COMPUTE_LOAD, m_autoFrameLoad ? UIParam::STATUS_AUTO : UIParam::STATUS_DEFAULT);
+        }
+
+        if (m_gamePadButtons.b == GamePad::ButtonStateTracker::PRESSED)
+        {
+            m_paused = !m_paused;
+        }
+
+        // Change zoom based on triggers
+        float zoom = m_graphZoom;
+        float zoomSpeed = 1.0f;
+        float zoomMax = 40.0f;
+        zoom *= (1.0f + 0.01f * zoomSpeed * pad.triggers.left);
+        zoom *= (1.0f - 0.01f * zoomSpeed * pad.triggers.right);
+        zoom = std::min(zoom, 1.0f);
+        zoom = std::max(zoom, 1.0f / zoomMax);
+        m_graphZoom = zoom;
+
+        // Change offset based on right thumbstick
+        float offset = m_graphOffset;
+        offset += 0.1f * zoomSpeed * m_graphZoom * pad.thumbSticks.rightX;
+        offset = std::min(offset, 0.0f);
+        offset = std::max(offset, -1.0f + m_graphZoom);
+        m_graphOffset = offset;
+
+        m_menu.Update(m_gamePadButtons);
+    }
+    else
+    {
+        m_gamePadButtons.Reset();
+    }
+
+    m_inputState.Update(elapsedTime, *m_gamePad);
+    m_uiManager.Update(elapsedTime, m_inputState);
+
+    // Set artificial processor loads
+    if (m_autoFrameLoad)
+    {
+        m_currentFrameLoadSequence = m_menu.GetItemValue<uint32_t>(UI_PARAM_FRAME_LOAD_SEQUENCE);
+
+        const auto& frameLoad = m_currentUpdateFrameBuffer.m_frameLoad;
+
+        m_menu.SetItemValue< float >(UI_PARAM_CPU_UPDATE_LOAD, static_cast<float>(frameLoad.m_cpuUpdateTimeInMs));
+        m_menu.SetItemValue< float >(UI_PARAM_CPU_RENDER_LOAD, static_cast<float>(frameLoad.m_cpuRenderTimeInMs));
+        m_menu.SetItemValue< float >(UI_PARAM_CPU_TO_GPU_LAG, static_cast<float>(frameLoad.m_cpuToGpuTimeInMs));
+        m_menu.SetItemValue< float >(UI_PARAM_GPU_GRAPHICS_LOAD, static_cast<float>(frameLoad.m_gpuGraphicsTimeInMs));
+        m_menu.SetItemValue< float >(UI_PARAM_GPU_COMPUTE_LOAD, static_cast<float>(frameLoad.m_gpuComputeTimeInMs));
+    }
+    else
+    {
+        auto getNonnegativeTimeInMs = [&](uint32_t item)
+        {
+            const auto valueInMs = std::max(0.0f, m_menu.GetItemValue<float>(item));
+            m_menu.SetItemValue<float>(item, valueInMs);
+            return valueInMs;
+        };
+
+        m_desiredFrameLoad.m_cpuUpdateTimeInMs = getNonnegativeTimeInMs(UI_PARAM_CPU_UPDATE_LOAD);
+        m_desiredFrameLoad.m_cpuRenderTimeInMs = getNonnegativeTimeInMs(UI_PARAM_CPU_RENDER_LOAD);
+        m_desiredFrameLoad.m_cpuToGpuTimeInMs = getNonnegativeTimeInMs(UI_PARAM_CPU_TO_GPU_LAG);
+        m_desiredFrameLoad.m_gpuGraphicsTimeInMs = getNonnegativeTimeInMs(UI_PARAM_GPU_GRAPHICS_LOAD);
+        m_desiredFrameLoad.m_gpuComputeTimeInMs = getNonnegativeTimeInMs(UI_PARAM_GPU_COMPUTE_LOAD);
+    }
+
+    if (m_autoPacing)
+    {
+        // Automatic pacing derives the period, buffering, and origin offset.
+        // The target rate and immediate threshold remain title choices.
+        m_framePacing.m_frameRateTarget = static_cast<FrameRate>(m_menu.GetItemValue<uint32_t>(UI_PARAM_FRAME_RATE));
+        m_framePacing.m_frameThreshold = static_cast<uint32_t>(m_menu.GetItemValue<int>(UI_PARAM_FRAME_THRESHOLD));
+        CalculateAutoPacing();
+        m_menu.SetItemValue<int>(UI_PARAM_FRAME_PERIOD, static_cast<int>(m_framePacing.m_framePeriod));
+        m_menu.SetItemValue<int>(UI_PARAM_FRAME_BUFFERS, static_cast<int>(m_framePacing.m_frameBuffers));
+        m_menu.SetItemValue< float >(UI_PARAM_FRAME_OFFSET, m_framePacing.m_frameOffsetInMs);
+
+        m_frameEventsDirty = true;
+    }
+    else
+    {
+        // Change frame pacing via the menu
+        auto frameRate = static_cast<FrameRate>(m_menu.GetItemValue< uint32_t >(UI_PARAM_FRAME_RATE));
+        auto frameRateChanged = (m_framePacing.m_frameRateTarget != frameRate);
+        m_framePacing.m_frameRateTarget = frameRate;
+
+        auto frameThreshold = static_cast<uint32_t>(m_menu.GetItemValue<int>(UI_PARAM_FRAME_THRESHOLD));
+        auto frameThresholdChanged = (m_framePacing.m_frameThreshold != frameThreshold);
+        m_framePacing.m_frameThreshold = frameThreshold;
+
+        auto framePeriod = static_cast<uint32_t>(m_menu.GetItemValue<int>(UI_PARAM_FRAME_PERIOD));
+        auto framePeriodChanged = (m_framePacing.m_framePeriod != framePeriod);
+        m_framePacing.m_framePeriod = framePeriod;
+
+        auto frameBuffers = static_cast<uint32_t>(m_menu.GetItemValue<int>(UI_PARAM_FRAME_BUFFERS));
+        auto frameBuffersChanged = (m_framePacing.m_frameBuffers != frameBuffers);
+        m_framePacing.m_frameBuffers = frameBuffers;
+
+        auto frameOffsetInMs = std::max(0.0f, m_menu.GetItemValue<float>(UI_PARAM_FRAME_OFFSET));
+        m_menu.SetItemValue<float>(UI_PARAM_FRAME_OFFSET, frameOffsetInMs);
+        auto frameOffsetInMsChanged = (m_framePacing.m_frameOffsetInMs != frameOffsetInMs);
+        m_framePacing.m_frameOffsetInMs = frameOffsetInMs;
+
+        if (frameRateChanged || framePeriodChanged || frameOffsetInMsChanged)
+        {
+            m_frameEventsDirty = true;
+        }
+
+        if (frameThresholdChanged)
+        {
+            // No action necessary here
+        }
+
+        if (frameBuffersChanged)
+        {
+            // No action necessary here
+        }
+    }
+}
+#pragma endregion
+
+#pragma region Frame Render
+// Draws the scene.
+void Sample::Render()
+{
+    while (!m_isExiting)
+    {
+        // Wait for Update thread to signal that a game state is available
+        {
+            PIXScopedEvent(PIX_COLOR_DEFAULT, L"Wait on Update");
+            auto result = WaitForSingleObject(m_eventUpdateDone, INFINITE);
+            if (WAIT_OBJECT_0 != result)
+            {
+                throw std::runtime_error("Expected thread to receive signal");
+            }
+        }
+
+        if (m_isExiting)
+        {
+            SetEvent(m_eventRenderReceived);
+            break;
+        }
+
+        RecordFrameStatistics();
+
+        // Statistics consume queues populated by the update thread. Release the
+        // producer only after the render thread has finished reading them.
+        if (!SetEvent(m_eventRenderReceived))
+        {
+            throw std::runtime_error("Expected event to get signaled");
+        }
+
+        AdvanceSwapChain();
+
+        static_assert(_countof(c_intervalColors) == c_maxBackBufferCount);
+        PIXBeginEvent(c_intervalColorsPacked[m_currentRenderFrameBuffer.m_frameBuffer], L"Render %d", m_currentRenderFrameBuffer.m_frame);
+
+        m_frameTokens.push(m_currentRenderFrameBuffer.m_token);
+        const auto& frameLoad = m_currentRenderFrameBuffer.m_frameLoad;
+
+        // Start timer for artificial CPU load
+        m_renderThreadTimeInMs = frameLoad.m_cpuToGpuTimeInMs;
+        m_startCpuRenderSignal = true;
+
+        // Record timestamp with frame token
+        TaggedCpuTimestamp startCpuRender;
+        startCpuRender.m_token = m_currentRenderFrameBuffer.m_token;
+        startCpuRender.m_frameBuffer = m_currentRenderFrameBuffer.m_frameBuffer;
+        if (!QueryPerformanceCounter(&startCpuRender.m_time))
+        {
+            throw std::runtime_error("QueryPerformanceCounter");
+        }
+        m_startCpuRender.push(startCpuRender);
+
+        // Wait for artificial CPU load
+        PIXBeginEvent(PIX_COLOR_DEFAULT, L"Artificial CPU to GPU lag");
+        while (!m_endCpuRenderSignal && !m_isExiting)
+        {
+            _mm_pause();
+        }
+        if (m_isExiting)
+        {
+            PIXEndEvent();
+            PIXEndEvent();
+            break;
+        }
+        m_endCpuRenderSignal = false;
+        PIXEndEvent();
+
+        // Start timer for artificial CPU load
+        m_renderThreadTimeInMs = std::max(0.0f, frameLoad.m_cpuRenderTimeInMs - frameLoad.m_cpuToGpuTimeInMs);
+        m_startCpuRenderSignal = true;
+
+        // Reset command list and allocator.
+        auto commandAllocatorGraphicsStartTimer = m_commandAllocatorGraphicsStartTimer[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+        auto commandListGraphicsStartTimer = m_commandListGraphicsStartTimer[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+        DX::ThrowIfFailed(commandAllocatorGraphicsStartTimer->Reset());
+        DX::ThrowIfFailed(commandListGraphicsStartTimer->Reset(commandAllocatorGraphicsStartTimer, nullptr));
+
+        auto commandAllocatorGraphics = m_commandAllocatorGraphics[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+        auto commandListGraphics = m_commandListGraphics[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+        DX::ThrowIfFailed(commandAllocatorGraphics->Reset());
+        DX::ThrowIfFailed(commandListGraphics->Reset(commandAllocatorGraphics, nullptr));
+
+        auto commandAllocatorCompute = m_commandAllocatorCompute[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+        auto commandListCompute = m_commandListCompute[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+        DX::ThrowIfFailed(commandAllocatorCompute->Reset());
+        DX::ThrowIfFailed(commandListCompute->Reset(commandAllocatorCompute, nullptr));
+
+        auto commandQueueGraphics = m_commandQueueGraphics.Get();
+
+        static_assert(_countof(c_intervalColors) == c_maxBackBufferCount);
+        PIXBeginEvent(commandListGraphicsStartTimer, c_intervalColorsPacked[m_currentRenderFrameBuffer.m_frameBuffer], L"Graphics work %d", m_currentRenderFrameBuffer.m_frame);
+
+        // Timestamp for GPU work
+        m_queryCurrentFrame = (m_queryCurrentFrame + 1U) % c_queryFrames;
+        auto queryIndex = m_queryCurrentFrame * c_queryCountPerFrame;
+        commandListGraphicsStartTimer->EndQuery(m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, queryIndex);
+        TaggedGpuTimestamp startGpuGraphics;
+        startGpuGraphics.m_token = m_currentRenderFrameBuffer.m_token;
+        startGpuGraphics.m_frameBuffer = m_currentRenderFrameBuffer.m_frameBuffer;
+        startGpuGraphics.m_index = queryIndex++;
+        m_startGpuGraphics.push(startGpuGraphics);
+
+        // Start timer for artificial GPU graphics load
+        BeginEnforceGpuTime(commandListGraphicsStartTimer, m_gpuTimeResourceGraphics.Get());
+
+        // Kick off the timer work immediately
+        DX::ThrowIfFailed(commandListGraphicsStartTimer->Close());
+        commandQueueGraphics->ExecuteCommandLists(1, CommandListCast(&commandListGraphicsStartTimer));
+
+        // Transition the render target into the correct state to allow for drawing into it.
+        auto backBuffer = m_renderTargets[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+        D3D12_RESOURCE_BARRIER barrierPresentToRenderTarget = CD3DX12_RESOURCE_BARRIER::Transition(backBuffer, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
+        commandListGraphics->ResourceBarrier(1, &barrierPresentToRenderTarget);
+
+        Clear();
+
+        RenderUI();
+
+        // Transition to UAV for write by async compute
+        D3D12_RESOURCE_BARRIER barrierRenderTargetToUnorderedAccess = CD3DX12_RESOURCE_BARRIER::Transition(backBuffer, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+        commandListGraphics->ResourceBarrier(1, &barrierRenderTargetToUnorderedAccess);
+
+        // Wait for artificial GPU load
+        EndEnforceGpuTime(commandListGraphics, m_gpuTimeResourceGraphics.Get(), frameLoad.m_gpuGraphicsTimeInMs);
+
+        // Timestamp for GPU work
+        commandListGraphics->EndQuery(m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, queryIndex);
+        TaggedGpuTimestamp stopGpuGraphics;
+        stopGpuGraphics.m_token = m_currentRenderFrameBuffer.m_token;
+        stopGpuGraphics.m_frameBuffer = m_currentRenderFrameBuffer.m_frameBuffer;
+        stopGpuGraphics.m_index = queryIndex++;
+        m_stopGpuGraphics.push(stopGpuGraphics);
+
+        // Graphics work for the frame ends here
+
+        PIXEndEvent(commandListGraphics);
+
+        DX::ThrowIfFailed(commandListGraphics->Close());
+
+        // The timer can overlap the preceding frame's compute work. Wait before
+        // the main graphics list starts using this frame's recycled back buffer.
+        commandQueueGraphics->Wait(m_fenceComputeToGraphics.Get(), m_fenceComputeToGraphicsValue);
+        commandQueueGraphics->ExecuteCommandLists(1, CommandListCast(&commandListGraphics));
+
+        // Signal that graphics is done, compute can start
+        commandQueueGraphics->Signal(m_fenceGraphicsToCompute.Get(), ++m_fenceGraphicsToComputeValue);
+
+        auto commandQueueCompute = m_commandQueueCompute.Get();
+
+        static_assert(_countof(c_intervalColors) == c_maxBackBufferCount);
+        PIXBeginEvent(commandListCompute, c_intervalColorsPacked[m_currentRenderFrameBuffer.m_frameBuffer], L"Compute work %d", m_currentRenderFrameBuffer.m_frame);
+
+        // Wait for graphics to be done before compute can start
+        commandQueueCompute->Wait(m_fenceGraphicsToCompute.Get(), m_fenceGraphicsToComputeValue);
+
+        // Timestamp for GPU work
+        commandListCompute->EndQuery(m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, queryIndex);
+        TaggedGpuTimestamp startGpuCompute;
+        startGpuCompute.m_token = m_currentRenderFrameBuffer.m_token;
+        startGpuCompute.m_frameBuffer = m_currentRenderFrameBuffer.m_frameBuffer;
+        startGpuCompute.m_index = queryIndex++;
+        m_startGpuCompute.push(startGpuCompute);
+
+        // Start timer for artificial GPU graphics load 
+        BeginEnforceGpuTime(commandListCompute, m_gpuTimeResourceCompute.Get());
+
+        // Transition to Present state for the PresentX call
+        D3D12_RESOURCE_BARRIER barrierUnorderedAccessToPresent = CD3DX12_RESOURCE_BARRIER::Transition(backBuffer, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_PRESENT);
+        commandListCompute->ResourceBarrier(1, &barrierUnorderedAccessToPresent);
+
+        // Wait for artificial GPU load
+        EndEnforceGpuTime(commandListCompute, m_gpuTimeResourceCompute.Get(), frameLoad.m_gpuComputeTimeInMs);
+
+        // Timestamp for GPU work
+        commandListCompute->EndQuery(m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, queryIndex);
+        TaggedGpuTimestamp stopGpuCompute;
+        stopGpuCompute.m_token = m_currentRenderFrameBuffer.m_token;
+        stopGpuCompute.m_frameBuffer = m_currentRenderFrameBuffer.m_frameBuffer;
+        stopGpuCompute.m_index = queryIndex++;
+        m_stopGpuCompute.push(stopGpuCompute);
+
+        assert(queryIndex == (m_queryCurrentFrame + 1U) * c_queryCountPerFrame);
+        commandListCompute->ResolveQueryData(m_queryHeap.Get(),
+            D3D12_QUERY_TYPE_TIMESTAMP,
+            m_queryCurrentFrame * c_queryCountPerFrame,
+            c_queryCountPerFrame,
+            m_queryBuffer.Get(),
+            m_queryCurrentFrame * c_queryCountPerFrame * sizeof(uint64_t));
+
+        PIXEndEvent(commandListCompute);
+
+        // Compute work for the frame ends here
+        DX::ThrowIfFailed(commandListCompute->Close());
+        commandQueueCompute->ExecuteCommandLists(1, CommandListCast(&commandListCompute));
+
+        // Signal that compute is done, graphics can start (2 frames from now)
+        commandQueueCompute->Signal(m_fenceComputeToGraphics.Get(), ++m_fenceComputeToGraphicsValue);
+
+        // Show the new frame.
+        EndFrame();
+        m_graphicsMemory->Commit(commandQueueGraphics);
+
+        // Wait for any remaining artificial CPU load after the real render,
+        // submission, presentation, and transient-memory work is complete.
+        PIXBeginEvent(PIX_COLOR_DEFAULT, L"Artificial CPU load");
+        while (!m_endCpuRenderSignal && !m_isExiting)
+        {
+            _mm_pause();
+        }
+        if (m_isExiting)
+        {
+            PIXEndEvent();
+            PIXEndEvent();
+            break;
+        }
+        m_endCpuRenderSignal = false;
+
+        TaggedCpuTimestamp stopCpuRender;
+        stopCpuRender.m_token = m_currentRenderFrameBuffer.m_token;
+        stopCpuRender.m_frameBuffer = m_currentRenderFrameBuffer.m_frameBuffer;
+        if (!QueryPerformanceCounter(&stopCpuRender.m_time))
+        {
+            throw std::runtime_error("QueryPerformanceCounter");
+        }
+        m_stopCpuRender.push(stopCpuRender);
+
+        PIXEndEvent();
+        PIXEndEvent();
+    }
+}
+
+void Sample::RenderUI()
+{
+    std::scoped_lock uiLock(m_uiMutex);
+
+    auto commandListGraphics = m_commandListGraphics[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+
+    ScopedPixEvent RenderUI(commandListGraphics, PIX_COLOR_DEFAULT, L"Render UI");
+
+    m_uiSpriteBatch->Begin(commandListGraphics);    // This remains active for the rest of the text UI
+
+    // Render predefined UI (background panels, etc.)
+    {
+        // Average the last few frames to see changes more easily
+        constexpr uint32_t numGhostFrames = 5;
+
+        auto updateMetric = [](Ring<float, numGhostFrames>& history, float value, const std::shared_ptr<UIStaticText>& text)
+        {
+            history.push_back(value);
+
+            float average = 0.0f;
+            for (auto sample : history)
+            {
+                average += sample;
+            }
+            average /= history.size();
+
+            std::ostringstream displayText;
+            displayText.precision(1);
+            displayText << std::fixed << average;
+            text->SetDisplayText(displayText.str());
+        };
+
+        static Ring<float, numGhostFrames> s_prevFrameRate;
+        static Ring<float, numGhostFrames> s_prevLatency;
+        static Ring<float, numGhostFrames> s_prevMargin;
+        updateMetric(s_prevFrameRate, m_frameRateMeasured, m_fpsText);
+        updateMetric(s_prevLatency, m_latencyMeasuredInMs, m_latencyText);
+        updateMetric(s_prevMargin, m_marginMeasuredInMs, m_marginText);
+
+        m_uiManager.Render();
+    }   
+
+    // Render tear indicator (lags by a few frames)
+    {
+        auto frameWidth = (m_outputSize.right - m_outputSize.left);
+        auto frameHeight = (m_outputSize.bottom - m_outputSize.top);
+
+        m_triEffect->Apply(commandListGraphics);
+        m_primBatch->Begin(commandListGraphics);
+
+        constexpr float indicatorWidthInPixels = 190.0f;
+        constexpr float indicatorHeightInPixels = 2.0f;
+        const float labelLineSpacing = m_smallFont->GetLineSpacing();
+        const float labelHeightInPixels = 2.0f * labelLineSpacing;
+
+        float indicatorWidth = 2.0f * indicatorWidthInPixels / frameWidth;
+        float indicatorHeight = 2.0f * indicatorHeightInPixels / frameHeight;
+        float tearLocation = std::clamp(m_tearLocation, 0.0f, 1.0f);
+        float tearIndicatorY = 2.0f * (1.0f - tearLocation) - 1.0f;
+        tearIndicatorY = std::clamp(tearIndicatorY, -1.0f + indicatorHeight / 2.0f, 1.0f - indicatorHeight / 2.0f);
+        Vector4 tearIndicatorColor(0.8588235294f, 0.2862745098f, 0.1098039215f, 1.0f);
+
+        Vector3 upperLeft(1.0f - indicatorWidth, tearIndicatorY + indicatorHeight / 2.0f, 0.0f);
+        Vector3 lowerLeft(1.0f - indicatorWidth, tearIndicatorY - indicatorHeight / 2.0f, 0.0f);
+        Vector3 lowerRight(1.0f, tearIndicatorY - indicatorHeight / 2.0f, 0.0f);
+        Vector3 upperRight(1.0f, tearIndicatorY + indicatorHeight / 2.0f, 0.0f);
+
+        VertexPositionColor qvul(upperLeft, tearIndicatorColor);
+        VertexPositionColor qvll(lowerLeft, tearIndicatorColor);
+        VertexPositionColor qvlr(lowerRight, tearIndicatorColor);
+        VertexPositionColor qvur(upperRight, tearIndicatorColor);
+
+        m_primBatch->DrawQuad(qvul, qvll, qvlr, qvur);
+
+        // Background for text
+        float backgroundHeight = 2.0f * labelHeightInPixels / frameHeight;
+        float labelTopInPixels = std::clamp(tearLocation * frameHeight, 0.0f, frameHeight - labelHeightInPixels);
+        float labelTop = 1.0f - 2.0f * labelTopInPixels / frameHeight;
+        float labelBottom = labelTop - backgroundHeight;
+        Vector4 backgroundColor(0.0980392156f, 0.0980392156f, 0.0980392156f, 0.95f);
+
+        qvul.position.x = (qvll.position.x += 2.0f / frameWidth);
+        qvul.position.y = qvur.position.y = labelTop;
+        qvll.position.y = qvlr.position.y = labelBottom;
+        qvul.color = qvur.color = qvll.color = qvlr.color = backgroundColor;
+
+        m_primBatch->DrawQuad(qvul, qvll, qvlr, qvur);
+
+        m_primBatch->End();
+
+        int indicatorWidthPixels = static_cast<int>(m_screenViewport.Width * indicatorWidth / 2.0f);
+        XMFLOAT2 textPos = XMFLOAT2(m_screenViewport.Width - indicatorWidthPixels + 10.0f, labelTopInPixels);
+
+        m_smallFont->DrawString(m_uiSpriteBatch.get(), L"Tear Indicator", textPos, tearIndicatorColor, 0.0f, { 0.0f, 0.0f }, 1.0f);
+
+        wchar_t tearPercentage[16] = {};
+        swprintf_s(tearPercentage, L"%.0f%%", tearLocation * 100.0f);
+        textPos.y += labelLineSpacing;
+        m_smallFont->DrawString(m_uiSpriteBatch.get(), tearPercentage, textPos, tearIndicatorColor, 0.0f, { 0.0f, 0.0f }, 1.0f);
+    }
+
+    // Render menu
+    {
+        // Set descriptor heaps
+        ID3D12DescriptorHeap* heaps[] = { m_srvPile->Heap(), m_commonStates->Heap() };
+        commandListGraphics->SetDescriptorHeaps(uint32_t(_countof(heaps)), heaps);
+
+        auto panelRect = m_menuPanel->GetMarginedRectInPixels();
+
+        m_menu.Render(m_uiSpriteBatch.get(), m_smallFont.get(), m_ctrlFont.get(), { (float)panelRect.x, (float)panelRect.y, });
+    }
+
+    m_uiSpriteBatch->End();
+
+    // Draw line graphs
+    {
+        for (uint32_t i = 0; i < _countof(m_lineGraph); ++i)
+        {
+            auto panelRect = m_lineGraphPanel[i]->GetMarginedRectInPixels();
+            D3D12_VIEWPORT panelViewport =
+            {
+                (float)panelRect.x,             // float TopLeftX;
+                (float)panelRect.y,             // float TopLeftY;
+                (float)panelRect.width,         // float Width;
+                (float)panelRect.height,        // float Height;
+                0.0f,                           // float MinDepth;
+                1.0f,                           // float MaxDepth;
+            };
+            m_lineGraph[i].Render(commandListGraphics, m_primBatch.get(), m_lineEffect.get(), m_uiSpriteBatch.get(), m_smallFont.get(), &m_screenViewport, &panelViewport);
+        }
+    }
+
+    // Draw interval graphs
+    {
+        for (uint32_t i = 0; i < _countof(m_intervalGraph); ++i)
+        {
+            auto panelRect = m_intervalGraphPanel[i]->GetMarginedRectInPixels();
+            D3D12_VIEWPORT panelViewport =
+            {
+                (float)panelRect.x,             // float TopLeftX;
+                (float)panelRect.y,             // float TopLeftY;
+                (float)panelRect.width,         // float Width;
+                (float)panelRect.height,        // float Height;
+                0.0f,                           // float MinDepth;
+                1.0f,                           // float MaxDepth;
+            };
+            m_intervalGraph[i].Render(commandListGraphics, m_primBatch.get(), m_triEffect.get(), m_uiSpriteBatch.get(), m_smallFont.get(), &m_screenViewport, &panelViewport);
+        }
+    }
+}
+
+// Queries the frame statistics used to visualize and automatically tune frame pacing.
+bool Sample::GetFrameStatistics(D3D12XBOX_FRAME_PIPELINE_TOKEN frameToken, FrameStatistics& stats)
+{
+    constexpr uint32_t expectedStatCount = 5;
+    D3D12XBOX_FRAME_STATISTICS rawStats[expectedStatCount];
+    D3D12XBOX_FRAME_STATISTICS_TYPE typeSet = D3D12XBOX_FRAME_STATISTICS_TYPE_FRAME_INTERVAL |
+        D3D12XBOX_FRAME_STATISTICS_TYPE_FRAME_EVENT |
+        D3D12XBOX_FRAME_STATISTICS_TYPE_RENDER |
+        D3D12XBOX_FRAME_STATISTICS_TYPE_PRESENT |
+        D3D12XBOX_FRAME_STATISTICS_TYPE_DISPLAY;
+    assert(__popcnt(typeSet) == expectedStatCount);
+
+    uint32_t statCount = expectedStatCount;
+    HRESULT hr = m_device->GetFrameStatisticsX(
+        frameToken,
+        typeSet,
+        &statCount,
+        rawStats);
+
+    if (hr == S_FALSE || statCount < expectedStatCount)
+    {
+        // Results not available yet
+        return false;
+    }
+
+    DX::ThrowIfFailed(hr);
+
+    assert(statCount == expectedStatCount);
+
+    // PresentX submits one composited display plane, so only plane 0 belongs to this sample.
+    for (auto& rawStat : rawStats)
+    {
+        switch (rawStat.Type)
+        {
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_FRAME_INTERVAL:
+            stats.interval = rawStat.Interval;
+            break;
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_FRAME_EVENT:
+            stats.origin = rawStat.Event;
+            break;
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_RENDER:
+            if (rawStat.Render.PlaneIndex == 0)
+                stats.render = rawStat.Render;
+            break;
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_PRESENT:
+            if (rawStat.Present.PlaneIndex == 0)
+                stats.present = rawStat.Present;
+            break;
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_DISPLAY:
+            if (rawStat.Display.PlaneIndex == 0)
+                stats.display = rawStat.Display;
+            break;
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_INPUT:
+#ifdef _GAMING_XBOX_SCARLETT
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_POWERSCALING:
+#endif
+        case D3D12XBOX_FRAME_STATISTICS_TYPE_NONE:
+        default:
+            assert(false);
+        }
+    }
+
+    return true;
+}
+
+// Keeps a record of the frame statistics for graphing purposes.
+// The automatic pacing policy consumes this history, while the graphs visualize the same data.
+void Sample::RecordFrameStatistics()
+{
+    std::scoped_lock statisticsLock(m_frameStatisticsMutex);
+
+    uint64_t totalFrameTime = 0;
+    uint32_t completedFrameIntervals = 0;
+    bool paused = m_paused;
+
+    // The render/update event handshake prevents the update thread from
+    // appending timestamps while this routine drains the shared queues.
+    // Check all unprocessed frames, stop if we find an unfinished one
+    while (m_frameTokens.size() > 0)
+    {
+        auto frameToken = m_frameTokens.front();
+
+        FrameStatistics stats{};
+
+        static auto firstToken = true;  // Driver doesn't provide statistics for the first presented frame
+        if (!firstToken && !GetFrameStatistics(frameToken, stats))
+        {
+            // Results not available yet
+            break;
+        }
+        m_frameTokens.pop();
+
+        // Since frame statistics were ready, timestamps must also be ready
+        auto startCpuUpdate = std::move(m_startCpuUpdate.front());
+        m_startCpuUpdate.pop();
+        assert(frameToken == startCpuUpdate.m_token);
+
+        auto stopCpuUpdate = std::move(m_stopCpuUpdate.front());
+        m_stopCpuUpdate.pop();
+        assert(frameToken == stopCpuUpdate.m_token);
+
+        auto startCpuRender = std::move(m_startCpuRender.front());
+        m_startCpuRender.pop();
+        assert(frameToken == startCpuRender.m_token);
+
+        auto stopCpuRender = std::move(m_stopCpuRender.front());
+        m_stopCpuRender.pop();
+        assert(frameToken == stopCpuRender.m_token);
+
+        auto startGpuGraphics = m_startGpuGraphics.front();
+        m_startGpuGraphics.pop();
+        assert(frameToken == startGpuGraphics.m_token);
+
+        auto stopGpuGraphics = m_stopGpuGraphics.front();
+        m_stopGpuGraphics.pop();
+        assert(frameToken == stopGpuGraphics.m_token);
+
+        auto startGpuCompute = m_startGpuCompute.front();
+        m_startGpuCompute.pop();
+        assert(frameToken == startGpuCompute.m_token);
+
+        auto stopGpuCompute = m_stopGpuCompute.front();
+        m_stopGpuCompute.pop();
+        assert(frameToken == stopGpuCompute.m_token);
+
+        if (firstToken)
+        {
+            firstToken = false;
+            break;
+        }
+
+        if (!m_frameStatistics.empty())
+        {
+            totalFrameTime += stats.display.FlipTime - m_frameStatistics.back().display.FlipTime;
+            ++completedFrameIntervals;
+        }
+
+        m_frameStatistics.push_back(stats);
+
+        for (uint32_t lineGraphIndex = 0; lineGraphIndex < _countof(m_lineGraph); ++lineGraphIndex)
+        {
+            m_lineGraph[lineGraphIndex].ZoomX(m_graphZoom, m_graphOffset);
+            if (!paused)
+            {
+                m_lineGraph[lineGraphIndex].Update(&m_frameStatistics.back());
+            }
+        }
+
+        FrameTimestamps frameTimestamps;
+        frameTimestamps.m_frameBuffer = startCpuUpdate.m_frameBuffer;
+        assert(frameTimestamps.m_frameBuffer == stopCpuUpdate.m_frameBuffer);
+        assert(frameTimestamps.m_frameBuffer == startCpuRender.m_frameBuffer);
+        assert(frameTimestamps.m_frameBuffer == stopCpuRender.m_frameBuffer);
+        assert(frameTimestamps.m_frameBuffer == startGpuGraphics.m_frameBuffer);
+        assert(frameTimestamps.m_frameBuffer == stopGpuGraphics.m_frameBuffer);
+        assert(frameTimestamps.m_frameBuffer == startGpuCompute.m_frameBuffer);
+        assert(frameTimestamps.m_frameBuffer == stopGpuCompute.m_frameBuffer);
+
+        frameTimestamps.m_flipTime = stats.display.FlipTime;
+
+        frameTimestamps.m_startCpuUpdate = startCpuUpdate.m_time;
+        frameTimestamps.m_stopCpuUpdate = stopCpuUpdate.m_time;
+        frameTimestamps.m_startCpuRender = startCpuRender.m_time;
+        frameTimestamps.m_stopCpuRender = stopCpuRender.m_time;
+
+        // Update calibration between CPU and GPU timestamps
+        DX::ThrowIfFailed(m_commandQueueGraphics->GetClockCalibration(&g_gpuAnchorTimestamp, &g_cpuAnchorTimestamp));
+
+        D3D12_RANGE readRange =
+        {
+            startGpuGraphics.m_index * sizeof(uint64_t),
+            (startGpuGraphics.m_index + c_queryCountPerFrame) * sizeof(uint64_t),
+        };
+        void* timestampData = nullptr;
+        m_queryBuffer->Map(0U, &readRange, &timestampData);
+
+        auto timestamps = reinterpret_cast<const uint64_t*>(timestampData) + startGpuGraphics.m_index;
+        frameTimestamps.m_startGpuGraphics = *timestamps++;
+        frameTimestamps.m_stopGpuGraphics = *timestamps++;
+        frameTimestamps.m_startGpuCompute = *timestamps++;
+        frameTimestamps.m_stopGpuCompute = *timestamps++;
+
+        m_queryBuffer->Unmap(0U, nullptr);
+
+        m_frameTimestamps.push_back(frameTimestamps);
+
+        for (uint32_t intervalGraphIndex = 0; intervalGraphIndex < _countof(m_intervalGraph); ++intervalGraphIndex)
+        {
+            m_intervalGraph[intervalGraphIndex].ZoomX(m_graphZoom, m_graphOffset);
+            if (!paused)
+            {
+                m_intervalGraph[intervalGraphIndex].Update(&m_frameTimestamps.back());
+            }
+        }
+    }
+
+    if (!paused && completedFrameIntervals > 0)
+    {
+        const auto& latestFrameStats = m_frameStatistics.back();
+        m_tearLocation = std::clamp(latestFrameStats.display.PercentScanned / 100.0f, 0.0f, 1.0f);
+        m_frameRateMeasured = static_cast<float>(
+            static_cast<double>(completedFrameIntervals) * g_cpuPerfFreq / totalFrameTime);
+
+        m_latencyMeasuredInMs = 1000.0f * static_cast<float>(
+            (latestFrameStats.present.GPUProcessTime - latestFrameStats.origin.SignalTime) / static_cast<double>(g_cpuPerfFreq));
+
+        auto frameOriginInMicroseconds = 1000.0 * 1000.0 * (latestFrameStats.origin.SignalTime / static_cast<double>(g_cpuPerfFreq));
+        auto frameBudgetInMicroseconds = latestFrameStats.interval.LengthInMicroseconds * latestFrameStats.interval.PeriodInIntervals
+            - latestFrameStats.origin.IntervalOffsetInMicroseconds;
+        auto frameDeadlineInMicroseconds = frameOriginInMicroseconds + frameBudgetInMicroseconds;
+        auto frameCompletionInMicroseconds = 1000.0 * 1000.0 * (latestFrameStats.present.GPUProcessTime / static_cast<double>(g_cpuPerfFreq));
+        m_marginMeasuredInMs = static_cast<float>((frameDeadlineInMicroseconds - frameCompletionInMicroseconds) / 1000.0);
+    }
+}
+
+// The algorithm to decide on frame pacing parameters automatically
+void Sample::CalculateAutoPacing()
+{
+    std::scoped_lock statisticsLock(m_frameStatisticsMutex);
+
+    // average the last N frame latencies
+    const auto desiredHistoryCount = 8U;
+    const auto minHistoryCount = 2U;
+    const auto maxFrameLatencyInMicroseconds = 100.0f * 1000.0f;
+    auto frameCount = 0U;
+    auto averageFrameLatencyInMicroseconds = 0.0f;
+    for (auto it = m_frameStatistics.crbegin(); it != m_frameStatistics.crend(); ++it)
+    {
+        if (frameCount == desiredHistoryCount)
+        {
+            break;
+        }
+        auto frameLatencyInMicroseconds = 1000.0f * 1000.0f * static_cast<float>(
+            (it->present.GPUProcessTime - it->origin.SignalTime) / static_cast<double>(g_cpuPerfFreq));
+        if (frameLatencyInMicroseconds > maxFrameLatencyInMicroseconds)
+        {
+            // We might have paused in the debugger or taken a PIX capture
+            continue;
+        }
+        averageFrameLatencyInMicroseconds += frameLatencyInMicroseconds;
+        ++frameCount;
+    }
+    if (frameCount < minHistoryCount)
+    {
+        // Not enough information
+        return;
+    }
+
+    averageFrameLatencyInMicroseconds /= frameCount;
+
+    // Use the historical average to calculate when the schedule the ORIGIN event.
+    // For safety, let's try to finish 1/2 frame interval early.
+    // Example:
+    //     - We are running at 60 fps, and average frame latency is 35.0 ms.
+    //     - We would like to finish 8.3 ms before the vblank.
+    //     - So we need to start 35.0 + 8.3 ms before a vblank, or 43.3 ms.
+    //     - That makes a period in intervals of 43.3 ms / 16.7 ms, rounded up to 3.
+    //     - And an offset of 3 * 16.7 ms - 43.3 ms = 6.8 ms.
+    uint32_t frameIntervalsInMicroseconds[] =
+    {
+        D3D12XBOX_FRAME_INTERVAL_120_HZ,
+        D3D12XBOX_FRAME_INTERVAL_60_HZ,
+        D3D12XBOX_FRAME_INTERVAL_40_HZ,
+        D3D12XBOX_FRAME_INTERVAL_30_HZ,
+    };
+    static_assert(_countof(c_frameRateNames) == _countof(frameIntervalsInMicroseconds), "Mismatch between enums");
+    auto frameIntervalInMicroseconds = frameIntervalsInMicroseconds[static_cast<uint32_t>(m_framePacing.m_frameRateTarget)];
+    constexpr uint32_t maxFramePeriod = c_maxBackBufferCount - 1U;
+    auto maxAllowedLatencyInMicroseconds = float(maxFramePeriod * frameIntervalInMicroseconds - 100U);
+    auto latencyBufferInMicroseconds = frameIntervalInMicroseconds / 2UL;   // leave half a frame of latency margin
+    auto paddedFrameLatencyInMicroseconds = averageFrameLatencyInMicroseconds + latencyBufferInMicroseconds;
+    paddedFrameLatencyInMicroseconds = std::min(paddedFrameLatencyInMicroseconds, maxAllowedLatencyInMicroseconds);
+    m_framePacing.m_framePeriod = static_cast<uint32_t>(paddedFrameLatencyInMicroseconds) / frameIntervalInMicroseconds + 1U;
+    m_framePacing.m_frameOffsetInMs = (m_framePacing.m_framePeriod * frameIntervalInMicroseconds - paddedFrameLatencyInMicroseconds) / 1000.0f;
+    m_framePacing.m_frameBuffers = m_framePacing.m_framePeriod + 1U;
+
+}
+
+// Helper method to clear the back buffers.
+void Sample::Clear()
+{
+    auto commandListGraphics = m_commandListGraphics[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+    PIXBeginEvent(commandListGraphics, PIX_COLOR_DEFAULT, L"Clear");
+
+    // Clear the views.
+    auto rtvDescriptor = GetRenderTargetView(m_currentRenderFrameBuffer.m_frameBuffer);
+
+    commandListGraphics->OMSetRenderTargets(1, &rtvDescriptor, FALSE, nullptr);
+    commandListGraphics->ClearRenderTargetView(rtvDescriptor, ATG::Colors::Background, 0, nullptr);
+
+    // Set the viewport and scissor rect.
+    commandListGraphics->RSSetViewports(1, &m_screenViewport);
+    commandListGraphics->RSSetScissorRects(1, &m_scissorRect);
+
+    PIXEndEvent(commandListGraphics);
+}
+
+// Start a timer to enforce a minimum of GPU busy time
+void Sample::BeginEnforceGpuTime(GraphicsCommandList* commandList, ID3D12Resource* bufTime)
+{
+    // Be sure to kick this off immediately to start the countdown
+    ScopedPixEvent Workload(commandList, 0, L"Get GPU start time");
+
+    commandList->SetComputeRootSignature(m_getStartTimeRS.Get());
+    commandList->SetComputeRootUnorderedAccessView(0, bufTime->GetGPUVirtualAddress());
+    commandList->SetPipelineState(m_getStartTimePSO.Get());
+
+    auto barrier = CD3DX12_RESOURCE_BARRIER::UAV(bufTime);
+    commandList->ResourceBarrier(1, &barrier);
+    commandList->Dispatch(1, 1, 1);
+    commandList->ResourceBarrier(1, &barrier);
+}
+
+// Wait on a timer to enforce a minimum of GPU busy time
+void Sample::EndEnforceGpuTime(GraphicsCommandList* commandList, ID3D12Resource* bufTime, float durationInMs)
+{
+    ScopedPixEvent Workload(commandList, 0, L"Artificial GPU load");
+
+    uint64_t clockRate = 0;
+    switch (m_deviceType)
+    {
+    case XSystemDeviceType::XboxOne:
+        clockRate = 853;
+        break;
+    case XSystemDeviceType::XboxOneS:
+        clockRate = 914;
+        break;
+    case XSystemDeviceType::XboxOneX:
+    case XSystemDeviceType::XboxOneXDevkit:
+        clockRate = 1172;
+        break;
+    case XSystemDeviceType::XboxScarlettLockhart:
+        clockRate = 1565;
+        break;
+    case XSystemDeviceType::XboxScarlettAnaconda:
+    case XSystemDeviceType::XboxScarlettDevkit:
+        clockRate = 1825;
+        break;
+    case XSystemDeviceType::Pc:
+    case XSystemDeviceType::Unknown:
+    default:
+        assert(false);
+    }
+
+    auto desiredFrameTimeInTicks = static_cast<uint64_t>(durationInMs * 1000.0f) * clockRate;
+
+    commandList->SetComputeRootSignature(m_gpuEnforceTimeRS.Get());
+    commandList->SetComputeRoot32BitConstants(0, 2, &desiredFrameTimeInTicks, 0);
+    commandList->SetComputeRootUnorderedAccessView(1, bufTime->GetGPUVirtualAddress());
+    commandList->SetPipelineState(m_gpuEnforceTimePSO.Get());
+
+    auto barrier = CD3DX12_RESOURCE_BARRIER::UAV(bufTime);
+    commandList->ResourceBarrier(1, &barrier);
+    commandList->Dispatch(1, 1, 1);
+    commandList->ResourceBarrier(1, &barrier);
+}
+
+#pragma endregion
+
+#pragma region Message Handlers
+// Message handlers
+void Sample::OnSuspending()
+{
+    m_commandQueueGraphics->SuspendX(0);
+    m_commandQueueCompute->SuspendX(0);
+}
+
+void Sample::OnResuming()
+{
+    m_commandQueueGraphics->ResumeX();
+    m_commandQueueCompute->ResumeX();
+
+    {
+        std::scoped_lock settingsLock(m_settingsMutex);
+        RegisterFrameEvents();
+        m_frameEventsDirty = false;
+    }
+    m_timer.ResetElapsedTime();
+    m_gamePadButtons.Reset();
+    m_inputState.Reset();
+}
+#pragma endregion
+
+#pragma region Direct3D Resources
+// These are the resources that depend on the device.
+void Sample::CreateDeviceDependentResources()
+{
+    // Create the DX12 API device object.
+    D3D12XBOX_CREATE_DEVICE_PARAMETERS params = {};
+    params.Version = D3D12_SDK_VERSION;
+
+#if defined(_DEBUG)
+    // Enable the debug layer.
+    params.ProcessDebugFlags = D3D12_PROCESS_DEBUG_FLAG_DEBUG_LAYER_ENABLED;
+#elif defined(PROFILE)
+    // Enable the instrumented driver.
+    params.ProcessDebugFlags = D3D12XBOX_PROCESS_DEBUG_FLAG_INSTRUMENTED;
+#endif
+
+    params.GraphicsCommandQueueRingSizeBytes = static_cast<uint32_t>(D3D12XBOX_DEFAULT_SIZE_BYTES);
+    params.GraphicsScratchMemorySizeBytes = static_cast<uint32_t>(D3D12XBOX_DEFAULT_SIZE_BYTES);
+    params.ComputeScratchMemorySizeBytes = static_cast<uint32_t>(D3D12XBOX_DEFAULT_SIZE_BYTES);
+#ifdef _GAMING_XBOX_SCARLETT
+    params.CreateDeviceFlags = D3D12XBOX_CREATE_DEVICE_FLAG_NONE;
+#endif
+
+    HRESULT hr = D3D12XboxCreateDevice(
+        nullptr,
+        &params,
+        IID_GRAPHICS_PPV_ARGS(m_device.ReleaseAndGetAddressOf()));
+#ifdef _DEBUG
+    if (hr == D3D12_ERROR_DRIVER_VERSION_MISMATCH)
+    {
+#ifdef _GAMING_XBOX_SCARLETT
+        OutputDebugStringA("ERROR: Running a d3d12_xs.lib (Xbox Series X|S) linked binary on an Xbox One is not supported\n");
+#else
+        OutputDebugStringA("ERROR: Running a d3d12_x.lib (Xbox One) linked binary on a Xbox Series X|S in 'Scarlett' mode is not supported\n");
+#endif
+    }
+#endif
+    DX::ThrowIfFailed(hr);
+    m_device->SetName(L"FramePacing device");
+
+    auto device = m_device.Get();
+
+    // Create the command queue.
+    {
+        D3D12_COMMAND_QUEUE_DESC queueDesc = {};
+        queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
+        queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+
+        DX::ThrowIfFailed(device->CreateCommandQueue(&queueDesc, IID_GRAPHICS_PPV_ARGS(m_commandQueueGraphics.ReleaseAndGetAddressOf())));
+
+        m_commandQueueGraphics->SetName(L"Command queue graphics");
+    }
+    {
+        D3D12XBOX_COMMAND_QUEUE_DESC queueDesc = {};
+        queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
+        queueDesc.Type = D3D12_COMMAND_LIST_TYPE_COMPUTE;
+        queueDesc.EngineOrPipeIndex = 0U;
+        queueDesc.QueueIndex = 0U;
+
+        DX::ThrowIfFailed(device->CreateCommandQueueX(&queueDesc, IID_GRAPHICS_PPV_ARGS(m_commandQueueCompute.ReleaseAndGetAddressOf())));
+
+        m_commandQueueCompute->SetName(L"Command queue compute");
+    }
+
+    auto commandQueueGraphics = m_commandQueueGraphics.Get();
+
+    // Create descriptor heaps for render target views and depth stencil views.
+    D3D12_DESCRIPTOR_HEAP_DESC rtvDescriptorHeapDesc = {};
+    rtvDescriptorHeapDesc.NumDescriptors = c_maxBackBufferCount;
+    rtvDescriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+
+    DX::ThrowIfFailed(device->CreateDescriptorHeap(&rtvDescriptorHeapDesc, IID_GRAPHICS_PPV_ARGS(m_rtvDescriptorHeap.ReleaseAndGetAddressOf())));
+
+    m_rtvDescriptorHeap->SetName(L"Render target descriptor heap");
+
+    m_rtvDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+
+    // Create a command allocator for each back buffer that will be rendered to.
+    for (uint32_t n = 0; n < c_maxBackBufferCount; n++)
+    {
+        wchar_t name[256] = {};
+
+        // Create a command list for recording graphics commands.
+        DX::ThrowIfFailed(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_GRAPHICS_PPV_ARGS(m_commandAllocatorGraphics[n].ReleaseAndGetAddressOf())));
+
+        swprintf_s(name, L"Command allocator graphics %u", n);
+        m_commandAllocatorGraphics[n]->SetName(name);
+
+        DX::ThrowIfFailed(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_commandAllocatorGraphics[n].Get(), nullptr, IID_GRAPHICS_PPV_ARGS(m_commandListGraphics[n].ReleaseAndGetAddressOf())));
+        DX::ThrowIfFailed(m_commandListGraphics[n]->Close());
+
+        swprintf_s(name, L"Command list graphics %u", n);
+        m_commandListGraphics[n]->SetName(name);
+
+        // Create a separate command list for immediate kickoff of timers.
+        DX::ThrowIfFailed(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_GRAPHICS_PPV_ARGS(m_commandAllocatorGraphicsStartTimer[n].ReleaseAndGetAddressOf())));
+
+        swprintf_s(name, L"Command allocator graphics start timer %u", n);
+        m_commandAllocatorGraphicsStartTimer[n]->SetName(name);
+
+
+        DX::ThrowIfFailed(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_commandAllocatorGraphicsStartTimer[n].Get(), nullptr, IID_GRAPHICS_PPV_ARGS(m_commandListGraphicsStartTimer[n].ReleaseAndGetAddressOf())));
+        DX::ThrowIfFailed(m_commandListGraphicsStartTimer[n]->Close());
+
+        swprintf_s(name, L"Command list graphics start timer %u", n);
+        m_commandListGraphicsStartTimer[n]->SetName(name);
+    }
+    for (uint32_t n = 0; n < c_maxBackBufferCount; n++)
+    {
+        DX::ThrowIfFailed(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COMPUTE, IID_GRAPHICS_PPV_ARGS(m_commandAllocatorCompute[n].ReleaseAndGetAddressOf())));
+
+        wchar_t name[256] = {};
+        swprintf_s(name, L"Command allocator compute %u", n);
+        m_commandAllocatorCompute[n]->SetName(name);
+
+        // Create a command list for recording compute commands.
+        DX::ThrowIfFailed(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COMPUTE, m_commandAllocatorCompute[n].Get(), nullptr, IID_GRAPHICS_PPV_ARGS(m_commandListCompute[n].ReleaseAndGetAddressOf())));
+        DX::ThrowIfFailed(m_commandListCompute[n]->Close());
+
+        swprintf_s(name, L"Command compute list %u", n);
+        m_commandListCompute[n]->SetName(name);
+    }
+
+    // Create a fence for tracking GPU execution progress.
+    DX::ThrowIfFailed(device->CreateFence(m_fenceValue, D3D12_FENCE_FLAG_NONE, IID_GRAPHICS_PPV_ARGS(m_fence.ReleaseAndGetAddressOf())));
+    m_fenceValue++;
+
+    m_fence->SetName(L"Queue drain fence");
+
+    m_fenceEvent.Attach(CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE));
+    if (!m_fenceEvent.IsValid())
+    {
+        throw std::system_error(std::error_code(static_cast<int>(GetLastError()), std::system_category()), "CreateEventEx");
+    }
+
+    // By default, validation may wait on preceding GPU work at ExecuteCommandLists.
+    // Those waits distort frame timings, which defeats some of the features of the sample.
+    // But it's worth leaving this flag enabled in typical validated builds of your title.
+    auto flags = device->GetDebugFlagsX();
+    flags |= D3D12XBOX_DEBUG_FLAG_ENABLE_OUT_OF_ORDER_CMD_LIST_VALIDATION;
+    device->SetDebugFlagsX(flags);
+
+    m_graphicsMemory = std::make_unique<GraphicsMemory>(device);
+
+    // State objects
+    m_commonStates = std::make_unique<DirectX::CommonStates>(device);
+
+    // Create heap
+    m_srvPile = std::make_unique<DescriptorPile>(device,
+        D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
+        D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
+        128,
+        SRVDescriptorHeapIndex::SRV_Count);
+
+    // Set up fences to synchronize between graphics and compute work
+    m_fenceGraphicsToComputeValue = 0ULL;
+    DX::ThrowIfFailed(device->CreateFence(m_fenceGraphicsToComputeValue, D3D12_FENCE_FLAG_NONE, IID_GRAPHICS_PPV_ARGS(m_fenceGraphicsToCompute.ReleaseAndGetAddressOf())));
+    m_fenceGraphicsToCompute->SetName(L"Fence graphics to compute");
+
+    m_fenceComputeToGraphicsValue = 0ULL;
+    DX::ThrowIfFailed(device->CreateFence(m_fenceComputeToGraphicsValue, D3D12_FENCE_FLAG_NONE, IID_GRAPHICS_PPV_ARGS(m_fenceComputeToGraphics.ReleaseAndGetAddressOf())));
+    m_fenceComputeToGraphics->SetName(L"Fence compute to graphics");
+
+    auto styleRenderer = std::make_unique<UIStyleRendererD3D>(*this, m_outputSize.right, m_outputSize.bottom);
+    m_uiManager.GetStyleManager().InitializeStyleRenderer(std::move(styleRenderer));
+
+    {
+        ResourceUploadBatch resourceUpload(device);
+        resourceUpload.Begin();
+
+        auto backBufferRts = RenderTargetState(m_backBufferFormat, DXGI_FORMAT_UNKNOWN);
+        auto spritePSD = SpriteBatchPipelineStateDescription(backBufferRts, &CommonStates::AlphaBlend);
+        m_uiSpriteBatch = std::make_unique<SpriteBatch>(device, resourceUpload, spritePSD);
+
+        auto finished = resourceUpload.End(commandQueueGraphics);
+        finished.wait();
+
+        m_primBatch = std::make_unique<PrimitiveBatch<VertexPositionColor>>(device);
+
+        EffectPipelineStateDescription effectPSD(
+            &VertexPositionColor::InputLayout,
+            CommonStates::Opaque,
+            CommonStates::DepthDefault,
+            CommonStates::CullNone,
+            backBufferRts);
+        m_triEffect = std::make_unique<BasicEffect>(device, EffectFlags::VertexColor, effectPSD);
+
+        effectPSD.primitiveTopology = D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE;
+        m_lineEffect = std::make_unique<BasicEffect>(device, EffectFlags::VertexColor, effectPSD);
+    }
+
+    // Begin uploading texture resources
+    {
+        ResourceUploadBatch resourceUpload(device);
+        resourceUpload.Begin();
+
+        m_smallFont = std::make_unique<SpriteFont>(device, resourceUpload,
+            L"Assets/Fonts/SegoeUI_18.spritefont",
+            m_srvPile->GetCpuHandle(SRVDescriptorHeapIndex::SRV_Font),
+            m_srvPile->GetGpuHandle(SRVDescriptorHeapIndex::SRV_Font));
+
+        m_ctrlFont = std::make_unique<SpriteFont>(device, resourceUpload,
+            L"Assets/Fonts/XboxOneControllerLegendSmall.spritefont",
+            m_srvPile->GetCpuHandle(SRVDescriptorHeapIndex::SRV_CtrlFont),
+            m_srvPile->GetGpuHandle(SRVDescriptorHeapIndex::SRV_CtrlFont));
+
+        auto finished = resourceUpload.End(commandQueueGraphics);
+        finished.wait();
+    }
+
+    // Timestamp queries
+    {
+        DX::ThrowIfFailed(m_commandQueueGraphics->GetTimestampFrequency(&g_gpuPerfFreq));
+
+        // Need enough for 4 timestamps per frame and as many frames as could be in flight
+        D3D12_QUERY_HEAP_DESC queryHeapDesc =
+        {
+            D3D12_QUERY_HEAP_TYPE_TIMESTAMP,        // D3D12_QUERY_HEAP_TYPE Type;
+            c_queryCountPerFrame * c_queryFrames,           // UINT Count;
+                                                    // UINT NodeMask;
+        };
+        DX::ThrowIfFailed(m_device->CreateQueryHeap(&queryHeapDesc,
+            IID_GRAPHICS_PPV_ARGS(m_queryHeap.GetAddressOf())));
+
+        D3D12_RESOURCE_DESC queryBufferDesc = CD3DX12_RESOURCE_DESC::Buffer(queryHeapDesc.Count * sizeof(uint64_t));
+        const D3D12_HEAP_PROPERTIES defaultHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
+        DX::ThrowIfFailed(
+            device->CreateCommittedResource(
+                &defaultHeapProperties,
+                D3D12_HEAP_FLAG_NONE,
+                &queryBufferDesc,
+                D3D12_RESOURCE_STATE_GENERIC_READ,
+                nullptr,
+                IID_GRAPHICS_PPV_ARGS(m_queryBuffer.ReleaseAndGetAddressOf())));
+        m_queryBuffer->SetName(L"Query Buffer");
+    }
+}
+
+// Allocate all memory resources that change on a window SizeChanged event.
+void Sample::CreateWindowSizeDependentResources()
+{
+    if (!m_window)
+    {
+        throw std::logic_error("Call SetWindow with a valid Win32 window handle");
+    }
+
+    // Wait until all previous GPU work is complete.
+    WaitForGpu();
+
+    // Ensure we present a blank screen before cleaning up resources.
+    DX::ThrowIfFailed(m_commandQueueGraphics->PresentX(0, nullptr, nullptr));
+    DX::ThrowIfFailed(m_commandQueueCompute->PresentX(0, nullptr, nullptr));
+
+    // Release resources that are tied to the swap chain and update fence values.
+    for (uint32_t n = 0; n < c_maxBackBufferCount; n++)
+    {
+        m_renderTargets[n].Reset();
+    }
+
+    // Determine the render target size in pixels.
+    const uint32_t backBufferWidth = std::max<uint32_t>(static_cast<uint32_t>(m_outputSize.right - m_outputSize.left), 1u);
+    const uint32_t backBufferHeight = std::max<uint32_t>(static_cast<uint32_t>(m_outputSize.bottom - m_outputSize.top), 1u);
+
+    // Obtain the back buffers for this window which will be the final render targets
+    // and create render target views for each of them.
+    CD3DX12_HEAP_PROPERTIES swapChainHeapProperties(D3D12_HEAP_TYPE_DEFAULT);
+
+    D3D12_RESOURCE_DESC swapChainBufferDesc = CD3DX12_RESOURCE_DESC::Tex2D(
+        m_backBufferFormat,
+        backBufferWidth,
+        backBufferHeight,
+        1, // This resource has only one texture.
+        1  // Use a single mipmap level.
+    );
+    swapChainBufferDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+
+    D3D12_CLEAR_VALUE swapChainOptimizedClearValue = {};
+    swapChainOptimizedClearValue.Format = m_backBufferFormat;
+
+    for (uint32_t n = 0; n < c_maxBackBufferCount; n++)
+    {
+        DX::ThrowIfFailed(m_device->CreateCommittedResource(
+            &swapChainHeapProperties,
+            D3D12_HEAP_FLAG_ALLOW_DISPLAY,
+            &swapChainBufferDesc,
+            D3D12_RESOURCE_STATE_PRESENT,
+            &swapChainOptimizedClearValue,
+            IID_GRAPHICS_PPV_ARGS(m_renderTargets[n].GetAddressOf())));
+
+        wchar_t name[25] = {};
+        swprintf_s(name, L"Render target %u", n);
+        m_renderTargets[n]->SetName(name);
+
+        D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = {};
+        rtvDesc.Format = m_backBufferFormat;
+        rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
+
+        CD3DX12_CPU_DESCRIPTOR_HANDLE rtvDescriptor(
+            m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart(),
+            static_cast<INT>(n), m_rtvDescriptorSize);
+        m_device->CreateRenderTargetView(m_renderTargets[n].Get(), &rtvDesc, rtvDescriptor);
+    }
+
+    // Set the 3D rendering viewport and scissor rectangle to target the entire window.
+    m_screenViewport.TopLeftX = m_screenViewport.TopLeftY = 0.f;
+    m_screenViewport.Width = static_cast<float>(backBufferWidth);
+    m_screenViewport.Height = static_cast<float>(backBufferHeight);
+    m_screenViewport.MinDepth = D3D12_MIN_DEPTH;
+    m_screenViewport.MaxDepth = D3D12_MAX_DEPTH;
+
+    m_scissorRect.left = m_scissorRect.top = 0;
+    m_scissorRect.right = static_cast<LONG>(backBufferWidth);
+    m_scissorRect.bottom = static_cast<LONG>(backBufferHeight);
+
+    m_uiManager.SetWindowSize(m_outputSize.right, m_outputSize.bottom);
+
+    // Fixed viewport for UI rendering
+    D3D12_VIEWPORT viewport = {};
+    viewport.TopLeftX = 0.0f;
+    viewport.TopLeftY = 0.0f;
+    viewport.Width = static_cast<float>(m_outputSize.right);
+    viewport.Height = static_cast<float>(m_outputSize.bottom);
+    viewport.MinDepth = 0.0f;
+    viewport.MaxDepth = 1.0f;
+
+    // Set UI sprite viewport
+    m_uiSpriteBatch->SetViewport(viewport);
+}
+#pragma endregion
+
+#pragma region Frame Scheduling
+// Set frame interval and register for frame events
+void Sample::RegisterFrameEvents()
+{
+    auto device = m_device.Get();
+
+    uint32_t frameIntervalsInMicroseconds[] =
+    {
+        D3D12XBOX_FRAME_INTERVAL_120_HZ,
+        D3D12XBOX_FRAME_INTERVAL_60_HZ,
+        D3D12XBOX_FRAME_INTERVAL_40_HZ,
+        D3D12XBOX_FRAME_INTERVAL_30_HZ,
+    };
+    static_assert(_countof(c_frameRateNames) == _countof(frameIntervalsInMicroseconds), "Mismatch between enums");
+    auto frameIntervalInMicroseconds = frameIntervalsInMicroseconds[static_cast<uint32_t>(m_framePacing.m_frameRateTarget)];
+    auto periodInIntervals = m_framePacing.m_framePeriod;
+    auto intervalOffsetInMicroseconds = static_cast<uint32_t>(1000.0f * m_framePacing.m_frameOffsetInMs);
+
+    // Set frame interval and register for frame events
+    DX::ThrowIfFailed(device->SetFrameIntervalX(
+        nullptr,
+        frameIntervalInMicroseconds,
+        periodInIntervals,
+        D3D12XBOX_FRAME_INTERVAL_FLAG_NONE));
+
+    DX::ThrowIfFailed(device->ScheduleFrameEventX(
+        D3D12XBOX_FRAME_EVENT_ORIGIN,
+        intervalOffsetInMicroseconds,
+        nullptr,
+        D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAG_NONE));
+}
+
+// Prepare to render the next frame.
+void Sample::AdvanceSwapChain()
+{
+    // Update the back buffer index.
+    std::scoped_lock swapChainLock(m_swapChainMutex);
+    m_currentRenderFrameBuffer = m_swapChain.front();
+    m_swapChain.pop();
+}
+
+// Prepare the command list and render target for rendering.
+void Sample::BeginFrame()
+{
+    auto device = m_device.Get();
+    FramePacing framePacing{};
+    {
+        std::scoped_lock settingsLock(m_settingsMutex);
+        if (m_frameEventsDirty)
+        {
+            RegisterFrameEvents();
+            m_frameEventsDirty = false;
+        }
+        framePacing = m_framePacing;
+    }
+    const auto frameLoad = GetFrameLoad(m_nextFrameIndex);
+
+    // Wait until frame start is signaled
+    D3D12XBOX_FRAME_PIPELINE_TOKEN framePipelineToken = D3D12XBOX_FRAME_PIPELINE_TOKEN_NULL;
+    DX::ThrowIfFailed(device->WaitFrameEventX(D3D12XBOX_FRAME_EVENT_ORIGIN, INFINITE, nullptr, D3D12XBOX_WAIT_FRAME_EVENT_FLAG_NONE, &framePipelineToken));
+
+    {
+        std::scoped_lock swapChainLock(m_swapChainMutex);
+        m_currentUpdateFrameBuffer.m_frameBuffer = m_nextFrameBufferIndex;
+        m_currentUpdateFrameBuffer.m_token = framePipelineToken;
+        m_currentUpdateFrameBuffer.m_frame = m_nextFrameIndex;
+        m_currentUpdateFrameBuffer.m_frameLoad = frameLoad;
+        m_currentUpdateFrameBuffer.m_framePacing = framePacing;
+        m_swapChain.push(m_currentUpdateFrameBuffer);
+    }
+
+    m_nextFrameBufferIndex = (m_nextFrameBufferIndex + 1) % framePacing.m_frameBuffers;
+    ++m_nextFrameIndex;
+}
+
+// Present the contents of the swap chain to the screen.
+void Sample::EndFrame()
+{
+    PIXBeginEvent(PIX_COLOR_DEFAULT, L"Present");
+    D3D12XBOX_PRESENT_PARAMETERS params = {};
+
+    // A late frame is displayed immediately only while scanout is within this
+    // percentage of the screen. Zero disables limited tearing; 100 permits a
+    // late flip anywhere in the scan.
+    params.ImmediateThresholdPercent = static_cast<float>(m_currentRenderFrameBuffer.m_framePacing.m_frameThreshold);
+
+    // Present the backbuffer using the PresentX API.
+    D3D12XBOX_PRESENT_PLANE_PARAMETERS planeParameters = {};
+    planeParameters.Token = m_currentRenderFrameBuffer.m_token;
+    planeParameters.ResourceCount = 1;
+    ID3D12Resource* backBuffer = m_renderTargets[m_currentRenderFrameBuffer.m_frameBuffer].Get();
+    planeParameters.ppResources = &backBuffer;
+
+    // Present from the Compute queue!
+    auto commandQueueCompute = m_commandQueueCompute.Get();
+    DX::ThrowIfFailed(commandQueueCompute->PresentX(1, &planeParameters, &params));
+
+    PIXEndEvent();
+}
+
+// Wait for pending GPU work to complete.
+void Sample::WaitForGpu() noexcept
+{
+    if (!m_fence || !m_fenceEvent.IsValid())
+    {
+        return;
+    }
+
+    // Drain the queues serially so shared fence values remain monotonic.
+    ID3D12CommandQueue* queues[] = { m_commandQueueGraphics.Get(), m_commandQueueCompute.Get() };
+    for (auto queue : queues)
+    {
+        if (queue && SUCCEEDED(queue->Signal(m_fence.Get(), m_fenceValue)))
+        {
+            if (SUCCEEDED(m_fence->SetEventOnCompletion(m_fenceValue, m_fenceEvent.Get())))
+            {
+                WaitForSingleObjectEx(m_fenceEvent.Get(), INFINITE, FALSE);
+                m_fenceValue++;
+            }
+        }
+    }
+}
+#pragma endregion
diff --git a/Samples/Graphics/FramePacing/FramePacing.h b/Samples/Graphics/FramePacing/FramePacing.h
new file mode 100644
index 00000000..6c7ba8e3
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FramePacing.h
@@ -0,0 +1,296 @@
+//--------------------------------------------------------------------------------------
+// FramePacing.h
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "CommonStates.h"
+#include "Menu.h"
+#include "StepTimer.h"
+#include "Graph.h"
+#include "UITK.h"
+#include "Utility.h"
+
+
+#ifdef _GAMING_XBOX_SCARLETT
+using Device = ID3D12Device8;
+using GraphicsCommandList = ID3D12GraphicsCommandList5;
+#else
+using Device = ID3D12Device2;
+using GraphicsCommandList = ID3D12GraphicsCommandList;
+#endif
+
+class Sample final : public ATG::UITK::D3DResourcesProvider
+{
+public:
+
+    Sample() noexcept(false);
+    ~Sample();
+
+    Sample(Sample&&) = delete;
+    Sample& operator= (Sample&&) = delete;
+
+    Sample(Sample const&) = delete;
+    Sample& operator= (Sample const&) = delete;
+
+    // Initialization and management
+    void Initialize(HWND window);
+
+    // Basic render loop
+    void Tick();
+
+    // Messages
+    void OnSuspending();
+    void OnResuming();
+    void OnConstrained() {}
+    void OnUnConstrained() {}
+
+    // Properties
+    bool RequestHDRMode() const noexcept { return false; }
+
+    // ATG::UITK::D3DResourcesProvider
+    ID3D12Device* GetD3DDevice() override { return m_device.Get(); }
+    ID3D12CommandQueue* GetCommandQueue() const override { return m_commandQueueGraphics.Get(); }
+    ID3D12GraphicsCommandList* GetCommandList() const override { return m_commandListGraphics[m_currentRenderFrameBuffer.m_frameBuffer].Get(); }
+
+private:
+    void CreateThreads();
+    void CreateWorkers();
+    void CreateGraphs();
+    void CreateFrameLoadSequences();
+
+    void InitializeUI();
+
+    void Update(DX::StepTimer const& timer);
+    void UpdateUI();
+    void Render();
+    void RenderUI();
+
+    void Clear();
+
+    void CreateDeviceDependentResources();
+    void CreateWindowSizeDependentResources();
+
+    void EnforceCpuUpdateTime();
+    void EnforceCpuRenderTime();
+
+    void BeginEnforceGpuTime(GraphicsCommandList* commandList, ID3D12Resource* bufTime);
+    void EndEnforceGpuTime(GraphicsCommandList* commandList, ID3D12Resource* bufTime, float durationInMs);
+
+    void RegisterFrameEvents();
+    void AdvanceSwapChain();
+    void BeginFrame();
+    void EndFrame();
+    void WaitForGpu() noexcept;
+
+    bool GetFrameStatistics(D3D12XBOX_FRAME_PIPELINE_TOKEN frameToken, FramePacingUtils::FrameStatistics& stats);
+    void RecordFrameStatistics();
+
+    void CalculateAutoPacing();
+
+    CD3DX12_CPU_DESCRIPTOR_HANDLE GetRenderTargetView(uint32_t index) const noexcept
+    {
+        return CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), static_cast<INT>(index), m_rtvDescriptorSize);
+    }
+
+    static constexpr uint32_t c_maxBackBufferCount = 4;
+
+    // Direct3D objects.
+    Microsoft::WRL::ComPtr<Device>                  m_device;
+    Microsoft::WRL::ComPtr<GraphicsCommandList>     m_commandListGraphics[c_maxBackBufferCount];
+    Microsoft::WRL::ComPtr<GraphicsCommandList>     m_commandListGraphicsStartTimer[c_maxBackBufferCount];
+    Microsoft::WRL::ComPtr<ID3D12CommandQueue>      m_commandQueueGraphics;
+    Microsoft::WRL::ComPtr<ID3D12CommandAllocator>  m_commandAllocatorGraphics[c_maxBackBufferCount];
+    Microsoft::WRL::ComPtr<ID3D12CommandAllocator>  m_commandAllocatorGraphicsStartTimer[c_maxBackBufferCount];
+
+    Microsoft::WRL::ComPtr<GraphicsCommandList>     m_commandListCompute[c_maxBackBufferCount];
+    Microsoft::WRL::ComPtr<ID3D12CommandQueue>      m_commandQueueCompute;
+    Microsoft::WRL::ComPtr<ID3D12CommandAllocator>  m_commandAllocatorCompute[c_maxBackBufferCount];
+
+    // Swap chain objects.
+    Microsoft::WRL::ComPtr<ID3D12Resource>          m_renderTargets[c_maxBackBufferCount];
+
+    // Presentation fence objects.
+    Microsoft::WRL::ComPtr<ID3D12Fence>             m_fence;
+    uint64_t                                        m_fenceValue;
+    Microsoft::WRL::Wrappers::Event                 m_fenceEvent;
+
+    // Direct3D rendering objects.
+    Microsoft::WRL::ComPtr<ID3D12DescriptorHeap>    m_rtvDescriptorHeap;
+    uint32_t                                        m_rtvDescriptorSize;
+    D3D12_VIEWPORT                                  m_screenViewport;
+    D3D12_RECT                                      m_scissorRect;
+
+    // Direct3D properties.
+    DXGI_FORMAT                                     m_backBufferFormat;
+
+    // Cached device properties.
+    HWND                                            m_window;
+    RECT                                            m_outputSize;
+
+    // Console mode
+    XSystemDeviceType                               m_deviceType;
+
+    // Rendering loop timer.
+    uint64_t                                        m_frame;
+    DX::StepTimer                                   m_timer;
+
+    struct FrameLoad
+    {
+        float m_cpuUpdateTimeInMs;
+        float m_cpuRenderTimeInMs;
+        float m_cpuToGpuTimeInMs;                   // Lag in kicking off work
+        float m_gpuGraphicsTimeInMs;
+        float m_gpuComputeTimeInMs;
+    };
+
+    struct FramePacing
+    {
+        FramePacingUtils::FrameRate                 m_frameRateTarget;
+        uint32_t                                    m_frameThreshold;
+        uint32_t                                    m_framePeriod;
+        uint32_t                                    m_frameBuffers;
+        float                                       m_frameOffsetInMs;
+    };
+
+    // Swap chain
+    struct FrameBuffer
+    {
+        uint32_t                                    m_frame;                    // frame count
+        D3D12XBOX_FRAME_PIPELINE_TOKEN              m_token;                    // frame token
+        uint32_t                                    m_frameBuffer;              // backbuffer index
+        FrameLoad                                   m_frameLoad;                // immutable workload for this frame
+        FramePacing                                 m_framePacing;              // schedule used to acquire this frame
+    };
+    std::queue<FrameBuffer>                         m_swapChain;                // communication between main thread and render thread
+    std::mutex                                      m_swapChainMutex;
+    uint32_t                                        m_nextFrameBufferIndex;     // touched only by main thread
+    uint32_t                                        m_nextFrameIndex;           // touched only by main thread
+    FrameBuffer                                     m_currentUpdateFrameBuffer; // touched only by main thread
+    FrameBuffer                                     m_currentRenderFrameBuffer; // touched only by render thread
+
+    // UITK
+    ATG::UITK::UIManager                            m_uiManager;
+    std::shared_ptr<ATG::UITK::UIStaticText>        m_fpsText;
+    std::shared_ptr<ATG::UITK::UIStaticText>        m_latencyText;
+    std::shared_ptr<ATG::UITK::UIStaticText>        m_marginText;
+    ATG::UITK::UIInputState                         m_inputState;
+    std::mutex                                      m_uiMutex;                  // protects UI state shared by update and render
+    FramePacingUtils::Menu                          m_menu;
+    std::shared_ptr<ATG::UITK::UIPanel>             m_menuPanel;
+    FramePacingUtils::LineGraph                     m_lineGraph[FramePacingUtils::LINE_GRAPH_COUNT];
+    std::shared_ptr<ATG::UITK::UIPanel>             m_lineGraphPanel[FramePacingUtils::LINE_GRAPH_COUNT];
+    FramePacingUtils::IntervalGraph                 m_intervalGraph[FramePacingUtils::INTERVAL_GRAPH_COUNT];
+    std::shared_ptr<ATG::UITK::UIPanel>             m_intervalGraphPanel[FramePacingUtils::INTERVAL_GRAPH_COUNT];
+    std::unique_ptr<DirectX::SpriteBatch>           m_uiSpriteBatch;
+    std::unique_ptr<DirectX::SpriteFont>            m_smallFont;
+    std::unique_ptr<DirectX::SpriteFont>            m_ctrlFont;
+    std::unique_ptr<DirectX::BasicEffect>           m_triEffect;
+    std::unique_ptr<DirectX::BasicEffect>           m_lineEffect;
+    std::unique_ptr<DirectX::PrimitiveBatch<DirectX::VertexPositionColor>> m_primBatch;
+
+    // Input device.
+    std::unique_ptr<DirectX::GamePad>               m_gamePad;
+    DirectX::GamePad::ButtonStateTracker            m_gamePadButtons;
+
+    // DirectXTK objects.
+    std::unique_ptr<DirectX::GraphicsMemory>        m_graphicsMemory;
+    std::unique_ptr<DirectX::CommonStates>          m_commonStates;
+    std::unique_ptr<DirectX::DescriptorPile>        m_srvPile;
+
+    // CPU synchronization
+    HANDLE                                          m_eventUpdateDone;
+    HANDLE                                          m_eventRenderReceived;
+    std::thread*                                    m_renderThread;
+
+    // GPU synchronization
+    Microsoft::WRL::ComPtr<ID3D12Fence>             m_fenceGraphicsToCompute;
+    uint64_t                                        m_fenceGraphicsToComputeValue;
+    Microsoft::WRL::ComPtr<ID3D12Fence>             m_fenceComputeToGraphics;
+    uint64_t                                        m_fenceComputeToGraphicsValue;
+
+    // Shaders to enforce GPU frame time
+    Microsoft::WRL::ComPtr<ID3D12PipelineState>     m_getStartTimePSO;
+    Microsoft::WRL::ComPtr<ID3D12RootSignature>     m_getStartTimeRS;
+    Microsoft::WRL::ComPtr<ID3D12PipelineState>     m_gpuEnforceTimePSO;
+    Microsoft::WRL::ComPtr<ID3D12RootSignature>     m_gpuEnforceTimeRS;
+    Microsoft::WRL::ComPtr<ID3D12Resource>          m_gpuTimeResourceGraphics;
+    Microsoft::WRL::ComPtr<ID3D12Resource>          m_gpuTimeResourceCompute;
+
+    // Threads to enforce CPU frame time
+    std::thread*                                    m_enforceCpuUpdateTimeThread;
+    std::thread*                                    m_enforceCpuRenderTimeThread;
+
+    // Flag to ensure thread finishes cleanly at sample exit
+    std::atomic<bool>                               m_isExiting;
+
+    // CPU frame time signals
+    std::atomic<bool>                               m_startCpuUpdateSignal;
+    float                                           m_updateThreadTimeInMs;
+    std::atomic<bool>                               m_endCpuUpdateSignal;
+    std::atomic<bool>                               m_startCpuRenderSignal;
+    float                                           m_renderThreadTimeInMs;
+    std::atomic<bool>                               m_endCpuRenderSignal;
+
+    // The adjustable processing loads
+    FrameLoad                                       m_desiredFrameLoad;
+    bool                                            m_autoFrameLoad;
+    uint32_t                                        m_currentFrameLoadSequence;
+    using FrameLoadSequence = std::vector<FrameLoad>;
+    std::vector<FrameLoadSequence>                  m_frameLoadSequences;
+    FrameLoad GetFrameLoad(uint32_t frameIndex) const;
+
+    // The adjustable frame pacing options
+    FramePacing                                     m_framePacing;
+    bool                                            m_autoPacing;
+    bool                                            m_frameEventsDirty;
+    mutable std::mutex                              m_settingsMutex;
+
+    // Frame statistics
+    float                                           m_frameRateMeasured;
+    float                                           m_latencyMeasuredInMs;
+    float                                           m_marginMeasuredInMs;
+    float                                           m_tearLocation;
+
+    // Pause
+    std::atomic<bool>                               m_paused;
+    std::atomic<float>                              m_graphZoom;
+    std::atomic<float>                              m_graphOffset;
+
+    // Timestamps
+    struct TaggedCpuTimestamp
+    {
+        D3D12XBOX_FRAME_PIPELINE_TOKEN              m_token;
+        LARGE_INTEGER                               m_time;
+        uint32_t                                    m_frameBuffer;
+    };
+    std::queue<TaggedCpuTimestamp>                  m_startCpuUpdate;
+    std::queue<TaggedCpuTimestamp>                  m_stopCpuUpdate;
+    std::queue<TaggedCpuTimestamp>                  m_startCpuRender;
+    std::queue<TaggedCpuTimestamp>                  m_stopCpuRender;
+
+    Microsoft::WRL::ComPtr<ID3D12QueryHeap>         m_queryHeap;
+    Microsoft::WRL::ComPtr<ID3D12Resource>          m_queryBuffer;
+    static constexpr uint32_t                       c_queryCountPerFrame = 4U;
+    static constexpr uint32_t                       c_queryFrames = 8U;
+    uint32_t                                        m_queryCurrentFrame;
+
+    struct TaggedGpuTimestamp
+    {
+        D3D12XBOX_FRAME_PIPELINE_TOKEN              m_token;
+        uint32_t                                    m_index;
+        uint32_t                                    m_frameBuffer;
+    };
+    std::queue<TaggedGpuTimestamp>                  m_startGpuGraphics;
+    std::queue<TaggedGpuTimestamp>                  m_stopGpuGraphics;
+    std::queue<TaggedGpuTimestamp>                  m_startGpuCompute;
+    std::queue<TaggedGpuTimestamp>                  m_stopGpuCompute;
+
+    std::queue<D3D12XBOX_FRAME_PIPELINE_TOKEN>      m_frameTokens;
+    std::mutex                                      m_frameStatisticsMutex;     // protects history used by automatic pacing
+    FramePacingUtils::Ring<FramePacingUtils::FrameStatistics, 256> m_frameStatistics;
+    FramePacingUtils::Ring<FramePacingUtils::FrameTimestamps, 256> m_frameTimestamps;
+};
diff --git a/Samples/Graphics/FramePacing/FramePacing.sln b/Samples/Graphics/FramePacing/FramePacing.sln
new file mode 100644
index 00000000..089ea00c
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FramePacing.sln
@@ -0,0 +1,62 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 15.0.28307.852
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FramePacing", "FramePacing.vcxproj", "{9901EBA7-174B-452F-8815-E045522330C5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DirectXTK12", "..\..\..\Kits\DirectXTK12\DirectXTK12_GXDK_2022.vcxproj", "{B47A013A-4DE2-4183-A279-A363289E19B8}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UITK", "..\..\..\Kits\UITK\UITK.vcxitems", "{2BFC8F59-E285-4B88-949E-1009233B11E1}"
+EndProject
+Global
+	GlobalSection(SharedMSBuildProjectFiles) = preSolution
+		..\..\..\Kits\UITK\UITK.vcxitems*{2bfc8f59-e285-4b88-949e-1009233b11e1}*SharedItemsImports = 9
+		..\..\..\Kits\UITK\UITK.vcxitems*{9901eba7-174b-452f-8815-e045522330c5}*SharedItemsImports = 4
+	EndGlobalSection
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Gaming.Xbox.Scarlett.x64 = Debug|Gaming.Xbox.Scarlett.x64
+		Debug|Gaming.Xbox.XboxOne.x64 = Debug|Gaming.Xbox.XboxOne.x64
+		Profile|Gaming.Xbox.Scarlett.x64 = Profile|Gaming.Xbox.Scarlett.x64
+		Profile|Gaming.Xbox.XboxOne.x64 = Profile|Gaming.Xbox.XboxOne.x64
+		Release|Gaming.Xbox.Scarlett.x64 = Release|Gaming.Xbox.Scarlett.x64
+		Release|Gaming.Xbox.XboxOne.x64 = Release|Gaming.Xbox.XboxOne.x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9901EBA7-174B-452F-8815-E045522330C5}.Debug|Gaming.Xbox.Scarlett.x64.ActiveCfg = Debug|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Debug|Gaming.Xbox.Scarlett.x64.Build.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Debug|Gaming.Xbox.Scarlett.x64.Deploy.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Debug|Gaming.Xbox.XboxOne.x64.ActiveCfg = Debug|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Debug|Gaming.Xbox.XboxOne.x64.Build.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Debug|Gaming.Xbox.XboxOne.x64.Deploy.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Profile|Gaming.Xbox.Scarlett.x64.ActiveCfg = Profile|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Profile|Gaming.Xbox.Scarlett.x64.Build.0 = Profile|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Profile|Gaming.Xbox.Scarlett.x64.Deploy.0 = Profile|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Profile|Gaming.Xbox.XboxOne.x64.ActiveCfg = Profile|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Profile|Gaming.Xbox.XboxOne.x64.Build.0 = Profile|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Profile|Gaming.Xbox.XboxOne.x64.Deploy.0 = Profile|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Release|Gaming.Xbox.Scarlett.x64.ActiveCfg = Release|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Release|Gaming.Xbox.Scarlett.x64.Build.0 = Release|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Release|Gaming.Xbox.Scarlett.x64.Deploy.0 = Release|Gaming.Xbox.Scarlett.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Release|Gaming.Xbox.XboxOne.x64.ActiveCfg = Release|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Release|Gaming.Xbox.XboxOne.x64.Build.0 = Release|Gaming.Xbox.XboxOne.x64
+		{9901EBA7-174B-452F-8815-E045522330C5}.Release|Gaming.Xbox.XboxOne.x64.Deploy.0 = Release|Gaming.Xbox.XboxOne.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Debug|Gaming.Xbox.Scarlett.x64.ActiveCfg = Debug|Gaming.Xbox.Scarlett.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Debug|Gaming.Xbox.Scarlett.x64.Build.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Debug|Gaming.Xbox.XboxOne.x64.ActiveCfg = Debug|Gaming.Xbox.XboxOne.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Debug|Gaming.Xbox.XboxOne.x64.Build.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Profile|Gaming.Xbox.Scarlett.x64.ActiveCfg = Profile|Gaming.Xbox.Scarlett.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Profile|Gaming.Xbox.Scarlett.x64.Build.0 = Profile|Gaming.Xbox.Scarlett.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Profile|Gaming.Xbox.XboxOne.x64.ActiveCfg = Profile|Gaming.Xbox.XboxOne.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Profile|Gaming.Xbox.XboxOne.x64.Build.0 = Profile|Gaming.Xbox.XboxOne.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Release|Gaming.Xbox.Scarlett.x64.ActiveCfg = Release|Gaming.Xbox.Scarlett.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Release|Gaming.Xbox.Scarlett.x64.Build.0 = Release|Gaming.Xbox.Scarlett.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Release|Gaming.Xbox.XboxOne.x64.ActiveCfg = Release|Gaming.Xbox.XboxOne.x64
+		{B47A013A-4DE2-4183-A279-A363289E19B8}.Release|Gaming.Xbox.XboxOne.x64.Build.0 = Release|Gaming.Xbox.XboxOne.x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {334607E4-C6DC-4D4B-8BFA-97D75EF38066}
+	EndGlobalSection
+EndGlobal
diff --git a/Samples/Graphics/FramePacing/FramePacing.vcxproj b/Samples/Graphics/FramePacing/FramePacing.vcxproj
new file mode 100644
index 00000000..2bb355b5
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FramePacing.vcxproj
@@ -0,0 +1,562 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Profile|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Profile</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Profile|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Profile</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <RootNamespace>FramePacing</RootNamespace>
+    <ProjectGuid>{9901eba7-174b-452f-8815-e045522330c5}</ProjectGuid>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <Keyword>Win32Proj</Keyword>
+    <!-- - - - -->
+    <MinimumVisualStudioVersion>17.0</MinimumVisualStudioVersion>
+    <TargetRuntime>Native</TargetRuntime>
+    <GDKExtLibNames>Xbox.Services.API.C</GDKExtLibNames>
+    <PreferredToolArchitecture>x64</PreferredToolArchitecture>
+    <GDKCrossPlatform>true</GDKCrossPlatform>
+  </PropertyGroup>
+  <Import Condition="Exists($(ATGBuildProps))" Project="$(ATGBuildProps)" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <GDKCrossPlatformPath Condition="'$(GDKCrossPlatformPath)'==''">$(GameDKCoreLatest)</GDKCrossPlatformPath>
+    <GDKCrossPlatformPath Condition="'$(GDKCrossPlatformPath)'==''">$(GameDKXboxLatest)</GDKCrossPlatformPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <EmbedManifest>false</EmbedManifest>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <EmbedManifest>false</EmbedManifest>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <EmbedManifest>false</EmbedManifest>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <EmbedManifest>false</EmbedManifest>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <EmbedManifest>false</EmbedManifest>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <EmbedManifest>false</EmbedManifest>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+    <Import Project="..\..\..\Kits\UITK\UITK.vcxitems" Label="Shared" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">
+    <ReferencePath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</ReferencePath>
+    <LibraryPath>$(Console_SdkLibPath)</LibraryPath>
+    <LibraryWPath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</LibraryWPath>
+    <IncludePath>$(Console_SdkIncludeRoot)</IncludePath>
+    <ExecutablePath>$(Console_SdkRoot)bin;$(Console_SdkToolPath);$(ExecutablePath)</ExecutablePath>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
+    <ReferencePath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</ReferencePath>
+    <LibraryPath>$(Console_SdkLibPath)</LibraryPath>
+    <LibraryWPath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</LibraryWPath>
+    <IncludePath>$(Console_SdkIncludeRoot)</IncludePath>
+    <ExecutablePath>$(Console_SdkRoot)bin;$(Console_SdkToolPath);$(ExecutablePath)</ExecutablePath>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">
+    <ReferencePath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</ReferencePath>
+    <LibraryPath>$(Console_SdkLibPath)</LibraryPath>
+    <LibraryWPath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</LibraryWPath>
+    <IncludePath>$(Console_SdkIncludeRoot)</IncludePath>
+    <ExecutablePath>$(Console_SdkRoot)bin;$(Console_SdkToolPath);$(ExecutablePath)</ExecutablePath>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">
+    <ReferencePath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</ReferencePath>
+    <LibraryPath>$(Console_SdkLibPath)</LibraryPath>
+    <LibraryWPath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</LibraryWPath>
+    <IncludePath>$(Console_SdkIncludeRoot)</IncludePath>
+    <ExecutablePath>$(Console_SdkRoot)bin;$(Console_SdkToolPath);$(ExecutablePath)</ExecutablePath>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">
+    <ReferencePath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</ReferencePath>
+    <LibraryPath>$(Console_SdkLibPath)</LibraryPath>
+    <LibraryWPath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</LibraryWPath>
+    <IncludePath>$(Console_SdkIncludeRoot)</IncludePath>
+    <ExecutablePath>$(Console_SdkRoot)bin;$(Console_SdkToolPath);$(ExecutablePath)</ExecutablePath>
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
+    <ReferencePath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</ReferencePath>
+    <LibraryPath>$(Console_SdkLibPath)</LibraryPath>
+    <LibraryWPath>$(Console_SdkLibPath);$(Console_SdkWindowsMetadataPath)</LibraryWPath>
+    <IncludePath>$(Console_SdkIncludeRoot)</IncludePath>
+    <ExecutablePath>$(Console_SdkRoot)bin;$(Console_SdkToolPath);$(ExecutablePath)</ExecutablePath>
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">
+    <Link>
+      <AdditionalDependencies>libHttpClient.lib;uuid.lib;$(Console_Libs);%(XboxExtensionsDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>$(ProjectDir);..\..\..\Kits\DirectXTK12\Inc;..\..\..\Kits\ATGTK;..\..\..\Kits\ATGTelemetry\GDK;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories />
+      <ForcedUsingFiles />
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>ATG_ENABLE_TELEMETRY;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level4</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
+    <Link>
+      <AdditionalDependencies>libHttpClient.lib;uuid.lib;$(Console_Libs);%(XboxExtensionsDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>$(ProjectDir);..\..\..\Kits\DirectXTK12\Inc;..\..\..\Kits\ATGTK;..\..\..\Kits\ATGTelemetry\GDK;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>
+      </AdditionalUsingDirectories>
+      <ForcedUsingFiles>
+      </ForcedUsingFiles>
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>ATG_ENABLE_TELEMETRY;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level4</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">
+    <Link>
+      <AdditionalDependencies>libHttpClient.lib;uuid.lib;$(Console_Libs);%(XboxExtensionsDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>$(ProjectDir);..\..\..\Kits\DirectXTK12\Inc;..\..\..\Kits\ATGTK;..\..\..\Kits\ATGTelemetry\GDK;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories />
+      <ForcedUsingFiles />
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>ATG_ENABLE_TELEMETRY;NDEBUG;PROFILE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level4</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">
+    <Link>
+      <AdditionalDependencies>libHttpClient.lib;uuid.lib;$(Console_Libs);%(XboxExtensionsDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>$(ProjectDir);..\..\..\Kits\DirectXTK12\Inc;..\..\..\Kits\ATGTK;..\..\..\Kits\ATGTelemetry\GDK;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>
+      </AdditionalUsingDirectories>
+      <ForcedUsingFiles>
+      </ForcedUsingFiles>
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>ATG_ENABLE_TELEMETRY;NDEBUG;PROFILE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level4</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">
+    <Link>
+      <AdditionalDependencies>libHttpClient.lib;uuid.lib;$(Console_Libs);%(XboxExtensionsDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <ClCompile>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <MinimalRebuild>false</MinimalRebuild>
+      <AdditionalIncludeDirectories>$(ProjectDir);..\..\..\Kits\DirectXTK12\Inc;..\..\..\Kits\ATGTK;..\..\..\Kits\ATGTelemetry\GDK;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories />
+      <ForcedUsingFiles />
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>ATG_ENABLE_TELEMETRY;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
+    <Link>
+      <AdditionalDependencies>libHttpClient.lib;uuid.lib;$(Console_Libs);%(XboxExtensionsDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <ClCompile>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <MinimalRebuild>false</MinimalRebuild>
+      <AdditionalIncludeDirectories>$(ProjectDir);..\..\..\Kits\DirectXTK12\Inc;..\..\..\Kits\ATGTK;..\..\..\Kits\ATGTelemetry\GDK;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>
+      </AdditionalUsingDirectories>
+      <ForcedUsingFiles>
+      </ForcedUsingFiles>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>ATG_ENABLE_TELEMETRY;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <CopyFileToFolders>
+      <DestinationFolders>$(OutDir)Assets</DestinationFolders>
+    </CopyFileToFolders>
+    <FxCompile>
+      <ShaderModel>6.0</ShaderModel>
+    </FxCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\Kits\ATGTK\ControllerFont.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\ReadData.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\Texture.h" />
+    <ClInclude Include="FramePacing.h" />
+    <ClInclude Include="Graph.h" />
+    <ClInclude Include="Utility.h" />
+    <ClInclude Include="Menu.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="StepTimer.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\StringUtil.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTelemetry\GDK\ATGTelemetry.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\Json.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\json\json.hpp" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\ATGColors.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\FindMedia.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="FramePacing.cpp" />
+    <ClCompile Include="Graph.cpp" />
+    <ClCompile Include="Main.cpp" />
+    <ClCompile Include="..\..\..\Kits\ATGTK\StringUtil.cpp" />
+    <ClCompile Include="..\..\..\Kits\ATGTK\Texture.cpp" />
+    <ClCompile Include="..\..\..\Kits\ATGTelemetry\GDK\ATGTelemetry.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <MGCCompile Include="MicrosoftGameConfig.mgc" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Kits\DirectXTK12\DirectXTK12_GXDK_2022.vcxproj">
+      <Project>{b47a013a-4de2-4183-a279-a363289e19b8}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Assets\UILayout.json" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Assets\Logo.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Assets\LargeLogo.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Assets\SmallLogo.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Assets\SplashScreen.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Assets\StoreLogo.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <FxCompile Include="EnforceGpuTime.hlsl">
+      <DisableOptimizations>true</DisableOptimizations>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">Compute</ShaderType>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+    </FxCompile>
+    <FxCompile Include="GetStartTime.hlsl">
+      <DisableOptimizations>true</DisableOptimizations>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Compute</ShaderType>
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">Compute</ShaderType>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">AssemblyCode</AssemblerOutput>
+      <AssemblerOutputFile Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)%(Filename).cso.txt</AssemblerOutputFile>
+    </FxCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\..\Media\Fonts\XboxOneControllerLegendSmall.spritefont">
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <FileType>Document</FileType>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\..\Media\Fonts\SegoeUI_18.spritefont">
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <FileType>Document</FileType>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\..\Media\Fonts\SegoeUI_48.spritefont">
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <FileType>Document</FileType>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">true</DeploymentContent>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)</DestinationFolders>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+      <DestinationFileName Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">Assets/Fonts/%(Filename)%(Extension)</DestinationFileName>
+    </CopyFileToFolders>
+    <None Include="Time.hlsli" />
+    <None Include="readme.md" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\LOGO_ATG.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="FrameLoads\GpuSpike.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="FrameLoads\GpuGlitch.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="FrameLoads\GpuJitter.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="FrameLoads\GpuSawtooth.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.Scarlett.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Profile|Gaming.Xbox.XboxOne.x64'">$(OutDir)FrameLoads</DestinationFolders>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+  <Target Name="GDKEditionCheck" BeforeTargets="PrepareForBuild">
+    <Error Condition="'$(GameDK)'==''" Text="GameDK property is required" />
+    <Error Condition="!HasTrailingSlash('$(GameDK)')" Text="GameDK property must have trailing slash" />
+    <Error Condition="'$(GDKCrossPlatformPath)'==''" Text="GDKCrossPlatformPath property, GameDKCoreLatest environment variable, or GameDKXboxLatest environment variable is required" />
+    <Error Condition="!HasTrailingSlash('$(GDKCrossPlatformPath)')" Text="GDKCrossPlatformPath property must have trailing slash" />
+    <Error Condition="!Exists('$(GDKCrossPlatformPath)windows')" Text="GDKCrossPlatformPath needs to point to the October 2024 GDK or later" />
+    <Message Importance="high" Text="Using $(GDKCrossPlatformPath)" />
+  </Target>
+  <Target Name="EnsureGDK" BeforeTargets="_CheckForInvalidConfigurationAndPlatform" Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(Platform)', 'Gaming\.Xbox\..+\.x64'))">
+    <PropertyGroup>
+      <ErrorText>This project requires the Microsoft GDK with Xbox Extensions to be installed. If you have already installed the GDK, then run Repair to ensure proper integration with Visual Studio. The missing platform is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('$(VCTargetsPath)\Platforms\$(Platform)\Platform.props')" Text="$([System.String]::Format('$(ErrorText)', '$(Platform)'))" />
+  </Target>
+  <Target Name="BuildMGC" AfterTargets="Build" Condition="!$([System.Text.RegularExpressions.Regex]::IsMatch('$(Platform)', 'Gaming\..+\.x64'))" Inputs="@(MGCCompile)" Outputs="$(OutDir)MicrosoftGame.config">
+    <Exec ConsoleToMsBuild="true" Command="copy &quot;%(MGCCompile.Identity)&quot; &quot;$(OutDir)MicrosoftGame.config&quot;" />
+    <Exec ConsoleToMsBuild="true" Command="makepkg.exe localize /d &quot;$(OutDir).&quot; /pd &quot;$(OutDir).&quot; /gc &quot;%(MGCCompile.Identity)&quot;" />
+  </Target>
+  <ItemGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(Platform)', 'Gaming\.Xbox\..+\.x64'))">
+    <ReferenceCopyLocalPaths Include="$(GDKCrossPlatformPath)xbox\bin\x64\libHttpClient.dll" />
+    <ReferenceCopyLocalPaths Include="$(GDKCrossPlatformPath)xbox\bin\x64\XCurl.dll" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/Samples/Graphics/FramePacing/FramePacing.vcxproj.filters b/Samples/Graphics/FramePacing/FramePacing.vcxproj.filters
new file mode 100644
index 00000000..b34b761b
--- /dev/null
+++ b/Samples/Graphics/FramePacing/FramePacing.vcxproj.filters
@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Common">
+      <UniqueIdentifier>a9b47655-1af9-4de2-8b41-09d2eabfef55</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets">
+      <UniqueIdentifier>5bed74ed-9fa2-47e1-aab0-83c8a24e9a77</UniqueIdentifier>
+      <Extensions>ico;cur;bmp;dds;dlg;fbx;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tga;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="ATG Tool Kit">
+      <UniqueIdentifier>8bd0bab9-4e1b-47f2-b243-30283cbd8090</UniqueIdentifier>
+    </Filter>
+    <Filter Include="External">
+      <UniqueIdentifier>e82ee1f2-958e-497b-b3e5-062395fdf5b5</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Shaders">
+      <UniqueIdentifier>{2085df52-0a3c-4e79-a0de-8aba75bdd715}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets\Fonts">
+      <UniqueIdentifier>{3361944d-1532-43fa-b79a-5f9a47c6baa4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets\FrameLoads">
+      <UniqueIdentifier>{3c061f13-92b9-41b0-aef0-d6f7431f6466}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="FramePacing.h" />
+    <ClInclude Include="StepTimer.h">
+      <Filter>Common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\Kits\ATGTK\ATGColors.h">
+      <Filter>ATG Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\Kits\ATGTelemetry\GDK\ATGTelemetry.h">
+      <Filter>ATG Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\Kits\ATGTK\StringUtil.h">
+      <Filter>ATG Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\Kits\ATGTK\json.h">
+      <Filter>ATG Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\Kits\ATGTK\json\json.hpp">
+      <Filter>External</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\Kits\ATGTK\FindMedia.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\ReadData.h">
+      <Filter>ATG Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="Menu.h" />
+    <ClInclude Include="Utility.h" />
+    <ClInclude Include="Graph.h" />
+    <ClInclude Include="..\..\..\Kits\ATGTK\Texture.h">
+      <Filter>ATG Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\Kits\ATGTK\ControllerFont.h">
+      <Filter>ATG Tool Kit</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="pch.cpp" />
+    <ClCompile Include="FramePacing.cpp" />
+    <ClCompile Include="Main.cpp" />
+    <ClCompile Include="..\..\..\Kits\ATGTelemetry\GDK\ATGTelemetry.cpp">
+      <Filter>ATG Tool Kit</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\Kits\ATGTK\StringUtil.cpp">
+      <Filter>ATG Tool Kit</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\Kits\ATGTK\Texture.cpp">
+      <Filter>ATG Tool Kit</Filter>
+    </ClCompile>
+    <ClCompile Include="Graph.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <MGCCompile Include="MicrosoftGameConfig.mgc" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Assets\UILayout.json">
+      <Filter>Assets</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="Assets\Logo.png">
+      <Filter>Assets</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="Assets\LargeLogo.png">
+      <Filter>Assets</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="Assets\SmallLogo.png">
+      <Filter>Assets</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="Assets\SplashScreen.png">
+      <Filter>Assets</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="Assets\StoreLogo.png">
+      <Filter>Assets</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\..\Media\Fonts\XboxOneControllerLegendSmall.spritefont">
+      <Filter>Assets\Fonts</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\..\Media\Fonts\SegoeUI_18.spritefont">
+      <Filter>Assets\Fonts</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\..\Media\Fonts\SegoeUI_48.spritefont">
+      <Filter>Assets\Fonts</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="FrameLoads\GpuSpike.txt">
+      <Filter>Assets\FrameLoads</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="FrameLoads\GpuGlitch.txt">
+      <Filter>Assets\FrameLoads</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="FrameLoads\GpuJitter.txt">
+      <Filter>Assets\FrameLoads</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="FrameLoads\GpuSawtooth.txt">
+      <Filter>Assets\FrameLoads</Filter>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <FxCompile Include="EnforceGpuTime.hlsl">
+      <Filter>Shaders</Filter>
+    </FxCompile>
+    <FxCompile Include="GetStartTime.hlsl">
+      <Filter>Shaders</Filter>
+    </FxCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Time.hlsli">
+      <Filter>Shaders</Filter>
+    </None>
+    <None Include="readme.md" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\LOGO_ATG.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/Samples/Graphics/FramePacing/GetStartTime.hlsl b/Samples/Graphics/FramePacing/GetStartTime.hlsl
new file mode 100644
index 00000000..58d4cad0
--- /dev/null
+++ b/Samples/Graphics/FramePacing/GetStartTime.hlsl
@@ -0,0 +1,30 @@
+//--------------------------------------------------------------------------------------
+// File: GetStartTime.hlsl
+//
+// This compute shader stores the current GPU clock value used as the starting point for
+// FramePacing's repeatable artificial GPU workloads.
+//
+// This should be compiled with /Od, or subsequent calls to __XB_MemTime() (in
+// GetTimeStamp()) may be optimized away.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#include "Time.hlsli"
+
+#define RS \
+[\
+    RootSignature\
+    (\
+        "UAV(u0)"\
+    )\
+]
+
+RWStructuredBuffer<Time> TimeBuffer : register(u0);
+
+[numthreads(1, 1, 1)]
+RS
+void main(uint3 DTid : SV_DispatchThreadID)
+{
+    TimeBuffer[0].startTime = GetTimeStamp();
+}
diff --git a/Samples/Graphics/FramePacing/Graph.cpp b/Samples/Graphics/FramePacing/Graph.cpp
new file mode 100644
index 00000000..ad47f66e
--- /dev/null
+++ b/Samples/Graphics/FramePacing/Graph.cpp
@@ -0,0 +1,245 @@
+//--------------------------------------------------------------------------------------
+// Graph.cpp
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#include "pch.h"
+
+#include "Graph.h"
+
+using namespace DirectX;
+using namespace FramePacingUtils;
+
+namespace
+{
+    using namespace DirectX::SimpleMath;
+
+    const XMVECTORF32 c_lineColor = { {{ 0.8588235294f, 0.2862745098f, 0.1098039215f, 1.0f }} };
+    const XMVECTORF32 c_labelColor = { {{ 0.5490196078f, 0.7764705882f, 0.7803921568f, 1.0f }} };
+    const XMVECTORF32 c_rangeColor = DirectX::Colors::Tan;
+};
+
+
+void LineGraph::Render(
+    ID3D12GraphicsCommandList* commandList,
+    PrimitiveBatch<VertexPositionColor>* primBatch,
+    BasicEffect* basicEffect,
+    SpriteBatch* spriteBatch,
+    SpriteFont* font,
+    const D3D12_VIEWPORT* screenViewport,
+    const D3D12_VIEWPORT* graphViewport)
+{
+    wchar_t textBuffer[128] = {};
+    _snwprintf_s(textBuffer, _TRUNCATE, L"Graph: %ls", m_name);
+    ScopedPixEvent Render(commandList, PIX_COLOR_DEFAULT, textBuffer);
+
+    commandList->RSSetViewports(1, screenViewport);
+
+    // Where is the graph element itself (excluding text), within its viewport
+    float graphStartX = 15.0f;
+    float graphStopX = graphViewport->Width - 70.0f;
+    float graphStartY = 15.0f;
+    float graphStopY = graphViewport->Height - 25.0f;    // account for label
+
+    // Text -- positions based on full-screen viewport
+    float incX = 10.0f;
+    float incY = 10.0f;
+    float textX = graphViewport->TopLeftX;
+    float textY = graphViewport->TopLeftY + graphStopY;
+    XMFLOAT2 textPos(textX, textY);
+
+    spriteBatch->Begin(commandList);
+
+    font->DrawString(spriteBatch, m_name, textPos, c_labelColor, 0.0f, { 0.0f, 0.0f }, 0.8f);
+
+    textPos.x = graphViewport->TopLeftX + graphStopX + incX;
+    textPos.y = graphViewport->TopLeftY;
+    _snwprintf_s(textBuffer, _TRUNCATE, L"%2.2f", m_maxY);
+    font->DrawString(spriteBatch, textBuffer, textPos, c_labelColor, 0.0f, { 0.0f, 0.0f }, 0.8f);
+
+    textPos.y = graphViewport->TopLeftY + graphStopY - incY;
+    _snwprintf_s(textBuffer, _TRUNCATE, L"%2.2f", m_minY);
+    font->DrawString(spriteBatch, textBuffer, textPos, c_labelColor, 0.0f, { 0.0f, 0.0f }, 0.8f);
+
+    spriteBatch->End();
+
+    // Graph
+    D3D12_VIEWPORT viewportGraph =
+    {
+        graphViewport->TopLeftX + graphStartX,
+        graphViewport->TopLeftY + graphStartY,
+        graphStopX - graphStartX,
+        graphStopY - graphStartY,
+        0.0f,
+        1.0f,
+    };
+    commandList->RSSetViewports(1, &viewportGraph);
+
+    basicEffect->Apply(commandList);
+    primBatch->Begin(commandList);
+
+    // Frame
+    float leftX = ScaleX(0.0f);
+    float rightX = ScaleX(1.0f);
+    float topY = ScaleY(m_maxY);
+    float bottomY = ScaleY(m_minY);
+    float zeroY = ScaleY(0.0f);
+    Vector3 topLeft(leftX, topY, 0.0f);
+    Vector3 topRight(rightX, topY, 0.0f);
+    Vector3 bottomLeft(leftX, bottomY, 0.0f);
+    Vector3 bottomRight(rightX, bottomY, 0.0f);
+    Vector3 zeroLeft(leftX, zeroY, 0.0f);
+    Vector3 zeroRight(rightX, zeroY, 0.0f);
+    primBatch->DrawLine(VertexPositionColor(topLeft, c_labelColor), VertexPositionColor(bottomLeft, c_labelColor));
+    primBatch->DrawLine(VertexPositionColor(zeroLeft, c_labelColor), VertexPositionColor(zeroRight, c_labelColor));
+    primBatch->DrawLine(VertexPositionColor(bottomRight, c_labelColor), VertexPositionColor(topRight, c_labelColor));
+    float tickSizeX = 0.02f;
+    for (float tick = m_minY; tick <= m_maxY; tick += m_tickInterval)
+    {
+        float tickY = ScaleY(tick);
+        float tickLeftStartX = ScaleX(0.0f);
+        float tickLeftStopX = ScaleX(0.0f) + tickSizeX;
+        Vector3 tickLeftStart(tickLeftStartX, tickY, 0.0f);
+        Vector3 tickLeftStop(tickLeftStopX, tickY, 0.0f);
+        primBatch->DrawLine(VertexPositionColor(tickLeftStart, c_labelColor), VertexPositionColor(tickLeftStop, c_labelColor));
+        float tickRightStartX = ScaleX(1.0f);
+        float tickRightStopX = ScaleX(1.0f) - tickSizeX;
+        Vector3 tickRightStart(tickRightStartX, tickY, 0.0f);
+        Vector3 tickRightStop(tickRightStopX, tickY, 0.0f);
+        primBatch->DrawLine(VertexPositionColor(tickRightStart, c_labelColor), VertexPositionColor(tickRightStop, c_labelColor));
+    }
+
+    // Data
+    if (!m_data.empty())
+    {
+        VertexPositionColor vertices[c_numData] = {};
+        VertexPositionColor* vertex = vertices;
+        double nowInMs = m_data.back().m_flipTimeInMs;
+        for (auto it = m_data.cend(); it != m_data.cbegin(); --it)
+        {
+            auto itPrev = it - 1;
+
+            float timeBeforeNowInMS = static_cast<float>(nowInMs - itPrev->m_flipTimeInMs);
+            float dataX = ScaleX((c_lengthInMs - timeBeforeNowInMS) / c_lengthInMs);
+            float dataY = ScaleY(itPrev->m_value);
+
+            *vertex = VertexPositionColor(Vector3(dataX, dataY, 0.0f), c_lineColor);
+
+            ++vertex;
+            if (vertex == vertices + _countof(vertices))
+            {
+                break;
+            }
+        }
+
+        primBatch->Draw(D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, vertices, static_cast<size_t>(vertex - vertices));
+    }
+
+    primBatch->End();
+}
+
+void IntervalGraph::Render(
+    ID3D12GraphicsCommandList* commandList,
+    PrimitiveBatch<VertexPositionColor>* primBatch,
+    BasicEffect* basicEffect,
+    SpriteBatch* spriteBatch,
+    SpriteFont* font,
+    const D3D12_VIEWPORT* screenViewport,
+    const D3D12_VIEWPORT* graphViewport)
+{
+    wchar_t textBuffer[128] = {};
+    _snwprintf_s(textBuffer, _TRUNCATE, L"Graph: %ls", m_name);
+    ScopedPixEvent Render(commandList, PIX_COLOR_DEFAULT, textBuffer);
+
+    commandList->RSSetViewports(1, screenViewport);
+
+    // Where is the graph element itself (excluding text), within its viewport
+    float graphStartX = 15.0f;
+    float graphStopX = graphViewport->Width - 15.0f;
+    float graphStartY = 15.0f;
+    float graphStopY = graphViewport->Height - 25.0f;    // account for label
+
+    // Text -- positions based on full-screen viewport
+    float textX = graphViewport->TopLeftX;
+    float textY = graphViewport->TopLeftY + graphStopY;
+    XMFLOAT2 textPos(textX, textY);
+
+    spriteBatch->Begin(commandList);
+
+    font->DrawString(spriteBatch, m_name, textPos, c_labelColor, 0.0f, { 0.0f, 0.0f }, 0.8f);
+
+    spriteBatch->End();
+
+    D3D12_VIEWPORT viewportGraph =
+    {
+        graphViewport->TopLeftX + graphStartX,
+        graphViewport->TopLeftY + graphStartY,
+        graphStopX - graphStartX,
+        graphStopY - graphStartY,
+        0.0f,
+        1.0f,
+    };
+    commandList->RSSetViewports(1, &viewportGraph);
+
+    basicEffect->Apply(commandList);
+    primBatch->Begin(commandList);
+
+    // Data
+    if (!m_data.empty())
+    {
+        std::vector<VertexPositionColor> vertices(c_numData * 4);
+        VertexPositionColor* vertex = vertices.data();
+
+        // Align the times for all interval graphs by starting at flip time
+        double nowInMs = m_data.back().m_flipTimeInMs;   
+        for (auto it = m_data.cend()-1; it != m_data.cbegin(); --it)
+        {
+            // float is good enough for relative times
+            float startBeforeNowInMS = static_cast<float>(nowInMs - it->m_startInMs);
+            float stopBeforeNowInMS = static_cast<float>(nowInMs - it->m_stopInMs);
+
+            float leftX = ScaleX((c_lengthInMs - startBeforeNowInMS) / c_lengthInMs);
+            float rightX = ScaleX((c_lengthInMs - stopBeforeNowInMS) / c_lengthInMs);
+            float topY = ScaleY(0.0f);
+            float bottomY = ScaleY(1.0f);
+
+            Vector3 topLeft(leftX, topY, 0.0f);
+            Vector3 topRight(rightX, topY, 0.0f);
+            Vector3 bottomLeft(leftX, bottomY, 0.0f);
+            Vector3 bottomRight(rightX, bottomY, 0.0f);
+            auto colorIndex = it->m_frameBuffer % _countof(c_intervalColors);
+            *vertex++ = VertexPositionColor(topLeft, c_intervalColors[colorIndex]);
+            *vertex++ = VertexPositionColor(bottomLeft, c_intervalColors[colorIndex]);
+            *vertex++ = VertexPositionColor(bottomRight, c_intervalColors[colorIndex]);
+            *vertex++ = VertexPositionColor(topRight, c_intervalColors[colorIndex]);
+
+            if (vertex == vertices.data() + vertices.size())
+            {
+                break;
+            }
+        }
+
+        primBatch->Draw(D3D_PRIMITIVE_TOPOLOGY_QUADLIST, vertices.data(), static_cast<size_t>(vertex - vertices.data()));
+    }
+
+    // Range finder
+    {
+        // Frame
+        float leftX = ScaleX(0.0f);
+        float rightX = ScaleX(1.0f);
+        float topY = ScaleY(0.0f);
+        float bottomY = ScaleY(1.0f);
+        Vector3 topLeft(leftX, topY, 0.0f);
+        Vector3 topRight(rightX, topY, 0.0f);
+        Vector3 bottomLeft(leftX, bottomY, 0.0f);
+        Vector3 bottomRight(rightX, bottomY, 0.0f);
+        primBatch->DrawLine(VertexPositionColor(topLeft, c_rangeColor), VertexPositionColor(bottomLeft, c_rangeColor));
+        primBatch->DrawLine(VertexPositionColor(bottomLeft, c_rangeColor), VertexPositionColor(bottomRight, c_rangeColor));
+        primBatch->DrawLine(VertexPositionColor(bottomRight, c_rangeColor), VertexPositionColor(topRight, c_rangeColor));
+        primBatch->DrawLine(VertexPositionColor(topRight, c_rangeColor), VertexPositionColor(topLeft, c_rangeColor));
+    }
+
+    primBatch->End();
+}
diff --git a/Samples/Graphics/FramePacing/Graph.h b/Samples/Graphics/FramePacing/Graph.h
new file mode 100644
index 00000000..c54bd2fc
--- /dev/null
+++ b/Samples/Graphics/FramePacing/Graph.h
@@ -0,0 +1,190 @@
+//--------------------------------------------------------------------------------------
+// Graph.h
+//
+// Helper code for rendering statistics as graphs on the screen
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "DirectXColors.h"
+#include "Effects.h"
+#include "PrimitiveBatch.h"
+#include "SpriteBatch.h"
+#include "SpriteFont.h"
+#include "Utility.h"
+
+namespace FramePacingUtils
+{
+    inline const DirectX::XMVECTORF32 c_intervalColors[] =
+    {
+        DirectX::Colors::LightGreen,
+        DirectX::Colors::Yellow,
+        DirectX::Colors::MediumSlateBlue,
+        DirectX::Colors::Orange,
+    };
+
+    enum : uint32_t
+    {
+        LINE_GRAPH_FRAME_TIME_FLIP,
+        LINE_GRAPH_FRAME_LATENCY,
+        LINE_GRAPH_LATENCY_MARGIN,
+
+        LINE_GRAPH_COUNT
+    };
+
+    inline constexpr const wchar_t* c_lineGraphNames[] =
+    {
+        L"Frame time (ms)",
+        L"Ideal latency (ms)",
+        L"Latency margin (ms)",
+    };
+    static_assert(_countof(c_lineGraphNames) == LINE_GRAPH_COUNT, "Mismatch between enum and reflected names");
+
+    inline constexpr const char* c_lineGraphLayoutNames[] =
+    {
+        "frame_time_panel",
+        "latency_panel",
+        "margin_panel",
+    };
+    static_assert(_countof(c_lineGraphLayoutNames) == LINE_GRAPH_COUNT, "Mismatch between enum and reflected names");
+
+    enum : uint32_t
+    {
+        INTERVAL_GRAPH_CPU_UPDATE,
+        INTERVAL_GRAPH_CPU_RENDER,
+        INTERVAL_GRAPH_GPU_GRAPHICS,
+        INTERVAL_GRAPH_GPU_COMPUTE,
+        INTERVAL_GRAPH_FLIP,
+
+        INTERVAL_GRAPH_COUNT
+    };
+
+    inline constexpr const wchar_t* c_intervalGraphNames[] =
+    {
+        L"CPU update",
+        L"CPU render",
+        L"GPU graphics",
+        L"GPU compute",
+        L"Flip",
+    };
+    static_assert(_countof(c_intervalGraphNames) == INTERVAL_GRAPH_COUNT, "Mismatch between enum and reflected names");
+
+    inline constexpr const char* c_intervalGraphLayoutNames[] =
+    {
+        "cpu_update_panel",
+        "cpu_render_panel",
+        "gpu_graphics_panel",
+        "gpu_compute_panel",
+        "flip_panel",
+    };
+    static_assert(_countof(c_intervalGraphLayoutNames) == INTERVAL_GRAPH_COUNT, "Mismatch between enum and reflected names");
+template<typename DataType, typename InputType>
+class Graph
+{
+protected:
+    static constexpr uint32_t c_numData = 256;
+    static constexpr float c_lengthInMs = 4000.0f;
+
+public:
+    Graph() noexcept
+        : m_name(nullptr)
+        , m_minX(0.0f)
+        , m_maxX(0.0f)
+        , m_minY(0.0f)
+        , m_maxY(0.0f)
+        , m_tickInterval(0.0f)
+        , m_createData(nullptr)
+    {}
+
+    virtual ~Graph() = default;
+
+    void Update(const InputType* input)
+    {
+        m_data.push_back(m_createData(input));
+    }
+
+    virtual void Render(
+        ID3D12GraphicsCommandList* commandList,
+        DirectX::PrimitiveBatch<DirectX::VertexPositionColor>* primBatch,
+        DirectX::BasicEffect* basicEffect,
+        DirectX::SpriteBatch* spriteBatch,
+        DirectX::SpriteFont* font,
+        const D3D12_VIEWPORT* screenViewport,
+        const D3D12_VIEWPORT* graphViewport) = 0;
+
+    float ScaleX(float val)
+    {
+        return Saturate(((val - m_minX) / (m_maxX - m_minX) * 2.0f) - 1.0f, -0.999f, 0.999f);
+    }
+
+    float ScaleY(float val)
+    {
+        return Saturate(((val - m_minY) / (m_maxY - m_minY) * 2.0f) - 1.0f, -0.999f, 0.999f);
+    }
+
+    void ZoomX(float zoom, float offset)
+    {
+        m_minX = 1.0f - zoom + offset;
+        m_maxX = 1.0f + offset;
+    }
+
+    const wchar_t* m_name;
+
+    float m_minX;
+    float m_maxX;
+    float m_minY;
+    float m_maxY;
+    float m_tickInterval;
+
+    using DataFactory = DataType(*)(const InputType* input);
+    DataFactory m_createData;
+
+    Ring< DataType, c_numData > m_data;
+};
+
+struct DataPoint
+{
+    double m_flipTimeInMs;
+    float m_value;
+};
+class LineGraph : public Graph<DataPoint, FrameStatistics>
+{
+public:
+    ~LineGraph() override = default;
+
+    void Render(
+        ID3D12GraphicsCommandList* commandList,
+        DirectX::PrimitiveBatch<DirectX::VertexPositionColor>* primBatch,
+        DirectX::BasicEffect* basicEffect,
+        DirectX::SpriteBatch* spriteBatch,
+        DirectX::SpriteFont* font,
+        const D3D12_VIEWPORT* screenViewport,
+        const D3D12_VIEWPORT* graphViewport) override;
+};
+
+struct DataInterval
+{
+    double m_flipTimeInMs;
+    double m_startInMs;
+    double m_stopInMs;
+
+    uint32_t m_frameBuffer;
+};
+class IntervalGraph : public Graph<DataInterval, FrameTimestamps>
+{
+public:
+    ~IntervalGraph() override = default;
+
+    void Render(
+        ID3D12GraphicsCommandList* commandList,
+        DirectX::PrimitiveBatch<DirectX::VertexPositionColor>* primBatch,
+        DirectX::BasicEffect* basicEffect,
+        DirectX::SpriteBatch* spriteBatch,
+        DirectX::SpriteFont* font,
+        const D3D12_VIEWPORT* screenViewport,
+        const D3D12_VIEWPORT* graphViewport) override;
+};
+} // namespace FramePacingUtils
diff --git a/Samples/Graphics/FramePacing/Main.cpp b/Samples/Graphics/FramePacing/Main.cpp
new file mode 100644
index 00000000..9c5957ef
--- /dev/null
+++ b/Samples/Graphics/FramePacing/Main.cpp
@@ -0,0 +1,234 @@
+//--------------------------------------------------------------------------------------
+// Main.cpp
+//
+// Entry point for Microsoft Game Core on Xbox
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#include "pch.h"
+#include "FramePacing.h"
+
+#include "ATGTelemetry.h"
+
+#include <appnotify.h>
+#include <XDisplay.h>
+#include <XGameRuntimeInit.h>
+
+using namespace DirectX;
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wcovered-switch-default"
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#endif
+
+#pragma warning(disable : 4061)
+
+namespace
+{
+    std::unique_ptr<Sample> g_sample;
+    HANDLE g_plmSuspendComplete = nullptr;
+    HANDLE g_plmSignalResume = nullptr;
+}
+
+bool g_HDRMode = false;
+
+LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
+void SetDisplayMode() noexcept;
+void ExitSample() noexcept;
+
+// Entry point
+int WINAPI wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow)
+{
+    UNREFERENCED_PARAMETER(lpCmdLine);
+
+    if (!XMVerifyCPUSupport())
+    {
+#ifdef _DEBUG
+        OutputDebugStringA("ERROR: This hardware does not support the required instruction set.\n");
+#ifdef __AVX2__
+        OutputDebugStringA("This may indicate a Gaming.Xbox.Scarlett.x64 binary is being run on an Xbox One.\n");
+#endif
+#endif
+        return 1;
+    }
+
+    // Initialize COM for WIC usage
+    if (FAILED(CoInitializeEx(nullptr, COINITBASE_MULTITHREADED)))
+        return 1;
+
+    if (FAILED(XGameRuntimeInitialize()))
+        return 1;
+
+    // Default main thread to CPU 0
+    SetThreadAffinityMask(GetCurrentThread(), 0x1);
+
+    // Microsoft Game Core on Xbox supports UTF-8 everywhere
+    assert(GetACP() == CP_UTF8);
+
+    g_sample = std::make_unique<Sample>();
+
+    // Register class and create window
+    PAPPSTATE_REGISTRATION hPLM = {};
+    PAPPCONSTRAIN_REGISTRATION hPLM2 = {};
+
+    {
+        // Register class
+        WNDCLASSEXA wcex = {};
+        wcex.cbSize = sizeof(WNDCLASSEXA);
+        wcex.style = CS_HREDRAW | CS_VREDRAW;
+        wcex.lpfnWndProc = WndProc;
+        wcex.hInstance = hInstance;
+        wcex.lpszClassName = u8"FramePacingWindowClass";
+        wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
+        if (!RegisterClassExA(&wcex))
+            return 1;
+
+        // Create window
+        HWND hwnd = CreateWindowExA(0, u8"FramePacingWindowClass", u8"FramePacing", WS_OVERLAPPEDWINDOW,
+            CW_USEDEFAULT, CW_USEDEFAULT, 1920, 1080, nullptr, nullptr, hInstance,
+            nullptr);
+        if (!hwnd)
+            return 1;
+
+        ShowWindow(hwnd, nCmdShow);
+
+        SetDisplayMode();
+
+        SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(g_sample.get()));
+
+        // Sample Usage Telemetry
+        //
+        // Disable or remove this code block to opt-out of sample usage telemetry
+        ATG::SendLaunchTelemetry();
+
+        g_sample->Initialize(hwnd);
+
+        g_plmSuspendComplete = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
+        g_plmSignalResume = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
+        if (!g_plmSuspendComplete || !g_plmSignalResume)
+            return 1;
+
+        if (RegisterAppStateChangeNotification([](BOOLEAN quiesced, PVOID context)
+        {
+            if (quiesced)
+            {
+                ResetEvent(g_plmSuspendComplete);
+                ResetEvent(g_plmSignalResume);
+
+                // To ensure we use the main UI thread to process the notification, we self-post a message
+                PostMessage(reinterpret_cast<HWND>(context), WM_USER, 0, 0);
+
+                // To defer suspend, you must wait to exit this callback
+                (void)WaitForSingleObject(g_plmSuspendComplete, INFINITE);
+            }
+            else
+            {
+                SetEvent(g_plmSignalResume);
+            }
+        }, hwnd, &hPLM))
+            return 1;
+
+        if (RegisterAppConstrainedChangeNotification([](BOOLEAN constrained, PVOID context)
+        {
+            // To ensure we use the main UI thread to process the notification, we self-post a message
+            SendMessage(reinterpret_cast<HWND>(context), WM_USER + 1, (constrained) ? 1u : 0u, 0);
+        }, hwnd, &hPLM2))
+            return 1;
+    }
+
+    // Main message loop
+    MSG msg = {};
+    while (WM_QUIT != msg.message)
+    {
+        if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
+        {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+        else
+        {
+            g_sample->Tick();
+        }
+    }
+
+    g_sample.reset();
+
+    UnregisterAppStateChangeNotification(hPLM);
+    UnregisterAppConstrainedChangeNotification(hPLM2);
+
+    CloseHandle(g_plmSuspendComplete);
+    CloseHandle(g_plmSignalResume);
+    
+    XGameRuntimeUninitialize();
+
+    CoUninitialize();
+
+    return static_cast<int>(msg.wParam);
+}
+
+// Windows procedure
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    auto sample = reinterpret_cast<Sample*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
+
+    switch (message)
+    {
+    case WM_USER:
+        if (sample)
+        {
+            sample->OnSuspending();
+
+            // Complete deferral
+            SetEvent(g_plmSuspendComplete);
+
+            (void)WaitForSingleObject(g_plmSignalResume, INFINITE);
+
+            SetDisplayMode();
+
+            sample->OnResuming();
+        }
+        break;
+
+    case WM_USER + 1:
+        if (sample)
+        {
+            if (wParam)
+            {
+                sample->OnConstrained();
+            }
+            else
+            {
+                SetDisplayMode();
+
+                sample->OnUnConstrained();
+            }
+        }
+        break;
+    }
+
+    return DefWindowProc(hWnd, message, wParam, lParam);
+}
+
+// HDR helper
+void SetDisplayMode() noexcept
+{
+    if (g_sample && g_sample->RequestHDRMode())
+    {
+        // Request HDR mode.
+        auto result = XDisplayTryEnableHdrMode(XDisplayHdrModePreference::PreferHdr, nullptr);
+
+        g_HDRMode = (result == XDisplayHdrModeResult::Enabled);
+
+#ifdef _DEBUG
+        OutputDebugStringA((g_HDRMode) ? "INFO: Display in HDR Mode\n" : "INFO: Display in SDR Mode\n");
+#endif
+    }
+}
+
+// Exit helper
+void ExitSample() noexcept
+{
+    PostQuitMessage(0);
+}
diff --git a/Samples/Graphics/FramePacing/Menu.h b/Samples/Graphics/FramePacing/Menu.h
new file mode 100644
index 00000000..a70a8908
--- /dev/null
+++ b/Samples/Graphics/FramePacing/Menu.h
@@ -0,0 +1,385 @@
+//--------------------------------------------------------------------------------------
+// Menu.h
+//
+// A menu UI implementation, used to control the simulated CPU/GPU spikes in this sample.
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "ControllerFont.h"
+#include "Utility.h"
+
+namespace FramePacingUtils
+{
+    // Base class for various types of menu items
+    class UIParam
+    {
+    public:
+        static constexpr DirectX::XMVECTORF32 c_activeParamColor = {{{ 0.8588235294f, 0.2862745098f, 0.1098039215f, 1.0f }}};
+        static constexpr DirectX::XMVECTORF32 c_inactiveParamColor = {{{ 0.5490196078f, 0.7764705882f, 0.7803921568f, 1.0f }}};
+        static constexpr DirectX::XMVECTORF32 c_activeOptionColor = {{{ 0.8588235294f, 0.2862745098f, 0.1098039215f, 1.0f }}};
+        static constexpr DirectX::XMVECTORF32 c_inactiveOptionColor = {{{ 0.5490196078f, 0.7764705882f, 0.7803921568f, 1.0f }}};
+        static constexpr DirectX::XMVECTORF32 c_readonlyOptionColor = {{{ 0.501960814f, 0.501960814f, 0.501960814f, 1.0f }}};
+        static constexpr float c_activeParamScale = 1.0f;
+        static constexpr float c_inactiveParamScale = 1.0f;
+        static constexpr float c_optionX = 360.0f;
+        static constexpr float c_arrowsDeltaY = 5.0f;
+        static constexpr float c_leftArrowDeltaX = -45.0f;
+        static constexpr float c_rightArrowDeltaX = 155.0f;
+
+        UIParam(const wchar_t* paramName = nullptr) : m_paramName(paramName), m_status(UIParam::STATUS_DEFAULT)
+        {}
+
+        virtual ~UIParam() = default;
+
+        virtual void RenderOptionUI(DirectX::SpriteBatch* batch, DirectX::SpriteFont* font, DirectX::XMFLOAT2 position, bool isActive) = 0;
+
+        void RenderUI(DirectX::SpriteBatch* batch, DirectX::SpriteFont* font, DirectX::XMFLOAT2 position, bool isActive)
+        {
+            // Probably an uninitialized class instance if this triggers
+            assert(m_paramName);
+
+            if (isActive)
+            {
+                font->DrawString(batch, m_paramName, position, c_activeParamColor, 0.0f, { 0.0f, 0.0f }, c_activeParamScale);
+            }
+            else
+            {
+                font->DrawString(batch, m_paramName, position, c_inactiveParamColor, 0.0f, { 0.0f, 0.0f }, c_inactiveParamScale);
+            }
+            RenderOptionUI(batch, font, position, isActive);
+        }
+
+        virtual void        DecreaseValue() = 0;
+        virtual void        IncreaseValue() = 0;
+
+        enum : uint32_t
+        {
+            STATUS_DEFAULT,         // Value is user-controlled
+            STATUS_AUTO,        // Value is not user-controlled
+
+            STATUS_COUNT
+        };
+        uint32_t            GetStatus() const { return m_status; }
+        void                SetStatus(uint32_t status) { m_status = status; }
+
+    protected:
+        const wchar_t*      m_paramName;
+        uint32_t            m_status;
+    };
+
+    template< typename valType >
+    class UIParamTyped : public UIParam
+    {
+    public:
+        UIParamTyped(const wchar_t* paramName, valType value = 0, valType step = 1)
+            : UIParam(paramName)
+            , m_value(value)
+            , m_step(step)
+        {}
+
+        virtual const wchar_t* GetOptionText(wchar_t* buffer, uint32_t count) const = 0;
+
+        void RenderOptionUI(DirectX::SpriteBatch* batch, DirectX::SpriteFont* font, DirectX::XMFLOAT2 position, bool isActive) override
+        {
+            DirectX::XMVECTOR optionTextColor[2][STATUS_COUNT] =
+            {
+                {
+                    c_inactiveOptionColor,
+                    c_readonlyOptionColor,
+
+                },
+                {
+                    c_activeOptionColor,
+                    c_readonlyOptionColor,
+
+                },
+            };
+            wchar_t optionTextBuffer[256] = {};
+            const wchar_t* optionText = GetOptionText(optionTextBuffer, _countof(optionTextBuffer));
+            const wchar_t* formatText[UIParam::STATUS_COUNT] =
+            {
+                L"%ls",
+                L"%ls",
+            };
+            wchar_t selectText[256];
+            swprintf_s(selectText, formatText[m_status], optionText);
+            position.x += c_optionX;
+            font->DrawString(batch, selectText, position, optionTextColor[isActive][m_status], 0.0f, { 0.0f, 0.0f }, isActive ? c_activeParamScale : c_inactiveParamScale);
+            if (isActive)
+            {
+                position.y -= c_arrowsDeltaY;
+                position.x += c_leftArrowDeltaX;
+                font->DrawString(batch, (STATUS_AUTO == m_status) ? L"[" :L"<", position, optionTextColor[isActive][m_status], 0.0f, { 0.0f, 0.0f }, 1.2f);
+                position.x = position.x - c_leftArrowDeltaX + c_rightArrowDeltaX;
+                font->DrawString(batch, (STATUS_AUTO == m_status) ? L"]" : L">", position, optionTextColor[isActive][m_status], 0.0f, { 0.0f, 0.0f }, 1.2f);
+            }
+        }
+
+        valType             GetValue() const { return m_value; };
+        void                SetValue(valType value) { m_value = value; };
+        void                DecreaseValue() override { m_value -= m_step; }
+        void                IncreaseValue() override { m_value += m_step; }
+
+    protected:
+        valType              m_value;
+        valType              m_step;
+    };
+
+    class UIParamInt : public UIParamTyped< int >
+    {
+    public:
+        UIParamInt(const wchar_t* paramName, int min, int max, int value = 0, int step = 1, uint32_t precision = 2)
+            : UIParamTyped< int >(paramName, value, step)
+            , m_min(min)
+            , m_max(max)
+            , m_precision(precision) {}
+
+        const wchar_t* GetOptionText(wchar_t* buffer, uint32_t count) const override
+        {
+            swprintf_s(buffer, count, L"%*d", m_precision, GetValue());
+            return buffer;
+        }
+
+        void        DecreaseValue() override { m_value = std::max(m_min, m_value - m_step); }
+        void        IncreaseValue() override { m_value = std::min(m_max, m_value + m_step); }
+
+    protected:
+        int m_min;
+        int m_max;
+
+    private:
+        uint32_t m_precision;
+    };
+
+    template< typename valType >
+    class UIParamCountable : public UIParamTyped< valType >
+    {
+    public:
+        UIParamCountable(const wchar_t* paramName, const wchar_t* const* optionNames, uint32_t count, uint32_t value = 0, uint32_t step = 1)
+            : UIParamTyped<valType>(paramName, value, step)
+            , m_optionNames(optionNames)
+            , m_count(count)
+        {}
+
+        const wchar_t* GetOptionText(wchar_t*, uint32_t) const override
+        {
+            return m_optionNames[UIParamTyped<valType>::GetValue()];
+        }
+
+        void        DecreaseValue() override { UIParamTyped<valType>::m_value += m_count - UIParamTyped<valType>::m_step;    UIParamTyped<valType>::m_value %= m_count; }
+        void        IncreaseValue() override { UIParamTyped<valType>::m_value += UIParamTyped<valType>::m_step;              UIParamTyped<valType>::m_value %= m_count; }
+
+    protected:
+        const wchar_t* const*   m_optionNames;
+        uint32_t                m_count;
+    };
+
+    using UIParamEnum = UIParamCountable<uint32_t>;
+
+    class UIParamFloat : public UIParamTyped< float >
+    {
+    public:
+        UIParamFloat(const wchar_t* paramName, float value = 0, float step = 1, uint32_t precision = 2)
+            : UIParamTyped< float >(paramName, value, step)
+            , m_precision(precision)
+        {}
+
+        const wchar_t* GetOptionText(wchar_t* buffer, uint32_t count) const override
+        {
+            swprintf_s(buffer, count, L"%*.*f", m_precision, m_precision, GetValue());
+            return buffer;
+        }
+
+    private:
+        uint32_t m_precision;
+    };
+
+    //-------------------------------------------------------------------------------------------------------------------------------------
+    // Supported tweakable UI parameters.     
+    //-------------------------------------------------------------------------------------------------------------------------------------
+    enum : uint32_t
+    {
+        UI_PARAM_FRAME_LOAD_SEQUENCE,
+
+        UI_PARAM_CPU_UPDATE_LOAD,
+        UI_PARAM_CPU_RENDER_LOAD,
+        UI_PARAM_CPU_TO_GPU_LAG,
+        UI_PARAM_GPU_GRAPHICS_LOAD,
+        UI_PARAM_GPU_COMPUTE_LOAD,
+
+        UI_PARAM_FRAME_RATE,
+        UI_PARAM_FRAME_THRESHOLD,
+        UI_PARAM_FRAME_PERIOD,
+        UI_PARAM_FRAME_BUFFERS,
+        UI_PARAM_FRAME_OFFSET,
+
+        UI_PARAM_COUNT
+    };
+
+    struct Menu
+    {
+        Menu()
+            : m_useBigMenu(true)
+            , m_processInput(true)
+            , m_activeUIParameter(0)
+            , m_visibleUIStart(0)
+            , m_visibleUICount(UI_PARAM_COUNT)
+        {
+            m_params[UI_PARAM_FRAME_LOAD_SEQUENCE] = new UIParamEnum(L"Auto Frame Load", c_frameLoadSequenceNames, _countof(c_frameLoadSequenceNames));
+
+            m_params[UI_PARAM_CPU_UPDATE_LOAD] = new UIParamFloat(L"CPU Update (ms)", 10.0f);
+            m_params[UI_PARAM_CPU_RENDER_LOAD] = new UIParamFloat(L"CPU Render (ms)", 12.0f);
+            m_params[UI_PARAM_CPU_TO_GPU_LAG] = new UIParamFloat(L"CPU To GPU Lag (ms)", 2.0f);
+            m_params[UI_PARAM_GPU_GRAPHICS_LOAD] = new UIParamFloat(L"GPU Graphics (ms)", 15.0f);
+            m_params[UI_PARAM_GPU_COMPUTE_LOAD] = new UIParamFloat(L"GPU Compute (ms)", 3.0f);
+
+            m_params[UI_PARAM_FRAME_RATE] = new UIParamEnum(L"Frame Rate", c_frameRateNames, _countof(c_frameRateNames), 1, 2); // skip 120/40 fps for now
+            m_params[UI_PARAM_FRAME_THRESHOLD] = new UIParamInt(L"Frame Threshold (%)", 0, 100, 0, 10);
+            m_params[UI_PARAM_FRAME_PERIOD] = new UIParamInt(L"Frame Period", 1, 3, 2);
+            m_params[UI_PARAM_FRAME_BUFFERS] = new UIParamInt(L"Frame Buffers", 2, 4, 3);
+            m_params[UI_PARAM_FRAME_OFFSET] = new UIParamFloat(L"Frame Offset (ms)", 0.0f, 1.0f);
+        }
+
+        ~Menu()
+        {
+            for (auto param = 0U; param < UI_PARAM_COUNT; ++param)
+            {
+                delete m_params[param];
+            }
+        }
+
+        template< typename valType >
+        inline valType GetItemValue(uint32_t itemNum) const
+        {
+            return dynamic_cast<const UIParamTyped< valType >*>(m_params[itemNum])->GetValue();
+        }
+        template< typename valType >
+        inline void SetItemValue(uint32_t itemNum, valType value)
+        {
+            dynamic_cast<UIParamTyped< valType >*>(m_params[itemNum])->SetValue(value);
+        }
+        inline uint32_t GetItemStatus(uint32_t itemNum)
+        {
+            return m_params[itemNum]->GetStatus();
+        }
+        inline void SetItemStatus(uint32_t itemNum, uint32_t status)
+        {
+            m_params[itemNum]->SetStatus(status);
+        }
+        inline void DecreaseItemValue(uint32_t itemNum)
+        {
+            m_params[itemNum]->DecreaseValue();
+        }
+        inline void IncreaseItemValue(uint32_t itemNum)
+        {
+            m_params[itemNum]->IncreaseValue();
+        }
+
+        void Update(const DirectX::GamePad::ButtonStateTracker& input)
+        {
+            if (m_processInput)
+            {
+                using ButtonState = DirectX::GamePad::ButtonStateTracker::ButtonState;
+
+                float decreaseAmount = 0.0f;
+                float increaseAmount = 0.0f;
+
+                // Process UI Input
+                if (input.dpadUp == ButtonState::PRESSED || input.leftStickUp == ButtonState::PRESSED)
+                {
+                    m_activeUIParameter += UI_PARAM_COUNT - 1;
+                    m_activeUIParameter %= UI_PARAM_COUNT;
+                }
+                if (input.dpadDown == ButtonState::PRESSED || input.leftStickDown == ButtonState::PRESSED)
+                {
+                    m_activeUIParameter += 1;
+                    m_activeUIParameter %= UI_PARAM_COUNT;
+                }
+
+                // Keep the selected parameter in view, in the small menu
+                if (m_visibleUICount < UI_PARAM_COUNT)
+                {
+                    if ((m_activeUIParameter + 1) % UI_PARAM_COUNT == m_visibleUIStart)
+                    {
+                        m_visibleUIStart += UI_PARAM_COUNT - 1;
+                        m_visibleUIStart %= UI_PARAM_COUNT;
+                    }
+                    else if ((m_visibleUIStart + m_visibleUICount) % UI_PARAM_COUNT == m_activeUIParameter)
+                    {
+                        m_visibleUIStart += 1;
+                        m_visibleUIStart %= UI_PARAM_COUNT;
+                    }
+                }
+
+                if (input.dpadLeft == ButtonState::PRESSED || input.leftStickLeft == ButtonState::PRESSED)
+                    decreaseAmount = 1.0f;
+                if (input.dpadRight == ButtonState::PRESSED || input.leftStickRight == ButtonState::PRESSED)
+                    increaseAmount = 1.0f;
+
+                if (decreaseAmount > 0.0f || increaseAmount > 0.0f)
+                {
+                    if (UIParam::STATUS_AUTO != GetItemStatus(m_activeUIParameter))
+                    {
+                        if (decreaseAmount > 0.0f)
+                        {
+                            DecreaseItemValue(m_activeUIParameter);
+                        }
+                        if (increaseAmount > 0.0f)
+                        {
+                            IncreaseItemValue(m_activeUIParameter);
+                        }
+                    }
+                }
+            }
+        }
+
+        float Render(DirectX::SpriteBatch* batch, DirectX::SpriteFont* font, DirectX::SpriteFont* controllerFont, DirectX::XMFLOAT2 position)
+        {
+            float paramYInc = 30.0f;
+
+            bool useBigMenu = m_useBigMenu || UI_PARAM_COUNT <= m_visibleUICount;
+
+            uint32_t visibleUIStartIndex = useBigMenu ? 0 : m_visibleUIStart;
+            uint32_t visibleUICount = useBigMenu ? UI_PARAM_COUNT : m_visibleUICount;
+
+            if (!useBigMenu)
+            {
+                position.x += 40.0f;
+                font->DrawString(batch, L"^", position, DirectX::Colors::Magenta, 0.0f, { 0.0f, 0.0f }, 0.8f);
+                position.x += 100.0f;
+                DX::DrawControllerString(batch, font, controllerFont, L"( [B] to expand )", position, DirectX::Colors::White, 0.8f);
+                position.x -= 140.0f;
+                position.y += paramYInc;
+            }
+
+            for (uint32_t i = 0; i < visibleUICount; ++i)
+            {
+                uint32_t paramIndex = (visibleUIStartIndex + i) % UI_PARAM_COUNT;
+
+                UIParam* param = m_params[paramIndex];
+
+                param->RenderUI(batch, font, position, (paramIndex == m_activeUIParameter));
+                position.y += paramYInc;
+            }
+
+            if (!useBigMenu)
+            {
+                font->DrawString(batch, L"v", position, DirectX::Colors::Magenta, 0.0f, { 0.0f, 0.0f }, 0.8f);
+                position.y += paramYInc;
+            }
+
+            return position.y;
+        }
+
+        UIParam*                    m_params[UI_PARAM_COUNT];
+        bool                        m_useBigMenu;
+        bool                        m_processInput;
+        uint32_t                    m_activeUIParameter;   // Which UI item is affected by l/r input
+        uint32_t                    m_visibleUIStart;
+        uint32_t                    m_visibleUICount;
+    };
+} // namespace FramePacingUtils
diff --git a/Samples/Graphics/FramePacing/MicrosoftGameConfig.mgc b/Samples/Graphics/FramePacing/MicrosoftGameConfig.mgc
new file mode 100644
index 00000000..b24b083e
--- /dev/null
+++ b/Samples/Graphics/FramePacing/MicrosoftGameConfig.mgc
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="0">
+  <!-- Version "1" is supported by March 2022 GDK or later -->
+
+  <Identity Name="9901eba7-174b-452f-8815-e045522330c5"
+            Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US"
+            Version="1.0.0.0"/>
+  
+  <ExecutableList>
+    <Executable Name="FramePacing.exe"
+                Id="Game"/>
+  </ExecutableList>
+
+  
+  <ShellVisuals DefaultDisplayName="FramePacing"
+                PublisherDisplayName="Xbox Advanced Technology Group"
+                StoreLogo="Assets\StoreLogo.png"
+                Square480x480Logo="Assets\LargeLogo.png"
+                Square150x150Logo="Assets\Logo.png"
+                Square44x44Logo="Assets\SmallLogo.png"
+                Description="FramePacing"
+                ForegroundText="dark"
+                BackgroundColor="#000000"
+                SplashScreenImage="Assets\SplashScreen.png"/>
+</Game>
diff --git a/Samples/Graphics/FramePacing/StepTimer.h b/Samples/Graphics/FramePacing/StepTimer.h
new file mode 100644
index 00000000..bb15fffa
--- /dev/null
+++ b/Samples/Graphics/FramePacing/StepTimer.h
@@ -0,0 +1,190 @@
+//
+// StepTimer.h - A simple timer that provides elapsed time information
+//
+
+#pragma once
+
+#include <cmath>
+#include <cstdint>
+#include <exception>
+
+
+namespace DX
+{
+    // Helper class for animation and simulation timing.
+    class StepTimer
+    {
+    public:
+        StepTimer() noexcept(false) :
+            m_elapsedTicks(0),
+            m_totalTicks(0),
+            m_leftOverTicks(0),
+            m_frameCount(0),
+            m_framesPerSecond(0),
+            m_framesThisSecond(0),
+            m_qpcSecondCounter(0),
+            m_isFixedTimeStep(false),
+            m_targetElapsedTicks(TicksPerSecond / 60)
+        {
+            if (!QueryPerformanceFrequency(&m_qpcFrequency))
+            {
+                throw std::exception();
+            }
+
+            if (!QueryPerformanceCounter(&m_qpcLastTime))
+            {
+                throw std::exception();
+            }
+
+            // Initialize max delta to 1/10 of a second.
+            m_qpcMaxDelta = static_cast<uint64_t>(m_qpcFrequency.QuadPart / 10);
+        }
+
+        // Get elapsed time since the previous Update call.
+        uint64_t GetElapsedTicks() const noexcept { return m_elapsedTicks; }
+        double GetElapsedSeconds() const noexcept { return TicksToSeconds(m_elapsedTicks); }
+
+        // Get total time since the start of the program.
+        uint64_t GetTotalTicks() const noexcept { return m_totalTicks; }
+        double GetTotalSeconds() const noexcept { return TicksToSeconds(m_totalTicks); }
+
+        // Get total number of updates since start of the program.
+        uint32_t GetFrameCount() const noexcept { return m_frameCount; }
+
+        // Get the current framerate.
+        uint32_t GetFramesPerSecond() const noexcept { return m_framesPerSecond; }
+
+        // Set whether to use fixed or variable timestep mode.
+        void SetFixedTimeStep(bool isFixedTimestep) noexcept { m_isFixedTimeStep = isFixedTimestep; }
+
+        // Set how often to call Update when in fixed timestep mode.
+        void SetTargetElapsedTicks(uint64_t targetElapsed) noexcept { m_targetElapsedTicks = targetElapsed; }
+        void SetTargetElapsedSeconds(double targetElapsed) noexcept { m_targetElapsedTicks = SecondsToTicks(targetElapsed); }
+
+        // Integer format represents time using 10,000,000 ticks per second.
+        static constexpr uint64_t TicksPerSecond = 10000000;
+
+        static constexpr double TicksToSeconds(uint64_t ticks) noexcept { return static_cast<double>(ticks) / TicksPerSecond; }
+        static constexpr uint64_t SecondsToTicks(double seconds) noexcept { return static_cast<uint64_t>(seconds * TicksPerSecond); }
+
+        // After an intentional timing discontinuity (for instance a blocking IO operation)
+        // call this to avoid having the fixed timestep logic attempt a set of catch-up
+        // Update calls.
+
+        void ResetElapsedTime()
+        {
+            if (!QueryPerformanceCounter(&m_qpcLastTime))
+            {
+                throw std::exception();
+            }
+
+            m_leftOverTicks = 0;
+            m_framesPerSecond = 0;
+            m_framesThisSecond = 0;
+            m_qpcSecondCounter = 0;
+        }
+
+        // Update timer state, calling the specified Update function the appropriate number of times.
+        template<typename TUpdate>
+        void Tick(const TUpdate& update)
+        {
+            // Query the current time.
+            LARGE_INTEGER currentTime;
+
+            if (!QueryPerformanceCounter(&currentTime))
+            {
+                throw std::exception();
+            }
+
+            uint64_t timeDelta = static_cast<uint64_t>(currentTime.QuadPart - m_qpcLastTime.QuadPart);
+
+            m_qpcLastTime = currentTime;
+            m_qpcSecondCounter += timeDelta;
+
+            // Clamp excessively large time deltas (e.g. after paused in the debugger).
+            if (timeDelta > m_qpcMaxDelta)
+            {
+                timeDelta = m_qpcMaxDelta;
+            }
+
+            // Convert QPC units into a canonical tick format. This cannot overflow due to the previous clamp.
+            timeDelta *= TicksPerSecond;
+            timeDelta /= static_cast<uint64_t>(m_qpcFrequency.QuadPart);
+
+            uint32_t lastFrameCount = m_frameCount;
+
+            if (m_isFixedTimeStep)
+            {
+                // Fixed timestep update logic
+
+                // If the app is running very close to the target elapsed time (within 1/4 of a millisecond) just clamp
+                // the clock to exactly match the target value. This prevents tiny and irrelevant errors
+                // from accumulating over time. Without this clamping, a game that requested a 60 fps
+                // fixed update, running with vsync enabled on a 59.94 NTSC display, would eventually
+                // accumulate enough tiny errors that it would drop a frame. It is better to just round
+                // small deviations down to zero to leave things running smoothly.
+
+                if (static_cast<uint64_t>(std::abs(static_cast<int64_t>(timeDelta - m_targetElapsedTicks))) < TicksPerSecond / 4000)
+                {
+                    timeDelta = m_targetElapsedTicks;
+                }
+
+                m_leftOverTicks += timeDelta;
+
+                while (m_leftOverTicks >= m_targetElapsedTicks)
+                {
+                    m_elapsedTicks = m_targetElapsedTicks;
+                    m_totalTicks += m_targetElapsedTicks;
+                    m_leftOverTicks -= m_targetElapsedTicks;
+                    m_frameCount++;
+
+                    update();
+                }
+            }
+            else
+            {
+                // Variable timestep update logic.
+                m_elapsedTicks = timeDelta;
+                m_totalTicks += timeDelta;
+                m_leftOverTicks = 0;
+                m_frameCount++;
+
+                update();
+            }
+
+            // Track the current framerate.
+            if (m_frameCount != lastFrameCount)
+            {
+                m_framesThisSecond++;
+            }
+
+            if (m_qpcSecondCounter >= static_cast<uint64_t>(m_qpcFrequency.QuadPart))
+            {
+                m_framesPerSecond = m_framesThisSecond;
+                m_framesThisSecond = 0;
+                m_qpcSecondCounter %= static_cast<uint64_t>(m_qpcFrequency.QuadPart);
+            }
+        }
+
+    private:
+        // Source timing data uses QPC units.
+        LARGE_INTEGER m_qpcFrequency;
+        LARGE_INTEGER m_qpcLastTime;
+        uint64_t m_qpcMaxDelta;
+
+        // Derived timing data uses a canonical tick format.
+        uint64_t m_elapsedTicks;
+        uint64_t m_totalTicks;
+        uint64_t m_leftOverTicks;
+
+        // Members for tracking the framerate.
+        uint32_t m_frameCount;
+        uint32_t m_framesPerSecond;
+        uint32_t m_framesThisSecond;
+        uint64_t m_qpcSecondCounter;
+
+        // Members for configuring fixed timestep mode.
+        bool m_isFixedTimeStep;
+        uint64_t m_targetElapsedTicks;
+    };
+}
diff --git a/Samples/Graphics/FramePacing/Time.hlsli b/Samples/Graphics/FramePacing/Time.hlsli
new file mode 100644
index 00000000..182de7ca
--- /dev/null
+++ b/Samples/Graphics/FramePacing/Time.hlsli
@@ -0,0 +1,19 @@
+//--------------------------------------------------------------------------------------
+// File: Time.hlsli
+//
+// Helpers for reading the real-time GPU clock used by the artificial workloads.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+struct Time
+{
+    uint64_t startTime;
+    uint64_t currentTime;
+};
+
+uint64_t GetTimeStamp()
+{
+    uint2 memtime = __XB_MemTime();
+    return ((uint64_t)memtime.y << 32) | memtime.x;
+}
diff --git a/Samples/Graphics/FramePacing/Utility.h b/Samples/Graphics/FramePacing/Utility.h
new file mode 100644
index 00000000..0c1bfefa
--- /dev/null
+++ b/Samples/Graphics/FramePacing/Utility.h
@@ -0,0 +1,119 @@
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "DirectXMath.h"
+
+namespace FramePacingUtils
+{
+    template<typename T>
+    inline T Saturate(T value, T minimum, T maximum)
+    {
+        return std::clamp(value, minimum, maximum);
+    }
+
+    inline float Saturate(float value, float minimum = 0.0f, float maximum = 1.0f)
+    {
+        return Saturate<float>(value, minimum, maximum);
+    }
+
+    enum class FrameRate : uint32_t
+    {
+        Fps120,
+        Fps60,
+        Fps40,
+        Fps30,
+
+        Count
+    };
+
+    inline constexpr const wchar_t* c_frameRateNames[] =
+    {
+        L"120 fps",
+        L"60 fps",
+        L"40 fps",
+        L"30 fps",
+    };
+    static_assert(_countof(c_frameRateNames) == static_cast<uint32_t>(FrameRate::Count), "Mismatch between enum and reflected names");
+
+    enum class FrameLoadSequenceType : uint32_t
+    {
+        GpuSawtooth,
+        GpuJitter,
+        GpuGlitch,
+        GpuSpike,
+
+        Count
+    };
+    inline constexpr const wchar_t* c_frameLoadSequenceNames[] =
+    {
+        L"Gpu Sawtooth",
+        L"Gpu Jitter",
+        L"Gpu Glitch",
+        L"Gpu Spike",
+    };
+    static_assert(_countof(c_frameLoadSequenceNames) == static_cast<uint32_t>(FrameLoadSequenceType::Count), "Mismatch between enum and reflected names");
+    inline constexpr const wchar_t* c_frameLoadSequenceFileNames[] =
+    {
+        L"GpuSawtooth",
+        L"GpuJitter",
+        L"GpuGlitch",
+        L"GpuSpike",
+    };
+    static_assert(_countof(c_frameLoadSequenceFileNames) == static_cast<uint32_t>(FrameLoadSequenceType::Count), "Mismatch between enum and reflected names");
+
+    // Convenience class for a ring buffer (assumes you only add using push_back or push_front)
+    template<typename T, uint32_t ringSize>
+    class Ring : public std::deque<T>
+    {
+    public:
+        void push_back(const T& element)
+        {
+            if (std::deque<T>::size() == ringSize)
+            {
+                std::deque<T>::pop_front();
+            }
+            std::deque<T>::push_back(element);
+        }
+
+        void push_front(const T& element)
+        {
+            if (std::deque<T>::size() == ringSize)
+            {
+                std::deque<T>::pop_back();
+            }
+            std::deque<T>::push_front(element);
+        }
+    };
+
+    // Frame statistics tracked to monitor frame rate, latency, etc.
+    struct FrameStatistics
+    {
+        D3D12XBOX_FRAME_INTERVAL_STATISTICS interval;
+        D3D12XBOX_FRAME_EVENT_STATISTICS origin;
+        D3D12XBOX_RENDER_STATISTICS render;
+        D3D12XBOX_PRESENT_STATISTICS present;
+        D3D12XBOX_DISPLAY_STATISTICS display;
+    };
+
+    // History of frame timestamps
+    struct FrameTimestamps
+    {
+        uint32_t                                    m_frameBuffer;
+
+        // Need an anchor time, to align all the graphs to a single start point
+        uint64_t                                    m_flipTime;
+
+        LARGE_INTEGER                               m_startCpuUpdate;
+        LARGE_INTEGER                               m_stopCpuUpdate;
+        LARGE_INTEGER                               m_startCpuRender;
+        LARGE_INTEGER                               m_stopCpuRender;
+        uint64_t                                    m_startGpuGraphics;
+        uint64_t                                    m_stopGpuGraphics;
+        uint64_t                                    m_startGpuCompute;
+        uint64_t                                    m_stopGpuCompute;
+    };
+} // namespace FramePacingUtils
diff --git a/Samples/Graphics/FramePacing/pch.cpp b/Samples/Graphics/FramePacing/pch.cpp
new file mode 100644
index 00000000..fb58e703
--- /dev/null
+++ b/Samples/Graphics/FramePacing/pch.cpp
@@ -0,0 +1,10 @@
+//--------------------------------------------------------------------------------------
+// pch.cpp
+//
+// Include the standard header and generate the precompiled header.
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#include "pch.h"
diff --git a/Samples/Graphics/FramePacing/pch.h b/Samples/Graphics/FramePacing/pch.h
new file mode 100644
index 00000000..ae533fb5
--- /dev/null
+++ b/Samples/Graphics/FramePacing/pch.h
@@ -0,0 +1,122 @@
+//--------------------------------------------------------------------------------------
+// pch.h
+//
+// Header for standard system include files.
+//
+// Advanced Technology Group (ATG)
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <winsdkver.h>
+#define _WIN32_WINNT 0x0A00
+#include <sdkddkver.h>
+
+// Use the C++ standard templated min/max
+#define NOMINMAX
+
+// DirectX apps don't need GDI
+#define NODRAWTEXT
+#define NOGDI
+#define NOBITMAP
+
+// Include <mcx.h> if you need this
+#define NOMCX
+
+// Include <winsvc.h> if you need this
+#define NOSERVICE
+
+// WinHelp is deprecated
+#define NOHELP
+
+#include <Windows.h>
+
+#include <wrl/client.h>
+#include <wrl/event.h>
+
+#include <gxdk.h>
+
+#if _GXDK_VER < 0x65F40752 /* GDK Edition 241000 */
+#error This sample requires the October 2024 GDK or later
+#endif
+
+#ifdef _GAMING_XBOX_SCARLETT
+#include <d3d12_xs.h>
+#include <d3dx12_xs.h>
+#else
+#include <d3d12_x.h>
+#include <d3dx12_x.h>
+#endif
+
+#define _XM_NO_XMVECTOR_OVERLOADS_
+
+#include <DirectXMath.h>
+#include <DirectXColors.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <cwchar>
+#include <exception>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <stdexcept>
+#include <string>
+#include <system_error>
+#include <vector>
+
+#include <pix3.h>
+#include <XGame.h>
+#include <XSystem.h>
+
+#include "GamePad.h"
+#include "GraphicsMemory.h"
+#include "RenderTargetState.h"
+
+#include "UITK.h"
+
+namespace DX
+{
+    // Helper class for COM exceptions
+    class com_exception : public std::exception
+    {
+    public:
+        com_exception(HRESULT hr) noexcept : result(hr) {}
+
+        const char* what() const override
+        {
+            static char s_str[64] = {};
+            sprintf_s(s_str, "Failure with HRESULT of %08X", static_cast<unsigned int>(result));
+            return s_str;
+        }
+
+    private:
+        HRESULT result;
+    };
+
+    // Helper utility converts D3D API failures into exceptions.
+    inline void ThrowIfFailed(HRESULT hr)
+    {
+        if (FAILED(hr))
+        {
+#ifdef _DEBUG
+            char str[64] = {};
+            sprintf_s(str, "**ERROR** Fatal Error with HRESULT of %08X\n", static_cast<unsigned int>(hr));
+            OutputDebugStringA(str);
+            __debugbreak();
+#endif
+            throw com_exception(hr);
+        }
+    }
+}
+
+// Enable off by default warnings to improve code conformance
+#pragma warning(default : 4061 4062 4191 4242 4263 4264 4265 4266 4289 4365 4746 4826 4841 4986 4987 5029 5038 5042)
diff --git a/Samples/Graphics/FramePacing/readme.md b/Samples/Graphics/FramePacing/readme.md
new file mode 100644
index 00000000..dd3ffb04
--- /dev/null
+++ b/Samples/Graphics/FramePacing/readme.md
@@ -0,0 +1,102 @@
+<!-----
+---
+page_type: sample
+languages:
+- cpp
+products:
+- gdk
+urlFragment: "framepacing"
+extendedZipContent:
+- path: LICENSE
+  target: LICENSE
+- path: Kits
+  target: Kits
+- path: Media
+  target: Media
+description: "This sample demonstrates how CPU work, GPU work, swap chain buffers, and Xbox frame scheduling interact to affect frame rate, latency, and presentation margin."
+---
+----->
+
+# Frame Pacing Sample
+
+*This sample requires the Microsoft Game Development Kit with Xbox Extensions
+(October 2024 or later).*
+
+# Description
+
+FramePacing demonstrates how CPU work, GPU work, swap chain buffers, and Xbox frame
+scheduling interact to affect frame rate, latency, and presentation margin.
+The sample can apply configurable artificial workloads to the update,
+rendering, graphics, and compute stages, then visualize the resulting frame
+pipeline with line and interval graphs.
+
+The controls support both manual experimentation and automatic modes. Automatic
+frame loads replay sawtooth, jitter, glitch, and spike sequences. Automatic
+pacing uses recent frame statistics to select a frame period, buffer count, and
+frame-event offset for the selected target rate.
+
+# Building the sample
+
+The sample requires Visual Studio 2022, the `v143` toolset, and a current GDK
+with Xbox Extensions.
+
+For Xbox One, set the active solution platform to
+`Gaming.Xbox.XboxOne.x64`.
+
+For Xbox Series X|S, set the active solution platform to
+`Gaming.Xbox.Scarlett.x64`.
+
+*For more information, see* **Running samples** *in the GDK documentation.*
+
+# Controls
+
+| Action | Gamepad |
+|---|---|
+| Select a setting | D-pad or left stick Up/Down |
+| Change the selected setting | D-pad or left stick Left/Right |
+| Toggle automatic frame pacing | A |
+| Toggle automatic frame loads | X |
+| Pause graph updates | B |
+| Zoom graph history | Left/Right trigger |
+| Pan graph history | Right stick Left/Right |
+| Exit | View |
+
+
+# Implementation notes
+
+`ID3D12Device::SetFrameIntervalX` sets the target frame interval and period.
+`ID3D12Device::ScheduleFrameEventX` and `WaitFrameEventX` schedule and wait for
+the frame origin. Each frame carries a `D3D12XBOX_FRAME_PIPELINE_TOKEN` through
+update, graphics, compute, and `PresentX`.
+
+The sample submits timestamp queries on both graphics and compute queues and
+correlates them with `GetFrameStatisticsX`. The resulting data drives the
+frame-time, latency, margin, CPU, GPU, and flip graphs. Artificial workloads
+exist only to make pacing behavior and missed budgets easy to reproduce.
+
+The automatic pacing mode is illustrative rather than a production policy.
+Games should choose thresholds and safety margins using their own workload,
+latency goals, supported displays, and quality strategy.
+
+The **Frame Threshold (%)** menu option is passed to `PresentX` as
+`ImmediateThresholdPercent`. When a frame finishes late, the runtime displays
+it immediately only if scanout has not passed that percentage of the screen.
+A threshold of 0 disables limited tearing, while 100 permits a late flip
+anywhere during scanout.
+
+The tear indicator shows `PercentScanned` from the display statistics for the
+latest completed frame. A value of 0% is a VBlank-aligned flip with no visible
+tear. To demonstrate limited tearing, increase **Frame Threshold (%)** above
+zero and use a frame-load sequence that occasionally exceeds the frame budget.
+The indicator then moves to the scan position where the late frame was
+displayed.
+
+# Privacy Statement
+
+When compiling and running a sample, the file name of the sample executable
+will be sent to Microsoft to help track sample usage. To opt out of this data
+collection, remove the block of code in `Main.cpp` labeled "Sample Usage
+Telemetry".
+
+For more information, see the
+[Microsoft Privacy Statement](https://privacy.microsoft.com/privacystatement/).
diff --git a/gdk-samples-list.md b/gdk-samples-list.md
index 3e6d21b5..1edd0c71 100644
--- a/gdk-samples-list.md
+++ b/gdk-samples-list.md
@@ -57,6 +57,7 @@ Following is a list of categories for the samples.
 | __DynamicLOD__ | This sample demonstrates how to leverage amplification shaders to do per-instance frustum culling and mesh level-of-detail (LOD) selection entirely on the GPU for an arbitrary number of instances on Xbox Series X\|S and PC. | ✓ | ✓ | 
 | __ExecuteIndirect__ | This sample demonstrates usage of DirectX 12's ExecuteIndirect API for asynchronously building rendering commands. | ✓ |  | 
 | __FastBlockCompress__ | This sample demonstrates how you can use DirectCompute to perform fast texture compression at run time to the BC1, BC3, and BC5 formats based on the classic Fast Block Compression algorithm on Xbox. | ✓ |  | 
+| __FramePacing__ | This sample demonstrates how CPU work, GPU work, swap chain buffers, and Xbox frame scheduling interact to affect frame rate, latency, and presentation margin. | ✓ |  | 
 | __GeometricExpansion__ | This sample demonstrates the geometric expansion capabilities of mesh shaders for Xbox Series X\|S and PC. | ✓ | ✓ | 
 | __HDR10__ | Switch a UHD TV into HDR mode and render a HDR10 scene with values higher than 1.0f, which will be displayed as brighter than white on a UHD TV using DirectX 12 on Xbox. | ✓ |  | 
 | __HDRCalibration__ | This sample switches an HDR TV to HDR mode and then presents the user with several calibration options to adjust the visible detail in brights and darks, the overall brightness and color saturation of the image. | ✓ |  |