• Category: Announcements

January 21, 2026

January Xbox Update: Xbox Expands to Arm-based PCs, Game Save Sync Indicator, and More

• Dean Shimabukuro, Senior Product Marketing Manager, Xbox Services Marketing

Starting the new year, we have some new updates to help expand and improve how you play Xbox games. This includes adding the Xbox PC app to Arm-based Windows 11 PCs, rolling out a highly demanded Game Save Sync Indicator to PC and handheld devices so you can more easily track your gaming status on multiple devices, and partnering to include cloud gaming on Hisense and V homeOS-powered Smart TVs so you can stream and play your favorite Game Pass titles directly from your TV. Read more about these including new game additions, below.

Xbox PC App Experience Expands to Arm-based Windows 11 PCs

We’re excited to share that the Xbox PC app experience is expanding support to Arm-based Windows 11 PCs.

Now you can download titles from the Xbox PC app catalog to unlock more games to play locally on Arm-based Windows 11 PCs. This includes all the titles offered through your Xbox Game Pass subscription.

More devices. More flexibility. Same great Xbox experience – wherever you play. Learn more about this new addition here.

Game Save Sync Indicator Is Now Live

We’re rolling out a feature you’ve been asking for: the Game Save Sync Indicator is now available across PC and handheld experiences.

This player-first feature gives you real-time visibility into your cloud save status, so you’ll always know when your gameplay progress is synced. Whether you’re wrapping up on your PC or powering down your handheld, you can hit the road with confidence.

No more guesswork. No more lost progress. Just seamless, stress-free play across devices, wherever your travels take you.

Xbox Cloud Gaming Coming to Select Hisense and V homeOS Smart TVs

At CES, Xbox teamed up with V (formerly VIDAA) to announce that the Xbox app is coming to select Hisense and V homeOS-powered Smart TVs in 2026. This partnership means more ways to play, giving you the freedom to jump into your favorite games on even more devices.

Soon, Xbox Game Pass subscribers will be able to stream hundreds of games directly through the Xbox app on supported TVs via Xbox Cloud Gaming.

Learn more about this exciting update here.

Game Additions

Handheld Compatibility Program – Optimizing Play for Players

The Handheld Compatibility Program makes it easier for you to identify which games are optimized for handheld play. This update is now visible on product detail pages across all Windows devices and featured in the handheld compatible channel on Home on supported Windows handhelds. Recently, the following games were added to the program:

• Arc Raiders (Mostly Compatible)
• Clair Obscur: Expedition 33 (Handheld Optimized)
• Dave the Diver (Handheld Optimized)
• Fallout 4: Anniversary Edition (Handheld Optimized)
• Final Fantasy VII Remake Intergrade (Mostly Compatible)
• Marvel Cosmic Invasion (Handheld Optimized)
• Octopath Traveler 0 (Mostly Compatible)
• The Outer Worlds 2 (Handheld Optimized)
• Red Dead Redemption (Mostly Compatible)
• Silent Hill 2 (Handheld Optimized)

Xbox Play Anywhere – Buy once, play anywhere

Over 1,000 games now support Xbox Play Anywhere, making it easier than ever to switch between PC, console, and supported handhelds at no extra cost to you. Jump into games like Octopath Traveler 0 and The Finals now. Your progress travels with you, including saves, add-ons, and achievements. Just sign in with your Xbox account on any device and pick up right where you left off.

These are the games added to the Xbox Play Anywhere collection in December:

• Abyss DX
• A Game About Digging A Hole
• Brok: Natal Tail, A New Christmas Special
• Brok: The Brawl Bar
• Buffet Boss
• Christmas Mutilator
• Coloring Book
• Cup Heroes
• Cyberpunk Hacker
• Detective – Rainy Night
• Dimensions: The Catalyst
• Dome Keeper
• Dunjungle
• Fast Food Master 2025
• The Finals
• Frogo Deluxe
• Jellycar Worlds
• The Legend of Princess Lyria
• Marvel Cosmic Invasion
• Montezuma’s Revenge – The 40th Anniversary Edition
• Octopath Traveler 0
• Oddsparks: An Automation Adventure – Ultimate Edition
• Pinball Jam
• Portal Balls
• Potions: A Curious Tale
• Puzzle Galaxy Xbox Edition
• Recipe of Love
• Rhythm Doctor
• Routine
• Slimeboo
• Snaky Snakes
• Space Elite Force II – Reloaded
• Stacky Dash
• SpotCat vs The Cheddar Mafia Back To Past
• Talisman: Digital 5^th Edition
• Thank Goodness You’re Here!
• Treasure Drop
• Uboat Attack
• Wylde Flowers
• Yakuza: Shadows of New York

Check out the full list of available games that players can enjoy anywhere.

Stream your own game – Over 1000 games

We’re continuing to grow the Stream your own game collection in Xbox Cloud Gaming. Xbox Game Pass Ultimate, Premium, and Essential subscribers can now stream from a library of 1000+ games they own, across supported devices. That includes titles like Final Fantasy VII Remake Intergrade andResident Evil Village.

More games, more flexibility, and more ways to play – wherever you may be.

Recently added:

• Don’t Starve Together: Console Edition
• Farming Simulator 19
• Final Fantasy VII Remake Intergrade
• Guilty Gear -Strive-
• I Am Future: Cozy Apocalypse Survival
• Just Cause 3
• Little Nightmares III
• Mio: Memories in Orbit
• Planet Coaster: Console Edition
• Resident Evil Village
• …and many more!

Coming soon:

• Dead Island Definitive Edition
• Jurassic World Evolution
• Killing Floor 2
• Middle-earth: Shadow of Mordor – Game of the Year Edition
• …and many more!

Check out the full list of cloud-playable games available to stream on supported devices here. For more information on Stream your own game, learn more here.

Retro Classics has 100+ games   

Great games deserve to stick around, and we’re making sure they do. Xbox and Antstream Arcade are bringing retro favorites to modern devices with Retro Classics available on Game Pass, so players can keep enjoying the classics. With over 1 million players already diving into Retro Classics, here’s a look at the titles that are coming soon to Retro Classics:

• Sky Patrol
• Keystone Kapers
• Laser Gates
• Rise of the Dragon

Xbox Game Pass subscribers can join weekly tournaments, take on community challenges and enjoy a growing library of Activision and Blizzard games with the Retro Classics collection of over 100 titles and more to come over time. Click here for more information on Retro Classics.

Xbox adds mouse and keyboard for more games

Xbox supports the use of wired USB mice and keyboards for navigation in select games and apps, as well as across Xbox and Windows devices.

Today, there are 230+ games with touch controls available on cloud, giving you more ways to play than ever before.

Here are the latest titles added this month for mouse and keyboard:

• Kentum
• Easy Red 2
• Little Rocket Lab
• Bratz Rhythm & Style
• The Outer Worlds 2
• Pacific Drive
• Detechtive 2112
• Routine
• Prince of Persia: The Lost Crown
• Silver Nornir

For support on setting up devices, see here for more details.

Help Shape the Future of Xbox

Stay tuned to Xbox Wire for future updates and the latest and greatest Xbox news. For support related to Xbox updates, visit the official Xbox Support site.

We love hearing from the community, whether it’s a new feature idea or feedback on something we can improve upon. Xbox is always evolving, and your input helps shape what’s next. If you’d like to help create the future of Xbox and get early access to new features, join the Xbox Insider Program today by downloading the Xbox Insider Hub for Xbox Series X|S & Xbox One or Windows PC.

Happy gaming!

The post January Xbox Update: Xbox Expands to Arm-based PCs, Game Save Sync Indicator, and More appeared first on Xbox Wire.

• Category: Announcements

Xbox App Now Available on Arm-based Windows 11 PCs

The post Xbox App Now Available on Arm-based Windows 11 PCs appeared first on Xbox Wire.

The KendoReact SmartGrid brings AI prompting capabilities to your favorite enterprise-grade component.

Working with large datasets in web applications can involve repetitive tasks, such as manually configuring filters, setting sorting rules or grouping data in multiple ways to find the information you need. While traditional data grids (like the Progress KendoReact Data Grid) provide the tools to accomplish these operations, they require users to understand the grid’s interface and manually configure each step of each operation.

What if our data grid could understand natural language commands? What if we could ask it to “show only failed transactions over $500” or “group customers by region and sort by revenue”? This is exactly what the new KendoReact SmartGrid offers.

KendoReact SmartGrid

The KendoReact SmartGrid enhances the traditional KendoReact DataGrid with AI-powered capabilities that enable users to interact with data using natural language. Instead of clicking through menus and manually configuring filters, users can describe what they want to see, and the AI assistant translates those requests into grid operations.

The SmartGrid maintains all the powerful features of the standard grid (sorting, filtering, grouping, etc.) while adding an intelligent layer that interprets user intent and automatically applies the appropriate data operations.

Let’s start with a basic implementation to see the SmartGrid in action:

import * as React from 'react';
import {
  Grid,
  GridColumn,
  GridToolbar,
  GridToolbarAIAssistant,
} from '@progress/kendo-react-grid';
import { filterIcon } from '@progress/kendo-svg-icons';

const App = () => {
  const transactions = [
    {
      id: 1,
      customerName: 'Acme Corp',
      amount: 1250.0,
      currency: 'USD',
      status: 'Completed',
      transType: 'Deposit',
      transDate: new Date('2024-10-15'),
    },
    {
      id: 2,
      customerName: 'Tech Solutions',
      amount: 450.0,
      currency: 'EUR',
      status: 'Failed',
      transType: 'Withdrawal',
      transDate: new Date('2024-10-16'),
    },
    {
      id: 3,
      customerName: 'Global Industries',
      amount: 2100.0,
      currency: 'USD',
      status: 'Completed',
      transType: 'Deposit',
      transDate: new Date('2024-10-17'),
    },
    {
      id: 4,
      customerName: 'StartUp Inc',
      amount: 850.0,
      currency: 'GBP',
      status: 'Pending',
      transType: 'Withdrawal',
      transDate: new Date('2024-10-18'),
    },
    {
      id: 5,
      customerName: 'Enterprise Co',
      amount: 3200.0,
      currency: 'USD',
      status: 'Completed',
      transType: 'Deposit',
      transDate: new Date('2024-10-19'),
    },
  ];

  return (
    <Grid
      autoProcessData={true}
      dataItemKey="id"
      data={transactions}
      sortable={true}
      groupable={true}
      pageable={true}
      columnMenuIcon={filterIcon}
    >
      <GridToolbar>
        <GridToolbarAIAssistant
          requestUrl="https://demos.telerik.com/service/v2/ai/grid/smart-state"
          promptPlaceHolder="Filter, sort or group with AI"
          suggestionsList={[
            'Sort by amount descending',
            'Show only completed transactions',
            'Group by transaction type',
            'Filter where currency is USD',
          ]}
          enableSpeechToText={true}
        />
      </GridToolbar>

      <GridColumn field="customerName" title="Customer Name" width={180} />
      <GridColumn field="amount" title="Amount" width={120} format="{0:c2}" />
      <GridColumn field="currency" title="Currency" width={100} />
      <GridColumn field="status" title="Status" width={120} />
      <GridColumn field="transType" title="Type" width={120} />
      <GridColumn
        field="transDate"
        title="Date"
        width={140}
        format="{0:MM/dd/yyyy}"
      />
    </Grid>
  );
};

export default App;

In the example above, we’ve created a transaction grid using the AI-powered toolbar assistant. The GridToolbarAIAssistant component provides a natural language interface that lets users type commands like “show only completed transactions” or “sort by amount descending,” and the AI automatically applies those operations to the grid.

The autoProcessData prop is key here in the above example. It enables the grid to automatically handle state updates when AI operations are applied, eliminating the need for manual state management in simple scenarios.

The SmartGrid is part of KendoReact Premium, an enterprise-grade UI library with 120+ components. The AI features demonstrated here use a Telerik-hosted service for demonstration purposes. For production applications, you’ll want to implement your own AI service tailored to your specific domain and data requirements.

Voice Input Support

A cool feature of the SmartGrid is its support for speech-to-text input. By setting enableSpeechToText={true} on the GridToolbarAIAssistant, users can speak their commands directly instead of typing them.

To use voice input, users click the microphone icon in the AI assistant and speak their command. The grid processes spoken commands the same way as typed text, so commands like “show only completed transactions” work just as seamlessly.

The voice input feature uses the browser’s native Web Speech API, so it works across modern browsers without additional dependencies or setup.

Tracking Operations with Controlled Integration

While autoProcessData works great for simple scenarios, we may need more control over how AI operations are applied to our grid. For example, we can log user interactions, validate AI suggestions before applying them or display an operation history to users.

The controlled approach gives us this flexibility through the onResponseSuccess callback:

import * as React from 'react';
import { process } from '@progress/kendo-data-query';
import {
  Grid,
  GridColumn,
  GridToolbar,
  GridToolbarAIAssistant,
} from '@progress/kendo-react-grid';

const App = () => {
  const [dataState, setDataState] = React.useState({
    skip: 0,
    take: 10,
    sort: [],
    filter: undefined,
    group: [],
  });

  const [outputs, setOutputs] = React.useState([]);
  const aiAssistantRef = React.useRef(null);

  const transactions = [
    {
      id: 1,
      customerName: 'Acme Corp',
      amount: 1250.0,
      status: 'Completed',
      currency: 'USD',
    },
    {
      id: 2,
      customerName: 'Tech Solutions',
      amount: 450.0,
      status: 'Failed',
      currency: 'EUR',
    },
    {
      id: 3,
      customerName: 'Global Industries',
      amount: 2100.0,
      status: 'Completed',
      currency: 'USD',
    },
    {
      id: 4,
      customerName: 'StartUp Inc',
      amount: 850.0,
      status: 'Pending',
      currency: 'GBP',
    },
    {
      id: 5,
      customerName: 'Enterprise Co',
      amount: 3200.0,
      status: 'Completed',
      currency: 'USD',
    },
  ];

  const handleResponseSuccess = (response, promptMessage) => {
    if (response && response.data) {
      // Apply AI-suggested operations to grid state
      const newState = { ...dataState };

      if (response.data.sort) newState.sort = response.data.sort;
      if (response.data.filter) newState.filter = response.data.filter;
      if (response.data.group) newState.group = response.data.group;

      setDataState(newState);

      // Track the operation in history
      if (response.data.messages) {
        const newOutput = {
          id: outputs.length + 1,
          prompt: promptMessage,
          responseContent: response.data.messages.join('\n'),
        };
        setOutputs([newOutput, ...outputs]);
      }
    }

    aiAssistantRef.current?.hide();
  };

  const processedData = process(transactions, dataState);

  return (
    <Grid
      dataItemKey="id"
      data={processedData.data}
      total={processedData.total}
      sortable={true}
      sort={dataState.sort}
      onSortChange={(e) => setDataState({ ...dataState, sort: e.sort })}
      filterable={true}
      filter={dataState.filter}
      onFilterChange={(e) => setDataState({ ...dataState, filter: e.filter })}
      groupable={true}
      group={dataState.group}
      onGroupChange={(e) => setDataState({ ...dataState, group: e.group })}
      pageable={true}
      skip={dataState.skip}
      take={dataState.take}
      onPageChange={(e) =>
        setDataState({
          ...dataState,
          skip: e.page.skip,
          take: e.page.take,
        })
      }
    >
      <GridToolbar>
        <GridToolbarAIAssistant
          ref={aiAssistantRef}
          requestUrl="https://demos.telerik.com/service/v2/ai/grid/smart-state"
          onResponseSuccess={handleResponseSuccess}
          outputs={outputs}
          promptPlaceHolder="Filter, sort or group with AI"
        />
      </GridToolbar>

      <GridColumn field="customerName" title="Customer" width={180} />
      <GridColumn field="amount" title="Amount" width={120} format="{0:c2}" />
      <GridColumn field="status" title="Status" width={120} />
      <GridColumn field="currency" title="Currency" width={100} />
    </Grid>
  );
};

export default App;

In this controlled approach, we explicitly manage the grid’s state and intercept AI responses via onResponseSuccess. This allows us to:

• Validate AI suggestions before applying them to the grid.
• Log user interactions and AI operations for analytics or debugging.
• Display operation history through the outputs prop, giving users transparency into what commands they’ve issued.

The outputs prop displays a history of AI operations, helping users understand how their natural language requests were interpreted and what operations were performed on the grid.

Wrap-up

The KendoReact SmartGrid brings AI-powered capabilities to data grids, making complex data operations accessible through natural language. By simply describing what they want to see, users can filter, sort and group data without needing to understand the intricacies of the grid interface.

For more details on implementing the SmartGrid and exploring its capabilities, check out the official documentation:

• KendoReact Smart DataGrid Overview
• KendoReact Grid Documentation

And to try it for yourself, download the 30-day free trial:

Try Now

Some time ago, I discussed custom dialog classes. You can specify that a dialog template use your custom dialog class by putting the custom class’s name in the CLASS statement of the dialog template. A customer tried doing that but it crashes with a stack overflow.

// Dialog template

IDD_AWESOME DIALOGEX 0, 0, 170, 62
STYLE DS_SHELLFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION
CAPTION "I'm so awesome"
CLASS "MyAwesomeDialog"
FONT 8, "MS Shell Dlg", 0, 0, 0x1
BEGIN
    ICON            IDI_AWESOME,IDC_STATIC,14,14,20,20
    LTEXT           "Whee!",IDC_STATIC,42,14,114,8
    DEFPUSHBUTTON   "OK",IDOK,113,41,50,14,WS_GROUP
END

// Custom dialog class procedure
// Note: This looks ugly but that's not the point.
LRESULT CALLBACK CustomDlgProc(HWND hwnd, UINT message,
                               WPARAM wParam, LPARAM lParam)
{
    if (message == WM_CTLCOLORDLG) {
        return (LRESULT)GetSysColorBrush(COLOR_INFOBK);
    }
    return DefDlgProc(hwnd, message, wParam, lParam);
}

void Test()
{
    // Register the custom dialog class
    WNDCLASS wc{};
    GetClassInfo(nullptr, WC_DIALOG, &wc);
    wc.lpfnWndProc = CustomDlgProc;
    wc.lpszClassName = TEXT("MyAwesomeDialog");
    RegisterClass(&wc);

    // Use that custom dialog class for a dialog
    DialogBox(hInstance, MAKEINTESOURCE(IDD_AWESOME), hwndParent,
              CustomDlgProc);
}

Do you see the problem?

The problem is that the code uses the CustomDlgProc function both as a window procedure and as a dialog procedure.

When a message arrives, it goes to the window procedure. This rule applies regardless of whether you have a traditional window or a dialog. If you have a standard dialog, then the window procedure is Def­Dlg­Proc, and that function calls the dialog procedure to let it respond to the message. If the dialog procedure declines to handle the message, then the Def­Dlg­Proc function does some default dialog stuff.

Creating a custom dialog class means that you want a different window procedure for the dialog, as if you had subclassed the dialog. The custom window procedure typically does some special work, and then it passes messages to Def­Dlg­Proc when it wants normal dialog behavior.

If you use the same function as both the window procedure and the dialog procedure, then when the function (acting as a window procedure) passes a message to Def­Dlg­Proc, the Def­Dlg­Proc function will call the dialog procedure, which is also Custom­Dlg­Proc. That function doesn’t realize that it’s now being used as a dialog procedure, so it is expected to return TRUE or FALSE (depending on whether it decided to handle the message). It thinks it is still a window procedure, so it passes the message to Def­Dlg­Proc, and the loop continues until you overflow the stack.

The idea behind custom dialog classes is that you have some general behavior you want to apply to all the dialogs that use that class. For example, maybe you want them all to use different default colors, or you want them all to respond to DPI changes the same way. Instead of replicating the code in each dialog procedure, you can put it in the dialog class window procedure.

But even if you are using a custom dialog class, your dialog procedure should still be a normal dialog procedure. That dialog procedure is the code-behind for the dialog template, initializing the controls in the template, responding to clicks on the controls in the template, and so on.

The post On the proper usage of a custom Win32 dialog class appeared first on The Old New Thing.

Targeting .NET Standard for a class library means that the library will be compatible with applications designed for past versions of .NET. E.g., an application targeting .NET Framework 4.8 or .NET Core 2.1 will be able to load a class library targeting .NET Standard 2.0 because it can only rely on the same API surface that the application does.

There are a few reasons developers need to work in .NET Standard. A popular one is writing Roslyn analyzers, another is writing PowerShell modules (Cmdlets) in C#. .NET Standard is a formal specification of .NET APIs available across multiple .NET implementations. It's like a definition of a slice of APIs that are implemented across .NET versions. Designing for a slice of APIs allows you to design and deploy class libraries that will work across .NET implementations. The latest version of .NET Standard (2.1) was released in September 2020.

Paradoxically, .NET languages depend on base-class libraries for aspects of their implementation. For example, the C# language feature foreach depends on the types IEnumerable, IEnumerable<T>, IEnumerator, and IEnumerator<T>. Specifications like .NET Standard enable C# language features across .NET implementations by including those dependent types in their specification. But languages evolve and improve over time, as do base class libraries.

Since .NET Standard was last updated in 2020, some new language features that depend on new types in the base class library have been introduced. Some of these new language features aren't necessarily supported in .NET Standard, even though you can use the latest compiler version when building .NET Standard class libraries. For example, Ranges and Indices are a feature added to C# 8.0, released in September 2019. Ranges and Indices depend upon the Range and Index types. But to write a PowerShell library that supports Windows PowerShell and PowerShell 7, you have to target .NET Standard 2.0, whose API surface was specified around August 2017--roughly two years before Range and Index existed. This means Ranges and Indices aren't supported out of the box in C# code targeting .NET Standard 2.0. var lastWord = words[^1] or var firstFourWords = words[0..3] will cause errors (Predefined type 'System.Index' is not defined or imported, and Predefined type 'System.Range' is not defined or imported, respectively).

Fortunately, the compiler is flexible about where those predefined types are defined. Someone can't simply create a .NET Standard 2.0 library with Range and Index as public types, because they will clash with modern versions of .NET (e.g., in an XUnit test project). But the .NET Standard 2.0 library can create internal versions of those classes that the compiler is happy to resolve to. But having everyone who authors a .NET Standard 2.0 library write their own Range and Index classes (as well as any other class that modern C# syntax requires, like CallerArgumentExpressionAttribute, DoesNotReturnAttribute, etc.) is problematic, to say the least.

Content-only NuGet Packages

.NET and NuGet packages support content- or source-only packages. Source-only packages are NuGet packages that, instead of packaging binaries like DLLs, package source code. Source-only packages don't add any assembly dependencies that require deployment.

That's where Pri.ProductivityExtensions.Source comes in. Pri.ProductivityExtensions.Source is a source-only NuGet package that includes the source code for various types created after .NET Standard 2.x to support C# language features (and some helper extensions like ArgumentException.ThrowIfNull that depend on those features) that aren't available in .NET Standard.

"Pri.ProductivityExtensions.Source" is also the ID of the package and can be found on NuGet.org here. It can be added to a project via the .NET API: dotnet add package Pri.ProductivityExtensions.Source, or via Package Manager Console: Install-Package Pri.ProductivityExtensions.Source. It is open source, and the source code is available on GitHub. For an example using Pri.ProductivityExtensions.Source see Pri.Essentials.DotnetPsCmds. And if you install DotnetPsCmds, you can install Pri.ProductivityExtensions.Source in PowerShell: Add-DotnetPackages Pri.ProductivityExtensions.Source.

When you reference Pri.ProductivityExtensions.Source, it causes the content (source code) to be considered part of the target project. The source code remains in the .nuget cache and is not copied alongside the rest of your source code so no new source code needs to be committed to revision control.

The types included in Pri.ProductivityExtensions.Source are internal, so they won't clash if Pri.ProductivityExtensions.Source is referenced in a project targeting a modern .NET implementation. Although I don't recommend using Pri.ProductivityExtensions.Source in a .NET Standard class library that is targeting a modern .NET implementation because it will resolve to Pri.ProductivityExtensions.Source instead of the .NET implementation's.

If you've created a .NET Standard library and have wanted to use the latest version of the compiler but start receiving compiler errors like The type or namespace name 'CallerArgumentExpressionAttribute' does not exist in the namespace 'System.Runtime.CompilerServices' (are you missing an assembly reference?) or the other aforementioned errors, fear not, you simply need to reference Pri.ProductivityExtensions.Source!

Pri.ProductivityExtensions.Source enables the following modern C# compiler features:

• Ranges and indices
• [CallerArgumentExpression] 🔗
• [DoesNotReturn] 🔗
• [NotNullWhen] 🔗

Additionally, Pri.ProductivityExtensions.Source includes the following helper methods that otherwise depend on newer language-dependent types:

• ArgumentException.ThrowIfNullOrWhiteSpace(string?, string?) 🔗
• ArgumentNullException.ThrowIfNull(object?, string?) 🔗

Understanding C# Timeline Since Last .NET Standard

The last version of .NET Standard (2.1) was released in 2020. Since 2020, C# versions 10, 11, 12, 13, and 14 have been released. A lot has changed across 5 versions of C#, including the use of numerous APIs to enable various features. There isn't a complete list of base-class APIs that the C# compiler depends on.

If you find this useful
I'm a freelance software architect. If you find this post useful and think I can provide value to your team, please reach out to see how I can help. See About for information about the services I provide.