Windows 10 IoT is the third (lower) layer of Windows 10. All three are built from the same codebase, part of Microsoft’s one Windows mantra. Whilst the desktop will have significantly more features than the IOT layer, the IoT layer will embedded features such as General Purpose IO (GPIO) which the desktop doesn’t. The Phone layer will support cellular networks for phone calls whereas the other two only support this for internet access. Apart from the common code, a binding feature of all three is Universal Apps. The same application code can be rebuild for different Windows 10 OS’s; and for different CPUs (HHH/Phone and Embedded/IoT)[1]. A simple “Hello World” UA will run on all three. A UI app with GPIO will only run without error on an Embedded/IoT. Such an app will attempt to load on the other two but will fail when GPIO features are initialized. Such errors can be trapped so that the app fails gracefully or runs some alternative code. Similarly a Windows 10 touch UA app will run erroneously on an Embedded/IOT device, although touch can be implemented separately from the Win 10 codebase through GPIO etc.



In creating an embedded device using Windows 10 IoT, one uses a prebuilt binary called Windows IoT Core that targets a specific target (CPU and peripherals). As of Build 2015 there are two platforms, the Minimax (x86) and Raspberry Pi 2 (ARM). You download the binary, install it on am SD Card (micro) boot the system and it auto-sets up. Unlike Windows Embedded Compact/CE this OS is not componentized; you can’t option the Core, although you can create and add custom drivers. It does mean that a system developed from Windows IoT needs to be based upon a target for which this binary has been made available. Microsoft’s initial main target with this is the hobbyist/maker community, not commercial but that will follow.

What about Windows Embedded Compact/CE? Two key features of Compact/CE are componentization and Real-time. With Windows Embedded 8.1[2] componentization was dispensed with for the embedded desktop as it was felt that embedded systems were big enough in memory and fast enough to support a full version of the desktop OS. For similar reasons, it is felt that embedded systems have sufficient memory and processing power to support an “off-the-shelf” general purpose operating system. Hence the non-componentized Win 10 IoT OS[3]. Windows 10 IoT is not Real-Time like Windows Embedded Compact/CE which is Hard Real-Time. It is felt that processing power for Windows 10 IoT devices is fast enough to handle things close to Real-Time. It is though acknowledged that if real Real-Time is required, that Windows Embedded Compact should be used. Still given the move towards using daughter boards for dedicated processing in many systems (eg Windows 10 and Arduino) then a Compact system could be hosted by a Windows 10 IoT system.

A further feature of Compact/CE is the simplicity of building device drivers (as stream drivers) for custom hardware when compared to the complexities of building Windows devices drivers. Again the daughter board approach may be used but the support for interrupts, GPIO, I2C and SPI with Windows 10 IoT can obviate the need to use Compact/Ce for custom hardware.


What about Galileo? This was an initial foray into IoT for Intel and Microsoft. It has the Arduino physical IO and runs as an Arduino “clone” when running in Linux mode. The Microsoft OS for this is a headless x86 version of Windows 8.1. Whilst there is much overlap with app development, there is no intention of enabling Windows 10 IoT on it. One blocking requirement is SSE2 which is mandated for all x86/64 Windows 10 systems (including IoT) but not present in the Galileo CPU, the Intel Quark. This is also a problem for other CPU manufacturers such as ICOP. SSE2 is a SIMD instruction set implemented in CPU hardware for graphics processing that needs licensing from Intel.


The Cloud. Two Codeplex projects, Ardjson and CEJson simplify connectivity for Arduino and Compact devices (respectively) running as IoT sensors sending data to Azure Mobile services. Windows 10 IoT devices are inherently cloud centric. It is a simple matter to connect any UA to a cloud service.

Windows 10 IoT Features

  • Within this “Windows 10 IoT” edition, there will be three classes, one for mobile devices, small devices, and industrial devices.
  • Windows 10 IoT will retain only a subset of functionality from Windows 10 but has extra IO features:
    •      Interrupts, I2C, SPI, Serial, Bluetooth, RS232, Ethernet
    •      There is a set of validated (On Minimax and RPI2) USB devices
  • There is a reduction in the requirements for storage and memory with 4GB and 512MB/256MB:
    •      Systems can be headless:
      •           Headed requires 512MB
      •           Headless only requires 256MB
  • The main application technology is Universal Apps:
    •      In the headed mode, the standard UAP UI stack is available for fully interactive apps.
    •      In headless mode, there is no UI stack available and apps are not interactive. Headless mode apps can be thought of as services.
  • Only one startup app is permitted which becomes the UI. There is no shell:
    •      The startup app IS the shell.
    •      Background tasks are supported.
    •      Console apps are supported but without UI and a subset of the existing Win32API:.
      •           This aspect is subject to further consideration.
      •           There is a tool for checking existing Console Win32 apps for Win32 API requirements against those available in Win 10 IoT.
  • There is a set of command line OS utilities, for example shutdown.
  • Remote management using PowerShell.
  • A variety of IO capabilities:
    •      Interrupts, I2C, SPI, Serial, Bluetooth, RS232, Ethernet
    •      There is a set of validated (On Minimax and RPI2) USB devices
  • Support for AllJoyn that allows devices to advertise and share their abilities.

[1] No ARM with Windows 10 for Tablets!

[2] Windows Embedded 8.1 Industry has extra features relevant to an embedded device, such as capturing dialog boxes.

[3] There is a tool for unpacking the OS binary and repackaging it with custom components.