DurangoXDK=C:\Program Files (x86)\Microsoft Durango XDK\
XboxOneXDKLatest=C:\Program Files (x86)\Microsoft Durango XDK\170614\
XboxOneExtensionSDKLatest=C:\Program Files (x86)\Microsoft SDKs\Durango.170614\v8.0\

GameDK=C:\Program Files (x86)\Microsoft GDK\
GameDKLatest=C:\Program Files (x86)\Microsoft GDK\build_number\

// 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>

int WINAPI wWinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR lpCmdLine,
    _In_ int nCmdShow)
{
...

int __cdecl main(Platform::Array<Platform::String^>^ /*argv*/)
{
    auto viewProviderFactory = ref new ViewProviderFactory();
    CoreApplication::Run(viewProviderFactory);
    return 0;
}

int WINAPIV WinMain()
{
    winrt::init_apartment();

    ViewProviderFactory viewProviderFactory;
    CoreApplication::Run(viewProviderFactory);

    winrt::uninit_apartment();
    return 0;
}

int WINAPI wWinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR lpCmdLine,
    _In_ int nCmdShow)
{
...
}

int WINAPI wWinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR lpCmdLine,
    _In_ int nCmdShow)
{
    HRESULT hr = CoInitializeEx(nullptr, COINITBASE_MULTITHREADED);
    if (FAILED(hr))
        return 1;

    // Register a class and create a window.
    {
        // Register class
        WNDCLASSEXW wcex = {};
        wcex.cbSize = sizeof(WNDCLASSEXW);
        wcex.style = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc = WndProc;
        wcex.hInstance = hInstance;
        wcex.hIcon = LoadIconW(hInstance, L"IDI_ICON");
        wcex.hCursor = LoadCursorW(nullptr, IDC_ARROW);
        wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
        wcex.lpszClassName = L"MyGameWindowClass";
        wcex.hIconSm = LoadIconW(wcex.hInstance, L"IDI_ICON");
        if (!RegisterClassExW(&wcex))
            return 1;

        // Create a window.
        RECT rc = { 0, 0, static_cast<LONG>(1280), static_cast<LONG>(720) };

        AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);

        HWND hwnd = CreateWindowExW(0, L"MyGameWindowClass", L"My Game",
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT, CW_USEDEFAULT,
            rc.right - rc.left, rc.bottom - rc.top, nullptr, nullptr, hInstance,
            nullptr);
        if (!hwnd)
            return 1;

        ShowWindow(hwnd, nCmdShow);

        SetWindowLongPtr(hwnd, GWLP_USERDATA, /* some object */ );

        GetClientRect(hwnd, &rc);

        // Initialize a device and more by using rc as the "real" size of the swap chain.
    }

    // Main message loop.
    MSG msg = {};
    while (WM_QUIT != msg.message)
    {
        if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            // Update and Render
        }
    }

    CoUninitialize();

    return static_cast<int>(msg.wParam);
}

int WINAPI wWinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR lpCmdLine,
    _In_ int nCmdShow)
{
    // Initialize the Game Runtime APIs.
    if (FAILED(InitializeGameRuntime())) // Function in GameRuntimeInit.h
        return 1;

    // Register a class and create a window.
    {
        // Register class
        WNDCLASSEXA wcex = {};
        wcex.cbSize = sizeof(WNDCLASSEXA);
        wcex.style = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc = WndProc;
        wcex.hInstance = hInstance;
        wcex.lpszClassName = "MyGameWindowClass";
        wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
        if (!RegisterClassExA(&wcex))
            return 1;

        // Create a window.

        HWND hwnd = CreateWindowExA(0, u8"MyGameWindowClass", u8"My Game",
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT, CW_USEDEFAULT,
            1920, 1080, nullptr, nullptr, hInstance,
            nullptr);
        if (!hwnd)
            return 1;

        ShowWindow(hwnd, nCmdShow);

        SetWindowLongPtr(hwnd, GWLP_USERDATA, /* some object of type SomeClass */ );

        // Initialize a device and more.
        // Assume a swap chain of 1080p, 1440p, or 4K.
    }

    // Main message loop.
    MSG msg = {};
    while (WM_QUIT != msg.message)
    {
        if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            // Update and Render
        }
    }

    UninitializeGameRuntime();

    return static_cast<int>(msg.wParam);
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    auto appPtr = reinterpret_cast<SomeClass*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));

    switch (message)
    {
    case WM_CREATE:
        break;

    case WM_ACTIVATEAPP:
        break;

    // WM_USER messages the application posts to itself.

    return DefWindowProc(hWnd, message, wParam, lParam);
}

ComPtr<ID3D12Device> device;

...

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<UINT>(D3D12XBOX_DEFAULT_SIZE_BYTES);
params.GraphicsScratchMemorySizeBytes = static_cast<UINT>(D3D12XBOX_DEFAULT_SIZE_BYTES);
params.ComputeScratchMemorySizeBytes = static_cast<UINT>(D3D12XBOX_DEFAULT_SIZE_BYTES);

ThrowIfFailed(D3D12XboxCreateDevice(
    nullptr,
    &params,
    IID_GRAPHICS_PPV_ARGS(device.GetAddressOf())
    ));

RECT outputSize = { 0, 0, 1920, 1080 };
switch (XSystemGetDeviceType())
{
case XSystemDeviceType::XboxOne:
case XSystemDeviceType::XboxOneS:
    break;

case XSystemDeviceType::XboxScarlettLockhart /* Xbox Series S */:
    outputSize = { 0, 0, 2560, 1440 };
    break;

case XSystemDeviceType::XboxScarlettAnaconda /* Xbox Series X */:
case XSystemDeviceType::XboxOneXDevkit:
case XSystemDeviceType::XboxScarlettDevkit:
default:
   outputSize = { 0, 0, 3840, 2160 };
   break;
}

D3D11X_VIRTUAL_MEMORY_CONFIGURATION vmConfig = {};
vmConfig.PageTableMemory4MBPageCount = 5;
ThrowIfFailed(
      D3DConfigureVirtualMemory(&VMConfig)
    );

<mx:Extension Category="xbox.system.resources">
  <mx:XboxSystemResources resourceConfiguration="extended">
    <mx:GpuAvailability>variable</mx:GpuAvailability>
  </mx:XboxSystemResources>
</mx:Extension>

// First, retrieve the underlying DXGI device from the D3D device.
ComPtr<IDXGIDevice1> dxgiDevice;
ThrowIfFailed(device.As(&dxgiDevice));

// Identify the physical adapter (GPU or card) that this device is running on.
ComPtr<IDXGIAdapter> dxgiAdapter;
ThrowIfFailed(dxgiDevice->GetAdapter(dxgiAdapter.GetAddressOf()));

// Retrieve the outputs for the adapter.
ComPtr<IDXGIOutput> dxgiOutput;
ThrowIfFailed(dxgiAdapter->EnumOutputs(0, dxgiOutput.GetAddressOf()));

// Set the frame interval, and register for frame events.
ThrowIfFailed(device->SetFrameIntervalX(
    dxgiOutput.Get(),
    D3D12XBOX_FRAME_INTERVAL_60_HZ,
    2 /* Allow 2 frames of latency */,
    D3D12XBOX_FRAME_INTERVAL_FLAG_NONE));

ThrowIfFailed(device->ScheduleFrameEventX(
    D3D12XBOX_FRAME_EVENT_ORIGIN,
    0U,
    nullptr,
    D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAG_NONE));

ComPtr<ID3D12Resource> renderTargets[MAX_BACK_BUFFER_COUNT];

...

CD3DX12_HEAP_PROPERTIES swapChainHeapProperties(D3D12_HEAP_TYPE_DEFAULT);

D3D12_RESOURCE_DESC swapChainBufferDesc = CD3DX12_RESOURCE_DESC::Tex2D(
    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_CLEAR_VALUE swapChainOptimizedClearValue = {};
swapChainOptimizedClearValue.Format = backBufferFormat;

for (UINT n = 0; n < m_backBufferCount; n++)
{
    ThrowIfFailed(m_d3dDevice->CreateCommittedResource(
        &swapChainHeapProperties,
        D3D12_HEAP_FLAG_ALLOW_DISPLAY,
        &swapChainBufferDesc,
        D3D12_RESOURCE_STATE_PRESENT,
        &swapChainOptimizedClearValue,
        IID_GRAPHICS_PPV_ARGS(renderTargets[n].GetAddressOf())));

    D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = {};
    rtvDesc.Format = m_backBufferFormat;
    rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;

    CD3DX12_CPU_DESCRIPTOR_HANDLE rtvDescriptor(rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), n,
         rtvDescriptorSize);
    device->CreateRenderTargetView(renderTargets[n].Get(), &rtvDesc, rtvDescriptor);
}

D3D12XBOX_FRAME_PIPELINE_TOKEN framePipelineToken = {};

...

framePipelineToken = D3D12XBOX_FRAME_PIPELINE_TOKEN_NULL;
ThrowIfFailed(device->WaitFrameEventX(D3D12XBOX_FRAME_EVENT_ORIGIN, INFINITE, nullptr,
      D3D12XBOX_WAIT_FRAME_EVENT_FLAG_NONE, &framePipelineToken));

D3D12XBOX_PRESENT_PLANE_PARAMETERS planeParameters = {};
planeParameters.Token = framePipelineToken;
planeParameters.ResourceCount = 1;
planeParameters.ppResources = renderTargets[backBufferIndex].GetAddressOf();

ThrowIfFailed(commandQueue->PresentX(1, &planeParameters, nullptr));

FlipEvent = CreateEvent(nullptr, false, false, "DXGIXFrameFlipEvent");
VERIFYD3D12RESULT(DXGIXSetFrameNotification(FRAME_NOTIFICATION_FLIPPED, FlipEvent));

FlipEvent = CreateEventA(nullptr, false, false, u8"ScheduleFrameEventX");
D3D12XBOX_SCHEDULE_FRAME_OBJECT_LIST objList = { 1, &FlipEvent };
VERIFYD3D12RESULT(GetD3D12Device()->ScheduleFrameEventX(D3D12XBOX_FRAME_EVENT_DISPLAY_FLIP, 0, &objList, D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAG_NONE));

#include <appnotify.h>

...

PAPPSTATE_REGISTRATION hPLM = {};
HANDLE plmSuspendComplete = nullptr;
HANDLE plmSignalResume = nullptr;

...

// Create a window.

plmSuspendComplete = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
plmSignalResume = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
if (!plmSuspendComplete || !plmSignalResume)
    return 1;

if (RegisterAppStateChangeNotification([](BOOLEAN quiesced, PVOID context)
{
    if (quiesced)
    {
        ResetEvent(plmSuspendComplete);
        ResetEvent(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 suspension, we must wait to exit this callback.
        (void)WaitForSingleObject(plmSuspendComplete, INFINITE);
    }
    else
    {
        SetEvent(plmSignalResume);
    }
}, hwnd, &hPLM))
    return 1;

// Message loop.

UnregisterAppStateChangeNotification(hPLM);

CloseHandle(plmSuspendComplete);
CloseHandle(plmSignalResume);

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
...
    switch (message)
    {
    case WM_USER:
        // Call SuspendX(0) on your command queue, and cease all GPU submissions.

        // Complete deferral.
        SetEvent(plmSuspendComplete);

        (void)WaitForSingleObject(plmSignalResume, INFINITE);

        // Before picking up rendering again, call ResumeX on your command queue.

        // You'll also need to register again for frame events
        // via SetFrameIntervalX and ScheduleFrameEventX.
        break;
    }
...
}

#include <appnotify.h>

PAPPCONSTRAIN_REGISTRATION hPLM2 = {};

// Create a window.

if (RegisterAppConstrainedChangeNotification([](BOOLEAN constrained, PVOID context)
{
    SendMessage(reinterpret_cast<HWND>(context), WM_USER+1, (constrained) ? 1 : 0, 0);
}, hwnd, &hPLM2))
    return 1;

// Message loop

UnregisterAppConstrainedChangeNotification(hPLM2);

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_USER+1:
        if (wParam)
        {
          // Constrained resources mode
        }
        else
        {
          // Full resource mode
        }
        break;
    }
}

void * memPool = VirtualAlloc(nullptr,
    size,
    MEM_LARGE_PAGES | MEM_GRAPHICS | MEM_RESERVE,
    PAGE_READONLY);

void * memPool = XMemVirtualAlloc(nullptr,
    size,
    MEM_64K_PAGES | MEM_RESERVE,
    XMEM_GRAPHICS | XMEM_MAPPABLE,
    PAGE_READONLY | PAGE_GRAPHICS_COHERENT | PAGE_GRAPHICS_READWRITE);

void* memory = VirtualAlloc(nullptr,
    size,
    MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES | MEM_GRAPHICS,
    PAGE_READWRITE | PAGE_WRITECOMBINE);

void* memory = XMemVirtualAlloc(nullptr,
    size,
    MEM_RESERVE | MEM_COMMIT | MEM_64K_PAGES,
    TITLE_MEM_GRAPHICS,
    PAGE_READWRITE | PAGE_WRITECOMBINE | PAGE_GRAPHICS_READWRITE);

const uint64_t c_XMemAllocAttributes = MAKE_XALLOC_ATTRIBUTES(
    eXALLOCAllocatorId_MiddlewareReservedMin,
    0,
    XALLOC_MEMTYPE_GRAPHICS_WRITECOMBINE_GPU_READONLY,
    XALLOC_PAGESIZE_64KB,
    XALLOC_ALIGNMENT_64K);

const uint64_t c_XMemAllocAttributes = MAKE_XALLOC_ATTRIBUTES(
    eXALLOCAllocatorId_MiddlewareReservedMin,
    0,
    XALLOC_MEMTYPE_GRAPHICS_WRITECOMBINE_GPU_READONLY,
    XALLOC_PAGESIZE_64KB,
    XALLOC_ALIGNMENT_64K,
    0);

void * memPool = VirtualAlloc(nullptr, size, MEM_LARGE_PAGES | MEM_GRAPHICS | MEM_RESERVE, PAGE_READONLY);
AllocateTitlePhysicalPages(GetCurrentProcess(), MEM_LARGE_PAGES, &NumPages64, PageArray);
MapTitlePhysicalPages(memPool, NumPages64, MEM_GRAPHICS | MEM_LARGE_PAGES, PAGE_READONLY, PageArray);

void * memPool = XMemVirtualAlloc(nullptr, size, MEM_64K_PAGES | MEM_RESERVE, XMEM_GRAPHICS | XMEM_MAPPABLE, PAGE_READONLY | PAGE_GRAPHICS_COHERENT | PAGE_GRAPHICS_READWRITE);
XMemAllocatePhysicalPages(MEM_64K_PAGES, &NumPages64, PageArray);
XMemMapPhysicalPages(memPool, NumPages64, PageArray);

XTaskQueueHandle queue;

// This one allows async work to use the default thread pool, but completion is explicit.
ThrowIfFailed(
    XTaskQueueCreate(XTaskQueueDispatchMode::ThreadPool, XTaskQueueDispatchMode::Manual, &queue)
);

...

// This pumps the completion work, which takes place on the calling thread.
while (XTaskQueueDispatch(m_queue, XTaskQueuePort::Completion, 0))
{
    // ... do other work ...
}

auto b = new XAsyncBlock{};
b->context = this;
b->queue = queue;
b->callback = [](XAsyncBlock* async)
{
    UpdateStatus status;
    if(SUCCEEDED(QueryUpdateStatusAsyncResult(async, &status)))
    {
       printf("Update Status: %d\r\n", status);
    }
    delete async;
};
QueryUpdateStatusAsync("Foo", b);

HRESULT SetTimeSensitiveThread(bool isTimeSensitive);
HRESULT VerifyNotTimeSensitiveThread();

uint16_t port;
hr = XNetworkingQueryPreferredLocalUdpMultiplayerPort(&port);
if (FAILED(hr))
    // NAT traversal failure

// Try to switch the display into HDR mode
auto result = XDisplayTryEnableHdrMode(XDisplayHdrModePreference::PreferHdr, nullptr);

if (result == XDisplayHdrModeResult::Enabled)
{
   // Specify the Auto HDR flag during D3D device creation
   params.CreateDeviceFlags = D3D12XBOX_CREATE_DEVICE_FLAG_ENABLE_AUTO_HDR;
}

// Create the D3D device
HRESULT hr = D3D12XboxCreateDevice(...);

D3D12_SAMPLER_DESC desc = { D3D12_FILTER_ANISOTROPIC,
    D3D12_TEXTURE_ADDRESS_MODE_WRAP,
    D3D12_TEXTURE_ADDRESS_MODE_WRAP,
    D3D12_TEXTURE_ADDRESS_MODE_WRAP,
    0, D3D12_MAX_MAXANISOTROPY, D3D12_COMPARISON_FUNC_NEVER,
    { 0, 0, 0, 0 }, 0, D3D12_FLOAT32_MAX };

D3D12_SAMPLER_DESC desc = { D3D12_FILTER_ANISOTROPIC,
    D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
    D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
    D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
    0, D3D12_MAX_MAXANISOTROPY, D3D12_COMPARISON_FUNC_NEVER,
    { 0, 0, 0, 0 }, 0, D3D12_FLOAT32_MAX };

<?xml version="1.0" encoding="utf-8"?>
<Game configVersion="1">

  <Identity Name="<project identifier or name>"
            Publisher="CN=<Publisher>"
            Version="1.0.0.0"/>

  <ExecutableList>
    <Executable Name="<name of title>.exe"
                Id="Game"/>
  </ExecutableList>

</Game>

  <ShellVisuals DefaultDisplayName="<name of title>"
                PublisherDisplayName="<publisher name>"
                StoreLogo="StoreLogo.png"
                Square150x150Logo="Logo.png"
                Square44x44Logo="SmallLogo.png"
                Square480x480Logo="LargeLogo.png"
                Description="<desc of title>"
                ForegroundText="light"
                BackgroundColor="#464646"
                SplashScreenImage="SplashScreen.png"/>

    <TitleId>hex-number</TitleId>

    <mx:Extension Category="xbox.system.resources">
        <mx:XboxSystemResources resourceConfiguration="extended">
          <mx:GpuAvailability>variable</mx:GpuAvailability>
          <mx:TitleMemory ConsoleType="Xbox_One_X" Size="9"/>
        </mx:XboxSystemResources>
    </mx:Extension>

    <VirtualMachine>
      <XboxOneXTitleMemory>Advanced</XboxOneXTitleMemory>
    </VirtualMachine>

#include <XSystem.h>

XSystemDeviceType deviceType = XSystemGetDeviceType();

switch (deviceType)
{
case XSystemDeviceType::Pc:                     ... break;
case XSystemDeviceType::XboxOne:                ... break;
case XSystemDeviceType::XboxOneS:               ... break;
case XSystemDeviceType::XboxOneX:               ... break;
case XSystemDeviceType::XboxOneXDevkit:         ... break;
case XSystemDeviceType::XboxScarlettLockhart: /* Xbox Series S */ ... break;
case XSystemDeviceType::XboxScarlettAnaconda: /* Xbox Series X */ ... break;
case XSystemDeviceType::XboxScarlettDevkit:     ... break;
case XSystemDeviceType::Unknown:                ... break;
}

#include <mmdeviceapi.h>

ComPtr<IMMDeviceEnumerator> devEnum;
hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(devEnum.GetAddressOf()));
// Check hr for errors

ComPtr<IMMDeviceCollection> devices;
hr = devEnum->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &devices);
// Check hr for errors

ComPtr<IMMDevice> endpoint;
hr = devices->Item(0, endpoint.GetAddressOf();
// Check hr for errors

LPWSTR id = nullptr;
hr = endpoint->GetId(&id);
// Check hr for errors

// The id variable contains the device identifier used by XAudio2

CoTaskMemFree(id);

int vk = static_cast<int>(wParam);
switch (vk)
{
    case VK_SHIFT:
    #if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_GAMES)
        vk = (((lParam & 0x00ff0000) >> 16) == 0x36) ? VK_RSHIFT : VK_LSHIFT;
    #else
        vk = MapVirtualKey((lParam & 0x00ff0000) >> 16, MAPVK_VSC_TO_VK_EX);
    #endif
        break;

    case VK_CONTROL:
        vk = (lParam & 0x01000000) ? VK_RCONTROL : VK_LCONTROL;
        break;

    case VK_MENU:
        vk = (lParam & 0x01000000) ? VK_RMENU : VK_LMENU;
        break;
}

// Name is a char array as input.
wchar_t wname[MAX_PATH] = {};
int result = MultiByteToWideChar(CP_UTF8, 0, name, -1, wname, MAX_PATH);
if (result <= 0) // Error

#include <shapexmacontext.h>

XTaskQueueHandle queue;
ThrowIfFailed(
    XTaskQueueCreate(XTaskQueueDispatchMode::ThreadPool, XTaskQueueDispatchMode::Immediate, &queue)
);

XAsyncBlock* ab = new XAsyncBlock;
ZeroMemory(ab, sizeof(XAsyncBlock));
ab->queue = queue;

// Show dialog, wait for completion, get result.

XGameUiMessageDialogButton button;
if (SUCCEEDED(XGameUiShowMessageDialogAsync(ab, u8"This is a title", u8"This is content text", u8"Option #1", u8"Option #2", u8"Option #3", XGameUiMessageDialogButton::First, XGameUiMessageDialogButton::Third)) &&
    SUCCEEDED(XAsyncGetStatus(ab, true)) &&
    SUCCEEDED(XGameUiShowMessageDialogResult(ab, &button)))
{
    DoSomethingWithResponse(button);
}

<PropertyGroup Label="Globals">
    <GDKExtLibNames>Xbox.Game.Chat.2.Cpp.API;Xbox.Services.API.C</GDKExtLibNames>
</PropertyGroup>