1.0.8

(cherry picked from commit 2a3f2d4)

.gitignore

@@ -1,14 +1,22 @@
 node_modules
 yotta_modules
 yotta_targets
+pxt_modules
 built
 typings
 tmp
 temp
 projects/**
-win10/app/bin
-win10/app/bld
-win10/*.opendb
+clients/win10/app/AppPackages
+clients/win10/app/BundlePackages
+clients/win10/app/BundleArtifacts
+clients/win10/app/bin
+clients/win10/app/bld
+clients/win10/*.opendb
+clients/**/bin/**
+clients/**/obj/**
+clients/electron/projects
+hexcache
 
 *.user
 *.sw?
@@ -16,4 +24,10 @@ win10/*.opendb
 *.tgz
 *.db
 *.suo
-*.log
+*.log
+
+.DS_Store
+.idea
+*.iml
+.vscode/.BROWSE.VC.DB-shm
+.vscode/.BROWSE.VC.DB-wal

.travis.yml

@@ -3,15 +3,14 @@ node_js:
   - "5.7.0"
 script:
   - "node node_modules/pxt-core/built/pxt.js travis"  
-  - "(cd libs/lang-test0; node ../../node_modules/pxt-core/built/pxt.js run)"
-  - "node node_modules/pxt-core/built/pxt.js uploaddoc"
-  - "(cd libs/hello; node ../../node_modules/pxt-core/built/pxt.js testconv ../../testconv.json)"
+  - "node node_modules/pxt-core/built/pxt.js testdir tests"
 sudo: false
 notifications:
   email:
-    - touchdevelop-build@microsoft.com
+    - kindscript@microsoft.com
 cache:
   directories:
     - node_modules
     - built/cache
+    - libs/hello/built/cache
 

.vscode/settings.json

@@ -1,5 +1,21 @@
 // Place your settings in this file to overwrite default and user settings.
 {
+    "file.autoSave": "afterDelay",   
+    "files.watcherExclude": {
+        "**/.git/objects/**": true,
+        "**/built/**": true,
+        "**/node_modules/**": true,
+        "**/yotta_modules/**": true,
+        "**/yotta_targets": true,
+        "**/pxt_modules/**": true
+    },    
+    "search.exclude": {
+        "**/node_modules": true,
+        "**/yotta_modules/**": true,
+        "**/yotta_targets": true,
+        "**/pxt_modules/**": true
+    },    
     "tslint.enable": true,
-    "tslint.rulesDirectory": "node_modules/tslint-microsoft-contrib"
+    "tslint.rulesDirectory": "node_modules/tslint-microsoft-contrib",
+    "typescript.tsdk": "./node_modules/typescript/lib"
 }

CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# Contributing Code
+
+PXT accepts bug fix pull requests. For a bug fix PR to be accepted, it must first have a tracking issue that has been marked approved. Your PR should link to the bug you are fixing. If you've submitted a PR for a bug, please post a comment in the bug to avoid duplication of effort.
+
+PXT also accepts new feature pull requests. For a feature-level PR to be accepted, it first needs to have design discussion. Design discussion can take one of two forms a) a feature request in the issue tracker that has been marked as approved or b) the PR must be accompanied by a full design spec and this spec is later approved in the open design discussion. Features are evaluated against their complexity, impact on other features, roadmap alignment, and maintainability.
+
+These two blogs posts on contributing code to open source projects are a good reference: [Open Source Contribution Etiquette](http://tirania.org/blog/archive/2010/Dec-31.html) by Miguel de Icaza and [Don't "Push" Your Pull Requests](https://www.igvita.com/2011/12/19/dont-push-your-pull-requests/) by Ilya Grigorik.
+
+## Security
+
+If you believe you have found a security issue in PXT, please share it with us privately following the guidance at the Microsoft [Security TechCenter](https://technet.microsoft.com/en-us/security/ff852094). Reporting it via this channel helps minimize risk to projects built with PXT.
+
+## Legal
+
+You will need to complete a Contributor License Agreement (CLA) before your pull request can be accepted. This agreement testifies that you are granting us permission to use the source code you are submitting, and that this work is being submitted under appropriate license that we can use it.
+
+You can complete the CLA by going through the steps at https://cla.microsoft.com. Once we have received the signed CLA, we'll review the request. You will only need to do this once.
+
+## Housekeeping
+
+Your pull request should:
+* Include a description of what your change intends to do
+* Be a child commit of a reasonably recent commit in the master branch
+* Pass all unit tests
+* Have a clear commit message
+* Include adequate tests

LICENSE.txt

@@ -0,0 +1,25 @@
+PXT - Programming Experience Toolkit
+
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,20 +1,27 @@
-# micro:bit target for PXT
+# Calliope target for PXT
 
-This target allow to program a [BBC micro:bit](https://www.microbit.co.uk/) using 
+This target allow to program a [Calliope](http://calliope.cc/) using 
 PXT ([Microsoft Programming Experience Toolkit](https://github.com/Microsoft/pxt)).
 
-* [Try it live](https://m.pxt.io)
+[![Build Status](https://travis-ci.org/Microsoft/pxt-calliope.svg?branch=master)](https://travis-ci.org/Microsoft/pxt-calliope)
 
-[![Build Status](https://travis-ci.org/Microsoft/pxt-microbit.svg?branch=master)](https://travis-ci.org/Microsoft/pxt-microbit)
+![](http://calliope.cc/content/1-ueber-mini/mini_board.png)
 
 ## Local server
 
+The local server allows to run the editor and the documentation from your computer.
+
 ### Setup
 
 The following commands are a 1-time setup after synching the repo on your machine.
 
-* clone this repo to your computer
-* install the PXT command line
+* See requirements for [pxt](https://github.com/Microsoft/pxt)
+* [clone this repo](https://help.github.com/articles/cloning-a-repository/) to your computer and go in the project folder
+```
+git clone https://github.com/microsoft/pxt-calliope
+cd pxt-calliope
+```
+* install the PXT command line (add ``sudo`` for Mac/Linux shells).
 ```
 npm install -g pxt
 ```
@@ -25,31 +32,44 @@ npm install
 
 ### Running
 
-Run this command to open a local web server (add ``sudo`` for Mac/Linux shells)
+Run this command to open a local web server (add ``sudo`` for Mac/Linux shells).
 ```
 pxt serve
 ```
 If the local server opens in the wrong browser, make sure to copy the URL containing the local token. 
 Otherwise, the editor will not be able to load the projects.
 
-If you need modify the `.cpp` files, turn on yotta compilation with the ``-yt`` flag (add ``sudo`` for Mac/Linux shells):
+If you need modify the `.cpp` files, turn on yotta compilation with the ``-yt`` flag (add ``sudo`` for Mac/Linux shells). On Windows, you must be running
+from the ``Run Yotta`` command prompt.
 ```
 pxt serve -yt
 ```
 
-To make sure you're running the latest tools, run (add ``sudo`` for Mac/Linux shells)
+## Updates
+
+To update your PXT version and make sure you're running the latest tools, run (add ``sudo`` for Mac/Linux shells)
 ```
 pxt update
 ```
 
 More instructions at https://github.com/Microsoft/pxt#running-a-target-from-localhost 
 
-## Universal Windows App
+## Testing
 
-The Windows 10 app is a [Universal Windows Hosted Web App](https://microsoftedge.github.io/WebAppsDocs/en-US/win10/CreateHWA.htm)
-that wraps ``m.pxt.io`` and provides additional features.
+The build automatically runs the following:
 
-### Building
+* make sure the built-in packages compile
+* `pxt run` in `libs/lang-test*` - this will run the test in command line runner; 
+  there is a number of asserts in both of these
+* `pxt testdir` in `tests` - this makes sure all the files compile and generates .hex files
 
-* Install Visual Studio 2015 Update 2 or higher. Make sure the Windows 10 templates are installed.
-* open the ``win10/app.sln`` solution and launch the ``m.pxt.io`` project.
+To test something on the device:
+
+* do a `pxt deploy` in `libs/lang-test*` - they should show `1` or `2` on the screen (and not unhappy face)
+* run `pxt testdir` in `tests` and deploy some of the hex files from `tests/built`
+
+The `lang-test0` source comes from the `pxt-core` package. It's also tested with `pxt run` there. 
+
+## Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

clients/chrome/README.md

@@ -0,0 +1,26 @@
+# microbit-chrome
+Prototype chrome addon that exposes the micro:bit's serial output to webpages. 
+* watch the [demo video](https://vimeo.com/146207766)
+
+# Installation
+See [developer.chrome.com](https://developer.chrome.com/extensions/getstarted#unpacked)
+for instructions on how to install the local version into your chrome browser.
+
+# Requirements
+* Chrome 48 or later.
+
+# Sample page
+The `demo.html` webpage goes along with the
+https://github.com/Microsoft/microbit-touchdevelop/blob/master/examples/tcs34725.cpp
+program. Run `http-server` from this directory, then visit
+http://localhost:8080/demo.html
+(keep in mind that pages served from `file://` cannot open ports).
+
+# Building
+
+Open a command prompt and run the following commands.
+
+````
+npm install
+typings update
+````

clients/chrome/background.js

@@ -0,0 +1,67 @@
+var connections = [];
+// A list of "ports", i.e. connected clients (such as web pages). Multiple web
+// pages can connect to our service: they all receive the same data.
+var ports = [];
+function byPath(path) {
+    return connections.filter(function (x) { return x.path == path; });
+}
+function byId(id) {
+    return connections.filter(function (x) { return x.id == id; });
+}
+function onReceive(data, id) {
+    if (ports.length == 0)
+        return;
+    var view = new DataView(data);
+    var decoder = new TextDecoder("utf-8");
+    var decodedString = decoder.decode(view);
+    ports.forEach(function (port) { return port.postMessage({
+        type: "serial",
+        data: decodedString,
+        id: id
+    }); });
+}
+function findNewDevices() {
+    chrome.serial.getDevices(function (serialPorts) {
+        serialPorts.forEach(function (serialPort) {
+            if (byPath(serialPort.path).length == 0 &&
+                serialPort.displayName == "mbed Serial Port") {
+                chrome.serial.connect(serialPort.path, { bitrate: 115200 }, function (info) {
+                    // In case the [connect] operation takes more than five seconds...
+                    if (info && byPath(serialPort.path).length == 0)
+                        connections.push({
+                            id: info.connectionId,
+                            path: serialPort.path
+                        });
+                });
+            }
+        });
+    });
+}
+function main() {
+    // Register new clients in the [ports] global variable.
+    chrome.runtime.onConnectExternal.addListener(function (port) {
+        if (/^(micro:bit|touchdevelop|yelm|pxt|codemicrobit|codethemicrobit|pxt.microbit.org)$/.test(port.name)) {
+            ports.push(port);
+            port.onDisconnect.addListener(function () {
+                ports = ports.filter(function (x) { return x != port; });
+            });
+        }
+    });
+    // When receiving data for one of the connections that we're tracking, forward
+    // it to all connected clients.
+    chrome.serial.onReceive.addListener(function (info) {
+        if (byId(info.connectionId).length > 0)
+            onReceive(info.data, info.connectionId);
+    });
+    // When it looks like we've been disconnected, drop the corresponding
+    // connection object from the [connections] global variable.
+    chrome.serial.onReceiveError.addListener(function (info) {
+        if (info.error == "system_error" || info.error == "disconnected" || info.error == "device_lost")
+            connections = connections.filter(function (x) { return x.id != info.connectionId; });
+    });
+    // Probe serial connections at regular intervals. In case we find an mbed port
+    // we haven't yet connected to, connect to it.
+    setInterval(findNewDevices, 5000);
+    findNewDevices();
+}
+document.addEventListener("DOMContentLoaded", main);

clients/chrome/background.ts

@@ -0,0 +1,92 @@
+// A list of: {
+//   id: number;
+//   path: string;
+// } where [id] is the [connectionId] (internal to Chrome) and [path] is the
+// OS' name for the device (e.g. "COM4").
+interface Connection {
+  id: string;
+  path: string;
+}
+let connections: Connection[] = [];
+
+// A list of "ports", i.e. connected clients (such as web pages). Multiple web
+// pages can connect to our service: they all receive the same data.
+let ports = [];
+
+interface Message {
+  type: string;
+  data: string;
+  id: string;
+}
+
+function byPath(path: string): Connection[] {
+  return connections.filter((x) => x.path == path);
+}
+
+function byId(id: string): Connection[] {
+  return connections.filter((x) => x.id == id);
+}
+
+function onReceive(data, id: string) {
+  if (ports.length == 0) return;
+
+  let view = new DataView(data);
+  let decoder = new TextDecoder("utf-8");
+  let decodedString = decoder.decode(view);
+  ports.forEach(port => port.postMessage(<Message>{
+    type: "serial",
+    data: decodedString,
+    id: id,
+  }));
+}
+
+function findNewDevices() {
+  chrome.serial.getDevices(function (serialPorts) {
+    serialPorts.forEach(function (serialPort) {
+      if (byPath(serialPort.path).length == 0 &&
+        serialPort.displayName == "mbed Serial Port") {
+        chrome.serial.connect(serialPort.path, { bitrate: 115200 }, function (info) {
+          // In case the [connect] operation takes more than five seconds...
+          if (info && byPath(serialPort.path).length == 0)
+            connections.push({
+              id: info.connectionId,
+              path: serialPort.path
+            });
+        });
+      }
+    });
+  });
+}
+
+function main() {
+  // Register new clients in the [ports] global variable.
+  chrome.runtime.onConnectExternal.addListener(function (port) {
+    if (/^(micro:bit|touchdevelop|yelm|pxt|codemicrobit|codethemicrobit|pxt.microbit.org)$/.test(port.name)) {
+      ports.push(port);
+      port.onDisconnect.addListener(function () {
+        ports = ports.filter(function (x) { return x != port });
+      });
+    }
+  });
+
+  // When receiving data for one of the connections that we're tracking, forward
+  // it to all connected clients.
+  chrome.serial.onReceive.addListener(function (info) {
+    if (byId(info.connectionId).length > 0)
+      onReceive(info.data, info.connectionId);
+  });
+
+  // When it looks like we've been disconnected, drop the corresponding
+  // connection object from the [connections] global variable.
+  chrome.serial.onReceiveError.addListener(function (info) {
+    if (info.error == "system_error" || info.error == "disconnected" || info.error == "device_lost")
+      connections = connections.filter((x) => x.id != info.connectionId);
+  });
+
+  // Probe serial connections at regular intervals. In case we find an mbed port
+  // we haven't yet connected to, connect to it.
+  setInterval(findNewDevices, 5000);
+  findNewDevices();
+}
+
+document.addEventListener("DOMContentLoaded", main);

clients/chrome/manifest.json

@@ -0,0 +1,30 @@
+{
+  "app": {
+    "background": {
+      "scripts": [ "background.js" ]
+    }
+  },
+
+  "manifest_version": 2,
+  "name": "pxt.microbit.org",
+  "version": "0.7.0",
+  "author": "Microsoft Corporation",
+  "short_name": "pxt.microbit.org",
+
+  "description": "Extension for https://pxt.microbit.org.",
+  "homepage_url": "https://pxt.microbit.org",
+  "offline_enabled": "true",
+  "icons": {
+    "48": "logo48.png",
+    "128": "logo128.png"
+  },
+
+  "permissions": [
+    "serial",
+    "usb"
+  ],
+
+  "externally_connectable": {
+    "matches": [ "*://localhost/*", "https://pxt.microbit.org/*", "https://*.microbit.org/*" ]
+  }
+}

clients/chrome/tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "compiler-options": {
+        "target": "ES5",
+        "module": "amd",
+        "sourceMap": false
+    }
+ }

clients/electron/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+projects

clients/electron/README.md

@@ -0,0 +1,5 @@
+# PXT micro:bit Electron app
+
+A very basic wrapper around the web app. To install, copy the contents of this
+directory to somewhere outside the main `pxt-microbit` repository. Then run `npm
+install && npm start`.

clients/electron/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>code the micro:bit</title>
+  </head>
+  <body>
+    <webview id="webview" style="position:absolute; left:0; top:0; right:0; bottom:0"/>
+    <script>
+      const webview = document.getElementById("webview")
+      const url = `http://localhost:3232/${window.location.hash}`
+      webview.src = url
+    </script>
+  </body>
+</html>

clients/electron/main.js

@@ -0,0 +1,39 @@
+const {app, BrowserWindow, Menu} = require('electron')
+const pxt = require('pxt-core')
+const path = require('path')
+
+let win
+
+const cliPath = path.join(process.cwd(), "node_modules/pxt-microbit") 
+
+function startServerAndCreateWindow() {
+  pxt.mainCli(cliPath, ["serve", "-no-browser"])
+  createWindow()
+}
+
+function createWindow () {
+  win = new BrowserWindow({
+    width: 800,
+    height: 600,
+    title: "code the micro:bit"
+  })
+  Menu.setApplicationMenu(null)
+  win.loadURL(`file://${__dirname}/index.html#local_token=${pxt.globalConfig.localToken}`)
+  win.on('closed', () => {
+    win = null
+  })
+}
+
+app.on('ready', startServerAndCreateWindow)
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})
+
+app.on('activate', () => {
+  if (win === null) {
+    createWindow()
+  }
+})

clients/electron/package.json

@@ -0,0 +1,14 @@
+{
+  "name"    : "code-the-microbit",
+  "version" : "1.0.0",
+  "description": "Blocks / Javascript editor",
+  "author": "Microsoft",
+  "main"    : "main.js",
+  "scripts": {
+      "start": "node_modules/.bin/electron ."
+  },
+  "devDependencies": {
+      "electron": "*",
+      "pxt-microbit": "*"
+  }
+}

clients/macuploader/.gitignore

@@ -0,0 +1,137 @@
+
+# Created by https://www.gitignore.io/api/osx,xcode,objective-c,vim
+
+### OSX ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+
+### Xcode ###
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## Build generated
+build/
+DerivedData/
+
+## Various settings
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata/
+
+## Other
+*.moved-aside
+*.xccheckout
+*.xcscmblueprint
+
+
+### Objective-C ###
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## Build generated
+build/
+DerivedData/
+
+## Various settings
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata/
+
+## Other
+*.moved-aside
+*.xcuserstate
+
+## Obj-C/Swift specific
+*.hmap
+*.ipa
+*.dSYM.zip
+*.dSYM
+
+# CocoaPods
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# Pods/
+
+# Carthage
+#
+# Add this line if you want to avoid checking in source code from Carthage dependencies.
+# Carthage/Checkouts
+
+Carthage/Build
+
+# fastlane
+#
+# It is recommended to not store the screenshots in the git repo. Instead, use fastlane to re-generate the 
+# screenshots whenever they are needed.
+# For more information about the recommended setup visit:
+# https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Gitignore.md
+
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots
+fastlane/test_output
+
+# Code Injection
+#
+# After new code Injection tools there's a generated folder /iOSInjectionProject
+# https://github.com/johnno1962/injectionforxcode
+
+iOSInjectionProject/
+
+### Objective-C Patch ###
+*.xcscmblueprint
+
+
+### Vim ###
+# swap
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+# session
+Session.vim
+# temporary
+.netrwhist
+*~
+# auto-generated tag files
+tags

clients/macuploader/Microbit Uploader.xcodeproj/project.pbxproj

@@ -0,0 +1,307 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		E93040071D895D1F00D931CA /* DirectoryWatcher.m in Sources */ = {isa = PBXBuildFile; fileRef = E93040061D895D1F00D931CA /* DirectoryWatcher.m */; };
+		E930400A1D89620900D931CA /* Uploader.m in Sources */ = {isa = PBXBuildFile; fileRef = E93040091D89620900D931CA /* Uploader.m */; };
+		E9F4FEE21D8709980071D783 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = E9F4FEE11D8709980071D783 /* AppDelegate.m */; };
+		E9F4FEE51D8709980071D783 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = E9F4FEE41D8709980071D783 /* main.m */; };
+		E9F4FEE71D8709980071D783 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = E9F4FEE61D8709980071D783 /* Assets.xcassets */; };
+		E9F4FEEA1D8709980071D783 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = E9F4FEE81D8709980071D783 /* MainMenu.xib */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		E93040051D895D1F00D931CA /* DirectoryWatcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DirectoryWatcher.h; sourceTree = "<group>"; };
+		E93040061D895D1F00D931CA /* DirectoryWatcher.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DirectoryWatcher.m; sourceTree = "<group>"; };
+		E93040081D89620900D931CA /* Uploader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Uploader.h; sourceTree = "<group>"; };
+		E93040091D89620900D931CA /* Uploader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Uploader.m; sourceTree = "<group>"; };
+		E9F4FEDD1D8709980071D783 /* Microbit Uploader.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "Microbit Uploader.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+		E9F4FEE01D8709980071D783 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = "<group>"; };
+		E9F4FEE11D8709980071D783 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = "<group>"; };
+		E9F4FEE41D8709980071D783 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
+		E9F4FEE61D8709980071D783 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		E9F4FEE91D8709980071D783 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = "<group>"; };
+		E9F4FEEB1D8709980071D783 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		E9F4FEDA1D8709980071D783 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		E9F4FED41D8709980071D783 = {
+			isa = PBXGroup;
+			children = (
+				E9F4FEDF1D8709980071D783 /* Microbit Uploader */,
+				E9F4FEDE1D8709980071D783 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		E9F4FEDE1D8709980071D783 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				E9F4FEDD1D8709980071D783 /* Microbit Uploader.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		E9F4FEDF1D8709980071D783 /* Microbit Uploader */ = {
+			isa = PBXGroup;
+			children = (
+				E9F4FEE01D8709980071D783 /* AppDelegate.h */,
+				E9F4FEE11D8709980071D783 /* AppDelegate.m */,
+				E9F4FEE61D8709980071D783 /* Assets.xcassets */,
+				E9F4FEE81D8709980071D783 /* MainMenu.xib */,
+				E9F4FEEB1D8709980071D783 /* Info.plist */,
+				E9F4FEE31D8709980071D783 /* Supporting Files */,
+				E93040051D895D1F00D931CA /* DirectoryWatcher.h */,
+				E93040061D895D1F00D931CA /* DirectoryWatcher.m */,
+				E93040081D89620900D931CA /* Uploader.h */,
+				E93040091D89620900D931CA /* Uploader.m */,
+			);
+			path = "Microbit Uploader";
+			sourceTree = "<group>";
+		};
+		E9F4FEE31D8709980071D783 /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				E9F4FEE41D8709980071D783 /* main.m */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		E9F4FEDC1D8709980071D783 /* Microbit Uploader */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = E9F4FEEE1D8709980071D783 /* Build configuration list for PBXNativeTarget "Microbit Uploader" */;
+			buildPhases = (
+				E9F4FED91D8709980071D783 /* Sources */,
+				E9F4FEDA1D8709980071D783 /* Frameworks */,
+				E9F4FEDB1D8709980071D783 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "Microbit Uploader";
+			productName = "Microbit Uploader";
+			productReference = E9F4FEDD1D8709980071D783 /* Microbit Uploader.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		E9F4FED51D8709980071D783 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0800;
+				ORGANIZATIONNAME = thomasdenney;
+				TargetAttributes = {
+					E9F4FEDC1D8709980071D783 = {
+						CreatedOnToolsVersion = 7.3.1;
+					};
+				};
+			};
+			buildConfigurationList = E9F4FED81D8709980071D783 /* Build configuration list for PBXProject "Microbit Uploader" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = E9F4FED41D8709980071D783;
+			productRefGroup = E9F4FEDE1D8709980071D783 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				E9F4FEDC1D8709980071D783 /* Microbit Uploader */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		E9F4FEDB1D8709980071D783 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				E9F4FEE71D8709980071D783 /* Assets.xcassets in Resources */,
+				E9F4FEEA1D8709980071D783 /* MainMenu.xib in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		E9F4FED91D8709980071D783 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				E9F4FEE51D8709980071D783 /* main.m in Sources */,
+				E930400A1D89620900D931CA /* Uploader.m in Sources */,
+				E9F4FEE21D8709980071D783 /* AppDelegate.m in Sources */,
+				E93040071D895D1F00D931CA /* DirectoryWatcher.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		E9F4FEE81D8709980071D783 /* MainMenu.xib */ = {
+			isa = PBXVariantGroup;
+			children = (
+				E9F4FEE91D8709980071D783 /* Base */,
+			);
+			name = MainMenu.xib;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		E9F4FEEC1D8709980071D783 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_IDENTITY = "-";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				MACOSX_DEPLOYMENT_TARGET = 10.11;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		E9F4FEED1D8709980071D783 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_IDENTITY = "-";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				MACOSX_DEPLOYMENT_TARGET = 10.11;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		E9F4FEEF1D8709980071D783 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				COMBINE_HIDPI_IMAGES = YES;
+				INFOPLIST_FILE = "Microbit Uploader/Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks";
+				PRODUCT_BUNDLE_IDENTIFIER = "org.thomasdenney.Microbit-Uploader";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		E9F4FEF01D8709980071D783 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				COMBINE_HIDPI_IMAGES = YES;
+				INFOPLIST_FILE = "Microbit Uploader/Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks";
+				PRODUCT_BUNDLE_IDENTIFIER = "org.thomasdenney.Microbit-Uploader";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		E9F4FED81D8709980071D783 /* Build configuration list for PBXProject "Microbit Uploader" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				E9F4FEEC1D8709980071D783 /* Debug */,
+				E9F4FEED1D8709980071D783 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		E9F4FEEE1D8709980071D783 /* Build configuration list for PBXNativeTarget "Microbit Uploader" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				E9F4FEEF1D8709980071D783 /* Debug */,
+				E9F4FEF01D8709980071D783 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = E9F4FED51D8709980071D783 /* Project object */;
+}

clients/macuploader/Microbit Uploader.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:Microbit Uploader.xcodeproj">
+   </FileRef>
+</Workspace>

clients/macuploader/Microbit Uploader/AppDelegate.h

@@ -0,0 +1,6 @@
+#import <Cocoa/Cocoa.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+
+@end
+

clients/macuploader/Microbit Uploader/AppDelegate.m

@@ -0,0 +1,130 @@
+#import "AppDelegate.h"
+#import "DirectoryWatcher.h"
+#import "Uploader.h"
+
+@interface AppDelegate ()<DirectoryWatcherDelegate, UploaderDelegate, NSUserNotificationCenterDelegate>
+
+@property DirectoryWatcher * watcher;
+@property Uploader * uploader;
+@property NSStatusItem * menubarItem;
+
+@end
+
+@implementation AppDelegate
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
+    // Insert code here to initialize your application
+    self.watcher = [[DirectoryWatcher alloc] initWithPath:[self downloadsDirectory]];
+    self.watcher.delegate = self;
+    [self.watcher startWatching];
+    
+    self.uploader = [[Uploader alloc] init];
+    self.uploader.delegate = self;
+    
+    [NSUserNotificationCenter defaultUserNotificationCenter].delegate = self;
+    
+    [self createMenuBarIcon];
+    [self configureVolumeMountNotifications];
+    [self showActiveMicroBits];
+}
+
+- (void)applicationWillTerminate:(NSNotification *)aNotification {
+    // Insert code here to tear down your application
+    [self.watcher stopWatching];
+}
+
+- (void)dealloc {
+    [[NSWorkspace sharedWorkspace].notificationCenter removeObserver:self];
+}
+
+#pragma mark - Directory
+
+- (void)watcher:(DirectoryWatcher *)watcher observedNewFileAtPath:(NSString *)path {
+    NSString * fullPath = [watcher.path stringByAppendingPathComponent:path];
+    if ([self.uploader shouldUploadFileAtPath:fullPath]) {
+        [self.uploader uploadFile:fullPath];
+    }
+}
+
+- (NSString*)downloadsDirectory {
+    NSArray * paths = NSSearchPathForDirectoriesInDomains(NSDownloadsDirectory, NSUserDomainMask, YES);
+    return paths.firstObject;
+}
+
+#pragma mark - Uploader delegate
+
+- (void)uploader:(Uploader *)uploader transferredFile:(NSString *)file toMicroBit:(NSString *)microbit {
+    [self showNotification:@"micro:bit upload" withDescription:[NSString stringWithFormat:@"%@ uploaded to %@", file.lastPathComponent, microbit]];
+}
+
+- (void)uploader:(Uploader *)uploader failedToTransferFile:(NSString *)file toMicroBit:(NSString *)microbit {
+    [self showNotification:@"micro:bit upload failed" withDescription:[NSString stringWithFormat:@"Couldn't transfer %@ to %@", file.lastPathComponent, microbit]];
+}
+
+- (void)showNotification:(NSString*)title withDescription:(NSString*)description {
+    NSUserNotification * notification = [NSUserNotification new];
+    notification.title = title;
+    notification.informativeText = description;
+    notification.soundName = NSUserNotificationDefaultSoundName;
+    [[NSUserNotificationCenter defaultUserNotificationCenter] deliverNotification:notification];
+}
+
+#pragma mark - NSUserNotificationCenterDelegate
+
+- (BOOL)userNotificationCenter:(NSUserNotificationCenter *)center shouldPresentNotification:(NSUserNotification *)notification {
+    return YES;
+}
+
+#pragma mark - Volume mount/unmount notification
+
+- (void)configureVolumeMountNotifications {
+    [[NSWorkspace sharedWorkspace].notificationCenter addObserver:self selector:@selector(volumeMountNotification:) name:NSWorkspaceDidRenameVolumeNotification object:nil];
+    [[NSWorkspace sharedWorkspace].notificationCenter addObserver:self selector:@selector(volumeMountNotification:) name:NSWorkspaceDidMountNotification object:nil];
+    [[NSWorkspace sharedWorkspace].notificationCenter addObserver:self selector:@selector(volumeMountNotification:) name:NSWorkspaceDidUnmountNotification object:nil];
+}
+
+- (void)volumeMountNotification:(NSNotification*)sender {
+    //Delay upadting the menu to give the chance for the disk to fully mount or unmount
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        [self showActiveMicroBits];
+    });
+}
+
+#pragma mark - Menu bar app
+
+- (void)createMenuBarIcon {
+    self.menubarItem = [[NSStatusBar systemStatusBar] statusItemWithLength:NSSquareStatusItemLength];
+    self.menubarItem.button.image = [NSImage imageNamed:@"menubar"];
+}
+
+- (void)showActiveMicroBits {
+    NSMenu * menu = [NSMenu new];
+    NSString * countString;
+    NSUInteger count = self.uploader.microBitPaths.count;
+    if (count == 0) {
+        countString = @"No connect micro:bits";
+    }
+    else if (count == 1) {
+        countString = @"1 connected micro:bit";
+    }
+    else {
+        countString = [NSString stringWithFormat:@"%lu connected micro:bits", count];
+    }
+    NSMenuItem * microBitCount = [[NSMenuItem alloc] initWithTitle:countString action:nil keyEquivalent:@""];
+    microBitCount.enabled = NO;
+    [menu addItem:microBitCount];
+    
+    NSMenuItem * websiteItem = [[NSMenuItem alloc] initWithTitle:@"Editor" action:@selector(launchEditor:) keyEquivalent:@"e"];
+    [menu addItem:websiteItem];
+    
+    NSMenuItem * quitItem = [[NSMenuItem alloc] initWithTitle:@"Quit" action:@selector(terminate:) keyEquivalent:@"q"];
+    [menu addItem:quitItem];
+    
+    self.menubarItem.menu = menu;
+}
+
+- (void)launchEditor:(id)sender {
+    [[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:@"https://pxt.microbit.org/"]];
+}
+
+@end

clients/macuploader/Microbit Uploader/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,68 @@
+{
+  "images" : [
+    {
+      "size" : "16x16",
+      "idiom" : "mac",
+      "filename" : "icon_16x16.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "16x16",
+      "idiom" : "mac",
+      "filename" : "icon_16x16@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "32x32",
+      "idiom" : "mac",
+      "filename" : "icon_32x32.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "32x32",
+      "idiom" : "mac",
+      "filename" : "icon_32x32@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "128x128",
+      "idiom" : "mac",
+      "filename" : "icon_128x128.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "128x128",
+      "idiom" : "mac",
+      "filename" : "icon_128x128@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "256x256",
+      "idiom" : "mac",
+      "filename" : "icon_256x256.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "256x256",
+      "idiom" : "mac",
+      "filename" : "icon_256x256@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "512x512",
+      "idiom" : "mac",
+      "filename" : "icon_512x512.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "512x512",
+      "idiom" : "mac",
+      "filename" : "icon_512x512@2x.png",
+      "scale" : "2x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

clients/macuploader/Microbit Uploader/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

clients/macuploader/Microbit Uploader/Assets.xcassets/menubar.imageset/Contents.json

@@ -0,0 +1,15 @@
+{
+  "images" : [
+    {
+      "idiom" : "mac",
+      "filename" : "menubar.pdf"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  },
+  "properties" : {
+    "template-rendering-intent" : "template"
+  }
+}

clients/macuploader/Microbit Uploader/Base.lproj/MainMenu.xib

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="11201" systemVersion="15G1004" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
+    <dependencies>
+        <deployment identifier="macosx"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="11201"/>
+    </dependencies>
+    <objects>
+        <customObject id="-2" userLabel="File's Owner" customClass="NSApplication">
+            <connections>
+                <outlet property="delegate" destination="Voe-Tx-rLC" id="GzC-gU-4Uq"/>
+            </connections>
+        </customObject>
+        <customObject id="-1" userLabel="First Responder" customClass="FirstResponder"/>
+        <customObject id="-3" userLabel="Application" customClass="NSObject"/>
+        <customObject id="Voe-Tx-rLC" customClass="AppDelegate"/>
+        <customObject id="YLy-65-1bz" customClass="NSFontManager"/>
+    </objects>
+</document>

clients/macuploader/Microbit Uploader/DirectoryWatcher.h

@@ -0,0 +1,24 @@
+#import <Foundation/Foundation.h>
+
+@class DirectoryWatcher;
+
+@protocol DirectoryWatcherDelegate <NSObject>
+
+- (void)watcher:(DirectoryWatcher*)watcher observedNewFileAtPath:(NSString*)path;
+
+@end
+
+@interface DirectoryWatcher : NSObject
+
+- (instancetype)initWithPath:(NSString*)path;
+
+@property (readonly) NSString * path;
+
+@property id<DirectoryWatcherDelegate> delegate;
+
+- (void)startWatching;
+
+//Automatically called when deallocated
+- (void)stopWatching;
+
+@end

clients/macuploader/Microbit Uploader/DirectoryWatcher.m

@@ -0,0 +1,75 @@
+#import "DirectoryWatcher.h"
+#import <CoreServices/CoreServices.h>
+
+void callback(ConstFSEventStreamRef streamRef, void * info, size_t numEvents, void * eventPaths, const FSEventStreamEventFlags eventFlags[], const FSEventStreamEventId eventIds[]);
+
+@interface DirectoryWatcher ()
+
+@property NSString * path;
+@property NSMutableSet<NSString*>* knownFiles;
+@property FSEventStreamRef stream;
+
+- (void)rescanPathWithEvents:(BOOL)sendEvents;
+
+@end
+
+@implementation DirectoryWatcher
+
+- (instancetype)initWithPath:(NSString *)path {
+    if (!path) {
+        return nil;
+    }
+    
+    self = [super init];
+    if (self) {
+        self.path = path;
+    }
+    return self;
+}
+
+- (void)dealloc {
+    [self stopWatching];
+}
+
+- (void)startWatching {
+    self.knownFiles = [NSMutableSet new];
+    [self rescanPathWithEvents:NO];
+    
+    CFStringRef path = (__bridge CFStringRef)(self.path);
+    CFArrayRef pathsToWatch = CFArrayCreate(NULL, (const void**)&path, 1, NULL);
+    CFAbsoluteTime latency = 1;
+    FSEventStreamContext context = { 0, (__bridge void * _Nullable)(self), NULL, NULL, NULL };
+    self.stream = FSEventStreamCreate(NULL, &callback, &context, pathsToWatch, kFSEventStreamEventIdSinceNow, latency, kFSEventStreamCreateFlagNone);
+    FSEventStreamScheduleWithRunLoop(self.stream, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+    FSEventStreamStart(self.stream);
+}
+
+- (void)stopWatching {
+    if (self.stream) {
+        FSEventStreamStop(self.stream);
+        FSEventStreamInvalidate(self.stream);
+        FSEventStreamRelease(self.stream);
+        self.stream = nil;
+    }
+}
+
+- (void)rescanPathWithEvents:(BOOL)sendEvents {
+    NSArray<NSString*>* downloadFiles = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:self.path error:nil];
+    NSMutableSet<NSString*>* fullSet = [NSMutableSet new];
+    for (NSString * file in downloadFiles) {
+        [fullSet addObject:file];
+        if (![self.knownFiles containsObject:file]) {
+            if (sendEvents) {
+                [self.delegate watcher:self observedNewFileAtPath:file];
+            }
+        }
+    }
+    self.knownFiles = fullSet;
+}
+
+@end
+
+void callback(ConstFSEventStreamRef streamRef, void * info, size_t numEvents, void * eventPaths, const FSEventStreamEventFlags eventFlags[], const FSEventStreamEventId eventIds[]) {
+    DirectoryWatcher * watcher = (__bridge DirectoryWatcher*)info;
+    [watcher rescanPathWithEvents:YES];
+}

clients/macuploader/Microbit Uploader/Info.plist

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.01</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>2</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
+	<key>LSUIElement</key>
+	<true/>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright © 2016 Thomas Denney. All rights reserved.</string>
+	<key>NSMainNibFile</key>
+	<string>MainMenu</string>
+	<key>NSPrincipalClass</key>
+	<string>NSApplication</string>
+</dict>
+</plist>

clients/macuploader/Microbit Uploader/Uploader.h

@@ -0,0 +1,21 @@
+#import <Foundation/Foundation.h>
+
+@class Uploader;
+
+@protocol UploaderDelegate <NSObject>
+
+- (void)uploader:(Uploader*)uploader transferredFile:(NSString*)file toMicroBit:(NSString*)microbit;
+- (void)uploader:(Uploader*)uploader failedToTransferFile:(NSString*)file toMicroBit:(NSString*)microbit;
+
+@end
+
+@interface Uploader : NSObject
+
+@property id<UploaderDelegate> delegate;
+
+- (BOOL)shouldUploadFileAtPath:(NSString*)path;
+- (NSArray<NSString*>*)microBitPaths;
+- (void)uploadFile:(NSString*)file;
+- (void)uploadFile:(NSString*)file toMicroBit:(NSString*)path;
+
+@end

clients/macuploader/Microbit Uploader/Uploader.m

@@ -0,0 +1,74 @@
+#import "Uploader.h"
+
+@interface Uploader ()
+
+@property NSOperationQueue * backgroundCopyQueue;
+
+@end
+
+@implementation Uploader
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        self.backgroundCopyQueue = [NSOperationQueue new];
+    }
+    return self;
+}
+
+- (BOOL)shouldUploadFileAtPath:(NSString *)path {
+    //Whilst Safari is downloading the file it appends .download to the name
+    NSRegularExpression * ignoreDownload = [NSRegularExpression regularExpressionWithPattern:@".download$" options:NSRegularExpressionCaseInsensitive error:nil];
+    if ([ignoreDownload numberOfMatchesInString:path.lastPathComponent options:0 range:NSMakeRange(0, path.lastPathComponent.length)] > 0) {
+        return NO;
+    }
+    
+    //Chrome and Firefox create .hex files
+    NSRegularExpression * hexFiles = [NSRegularExpression regularExpressionWithPattern:@".hex$" options:NSRegularExpressionCaseInsensitive error:nil];
+    if ([hexFiles numberOfMatchesInString:path.lastPathComponent options:0 range:NSMakeRange(0, path.lastPathComponent.length)] > 0) {
+        return YES;
+    }
+    
+    //Safari tends to just name files 'Unknown X'
+    NSRegularExpression * unknownFiles = [NSRegularExpression regularExpressionWithPattern:@"^Unknown(( |-)[0-9]+)?" options:NSRegularExpressionCaseInsensitive error:nil];
+    if ([unknownFiles numberOfMatchesInString:path.lastPathComponent options:0 range:NSMakeRange(0, path.lastPathComponent.length)]) {
+        return YES;
+    }
+    
+    return NO;
+}
+
+- (NSArray<NSString*>*)microBitPaths {
+    NSArray<NSURL*>* allVolumes = [[NSFileManager defaultManager] mountedVolumeURLsIncludingResourceValuesForKeys:nil options:NSVolumeEnumerationSkipHiddenVolumes];
+    NSMutableArray<NSString*>* microbitPaths = [NSMutableArray new];
+    NSRegularExpression * microbitRegex = [NSRegularExpression regularExpressionWithPattern:@"^MICROBIT" options:NSRegularExpressionCaseInsensitive error:nil];
+    for (NSURL * volume in allVolumes) {
+        NSString * lastPathComponent = volume.lastPathComponent;
+        if ([microbitRegex numberOfMatchesInString:lastPathComponent options:0 range:NSMakeRange(0, lastPathComponent.length)] > 0) {
+            [microbitPaths addObject:volume.path];
+        }
+    }
+    
+    return microbitPaths;
+}
+
+- (void)uploadFile:(NSString *)file {
+    for (NSString * microbit in [self microBitPaths]) {
+        [self uploadFile:file toMicroBit:microbit];
+    }
+}
+
+- (void)uploadFile:(NSString *)file toMicroBit:(NSString *)path {
+    [self.backgroundCopyQueue addOperationWithBlock:^{
+        NSError * copyError;
+        NSString * destination = [path stringByAppendingPathComponent:file.lastPathComponent];
+        if (![[NSFileManager defaultManager] copyItemAtPath:file toPath:destination error:&copyError]) {
+            [self.delegate uploader:self failedToTransferFile:file toMicroBit:path.lastPathComponent];
+        }
+        else {
+            [self.delegate uploader:self transferredFile:file toMicroBit:path.lastPathComponent];
+        }
+    }];
+}
+
+@end

clients/macuploader/Microbit Uploader/main.m

@@ -0,0 +1,5 @@
+#import <Cocoa/Cocoa.h>
+
+int main(int argc, const char * argv[]) {
+    return NSApplicationMain(argc, argv);
+}

clients/macuploader/README.md

@@ -0,0 +1,40 @@
+# micro:bit uploader for OS X
+
+![](Microbit Uploader/Assets.xcassets/AppIcon.appiconset/icon_256x256.png)
+
+This project is a clone of the [Windows
+uploader](https://pxt.microbit.org/uploader), but for OS X. Once launched,
+the app runs in your menu bar and will automatically deploy any HEX files to
+your `micro:bit`. Like the Windows version, it is compatible with any browser
+that can run [pxt.microbit.org](http://pxt.microbit.org).
+
+## Install the built version
+
+1. Download the latest `.zip` release from the `Release` directory
+2. Unzip it
+3. Drag `Microbit Uploader` to your Applications folder and launch it
+
+## Building
+
+To build the project you'll need a copy of OS X 10.11 or higher and Xcode 8 or
+higher (you may be able to build on earlier OSes or versions of Xcode, but this
+remains untested). Once you have a development environment set up, just build
+and run `Microbit Uploader.xcodeproj`.
+
+## Distributing
+
+1. Open the Xcode project
+2. Product > Archive
+3. Export:
+
+    ![Export](Graphics/export.png)
+
+4. You will then have the option of either signing or not-signing the
+   application:
+
+    a) If you have an Apple developer account, select 'Export a Developer
+       ID-signed Application'
+
+    b) If you don't have a developer ID, select 'Export as a macOS App'
+
+5. Zip the produced app and upload to CDN or equivalent

clients/winuploader/CodeTheMicroBit.sln

@@ -0,0 +1,40 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25123.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeTheMicrobit", "Microbit.Uploader\CodeTheMicrobit.csproj", "{7DC6CA45-FD75-44BC-805E-708C812CD4BF}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|ARM = Debug|ARM
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|ARM = Release|ARM
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|ARM.Build.0 = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|x64.Build.0 = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Debug|x86.Build.0 = Debug|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|ARM.ActiveCfg = Release|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|ARM.Build.0 = Release|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|x64.ActiveCfg = Release|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|x64.Build.0 = Release|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|x86.ActiveCfg = Release|Any CPU
+		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|x86.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

clients/winuploader/Microbit.Uploader/App.config

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+  <startup>
+    <supportedRuntime version="v4.0"/>
+    <supportedRuntime version="v2.0.50727"/>
+  </startup>
+</configuration>

clients/winuploader/Microbit.Uploader/CodeTheMicrobit.csproj

@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{7DC6CA45-FD75-44BC-805E-708C812CD4BF}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Microsoft.MicroBit</RootNamespace>
+    <AssemblyName>CodeTheMicrobit</AssemblyName>
+    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <RunCodeAnalysis>true</RunCodeAnalysis>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationIcon>
+    </ApplicationIcon>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
+  <PropertyGroup />
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualBasic" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Deployment" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Management" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Settings.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Settings.Designer.cs">
+      <DependentUpon>Settings.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GlobalSuppressions.cs" />
+    <Compile Include="KnownFolders.cs" />
+    <Compile Include="LicenseDialog.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="LicenseDialog.Designer.cs">
+      <DependentUpon>LicenseDialog.cs</DependentUpon>
+    </Compile>
+    <Compile Include="MainForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="MainForm.Designer.cs">
+      <DependentUpon>MainForm.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SingleInstanceAppHelper.cs" />
+    <Compile Include="SingleInstanceAppStarter.cs" />
+    <EmbeddedResource Include="LicenseDialog.resx">
+      <DependentUpon>LicenseDialog.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="MainForm.resx">
+      <DependentUpon>MainForm.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+      <DesignTime>True</DesignTime>
+    </Compile>
+    <EmbeddedResource Include="Settings.resx">
+      <DependentUpon>Settings.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="MSFT_logo_png.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+    <None Include="Resources\MSR-LA - 2576.rtf" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="favicon.ico" />
+    <EmbeddedResource Include="microbit.red.png" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

clients/winuploader/Microbit.Uploader/KnownFolders.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Management;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Microsoft.MicroBit
+{
+    /// <summary>
+    /// Class containing methods to retrieve specific file system paths.
+    /// </summary>
+    internal static class KnownFoldersNativeMethods
+    {
+        [SecurityCritical]
+        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
+        public static string GetDownloadPath()
+        {
+            IntPtr outPath;
+            int result = SHGetKnownFolderPath(new Guid("{374DE290-123F-4565-9164-39C4925E467B}"), 0x00004000, new IntPtr(0), out outPath);
+            if (result >= 0)
+                return Marshal.PtrToStringUni(outPath);
+            else return null;
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA5122:PInvokesShouldNotBeSafeCriticalFxCopRule")]
+        [DllImport("Shell32.dll")]
+        [SecurityCritical]
+        private static extern int SHGetKnownFolderPath(
+            [MarshalAs(UnmanagedType.LPStruct)]Guid rfid, uint dwFlags, IntPtr hToken,
+            out IntPtr ppszPath);
+    }
+
+}

clients/winuploader/Microbit.Uploader/LicenseDialog.Designer.cs

@@ -0,0 +1,93 @@
+namespace Microsoft.MicroBit
+{
+    partial class LicenseDialog
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.textBox = new System.Windows.Forms.RichTextBox();
+            this.acceptButton = new System.Windows.Forms.Button();
+            this.exitButton = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // textBox
+            // 
+            this.textBox.BorderStyle = System.Windows.Forms.BorderStyle.None;
+            this.textBox.Location = new System.Drawing.Point(13, 13);
+            this.textBox.Name = "textBox";
+            this.textBox.ReadOnly = true;
+            this.textBox.Size = new System.Drawing.Size(465, 438);
+            this.textBox.TabIndex = 0;
+            this.textBox.Text = "";
+            // 
+            // acceptButton
+            // 
+            this.acceptButton.Location = new System.Drawing.Point(322, 457);
+            this.acceptButton.Name = "acceptButton";
+            this.acceptButton.Size = new System.Drawing.Size(75, 23);
+            this.acceptButton.TabIndex = 1;
+            this.acceptButton.Text = "Accept";
+            this.acceptButton.UseVisualStyleBackColor = true;
+            this.acceptButton.Click += new System.EventHandler(this.acceptButton_Click);
+            // 
+            // exitButton
+            // 
+            this.exitButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.exitButton.Location = new System.Drawing.Point(403, 457);
+            this.exitButton.Name = "exitButton";
+            this.exitButton.Size = new System.Drawing.Size(75, 23);
+            this.exitButton.TabIndex = 2;
+            this.exitButton.Text = "Exit";
+            this.exitButton.UseVisualStyleBackColor = true;
+            this.exitButton.Click += new System.EventHandler(this.exitButton_Click);
+            // 
+            // LicenseDialog
+            // 
+            this.AcceptButton = this.acceptButton;
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.CancelButton = this.exitButton;
+            this.ClientSize = new System.Drawing.Size(490, 492);
+            this.ControlBox = false;
+            this.Controls.Add(this.exitButton);
+            this.Controls.Add(this.acceptButton);
+            this.Controls.Add(this.textBox);
+            this.MaximizeBox = false;
+            this.MinimizeBox = false;
+            this.Name = "LicenseDialog";
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "code the micro:bit terms of use";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.RichTextBox textBox;
+        private System.Windows.Forms.Button acceptButton;
+        private System.Windows.Forms.Button exitButton;
+    }
+}

clients/winuploader/Microbit.Uploader/LicenseDialog.cs

@@ -0,0 +1,32 @@
+using Microsoft.MicroBit.Properties;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+namespace Microsoft.MicroBit
+{
+    public partial class LicenseDialog : Form
+    {
+        public LicenseDialog()
+        {
+            InitializeComponent();
+            this.textBox.Text = Resources.MSR_LA___2576;
+        }
+
+        private void acceptButton_Click(object sender, EventArgs e)
+        {
+            this.DialogResult = DialogResult.Yes;
+            this.Close();
+        }
+
+        private void exitButton_Click(object sender, EventArgs e)
+        {
+            this.DialogResult = DialogResult.No;
+            this.Close();
+        }
+    }
+}

clients/winuploader/Microbit.Uploader/LicenseDialog.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

clients/winuploader/Microbit.Uploader/MainForm.Designer.cs

@@ -0,0 +1,173 @@
+namespace Microsoft.MicroBit
+{
+    partial class MainForm
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm));
+            this.statusLabel = new System.Windows.Forms.Label();
+            this.backgroundPictureBox = new System.Windows.Forms.PictureBox();
+            this.trayIcon = new System.Windows.Forms.NotifyIcon(this.components);
+            this.versionLabel = new System.Windows.Forms.LinkLabel();
+            this.label1 = new System.Windows.Forms.Label();
+            this.SettingsLabel = new System.Windows.Forms.LinkLabel();
+            this.pictureBox1 = new System.Windows.Forms.PictureBox();
+            this.linkLabel1 = new System.Windows.Forms.LinkLabel();
+            ((System.ComponentModel.ISupportInitialize)(this.backgroundPictureBox)).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
+            this.SuspendLayout();
+            // 
+            // statusLabel
+            // 
+            this.statusLabel.BackColor = System.Drawing.SystemColors.Window;
+            this.statusLabel.Font = new System.Drawing.Font("Consolas", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.statusLabel.Location = new System.Drawing.Point(11, 30);
+            this.statusLabel.Name = "statusLabel";
+            this.statusLabel.Size = new System.Drawing.Size(364, 23);
+            this.statusLabel.TabIndex = 1;
+            this.statusLabel.Text = "loading...";
+            // 
+            // backgroundPictureBox
+            // 
+            this.backgroundPictureBox.BackColor = System.Drawing.Color.White;
+            this.backgroundPictureBox.Cursor = System.Windows.Forms.Cursors.Hand;
+            this.backgroundPictureBox.Image = global::Microsoft.MicroBit.Properties.Resources.MSFT_logo_png;
+            this.backgroundPictureBox.InitialImage = null;
+            this.backgroundPictureBox.Location = new System.Drawing.Point(226, 91);
+            this.backgroundPictureBox.Name = "backgroundPictureBox";
+            this.backgroundPictureBox.Size = new System.Drawing.Size(149, 52);
+            this.backgroundPictureBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom;
+            this.backgroundPictureBox.TabIndex = 0;
+            this.backgroundPictureBox.TabStop = false;
+            this.backgroundPictureBox.Click += new System.EventHandler(this.backgroundPictureBox_Click);
+            // 
+            // trayIcon
+            // 
+            this.trayIcon.Icon = ((System.Drawing.Icon)(resources.GetObject("trayIcon.Icon")));
+            this.trayIcon.Visible = true;
+            this.trayIcon.Click += new System.EventHandler(this.trayIcon_Click);
+            // 
+            // versionLabel
+            // 
+            this.versionLabel.AutoSize = true;
+            this.versionLabel.Location = new System.Drawing.Point(12, 121);
+            this.versionLabel.Name = "versionLabel";
+            this.versionLabel.Size = new System.Drawing.Size(28, 13);
+            this.versionLabel.TabIndex = 2;
+            this.versionLabel.TabStop = true;
+            this.versionLabel.Text = "v0.9";
+            this.versionLabel.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.versionLabel_LinkClicked);
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.label1.Location = new System.Drawing.Point(12, 103);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(169, 15);
+            this.label1.TabIndex = 3;
+            this.label1.Text = "Automatic upload of .hex files.";
+            // 
+            // SettingsLabel
+            // 
+            this.SettingsLabel.AutoSize = true;
+            this.SettingsLabel.Location = new System.Drawing.Point(151, 121);
+            this.SettingsLabel.Name = "SettingsLabel";
+            this.SettingsLabel.Size = new System.Drawing.Size(43, 13);
+            this.SettingsLabel.TabIndex = 4;
+            this.SettingsLabel.TabStop = true;
+            this.SettingsLabel.Text = "settings";
+            this.SettingsLabel.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.SettingsLabel_LinkClicked);
+            // 
+            // pictureBox1
+            // 
+            this.pictureBox1.BackColor = System.Drawing.Color.White;
+            this.pictureBox1.Cursor = System.Windows.Forms.Cursors.Hand;
+            this.pictureBox1.Image = global::Microsoft.MicroBit.Properties.Resources.microbit_red;
+            this.pictureBox1.InitialImage = null;
+            this.pictureBox1.Location = new System.Drawing.Point(226, 6);
+            this.pictureBox1.Name = "pictureBox1";
+            this.pictureBox1.Size = new System.Drawing.Size(149, 79);
+            this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom;
+            this.pictureBox1.TabIndex = 5;
+            this.pictureBox1.TabStop = false;
+            this.pictureBox1.Click += new System.EventHandler(this.pictureBox1_Click);
+            // 
+            // linkLabel1
+            // 
+            this.linkLabel1.AutoSize = true;
+            this.linkLabel1.Location = new System.Drawing.Point(62, 121);
+            this.linkLabel1.Name = "linkLabel1";
+            this.linkLabel1.Size = new System.Drawing.Size(60, 13);
+            this.linkLabel1.TabIndex = 6;
+            this.linkLabel1.TabStop = true;
+            this.linkLabel1.Text = "open editor";
+            this.linkLabel1.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel1_LinkClicked);
+            // 
+            // MainForm
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.BackColor = System.Drawing.Color.White;
+            this.ClientSize = new System.Drawing.Size(388, 143);
+            this.Controls.Add(this.linkLabel1);
+            this.Controls.Add(this.pictureBox1);
+            this.Controls.Add(this.SettingsLabel);
+            this.Controls.Add(this.label1);
+            this.Controls.Add(this.versionLabel);
+            this.Controls.Add(this.statusLabel);
+            this.Controls.Add(this.backgroundPictureBox);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
+            this.MaximizeBox = false;
+            this.Name = "MainForm";
+            this.ShowInTaskbar = false;
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "code the micro:bit";
+            this.Load += new System.EventHandler(this.MainForm_Load);
+            ((System.ComponentModel.ISupportInitialize)(this.backgroundPictureBox)).EndInit();
+            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.PictureBox backgroundPictureBox;
+        private System.Windows.Forms.Label statusLabel;
+        private System.Windows.Forms.NotifyIcon trayIcon;
+        private System.Windows.Forms.LinkLabel versionLabel;
+        private System.Windows.Forms.Label label1;
+        private System.Windows.Forms.LinkLabel SettingsLabel;
+        private System.Windows.Forms.PictureBox pictureBox1;
+        private System.Windows.Forms.LinkLabel linkLabel1;
+    }
+}
+

clients/winuploader/Microbit.Uploader/MainForm.cs

@@ -0,0 +1,267 @@
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing;
+using System.IO;
+using System.Security;
+using System.Threading;
+using System.Windows.Forms;
+
+namespace Microsoft.MicroBit
+{
+    internal partial class MainForm : Form
+    {
+        FileSystemWatcher watcher;
+        private string customcopypath = "";
+
+        public MainForm()
+        {
+            InitializeComponent();
+            var v = typeof(MainForm).Assembly.GetName().Version;
+            this.versionLabel.Text = "v" + v.Major + "." + v.Minor;
+        }
+
+        private void MainForm_Load(object sender, EventArgs e)
+        {
+            this.initializeFileWatch();
+            customcopypath = (string)Application.UserAppDataRegistry.GetValue("CustomDirectory", "");
+            this.openEditor();
+        }
+
+        private void openEditor()
+        {
+            // lanch editor
+            try { Process.Start("https://pxt.microbit.org#uploader"); } catch (Exception) { }
+        }
+
+        private void initializeFileWatch()
+        {
+            if (!checkTOU()) return;
+
+            var downloads = KnownFoldersNativeMethods.GetDownloadPath();
+            if (downloads == null)
+            {
+                this.updateStatus("oops, can't find the `Downloads` folder");
+                return;
+            }
+
+            this.watcher = new FileSystemWatcher(downloads);
+            this.watcher.Renamed += (sender, e) => this.handleFileEvent(e);
+            this.watcher.Created += (sender, e) => this.handleFileEvent(e);
+            this.watcher.EnableRaisingEvents = true;
+
+            this.waitingForHexFileStatus();
+        }
+
+        private void waitingForHexFileStatus()
+        {
+            this.updateStatus("waiting for .hex file...");
+            this.trayIcon.ShowBalloonTip(3000, "ready...", "waiting for .hex file...", ToolTipIcon.None);
+        }
+
+        static bool checkTOU()
+        {
+            var v = (int)Application.UserAppDataRegistry.GetValue("TermOfUse", 0);
+            if (v != 1)
+            {
+                using (var f = new LicenseDialog())
+                {
+                    var r = f.ShowDialog();
+                    if (r != DialogResult.Yes)
+                    {
+                        Application.Exit();
+                        return false;
+                    }
+                }
+                Application.UserAppDataRegistry.SetValue("TermOfUse", 1, RegistryValueKind.DWord);
+            }
+
+            return true;
+        }
+
+        delegate void Callback();
+
+        private void updateStatus(string value)
+        {
+            Callback a = (Callback)(() =>
+            {
+                this.statusLabel.Text = value;
+                this.trayIcon.Text = value;
+            });
+            this.Invoke(a);
+        }
+
+        void handleFileEvent(FileSystemEventArgs e)
+        {
+            this.handleFile(e.FullPath);
+        }
+
+        volatile int copying;
+        void handleFile(string fullPath)
+        {
+            try
+            {
+                // In case this is data-url download, at least Chrome will not rename file, but instead write to it
+                // directly. This mean we may catch it in the act. Let's leave it some time to finish writing.
+                Thread.Sleep(500);
+
+                var info = new System.IO.FileInfo(fullPath);
+                Trace.WriteLine("download: " + info.FullName);
+
+                if (info.Extension != ".hex") return;
+
+                var infoName = info.Name;
+                Trace.WriteLine("download name: " + info.Name);
+                if (!infoName.StartsWith("microbit-", StringComparison.OrdinalIgnoreCase)) return;
+                if (info.Name.EndsWith(".uploaded.hex", StringComparison.OrdinalIgnoreCase)) return;
+                if (info.Length > 1000000) return; // make sure we don't try to copy large files
+
+
+                // already copying?
+                if (Interlocked.Exchange(ref this.copying, 1) == 1)
+                    return;
+
+                try
+                {
+
+                    var driveletters = getMicrobitDrives();
+                    List<String> drives = new List<String>();
+                    foreach (var d in driveletters)
+                    {
+                        drives.Add(d.RootDirectory.FullName);
+                    }
+                    if (!String.IsNullOrEmpty(customcopypath) && Directory.Exists(customcopypath))
+                    {
+                        drives.Add(customcopypath);
+                    }
+                    if (drives.Count == 0)
+                    {
+                        this.updateStatus("no board found");
+                        this.trayIcon.ShowBalloonTip(3000, "cancelled uploading...", "no board found", ToolTipIcon.None);
+                        return;
+                    }
+
+                    this.updateStatus("uploading .hex file");
+                    this.trayIcon.ShowBalloonTip(3000, "uploading...", "uploading .hex file", ToolTipIcon.None);
+
+                    // copy to all boards
+                    copyFirmware(info.FullName, drives);
+
+                    // move away hex file
+                    var temp = System.IO.Path.ChangeExtension(info.FullName, ".uploaded.hex");
+                    try
+                    {
+                        File.Copy(info.FullName, temp, true);
+                        File.Delete(info.FullName);
+                    }
+                    catch (IOException) { }
+                    catch (NotSupportedException) { }
+                    catch (UnauthorizedAccessException) { }
+                    catch (ArgumentException) { }
+
+                    // update ui
+                    this.updateStatus("uploading done");
+                    this.waitingForHexFileStatus();
+                }
+                finally
+                {
+                    Interlocked.Exchange(ref this.copying, 0);
+                }
+            }
+            catch (IOException) { }
+            catch (NotSupportedException) { }
+            catch (UnauthorizedAccessException) { }
+            catch (ArgumentException) { }
+        }
+
+        static void copyFirmware(string file, List<string> drives)
+        {
+            var waitHandles = new List<WaitHandle>();
+            foreach (var drive in drives)
+            {
+                var ev = new AutoResetEvent(false);
+                waitHandles.Add(ev);
+                ThreadPool.QueueUserWorkItem((state) =>
+                {
+                    try
+                    {
+                        var trg = System.IO.Path.Combine(drive, "firmware.hex");
+                        File.Copy(file, trg, true);
+                    }
+                    catch (IOException) { }
+                    catch (NotSupportedException) { }
+                    catch (UnauthorizedAccessException) { }
+                    catch (ArgumentException) { }
+                    ev.Set();
+                }, ev);
+            }
+
+            //waits for all the threads (waitHandles) to call the .Set() method
+            //and inform that the execution has finished.
+            WaitHandle.WaitAll(waitHandles.ToArray());
+        }
+
+        static DriveInfo[] getMicrobitDrives()
+        {
+            var drives = System.IO.DriveInfo.GetDrives();
+            var r = new System.Collections.Generic.List<DriveInfo>();
+            foreach (var di in drives)
+            {
+                var label = getVolumeLabel(di);
+                if (label.StartsWith("MICROBIT", StringComparison.Ordinal))
+                    r.Add(di);
+            }
+            return r.ToArray();
+        }
+
+        static string getVolumeLabel(DriveInfo di)
+        {
+            try { return di.VolumeLabel; }
+            catch (IOException) { }
+            catch (SecurityException) { }
+            catch (UnauthorizedAccessException) { }
+            return "";
+        }
+
+        private void trayIcon_Click(object sender, EventArgs e)
+        {
+            this.WindowState = FormWindowState.Minimized;
+            this.WindowState = FormWindowState.Normal;
+            this.Show();
+            this.Activate();
+        }
+
+        private void versionLabel_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
+        {
+            try
+            {
+                Process.Start("https://pxt.microbit.org/uploader");
+            }
+            catch (IOException) { }
+        }
+
+        private void backgroundPictureBox_Click(object sender, EventArgs e)
+        {
+            this.openEditor();
+        }
+
+        private void SettingsLabel_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
+        {
+            var settings = new Settings(customcopypath);
+            settings.ShowDialog();
+            customcopypath = settings.CustomCopyPath;
+            Application.UserAppDataRegistry.SetValue("CustomDirectory", customcopypath, RegistryValueKind.String);
+        }
+
+        private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
+        {
+            this.openEditor();
+        }
+
+        private void pictureBox1_Click(object sender, EventArgs e)
+        {
+            this.openEditor();
+        }
+    }
+}

clients/winuploader/Microbit.Uploader/MainForm.resx

@@ -0,0 +1,172 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <metadata name="trayIcon.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="trayIcon.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        AAABAAEAEBAAAAAAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAQAAMIOAADCDgAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAN6bIZTOkxoUtj62FL5W1hTWpzYUvlbWFLY+thTKgwoUxnb+FLY6shS6TsoUzpMaFL5a1hS2P
+        rYUxnb6FNZ2+ZTCTsvkriaf/KYKe/yuIpf8uk7L/K4il/ymBnP8tjqz/K4qn/yiBnP8qhaL/KoWh/yqG
+        o/8ogJv/JXeQ/yqDnvkRMjz/Di02/wofJv8MJS3/Di02/wskLP8HGB3/Di43/w0qM/8HFxz/CyMr/w4s
+        Nv8MJi7/CiAm/w4sNv8RMTv/BQsN/wUQE/8BAgL/AQQF/wYRFP8EBgf/AgIA/xAYJv8TGy3/AgIA/wMF
+        Bv8HEhX/AQUG/wECAv8FEBT/BQsN/wYFD/8LByT/AQAC/wAAAP8CAgL/AwMD/woKEv8LCxT/DAwY/woK
+        Ev8DAwT/AgIC/wAAAP8AAAD/AAAA/wICAv8JCA//IBs//wwMEP8AAAD/AgIC/wQEBv8bGzf/BgYK/wQE
+        Bf8bGzj/BgYJ/wMDA/8AAAD/CgoK/xEREf8HBwf/Li4u/1FRUf9ERET/AQEA/wwMGf8UFCj/BAQE/wMD
+        Av8DAwL/BAQE/xAQIP8RESL/AAAA/z8/P/9SUlH/NTU1/y4uLv9QUFD/QUFB/wEBAP8LCxf/EhIk/wIC
+        Af8JCRH/CwsV/wICAf8PDx3/Dw8f/wAAAP89PT3/UVFQ/zQ0M/8FBQX/DAwM/wgICP8AAAD/CwsW/xIS
+        JP8FBQb/Dg4b/xERIv8FBQb/Dw8d/w8PHv8AAAD/CAgK/xwXO/8KCRT/BAMI/wAAAP8AAAD/AAAA/wIC
+        Av8EBAX/HR06/wgIEP8GBgv/HR07/wYGCf8DAwL/AAAA/wAAAP8JBh3/BwUS/y0fhf8FBBD/AAAA/wAA
+        AP8AAAD/AAAA/xIOMv8fFVz/HhVa/xQPOP8AAQD/AAAA/wAAAP8AAAD/AAAA/wICAv9UO/v/MiKX/wUD
+        D/8FAw7/AwIK/wAAAP8RCzP/IBZi/yAWYP8TDTr/AAAA/wAAAP8AAAD/AAAA/wAAAP8CAgL/VTz/+FQ6
+        /P8yI5j/IBZg/ywehf8MCCX/BAMN/wUEEP8GBBH/AQED/wAAAP8AAAD/AAAA/wAAAP8AAAD/AgIC9Vc+
+        /2BVOv9+Ujj0fTwptH5ONul9OCapfRUOPn4AAAB+AAAAfQAAAH4AAAB+AAAAfQAAAH4AAAB+AAAAfgQE
+        BFkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAA//8AAA==
+</value>
+  </data>
+  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        AAABAAEAEBAAAAAAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAQAAMIOAADCDgAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAN6bIZTOkxoUtj62FL5W1hTWpzYUvlbWFLY+thTKgwoUxnb+FLY6shS6TsoUzpMaFL5a1hS2P
+        rYUxnb6FNZ2+ZTCTsvkriaf/KYKe/yuIpf8uk7L/K4il/ymBnP8tjqz/K4qn/yiBnP8qhaL/KoWh/yqG
+        o/8ogJv/JXeQ/yqDnvkRMjz/Di02/wofJv8MJS3/Di02/wskLP8HGB3/Di43/w0qM/8HFxz/CyMr/w4s
+        Nv8MJi7/CiAm/w4sNv8RMTv/BQsN/wUQE/8BAgL/AQQF/wYRFP8EBgf/AgIA/xAYJv8TGy3/AgIA/wMF
+        Bv8HEhX/AQUG/wECAv8FEBT/BQsN/wYFD/8LByT/AQAC/wAAAP8CAgL/AwMD/woKEv8LCxT/DAwY/woK
+        Ev8DAwT/AgIC/wAAAP8AAAD/AAAA/wICAv8JCA//IBs//wwMEP8AAAD/AgIC/wQEBv8bGzf/BgYK/wQE
+        Bf8bGzj/BgYJ/wMDA/8AAAD/CgoK/xEREf8HBwf/Li4u/1FRUf9ERET/AQEA/wwMGf8UFCj/BAQE/wMD
+        Av8DAwL/BAQE/xAQIP8RESL/AAAA/z8/P/9SUlH/NTU1/y4uLv9QUFD/QUFB/wEBAP8LCxf/EhIk/wIC
+        Af8JCRH/CwsV/wICAf8PDx3/Dw8f/wAAAP89PT3/UVFQ/zQ0M/8FBQX/DAwM/wgICP8AAAD/CwsW/xIS
+        JP8FBQb/Dg4b/xERIv8FBQb/Dw8d/w8PHv8AAAD/CAgK/xwXO/8KCRT/BAMI/wAAAP8AAAD/AAAA/wIC
+        Av8EBAX/HR06/wgIEP8GBgv/HR07/wYGCf8DAwL/AAAA/wAAAP8JBh3/BwUS/y0fhf8FBBD/AAAA/wAA
+        AP8AAAD/AAAA/xIOMv8fFVz/HhVa/xQPOP8AAQD/AAAA/wAAAP8AAAD/AAAA/wICAv9UO/v/MiKX/wUD
+        D/8FAw7/AwIK/wAAAP8RCzP/IBZi/yAWYP8TDTr/AAAA/wAAAP8AAAD/AAAA/wAAAP8CAgL/VTz/+FQ6
+        /P8yI5j/IBZg/ywehf8MCCX/BAMN/wUEEP8GBBH/AQED/wAAAP8AAAD/AAAA/wAAAP8AAAD/AgIC9Vc+
+        /2BVOv9+Ujj0fTwptH5ONul9OCapfRUOPn4AAAB+AAAAfQAAAH4AAAB+AAAAfQAAAH4AAAB+AAAAfgQE
+        BFkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAA//8AAA==
+</value>
+  </data>
+</root>

clients/winuploader/Microbit.Uploader/Program.cs

@@ -0,0 +1,30 @@
+using Microsoft.VisualBasic.ApplicationServices;
+using System;
+using System.Windows.Forms;
+
+namespace Microsoft.MicroBit
+{
+    static class Program
+    {
+        /// <summary>
+        /// The main entry point for the application.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
+        [STAThread]
+        static void Main()
+        {
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            SingleInstanceAppStarter.Start(new MainForm(), StartNewInstance);
+        }
+
+        // The handler when attempting to start another instance of this application
+        // We can customize the logic here for which form to activate in different 
+        // conditions. Like in this sample, we will be selectively activate the LoginForm
+        // or MainForm based on the login state of the user.
+        static void StartNewInstance(object sender, StartupNextInstanceEventArgs e)
+        {
+            e.BringToForeground = true;
+        }
+    }
+}

clients/winuploader/Microbit.Uploader/Properties/AssemblyInfo.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Code The micro:bit Uploader")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("MicrosoftMicrobitUploader")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7dc6ca45-fd75-44bc-805e-708c812cd4bf")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.10.0.0")]
+[assembly: AssemblyFileVersion("0.10.0.0")]
+[assembly: CLSCompliant(true)]
+[assembly: NeutralResourcesLanguage("en-US")]

clients/winuploader/Microbit.Uploader/Properties/Resources.Designer.cs

@@ -0,0 +1,92 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace Microsoft.MicroBit.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.MicroBit.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap microbit_red {
+            get {
+                object obj = ResourceManager.GetObject("microbit_red", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap MSFT_logo_png {
+            get {
+                object obj = ResourceManager.GetObject("MSFT_logo_png", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to TBD.
+        /// </summary>
+        internal static string MSR_LA___2576 {
+            get {
+                return ResourceManager.GetString("MSR_LA___2576", resourceCulture);
+            }
+        }
+    }
+}

clients/winuploader/Microbit.Uploader/Properties/Resources.resx

@@ -0,0 +1,130 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="microbit_red" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\microbit.red.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="MSFT_logo_png" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\MSFT_logo_png.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="MSR_LA___2576" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\MSR-LA - 2576.rtf;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
+  </data>
+</root>

clients/winuploader/Microbit.Uploader/Resources/MSR-LA - 2576.rtf

@@ -0,0 +1 @@
+TBD

clients/winuploader/Microbit.Uploader/Settings.Designer.cs

@@ -0,0 +1,76 @@
+namespace Microsoft.MicroBit
+{
+    partial class Settings
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.textBox1 = new System.Windows.Forms.TextBox();
+            this.label1 = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // textBox1
+            // 
+            this.textBox1.Location = new System.Drawing.Point(107, 12);
+            this.textBox1.Name = "textBox1";
+            this.textBox1.Size = new System.Drawing.Size(100, 20);
+            this.textBox1.TabIndex = 0;
+            this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged);
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(34, 15);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(67, 13);
+            this.label1.TabIndex = 1;
+            this.label1.Text = "Custom Path";
+            // 
+            // Settings
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(246, 48);
+            this.Controls.Add(this.label1);
+            this.Controls.Add(this.textBox1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.MaximizeBox = false;
+            this.MinimizeBox = false;
+            this.Name = "Settings";
+            this.ShowIcon = false;
+            this.Text = "Settings";
+            this.Load += new System.EventHandler(this.Settings_Load);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox textBox1;
+        private System.Windows.Forms.Label label1;
+    }
+}

clients/winuploader/Microbit.Uploader/Settings.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Security.AccessControl;
+using System.Text;
+using System.Windows.Forms;
+
+namespace Microsoft.MicroBit
+{
+    public partial class Settings : Form
+    {
+        public string CustomCopyPath;
+        public Settings(string currentpath)
+        {
+            InitializeComponent();
+            CustomCopyPath = currentpath;
+
+        }
+
+        private void Settings_Load(object sender, EventArgs e)
+        {
+            textBox1.Text = CustomCopyPath;
+        }
+
+        private void label1_Click(object sender, EventArgs e)
+        {
+
+        }
+
+        private void textBox1_TextChanged(object sender, EventArgs e)
+        {
+            CustomCopyPath = textBox1.Text;
+        }
+    }
+}

clients/winuploader/Microbit.Uploader/Settings.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

clients/winuploader/Microbit.Uploader/SingleInstanceAppHelper.cs

@@ -0,0 +1,39 @@
+/****************************** Module Header ******************************\
+* Module Name:  SingleInstanceAppHelper.cs
+* Project:      CSWinFormSingleInstanceApp
+* Copyright (c) Microsoft Corporation.
+* 
+* The  sample demonstrates how to achieve the goal that only 
+* one instance of the application is allowed in Windows Forms application..
+* 
+* This source is subject to the Microsoft Public License.
+* See http://www.microsoft.com/en-us/openness/resources/licenses.aspx#MPL.
+* All other rights reserved.
+* 
+* THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, 
+* EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED 
+* WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
+\***************************************************************************/
+
+using System;
+using Microsoft.VisualBasic.ApplicationServices;
+using System.Windows.Forms;
+
+namespace Microsoft.MicroBit
+{
+    // We need to add Microsoft.VisualBasic reference to use
+    // WindowsFormsApplicationBase type.
+    class SingleInstanceApp : WindowsFormsApplicationBase 
+    {
+        public SingleInstanceApp()
+        {
+        }
+        public SingleInstanceApp(Form f)
+        {
+            // Set IsSingleInstance property to true to make the application 
+            base.IsSingleInstance = true;
+            // Set MainForm of the application.
+            this.MainForm = f;
+        }
+    }
+}

clients/winuploader/Microbit.Uploader/SingleInstanceAppStarter.cs

@@ -0,0 +1,39 @@
+/****************************** Module Header ******************************\
+* Module Name:  SingleInstanceAppStarter.cs
+* Project:      CSWinFormSingleInstanceApp
+* Copyright (c) Microsoft Corporation.
+* 
+* The  sample demonstrates how to achieve the goal that only 
+* one instance of the application is allowed in Windows Forms application..
+* 
+* This source is subject to the Microsoft Public License.
+* See http://www.microsoft.com/en-us/openness/resources/licenses.aspx#MPL.
+* All other rights reserved.
+* 
+* THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, 
+* EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED 
+* WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
+\***************************************************************************/
+
+using System;
+using System.Windows.Forms;
+using Microsoft.VisualBasic.ApplicationServices;
+
+namespace Microsoft.MicroBit
+{
+    internal static class SingleInstanceAppStarter
+    {
+        static SingleInstanceApp app = null;
+
+        // Construct SingleInstanceApp object, and invoke its run method.
+        public static void Start(Form f, StartupNextInstanceEventHandler handler)
+        {
+            if (app == null && f != null)
+                app = new SingleInstanceApp(f);
+
+            // Wire up StartupNextInstance event handler.
+            app.StartupNextInstance += handler;
+            app.Run(Environment.GetCommandLineArgs());
+        }
+    }
+}

cmds/cmds.ts

@@ -1,43 +0,0 @@
-/// <reference path="../node_modules/pxt-core/built/pxt.d.ts"/>
-
-import * as fs from "fs";
-import * as path from "path";
-import * as child_process from "child_process";
-
-let writeFileAsync: any = Promise.promisify(fs.writeFile)
-let execAsync: (cmd: string, options?: { cwd?: string }) => Promise<Buffer> = Promise.promisify(child_process.exec)
-
-export function deployCoreAsync(res: ts.pxt.CompileResult) {
-    return getBitDrivesAsync()
-        .then(drives => {
-            if (drives.length == 0) {
-                console.log("cannot find any drives to deploy to")
-            } else {
-                console.log(`copy ${ts.pxt.BINARY_HEX} to ` + drives.join(", "))
-            }
-            return Promise.map(drives, d =>
-                writeFileAsync(d + ts.pxt.BINARY_HEX, res.outfiles[ts.pxt.BINARY_HEX])
-                    .then(() => {
-                        console.log("wrote hex file to " + d)
-                    }))
-        })
-        .then(() => { })
-}
-
-function getBitDrivesAsync(): Promise<string[]> {
-    if (process.platform == "win32") {
-        return execAsync("wmic PATH Win32_LogicalDisk get DeviceID, VolumeName, FileSystem")
-            .then(buf => {
-                let res: string[] = []
-                buf.toString("utf8").split(/\n/).forEach(ln => {
-                    let m = /^([A-Z]:).* MICROBIT/.exec(ln)
-                    if (m) {
-                        res.push(m[1] + "/")
-                    }
-                })
-                return res
-            })
-    } else {
-        return Promise.resolve([])
-    }
-}

cmds/pxtrequire.ts

@@ -0,0 +1,7 @@
+/// <reference path="../node_modules/pxt-core/typings/globals/node/index.d.ts"/>
+/// <reference path="../node_modules/pxt-core/built/pxtlib.d.ts" />
+
+import * as path from "path";
+export let pxtCore = require("pxt-core");
+// require.resolve() gives path to [pxt dir]/built/pxt.js, so move up twice to get pxt root dir
+export let pxtCoreDir = path.resolve(require.resolve("pxt-core"), "..", "..");

docs/_locales/pl/_theme.json

@@ -1,22 +0,0 @@
-{
-    "name": "koduj z micro:bit",
-    "title": "koduj z micro:bit",
-    "docMenu": [
-        {
-            "name": "O nas",
-            "path": "/about"
-        },
-        {
-            "name": "Lekcje",
-            "path": "/lessons"
-        },
-        {
-            "name": "Instrukcja obsługi",
-            "path": "/reference"
-        },
-        {
-            "name": "Urządzenie",
-            "path": "/device"
-        }
-    ]
-}

docs/_locales/pl/docs.md

@@ -1,7 +0,0 @@
-# Dokumentacja
-
-Witamy na stronach dokumentacji!
-
-* Przeglądnij [instrukcje obsługi](/reference)
-* Dowiedz się więcej o [urządzeniu](/device)
-* Wystartuj z [lekcjami](/lessons)

docs/about.md

@@ -1,68 +1,5 @@
-```sim
-basic.forever(() => {
-  basic.showString("Hi!");
-})
-input.onButtonPressed(Button.A, () => {
-    led.stopAnimation();
-    basic.showLeds(`
-. . . . .
-. # . # .
-. . . . .
-# . . . #
-. # # # .`);
-});
-input.onButtonPressed(Button.B, () => {
-    led.stopAnimation();
-    basic.showLeds(`
-. # . # .
-# . # . #
-# . . . #
-. # . # .
-. . # . .`);
-});
-``` 
+![](/static/mb/device/pano.jpg)
+
 # About
 
-The [BBC micro:bit](https://www.microbit.co.uk) is a [pocket-size computer](/device) with a 5x5 display of 25 LEDs, Bluetooth and sensors that can be programmed by anyone.
-The BBC micro:bit was made possible by many [partners](https://www.microbit.co.uk/partners).
-
-The micro:bit provides an easy and fun introduction to programming and making – switch on, program it to do something fun – wear it, customize it.
-Just like Arduino, the micro:bit can be connected to and interact with sensors, displays, and other devices. 
-
-## Hardware: The Device
-
-Learn about about the [hardware components](/device) of the micro:bit to make the most of it!
-
-## Programming: Blocks or JavaScript
-
-The student can program the BBC micro:bit using [Blocks](/blocks) or [JavaScript](/typescript), via the [micro:bit APIs](/reference):
-
-```blocks
-basic.showString("Hi!");
-```
-
-## Compile and Flash: Your Program!
-
-When a user has her code ready, she can connect her BBC micro:bit to a computer via a USB cable, so it appears as a mounted drive (named MICROBIT). 
-
-Compilation to ARM thumb machine code from [Blocks](/blocks) or [JavaScript](/typescript) happens in the browser.
-
-The student is prompted to save the ARM binary program to a file, which she then simply drags to the micro:bit mounted drive, 
-which flashes the micro:bit device with the new program.
-
-## Simulator: Test Your Code
-
-Before a student compiles her code for the micro:bit, she can run it using the micro:bit simulator, all within the confines of a web browser. 
-The simulator has support for the LED screen, buttons, as well as compass, accelerometer, and digital I/O pins.
-
-## C++ Runtime
-
-The [C++ BBC micro:bit runtime](http://lancaster-university.github.io/microbit-docs/), created at [Lancaster University](http://www.lancaster.ac.uk/), provides access to the hardware functions of the micro:bit, 
-as well as a set of helper functions (such as displaying a number/image/string on the LED screen). 
-
-The [micro:bit library](/reference) mirrors the functions of the C++ library. 
-When code is compiled to ARM machine code, the calls to JavaScript micro:bit functions are replaced with calls to the corresponding C++ functions.
-
-## Open Source
-
-The editor for the BBC micro:bit is [open source](/open-source) on GitHub. Contributors are welcome!
+Read more at https://calliope.cc .

docs/beta-ref.json

@@ -0,0 +1,3 @@
+{
+    "appref": "v"
+}

docs/blocks.md

@@ -1,8 +1,14 @@
 # Blocks language
 
+### @description Langugage constructs for the Block editor.
+
 ```namespaces
 for (let i = 0;i<5;++i) {}
 if (true){}
 let x = 0;
 Math.random(5);
-```
+```
+
+## See Also
+
+[logic](/blocks/logic), [loops](/blocks/loops), [math](/blocks/math), [variables](/blocks/variables)

docs/blocks/logic/boolean.md

@@ -86,7 +86,7 @@ if (led.point(1,1) && led.point(2,2)) {
 When you compare two Numbers, you get a Boolean value, such as the comparison `x < 5` in the code below:
 
 ```blocks
-let x = math.random(5)
+let x = Math.random(5)
 if(x < 5) {
    basic.showString("low");
 } else { 

docs/blocks/math.md

@@ -1,37 +1,36 @@
 # Math
 
-[Numeric](/reference/types/number) values: 0, 1, 2, ...
+### [Numeric](/reference/types/number) values: 0, 1, 2, ...
 
-```blocks
+```block
 0;
 1;
 2;
 ```
 
-Arithmetic binary operation (+, -, *, /)
+### Arithmetic binary operation (+, -, *, /)
 
-```blocks
+```block
 0+1;
 0-1;
 1*2;
 3/4;
 ```
 
-Absolute value
+### Absolute value
 
-```blocks
+```block
 Math.abs(-5);
 ```
 
-Minimum/maximum of two values
+### Minimum/maximum of two values
 
-```blocks
+```block
 Math.min(0, 1);
-Math.max(0, 1);
 ```
 
-Random value
+### Random value
 
-```blocks
+```block
 Math.random(5);
 ```

docs/blocks/math/math.md

@@ -1,42 +0,0 @@
-# Math functions
-
-### @parent blocks/language
-
-The math library includes math related functions that you can use with [Numbers](/reference/types/number).
-
-### abs
-
-math `->` abs (x : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
-
-returns the absolute value of input parameter `x`
-
-![](/static/mb/blocks/math-0.png)
-
-### max
-
-math `->` max (x : [Number](/reference/types/number), y : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
-
-returns the larger of two input numbers (`x` and `y`)
-
-![](/static/mb/blocks/math-1.png)
-
-### min
-
-math `->` min (x : [Number](/reference/types/number), y : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
-
-returns the smaller of two input numbers (`x` and `y`)
-
-![](/static/mb/blocks/math-2.png)
-
-### random
-
-math `->` random (limit : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
-
-returns a random [Number](/reference/types/number) between 0 and the parameter *limit*
-
-![](/static/mb/blocks/math-3.png)
-
-### See also
-
-[Number](/reference/types/number)
-

docs/blocks/variables.md

@@ -1,4 +1,4 @@
-## Variables
+# Variables
 
 [Assign](/blocks/variables/assign) (set) a variable's value
 

docs/blocks/variables/var.md

@@ -46,7 +46,7 @@ basic.showNumber(counter);
 
 To change the contents of a variable use the assignment operator. The following code sets `counter` to 1 and then increments `counter` by 10:
 
-```blocks 
+```blocks
 let counter = 1;
 counter = counter + 10;
 basic.showNumber(counter);

docs/browsers.md

@@ -0,0 +1,103 @@
+# Unsupported configuration
+
+Your browser is currently not supported. The following configurations are supported:
+
+## Windows
+
+You need one of these browsers running on Windows 7, Windows 8, Windows 8.1, or
+Windows 10:
+
+* Internet Explorer 11
+* Microsoft Edge
+* Google Chrome
+* Mozilla Firefox
+
+## Mac
+
+You need one of these browsers running on OS X 10.9 Mavericks, OS X 10.10
+Yosemite, OS X 10.11 El Capitan, or macOS 10.12 Sierra:
+
+* Safari
+* Google Chrome
+* Mozilla Firefox
+
+## Linux
+
+If you're using a Raspberry Pi, please see [the documentation
+here](/raspberry-pi).
+
+You need to be running a Linux distribution recent enough to run the most recent
+version of one of the following:
+
+* Google Chrome, or Chromium
+* Mozilla Firefox, Iceweasel, or Seamonkey
+
+## How to check your OS or browser
+
+### Windows
+
+* Click on the Start menu
+* Type 'System'
+* Click on the app called 'System'
+* The version of Windows you are using will be displayed:
+
+![](/static/configurations/windows-version.png)
+
+### Mac
+
+* Click on the Apple icon in the top left
+* Click on 'About this Mac'
+* This window will be displayed:
+
+![](/static/configurations/osx-version.png)
+
+### Internet Explorer
+
+* Click on the Settings icon in the top right
+* Click 'About Internet Explorer'
+* This window will be displayed:
+
+![](/static/configurations/ie-version.png)
+
+### Edge
+
+Edge automatically updates, so you should always be using the latest version
+
+* Click on the menu icon in the top right (three dots)
+* Scroll to the bottom
+* Information similar to the following will be displayed:
+
+![](/static/configurations/edge-version.png)
+
+### Google Chrome
+
+Google Chrome automatically updates, so you should always be using the latest version
+
+* Click on the menu icon in the top right (three dots)
+* Click Help, and About Google Chrome
+* Information similar to the following will be displayed:
+
+![](/static/configurations/chrome-version.png)
+
+### Firefox
+
+Firefox automatically updates, so you should always be using the latest version
+
+* Click on the menu icon in the top right (three horizontal lines)
+* Click the question mark icon (help button)
+* Click 'About Firefox'
+
+![](/static/configurations/firefox-version.png)
+
+### Safari
+
+Safari updates when your operating system updates, so if you are using the
+latest version of OS X then you'll be using the latest version of Safari.
+
+* Click on the Safari menu in the top left
+* Click 'About Safari'
+
+![](/static/configurations/safari-version.png)
+
+IT administrators should check which browser versions are supported
+[here](/browsers/technical).

docs/browsers/linux.md

@@ -0,0 +1,16 @@
+# Recommended browser for Linux
+
+As you are using Linux, it is recommended that you use [Mozilla
+Firefox][firefox] or [Google Chrome][chrome].
+
+Please see [here][technical] for technical information on which browsers are
+supported, or [here][versions] to check which version you are using.
+
+[edge]: https://www.microsoft.com/en-us/windows/microsoft-edge
+[ie]: https://www.microsoft.com/en-us/download/internet-explorer.aspx
+[firefox]: https://www.mozilla.org/en-US/firefox/new/
+[chrome]: https://www.google.com/chrome/
+[opera]: https://www.opera.com
+[safari]: http://www.apple.com/safari/
+[technical]: /browsers/technical
+[versions]: /browsers

docs/browsers/mac.md

@@ -0,0 +1,16 @@
+# Recommended browser for Mac
+
+As you are using a Mac, it is recommended that you use [Safari][]. Alternatively,
+[Google Chrome][chrome] and [Mozilla Firefox][firefox] are also supported.
+
+Please see [here][technical] for technical information on which browsers are
+supported, or [here][versions] to check which version you are using.
+
+[edge]: https://www.microsoft.com/en-us/windows/microsoft-edge
+[ie]: https://www.microsoft.com/en-us/download/internet-explorer.aspx
+[firefox]: https://www.mozilla.org/en-US/firefox/new/
+[chrome]: https://www.google.com/chrome/
+[opera]: https://www.opera.com
+[safari]: http://www.apple.com/safari/
+[technical]: /browsers/technical
+[versions]: /browsers

docs/browsers/technical.md

@@ -0,0 +1,36 @@
+# Technical information about browser support
+
+[pxt.microbit.org][] requires that you use a recent version of a modern
+browser, such as Microsoft Edge, Google Chrome, Mozilla Firefox, Safari, Opera,
+or IE11.  This is because the editor uses modern web technologies such as [web
+workers][] to enable compiling [TypeScript][] in the browser, or the using the
+same [Monaco][] editor that powers [Visual Studio Code][].
+
+[pxt.microbit.org]: https://pxt.microbit.org
+[web workers]: http://www.w3.org/TR/workers/
+[typescript]: http://www.typescriptlang.org
+[monaco]: https://microsoft.github.io/monaco-editor/
+[visual studio code]: http://code.visualstudio.com
+
+Most modern browsers automatically update themselves, but in some environments
+such as schools these automatic updates are disabled for security. **We
+strongly recommend that you use the most recent version of any of these
+browsers**, but if you can't then you must use at least:
+
+| Browser           | Minimum version | Release date   | Windows     | Mac        |
+| ----------------- | --------------- | -------------- | ----------- | ---------- |
+| Edge              | 12              | March 2015     | Windows 10+ | N/A        |
+| Internet Explorer | 11              | October 2013   | Windows 7+  | N/A        |
+| Mozilla Firefox   | 31 ESR          | July 2014      | Windows XP+ | OS X 10.6+ |
+| Google Chrome     | 38              | October 2014   | Windows XP+ | OS X 10.6+ |
+| Safari            | 9               | September 2015 | N/A         | OS X 10.9+ |
+| Opera             | 21              | May 2014       | Windows 7+  | OS X 10.9+ |
+
+
+Please see our information for which browsers are recommended for [Windows][],
+[Mac][], [Linux][], or [Raspberry Pi][].
+
+[Windows]: /browsers/windows
+[Mac]: /browsers/mac
+[Linux]: /browsers/linux
+[Raspberry Pi]: /raspberry-pi

docs/browsers/windows.md

@@ -0,0 +1,18 @@
+# Recommended browser for Windows
+
+We recommend [Microsoft Edge][edge] if you are running Windows 10, but users on
+Windows 7 or higher can use [Internet Explorer 11][ie] or recent versions of
+[Mozilla Firefox][firefox], [Google Chrome][chrome], or [Opera][opera].
+
+
+Please see [here][technical] for technical information on which browsers are
+supported, or [here][versions] to check which version you are using.
+
+[edge]: https://www.microsoft.com/en-us/windows/microsoft-edge
+[ie]: https://www.microsoft.com/en-us/download/internet-explorer.aspx
+[firefox]: https://www.mozilla.org/en-US/firefox/new/
+[chrome]: https://www.google.com/chrome/
+[opera]: https://www.opera.com
+[safari]: http://www.apple.com/safari/
+[technical]: /browsers/technical
+[versions]: /browsers

docs/device.md

@@ -1,89 +0,0 @@
-# Device
-
-All the bits and pieces that make up your BBC micro:bit
-
-![](/static/mb/device-0.png)
-
-### LED Screen and Status LED
-
-The red lights are [LEDs](/device/screen) (light emitting diodes) and form a 5 x 5 LED Screen. 
-They can be set to on/off and the brightness can be controlled.
-
-The yellow light on the back of the micro:bit is the status LED.
-It flashes yellow when the system wants to tell the user that something has happened.
-
-### Buttons
-
-Buttons A and B are a form of input.  When you press a button, it completes an electrical circuit. 
-The micro:bit can detect either of its two buttons being pressed/released and be programmed 
-to act on these events.
-
-Button R on the back of the micro:bit is a system button. It has different uses. 
-When you have downloaded and run your code onto your micro:bit, press Button R to restart and run your program from the beginning.
-
-### USB connection
-
-When you plug in your micro:bit, it should appear as MICROBIT. 
-If you accidentally hold down the reset button as you’re plugging in your micro:bit, 
-the micro:bit will appear as a MAINTENANCE drive instead of MICROBIT. This is known as maintenance mode.**
-
-To continue programming your micro:bit YOU MUST unplug your USB and reconnect it. Check that the drive now shows as MICROBIT.
-
-**Use with caution. If you click on the drive while it shows as MAINTENANCE, 
-you can see which version of firmware you have running on your micro:bit. 
-Firmware on your micro:bit should be up-to-date already. 
-You can find the version of firmware in the 'version.txt' file on the micro:bit. Further information on the firmware can be found here:
-
-https://developer.mbed.org/platforms/Microbit/#firmware
-
-### Compass
-
-The compass can detect magnetic fields such as the Earth’s magnetic field. 
-As the micro:bit has this compass, it is possible to detect the direction it is moving in. 
-The micro:bit can detect where it is facing and movement in degrees. 
-This data can be used by the micro:bit in a program or be sent to another device.
-
-### Accelerometer
-
-There is an accelerometer on your micro:bit which detects changes in the micro:bit’s speed. 
-It converts analogue information into digital form that can be used in micro:bit programs. 
-Output is in milli-g. The device will also detect a small number of standard actions e.g. shake, tilt and free-fall.
-
-### Pins
-
-The pins can be a form of input or output. 
-There are labels for the input/output pins P0, P1, P2, which you can attach external sensors to such as thermometers or moisture detectors. 
-You can read more about large and small pins [here](/device/pins).
-
-### How do I connect the micro:bit to my computer?
-
-Your micro:bit can be connected to your computer via a micro USB cable. 
-Data can be sent and received between the micro:bit and the computer so programs 
-can be downloaded from Windows, Macs and Chromebooks onto the micro:bit via this USB data connection. 
-You can read more information on how to run scripts on your micro:bit [here](/device/usb), 
-and about the error messages you might get [here](/device/error-codes).
-
-### Powering your micro:bit
-
-When your micro:bit is connected to your computer with the micro USB, it doesn’t need another power source.  
-When your micro:bit isn’t connected to your computer, tablet or mobile, you will need 2 x AAA 1.5 V batteries to power it.
-
-The pins labelled 3V and GND are the power supply pins. 
-You can attach an external device such as a motor to these and power it using the battery or USB.
-
-### Serial Communication
-
-The BBC micro:bit can send an receive data via [serial communication](/device/serial). The serial data can be transfered via USB or BlE.
-
-### Bluetooth Low Energy (BLE) Antenna
-
-You will see the label BLE ANTENNA on the back of your micro:bit. It is for a messaging service, 
-so that devices can talk to each other. The micro:bit is a peripheral 
-device which can talk to a central device like a smart phone or tablet that has Bluetooth Low Energy (BLE). 
-The micro:bit can send signals and receive signals from a central device so another BLE device can 
-control the micro:bit or the micro:bit can control another BLE device.
-
-### Technical Information
-
-The micro:bit has been designed to be a bare-board micro controller for use by children aged 11-12. 
-More information is available at the [BBC web site](http://www.microbit.co.uk/device).

docs/device/contents.md

@@ -1,19 +0,0 @@
-# micro:bit - the device
-
-The micro:bit is a very capable device with many components:
-
-* [the USB connector](/device/usb)
-* [the LED screen](/device/screen)
-* [the buttons]
-* [the accelerometer]
-* [the compass]
-* [the pins](/device/pins)
-* [the battery plug]
-
-The micro:bit embodies many fundamental concepts in computer science. To learn more, read:
-
-* [the micro:bit - a reactive system](/device/reactive)
-
-Sometimes, your micro:bit may display an error code. For more information, see:
-
-* [the error codes](/device/error-codes)

docs/device/crocodile-clips.md

@@ -1,17 +0,0 @@
-# crocodile clips
-
-The large holes at the bottom of the board are designed to attach alligator/crocodile clips.
-Register an event that will execute whenever the user attaches one side of the crocodile clip to the `GND` pin, then connects and disconnects the unattached side of the crocodile clip to pin `0`, `1`, or `2`.
-
-### Example: on pin pressed with random numbers
-
-This example displays a random number every time the crocodile clip holds  `GND` then connects and disconnects the `P0` pin. Each time the crocodile clip is firmly connected and disconnected from pin `P0`, the micro:bit will return a random Number between 0 and the parameter limit
-
-![](/static/mb/crocodile-clips-0.png)
-
-### Connecting Crocodile Clips
-
-### See also
-
-[micro:bit pins](/device/pins), [pin is pressed](/reference/input/pin-is-pressed), [analog read pin](/reference/pins/analog-read-pin), [analog write pin](/reference/pins/analog-write-pin), [digital read pin](/reference/pins/digital-read-pin), [digital write pin](/reference/pins/digital-write-pin)
-

docs/device/error-codes.md

@@ -1,17 +0,0 @@
-# Error codes
-
-The micro:bit error codes
-
-Your micro:bit may encounter a situation that prevents it from running your code. When this happens, a frowny face will appear on your micro:bit screen (see picture) followed by an error number.
-
-Below is a list of error numbers and what they mean:
-
-* **10** (`MICROBIT_I2C_LOCKUP`): the micro:bit's I2C bus is not working
-* **20** (`MICROBIT_OOM`): there is no free memory on the micro:bit
-
-![](/static/mb/device/error-codes-0.png)
-
-### See also
-
-[Run scripts on your micro:bit](/device/usb)
-

docs/device/pins.md

@@ -1,63 +0,0 @@
-# micro:bit pins
-
-The micro:bit pins 
-
-![](/static/mb/device/pins-0.png)
-
-The micro:bit has 25 external connections on the edge connector of the board, which we refer to as ‘pins’.  The edge connector is the grey area on the right side of the figure above.
-
-There are five large pins, that are also connected to holes in the board labelled: 0, 1, 2, 3V, and GND. And along the same edge, there are 20 small pins that you can use when plugging the micro:bit into an edge connector.
-
-### Large pins
-
-You can easily attach crocodile clips or 4mm banana plugs to the five large pins.
-
-The first three, labelled 0, 1 and 2 are flexible and can be used for many different things - which means they are often called ‘general purpose input and output’ (shortened to GPIO). These three pins also have the ability to read analogue voltages using something called an analogue-to-digital converter (ADC). They all have the same function:
-
-* **0**: GPIO (general purpose digital input and output) with analogue to digital convertor (ADC).
-* **1**: GPIO with ADC
-* **2**: GPIO with ADC
-
-The other two large pins (3V and GND) are very different!/td/td
-
-### ~hint 
-
-Watch out! The pins labelled 3V and GND relate to the power supply of the board, and they should NEVER be connected together.
-
-### ~
-
-*power input*: If the micro:bit is powered by USB or a battery, then you can use the 3V pin as a *power output* to power peripherals with.
-
-* **3V**: *3 volt power output* or *power input*.  (1) *power output*: If the micro:bit is powered by USB or a battery, then you can use the 3V pin as a power output to power peripherals with; (2) *power input*: If the micro:bit is not being powered by USB or battery, you can use the 3V pin as a power input to power the micro:bit
-* **GND**: attaches to ground in order to complete a circuit (required when using the 3V pin)
-
-If you hold the ‘GND’ pin with one hand, you can program the microbit to detect yourself touching the 0,1 or 2 pins with your other hand, giving you three more buttons to experiment with (you just used your body to complete an electrical circuit).
-
-### Small pins
-
-There are 20 small pins numbered sequentially from 3-22 (these pins are not labeled on the micro:bit, however, they are labelled in the picture above).
-
-Unlike the three large pins that are dedicated to being used for external connections, some of the small pins are shared with other components on the micro:bit board. For example, pin 3 is shared with some of the LEDs on the screen of the micro:bit, so if you are using the screen to scroll messages, you can’t use this pin as well.
-
-* **pin 3**: GPIO shared with LED Col 1 of the LED screen; can be used for ADC and digital I/O when the LED screen is turned off.
-* **pin 4**: GPIO shared with LED Col 2 of the LED screen; can be used for ADC and digital I/O when the LED screen is turned off.
-* **pin 5**: GPIO shared with Button A. This lets you trigger or detect a button "A" click externally. This pin has a pull-up resistor, which means that by default it is at voltage of 3V. To replace button A on the micro:bit with an external button, connect one end of the external button to pin 4 and the other end to GND. When the button is pressed, the voltage on pin 4 is pulled down to 0, which generates a button click event.
-* **pin 6**: GPIO shared with LED Col 9 of the LED screen;  can be used for digital I/O when the LED screen is turned off.
-* **pin 7**: GPIO shared with LED Col 8 of the LED screen; can be used for digital I/O when the LED screen is turned off.
-* **pin 8**: Dedicated GPIO, for sending and sensing digital signals.
-* **pin 9**: GPIO shared with LED Col 7 of the LED screen;  can be used for digital I/O when the LED screen is turned off.
-* **pin 10**: GPIO shared with LED Col 3 of the LED screen;  can be used for ADC and digital I/O when the LED screen is turned off.
-* **pin 11**: GPIO shared with Button B. This lets you trigger or detect a button “B” click externally.
-* **pin 12**: this GPIO pin has been reserved to provide support for accessibility.
-* **pin 13**: GPIO that is conventionally used for the serial clock (SCK) signal of the 3-wire Serial Peripheral Interface (SPI) bus.
-* **pin 14**: GPIO that is conventionally used for the Master In Slave Out (MISO) signal of the SPI bus.
-* **pin 15**: GPIO that is conventionally used for the Master Out Slave In (MOSI) signal of the SPI bus.
-* **pin 16**: Dedicated GPIO (conventionally also used for SPI ‘Chip Select’ function).
-* **pins 17 and 18**: these pins are wired to the 3V supply, like the large ‘3V’ pad.
-* **pins 19 and 20**: implement the clock signal (SCL) and data line (SDA) of the I2C bus communication protocol. With I2C, several devices can be connected on the same bus and send/read messages to and from the CPU. Internally, the accelerometer and the compass are connected to i2c.
-* **pins 21 and 22**: these pins are wired to the GND pin and serve no other function
-
-### Connecting to the small pins
-
-It is recommended that an edge connector be acquired to connect to the small pins. More information on compatible edge connectors will be available later.
-

docs/device/reactive.md

@@ -1,145 +0,0 @@
-# The micro:bit - a reactive system
-
-### Computing systems
-
-What sort of a *computing system* is the micro:bit?
-
-### ~hint 
-
-There are different types of computing systems, to address different kinds of problems that arise in practice: *transaction processing systems* are used by banks to handle huge numbers of financial transactions by their customers; *distributed systems* make a set of networked computers appear as one big computer (like Google’s search engine); there are also *parallel systems*, such as graphic cards, which perform a huge number of primitive operations simultaneously, using a great number of small processing cores.
-
-### ~
-
-The micro:bit is a *reactive system* – it reacts continuously to external events, such as a person pressing the A button of the micro:bit or shaking the device. The reaction to an event may be to perform a computation, update variables, and change the display.  After the device reacts to an event, it is ready to react to the next one. If this sounds like a computer game, that’s because most computer games are reactive systems too!
-
-### Responsiveness
-
-We want reactive systems to be responsive, which means to react in a timely manner to events. For example, when you play a computer game, it’s frustrating if you press a button to make a character jump, but it doesn’t immediately jump.  A delay in reacting, or lack of responsiveness , can be the difference between life and death, both in the real and virtual worlds.
-
-Let’s consider a simple example: you want to program your micro:bit to accurately count the number of times the A button has been pressed and continuously display the current count on the 5x5 [LED screen](/device/screen).   Because the LED screen is small, we can only display one digit of a number at a time on it. The [show number](/reference/basic/show-number) function will scroll the digits of a number across the screen so you can read it.
-
-Let’s say that the current count is 42 and the number 42 is scrolling across the LED screen. This means there is some code executing to perform the scroll.  So, what should happen if you press the A button during the scroll?  It would be a bad idea to ignore the button press, so some code should record the occurrence of the button press. But we just said there already is code running in order to scroll the number 42!  If we wait until the code scrolling the 42 has finished to look for a button press, we will miss the button press.  We want to avoid this sort of unresponsiveness.
-
-### Concurrency
-
-To be responsive, a reactive system needs to be able to do several things at the same time (concurrently), just like you can.  But the micro:bit only has one CPU for executing your program, which means it can only execute one program instruction at a time. On the other hand, it can execute millions of instructions in a single second.  This points the way to a solution.
-
-Think about how a motion picture projector works - it projects only 24 frames per second, yet this is good enough to provide the illusion of fluid motion on the screen. The micro:bit can execute millions of instructions per second, so it seems quite possible for the device to both to smoothly scroll the number 42 across the LED screen while looking for button presses and counting them.
-
-Let’s think about three sequences of instructions:
-
-* Sequence S1 contains the instructions (let’s say several hundred thousand or so) that scroll the number 42 across the LED screen;
-* Sequence S2 contains a few instructions to check if button A is pressed;
-* Sequence S3 contains a few instructions to increment a counter.
-
-In order to be responsive, we would like to *interrupt* the execution of sequence S1 *periodically* to execute the sequence S2, which will check if button A is pressed, which looks like:
-
-TODO Diagram
-
-The result is that it takes sequence S1 a little longer to complete, due to the interruptions to execute sequence S2, but we are checking often enough to detect a press of button A .  When S2 detects a press of button A, then the sequence S3 can be executed before S1 resumes:
-
-TODO Diagram
-
-As we’ll soon see, there are other choices for how the sequences can be ordered to achieve the desired result.
-
-### The micro:bit scheduler and queuing up subprograms
-
-The micro:bit’s *scheduler* provides the capability to concurrently execute different code sequences, relieving us of a lot of low-level programming.   In fact, scheduling is so useful that it is a part of every *operating system*!
-
-The first job of the scheduler is to allow multiple *subprograms* to be queued up for later execution . For our purposes, a subprogram is just a statement or sequence of statements in the context of a larger program. Consider the Touch Develop program below for counting button presses.
-
-```
-export function countButtonPresses() {
-    input.onButtonPressed(Button.A, () => {
-        count = count + 1
-    })
-    basic.forever(() => {
-        basic.showNumber(count, 150)
-    })
-    count = 0
-}
-```
-
-The program above contains three statements that execute in order from top to bottom. The first statement
-
-```
-input.onButtonPressed(Button.A, () => {
-    count = count + 1
-})
-```
-
-informs the scheduler that on each and every event of the A button being pressed, a subprogram (called the event handler) should be queued for execution. The event handler is demarcated by the do/end keywords; it increments the global variable `count` by one.  The second statement
-
-```
-basic.forever(() => {
-    basic.showNumber(count, 150)
-})
-```
-
-queues a `forever` loop for later execution by the scheduler; the body of this loop (between the do/end keywords) displays the current value of global variable `count` on the LED screen. The third statement
-
-```
-count = 0
-```
-
-initializes the global variable `count` to zero.  The function ends after the execution of these three statements, but this is not the end of program execution!  That’s because the function queued the `forever` loop for execution by the scheduler.
-
-The second job of the scheduler is to periodically interrupt execution to read (poll) the various inputs to the micro:bit (the buttons, pins, etc.) and fire off events (such as “button A pressed”). Recall that the firing of an event causes the event handler subprogram associated with that event to be queued for later execution. The scheduler uses a timer built into the micro:bit hardware to interrupt execution every 6 milliseconds and poll the inputs, which is more than fast enough to catch the quickest press of a button.
-
-### Cooperative passing of control
-
-How does the forever loop get to start execution? Furthermore, once the forever loop is running, how does any other subprogram (like the event handler that increments the count) ever get a chance to execute?
-
-The answer is “cooperation” and “passing”.  Think of a football team doing a drill – there is one ball and each footballer gets to dribble the ball for a certain number of touches, after which they pass to another footballer. A footballer who never passes prevents all other footballers from dribbling.  A cooperative footballer always passes to some other footballer after taking a few touches.
-
-If you hadn’t guessed already, a footballer represents subprogram and dribbling the ball corresponds to that subprogram executing. Only one subprogram gets to execute at a time, as there is only one ball (processor). Footballer Alice passing the ball to footballer Bob corresponds to stopping execution of Alice’s subprogram (and remembering where it stopped) and starting/resuming execution of Bob’s subprogram.
-
-We will call this “passing control of execution” rather than “passing the ball”.  However, in the world of the micro:bit, the concurrently executing subprograms are not aware of each other, so they don’t actually pass control directly to one another.  Rather they pass control of execution back to the scheduler and the scheduler determines the subprogram to pass control to next.  The programmer inserts a call to the `pause` function to indicate a point in the subprogram where control of execution passes to the scheduler. Also, when a subprogram ends execution, control passes to the scheduler.
-
-Let’s take a look at the implementation of the `forever` statement to see an example of cooperative scheduling:
-
-![](/static/mb/device/reactive-2.png)
-
-The `forever` loop actually is a function that takes a subprogram (an *Action* in Touch Develop) as a parameter. The function uses the `control -> in background` function of the micro:bit runtime to queue a `while true` loop for execution by the scheduler. The while loop has two statements. The first statement runs the subprogram represented by the `body` parameter. The second statement passes control to the scheduler (requesting to “sleep” for 20 milliseconds).
-
-Though the `while true` loop will repeatedly execute the body subprogram, between each execution of the body it will permit the scheduler to execute other subprograms.  If the while loop did not contain the call to `pause`, then once control passed into the while loop, it would never pass back to the scheduler and no other subprogram would be able to execute (unless the body subprogram contained a call to `pause` itself).
-
-### Round-robin scheduling
-
-Now, we come to the third and final job of the scheduler, which is to determine which subprogram to pass control to next. The scheduler uses two queues to perform this task, the sleep queue and the run queue. The sleep queue contains the subprograms that have called the pause function and still have time left to sleep. The run queue contains all the non-sleeping subprograms, such as the event handlers queued by the firing of an event.
-
-The scheduler  moves the subprogram that has just paused into the sleep queue and then removes the subprogram at the head of the run queue and resumes its execution. Once a subprogram’s sleep period is over, the scheduler moves it from the sleep queue to the back  of the run queue.
-
-The property of such round-robin scheduling is that under the assumption that every subprogram periodically enters the sleep queue, then every subprogram will periodically get a chance to execute.
-
-### Putting it all together
-
-Let’s go back to the `count button presses` function and revisit its execution based on what we have learned about the micro:bit scheduler. As detailed before, the function executes three steps to: (1) set up the event handler for each press of button A; (2) queue the forever loop to the run queue; (3) initialize the global variable `count` to zero.
-
-The function then ends execution and control passes back to the scheduler.  Let’s assume the user has not pressed any buttons . The scheduler finds the `forever` loop in the run queue and passes control to it.  The loop first calls `basic -> show number(0,150)`.  In the diagram below, we use “Show 0” to refer to the execution of this function:
-
-![](/static/mb/device/reactive-3.png)
-
-While "Show 0" (the blue sequence) is running, periodic interrupts by the scheduler (every 6 milliseconds) poll for button presses and queue an event handler for each press of button A.  Let’s say that one button press takes place during this time, as shown above. This will cause an event handler (labelled “inc”) to be queued for later execution by the scheduler. Once the "Show 0" has completed, the loop then calls `basic -> pause(20)` to put the forever loop to sleep for 20 milliseconds and give the scheduler an opportunity to run any newly queued event handler. Control passes to the “inc” event handler which will increment the global variable `count` from 0 to 1 and then complete, returning control to the scheduler.  At some point, the `forever` loop moves from the sleep queue to the run queue; the `forever` loop then will resume and call `basic -> show number(1,150)`.
-
-### Final thoughts
-
-Through this example, we have seen that the micro:bit scheduler enables you to create a program that is composed of concurrent subprograms. In essence, the programmer needs to only think about the concurrent subprograms cooperatively passing control back to the scheduler, making sure no subprogram hogs control (or “dribbles the ball without passing”) for too long. While a subprogram runs, the scheduler polls the buttons and other IO peripherals at a high frequency in order to fire off events and queue event handlers for later execution, but this is invisible to the programmer.
-
-As a result, you can easily add a new capability to the micro:bit by just adding a new subprogram. For example, if you want to add a reset feature to the counter program, all you need to do is add a new event handler for a press of button B that sets the global variable "count" to zero, as shown below:
-
-```
-export function countButtonPressesWithReset() {
-    input.onButtonPressed(Button.A, () => {
-        count = count + 1
-    })
-    basic.forever(() => {
-        basic.showNumber(count, 150)
-    })
-    count = 0
-    input.onButtonPressed(Button.B, () => {
-        count = 0
-    })
-}
-```
-

docs/device/screen.md

@@ -1,93 +0,0 @@
-# LED screen
-
-The micro:bit LED screen 
-
-```sim
-    basic.showLeds(`
-        # . # . #
-        . # . # .
-        # . # . #
-        . # . # .
-        # . # . #
-        `);
-```
-
-The micro:bit LED screen consists of 25 red LED lights arranged in a 5X5 grid (5 LEDs across by 5 LEDs down).
-In the screen above, we created a checkerboard pattern using the LEDs.
-
-### Which LED?
-
-You use `(x ,y)` coordinates to specify a particular LED in the grid; 
-where `x` is the horizontal position (0,1,2,3,4) and `y` is the vertical position 
-(0, 1, 2, 3, 4). 
-
-To figure out the ``x``, ``y`` coordinates, position your micro:bit horizontally, like a credit card (see picture above).
-
-Here are the x, y coordinates for the LEDs in the 5X5 grid:
-
-`(0,0)` `(1,0)` `(2,0)` `(3,0)` `(4,0)`
-
-`(0,1)` `(1,1)` `(2,1)` `(3,1)` `(4,1)`
-
-`(0,2)` `(1,2)` `(2,2)` `(3,2)` `(4,2)`
-
-`(0,3)` `(1,3)` `(2,3)` `(3,3)` `(4,3)`
-
-`(0,4)` `(1,4)` `(2,4)` `(3,4)` `(4,4)`
-
-The x, y coordinates for the LED in the centre of the grid are `(2,2)`. Starting from `(0,0)` count over 2 columns and then down 2 rows.
-
-### Check your understanding
-
-Which LEDs are turned on in the checkboard pattern above? 
-
-### Row, column - 1
-
-Since the row and column numbers start at 0, an easy way to figure out the (x,y) coordinates 
-is to subtract 1 from the row and column number (when counting from 1). 
-In other words, to specify the LED in the 4th column 5th row, subtract 1 from each number to get coordinates `(3,4)`.
-
-### Turn a LED on/off
-
-Use [plot](/reference/led/plot) and [unplot](/reference/led/unplot) to turn a LED on or off
-
-```blocks
-led.plot(0,0);
-led.plot(1,1);
-basic.pause(1000);
-led.unplot(0,0);
-basic.pause(1000);
-led.unplot(1,1);
-```
-
-### Is a LED on/off?
-
-Use the [point](/reference/led/point) function to find out if a LED is on or off.
-
-```blocks
-if(led.point(0,0)) {
-}
-```
-
-### Display images, strings and numbers
-
-Instead of turning individual LEDs on or off, as above, you can display an [image](/reference/images/image) directly to the screen or show text/numbers on screen using the [show number](/reference/basic/show-number)/[show string](/reference/basic/show-string) function.
-
-### The display buffer
-
-The micro:bit runtime keeps an in-memory representation of the state of all 25 LEDS. This state is known as the "display buffer" and controls which LEDS are on and which are off. The plot/unplot/point functions access the display buffer directly. On the other hand, the functions that show an image, number or string overwrite the buffer completely. To illustrate, first try running this code sequence
-
-```blocks
-basic.showString("d")
-led.plot(0, 0)
-```
-
-You will see the letter "d" displayed as well as the LED in position `0,0` lit up. Now try reversing the order of the two statements above:
-
-```blocks
-led.plot(0, 0)
-basic.showString("d", 150)
-```
-
-You will not see the LED at position `0,0` lit up because the `show string` function overwrites the whole display buffer.
-

docs/device/serial.md

@@ -1,83 +0,0 @@
-# Serial
-
-The [serial](/reference/serial) supports [serial communication](https://en.wikipedia.org/wiki/Serial_port) between the BBC micro:bit and another computer. Basically, this allows you to send data from the micro:bit to your own computer. This is very useful for debugging purposes: you can add `write line` statements in your code and see them display on your computer as the program executes.
-
-The code below shows a simple script that sends a line when the BBC micro:bit starts and another line each time the button ``A`` is pressed.
-
-```blocks
-serial.writeLine("started...")
-input.onButtonPressed(Button.A, () => {
-    serial.writeLine("A pressed")
-})
-```
-
-Data is also automatically streamed to serial by the ** bar graph** block
-and picked up by the editor. This data can be streamed to the cloud as well.
-
-```blocks
-basic.forever(() => {
-   led.plotBarGraph(input.acceleration(Dimension.X), 0);
-});
-```
-
-## How to read the micro:bit's serial output from your computer
-
-Unfortunately, using the serial library requires quite a bit of a setup.
-
-### BBC micro:bit Chrome Extension
-
-If you are using the Google Chrome browser, you can use our extension to get serial data streaming in the editor.
-
-* Install the [Extension for BBC micro:bit](https://chrome.google.com/webstore/detail/extension-for-bbc-microbi/cihhkhnngbjlhahcfmhekmbnnjcjdbge?hl=en-US) on the Chrome Web Store.
-* Restart Chrome and open the web editor.
-
-### Windows
-
-You must install a device driver (for the computer to recognize the serial interface of the micro:bit); then, you must also install a terminal emulator (which is going to connect to the micro:bit and read its output). Here's how to do it:
-
-* Follow instructions at https://developer.mbed.org/handbook/Windows-serial-configuration in order to install the device driver
-
-#### Windows > Tera Term
-
-* Install the terminal emulator [Tera Term](https://ttssh2.osdn.jp/index.html.en). At the time of this writing, the latest version is 4.88 and can be downloaded [from here](http://en.osdn.jp/frs/redir.php?m=jaist&f=%2Fttssh2%2F63767%2Fteraterm-4.88.exe). Follow the instructions from the installer.
-
-Once both the driver and the terminal emulator are installed, plug in the micro:bit and wait until the device is fully setup. Then, open TeraTerm.
-
-* Hit `File` > `New Connection`
-* Check "Serial"; in the dropdown menu, pick the COM port that says "mbed Serial Port". Hit `Ok`.
-* In the menus, hit `Setup` > `Serial Port` and set the baud rate to `115200`.
-
-You should be good. Feel free to hit `Setup` > `Save Setup` in the menus to erase the default configuration file with a new one so that you don't have to type in the settings again.
-
-Please note that Windows will assign you a different COM port if you plug in another micro:bit. If you're juggling between micro:bits, you'll have to change the COM port every time.
-
-#### Windows > Putty
-
-If you prefer another terminal emulator (such as [PuTTY](http://www.putty.org/)), here are some instructions.
-
-* Open Windows's [Device Manager](https://windows.microsoft.com/en-us/windows/open-device-manager); expand the section called "Ports (COM & LPT)"; write down the com number for "mbed Serial Port" (e.g. COM14)
-* Open PuTTY; on the main screen, use the following settings: Serial / COM14 / 115200. Replace COM14 with the COM port number you wrote down previously. Feel free to type in a name and hit "Save" to remember this configuration.
-
-![](/static/mb/serial-library-0.png)
-
-* (optional): in the "Terminal" section, check "implicit cr in every lf"
-
-![](/static/mb/serial-library-1.png)
-
-### Linux
-
-(Untested).
-
-* Plug in the micro:bit
-* Open a terminal
-* `dmesg | tail` will show you which `/dev/` node the micro:bit was assigned (e.g. `/dev/ttyUSB0`)
-* Then, do: `screen /dev/ttyUSB0 115200` (install the `screen` program if you don't have it). To exit, run `Ctrl-A` `Ctrl-D`.
-
-Alternative programs include minicom, etc.
-
-### Mac OS
-
-* Plug in the micro:bit
-* Open a terminal
-* `ls /dev/cu.*` will return to you a list of serial devices; one of them will look like `/dev/cu.usbmodem1422` (the exact number depends on your computer)
-* `screen /dev/cu.usbmodem1422 115200` will open up the micro:bit's serial output. To exit, hit `Ctrl-A` `Ctrl-D`.