Download Report

Windows 10 IoT Core
Insider Preview
Overview and Getting
Started
Version 1.0
April 2015
Proprietary Notice
© 2015 Microsoft. All rights reserved. This document is provided “as-is”. Information and views
expressed in this document, including URL and other Internet website references, may change without
notice. You bear the risk of using it. Some examples depicted herein are provided for illustration only and
are fictitious. No real association or connection is intended or should be inferred.
This document does not provide you with any legal rights to any intellectual property in any Microsoft
product. You may copy and use this document for your internal, reference purposes.
Table of Contents
Overview ---------------------------------------------------------------------------- 1
WHAT IS WINDOWS 10 IOT CORE INSIDER PREVIEW? ------------------------------------------------------------------------- 1
HOW DOES WINDOWS 10 IOT CORE INSIDER PREVIEW COMPARE TO WINDOWS EMBEDDED COMPACT?---------------- 2
Key Concepts ----------------------------------------------------------------------- 2
HEADED/HEADLESS ---------------------------------------------------------------------------------------------------------------- 2
SHELL AND DEVICE EXPERIENCE -------------------------------------------------------------------------------------------------- 3
Getting Started -------------------------------------------------------------------- 4
WINDOWS 10 IOT CORE INSIDER PREVIEW HARDWARE REQUIREMENTS ----------------------------------------------------- 4
BUILDING DEVICE DRIVERS ---------------------------------------------------------------------------------------------------------7
GETTING STARTED WITH UNIVERSAL DRIVERS ---------------------------------------------------------------- 8
BUILDING UNIVERSAL DRIVERS ----------------------------------------------------------------------------- 8
BUILDING APPLICATIONS ---------------------------------------------------------------------------------------------------------- 8
BUILDING UNIVERSAL APPLICATIONS ----------------------------------------------------------------------- 9
TOOLS ------------------------------------------------------------------------------------------------------------------------------ 10
VISUAL STUDIO ------------------------------------------------------------------------------------------ 10
WINDOWS ASSESSMENT AND DEPLOYMENT KIT (ADK) ----------------------------------------------------- 10
IMAGE CONFIGURATION DESIGNER (ICD) ------------------------------------------------------------------ 10
PORTING ------------------------------------------------------------------------------------------------ 11
SETTING UP YOUR DEVICE & FIRST STEPS --------------------------------------------------------------------------------------- 11
REMOTE DEVICE MANAGEMENT ------------------------------------------------------------------------------------------------- 11
INITIATING A REMOTE POWERSHELL (PS) SESSION ---------------------------------------------------------- 12
COMMONLY USED UTILITIES ------------------------------------------------------------------------------- 12
SECURING YOUR DEVICE WITH A TPM 2.0 -------------------------------------------------------------------------------------- 14
GETTING STARTED WITH A DISCRETE TPM MODULE OR TPM-SIMULATOR ------------------------------------- 15
Appendix --------------------------------------------------------------------------- 15
DETAILED TOPICS ----------------------------------------------------------------------------------------------------------------- 15
SHELL CONFIGURATION DETAILS -------------------------------------------------------------------------- 16
FOR MORE INFORMATION: -------------------------------------------------------------------------------------------------------- 19
1
Overview
What is Windows 10 IoT Core Insider
Preview?
Windows 10 IoT Core Insider Preview is a small footprint version of Windows 10 that is based on the
Windows 10 common core and enables lower cost devices with fewer resources. Windows IoT Core
targets devices with a minimum of 256 MB of RAM in a configuration without a screen (headless), or 512
MB of RAM with Windows Video display capabilities (headed), both with a minimum storage requirement
of 2 GB.
Windows IoT Core is similar in concept to previous versions of Windows Embedded Standard or
Windows Embedded Compact in that it targets dedicated devices, not traditional consumer PCs. It
enables many new low cost devices that can be quickly acquired, developed and deployed. In addition to
the numerous commercial embedded Windows customers, with the Visual Studio developer experience
and the alignment with other editions of Windows 10, Windows IoT Core enables hobbyists and Makers
to use inexpensive hardware to quickly develop designs based on Windows 10.
While Windows IoT Core shares a common platform with other editions of Windows 10, there are a
number of key differences. These include Windows IoT Core being brand new, without duplicated Win32
code. While full backward compatibility with other devices or products is not a goal for Windows IoT
Core, app and driver migration is straight forward, and tools and documentation will be provided to ease
the migration process.
Windows IoT Core is based on the modern app model used on Windows 10, though with an expanded
API set. Windows IoT Core achieves its footprint reduction by eliminating redundant APIs, converging
into a common platform across all editions of Windows 10 and removing inbox applications and the
Windows shell experience.
How does Windows 10 IoT Core
Insider Preview compare to Windows
Embedded Compact?
Windows 10 IoT Core Insider Preview shares a great deal conceptually with Windows Embedded
Compact (Windows CE). Both target resource constrained devices, support multiple chipsets, use the
Visual Studio tool chain for development.
Windows IoT Core however deviates from Windows Embedded Compact in a number of ways.
Windows IoT Core shares a common platform (the core OS, kernel and middleware) with other Windows
10 editions and, in many cases, has binary capability with other Windows 10 platforms. Windows
Embedded Compact never provided binary compatibility with other Windows products and used a
custom developed kernel which was different from the rest of the Windows.
Another difference between Windows Embedded Compact and Windows IoT Core is in the image
creation model. Windows Embedded Compact was highly componentized creating complex and error
prone process that had an impact on the API surface and SDK creation. As a result of the complicated
creation process images were often created with everything the OS had to offer. Windows IoT Core is a
feature complete OS focused on minimizing the resource requirements of the full image rather than
significant componentization, resulting in a balance between size, function, and simplicity of image
creation. It also results in a model where a common Windows IoT Core SDK could be created simplifying
application and driver development and porting, and provides a platform that can share applications and
drivers across the Windows 10 line of products.
Key Concepts
Headed/Headless
Windows 10 IoT Core Insider Preview supports both headed and headless device configurations.
Headed devices have a video display and uses the Windows Video subsystem & drivers to address it.
Headed devices have what would be recognized as a “typical” consumer display as you might see on a
laptop or tablet that in industry space would be things like ATMs, kiosks, digital signs and many others.
2
Headless devices have no display and do not require the Windows Video subsystem or drivers.
Headed vs Headless boot mode is controlled by configuration settings (read at boot time.) See the
section on Shell configuration for more detail.
Shell and Device Experience
Windows 10 IoT Core Insider Preview targets appliance type devices that will have OEM branded, custom
user experiences. The consumer Windows experience is seldom the best experience for these types of
devices. As such, the device maker will have complete freedom to create a modern user experience
highlighting their branding and have the ability to have deep integration into devices, hardware and
functionality while still having the familiar development model and tools as the rest of the Windows 10
line of products.
The primary visible user interface face for a Windows IoT Core headed device is a Universal Windows
Platform app (UWP app), that is developed with Visual Studio and deployed to the device. Visual Studio
is used for development and in the case of the UWP app and Visual Studio can package the application
and configuration into an APPX package (APPX is a file format similar to CAB or MSI, with improved
lifecycle management metadata.)
A platform Board Support Package (BSP), the Windows IoT Core OS, the various applications and services
and any provisioning/configuration data are combined in Windows Imaging and Configuration Designer
(ICD) to create an image that can be deployed onto a device. APPX packages are added to a device
image while being created with the ICD tool. (APPX packages can also be added to devices post image
deployment in a variety of ways including device management options).
In Windows, a number of functions and features are provided by the shell. In Windows IoT Core a
minimum custom shell layer will be provided to provide necessary features and to load and manage
OEM applications and manage their capabilities and lifecycle, including application and service watchdog functionality to ensure apps that unexpectedly exit are restarted, providing a predictable experience
for end users
3
Getting Started
Windows 10 IoT Core Insider Preview
Hardware Requirements
The following table lists the minimum requirements for Windows 10 IoT Core Insider Preview (subject to
change). For more detail see “Minimum Hardware Requirements for Windows 10” on the Windows
Hardware Dev Center at https://msdn.microsoft.com/en-us/windows/hardware/dn859155
4
Component
Windows IoT Core
Processor
400 MHz or faster x86 processor or SoC
With PAE, NX SSE2.
ARM SoC requirements are TBD, and will be provided in a future
update
x64 support coming at a later release
Faster processor performance may be required based on the design
and functionality of the device.
RAM
256 MB min. for devices without display support
512 MB min. for devices with display support, depending on
resolution and video implementation
More RAM may be required based on the design and functionality of
the device.
Storage
2 GB min
More Storage may be required based on the design and functionality
of the device.
Security
Trusted
Platform
Module (TPM)
Optional but recommended
If included, the TPM 2.0 must be implemented as either an integrated
firmware-based solution or included as a discrete component.
If implemented, the TPM 2.0 must meet the following requirements:
•
An EK certificate must either be pre-provisioned to the TPM
by the hardware vendor or be capable of being retrieved by the
device during the first boot experience.
•
It must ship with a SHA-256 PCR bank and implement PCRs 0
through 23 for SHA-256. Note it is acceptable to ship TPMs with a
single switchable PCR bank that can be used for both SHA-1 and
SHA-256 measurements.
Note: TPM 2.0 will be required for Windows IoT Core in a future
release.
Display
UEFI Secure
Boot
Optional; Recommended for commercial devices
Screen
Optional
Resolution
Design dependent
5
Bit depth
Touch, touch pad, and digital
pen
Camera
Audio
Wireless
Optional
Rear-facing
camera
Optional
Forwardfacing camera
Optional
Audio codec
hardware
Optional
Primary
microphone
Optional
Secondary
microphone
Optional
Dynamic noise
suppression
Optional
Loudspeaker
Optional
Earpiece
Optional
2G / 2.5G / 3G
(UMTS/EvDO)
/ 4G (HSPA)
cellular radio
Optional (data only; no voice support)
LTE cellular
radio
Optional (data only; no voice support)
Bluetooth
Optional
Wi-Fi
Optional
A-GNSS
Optional
FM radio
Optional
NFC
Optional
Networking
Sensors
Design dependent
Optional
Accelerometer
Optional
Magnetometer
Optional
Ambient light
sensor
Optional
6
Notification
Hardware
buttons
Proximity
sensor
Optional
Gyroscope
Optional
Vibration
mechanism
Optional
NLED
Optional
Power
All buttons are optional
Volume Up/
Volume Down
Start
Back/
Search
Camera
Rotation lock
Connectors
USB
Optional
Headphone/
headset jack
Optional
micro SD card
slot
Optional
Video output
Optional
SIM slot
Optional
Building Device Drivers
Developing drivers for Windows 10 IoT Core Insider Preview uses the same Windows Driver Kit (WDK)
that is used on Windows 10 “Desktop” and other Windows editions. In addition, a developer can take
advantage of the Universal Driver model to write a driver once and have the ability to deploy the driver
to multiple Windows editions.
7
Getting Started with Universal Drivers
A universal driver is a kernel-mode or user-mode driver binary that installs and runs on any UWPenabled edition of Windows 10 Technical Preview. A universal driver calls only device driver interfaces
(DDIs) that are part of the UWP.
Prior to Windows 10 Technical Preview, developers needed to write two separate drivers to get a device
to work on different editions of Windows. For example, a developer had to write one for Windows 8.1
and one for Windows Phone 8.1. Starting with Windows 10 Technical Preview, a developer can write one
driver that runs on both Windows 10 "Desktop" and Windows IoT Core, as well as other Windows 10
Technical Preview versions that share a common set of interfaces. The API set designated for universal
driver development was defined based on existing Windows APIs and as such many drivers require little
to no recoding and may work with a simple recompile. Drivers that adhere to these common APIs are
called universal drivers.
Building Universal Drivers
Windows 10 Technical Preview includes a unified WDK that supports building drivers for desktop,
Windows 10 IoT Core Insider Preview.
In many cases, you can recompile an existing kernel-mode driver that runs on Windows 8.1 to target
both Windows 10 "Desktop" and Windows IoT Core, as long as the driver does not work with any usermode components. WDM and KMDF drivers that work with Windows 8.1 should recompile as universal
drivers targeting Windows 10 Technical Preview with no conversion required.
Existing user-mode drivers may require modification to compile as universal drivers. Specifically, your
driver package must not have any dependencies outside of UWP. For example, only some of the Win32
APIs are part of UWP.
Driver packages should be created in such a way that the pure driver components are packaged
separately so they can easily be used on other platforms.
Visit https://msdn.microsoft.com/en-us/library/windows/hardware/ff554690.aspx for more information
on writing a driver for Windows.
Building Applications
8
Building Universal Applications
UWP is the primary focus for application development on Windows 10 IoT Core Insider Preview. The full
range of UWP languages/frameworks are supports include C++, C#, VB.Net, JS, XAML, HTML, and
DirectX. For headed devices a single UI app can be installed and this UI app owns the entire UI
experience for that device.
In addition to the UI app and existing Windows background task types, Microsoft is introducing “IoT
Background Service” applications that can contain StartupTasks. Any number of these StartupTasks may
be installed and they launch at boot, and they will be auto-restarted by the shell watch-dog if they exit
unexpectedly. In addition to their ability to start at system boot, without a UI app registering them, these
tasks are unique in that they are allowed to execute forever without resource management constraints.
This enables the common patterns in the IoT world where there are continuously running apps
monitoring the device and sensors, processing and reporting data, and controlling external devices.
New UWP Supported Languages and Frameworks
In addition to supporting the traditional UWP languages and frameworks, Microsoft is expanding
support for those that are favored by the IoT community. These are Python, Node.js, and Wiring
platforms that run in UWP and deliver the development experience expected and desired by these
communities. This support will come in the form of extensions to the Python Tools for Visual Studio and
Node.js Tools for Visual Studio packages as well as a new one for Wiring. The application code
developers write will be almost identical (except for native extensions) and will have the same remote
tooling experience all other UWP apps have.
More information on supported languages and frameworks can be found on the Windows Software Dev
Center at http://dev.windows.com/en-us/iot
New APIs
In addition to supporting IoT scenarios by introducing new application types, Windows IoT Core includes
include a broad range of WinRT APIs to support important IoT scenarios. These APIs fall into three basic
buckets
1.
Device and Bus Access
a.
APIs for controlling devices attached through common IoT busses
b. Supported now: GPIO, SPI, I2C, UART, Serial
2.
Connectivity
a.
APIs for communicating with between apps on different machines and on the same
machine
b. Examples: “Application Services” allows different applications on the same machine to
easily communicate with each other while the Windows 10 Alljoyn APIs make it easy to
talk to any devices that support the Alljoyn protocols
3.
System Administration
9
a.
As there is no longer a visible shell on the machine, developers need to be able to take
over some of the OS administration APIs that users usually get by interacting with the
Windows shell. Windows 10 IoT Core Insider Preview includes APIs to give this control to
apps on these IoT Devices
b. Examples: Wireless network password setting, system time zone, power management
All of the security sensitive APIs being added will be protected behind the existing capability
infrastructure. Individual apps on IoT Devices will be able to request and get these capabilities, but apps
that do not do so will run with the same level of sandboxing they would have on any other OS edition.
This approach expands the capabilities of apps on these devices while still maintaining security and
making it easy to prioritize security reviews for the applications that have these extended capabilities.
Tools
Visual Studio
Visual Studio 2015 will be the primary development tool for Windows 10 IoT Core Insider Preview
application development. UWP applications will be built with the same project templates and tools used
for all other UI based UWP apps. Additional templates have been added to make it very easy to build IoT
Background Services.
When configuring a project you can choose to debug the app either locally or on a remote machine.
Local development can be used for applications that are UI only and don’t have direct device
dependencies. Other applications will use the same remote development tools used for mobile/phone
application development and will have the same seamless F5 deploy/launch/debug experience.
Windows Assessment and Deployment Kit (ADK)
The Windows® Assessment and Deployment Kit (Windows ADK) is a collection of tools that you can use
to customize, assess, and deploy Windows operating systems to new computers. Information on
downloading the Windows ADK as well as documentation about how to use the Windows ADK tools are
available on the Windows Hardware Dev Center at
https://msdn.microsoft.com/library/windows/hardware/dn247001.aspx.
Image Configuration Designer (ICD)
You can build a customized Windows 10 IoT Core Insider Preview image using the new Windows
Imaging and Configuration Designer (ICD) tool. The tool allows you to add new drivers, Applications as
10
well as custom settings or policies to an existing Windows IoT Core image and create a new deployable
customized image from it. The tool will provide common mechanism and interface for image
customization for all Windows 10 Editions. For RTM you will also be able to use the tool to create
provisioning packages that can be applied to devices that have already been imaged without needing to
re-image. The Windows ICD tool ships as part of the Windows Assessment & Deployment Kit (ADK). You
will also need to download the Unified Windows Driver Kit (WDK) from the Windows Hardware Dev
Center at https://msdn.microsoft.com/en-us/windows/hardware/dn859155.
Porting
Windows 10 IoT Core Insider Preview is a new UWP based OS and as a result is very limited backward
compatible with applications built with Windows CE or Windows Embedded. However, a large number of
the APIs, Win32 and .Net, which these applications will have used are present on Windows IoT Core and
available to applications. These apps can either be left as classic Win32 or .net apps or migrated to UWP.
UI apps will need to be migrated as the only UI frameworks on Windows IoT Core are the UWP UI
frameworks.
Migration tools will be provided in upcoming releases that will analyze existing app binaries and provide
reports indicating which API calls will need to be removed/changed in order to work property on UWP
and Windows IoT Core.
Setting up your device & First Steps
Included in the Windows 10 IoT Core is a set of tutorials that include setting up your development
environment, flashing the device with Windows IoT Core and have a number of code samples to get you
started developing on Windows IoT Core. Start with the index.htm file in the Docs folder of your
Windows IoT Core release.
Remote Device Management
You can remotely configure and manage any Windows 10 IoT Core Insider Preview device using
Windows PowerShell. PowerShell is a task-based command-line shell and scripting language, designed
especially for system administration.
11
Initiating a Remote PowerShell (PS) session
To start a PS session with your Windows 10 IoT Core Insider Preview device, you’ll first need to create a
trust relationship between your host PC and your device. After booting your Windows IoT Core device,
an IP address will be shown on the screen attached to the device. Next, launch an administrator PS
console on your local PC and type the following:
Set-Item WSMan:\localhost\Client\TrustedHosts -Value [IP Address]
Enter Y to confirm the change.
Note: [IP Address] should be replaced with the IP address shown on the display attached to
your device.
Now, you can start a session with you Windows IoT Core device. From you administrator PS console,
type:
enter-pssession –computername [IP Address] -credential Administrator
In the credential dialog enter the following default password: p@ssw0rd (We recommend that
the default password on the devices is changed as soon as possible.)
Note: [IP Address] should be replaced with the IP address shown on the display attached to your
device.
Commonly used utilities
Below is a list of common configuration tasks and corresponding utilities that have been made available
in PowerShell.

Update account password:
It is highly recommended that you update the default password for the Administrator account.
To do this, you can issue the following command: net user Administrator [new password]
where [new password] represents a strong password of your choice.

Create local user accounts:
If you wish to give others access to your Windows 10 IoT device, you can create additional local
user accounts using PS by typing in net user [username] [password] /add. If you wish to add
this user to other groups, such as the Administrator group, use net localgroup Administrators
[username] /add.
12

Query and set device name:
To identify your current device name, simply type hostname. To change the name of your
Windows 10 IoT device, type SetComputerName [new machinename]. You may need to
restart your device for the name change to take effect.

Basic network configuration:
Many of the basic network configuration utilities you may already be familiar with are available in
Windows 10 for IoT, including commands such as ping.exe netstat.exe, netsh.exe, ipconfig.exe,
nslookup.exe, tracert.exe and arp.exe.

Copy utilities:
Microsoft is providing familiar tools, including sfpcopy.exe as well as xcopy.exe.

Process Management:
To view currently running processes, you can try either get-process or alternatively tlist.exe. To
stop a running process, type kill.exe [pid or process name]. To start a process,

Setting startup app:
Use the startup editor to configure startup apps on your Windows 10 IoT device. To see a list of
current startup apps, type startup.exe /d. To add an app to startup, type startup.exe /a
[Name] [Command]. For further help, try startup.exe /?

Headless vs. headed boot:
Windows 10 IoT devices can be set to headed (when display capabilities are required) or
headless (when a display is not required or available) device mode. To change this setting, use
setbootoption.exe [headed | headless].

Task scheduler:
To view the current list of scheduled tasks, use the schtasks.exe command. You can create new
tasks with the /create switch or run on-demand tasks with the /run switch. For a full list of
supported parameters, use schtasks.exe /?

Device drivers:
The device console utility is useful in identifying and managing installed devices and drivers. For
a full list of parameters, use devcon.exe /?

Registry Access:
If you need to access the registry to view or modify settings, use the reg.exe /? Command for
the full list of supported parameters.

Services:
13
Managing Windows services can be accomplished via the net.exe command. To see a list of
running services, type net start. To start or stop a specific service, type net [start | stop]
[service name]. Alternatively, you can also use the service control manager via sc.exe
command.

Boot configuration:
You can make changes to the boot configuration of your Windows IoT Core device using
bcdedit.exe. For instance, you can enable testsigning with bcdedit –set testsigning on
command.

Shutdown/restart device:
To shut down your device, type shutdown /s /t 0. To restart the device, use the /r switch instead
with the command shutdown /r /t 0.
Securing your device with a TPM 2.0
Trusted Platform Modules (TPMs) bring enhanced security to the world of IoT. This widely adopted,
industry standard provides numerous security benefits, including a trusted execution environment,
strong cryptographic identity and the secure storage and management of keys and sensitive assets –
traits that are highly desirable in IoT-class devices.
In Windows IoT Core, Microsoft will support firmware TPM as well as discrete TPM2.0 implementations
over the currently supported LPC interface as well as SPI and I 2C buses for IoT devices. Additionally, in
order to facilitate development and provide a full set of tools to developers, Microsoft will make available
a TPM2.0 software simulator* that can be leveraged during the development cycle on devices that do not
have a firmware or discrete TPM implementation.
* Important Note: The TPM simulator is only a development aid. It provides absolutely
NO security functionality and should never be thought of or used as a replacement for a
firmware-based TPM or a discrete TPM solution.
14
Getting started with a discrete TPM module or TPMsimulator
You may wish to try out test modules currently available from select TPM manufacturers or enable the
TPM simulator in Windows 10 IoT Core Insider Preview. To do this, first, you’ll need to enable test
signing on your device. Initiate a remote PowerShell session to your Windows IoT Core device and once
logged-in, run the following command to enable test signing:
bcdedit –set testsigning on
Next, you’ll need to get the appropriate ACPITABL.DAT files for the corresponding TPM you wish to use.
1.
Download the complete set here and unzip.
2.
Copy the TPM’s corresponding DAT file onto your device under \Windows\System32:
TPM Manufacturer
Bus Type
NationZ
SPI
NationZ
I2C
Infineon
I2C
STMicro/Infineon/Nuvoton
SPI
TPM Simulator
N/A
Filename
3.
Rename above filename to ACPITABL.DAT and reboot device
4.
Your TPM is now initialized and ready for use.
Appendix
Detailed Topics
15
Shell Configuration Details
16
Background and Detail
As Windows IoT Core will be a custom, fixed purpose device rather than a consumer PC, the user
experience and user interface is expected to be defined and implemented by the OEM/device creator.
On an in-car entertainment unit for example there may be some buttons on the device as well as UI on
the screen allowing the user to do things like control the CD player, set FM stations, provide navigation
functionality, etc. but that user experience will have little resemblance to what we know of as the
consumer Windows experience.
Some devices in fact will have NO visible UI on a video monitor at all – a wireless access point is a great
example of that where the device provides ongoing functionality without user intervention and any user
interaction is remote through an HTML experience in the users browser. In both cases Windows IoT Core
has to provide the APIs and services to allow the OEM/device maker to create the user experience for
their device and to manage the applications and services for the device.
In Windows IoT Core scenarios OEMs may prefer to have no visible Windows or Microsoft presence. As
such, Windows IoT Core will not include the Windows shell or any inbox applications and OEMs will
create the entire end-to-end experience for their device using the tools and features provided for use
with all Windows 10 editions, including Windows IoT Core.
Device Lockdown
IoT Core shell will allow an OEM/Maker to take complete control of their device experience while
aligning with “lock-down” features on other versions of Windows. Here is a comparison of lock-down
features and how IoT Core aligns:
Feature
Explanation
IoT Core
Assigned
Restrict a user account to access a single app
IoT Core shell functionality is minimal for
Access/Restrict
(on PC/RT) or a set of apps (on Handheld).
OEMs/device makers;
Available Apps
Users cannot access additional system
functionality beyond the intended purpose
of the device, which may include switching to
End user experiences are implemented by the
OEM.
other apps, viewing the start screen,
receiving system notifications, etc…
Suppress System
Turns off Task manager, Lock screen, Camera,
Not needed for IoT Core since no system controls
Controls
Accessibility Options, Hides power buttons
are visible to users.
on the welcome screen
Dialog Filter
Controls which dialog boxes and windows
System dialogs are not present in IoT Core.
are displayed on the screen, and to
filtering capabilities provide a way to intercept
automatically handle dialog boxes by taking
certain notifications and route to OEM shell.
a default action, such as to close/show dialog
box, or always show dialogs from specific
processes
App Launcher
Starts a Windows Store app immediately
IoT Core shell will expose settings to enable this.
after a user signs in, helps configure the
behavior when the app exits – shutdown,
restart, restart the app. Different apps can be
launched for different users
Shell Launcher
Helps replace the default Windows shell with
IoT Core shell will expose settings to enable this.
a custom shell - any app or executable can
be used as custom shell. Different shell can
be launched for different users
Gesture Filter
Helps disable the edge and corner gestures.
Not needed since IoT Core shell does not expose
Gesture Filter enables you to block edge
edge and cornet gestures.
gestures (left, right, top extended swipe, and
each corner) individually.
Toast Notification
Prevents modern system toast notifications
Not needed since toast notifications are not part
Filter
from displaying
of Windows IoT Core shell. The OEM device/shell
design should handle it as appropriate.]
Keyboard Filter
Helps suppress undesirable key presses or
Not needed for Windows IoT Core
key combinations, such as Ctrl+Alt+Delete,
Ctrl+Shift+Tab. Works with Physical
keyboards, onscreen keyboard, touch
keyboard. Detects dynamic layout changes
USB Filter
Helps allow trusted USB devices to connect
Extended filtering capability is being evaluated for
to a system. USB Filter intercepts device
Windows IoT Core. For most scenarios the OEM
connect requests and only allows USB
code handles these scenarios directly and can be
devices with matching device product ID,
managed directly. In some limited cases filtering
device vendor ID, or device class ID
can further assist but it is a much smaller set than
on other Windows versions.
17
Unified Write Filter
Helps protect physical storage media,
Not Supported
including most standard writable storage
types such as physical hard disks, solid-state
drives, internal USB devices, external SATA
devices, etc. Provides capability to configure
exclusions – files, folders, registry etc.
The IoT shell infrastructure will determine if this is a headless installation and decide whether or not to
launch the compositor and then will launch a single (registry configurable by appid) APPX package. If
this package is a normal APPX package then there will be a single app experience that is always visible
and always has focus.
Although only one UWP foreground application can be used in a headed configuration, as many
background applications and services as resources will allow can get be configured to load and execute –
in either headed or headless modes.
Shell Configuration Service Provider (CSP)
Since the OEM UI is implemented as a UWP app, the shell needs to be configurable as to which app
should be loaded as the main local, onscreen UI. We provide a configuration service provider (CSP) to
configure the shell and OEM apps, including the list of applications to launch at start-up, the order to
execute them and any application configuration settings (reg keys) necessary. (Background tasks and
services launched by the shell are managed by the APPX manifests since multiple background tasks and
services are supported. Only in the case of the local, on-screen UI does the shell have to differentiate
between UWP apps as more than one could be available.
A configuration CSP is required to isolate the implementation specifics above from the actual
management and configuration process. To accomplish this a CSP will be implemented that can be used
to configure the above settings in a more user friendly way.
Notes:

The Shell Configuration Service Provider (CSP) is for Windows IoT Core only.

This CSP does not cover the install scenarios

The APPX must be preinstalled for this functionality to work.
Shell configuration commands
During development the shell can be configured quickly from a remote command line (PowerShell) with
IoTStartUp.exe.
Usage:
18
Shell Registry Reference
The following is provided for reference only. The preferred method of configuring the shell and start up
apps is with the provided CSP using either device management or ICD.

Hklm\system\currentcontrolset\control\wininit DWORD headless == 1

Hklm\software\microsoft\windows nt\currentversion\winlogon\iotshellextension


Hklm\software\microsoft\windows nt\currentversion\winlogon\iotshellextension\cbt


appid string value is the appid/aumid to launch.
String values under this are package family and entrypoint for cbts to activate
Hklm\software\microsoft\windows nt\currentversion\winlogon\iotshellextension DWORD
EnableRemoteCommandPrompt.

If this is set to 1 then we will launch a remote command prompt that is accessible over
the network in addition to the appx app and CBTs
For more information:
For more information including tutorials and code samples go to www.WindowsOnDevices.com.
19