Identity, Registration and Activation of Non-packaged Win32 Apps – Windows Developer Blog

Many new and sought-after Windows APIs and features such as BackgroundTasks, Notifications, LiveTiles, Share and more, are either not available or not easily callable from non-packaged Win32 applications. This is due to the programming model for UWP APIs that integrate with the system and have a dependency on the following concepts:Identity – The need for package or application identity to identify the caller, and an identifier to scope data and resources.
Registration – The need for configuration of machine state during application deployment, which is required by the API and indexed by the package or application identity.
For packaged applications, Identity declared in the Appxmanifest.xml, and Registration is handled by the MSIX deployment pipeline based on the information in the AppxManifest.xml. This allows a simplified calling pattern for UWP APIs where the application code just uses an API. Compare this to a typical Win32 API that requires a register-use-unregister pattern for managing a callback.
We’ve heard your feedback, and in response we’re filling in the divide between Win32 apps and new Windows APIs & features so that you can take advantage of these new APIs & features and enhance your applications. As of Windows Build 10.0.19000.0 we’re introducing the following new AppModel concepts to provide your Win32 app with deeper integration into the OS:
Sparse Package registrationSigned MSIX packages can be installed on Windows today but all content referenced in the package’s Appxmanifest.xml must be present inside the package. A ‘Sparse’ Package contains an AppxManifest.xml but unlike a regular/full package, the manifest can reference files outside its package in a predetermined ‘external location’. This allows applications that are not yet able to adopt complete MSIX packaging to gain Identity, configure state (Registration) as required by UWP APIs and then take advantage of these APIs.
Package ‘External Location’ To support a Sparse Package, a package definition now has a new element. This is what allows your package AppxManifest.xml to reference content outside its package, in a specific location on disk. For example, if your existing Win32 app installs content in C:Program FilesMyWin32App , you can create a Sparse Package that declares the element and during app installation or first run of your app, you can register the Sparse Package and declare C:Program FilesMyWin32App as the external location your app will be using. This way you can continue deploying all your other app artifacts in the locations you do today while taking advantage of the Sparse Package.
Win32 type RuntimeBehaviorTo help with compatibility of your existing Win32 app when using a Sparse Package, the app can register to have its application process be run like a non-packaged Win32 app as much as possible. This differs from a fully packaged Win32 app in that it is not subject to filesystem + registry virtualization, lifetime management by the system and other runtime attributes of fully packaged applications. The main runtime similarity between such an app and a fully packaged app is the presence of app/package identity in the running process.
Activation via CreateProcessThe activation path for UWP applications today ensures the app has PackageIdentity in its process token. This is used by UWP APIs to identify the caller and refer to later – either to perform a callback or to look up state that was configured during deployment. Because of this requirement, calling CreateProcess() on a UWP exe will fail as the CreateProcess() pipeline was not enlightened about Identity. In order to support Sparse Packages with an External Location, we leverage the classic Win32 application.manifest to provide Identity in CreateProcess() scenarios.
At their core, these features are about providing a foundation for non-packaged Win32 processes to use our latest APIs and features.
*Please note that these are still new and somewhat advanced development features that do not yet have full Visual Studio integration i.e. there are still some gaps in the end to end authoring experience such as having to create a Sparse Package outside of Visual Studio.

We’ll be using a sample application making use of a Sparse Package to walk through the different aspects of Sparse Package authoring and usage. The demo app is located at
We have a non-packaged WPF application PhotoStoreDemo that stores and displays photos. In its purely non-packaged state, it can be challenging to take advantage of new Windows APIs and features. Our goal is to change this by creating a Sparse Package and continuing to use our previously existing Win32 app artifacts.
Anatomy of a Sparse Package
A Sparse Package must have an AppxManifest.xml and a minimal set of required visual assets in order to deploy.


Let’s use the AppxManifest.xml from our sample code above to look at the anatomy of a Sparse Package.
Package External Location
Firstly, the AppxManifest should declare the package property. This allows the manifest to reference content that is not located within the package. Any content referenced in the Sparse Package that isn’t located in the package directly should be in the ‘external’ location which is specified when the Sparse Package is registered. For example, if I declare my package’s external location to be C:Program FilesMyDesktopApp during installation or at first run, the image storelogo.png defined for the property should be installed at C:Program FilesMyDesktopAppAssetsstorelogo.png and the main application executable PhotoStoreDemo.exe should be installed at C:Program FilesMyDesktopAppPhotoStoreDemo.exe. In addition, the MinVersion should be OS Build 10.0.19000.0 or greater, Sparse packages are currently not supported on OS versions earlier than this.
It’s important to note that unlike a fully packaged application, an app using a Sparse Package + ‘External Location’ is not fully managed by the OS at deployment, runtime and uninstall. As is the case with Win32 apps today, your application is responsible for install and uninstall of all its artifacts including the Sparse Package and any content in the ‘external location’. This also means your app doesn’t receive lifetime management and tamper protection that fully packaged apps receive from being installed in a locked down location on the System.
Win32 Runtime Behavior
The newly introduced TrustLevel=mediumIL and RuntimeBehavior=Win32App attributes in the element are used to declare that the application associated with this Sparse Package will run like a Win32 app, with no registry + filesystem virtualisation and other runtime changes.
Sparse Package Authoring
The steps required in authoring Sparse Package are:
Create an AppxManifest.xml + Visual Assets and package them
Sign the Sparse Package
Create a classic Win32 application.manifest in your Win32 app
Register the Sparse Package
Creating and Packaging an AppxManifest.xml + Visual Assets
The first step in creating a Sparse Package is generating the AppxManifest.xml. The AppxManifest needs to contain the properties listed above, you can use this template as a starting point. In addition to the AppxManifest you need to include the visual assets referenced in the manifest file. You can use the “Visual Assets” node in the package.manifest editor of the Visual Studio Application Packaging Project to generate the visual assets.
Once you have your AppxManifest.xml and visual assets, you can use App Packager (MakeAppx.exe) to create a Sparse Package. Because the Sparse package doesn’t contain all the files referenced in the AppxManifest.xml, you need to specify the /nv command.
Here is an example command to create a Sparse Package containing just an AppxManifest.xml from a VS Developer Command Prompt:
MakeAppx.exe  pack  /d    /p  mypackage.msix  /nv
You can find more info on App packager (MakeAppx.exe) here.
Signing a Sparse package
To successfully install on a machine, your Sparse Package must be signed with a cert that is trusted on that machine. This is the case for regular MSIX packages today. You can create a new self-signed cert for development purposes and sign your Sparse Package using the SignTool available in the Windows SDK and MSIX Toolkit. You can also make use of the newly announced Device Guard Signing feature.Here’s an example of how to sign a Sparse Package from a VS Developer Command Prompt using the Sign Tool:
SignTool.exe sign /fd SHA256 /a /f mycert.pfx  /p   mypackage.msix
Creating a classic Win32 application.manifest
To support CreateProcess() scenarios that do not go through the UWP activation pipeline, your app must use the classic Win32-style application.manifest to declare the identity attributes of your application under the new element. The values defined in the manifest are used determine your application’s identity when its executable is launched and must match those declared in your Sparse Package’s AppxManifest.xml.

packageName (above) corresponds to Name and publisher corresponds to Publisher in the element of your Sparse package:
(Sparse Package)

applicationId corresponds to the Id attribute in the element for this app declared in the Sparse package:
(Sparse Package)


To add a classic Win32 manifest to an existing project in Visual studio, from the application node right click | Add | New Item | Visual C# | Application Manifest File. The manifest file naming convention is that it must have the same name as your application’s .exe and have the .manifest extension, in this case I named it “PhotoStoreDemo.exe.manifest”.
Taking advantage of your app’s Sparse Package
As earlier mentioned, creating a Sparse Package for your application makes it easier for your Win32 app to deeply integrate with the OS and take advantage of features such as BackgroundTasks, Share, Notifications and Tiles. Let’s have a look at how our sample app runs and uses the Sparse Package to register as a Share Target and make use of UWP activation.
The workflow in our sample looks something like this:
Declare our app as a Share Target in the Sparse Package AppxManifest.xml
Register our app’s Sparse Package with the OS.
Relaunch the app and handle activation types.
Example usage – Declaring your app as a Share Target in the Sparse Package AppxManifest.xml
Our sample app is registered as a Share Target by declaring the windows.ShareTarget Application Extension in the Sparse Package AppxManifest.xml:



Registering a Sparse Package
To take advantage of a Sparse package, your application needs to register the signed package with the system. You can register the package during first run, or you can also register the package during installation of your other Win32 artifacts, if you’re using an installer such as an MSI. To install the package using an MSI you’d need to use Custom Actions. In our sample app, we register the Sparse package during first run. When our application is launched, we check if it’s running with Identity (identity or the lack thereof is a signal of whether the Sparse package has been registered/installed) if the app is not running with identity we then register the Sparse Package and restart the app. This is expected to take place only once at first run. To see how we’re determining if the app is running with identity, have a look at the ExecutionMode class and this post if you’d like more background.
This is what the code in our app looks like:

//if app isn’t running with identity, register its sparse package
if (!ExecutionMode.IsRunningWithIdentity())
string externalLocation = @”C:\”;
string sparsePkgPath = @”C:\PhotoStoreDemo.msix”;

//Attempt registration
if (registerSparsePackage(externalLocation, sparsePkgPath))
//Registration succeded, restart the app to run with identity
System.Diagnostics.Process.Start(Application.ResourceAssembly.Location, arguments: cmdArgs?.ToString());
else //Registration failed, run without identity
Debug.WriteLine(“Package Registation failed, running WITHOUT Identity”);
SingleInstanceManager wrapper = new SingleInstanceManager();


And this is the registerSparsePackage method called above handling package registration:

Using Windows.Management.Deployment

private static bool registerSparsePackage(string externalLocation, string sparsePkgPath)
bool registration = false;
Uri externalUri = new Uri(externalLocation);
Uri packageUri = new Uri(sparsePkgPath);
PackageManager packageManager = new PackageManager();
//Set the externalLocation where your Win32 artifacts will be installed
//Anything not in the package but referenced by your AppxManifest.xml needs to to be under this location
var options = new AddPackageOptions();
options.ExternalLocationUri = externalUri;

Windows.Foundation.IAsyncOperationWithProgress deploymentOperation = packageManager.AddPackageByUriAsync(packageUri, options)

To register the Sparse packages, you need to make use of the PackageManager AddPackageByUriAsync(packageUri, addPackageOptions) API. The API takes in the location of your signed Sparse Package as a URI and an AddPackageOptions object. You need to create an AddpackageOptions object and set the ExternalLocationUri property to the URI of the location where your Win32 artifacts (e.g. app executable) being referenced in the Sparse Package will be installed.
Handling App Activation
When our app is running, we check whether it was launched under UWP type activation e.g. a Share Event or Notification Event. If it was, we handle the activation event accordingly, otherwise, we handle the launch as a regular .exe launch such as double clicking the app .exe. Here’s a look at the code:

public static void Main(string[] cmdArgs)

//Handle Sparse Package based activation e.g Share target activation or clicking on a Tile
// Launching the .exe directly will have activationArgs == null
var activationArgs = AppInstance.GetActivatedEventArgs();
if (activationArgs != null)
switch (activationArgs.Kind)
case ActivationKind.Launch:
HandleLaunch(activationArgs as LaunchActivatedEventArgs);
case ActivationKind.ToastNotification:
HandleToastNotification(activationArgs as ToastNotificationActivatedEventArgs);
case ActivationKind.ShareTarget:
HandleShareAsync(activationArgs as ShareTargetActivatedEventArgs);

//This is a direct exe based launch e.g. double click.exe or desktop shortcut
SingleInstanceManager singleInstanceManager = new SingleInstanceManager();

Running the Sample
To run the sample app at
Make sure your machine has Developer Mode turned on, and both your Windows Build and SDK versions are 10.0.19000.0 or later.
Retarget the solution to the SDK version on your machine – Right click -> Retarget solution.
Add a project reference to the Windows.winmd file at “C:Program Files (x86)Windows Kits10UnionMetadata\Windows.winmd”(Right click PhotoStoreDemo project | Add | Reference| Browse | All files | Windows.winmd)
Make sure the Sparse Package is signed by a trusted cert on your machine.
You can sign using an existing cert or you can create a self-signed cert and trust it on your machine by double clicking | Install certificate | Local Machine | Place all certificates in the following store | Browse | Trusted People | Next | Finish
Update, package and sign the unpackaged files in PhotoStoreDemoPkg. Open the AppxManifest.xml and update the Publisher value in the package element to match the publisher value in your cert. *You will also need to make sure the Publisher value is updated in the classic Win32 app.manifest (PhotoStoreDemo.exe.manifest) to match the new value in the AppxManifest.xml.
Follow the steps under “Creating and Packaging an AppxManifest.xml” and “Signing a Sparse Package” sections to package the files with App Packager (MakeAppx) and then sign them with the SignTool or Device Guard Signing.

Once the Sparse Package is signed, in the main method (in Startup.cs) update the externalLocation value to match the output location of your VS Build binaries and the sparsePkgPath value to match the path to your signed Sparse Package.
When you run the package, you should see the PhotoStoreDemo app launch with a “Running with Identity” tag in the top left corner. If registration of the package failed the tag will read “Desktop App” instead. If the package registration was successful and the app still launches without identity, try double checking to make sure the values in the element of the classic Win32 app.manifest (PhotoStoreDemo.exe.manifest) match the values in the and element of your Sparse Package’s AppxManifest.xml.
Launching the app with identity:

Checking the Details tab in Task Manager shows the app running with a Package Name PhotoStoreDemo which is an indicator that the app is running with our Sparse Package’s declared identity:

After my app has successfully registered the Sparse package, it shows up as a Share target when I right click on a .jpg/.png/.gif file:

Selecting our app activates the app and adds the new image to the image store.

As a bonus, our sample handles toast notification activation in the HandleToastNotification() method in Startup.cs. Clicking the “Add Via Toast” button in the bottom left quadrant of the running app launches a toast message from the app.

If you enter a full path to an image file, it should add the image file to the app’s photo store. If you close the app before responding to the toast, it will relaunch the app with the new image you specified in the path.

Unlike a fully packaged application that is uninstalled by the System when a user chooses to uninstall the app, a Sparse Package must be uninstalled by the application that registers it. The uninstall workflow of a Sparse Package points the user to the uninstaller of the application that registered the package and while uninstalling the Win32 artifacts of the app, the uninstaller must also remove the Sparse Package. This can be done using the PackageManager.RemovePackage..() APIs, you can find an example of an app using the APIs here.
Adding a Sparse Package to your existing Win32 app is a great way to give your application identity and add deeper integration with Windows APIs and features such as Notifications, BackgroundTasks, Live Tiles, Share and more. The main caveats are that unlike for fully packaged applications, your application does not receive tamper protection and installation in a locked down location. In addition, your app is not fully managed by the OS at deployment, runtime and uninstall – your application is responsible for install, lifetime management and uninstall of your Sparse Package, in the same way you are responsible for installing and managing your Win32 app artifacts.

Announcing Windows 10 Insider Preview Build 19013 | Windows Experience Blog

UPDATE 11/1: We have released Build 19013.1000 (KB4528332) to Windows Insiders. This update does not include any changes or fixes.NOTE: If you try to install a Feature On Demand (FOD) while this update is pending and you restart your PC, it will not trigger this update to successfully install. As a workaround, you can pause updates, un-pause updates, and then scan for updates to get out of this state if this happens to you.
Hello Windows Insiders, today we’re releasing Windows 10 Insider Preview Build 19013 (20H1) to Windows Insiders in the Fast ring.

More kaomoji

( ͡~ ͜ʖ ͡°)
And more! Enjoy (❁´◡`❁)

PowerToys v0.12 now available!

Check out our latest article for all the details.
Your Phone app–Elevating the Phone screen feature by removing its dependency on Bluetooth connection
Windows Insiders, we heard your feedback about the Phone screen feature’s dependency on Bluetooth Low Energy connectivity. To address your feedback, we partnered closely with Samsung to bring you a more streamlined experience across all Windows 10 PCs by removing the peripheral role dependency for Phone screen, which will expand the overall reach of this feature.
Samsung Galaxy Note 10 was the first device to introduce this feature in August. After a positive response, we’ve recently enabled this feature across Samsung Galaxy Fold, S10, S10+, and S10e smartphones. You’ll need to update your supported Samsung devices with the recent software update that enables the ‘Link to Windows’ feature. To continue offering this experience to other smartphones, we’re expanding this feature support to Samsung Galaxy A30s, A50s, and A90 smartphones, and we’ll continue to add additional devices in the coming months.
With the new experience rolling out, we’ll be removing the Bluetooth connectivity option, effective immediately. If you were previously enjoying Phone screen over Bluetooth and you have a phone model that doesn’t yet support Link to Windows, the Phone screen node will disappear automatically within the Your Phone app. We recommend that you unpair your devices by going to the Bluetooth settings on both your PC and your Android phone, so that you don’t have a connection that is no longer in use.
Thank you for helping us refine the Phone screen experience so far!
Phone screen requirements:
Select Android phones running Android 9.0 or greater
PC running Windows 10 October 2018 Update or later
Android phone must be on and connected to the same network as the PC
You will need a supported device to use this feature:
Samsung Galaxy Fold
Samsung Galaxy Note 10/ Note 10+
Samsung Galaxy S10/S10+/S10e
Samsung Galaxy A30s/A50s/A90

Refer to the Your Phone FAQs for additional information.
Preview new DirectX 12 features
In the latest 20H1 builds, you can preview new DirectX 12 features, including DirectX Raytracing tier 1.1, Mesh Shader, and Sampler Feedback. In this blog post, the DirectX Team explains what each of these features are and how they will improve the gaming experience in Windows 10!

We fixed an issue resulting in frames being skipped, starting with Build 19002, when running games and videos fullscreen.
We fixed an issue where initiating “Reset this PC” with the cloud download option wasn’t working when started from Windows RE.
We fixed an issue resulting in preinstalled apps (like Calculator) and other UWP apps being missing from the Apps & Features page in Settings.
We appreciate your patience while we worked on our sync engine. As of this build, wallpaper and theme syncing is now up and running again.
We fixed an issue resulting in Wi-Fi unexpectedly resetting (turning off and back on) frequently in recent flights.
We fixed an issue where Wi-Fi Settings might get stuck saying Connecting, even though the network flyout (correctly) indicated that you were Connected.
We fixed an issue where an update being temporarily suspended would result in an 0xc19001e1 error being displayed in Windows Update history.
We fixed an issue resulting in the “Open location” search result option not working if the search result was a folder.
We fixed an issue where if you moved Cortana’s window to certain places on your screen, and then closed the window, the minimize animation wouldn’t go towards Cortana’s icon on the taskbar.
We fixed an issue resulting in File Explorer not rendering correctly sometimes when using multiple monitors with different DPIs on the previous flight.
We fixed an issue that could result in the app thumbnail disappearing when you right clicked it in Task View.
We fixed an issue that could result in the Send Message button in certain notifications not being visible when using High Contrast White.
We fixed an issue where the notification following WIN+Shift+S might have a blank space for the screenshot (rather than actually displaying the screenshot).
We fixed an issue resulting in Resource Manager unexpectedly not showing any disk activity.
We fixed an issue where, if you called SUBST with a path ending with a it would give a Path not found error.
We fixed a memory leak with running apps that repeatedly sent calls to adjust gamma.
Some of you have reached out about when trying to shutdown, seeing a message saying that an app named “G” was preventing shutdown. We investigated and found an issue where windows related to GDI+were only referenced as “G.” We’ve fixed this, so going forward, these will now have the name “GDI+ Window ()”, where will show the .exe name of the app using GDI+.
We fixed an issue resulting in speechruntime.exe using an unexpectedly high amount of CPU on the previous flight.
We fixed an issue resulting in Bluetooth devices potentially not reconnecting as expected after closing then reopening the device lid for certain devices.
We fixed an issue resulting in the Surface Dial not scrolling in recent builds if you switched to something like zoom and then back to scrolling.
Thank you Insiders who shared feedback about the 2-in-1 convertible tablet experience improvements we discussed here. For the time being, we’re returning to the current experience in retail.
We fixed an issue where Narrator would sometime report focus as the page instead of reporting the actual focused control within Chrome.
We fixed an issue where Narrator would not automatically start reading the Narrator user guide webpage and the YouTube webpage.
We corrected Narrator’s “Next Table” command so that it would work in Excel.
We fixed an issue where the text cursor indicator was visible on top of the lock screen background picture.
We fixed an issue where the text cursor indicator preview wasn’t displaying correctly in Settings when using dark theme.
We fixed an issue where when using dark theme, the hardware keyboard text prediction candidate window was unreadable due to black text on a dark grey background.
We fixed an issue that could result in the touch keyboard flickering when inputting emoji.
We fixed an issue where English punctuations were outputted when using the Chinese Pinyin and Wubi IMEs, even if input mode was set to Chinese under the default IME settings. Thanks for your feedback.
We’ve fixed an issue where the character width of alphanumeric characters when using the Traditional Chinese Bopomofo IME would change from half width to full width unexpectedly in some input fields. Thanks for reporting it! If you feel this issue hasn’t been fully addressed in the new version of Bopomofo IME, please let us know your feedback.
We’ve fixed an issue where after successfully updating to a new build, the Windows Update Settings page may have shown the same build needed to be installed.
We’ve fixed an issue where Optional drivers were failing to install.

If you use remote desktop connection and the target PC is on this build, within about an hour (if not sooner), DWM may start crashing, and the session window will either go totally black, experience black flashes, or you may get signed out of the remote desktop session altogether. We appreciate your patience.
[ADDED] A small subset of Insiders are reporting the Settings app hangs or crashes when accessing the System or Ease of Access sections. We’ve identified the cause, which is related to display settings, and are working on a fix for a future flight. As a workaround, launch Settings and then search for the setting you’d like to adjust. Any display-related setting can’t be adjusted until a fix is made available. Thank you to the Insiders who reported this.

Halloween is right around the corner and we challenge you to take our Bing Halloween Quiz! Learn the history behind jack-o’-lanterns, werewolves, trick-or-treating, and more. Test your knowledge here and become a Halloween expert with Bing.

Windows 10 SDK Preview Build 19008 available now! – Windows Developer Blog

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 19008 or greater). The Preview SDK Build 19008 contains bug fixes and under development changes to the API surface area.The Preview SDK can be downloaded from developer section on Windows Insider.


Message Compiler (mc.exe)
Windows Trace Preprocessor (tracewpp.exe)
Signing your apps with Device Guard Signing

We have stood up a NuGet feed for the flighted builds of the SDK. You can now test preliminary builds of the Windows 10 WinRT API Pack, as well as a NuGet package.
We use the following feed to flight our NuGet packages.
Microsoft.Windows.SDK.Contracts which can be used with to add the latest Windows Runtime APIs support to your .NET Framework 4.5+ and .NET Core 3.0+ libraries and apps.
Microsoft.Windows.SDK.Headless.Contracts provides a subset of the Windows Runtime APIs for console apps excludes the APIs associated with a graphical user interface. This NuGet is used in conjunction with Windows ML container development. Check out the Getting Started guide for more information.

Removal of IRPROPS.LIB
In this release, irprops.lib has been removed from the Windows SDK. Apps that were linking against irprops.lib can switch to bthprops.lib as a drop-in replacement.
Removal of WUAPICommon.H and WUAPICommon.IDL
In this release we have moved ENUM tagServerSelection from WUAPICommon.H to wupai.h and removed the header. If you would like to use the ENUM tagServerSelection, you will need to include wuapi.h or wuapi.idl.


namespace Windows.AI.MachineLearning {
public sealed class LearningModelSessionOptions {
bool CloseModelOnSessionCreation { get; set; }
namespace Windows.ApplicationModel {
public sealed class AppInfo {
public static AppInfo Current { get; }
Package Package { get; }
public static AppInfo GetFromAppUserModelId(string appUserModelId);
public static AppInfo GetFromAppUserModelIdForUser(User user, string appUserModelId);
public interface IAppInfoStatics
public sealed class Package {
StorageFolder EffectiveExternalLocation { get; }
string EffectiveExternalPath { get; }
string EffectivePath { get; }
string InstalledPath { get; }
bool IsStub { get; }
StorageFolder MachineExternalLocation { get; }
string MachineExternalPath { get; }
string MutablePath { get; }
StorageFolder UserExternalLocation { get; }
string UserExternalPath { get; }
IVectorView GetAppListEntries();
RandomAccessStreamReference GetLogoAsRandomAccessStreamReference(Size size);
namespace Windows.ApplicationModel.AppService {
public enum AppServiceConnectionStatus {
AuthenticationError = 8,
DisabledByPolicy = 10,
NetworkNotAvailable = 9,
WebServiceUnavailable = 11,
public enum AppServiceResponseStatus {
AppUnavailable = 6,
AuthenticationError = 7,
DisabledByPolicy = 9,
NetworkNotAvailable = 8,
WebServiceUnavailable = 10,
public enum StatelessAppServiceResponseStatus {
AuthenticationError = 11,
DisabledByPolicy = 13,
NetworkNotAvailable = 12,
WebServiceUnavailable = 14,
namespace Windows.ApplicationModel.Background {
public sealed class BackgroundTaskBuilder {
void SetTaskEntryPointClsid(Guid TaskEntryPoint);
public sealed class BluetoothLEAdvertisementPublisherTrigger : IBackgroundTrigger {
bool IncludeTransmitPowerLevel { get; set; }
bool IsAnonymous { get; set; }
IReference PreferredTransmitPowerLevelInDBm { get; set; }
bool UseExtendedFormat { get; set; }
public sealed class BluetoothLEAdvertisementWatcherTrigger : IBackgroundTrigger {
bool AllowExtendedAdvertisements { get; set; }
namespace Windows.ApplicationModel.ConversationalAgent {
public sealed class ActivationSignalDetectionConfiguration
public enum ActivationSignalDetectionTrainingDataFormat
public sealed class ActivationSignalDetector
public enum ActivationSignalDetectorKind
public enum ActivationSignalDetectorPowerState
public sealed class ConversationalAgentDetectorManager
public sealed class DetectionConfigurationAvailabilityChangedEventArgs
public enum DetectionConfigurationAvailabilityChangeKind
public sealed class DetectionConfigurationAvailabilityInfo
public enum DetectionConfigurationTrainingStatus
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataPackage {
event TypedEventHandler ShareCanceled;
namespace Windows.Devices.Bluetooth {
public sealed class BluetoothAdapter {
bool IsExtendedAdvertisingSupported { get; }
uint MaxAdvertisementDataLength { get; }
namespace Windows.Devices.Bluetooth.Advertisement {
public sealed class BluetoothLEAdvertisementPublisher {
bool IncludeTransmitPowerLevel { get; set; }
bool IsAnonymous { get; set; }
IReference PreferredTransmitPowerLevelInDBm { get; set; }
bool UseExtendedAdvertisement { get; set; }
public sealed class BluetoothLEAdvertisementPublisherStatusChangedEventArgs {
IReference SelectedTransmitPowerLevelInDBm { get; }
public sealed class BluetoothLEAdvertisementReceivedEventArgs {
BluetoothAddressType BluetoothAddressType { get; }
bool IsAnonymous { get; }
bool IsConnectable { get; }
bool IsDirected { get; }
bool IsScannable { get; }
bool IsScanResponse { get; }
IReference TransmitPowerLevelInDBm { get; }
public enum BluetoothLEAdvertisementType {
Extended = 5,
public sealed class BluetoothLEAdvertisementWatcher {
bool AllowExtendedAdvertisements { get; set; }
public enum BluetoothLEScanningMode {
None = 2,
namespace Windows.Devices.Bluetooth.Background {
public sealed class BluetoothLEAdvertisementPublisherTriggerDetails {
IReference SelectedTransmitPowerLevelInDBm { get; }
namespace Windows.Devices.Display {
public sealed class DisplayMonitor {
bool IsDolbyVisionSupportedInHdrMode { get; }
namespace Windows.Devices.Input {
public sealed class PenButtonListener
public sealed class PenDockedEventArgs
public sealed class PenDockListener
public sealed class PenTailButtonClickedEventArgs
public sealed class PenTailButtonDoubleClickedEventArgs
public sealed class PenTailButtonLongPressedEventArgs
public sealed class PenUndockedEventArgs
namespace Windows.Devices.Sensors {
public sealed class Accelerometer {
AccelerometerDataThreshold ReportThreshold { get; }
public sealed class AccelerometerDataThreshold
public sealed class Barometer {
BarometerDataThreshold ReportThreshold { get; }
public sealed class BarometerDataThreshold
public sealed class Compass {
CompassDataThreshold ReportThreshold { get; }
public sealed class CompassDataThreshold
public sealed class Gyrometer {
GyrometerDataThreshold ReportThreshold { get; }
public sealed class GyrometerDataThreshold
public sealed class Inclinometer {
InclinometerDataThreshold ReportThreshold { get; }
public sealed class InclinometerDataThreshold
public sealed class LightSensor {
LightSensorDataThreshold ReportThreshold { get; }
public sealed class LightSensorDataThreshold
public sealed class Magnetometer {
MagnetometerDataThreshold ReportThreshold { get; }
public sealed class MagnetometerDataThreshold
namespace Windows.Foundation.Metadata {
public sealed class AttributeNameAttribute : Attribute
public sealed class FastAbiAttribute : Attribute
public sealed class NoExceptionAttribute : Attribute
namespace Windows.Globalization {
public sealed class Language {
string AbbreviatedName { get; }
public static IVector GetMuiCompatibleLanguageListFromLanguageTags(IIterable languageTags);
namespace Windows.Graphics.Capture {
public sealed class GraphicsCaptureSession : IClosable {
bool IsCursorCaptureEnabled { get; set; }
namespace Windows.Graphics.DirectX {
public enum DirectXPixelFormat {
SamplerFeedbackMinMipOpaque = 189,
SamplerFeedbackMipRegionUsedOpaque = 190,
namespace Windows.Graphics.Holographic {
public sealed class HolographicFrame {
HolographicFrameId Id { get; }
public struct HolographicFrameId
public sealed class HolographicFrameRenderingReport
public sealed class HolographicFrameScanoutMonitor : IClosable
public sealed class HolographicFrameScanoutReport
public sealed class HolographicSpace {
HolographicFrameScanoutMonitor CreateFrameScanoutMonitor(uint maxQueuedReports);
namespace Windows.Management.Deployment {
public sealed class AddPackageOptions
public enum DeploymentOptions : uint {
StageInPlace = (uint)4194304,
public sealed class PackageManager {
IAsyncOperationWithProgress AddPackageByUriAsync(Uri packageUri, AddPackageOptions options);
IVector FindProvisionedPackages();
PackageStubPreference GetPackageStubPreference(string packageFamilyName);
IAsyncOperationWithProgress RegisterPackageByUriAsync(Uri manifestUri, RegisterPackageOptions options);
IAsyncOperationWithProgress RegisterPackagesByFullNameAsync(IIterable packageFullNames, RegisterPackageOptions options);
void SetPackageStubPreference(string packageFamilyName, PackageStubPreference useStub);
IAsyncOperationWithProgress StagePackageByUriAsync(Uri packageUri, StagePackageOptions options);
public enum PackageStubPreference
public enum PackageTypes : uint {
All = (uint)4294967295,
public sealed class RegisterPackageOptions
public enum RemovalOptions : uint {
PreserveRoamableApplicationData = (uint)128,
public sealed class StagePackageOptions
public enum StubPackageOption
namespace Windows.Media.Audio {
public sealed class AudioPlaybackConnection : IClosable
public sealed class AudioPlaybackConnectionOpenResult
public enum AudioPlaybackConnectionOpenResultStatus
public enum AudioPlaybackConnectionState
namespace Windows.Media.Capture {
public sealed class MediaCapture : IClosable {
MediaCaptureRelativePanelWatcher CreateRelativePanelWatcher(StreamingCaptureMode captureMode, DisplayRegion displayRegion);
public sealed class MediaCaptureInitializationSettings {
Uri DeviceUri { get; set; }
PasswordCredential DeviceUriPasswordCredential { get; set; }
public sealed class MediaCaptureRelativePanelWatcher : IClosable
namespace Windows.Media.Capture.Frames {
public sealed class MediaFrameSourceInfo {
Panel GetRelativePanel(DisplayRegion displayRegion);
namespace Windows.Media.Devices {
public sealed class PanelBasedOptimizationControl
namespace Windows.Media.MediaProperties {
public static class MediaEncodingSubtypes {
public static string Pgs { get; }
public static string Srt { get; }
public static string Ssa { get; }
public static string VobSub { get; }
public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties {
public static TimedMetadataEncodingProperties CreatePgs();
public static TimedMetadataEncodingProperties CreateSrt();
public static TimedMetadataEncodingProperties CreateSsa(byte[] formatUserData);
public static TimedMetadataEncodingProperties CreateVobSub(byte[] formatUserData);
namespace Windows.Networking.BackgroundTransfer {
public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void RemoveRequestHeader(string headerName);
void SetRequestHeader(string headerName, string headerValue);
public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void RemoveRequestHeader(string headerName);
void SetRequestHeader(string headerName, string headerValue);
namespace Windows.Networking.Connectivity {
public enum NetworkAuthenticationType {
Owe = 12,
namespace Windows.Networking.NetworkOperators {
public sealed class NetworkOperatorTetheringAccessPointConfiguration {
TetheringWiFiBand Band { get; set; }
bool IsBandSupported(TetheringWiFiBand band);
IAsyncOperation IsBandSupportedAsync(TetheringWiFiBand band);
public sealed class NetworkOperatorTetheringManager {
public static void DisableNoConnectionsTimeout();
public static IAsyncAction DisableNoConnectionsTimeoutAsync();
public static void EnableNoConnectionsTimeout();
public static IAsyncAction EnableNoConnectionsTimeoutAsync();
public static bool IsNoConnectionsTimeoutEnabled();
public enum TetheringWiFiBand
namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static event EventHandler ChannelsRevoked;
public sealed class PushNotificationChannelsRevokedEventArgs
public sealed class RawNotification {
IBuffer ContentBytes { get; }
namespace Windows.Security.Authentication.Web.Core {
public sealed class WebAccountMonitor {
event TypedEventHandler AccountPictureUpdated;
namespace Windows.Security.Isolation {
public sealed class IsolatedWindowsEnvironment
public enum IsolatedWindowsEnvironmentActivator
public enum IsolatedWindowsEnvironmentAllowedClipboardFormats : uint
public enum IsolatedWindowsEnvironmentAvailablePrinters : uint
public enum IsolatedWindowsEnvironmentClipboardCopyPasteDirections : uint
public struct IsolatedWindowsEnvironmentContract
public struct IsolatedWindowsEnvironmentCreateProgress
public sealed class IsolatedWindowsEnvironmentCreateResult
public enum IsolatedWindowsEnvironmentCreateStatus
public sealed class IsolatedWindowsEnvironmentFile
public static class IsolatedWindowsEnvironmentHost
public enum IsolatedWindowsEnvironmentHostError
public sealed class IsolatedWindowsEnvironmentLaunchFileResult
public enum IsolatedWindowsEnvironmentLaunchFileStatus
public sealed class IsolatedWindowsEnvironmentOptions
public static class IsolatedWindowsEnvironmentOwnerRegistration
public sealed class IsolatedWindowsEnvironmentOwnerRegistrationData
public sealed class IsolatedWindowsEnvironmentOwnerRegistrationResult
public enum IsolatedWindowsEnvironmentOwnerRegistrationStatus
public sealed class IsolatedWindowsEnvironmentProcess
public enum IsolatedWindowsEnvironmentProcessState
public enum IsolatedWindowsEnvironmentProgressState
public sealed class IsolatedWindowsEnvironmentShareFolderRequestOptions
public sealed class IsolatedWindowsEnvironmentShareFolderResult
public enum IsolatedWindowsEnvironmentShareFolderStatus
public sealed class IsolatedWindowsEnvironmentStartProcessResult
public enum IsolatedWindowsEnvironmentStartProcessStatus
public sealed class IsolatedWindowsEnvironmentTelemetryParameters
public static class IsolatedWindowsHostMessenger
public delegate void MessageReceivedCallback(Guid receiverId, IVectorView message);
namespace Windows.Storage {
public static class KnownFolders {
public static IAsyncOperation GetFolderAsync(KnownFolderId folderId);
public static IAsyncOperation RequestAccessAsync(KnownFolderId folderId);
public static IAsyncOperation RequestAccessForUserAsync(User user, KnownFolderId folderId);
public enum KnownFoldersAccessStatus
public static IAsyncOperation GetFileFromPathForUserAsync(User user, string path);
public static IAsyncOperation GetFolderFromPathForUserAsync(User user, string path);
namespace Windows.Storage.Provider {
public sealed class StorageProviderFileTypeInfo
public sealed class StorageProviderSyncRootInfo {
IVector FallbackFileTypeInfo { get; }
public static class StorageProviderSyncRootManager {
public static bool IsSupported();
namespace Windows.System {
public sealed class UserChangedEventArgs {
IVectorView ChangedPropertyKinds { get; }
public enum UserWatcherUpdateKind
namespace Windows.UI.Composition.Interactions {
public sealed class InteractionTracker : CompositionObject {
public enum InteractionTrackerPositionUpdateOption
namespace Windows.UI.Input {
public sealed class CrossSlidingEventArgs {
uint ContactCount { get; }
public sealed class DraggingEventArgs {
uint ContactCount { get; }
public sealed class GestureRecognizer {
uint HoldMaxContactCount { get; set; }
uint HoldMinContactCount { get; set; }
float HoldRadius { get; set; }
TimeSpan HoldStartDelay { get; set; }
uint TapMaxContactCount { get; set; }
uint TapMinContactCount { get; set; }
uint TranslationMaxContactCount { get; set; }
uint TranslationMinContactCount { get; set; }
public sealed class HoldingEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
public sealed class ManipulationCompletedEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
public sealed class ManipulationInertiaStartingEventArgs {
uint ContactCount { get; }
public sealed class ManipulationStartedEventArgs {
uint ContactCount { get; }
public sealed class ManipulationUpdatedEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
public sealed class RightTappedEventArgs {
uint ContactCount { get; }
public sealed class SystemButtonEventController : AttachableInputObject
public sealed class SystemFunctionButtonEventArgs
public sealed class SystemFunctionLockChangedEventArgs
public sealed class SystemFunctionLockIndicatorChangedEventArgs
public sealed class TappedEventArgs {
uint ContactCount { get; }
namespace Windows.UI.Input.Inking {
public sealed class InkModelerAttributes {
bool UseVelocityBasedPressure { get; set; }
namespace Windows.UI.Text {
public enum RichEditMathMode
public sealed class RichEditTextDocument : ITextDocument {
void GetMath(out string value);
void SetMath(string value);
void SetMathMode(RichEditMathMode mode);
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
bool CriticalInputMismatch { get; set; }
bool TemporaryInputMismatch { get; set; }
void ApplyApplicationUserModelID(string value);
public sealed class UISettings {
event TypedEventHandler AnimationsEnabledChanged;
event TypedEventHandler MessageDurationChanged;
public sealed class UISettingsAnimationsEnabledChangedEventArgs
public sealed class UISettingsMessageDurationChangedEventArgs
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
event TypedEventHandler PrimaryViewHiding;
event TypedEventHandler PrimaryViewShowing;
public sealed class CoreInputViewHidingEventArgs
public enum CoreInputViewKind {
Symbols = 4,
public sealed class CoreInputViewShowingEventArgs
public sealed class UISettingsController

Announcing Windows Server vNext Insider Preview Build 19008 | Windows Experience Blog

Hello Windows Insiders!Today we are pleased to release a new Insider Preview build of the Windows Server VNext Semi-Annual Channel edition.

Windows Server Core Container Images Are 20% Smaller
In what should be a significant win for any workflow that pulls Windows containers images, the download size of the Windows Server Core container Insider image has been reduced by 20%. This has been achieved by optimizing the set of .NET pre-compiled native images included in the Server Core container image. If you are using .NET Framework with Windows containers, including Windows PowerShell, use a .NET Framework image, which will include additional .NET pre-compiled native images to maintain performance for those scenarios, while also benefiting from a reduced size.

Windows Server vNext Semi-Annual Preview Build 19008 The Server Core Edition is available in the 18 supported Server languages in ISO format and in VHDX format in English only.
Matching Windows Server Core App Compatibility FoD Preview
Matching Windows Server Language Packs

Windows Admin Center Preview 1909
Containers: For more information about how to obtain and install Windows Server containers and Insider builds, click here. Quick start information, here.
Keys: The following keys allow for unlimited activations of Windows Server Semi-Annual Channel Previews
Server Standard: V6N4W-86M3X-J77X3-JF6XW-D9PRV
Server Datacenter: B69WH-PRNHK-BXVK3-P9XF7-XD84W
The Windows Server Preview will expire July 31st, 2020.

Registered Insiders may navigate directly to the Windows Server Insider Preview download page.  See the Additional Downloads dropdown for Windows Admin Center and other supplemental apps and products. If you have not yet registered as an Insider, see GETTING STARTED WITH SERVER on the Windows Insiders for Business portal.

[Server #####] Title of my feedback
See Share Feedback on Windows Server via Feedback Hub for specifics. We also encourage you to visit the Windows Server Insiders space on the Microsoft Tech Communities forum to collaborate, share and learn from experts.


Consider these Office 365 alternatives to public folders

As more organizations consider a move from Exchange Server, public folders continue to vex many administrators for a variety of reasons.

Microsoft supports public folders in its latest Exchange Server 2019 as well as Exchange Online, but it is pushing companies to adopt some of its newer options, such as Office 365 Groups and Microsoft Teams. An organization pursuing alternatives to public folders will find there is no direct replacement for this Exchange feature. There reason for this is due to the nature of the cloud.

Microsoft set its intentions early on under Satya Nadella’s leadership with its “mobile first, cloud first” initiative back in 2014. Microsoft aggressively expanded its cloud suite with new services and features. This fast pace meant that migrations to cloud services, such as Office 365, would offer a different experience based on the timing. Depending on when you moved to Office 365, there might be different features than if you waited several months. This was the case for migrating public folders from on-premises Exchange Server to Exchange Online, which evolved over time and also coincided with the introduction of Microsoft Teams, Skype for Business and Office 365 Groups.

The following breakdown of how organizations use public folders can help Exchange administrators with their planning when moving to the new cloud model on Office 365.

Organizations that use public folders for email only

Public folders are a great place to store email that multiple people within an organization need to access. For example, an accounting department can use public folders to let department members use Outlook to access the accounting public folders and corresponding email content.

A shared mailbox has a few advantages over a public folder with the primary one being accessibility through the Outlook mobile app or from Outlook via the web.

Office 365 offers similar functionality to public folders through its shared mailbox feature in Exchange Online. A shared mailbox stores email in folders, which is accessible by multiple users.

A shared mailbox has a few advantages over a public folder with the primary one being accessibility through the Outlook mobile app or from Outlook via the web. This allows users to connect from their smartphones or a standard browser to review email going to the shared mailbox. This differs from public folder access which requires opening the Outlook client.

Organizations that use public folders for email and calendars

For organizations that rely on both email and calendars in their public folders, Microsoft has another cloud alternative that comes with a few extra perks.

Office 365 Groups not only lets users collaborate on email and calendars, but also stores files in a shared OneDrive for Business page, tasks in Planner and notes in OneNote. Office 365 Groups is another option for email and calendars made available on any device. Office 365 Groups owners manage their own permissions and membership to lift some of the burden of security administration from the IT department.

Microsoft provides migration scripts to assist with the move of content from public folders to Office 365 Groups.

Organizations that use public folders for data archiving

Some organizations that prefer to stay with a known quantity and keep the same user experience also have the choice to keep using public folders in Exchange Online.

The reasons for this preference will vary, but the most likely scenario is a company that wants to keep email for archival purposes only. The migration from Exchange on-premises public folders requires administrators to use Microsoft’s scripts at this link.

Organizations that use public folders for project communication and data sharing repository

The Exchange public folders feature is excellent for sharing email, contacts and calendar events. For teams working on projects, the platform shines as a way to centralize information that’s relevant to the specific project or department. But it’s not as expansive as other collaboration tools on Office 365.

Take a closer look at some of the other modern collaboration tools available in Office 365 in addition to Microsoft Teams and Office 365 Groups, such as Kaizala. These offerings extend the organization’s messaging abilities to include real-time chat, presence status and video conferencing.

Go to Original Article