07 Mar 2018
07 Mar 2018

Windows 10 in S Mode coming soon to all editions of Windows 10

Author: Joe Belfiore
Go to Source

Some of you may have seen a discussion around our plans for Windows 10 S on Twitter today, and given some additional questions I’ve received, I thought it might be helpful to share more about our plans with Windows 10 S.

Last year we introduced Windows 10 S – an effort to provide a Windows experience that delivers predictable performance and quality through Microsoft-verified apps via the Microsoft Store. This configuration was offered initially as part of the Surface Laptop and has been adopted by our customers and partners for its performance and reliability.

Since that time, we’ve received great feedback from customers and partners on Windows 10 S. Customers love the security, faster boot time, better battery life and consistent performance over time. Our partners have brought to market more than 20 devices with Windows 10 S enabled. We have also heard feedback that the naming was a bit confusing for both customers and partners.

Based on that feedback, we are simplifying the experience for our customers. Starting with the next update to Windows 10, coming soon, customers can choose to buy a new Windows 10 Home or Windows 10 Pro PC with S mode enabled, and commercial customers will be able to deploy Windows 10 Enterprise with S mode enabled.

We expect the majority of customers to enjoy the benefits of Windows 10 in S mode. If a customer does want to switch out of S mode, they will be able to do so at no charge, regardless of edition. We expect to see new Windows 10 devices ship with S mode, available from our partners in the coming months, so check back here for updates.

We hope this new approach will simplify and make it possible for more customers to start using Windows in S mode: a familiar, productive Windows experience that is streamlined for security and performance across all our editions.

Go to Source

Share this
07 Mar 2018
07 Mar 2018
07 Mar 2018

Preview the latest Windows Mixed Reality features coming this spring

Author: Dona Sarkar
Go to Source

Hello Windows Insiders!

The new Skyloft Mixed Reality environment.

We’re excited to offer our Fast ring insiders a sneak peek at the latest features coming this spring to Windows Mixed Reality! Our favorite new updates in Insider Preview Build 17115 include:

  • A brand-new environment. In October we mentioned that the Cliff House was the first of many environments you’ll be able to enjoy in Windows Mixed Reality, and now we’re rolling out the Skyloft for you to customize and expand your MR experience. You can navigate there by selecting Places on the Mixed Reality Start menu.
  • As requested, we’ve added haptic feedback to the motion controllers for SteamVR games!
  • We’ve improved performance in SteamVR games with significantly lower video RAM usage. We’ve also improved the performance of live video preview in the Mixed Reality Portal on desktop.
  • You can now take mixed reality photos directly from your controller by holding the Windows button and then tapping the trigger. This works across environments and apps except for capturing content protected with DRM.
  • The automatic performance settings have been updated to provide an optimized experience, and we’ve added a new setting to override the default in Settings > Mixed Reality > Headset display.
  • Setup now provides more detailed information about common compatibility issues with USB3.0 controllers and graphics cards.
  • Many more improvements that the team has been hard at work on!

This build also contains fixes for the two blocking issues in our previous flight, as well as reliability and fit and finish improvements. We are still working on few known issues related to Inbox Apps launching and tracking being lost in some sleep/update scenarios.

To use Windows Mixed Reality, you’ll need a capable PC and a compatible headset. We’re looking for more great feedback from Insiders on these new features so let us know what you think! Please use the Feedback Hub to log any bugs you encounter.

Thanks,
Dona

Go to Source

Share this
07 Mar 2018

Windows 10 SDK Preview Build 17110 now available

Author: Clint Rutkas
Go to Source

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

The Preview SDK can be downloaded from developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

Things to note:

  • This build works in conjunction with previously released SDKs and Visual Studio 2017.  You can install this SDK and still also continue to submit your apps that target Windows 10 Creators build or earlier to the store.
  • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.
  • This build of the Windows SDK will install on Windows 10 Insider Preview and supported Windows operating systems.

What’s New:

  • C++/WinRT Now Available: The C++/WinRT headers and cppwinrt compiler (cppwinrt.exe) are now included in the Windows SDK. The compiler comes in handy if you need to consume a third-party WinRT component or if you need to author your own WinRT components with C++/WinRT. The easiest way to get working with it after installing the Windows Insider Preview SDK is to start the Visual Studio Developer Command Prompt and run the compiler in that environment. Authoring support is currently experimental and subject to change. Stay tuned as we will publish more detailed instructions on how to use the compiler in the coming week.The ModernCPP blog has a deeper dive into the CppWinRT compiler.  Please give us feedback by creating an issue at: https://github.com/microsoft/cppwinrt.

Breaking Changes

New MIDL key words. 

As a part of the “modernizing IDL” effort, several new keywords are added to the midlrt tool. These new keywords will cause build breaks if they are encountered in IDL files.

The new keywords are:

  • event
  • set
  • get
  • partial
  • unsealed
  • overridable
  • protected
  • importwinmd

If any of these keywords is used as an identifier, it will generate a build failure indicating a syntax error.

The error will be similar to:

1 >d:ossrconecorecomcombaseunittestastatestserverstestserver6idlremreleasetest.idl(12) : error MIDL2025 : [msg]syntax error [context]: expecting a declarator or * near “)”

To fix this, modify the identifier in error to an “@” prefix in front of the identifier. That will cause MIDL to treat the offending element as an identifier instead of a keyword.

API Updates and Additions

When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.

The following APIs have been added to the platform since the release of 16299.


namespace Windows.AI.MachineLearning.Preview {
  public enum FeatureElementKindPreview
  public interface ILearningModelVariableDescriptorPreview
  public sealed class ImageVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public sealed class InferencingOptionsPreview
  public sealed class LearningModelBindingPreview : IIterable<IKeyValuePair<string, object>>, IMapView<string, object>
  public sealed class LearningModelDescriptionPreview
  public enum LearningModelDeviceKindPreview
  public sealed class LearningModelEvaluationResultPreview
  public enum LearningModelFeatureKindPreview
  public sealed class LearningModelPreview
  public sealed class LearningModelVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public struct MachineLearningPreviewContract
  public sealed class MapVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public sealed class SequenceVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public sealed class TensorVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
}
namespace Windows.ApplicationModel {
  public enum AddResourcePackageOptions : uint
  public sealed class AppInstance
  public sealed class PackageCatalog {
    IAsyncOperationWithProgress<PackageCatalogAddResourcePackageResult, PackageInstallProgress> AddResourcePackageAsync(string resourcePackageFamilyName, string resourceID, AddResourcePackageOptions options);
    IAsyncOperation<PackageCatalogRemoveResourcePackagesResult> RemoveResourcePackagesAsync(IIterable<Package> resourcePackages);
  }
  public sealed class PackageCatalogAddResourcePackageResult
  public sealed class PackageCatalogRemoveResourcePackagesResult
  public struct PackageInstallProgress
  public enum StartupTaskState {
    EnabledByPolicy = 4,
  }
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    BarcodeScannerProvider = 1022,
  }
  public sealed class BarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public interface IBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs
}
namespace Windows.ApplicationModel.Background {
  public enum BackgroundAccessRequestKind
  public static class BackgroundExecutionManager {
    public static IAsyncOperation<bool> RequestAccessKindAsync(BackgroundAccessRequestKind requestedAccess, string reason);
  }
  public sealed class CustomSystemEventTrigger : IBackgroundTrigger
  public enum CustomSystemEventTriggerRecurrence
  public sealed class MobileBroadbandPcoDataChangeTrigger : IBackgroundTrigger
  public sealed class NetworkOperatorDataUsageTrigger : IBackgroundTrigger
  public sealed class StorageLibraryChangeTrackerTrigger : IBackgroundTrigger
  public sealed class TetheringEntitlementCheckTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
  public enum PhoneCallMedia {
    AudioAndRealTimeText = 2,
  }
  public sealed class VoipCallCoordinator {
    VoipPhoneCall RequestNewAppInitiatedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
    VoipPhoneCall RequestNewIncomingCall(string context, string contactName, string contactNumber, Uri contactImage, string serviceName, Uri brandingImage, string callDetails, Uri ringtone, VoipPhoneCallMedia media, TimeSpan ringTimeout, string contactRemoteId);
  }
  public sealed class VoipPhoneCall {
    void NotifyCallAccepted(VoipPhoneCallMedia media);
  }
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    IAsyncOperation<bool> LaunchForUserAsync(User user);
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackagePropertySet : IIterable<IKeyValuePair<string, object>>, IMap<string, object> {
    string ContentSourceUserActivityJson { get; set; }
  }
  public sealed class DataPackagePropertySetView : IIterable<IKeyValuePair<string, object>>, IMapView<string, object> {
    string ContentSourceUserActivityJson { get; }
  }
  public static class StandardDataFormats {
    public static string UserActivityJsonArray { get; }
  }
}
namespace Windows.ApplicationModel.Store.Preview {
  public enum StoreSystemFeature {
    ArchitectureArm64 = 34,
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallItem {
    bool LaunchAfterInstall { get; set; }
  }
  public sealed class AppInstallManager {
    IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallAsync(string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallForUserAsync(User user, string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesAsync(string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync(User user, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesAsync(string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync(User user, string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync(string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync(User user, string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
  }
  public sealed class AppInstallOptions
  public sealed class AppInstallStatus {
    bool IsStaged { get; }
  }
  public sealed class AppUpdateOptions
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity {
    public UserActivity(string activityId);
    string ToJson();
    public static string ToJsonArray(IIterable<UserActivity> activities);
    public static UserActivity TryParseFromJson(string json);
    public static IVector<UserActivity> TryParseFromJsonArray(string json);
  }
  public sealed class UserActivityChannel {
    public static void DisableAutoSessionCreation();
    IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetRecentUserActivitiesAsync(int maxUniqueActivities);
    IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetSessionHistoryItemsForUserActivityAsync(string activityId, DateTime startTime);
    public static UserActivityChannel TryGetForWebAccount(WebAccount account);
  }
  public sealed class UserActivityRequest
  public sealed class UserActivityRequestedEventArgs
  public sealed class UserActivityRequestManager
  public sealed class UserActivitySessionHistoryItem
  public sealed class UserActivityVisualElements {
    string AttributionDisplayText { get; set; }
  }
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter {
    bool AreClassicSecureConnectionsSupported { get; }
    bool AreLowEnergySecureConnectionsSupported { get; }
  }
  public sealed class BluetoothDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
  public sealed class BluetoothLEDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
}
namespace Windows.Devices.Display {
  public sealed class DisplayMonitor
  public enum DisplayMonitorConnectionKind
  public enum DisplayMonitorDescriptorKind
  public enum DisplayMonitorPhysicalConnectorKind
  public enum DisplayMonitorUsageKind
}
namespace Windows.Devices.Input.Preview {
  public enum GazeDeviceConfigurationStatePreview
  public sealed class GazeDevicePreview
  public sealed class GazeDeviceWatcherAddedPreviewEventArgs
  public sealed class GazeDeviceWatcherPreview
  public sealed class GazeDeviceWatcherRemovedPreviewEventArgs
  public sealed class GazeDeviceWatcherUpdatedPreviewEventArgs
  public sealed class GazeEnteredPreviewEventArgs
  public sealed class GazeExitedPreviewEventArgs
  public sealed class GazeInputSourcePreview
  public sealed class GazeMovedPreviewEventArgs
  public sealed class GazePointPreview
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScannerReport {
    public BarcodeScannerReport(uint scanDataType, IBuffer scanData, IBuffer scanDataLabel);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    bool IsVideoPreviewShownOnEnable { get; set; }
    void HideVideoPreview();
    IAsyncOperation<bool> ShowVideoPreviewAsync();
  }
  public sealed class UnifiedPosErrorData {
    public UnifiedPosErrorData(string message, UnifiedPosErrorSeverity severity, UnifiedPosErrorReason reason, uint extendedReason);
  }
}
namespace Windows.Devices.PointOfService.Provider {
  public sealed class BarcodeScannerDisableScannerRequest
  public sealed class BarcodeScannerDisableScannerRequestEventArgs
  public sealed class BarcodeScannerEnableScannerRequest
  public sealed class BarcodeScannerEnableScannerRequestEventArgs
  public sealed class BarcodeScannerGetSymbologyAttributesRequest
  public sealed class BarcodeScannerGetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerHideVideoPreviewRequest
  public sealed class BarcodeScannerHideVideoPreviewRequestEventArgs
  public sealed class BarcodeScannerProviderConnection : IClosable
  public sealed class BarcodeScannerProviderTriggerDetails
  public sealed class BarcodeScannerSetActiveSymbologiesRequest
  public sealed class BarcodeScannerSetActiveSymbologiesRequestEventArgs
  public sealed class BarcodeScannerSetSymbologyAttributesRequest
  public sealed class BarcodeScannerSetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerStartSoftwareTriggerRequest
  public sealed class BarcodeScannerStartSoftwareTriggerRequestEventArgs
  public sealed class BarcodeScannerStopSoftwareTriggerRequest
  public sealed class BarcodeScannerStopSoftwareTriggerRequestEventArgs
  public enum BarcodeScannerTriggerState
  public sealed class BarcodeSymbologyAttributesBuilder
}
namespace Windows.Foundation.Numerics {
  public struct Rational
}
namespace Windows.Globalization {
  public static class ApplicationLanguages {
    public static IVectorView<string> GetLanguagesForUser(User user);
 }
  public sealed class Language {
    LanguageLayoutDirection LayoutDirection { get; }
  }
  public enum LanguageLayoutDirection
}
namespace Windows.Graphics {
  public struct DisplayAdapterId
  public interface IGeometrySource2D
}
namespace Windows.Graphics.Capture {
  public sealed class Direct3D11CaptureFrame : IClosable
  public sealed class Direct3D11CaptureFramePool : IClosable
  public sealed class GraphicsCaptureItem
  public sealed class GraphicsCapturePicker
  public sealed class GraphicsCaptureSession : IClosable
}
namespace Windows.Graphics.DirectX {
  public enum DirectXColorSpace
}
namespace Windows.Graphics.Display {
  public sealed class AdvancedColorInfo
  public enum AdvancedColorKind
  public sealed class BrightnessOverrideSettings
  public sealed class ColorOverrideSettings
  public enum DisplayBrightnessOverrideScenario
  public enum DisplayColorOverrideScenario
  public sealed class DisplayEnhancementOverride
  public sealed class DisplayEnhancementOverrideCapabilities
  public sealed class DisplayEnhancementOverrideCapabilitiesChangedEventArgs
  public sealed class DisplayInformation {
    event TypedEventHandler<DisplayInformation, object> AdvancedColorInfoChanged;
    AdvancedColorInfo GetAdvancedColorInfo();
  }
  public enum HdrMetadataFormat
  public struct NitRange
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool CanOverrideViewport { get; }
  }
  public sealed class HolographicCameraPose {
    void OverrideProjectionTransform(HolographicStereoTransform projectionTransform);
    void OverrideViewport(Rect leftViewport, Rect rightViewport);
    void OverrideViewTransform(SpatialCoordinateSystem coordinateSystem, HolographicStereoTransform coordinateSystemToViewTransform);
  }
  public sealed class HolographicFramePresentationMonitor : IClosable
  public sealed class HolographicFramePresentationReport
  public sealed class HolographicSpace {
    HolographicSpaceUserPresence UserPresence { get; }
    event TypedEventHandler<HolographicSpace, object> UserPresenceChanged;
    HolographicFramePresentationMonitor CreateFramePresentationMonitor(uint maxQueuedReports);
    void WaitForNextFrameReady();
    void WaitForNextFrameReadyWithHeadStart(TimeSpan requestedHeadStartDuration);
  }
  public enum HolographicSpaceUserPresence
}
namespace Windows.Graphics.Imaging {
  public enum BitmapPixelFormat {
    P010 = 104,
  }
}
namespace Windows.Graphics.Printing {
  public sealed class PrintPageRange
  public sealed class PrintPageRangeOptions
  public sealed class PrintTaskOptions : IPrintTaskOptionsCore, IPrintTaskOptionsCoreProperties, IPrintTaskOptionsCoreUIConfiguration {
    IVector<PrintPageRange> CustomPageRanges { get; }
    PrintPageRangeOptions PageRangeOptions { get; }
  }
  public static class StandardPrintTaskOptions {
    public static string CustomPageRanges { get; }
  }
}
namespace Windows.Graphics.Printing.OptionDetails {
  public sealed class PrintBindingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintBorderingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCollationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintColorModeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCopiesOptionDetails : IPrintNumberOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomItemListOptionDetails : IPrintCustomOptionDetails, IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
    void AddItem(string itemId, string displayName, string description, IRandomAccessStreamWithContentType icon);
  }
  public sealed class PrintCustomTextOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomToggleOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails
  public sealed class PrintDuplexOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintHolePunchOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
 public sealed class PrintMediaSizeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintMediaTypeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public enum PrintOptionType {
    Toggle = 4,
  }
  public sealed class PrintOrientationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintPageRangeOptionDetails : IPrintOptionDetails
  public sealed class PrintQualityOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintStapleOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintTaskOptionDetails : IPrintTaskOptionsCore, IPrintTaskOptionsCoreUIConfiguration {
    PrintCustomToggleOptionDetails CreateToggleOption(string optionId, string displayName);
  }
}
namespace Windows.Management.Deployment {
  public sealed class PackageManager {
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris, IIterable<Uri> packageUrisToInstall);
  }
}
namespace Windows.Management.Update {
  public sealed class PreviewBuildsManager
  public sealed class PreviewBuildsState
}
namespace Windows.Media {
  public sealed class VideoFrame : IClosable, IMediaFrame {
    IAsyncAction CopyToAsync(VideoFrame frame, IReference<BitmapBounds> sourceBounds, IReference<BitmapBounds> destinationBounds);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height, IDirect3DDevice device);
    public static VideoFrame CreateWithDirect3D11Surface(IDirect3DSurface surface);
    public static VideoFrame CreateWithSoftwareBitmap(SoftwareBitmap bitmap);
  }
}
namespace Windows.Media.Audio {
  public sealed class AudioGraph : IClosable {
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource);
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource, AudioNodeEmitter emitter);
  }
  public sealed class AudioGraphSettings {
    double MaxPlaybackSpeedFactor { get; set; }
  }
  public sealed class AudioStateMonitor
  public sealed class CreateMediaSourceAudioInputNodeResult
  public sealed class MediaSourceAudioInputNode : IAudioInputNode, IAudioInputNode2, IAudioNode, IClosable
  public enum MediaSourceAudioInputNodeCreationStatus
}
namespace Windows.Media.Capture {
  public sealed class CapturedFrame : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType {
    BitmapPropertySet BitmapProperties { get; }
    CapturedFrameControlValues ControlValues { get; }
  }
  public enum KnownVideoProfile {
    HdrWithWcgPhoto = 8,
    HdrWithWcgVideo = 7,
    HighFrameRate = 5,
    VariablePhotoSequence = 6,
    VideoHdr8 = 9,
  }
  public sealed class MediaCaptureSettings {
    IDirect3DDevice Direct3D11Device { get; }
  }
  public sealed class MediaCaptureVideoProfile {
    IVectorView<MediaFrameSourceInfo> FrameSourceInfos { get; }
    IMapView<Guid, object> Properties { get; }
  }
  public sealed class MediaCaptureVideoProfileMediaDescription {
    IMapView<Guid, object> Properties { get; }
    string Subtype { get; }
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class AudioMediaFrame
  public sealed class MediaFrameFormat {
    AudioEncodingProperties AudioEncodingProperties { get; }
  }
  public sealed class MediaFrameReference : IClosable {
    AudioMediaFrame AudioMediaFrame { get; }
  }
  public sealed class MediaFrameSourceController {
    AudioDeviceController AudioDeviceController { get; }
  }
  public sealed class MediaFrameSourceInfo {
    string ProfileId { get; }
    IVectorView<MediaCaptureVideoProfileMediaDescription> VideoProfileMediaDescription { get; }
  }
  public enum MediaFrameSourceKind {
    Audio = 4,
    Image = 5,
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    AudioStreamDescriptor Copy();
  }
  public sealed class MediaBindingEventArgs {
    void SetDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    DownloadOperation DownloadOperation { get; }
    public static MediaSource CreateFromDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class TimedMetadataStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    VideoStreamDescriptor Copy();
  }
}
namespace Windows.Media.Devices {
  public sealed class VideoDeviceController : IMediaDeviceController {
    VideoTemporalDenoisingControl VideoTemporalDenoisingControl { get; }
  }
  public sealed class VideoTemporalDenoisingControl
  public enum VideoTemporalDenoisingMode
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp {
    IAsyncOperation<string> GetUniqueDeviceNameAsync();
  }
}
namespace Windows.Media.Effects {
  public sealed class VideoTransformEffectDefinition : IVideoEffectDefinition {
    VideoTransformSphericalProjection SphericalProjection { get; }
  }
  public sealed class VideoTransformSphericalProjection
}
namespace Windows.Media.MediaProperties {
  public sealed class AudioEncodingProperties : IMediaEncodingProperties {
    AudioEncodingProperties Copy();
  }
  public sealed class ContainerEncodingProperties : IMediaEncodingProperties {
    ContainerEncodingProperties Copy();
  }
  public sealed class ImageEncodingProperties : IMediaEncodingProperties {
    ImageEncodingProperties Copy();
  }
  public sealed class MediaEncodingProfile {
    IVector<TimedMetadataStreamDescriptor> GetTimedMetadataTracks();
    void SetTimedMetadataTracks(IIterable<TimedMetadataStreamDescriptor> value);
  }
  public static class MediaEncodingSubtypes {
    public static string P010 { get; }
  }
  public enum MediaPixelFormat {
    P010 = 2,
  }
  public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    VideoEncodingProperties Copy();
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSession {
    MediaRotation PlaybackRotation { get; set; }
    MediaPlaybackSessionOutputDegradationPolicyState GetOutputDegradationPolicyState();
  }
  public sealed class MediaPlaybackSessionOutputDegradationPolicyState
  public enum MediaPlaybackSessionVideoConstrictionReason
  public sealed class MediaPlayer : IClosable {
    AudioStateMonitor AudioStateMonitor { get; }
  }
}
namespace Windows.Media.SpeechSynthesis {
  public enum SpeechAppendedSilence
  public enum SpeechPunctuationSilence
  public sealed class SpeechSynthesizerOptions {
    SpeechAppendedSilence AppendedSilence { get; set; }
    SpeechPunctuationSilence PunctuationSilence { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
  public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class CellularApnContext {
    string ProfileName { get; set; }
  }
  public sealed class ConnectionProfileFilter {
    IReference<Guid> PurposeGuid { get; set; }
  }
  public sealed class WwanConnectionProfileDetails {
    WwanNetworkIPKind IPKind { get; }
    IVectorView<Guid> PurposeGuids { get; }
  }
  public enum WwanNetworkIPKind
}
namespace Windows.Networking.NetworkOperators {
  public sealed class ESim
  public sealed class ESimAddedEventArgs
  public enum ESimAuthenticationPreference
  public sealed class ESimDownloadProfileMetadataResult
  public static class ESimManager
  public sealed class ESimOperationResult
  public enum ESimOperationStatus
  public sealed class ESimPolicy
  public sealed class ESimProfile
  public enum ESimProfileClass
  public struct ESimProfileInstallProgress
  public sealed class ESimProfileMetadata
  public enum ESimProfileMetadataState
  public sealed class ESimProfilePolicy
  public enum ESimProfileState
  public sealed class ESimRemovedEventArgs
  public sealed class ESimServiceInfo
  public enum ESimState
  public sealed class ESimUpdatedEventArgs
  public sealed class ESimWatcher
  public enum ESimWatcherStatus
  public sealed class MobileBroadbandAntennaSar {
    public MobileBroadbandAntennaSar(int antennaIndex, int sarBackoffIndex);
  }
  public sealed class MobileBroadbandModem {
    bool IsInEmergencyCallMode { get; }
    event TypedEventHandler<MobileBroadbandModem, object> IsInEmergencyCallModeChanged;
    IAsyncOperation<MobileBroadbandPco> TryGetPcoAsync();
  }
  public sealed class MobileBroadbandModemIsolation
  public sealed class MobileBroadbandPco
  public sealed class MobileBroadbandPcoDataChangeTriggerDetails
  public enum NetworkOperatorDataUsageNotificationKind
  public sealed class NetworkOperatorDataUsageTriggerDetails
  public sealed class TetheringEntitlementCheckTriggerDetails
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocket : IClosable, IWebSocket {
    IAsyncOperationWithProgress<uint, uint> SendFinalFrameAsync(IBuffer data);
    IAsyncOperationWithProgress<uint, uint> SendNonfinalFrameAsync(IBuffer data);
  }
  public sealed class ServerMessageWebSocket : IClosable
  public sealed class ServerMessageWebSocketControl
  public sealed class ServerMessageWebSocketInformation
  public sealed class ServerStreamWebSocket : IClosable
  public sealed class ServerStreamWebSocketInformation
}
namespace Windows.Networking.Vpn {
  public sealed class VpnChannel {
    object CurrentRequestTransportContext { get; }
    void AddAndAssociateTransport(object transport, object context);
    ControlChannelTriggerStatus GetSlotTypeForTransportContext(object context);
    void ReplaceAndAssociateTransport(object transport, object context);
    void StartReconnectingTransport(object transport, object context);
    void StartWithTrafficFilter(IIterable<HostName> assignedClientIpv4Addresses, IIterable<HostName> assignedClientIpv6Addresses, VpnInterfaceId vpninterfaceId, VpnRouteAssignment assignedRoutes, VpnDomainNameAssignment assignedNamespace, uint mtuSize, uint maxFrameSize, bool reserved, IIterable<object> transports, VpnTrafficFilterAssignment assignedTrafficFilters);
  }
  public sealed class VpnPacketBuffer {
    object TransportContext { get; set; }
  }
}
namespace Windows.Security.Authentication.Identity.Provider {
  public enum SecondaryAuthenticationFactorAuthenticationMessage {
    CanceledByUser = 22,
    CenterHand = 23,
    ConnectionRequired = 20,
    DeviceUnavailable = 28,
    MoveHandCloser = 24,
    MoveHandFarther = 25,
    PlaceHandAbove = 26,
    RecognitionFailed = 27,
    TimeLimitExceeded = 21,
  }
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class FindAllAccountsResult
  public enum FindAllWebAccountsStatus
  public static class WebAuthenticationCoreManager {
    public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider);
    public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider, string clientId);
    public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId);
    public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId, string authority);
    public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId, string authority, User user);
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public sealed class WebProviderTokenRequest {
    string ApplicationPackageFamilyName { get; }
    string ApplicationProcessName { get; }
    IAsyncOperation<bool> CheckApplicationForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.Security.Credentials {
  public sealed class WebAccountProvider {
    bool IsSystemProvider { get; }
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRouteDrivingOptions {
    IReference<DateTime> DepartureTime { get; set; }
  }
  public sealed class PlaceInfo {
    public static PlaceInfo CreateFromAddress(string displayAddress);
    public static PlaceInfo CreateFromAddress(string displayAddress, string displayName);
  }
}
namespace Windows.Services.Store {
  public sealed class StoreCanAcquireLicenseResult
  public enum StoreCanLicenseStatus
  public sealed class StoreContext {
    bool CanSilentlyDownloadStorePackageUpdates { get; }
    IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseAsync(string productStoreId);
    IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseForOptionalPackageAsync(Package optionalPackage);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> DownloadAndInstallStorePackagesAsync(IIterable<string> storeIds);
    IAsyncOperation<IVectorView<StoreQueueItem>> GetAssociatedStoreQueueItemsAsync();
    IAsyncOperation<StoreProductQueryResult> GetStoreProductsAsync(IIterable<string> productKinds, IIterable<string> storeIds, StoreProductOptions storeProductOptions);
    IAsyncOperation<IVectorView<StoreQueueItem>> GetStoreQueueItemsAsync(IIterable<string> storeIds);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackagesAsync(IIterable<string> storeIds, StorePackageInstallOptions storePackageInstallOptions);
    IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageAsync(Package package);
    IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageByStoreIdAsync(string storeId);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadAndInstallStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
    IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageAsync(Package package);
    IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageByStoreIdAsync(string storeId);
  }
  public sealed class StorePackageInstallOptions
  public sealed class StorePackageUpdateResult {
    IVectorView<StoreQueueItem> StoreQueueItems { get; }
  }
  public sealed class StoreProductOptions
  public sealed class StoreQueueItem
  public sealed class StoreQueueItemCompletedEventArgs
  public enum StoreQueueItemExtendedState
  public enum StoreQueueItemKind
  public enum StoreQueueItemState
  public sealed class StoreQueueItemStatus
  public sealed class StoreUninstallStorePackageResult
  public enum StoreUninstallStorePackageStatus
}
namespace Windows.Storage {
  public sealed class StorageFolder : IStorageFolder, IStorageFolder2, IStorageFolderQueryOperations, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
    StorageLibraryChangeTracker TryGetChangeTracker();
  }
}
namespace Windows.Storage.Provider {
  public interface IStorageProviderUriSource
  public sealed class StorageProviderGetContentInfoForPathResult
  public sealed class StorageProviderGetPathForContentUriResult
  public enum StorageProviderUriSourceStatus
}
namespace Windows.Storage.Search {
  public sealed class StorageLibraryChangeTrackerTriggerDetails
}
namespace Windows.System {
  public sealed class AppActivationResult
  public sealed class AppDiagnosticInfo {
    IAsyncOperation<AppActivationResult> LaunchAsync();
  }
  public sealed class AppExecutionStateChangeResult
  public sealed class AppResourceGroupInfo {
    IAsyncOperation<AppExecutionStateChangeResult> StartResumeAsync();
    IAsyncOperation<AppExecutionStateChangeResult> StartSuspendAsync();
    IAsyncOperation<AppExecutionStateChangeResult> StartTerminateAsync();
  }
  public enum AutoUpdateTimeZoneStatus
  public static class TimeZoneSettings {
    public static IAsyncOperation<AutoUpdateTimeZoneStatus> AutoUpdateTimeZoneAsync(TimeSpan timeout);
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticInvoker {
    IAsyncOperationWithProgress<DiagnosticActionResult, DiagnosticActionState> RunDiagnosticActionFromStringAsync(string context);
  }
}
namespace Windows.System.Diagnostics.DevicePortal {
  public sealed class DevicePortalConnection {
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol, uint outboundBufferSizeInBytes, uint maxMessageSize, MessageWebSocketReceiveMode receiveMode);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request, string protocol, uint outboundBufferSizeInBytes, bool noDelay);
  }
  public sealed class DevicePortalConnectionRequestReceivedEventArgs {
    bool IsWebSocketUpgradeRequest { get; }
    IVectorView<string> WebSocketProtocolsRequested { get; }
    Deferral GetDeferral();
  }
}
namespace Windows.System.Inventory {
  public sealed class InstalledDesktopApp : IStringable
}
namespace Windows.System.Profile {
  public static class AnalyticsInfo {
    public static IAsyncOperation<IMapView<string, string>> GetSystemPropertiesAsync(IIterable<string> attributeNames);
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    RemoteSystemPlatform Platform { get; }
  }
  public sealed class RemoteSystemEnumerationCompletedEventArgs
  public enum RemoteSystemPlatform
  public sealed class RemoteSystemWatcher {
    event TypedEventHandler<RemoteSystemWatcher, RemoteSystemEnumerationCompletedEventArgs> EnumerationCompleted;
    event TypedEventHandler<RemoteSystemWatcher, RemoteSystemWatcherErrorOccurredEventArgs> ErrorOccurred;
  }
  public enum RemoteSystemWatcherError
  public sealed class RemoteSystemWatcherErrorOccurredEventArgs
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static GlobalizationPreferencesForUser GetForUser(User user);
  }
  public sealed class GlobalizationPreferencesForUser
}
namespace Windows.UI.ApplicationSettings {
  public sealed class AccountsSettingsPane {
    public static IAsyncAction ShowAddAccountForUserAsync(User user);
    public static IAsyncAction ShowManageAccountsForUserAsync(User user);
  }
  public sealed class AccountsSettingsPaneCommandsRequestedEventArgs {
    User User { get; }
  }
}
namespace Windows.UI.Composition {
  public sealed class AnimationController : CompositionObject
  public enum AnimationControllerProgressBehavior
  public sealed class BounceScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class BounceVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class BounceVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public sealed class CompositionContainerShape : CompositionShape
  public sealed class CompositionEllipseGeometry : CompositionGeometry
  public class CompositionGeometry : CompositionObject
  public class CompositionLight : CompositionObject {
    bool IsEnabled { get; set; }
  }
  public sealed class CompositionLineGeometry : CompositionGeometry
  public class CompositionObject : IClosable {
    AnimationController TryGetAnimationController(string propertyName);
  }
  public sealed class CompositionPath : IGeometrySource2D
  public sealed class CompositionPathGeometry : CompositionGeometry
  public sealed class CompositionRectangleGeometry : CompositionGeometry
  public sealed class CompositionRoundedRectangleGeometry : CompositionGeometry
  public class CompositionShape : CompositionObject
  public sealed class CompositionShapeCollection : CompositionObject, IIterable<CompositionShape>, IVector<CompositionShape>
  public sealed class CompositionSpriteShape : CompositionShape
  public enum CompositionStrokeCap
  public sealed class CompositionStrokeDashArray : CompositionObject, IIterable<float>, IVector<float>
  public enum CompositionStrokeLineJoin
  public sealed class CompositionViewBox : CompositionObject
  public sealed class Compositor : IClosable {
    string Comment { get; set; }
    float GlobalPlaybackRate { get; set; }
    public static float MaxGlobalPlaybackRate { get; }
    public static float MinGlobalPlaybackRate { get; }
    BounceScalarNaturalMotionAnimation CreateBounceScalarAnimation();
    BounceVector2NaturalMotionAnimation CreateBounceVector2Animation();
    BounceVector3NaturalMotionAnimation CreateBounceVector3Animation();
    CompositionContainerShape CreateContainerShape();
    CompositionEllipseGeometry CreateEllipseGeometry();
    CompositionLineGeometry CreateLineGeometry();
    CompositionPathGeometry CreatePathGeometry();
    CompositionPathGeometry CreatePathGeometry(CompositionPath path);
    PathKeyFrameAnimation CreatePathKeyFrameAnimation();
    CompositionRectangleGeometry CreateRectangleGeometry();
    CompositionRoundedRectangleGeometry CreateRoundedRectangleGeometry();
    ShapeVisual CreateShapeVisual();
    CompositionSpriteShape CreateSpriteShape();
    CompositionSpriteShape CreateSpriteShape(CompositionGeometry geometry);
    CompositionViewBox CreateViewBox();
    IAsyncAction RequestCommitAsync();
  }
  public sealed class PathKeyFrameAnimation : KeyFrameAnimation
  public sealed class PointLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
  public sealed class ShapeVisual : ContainerVisual
  public sealed class SpotLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
}
namespace Windows.UI.Composition.Core {
  public sealed class CompositorController : IClosable
}
namespace Windows.UI.Composition.Desktop {
  public sealed class DesktopWindowTarget : CompositionTarget
}
namespace Windows.UI.Composition.Diagnostics {
  public sealed class CompositionDebugHeatMaps
  public enum CompositionDebugOverdrawContentKinds : uint
  public sealed class CompositionDebugSettings
}
namespace Windows.UI.Composition.Interactions {
  public enum VisualInteractionSourceRedirectionMode {
    CapableTouchpadAndPointerWheel = 3,
    PointerWheelOnly = 2,
  }
}
namespace Windows.UI.Core {
  public enum AppViewBackButtonVisibility {
    Disabled = 2,
  }
  public sealed class CoreComponentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public sealed class CoreIndependentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public interface ICorePointerInputSource2 : ICorePointerInputSource
}
namespace Windows.UI.Input.Core {
  public sealed class RadialControllerIndependentInputSource {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.UI.Input.Inking {
  public sealed class InkDrawingAttributes {
    InkModelerAttributes ModelerAttributes { get; }
  }
  public sealed class InkInputConfiguration
  public sealed class InkModelerAttributes
  public sealed class InkPresenter {
    InkInputConfiguration InputConfiguration { get; }
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.UI.Notifications {
  public sealed class ScheduledToastNotification {
    IReference<DateTime> ExpirationTime { get; set; }
  }
}
namespace Windows.UI.StartScreen {
  public sealed class TileMixedRealityModel {
    TileMixedRealityModelActivationBehavior ActivationBehavior { get; set; }
  }
  public enum TileMixedRealityModelActivationBehavior
}
namespace Windows.UI.Text {
  public sealed class ContentLinkInfo
  public sealed class RichEditTextRange : ITextRange
  public enum TextRangeUnit {
    ContentLink = 32,
  }
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView {
    event TypedEventHandler<CoreInputView, object> XYFocusTransferredToPrimaryView;
    event TypedEventHandler<CoreInputView, CoreInputViewTransferringXYFocusEventArgs> XYFocusTransferringFromPrimaryView;
    bool TryTransferXYFocusToPrimaryView(Rect origin, CoreInputViewXYFocusTransferDirection direction);
  }
  public sealed class CoreInputViewTransferringXYFocusEventArgs
  public enum CoreInputViewXYFocusTransferDirection
}
namespace Windows.UI.WebUI {
  public sealed class WebUIBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public sealed class WebUILaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, ILaunchActivatedEventArgs2, IPrelaunchActivatedEventArgs {
    TileActivatedInfo TileActivatedInfo { get; }
  }
}
namespace Windows.UI.Xaml {
  public sealed class BringIntoViewOptions {
    double HorizontalAlignmentRatio { get; set; }
    double HorizontalOffset { get; set; }
    double VerticalAlignmentRatio { get; set; }
    double VerticalOffset { get; set; }
  }
  public sealed class BringIntoViewRequestedEventArgs : RoutedEventArgs
  public sealed class ElementSoundPlayer {
    public static ElementSpatialAudioMode SpatialAudioMode { get; set; }
  }
  public enum ElementSpatialAudioMode
  public enum FocusVisualKind {
    Reveal = 2,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent BringIntoViewRequestedEvent { get; }
    public static RoutedEvent ContextRequestedEvent { get; }
    KeyboardAcceleratorPlacementMode KeyboardAcceleratorPlacementMode { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementModeProperty { get; }
    DependencyObject KeyboardAcceleratorPlacementTarget { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementTargetProperty { get; }
    DependencyObject KeyTipTarget { get; set; }
    public static DependencyProperty KeyTipTargetProperty { get; }
    event TypedEventHandler<UIElement, BringIntoViewRequestedEventArgs> BringIntoViewRequested;
    virtual void OnBringIntoViewRequested(BringIntoViewRequestedEventArgs e);
    virtual void OnKeyboardAcceleratorInvoked(KeyboardAcceleratorInvokedEventArgs args);
    public static void RegisterAsScrollPort(UIElement element);
  }
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty HeadingLevelProperty { get; }
 }
  public sealed class AutomationProperties {
    public static DependencyProperty HeadingLevelProperty { get; }
    public static AutomationHeadingLevel GetHeadingLevel(DependencyObject element);
    public static void SetHeadingLevel(DependencyObject element, AutomationHeadingLevel value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationHeadingLevel
  public class AutomationPeer : DependencyObject {
    AutomationHeadingLevel GetHeadingLevel();
    virtual AutomationHeadingLevel GetHeadingLevelCore();
  }
  public sealed class AutoSuggestBoxAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider {
    void Invoke();
  }
  public class CalendarDatePickerAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider, IValueProvider
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer, IExpandCollapseProvider
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarButtonTemplateSettings TemplateSettings { get; }
  }
  public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarToggleButtonTemplateSettings TemplateSettings { get; }
  }
  public sealed class ContentLinkChangedEventArgs
  public enum ContentLinkChangeKind
  public sealed class HandwritingPanelClosedEventArgs
  public sealed class HandwritingPanelOpenedEventArgs
  public enum HandwritingPanelPlacementAlignment
  public class HandwritingView : Control
  public class MediaTransportControls : Control {
    bool IsCompactOverlayButtonVisible { get; set; }
    public static DependencyProperty IsCompactOverlayButtonVisibleProperty { get; }
    bool IsCompactOverlayEnabled { get; set; }
    public static DependencyProperty IsCompactOverlayEnabledProperty { get; }
  }
  public class MenuFlyoutItem : MenuFlyoutItemBase {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    MenuFlyoutItemTemplateSettings TemplateSettings { get; }
  }
  public class NavigationView : ContentControl {
    NavigationViewBackButtonVisible IsBackButtonVisible { get; set; }
    public static DependencyProperty IsBackButtonVisibleProperty { get; }
    bool IsBackEnabled { get; set; }
    public static DependencyProperty IsBackEnabledProperty { get; }
    string PaneTitle { get; set; }
    public static DependencyProperty PaneTitleProperty { get; }
    event TypedEventHandler<NavigationView, NavigationViewBackRequestedEventArgs> BackRequested;
    event TypedEventHandler<NavigationView, object> PaneClosed;
    event TypedEventHandler<NavigationView, NavigationViewPaneClosingEventArgs> PaneClosing;
    event TypedEventHandler<NavigationView, object> PaneOpened;
    event TypedEventHandler<NavigationView, object> PaneOpening;
  }
  public enum NavigationViewBackButtonVisible
  public sealed class NavigationViewBackRequestedEventArgs
  public sealed class NavigationViewPaneClosingEventArgs
  public class RefreshContainer : ContentControl
  public sealed class RefreshInteractionRatioChangedEventArgs
  public enum RefreshPullDirection
  public sealed class RefreshRequestedEventArgs
  public sealed class RefreshStateChangedEventArgs
  public class RefreshVisualizer : Control
  public enum RefreshVisualizerOrientation
  public enum RefreshVisualizerState
  public class RichEditBox : Control {
    SolidColorBrush ContentLinkBackgroundColor { get; set; }
    public static DependencyProperty ContentLinkBackgroundColorProperty { get; }
    SolidColorBrush ContentLinkForegroundColor { get; set; }
    public static DependencyProperty ContentLinkForegroundColorProperty { get; }
    ContentLinkProviderCollection ContentLinkProviders { get; set; }
    public static DependencyProperty ContentLinkProvidersProperty { get; }
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
    event TypedEventHandler<RichEditBox, ContentLinkChangedEventArgs> ContentLinkChanged;
    event TypedEventHandler<RichEditBox, ContentLinkInvokedEventArgs> ContentLinkInvoked;
  }
  public class TextBox : Control {
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
  }
  public class TreeView : Control
  public sealed class TreeViewCollapsedEventArgs
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemInvokedEventArgs
  public class TreeViewItemTemplateSettings : DependencyObject
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject
  public enum TreeViewSelectionMode
  public sealed class WebView : FrameworkElement {
    event TypedEventHandler<WebView, WebViewSeparateProcessLostEventArgs> SeparateProcessLost;
  }
  public enum WebViewExecutionMode {
    SeparateProcess = 2,
  }
  public enum WebViewPermissionType {
    ImmersiveView = 6,
    Screen = 5,
  }
  public sealed class WebViewSeparateProcessLostEventArgs
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    string Region { get; set; }
    public static DependencyProperty RegionProperty { get; }
  }
  public class MapElement : DependencyObject {
    bool IsEnabled { get; set; }
    public static DependencyProperty IsEnabledProperty { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public sealed class AppBarButtonTemplateSettings : DependencyObject
  public sealed class AppBarToggleButtonTemplateSettings : DependencyObject
  public sealed class MenuFlyoutItemTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Documents {
  public sealed class ContactContentLinkProvider : ContentLinkProvider
  public sealed class ContentLink : Inline
  public sealed class ContentLinkInvokedEventArgs
  public class ContentLinkProvider : DependencyObject
  public sealed class ContentLinkProviderCollection : IIterable<ContentLinkProvider>, IVector<ContentLinkProvider>
  public sealed class PlaceContentLinkProvider : ContentLinkProvider
}
namespace Windows.UI.Xaml.Input {
  public sealed class FocusManager {
    public static IAsyncOperation<FocusMovementResult> TryFocusAsync(DependencyObject element, FocusState value);
    public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection);
    public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
  }
  public sealed class FocusMovementResult
  public sealed class GettingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
  public sealed class KeyboardAcceleratorInvokedEventArgs {
    KeyboardAccelerator KeyboardAccelerator { get; }
  }
  public enum KeyboardAcceleratorPlacementMode
  public sealed class LosingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
}
namespace Windows.UI.Xaml.Media {
  public sealed class CompositionTarget {
    public static event EventHandler<RenderedEventArgs> Rendered;
  }
  public sealed class RenderedEventArgs
}
namespace Windows.Web.UI {
  public interface IWebViewControl
  public sealed class WebViewControlContentLoadingEventArgs
  public sealed class WebViewControlDeferredPermissionRequest
  public sealed class WebViewControlDOMContentLoadedEventArgs
  public sealed class WebViewControlLongRunningScriptDetectedEventArgs
  public sealed class WebViewControlNavigationCompletedEventArgs
  public sealed class WebViewControlNavigationStartingEventArgs
  public sealed class WebViewControlNewWindowRequestedEventArgs
  public sealed class WebViewControlPermissionRequest
  public sealed class WebViewControlPermissionRequestedEventArgs
  public enum WebViewControlPermissionState
  public enum WebViewControlPermissionType
  public sealed class WebViewControlScriptNotifyEventArgs
  public sealed class WebViewControlSettings
  public sealed class WebViewControlUnsupportedUriSchemeIdentifiedEventArgs
  public sealed class WebViewControlUnviewableContentIdentifiedEventArgs
  public sealed class WebViewControlWebResourceRequestedEventArgs
}
namespace Windows.Web.UI.Interop {
  public sealed class WebViewControl : IWebViewControl
  public sealed class WebViewControlAcceleratorKeyPressedEventArgs
  public enum WebViewControlAcceleratorKeyRoutingStage
  public enum WebViewControlMoveFocusReason
  public sealed class WebViewControlMoveFocusRequestedEventArgs
  public sealed class WebViewControlProcess
  public enum WebViewControlProcessCapabilityState
  public sealed class WebViewControlProcessOptions
}

Go to Source

Share this
07 Mar 2018

Announcing Windows 10 Insider Preview Build 17618 for Skip Ahead

Author: Dona Sarkar
Go to Source

Hello Windows Insiders!

Today, we are releasing Windows 10 Insider Preview Build 17618 (RS5) to Windows Insiders who have opted into Skip Ahead.

What’s new in Build 17618

Sets: Sets is designed to make sure that everything related to your task: relevant webpages, research documents, necessary files, and applications, is connected and available to you in one click. Starting today in RS5 builds, we have turned the Sets experiment back on so any Insider who has opted into Skip Ahead will be able to try out Sets. With Sets, 1st party experiences like Mail, Calendar, OneNote, MSN News, Windows and Microsoft Edge become more integrated to create a seamless experience, so you can get back to what’s important and be productive, recapturing that moment, saving time – we believe that’s the true value of Sets. Additional app integration with Sets is expected over time.

Sets supports Win32 apps in addition to UWP apps and websites!

If you are an Insider who was testing out Sets previously, you’ll find the following improvements to the experience:

  • Support for desktop (Win32) apps. Sets now supports File Explorer, Notepad, Command Prompt, and PowerShell. One of the top feature requests by Insiders has been tabs for File Explorer and with Sets you can get a tabbed File Explorer experience! Try it out with these apps and let us know what you think!
  • You can now launch apps from the new tab page by typing the app name into the search box.
  • UWP apps are launched in the same window replacing the new tab page.
  • The tab UI in Sets now shows icons including website favicons and app icons.
  • Resume your project with more control – When restoring your projects you’ll be prompted to restore related apps and webpages. In Timeline you’ll see when a project has multiple activities associated with it.

Here are a few keyboard shortcuts you can try out:

  • Ctrl + Win + Tab – switch to next tab.
  • Ctrl + Win + Shift + Tab – switch to previous tab.
  • Ctrl + Win + T – open a new tab.
  • Ctrl + Win + W – close current tab.

Here are a few things we’re still working on that aren’t quite finished yet:

  • Tab drag-and-drop does not work for re-ordering tabs. You can’t drag a tab to join another window.
  • When launching a supported desktop (Win32) app from a tabbed window, such as protocol/file launch or from the new tab page, it launches in a new window instead of auto-grouping to the existing window. You can work around this for now by holding down the Ctrl key while launching a supported desktop (Win32) app – note, for File Explorer, in particular, you will need to hold down Ctrl until the new tab with File Explorer appears, not just Ctrl + click and immediately release.
  • You may notice some flashes when switching between tabs within a Set.
  • If your display scaling is higher than 100%, using touch to interact with the Sets title bar won’t work.

If needed, you can find a setting to enable or disable Sets under Settings > System > Multitasking. We’re looking forward to your feedback as you try it out in today’s build!

Windows Mixed Reality

There are two issues impacting the usability of Windows Mixed Reality on this build. Windows Mixed Reality runs at a very low frame rate (8-10fps) that could result in some physical discomfort. And there are multiple crashes at startup that will cause Windows Mixed Reality to not work. For Insiders who want to keep Windows Mixed Reality working – you might want to consider hitting pause on taking new Insider Preview builds until these issues are fixed. You can pause Insider Preview builds by going to Settings > Update & Security > Windows Insider Program and pressing the “Stop Insider Preview builds” button and choosing “Pause updates for a bit”.

General changes, improvements, and fixes for PC

  • We fixed an issue resulting in 3 and 4 finger gestures on the touchpad being unresponsive in the last two flights.
  • We fixed an issue that could result in UWP apps sometimes launching as small white rectangular boxes.
  • We fixed an issue where the Settings tile didn’t have a name if you pinned it to Start.
  • We fixed an issue where navigating to Themes Settings crashed Settings.
  • We fixed a typo in Storage Sense Settings.
  • We fixed an issue resulting in all dropdowns in Settings appearing blank until clicked.
  • We fixed an issue that could result in Settings crashing after having navigated to and left Sound Settings.
  • We fixed an issue that could result in the labels for files on the desktop overlapping their icons.
  • We fixed an issue resulting in the hamburger button in Windows Defender overlapping the home button.
  • We’ve updated Start so that it now follows the new Ease of Access setting to enable or disable hiding scrollbars.
  • We’ve updated the Action Center so that notifications will now appear with a fade in animation when you open it.
  • We’ve updated the new notification to fix blurry apps so that it now will persist in the Action Center to be accessed later once the toast has timed out and dismissed.
  • We fixed an issue resulting in some app icons appearing distorted in Task View.
  • We fixed an issue where making a pinch gesture over the open apps in Task View might result in no longer being able to scroll down to Timeline.
  • We fixed an issue where pressing and holding on a card in Timeline would open the corresponding app, rather than bringing up a context menu.
  • We fixed an issue resulting in the title bar overlapping content when you opened your lists in Cortana’s notebook.
  • We fixed an issue resulting in the Windows Defender offline scan not working in recent builds.
  • We fixed an issue where the Japanese IME sometimes wouldn’t turn on correctly.
  • We fixed an issue where the floating dictation UI could be unexpectedly tiny.
  • We fixed an issue where the touch keyboard might stop invoking automatically after locking the PC and then unlocking the PC by using the touch keyboard to enter your PIN or password.
  • We fixed an issue where the touch keyboard number pad would show the period as a decimal separator for countries that use the comma as a decimal separator.
  • We fixed an issue resulting in not being able to turn on and off third-party IMEs using the touch keyboard.
  • We fixed an issue resulting in numbers not being inserted when flicking up on the top row of letters in the wide touch keyboard layout.
  • We fixed an issue where plugging in an external optical drive (DVD) would cause an Explorer.exe crash.
  • We fixed an issue resulting in DirectAccess not working in recent builds, where the connection would be stuck with status “Connecting”.
  • We fixed an issue where all apps in Task Manager’s Startup tab had the status “0 suspended”.
  • We fixed an issue where after upgrading your speaker volume might change to 67%.
  • We’ve updated Microsoft Edge’s Hub to now have an acrylic navigation pane.
  • We fixed an issue where it wasn’t possible to open a new inPrivate window of Microsoft Edge from the taskbar jumplist while in Tablet Mode.
  • We fixed an issue where dragging a Microsoft Edge tab out of the window and releasing hold of it somewhere over the desktop might periodically result in a stuck invisible window.
  • We fixed an issue where the keyboard combo to switch Virtual Desktops didn’t work if Microsoft Edge was open on multiple Virtual Desktops and focus was on the web content.
  • We fixed an issue that could result in tabs hanging and not loading content recently in Microsoft Edge after using the browser for a few days with an adblocker enabled.
  • We fixed an issue where clicking to zoom in on an image in Microsoft Edge would zoom into the top left corner rather than the area where you’d clicked.
  • We fixed an issue from the last few flights where Microsoft Edge might crash if you refreshed a window with a PDF open in it.
  • We fixed an issue in Microsoft Edge where favicons in light theme were unexpectedly getting black backgrounds.
  • We fixed an issue where the buttons on Game bar were not centered correctly.
  • We fixed an issue where in some games—such as Destiny 2 and Fortnite—mouse and keyboard input would still go to the game while Game bar was open.
  • We fixed an issue where keyboard and mouse input might not work correctly in Game bar when playing a first-person game (e.g. Minecraft).
  • We fixed an issue in the text box for Mixer stream title, using non-character keys (e.g. Tab, Delete, Backspace, etc.) might cause the game to hang for a few seconds.
  • We fixed an issue where bringing up Game bar using the Xbox button on an Xbox One controller didn’t work in some games.
  • We fixed an issue where certain games using Easy Anti Cheat could result in the system experiencing a bugcheck (KMODE_EXCEPTION_NOT_HANDLED).
  • We fixed an issue where we had observed seeing longer-than-normal delays during install at the 88% mark. Some delays were as long as 90 minutes before moving forward.
  • We fixed an issue in apps like Movies & TV where if you deny consent to access your library it crashes the app.
  • We fixed an issue where on post-install at the first user-prompted reboot or shutdown, a small number of devices would experience a scenario wherein the OS fails to load properly and may enter a reboot loop state.
  • We fixed an issue where selecting a notification after taking a screenshot or game clip opens the Xbox app’s home screen instead of opening the screenshot or game clip.
  • We fixed an issue where tearing a PDF tab in Microsoft Edge will result in a bugcheck (GSOD).

Known issues

  • IMPORTANT: The Microsoft Store may be completely broken or disappeared altogether after upgrading to this build. Please see this forum post for details including a workaround on how to get the Microsoft Store back.
  • If you open Settings and clicking on any links to the Microsoft Store or links in tips, Settings will crash. This includes the links to get themes and fonts from the Microsoft Store.
  • If you try to open a file that is available online-only from OneDrive that hasn’t been previously downloaded to your PC (marked with a green checkmark in File Explorer), your PC could bugcheck (GSOD). You can work around this problem by right-clicking on these files and selecting “Always keep on this device.” Any file-on-demand from OneDrive that is already downloaded to the PC should open fine.

Office Insider + Skip Ahead = More awesome!

Our friends on the Office team want to reiterate their invitation for Windows Insiders to participate in feedback and product usage which will inform the next generation of Office innovations! Windows and Office are continually looking for the best-connected experiences. Your feedback is extremely valuable to us and will help us to understand customer needs and scenarios and to prioritize our investments in the coming months. Please join the Office Insider Program to help directly affect product design decisions!

No downtime for Hustle-As-A-Service,
Dona <3

Go to Source

Share this
07 Mar 2018

AI Platform for Windows Developers

Author: Kam VedBrat
Go to Source

At Microsoft, we’re making huge investments in AI and Machine Learning across the company. AI capabilities in Office 365 help subscribers with productivity at work, intelligent features in the Photos app for Windows 10 make it easier for people to create videos and search through massive photo collections, and Windows Hello uses AI to recognize your face and get you quickly logged in to your Windows devices. We also use AI to answer your questions when using Bing Search and Cortana, to enable advertisers build deeper connections with customers, and to help security professionals safeguard businesses against modern threats. Microsoft Research continues to drive the state of the art with speech recognition, machine reading and comprehension, computer vision. We’ve scaled AI to tiny devices, and even built AI that can draw!

“Intel’s Movidius VPU technology will deliver increasingly sophisticated AI experiences for the hundreds of millions of Microsoft users worldwide,” said Intel’s Remi El-Ouazzane, Vice President and General Manager of Movidius.

With the next major update to Windows 10, we begin to deliver the advances that have been built into our apps and services as part of the Windows 10 platform. Every developer that builds apps on Windows 10 will be able to use AI to deliver more powerful and engaging experiences.

“AI acceleration on Window 10 PCs is the latest evidence of how artificial intelligence is becoming ubiquitous in our everyday lives,” said Ian Buck, vice president and general manager, Accelerated Computing, at NVIDIA. “NVIDIA is delighted to be partnering with Microsoft to enhance the PC experience for users worldwide.”

The AI platform in Windows 10 enables developers to use pre-trained machine learning models in their Apps on Windows devices. This offers developers a number of benefits:

  • Low latency, real-time results. Windows can perform AI evaluation tasks using the local processing capabilities of the PC, enabling real-time analysis of large local data such as images and video. Results can be delivered quickly and efficiently for use in performance intensive workloads like game engines, or background tasks such as indexing for search.
  • Reduced operational costs. Together with Microsoft’s Cloud AI platform, developers can build affordable, end-to-end AI solutions that combine training models in Azure with deployment to Windows devices for evaluation. Significant savings can be realized by reducing or eliminating costs associated with bandwidth due to ingestion of large data sets, such as camera footage or sensor telemetry. Complex workloads can be processed in real-time on the edge, with minimal sample data sent to the cloud for improved training on observations.
  • Flexibility. Developers can choose to perform AI tasks on device or in the cloud based on what their customers & scenarios need. AI processing can happen on the device if it becomes disconnected, or in scenarios where data cannot be sent to the cloud due to cost, size, policy or customer preference. 

“We’re excited to be collaborating with Microsoft on the Windows ML platform, and helping developers accelerate on-device AI performance on Windows laptops with the Snapdragon 835 AI Engine.” Gary Brotman, Director of Product Management – AI and Machine Learning, Qualcomm Technologies, Inc.

Our ML model evaluation is tuned for efficiency across the diverse silicon that runs Windows. By using instruction set optimizations on modern CPUs, hardware acceleration on GPUs that support DirectX 12, and a driver model for purpose-built AI processors in the future, we deliver performance and efficiency on the broadest range of form factors. With the update, developers can use the AI platform across the Windows device family, including IoT edge devices, HoloLens, 2-in-1s and desktop PCs, workstations, servers and in data centers.

“We’re excited to work with Microsoft on Windows ML as a part of taking advantage of the high-performance capabilities of AMD CPUs and GPUs to bring AI acceleration to Windows 10 PCs.” – Andre Zdravkovic, CVP Software, AMD

Windows supports ONNX, an industry standard format for ML models that is driven by Microsoft, Facebook, and Amazon Web Services, and supported by Windows IHVs including NVIDIA, Intel, Qualcomm and AMD. Data scientists can train and deliver ONNX models for use by Windows developers using Azure Machine Learning Workbench, and coming soon, the Azure Custom Vision Service will also support creating ONNX models for Windows.

We’ve also invested in delivering a great development experience for AI developers on Windows. Starting with Visual Studio Preview 15.7, adding an ONNX file to a UWP project will automatically generate a model interfaces in your project. For prior versions of Visual Studio, developers can use the MLGen tool to generate the code interface and then manually add it to their projects. This capability will be coming soon to Visual Studio tools for AI as well.

For consumers, this is just the beginning! You’ll see more intelligence in every day experiences on Windows devices. Developers can build AI powered apps that help you inspire and communicate in 3d, keep track of tasks and commitments more easily, and listen to music from playlists made just right for you.

You can learn more about our AI journey at Windows Developer Day on March 7, and at //build 2018.

Go to Source

Share this
07 Mar 2018

Three things you need to know about Windows Developer Day

Author: Kevin Gallo
Go to Source

We live in an interconnected world and the digital transformation that companies are going through are as unique as the companies themselves. The opportunity to explore new approaches and new technology has never been greater than it is today. With that in mind, I’m privileged to share with you key advancements available in the SDK for the next Windows 10 Update. At the Windows Developer Day event, we focused on three specific areas:

  • Making it easier for desktop developers to modernize their applications
  • Introducing AI for Windows
  • Windows IoT will help you expand into the Intelligent Edge

Modern applications for a modern workplace

For those of you building new applications for the modern workplace, UWP continues to be our modern native platform and the best path forward. At the same time, we understand that developers want to reuse and preserve code investments too. For those of you who are maintaining Windows desktop applications, you can now add modern experiences into your existing Win32, WPF, or Windows Forms applications incrementally.

  • Modern WebView using the Microsoft Edge rendering engine is now available to all Win32, WPF, and Windows Forms applications – providing the latest improvements from our Web Platform. Developers will also have access to the latest web technologies such as Grid and Flexbox layouts, HTTP intercepting and WebRTC.
  • MSIX is our vision for a complete containerization solution and it inherits all the great features in UWP and most importantly, it applies to all Win32, WPF, Windows Forms, and UWP applications. The MSIX packaging format was open sourced today.
  • Adaptive cards gives you a flexible way to present your content and data to enable you to connect with your users. Examples of high value engagement surfaces are notifications, activities in Timeline, and bots in Skype and Teams. The 1.0 release is available today.

Additionally, it’s exciting to see community development tools come to market. Advanced Installer announced their Advanced Installer Express Edition, a free tool to modernize existing Windows desktop applications and create an .appx package. We are also working with other 3rd party installers.

Artificial Intelligence for Modern Experiences

With the SDK for the next Windows 10 Update, developers can use AI to deliver more powerful and engaging experiences. Developers can use pre-trained machine learning models in their apps, to deliver AI experiences with the following benefits.

  • Low latency, real-time results. Windows can perform AI evaluation tasks using the local processing capabilities of the PC, and results can be delivered quickly and efficiently.
  • Reduced operational costs. Together with Microsoft’s Cloud AI platform, developers can build affordable, end-to-end AI solutions that combine training models in Azure with deployment to Windows devices for evaluation. Significant savings can be realized by reducing or eliminating costs associated with bandwidth due to ingestion of large data sets, such as camera footage or sensor telemetry. Complex workloads can be processed in real-time on the edge, with minimal sample data sent to the cloud for improved training on observations.
  • Flexibility. Developers can choose to perform AI tasks on a device or in the cloud based on what their customers and scenarios needs are. AI processing can happen on the device if it becomes disconnected, or in scenarios where data cannot be sent to the cloud due to cost, size, policy, or customer preference.

Windows supports ONNX, an industry standard format for ML models that is driven by Microsoft, Facebook, and Amazon Web Services, and supported by Windows IHVs including NVIDIA, Intel, Qualcomm and AMD. With the update, developers can use the AI platform across the Windows 10 devices family, including IoT edge devices, HoloLens, 2-in-1s and desktop PCs, workstations, servers, and in data centers. To learn more, read AI Platform for Windows Developers.

Windows Internet of Things in the Intelligent Cloud and Intelligent Edge

We’ve noticed a fundamental change in the way applications are being built and the shift from being a mobile device-centric world to a world that’s more interconnected with all our devices.

Today, we shared two editions of Windows 10 IoT to help your applications excel in our interconnected world.

  • Windows 10 IoT Core for small footprint smart edge devices. With NXP modules available below $50/unit, you can build great low-cost solutions on Windows 10.
  • Windows 10 IoT Enterprise on powerful PC or Server-class hardware. Windows IoT Enterprise will be great for larger devices such as ATMs, medical devices, or industrial scales to name a few.

Whichever edition you choose, you can use the same tools and workflow, using Visual Studio, NuGet, remote debugging, and others that you are familiar with.

The Intelligent Edge is the interface between the cloud and the real world. It is the layer of devices that we use to access the data in the cloud onto your device.  Below are some great partners we featured earlier today.

  • VW’s MQB platform is a great metaphor for what you get from Windows 10 when you build a device on a more complete platform. We allow developers to be the fastest from concept to market.
  • The Misty One from Misty Robotics, benefitted from the Windows 10 “chassis” and they were able to get a complete product together much faster than pulling everything together themselves.
  • Xogo chose Windows 10 IoT Core on their Xogo Mini for the low-cost silicon and the ability to use the same app as on PCs.

Earlier today, we described how using Azure Cognitive Services on the Intelligent Edge could be used to inject even more capability into a digital sign—to create a sign that sees you, listens to you, talks to you, and gets to know you.

The Intelligent Cloud gives you the ability to process all the data coming from the world around you, react to events, and work in a serverless environment.  Practically speaking, you can quickly and easily bring cloud microservices to Windows using Azure IoT Edge. This component of Azure is in public preview today.

This next update to Windows 10 provides you with the building blocks we have available today. With Windows machine learning and Azure IoT Edge Public Preview you can experiment on your Windows PC or pick up a low-cost Windows IoT device.

Community and Thanks

I would like to thank the MVPs and RDs who joined us in Redmond today – the Windows community is crucial to the Windows developer platform. I’d also like to thank all developers who are participating in the Windows Insiders Program and have been using the Windows Insider Preview SDK.  We value your insights, suggestions, and your feedback.

I look forward to seeing what you create with the next Windows 10 Update.  For more details, go to dev.windows.com. We also look forward to continuing this conversation with you at Build, so I hope you can join us there. Thank you!

Go to Source

Share this

© 2010-2018 Alt-Tech Inc. All rights reserved.

Click Me