diff --git a/cli/buildengine.ts b/cli/buildengine.ts
index 7fa1ac0cc68a..c3b4182ad7a7 100644
--- a/cli/buildengine.ts
+++ b/cli/buildengine.ts
@@ -316,7 +316,7 @@ function msdDeployCoreAsync(res: ts.pxtc.CompileResult) {
     if (pxt.appTarget.serial && pxt.appTarget.serial.useHF2) {
         let f = res.outfiles[pxtc.BINARY_UF2]
         let blocks = pxtc.UF2.parseFile(U.stringToUint8Array(atob(f)))
-        return hid.hf2DeviceAsync()
+        return hid.initAsync()
             .then(dev => dev.flashAsync(blocks))
     }
 
diff --git a/cli/cli.ts b/cli/cli.ts
index 638be8ec55f9..feab69093155 100644
--- a/cli/cli.ts
+++ b/cli/cli.ts
@@ -23,6 +23,7 @@ import * as commandParser from './commandparser';
 import * as hid from './hid';
 import * as serial from './serial';
 import * as gdb from './gdb';
+import * as clidbg from './clidbg';
 import * as pyconv from './pyconv';
 
 const rimraf: (f: string, opts: any, cb: () => void) => void = require('rimraf');
@@ -1622,7 +1623,7 @@ function buildTargetCoreAsync() {
             .then(res => {
                 cfg.bundledpkgs[path.basename(dirname)] = res
             })
-            .then(testForBuildTargetAsync)
+            .then(() => testForBuildTargetAsync(isPrj))
             .then((compileOpts) => {
                 // For the projects, we need to save the base HEX file to the offline HEX cache
                 if (isPrj && pxt.appTarget.compile.hasHex) {
@@ -2604,7 +2605,7 @@ function testAssemblers(): Promise<void> {
 }
 
 
-function testForBuildTargetAsync(): Promise<pxtc.CompileOptions> {
+function testForBuildTargetAsync(useNative: boolean): Promise<pxtc.CompileOptions> {
     let opts: pxtc.CompileOptions
     return mainPkg.loadAsync()
         .then(() => {
@@ -2612,18 +2613,27 @@ function testForBuildTargetAsync(): Promise<pxtc.CompileOptions> {
             let target = mainPkg.getTargetOptions()
             if (target.hasHex)
                 target.isNative = true
+            if (!useNative)
+                target.isNative = false
             return mainPkg.getCompileOptionsAsync(target)
         })
         .then(o => {
             opts = o
             opts.testMode = true
             opts.ast = true
-            return pxtc.compile(opts)
+            if (useNative)
+                return pxtc.compile(opts)
+            else {
+                pxt.log("  skip native build of non-project")
+                return null
+            }
         })
         .then(res => {
-            reportDiagnostics(res.diagnostics);
-            if (!res.success) U.userError("Compiler test failed")
-            simulatorCoverage(res, opts)
+            if (res) {
+                reportDiagnostics(res.diagnostics);
+                if (!res.success) U.userError("Compiler test failed")
+                simulatorCoverage(res, opts)
+            }
         })
         .then(() => opts);
 }
@@ -3317,9 +3327,19 @@ function prepBuildOptionsAsync(mode: BuildOption, quick = false) {
         })
 }
 
+function dbgTestAsync() {
+    return buildCoreAsync({
+        mode: BuildOption.JustBuild,
+        debug: true
+    })
+        .then(clidbg.startAsync)
+}
+
 interface BuildCoreOptions {
     mode: BuildOption;
 
+    debug?: boolean;
+
     // docs
     locs?: boolean;
     docs?: boolean;
@@ -3327,16 +3347,22 @@ interface BuildCoreOptions {
     createOnly?: boolean;
 }
 
-function buildCoreAsync(buildOpts: BuildCoreOptions): Promise<pxtc.CompileOptions> {
+function buildCoreAsync(buildOpts: BuildCoreOptions): Promise<pxtc.CompileResult> {
     let compileOptions: pxtc.CompileOptions;
+    let compileResult: pxtc.CompileResult;
     ensurePkgDir();
     return prepBuildOptionsAsync(buildOpts.mode)
         .then((opts) => {
             compileOptions = opts;
             opts.breakpoints = buildOpts.mode === BuildOption.DebugSim;
+            if (buildOpts.debug) {
+                opts.breakpoints = true
+                opts.justMyCode = true
+            }
             return pxtc.compile(opts);
         })
         .then((res): Promise<void | pxtc.CompileOptions> => {
+            compileResult = res
             U.iterMap(res.outfiles, (fn, c) => {
                 if (fn !== pxtc.BINARY_JS) {
                     mainPkg.host().writeFile(mainPkg, "built/" + fn, c);
@@ -3403,7 +3429,7 @@ function buildCoreAsync(buildOpts: BuildCoreOptions): Promise<pxtc.CompileOption
             }
         })
         .then(() => {
-            return compileOptions;
+            return compileResult;
         });
 }
 
@@ -4343,6 +4369,7 @@ function initCommands() {
     advancedCommand("testdir", "compile files in directory one by one", testDirAsync, "<dir>");
     advancedCommand("testconv", "test TD->TS converter", testConverterAsync, "<jsonurl>");
     advancedCommand("testpkgconflicts", "tests package conflict detection logic", testPkgConflictsAsync);
+    advancedCommand("testdbg", "tests hardware debugger", dbgTestAsync);
 
     advancedCommand("buildtarget", "build pxtarget.json", buildTargetAsync);
     advancedCommand("uploadtrg", "upload target release", pc => uploadTargetAsync(pc.arguments[0]), "<label>");
diff --git a/cli/clidbg.ts b/cli/clidbg.ts
new file mode 100644
index 000000000000..b8cb72923872
--- /dev/null
+++ b/cli/clidbg.ts
@@ -0,0 +1,39 @@
+import * as hid from './hid';
+import * as fs from "fs";
+
+import Cloud = pxt.Cloud;
+import U = pxt.Util;
+import D = pxt.HWDBG;
+
+
+export function startAsync(compileRes: pxtc.CompileResult) {
+    return hid.initAsync()
+        .then(d => {
+            hid.connectSerial(d)
+
+            D.postMessage = msg => {
+                if (msg.subtype != "breakpoint") {
+                    console.log(msg)
+                    return
+                }
+                let bmsg = msg as pxsim.DebuggerBreakpointMessage
+
+                console.log("GLOBALS", bmsg.globals)
+                for (let s of bmsg.stackframes)
+                    console.log(s.funcInfo.functionName, s.locals)
+
+                let brkMatch = compileRes.breakpoints.filter(b => b.id == bmsg.breakpointId)[0]
+                if (!brkMatch) {
+                    console.log("Invalid breakpoint ID", msg)
+                    return
+                }
+                let lines = fs.readFileSync(brkMatch.fileName, "utf8").split(/\n/)
+
+                console.log(">>>", lines.slice(brkMatch.line, brkMatch.endLine + 1).join(" ;; "))
+                Promise.delay(500)
+                    .then(() => D.resumeAsync(false))
+            }
+
+            return D.startDebugAsync(compileRes, d)
+        })
+}
\ No newline at end of file
diff --git a/cli/hid.ts b/cli/hid.ts
index c7963f08f2b7..1a073354167a 100644
--- a/cli/hid.ts
+++ b/cli/hid.ts
@@ -32,14 +32,14 @@ export function listAsync() {
 }
 
 export function serialAsync() {
-    return hf2DeviceAsync()
+    return initAsync()
         .then(d => {
             connectSerial(d)
         })
 }
 
 export function dmesgAsync() {
-    return hf2DeviceAsync()
+    return initAsync()
         .then(d => d.talkAsync(pxt.HF2.HF2_CMD_DMESG)
             .then(resp => {
                 console.log(U.fromUTF8(U.uint8ArrayToString(resp)))
@@ -69,12 +69,8 @@ export function hf2ConnectAsync(path: string) {
 }
 
 let hf2Dev: Promise<HF2.Wrapper>
-export function hf2DeviceAsync(path: string = null): Promise<HF2.Wrapper> {
+export function initAsync(path: string = null): Promise<HF2.Wrapper> {
     if (!hf2Dev) {
-        let devs = getHF2Devices()
-        if (devs.length == 0)
-            return Promise.reject(new HIDError("no devices found"))
-        path = devs[0].path
         hf2Dev = hf2ConnectAsync(path)
     }
     return hf2Dev
@@ -100,17 +96,29 @@ export class HIDError extends Error {
 
 export class HidIO implements HF2.PacketIO {
     dev: any;
+    private path: string;
 
     onData = (v: Uint8Array) => { };
+    onEvent = (v: Uint8Array) => { };
     onError = (e: Error) => { };
 
-    constructor(private path: string) {
+    constructor(private requestedPath: string) {
         this.connect()
     }
 
     private connect() {
         const hid = getHID();
         U.assert(hid)
+
+        if (this.requestedPath == null) {
+            let devs = getHF2Devices()
+            if (devs.length == 0)
+                throw new HIDError("no devices found")
+            this.path = devs[0].path
+        } else {
+            this.path = this.requestedPath
+        }
+
         this.dev = new HID.HID(this.path)
         this.dev.on("data", (v: Buffer) => {
             //console.log("got", v.toString("hex"))
diff --git a/cli/server.ts b/cli/server.ts
index 623c0c57865a..dd48d88139dc 100644
--- a/cli/server.ts
+++ b/cli/server.ts
@@ -428,6 +428,16 @@ function initSocketServer(wsPort: number, hostname: string) {
                             case "init":
                                 return hio.reconnectAsync()
                                     .then(() => {
+                                        hio.io.onEvent = v => {
+                                            if (!ws) return
+                                            ws.send(JSON.stringify({
+                                                op: "event",
+                                                result: {
+                                                    path: msg.arg.path,
+                                                    data: U.toHex(v),
+                                                }
+                                            }))
+                                        }
                                         hio.onSerial = (v, isErr) => {
                                             if (!ws) return
                                             ws.send(JSON.stringify({
diff --git a/docs/debugger.md b/docs/debugger.md
new file mode 100644
index 000000000000..b7407e476ac8
--- /dev/null
+++ b/docs/debugger.md
@@ -0,0 +1,104 @@
+# On-device Software Debugger
+
+PXT supports debugging the generated TypeScript code. This is done via
+a USB HID interface implemented in software and doesn't require an interface 
+(debugging) chip. The USB HID interface uses 
+[HF2 protocol](https://github.com/Microsoft/uf2/blob/master/hf2.md).
+Messages from the host (computer connected to the device being debugged)
+are handled in the USB interrupt of the device.
+
+Debugging needs to be enabled during compilation. The switch will cause breakpoint
+code to be inserted before every statement. It's possible to enable debug for all
+TypeScript code, or only user code (i.e, excluding everything under `pxt_modules/**`).
+
+## Debugger features (TODO)
+
+* [x] inspecting globals (including `uint16` and friends)
+* [x] inspecting tagged values, doubles, strings, buffers
+* [x] `debugger` statement support
+* [x] step-into support
+* [x] step-over support
+* [x] continue support
+* [x] inspecting locals in current function, and up the call stack
+
+* [ ] stack-walking with first-class functions
+* [ ] inspecting contents of records
+* [ ] inspecting contents of arrays
+* [ ] inspecting contents of maps
+* [ ] inspecting contents of reference-locals (captured ones)
+* [ ] inspecting active threads
+* [ ] user-defined breakpoints (other than `debugger` statement)
+* [ ] handling of non-intentional faults (right now we get infinite loop; not sure how useful this is without GDB)
+
+## Debugger implementation
+
+The debug mode is controlled by the first global variable. In C++ code it's
+referred to as `globals[0]`, while in assembly it's `[r6, #0]` (`r6` holds `globals`
+while TypeScript code is executing).
+
+The C++ side of the code sits in `hf2.cpp` file in `core` library (in `pxt-common-packages`).
+Current link: https://github.com/Microsoft/pxt-common-packages/blob/dbg/libs/core/hf2.cpp#L182
+
+There are currently 4 possible values of `globals[0]`
+* a valid heap address, somewhere in the middle - normal execution
+* `0` - debugger connected, no single stepping mode
+* `1` - debugger connected, step-into mode
+* `3` - debugger connected, step-over mode (replaced with `0` on first hit)
+
+The host will start by resetting the device into debug mode with a specific HF2
+message. This causes `globals[0]` to be set to `1`.
+After that, the device will send a message to the host saying it's halted.
+Then the host will eventually set `globals[0]` to `0`, `1` or `3` and
+resume execution via another HF2 message.
+
+TS `debugger` statement is translated into a word fetch from `globals[0] - 4`.
+In any mode other than the normal execution, it will cause a fault - either alignment fault
+or accessing memory at `0xfffffffc`.
+
+```
+    ldr r0, [r6, #0]
+    subs r0, r0, #4
+    ldr r0, [r0, #0]
+```
+
+Additionally, in front of all other statements, provided debugging is enabled,
+we try to load memory location pointed to by `globals[0]`. If `globals[0]`
+is `1` or `3` (but not `0` or valid heap address), this will cause alignment fault.
+
+```
+    ldr r0, [r6, #0]
+    ldr r0, [r0, #0]
+```
+
+All hard faults are caught by a single handler. It then looks at
+the instruction causing fault and if it is `ldr r0, [r0, #0]`,
+it will return to a function which pauses all other user
+fibers and executes `fiber_sleep()` in a loop.
+It also sends a HF2 message to the host stating that the device
+if halted. At some point, a HF2 message from the host clears
+a flag causing the loop to stop and the device to resume execution after the 
+`ldr r0, [r0, #0]` instruction (after unpausing all other user fibers).
+
+This is enough to support step-into and continue modes of operation.
+To support step-over, a instructions sequence similar to the one above 
+is used at the entry of every procedure, before even the `push {lr}`:
+
+```
+    ldr r0, [r6, #0]
+    ldr r0, [r0, #4]
+```
+
+If the fault handler detects the fault instruction to be `ldr r0, [r0, #4]`
+and `globals[0]` is `3` it sets `globals[0]` to `0` and modifies the
+contents of `lr` register by setting its highest bit. In all cases, when it's done,
+it just resumes execution after the `ldr r0, [r0, #4]` instruction
+(without entering the pause loop).
+
+Thus, in step-over mode, entry to any user procedure will set `globals[0]` to
+`0` preventing further instruction breakpoints from firing. When this particular
+function tries to return, we get another fault, where the `pc` is set to
+an address with highest bit set. This is detected, the `globals[0]` is set 
+back to `3`, the `pc` is corrected and execution continues.
+
+
+
diff --git a/docs/language.md b/docs/language.md
index 80cbde0a69f8..de5f129fde58 100644
--- a/docs/language.md
+++ b/docs/language.md
@@ -106,7 +106,7 @@ There are two compilation strategies available - the legacy strategy used by the
 micro:bit target, and a tagged strategy used by the upcoming SAMD21 targets, as well as all
 the other targets going forward (possibly including new version of the micro:bit target).
 
-In the legacy strategy, there are some semantic differences with JavaScript,
+In the **legacy strategy**, there are some semantic differences with JavaScript,
 particularly:
 * numbers are 32 bit signed integers with wrap-around semantics; 
   in JavaScript they are 64 bit floating points
@@ -157,8 +157,8 @@ strategy.
 Compared to a typical dynamic JavaScript engine, PXT compiles code statically,
 giving rise to significant time and space performance improvements:
 * user programs are compiled directly to machine code, and are
-  never in any byte-code form that needs to be interpreted; this results in execution
-  10-20x faster than a typical JS interpreter
+  never in any byte-code form that needs to be interpreted; this results in
+  much faster execution than a typical JS interpreter
 * there is no RAM overhead for user-code - all code sits in flash; in a dynamic VM
   there are usually some data-structures representing code
 * due to lack of boxing for small integers and static class layout the memory consumption for objects
@@ -200,6 +200,13 @@ The supported types are:
 If you attempt to store a number exceeding the range of the small int type, only
 the lowest 8 or 16 bits will be stored. There is no clamping nor overflow exceptions.
 
+If you just use `number` type (or specify no type at all) in tagged strategy,
+then if the number fits in signed 31 bits, 4 bytes of memory will be used.
+Otherwise, the 4 bytes will point to a heap-allocated double (all together,
+with memory allocator overhead, around 20 bytes).
+
+In legacy strategy, `number` is equivalent to `int32`, and there is no `uint32`.
+
 ### Limitations
 
 * arrays of int types are currently not supported; you can use a `Buffer` instead
diff --git a/libs/pxt-common/pxt-core.d.ts b/libs/pxt-common/pxt-core.d.ts
index a52eeaa64497..f7343c031134 100644
--- a/libs/pxt-common/pxt-core.d.ts
+++ b/libs/pxt-common/pxt-core.d.ts
@@ -215,7 +215,7 @@ interface RegExp { }
 
 type uint8 = number;
 type uint16 = number;
-//type uint32 = number;
+type uint32 = number;
 type int8 = number;
 type int16 = number;
 type int32 = number;
diff --git a/localtypings/pxtparts.d.ts b/localtypings/pxtparts.d.ts
index 4040b349f62d..d22876516cce 100644
--- a/localtypings/pxtparts.d.ts
+++ b/localtypings/pxtparts.d.ts
@@ -118,4 +118,60 @@ declare namespace pxsim {
         part?: boolean, // if true, the part itself should be assembled during this step
         pinIndices?: number[], // the indices (ranging from 0 to "numberOfPins") of pins that should be wired for this step 
     }
+
+    export interface SimulatorMessage {
+        type: string;
+    }
+
+    // type=debugger
+    export interface DebuggerMessage extends SimulatorMessage {
+        subtype: string;
+    }
+
+    // subtype=config
+    export interface DebuggerConfigMessage extends DebuggerMessage {
+        setBreakpoints?: number[];
+    }
+
+    // subtype=resume
+    // subtype=stepover
+    // subtype=stepinto
+
+    //
+    // Responses from simulator
+    //
+
+    // subtype=breakpoint
+    export interface DebuggerBreakpointMessage extends DebuggerMessage {
+        breakpointId: number;
+        globals: Variables;
+        stackframes: {
+            locals: Variables;
+            funcInfo: any; // pxtc.FunctionLocationInfo
+            breakpointId: number;
+        }[];
+        exceptionMessage?: string;
+        exceptionStack?: string;
+    }
+
+    // subtype=trace
+    export interface TraceMessage extends DebuggerMessage {
+        breakpointId: number;
+    }
+
+    // subtype=traceConfig
+    export interface TraceConfigMessage extends DebuggerMessage {
+        interval: number;
+    }
+
+    export interface DebuggerWarningMessage extends DebuggerMessage {
+        message: string;
+        breakpointIds: number[];
+    }
+
+    export interface Variables {
+        [name: string]: any;
+    }
+
+
 }
\ No newline at end of file
diff --git a/pxtcompiler/emitter/backbase.ts b/pxtcompiler/emitter/backbase.ts
index e8613e54ceda..ae70bb759eb8 100644
--- a/pxtcompiler/emitter/backbase.ts
+++ b/pxtcompiler/emitter/backbase.ts
@@ -39,9 +39,9 @@ namespace ts.pxtc {
         pop_fixed(reg: string[]) { return "TBD" }
         pop_locals(n: number) { return "TBD" }
         proc_return() { return "TBD" }
-        debugger_hook(lbl: string) { return "TBD" }
+        debugger_stmt(lbl: string) { return "TBD" }
         debugger_bkpt(lbl: string) { return "TBD" }
-        breakpoint() { return "TBD" }
+        debugger_proc(lbl: string) { return "TBD" }
         unconditional_branch(lbl: string) { return "TBD" }
         beq(lbl: string) { return "TBD" }
         bne(lbl: string) { return "TBD" }
@@ -112,10 +112,8 @@ namespace ts.pxtc {
             let baseLabel = this.proc.label()
             let bkptLabel = baseLabel + "_bkpt"
             let locLabel = baseLabel + "_locals"
-            this.write(`
-.section code
-${bkptLabel}:`)
-            this.write(this.t.breakpoint())
+            let endLabel = baseLabel + "_end"
+            this.write(`.section code`)
             this.write(`
 ${baseLabel}:
     @stackmark func
@@ -129,7 +127,8 @@ ${baseLabel}:
                     locals: (this.proc.seqNo == 1 ? this.bin.globals : this.proc.locals).map(l => l.getDebugInfo()),
                     args: this.proc.args.map(l => l.getDebugInfo()),
                     name: this.proc.getName(),
-                    codeStartLoc: U.lookup(labels, bkptLabel + "_after"),
+                    codeStartLoc: U.lookup(labels, locLabel),
+                    codeEndLoc: U.lookup(labels, endLabel),
                     bkptLoc: U.lookup(labels, bkptLabel),
                     localsMark: U.lookup(th.stackAtLabel, locLabel),
                     idx: this.proc.seqNo,
@@ -146,11 +145,16 @@ ${baseLabel}:
                     let bi = this.proc.body[i].breakpointInfo
                     if (bi) {
                         let off = U.lookup(th.stackAtLabel, `__brkp_${bi.id}`)
-                        assert(off === this.proc.debugInfo.localsMark)
+                        if (off !== this.proc.debugInfo.localsMark) {
+                            console.log(bi)
+                            console.log(th.stackAtLabel)
+                            U.oops(`offset doesn't match: ${off} != ${this.proc.debugInfo.localsMark}`)
+                        }
                     }
                 }
             }
 
+            this.write(this.t.debugger_proc(bkptLabel))
             this.write(this.t.proc_setup(true))
             // initialize the locals
             let numlocals = this.proc.locals.length
@@ -168,10 +172,6 @@ ${baseLabel}:
             this.proc.resolve()
             //console.log("OPT", proc.toString())
 
-            // debugger hook - bit #1 of global #0 determines break on function entry
-            // we could have put the 'bkpt' inline, and used `bpl`, but that would be 2 cycles slower
-            this.write(this.t.debugger_hook(bkptLabel))
-
             for (let i = 0; i < this.proc.body.length; ++i) {
                 let s = this.proc.body[i]
                 // console.log("STMT", s.toString())
@@ -196,13 +196,13 @@ ${baseLabel}:
                         this.write(s.lblName + ":")
                         break;
                     case ir.SK.Breakpoint:
-                        this.write(`__brkp_${s.breakpointInfo.id}:`)
-                        if (s.breakpointInfo.isDebuggerStmt) {
-                            let lbl = this.mkLbl("debugger")
-                            // bit #0 of debugger register is set when debugger is attached
-                            this.t.debugger_bkpt(lbl)
-                        } else {
-                            // do nothing
+                        if (this.bin.options.breakpoints) {
+                            let lbl = `__brkp_${s.breakpointInfo.id}`
+                            if (s.breakpointInfo.isDebuggerStmt) {
+                                this.write(this.t.debugger_stmt(lbl))
+                            } else {
+                                this.write(this.t.debugger_bkpt(lbl))
+                            }
                         }
                         break;
                     default: oops();
@@ -212,13 +212,16 @@ ${baseLabel}:
             assert(0 <= numlocals && numlocals < 127);
             if (numlocals > 0)
                 this.write(this.t.pop_locals(numlocals))
+            this.write(`${endLabel}:`)
             this.write(this.t.proc_return())
             this.write("@stackempty func");
             this.write("@stackempty args")
         }
 
         private mkLbl(root: string) {
-            return "." + root + this.bin.lblNo++
+            let l = root + this.bin.lblNo++
+            if (l[0] != "_") l = "." + l
+            return l
         }
 
         private terminate(expr: ir.Expr) {
@@ -475,8 +478,7 @@ ${baseLabel}:
                 }
             }
 
-            let lbl = this.mkLbl("proccall")
-            let afterall = this.mkLbl("afterall")
+            let lbl = this.mkLbl("_proccall")
 
             let procid = topExpr.data as ir.ProcId
             let procIdx = -1
@@ -488,8 +490,8 @@ ${baseLabel}:
                     this.write(this.t.emit_int(procid.mapIdx, "r1"))
                     if (isSet)
                         this.write(this.t.emit_int(procid.ifaceIndex, "r2"))
-                    this.write(lbl + ":")
                     this.emitHelper(this.t.vcall(procid.mapMethod, isSet, vtableShift))
+                    this.write(lbl + ":")
                 } else {
                     this.write(this.t.prologue_vtable(topExpr.args.length - 1, vtableShift))
 
@@ -505,15 +507,14 @@ ${baseLabel}:
                         this.write(this.t.load_reg_src_off("r0", "r0", "r1") + " ; ld-method")
                     }
 
-                    this.write(lbl + ":")
                     this.write(this.t.call_reg("r0"))
-                    this.write(afterall + ":")
+                    this.write(lbl + ":")
                 }
             } else {
                 let proc = procid.proc
                 procIdx = proc.seqNo
-                this.write(lbl + ":")
                 this.write(this.t.call_lbl(proc.label()))
+                this.write(lbl + ":")
             }
             this.calls.push({
                 procIndex: procIdx,
diff --git a/pxtcompiler/emitter/backjs.ts b/pxtcompiler/emitter/backjs.ts
index b3cf1685b3f9..273ae1fc6089 100644
--- a/pxtcompiler/emitter/backjs.ts
+++ b/pxtcompiler/emitter/backjs.ts
@@ -382,6 +382,7 @@ switch (step) {
                 case BitSize.Int32: return "pxsim.pxtrt.toInt32"
                 case BitSize.UInt8: return "pxsim.pxtrt.toUInt8"
                 case BitSize.UInt16: return "pxsim.pxtrt.toUInt16"
+                case BitSize.UInt32: return "pxsim.pxtrt.toUInt32"
                 default: throw oops()
             }
         }
diff --git a/pxtcompiler/emitter/backthumb.ts b/pxtcompiler/emitter/backthumb.ts
index 556de3e7a0f8..237bd1242bd7 100644
--- a/pxtcompiler/emitter/backthumb.ts
+++ b/pxtcompiler/emitter/backthumb.ts
@@ -22,27 +22,33 @@ namespace ts.pxtc {
         pop_fixed(regs: string[]) { return "pop {" + regs.join(", ") + "}" }
         proc_setup(main?: boolean) { return "push {lr}" }
         proc_return() { return "pop {pc}" }
-        debugger_hook(lbl: string) {
+
+        debugger_stmt(lbl: string) {
             return `
-    ldr r0, [r6, #0]
-    lsls r0, r0, #30
-    bmi ${lbl}
-${lbl + "_after"}:
-`;
+    @stackempty locals
+    ldr r0, [r6, #0] ; debugger
+    subs r0, r0, #4  ; debugger
+${lbl}:
+    ldr r0, [r0, #0] ; debugger
+`
         }
 
         debugger_bkpt(lbl: string) {
             return `
-    ldr r0, [r6, #0]
-    lsls r0, r0, #31
-    bpl ${lbl}
-    bkpt 2
-${lbl}:`
+    @stackempty locals
+    ldr r0, [r6, #0] ; brk
+${lbl}:
+    ldr r0, [r0, #0] ; brk
+`
         }
 
-        breakpoint() {
-            return "bkpt 1"
+        debugger_proc(lbl: string) {
+            return `
+    ldr r0, [r6, #0]  ; brk-entry
+    ldr r0, [r0, #4]  ; brk-entry
+${lbl}:`
         }
+
         push_local(reg: string) { return `push {${reg}}` }
         pop_locals(n: number) { return `add sp, #4*${n} ; pop locals${n}` }
         unconditional_branch(lbl: string) { return "bb " + lbl; }
diff --git a/pxtcompiler/emitter/emitter.ts b/pxtcompiler/emitter/emitter.ts
index e327aed00ade..97b24ae1d2ed 100644
--- a/pxtcompiler/emitter/emitter.ts
+++ b/pxtcompiler/emitter/emitter.ts
@@ -124,9 +124,16 @@ namespace ts.pxtc {
         return true
     }
 
-    function isRefDecl(def: Declaration) {
+    function isSyntheticThis(def: Declaration) {
         if ((<any>def).isThisParameter)
             return true;
+        else
+            return false;
+    }
+
+    function isRefDecl(def: Declaration) {
+        if (isSyntheticThis(def))
+            return true;
         //let tp = checker.getDeclaredTypeOfSymbol(def.symbol)
         let tp = typeOf(def)
         return isRefType(tp)
@@ -165,6 +172,7 @@ namespace ts.pxtc {
             case "int32": return BitSize.Int32
             case "uint8": return BitSize.UInt8
             case "uint16": return BitSize.UInt16
+            case "uint32": return BitSize.UInt32
             default: return BitSize.None
         }
     }
@@ -177,6 +185,21 @@ namespace ts.pxtc {
             case BitSize.Int32: return 4
             case BitSize.UInt8: return 1
             case BitSize.UInt16: return 2
+            case BitSize.UInt32: return 4
+            default: throw oops()
+        }
+    }
+
+    export function isBitSizeSigned(b: BitSize) {
+        switch (b) {
+            case BitSize.Int8:
+            case BitSize.Int16:
+            case BitSize.Int32:
+                return true
+            case BitSize.UInt8:
+            case BitSize.UInt16:
+            case BitSize.UInt32:
+                return false
             default: throw oops()
         }
     }
@@ -185,10 +208,20 @@ namespace ts.pxtc {
         l._isRef = isRefDecl(l.def)
         l._isLocal = isLocalVar(l.def) || isParameter(l.def)
         l._isGlobal = isGlobalVar(l.def)
-        if (!l.isRef() && typeOf(l.def).flags & TypeFlags.Void) {
-            oops("void-typed variable, " + l.toString())
+        if (!isSyntheticThis(l.def)) {
+            let tp = typeOf(l.def)
+            if (tp.flags & TypeFlags.Void) {
+                oops("void-typed variable, " + l.toString())
+            }
+            l.bitSize = getBitSize(l.def)
+            if (l.bitSize != BitSize.None) {
+                l._debugType = (isBitSizeSigned(l.bitSize) ? "int" : "uint") + (8 * sizeOfBitSize(l.bitSize))
+            } else if (tp.flags & TypeFlags.String) {
+                l._debugType = "string"
+            } else if (tp.flags & TypeFlags.NumberLike) {
+                l._debugType = "number"
+            }
         }
-        l.bitSize = getBitSize(l.def)
         if (l.isLocal() && l.bitSize != BitSize.None) {
             l.bitSize = BitSize.None
             userError(9256, lf("bit sizes are not supported for locals and parameters"))
@@ -309,15 +342,6 @@ namespace ts.pxtc {
         }
     }
 
-    export const enum BitSize {
-        None,
-        Int8,
-        UInt8,
-        Int16,
-        UInt16,
-        Int32,
-    }
-
     export interface CallInfo {
         decl: Declaration;
         qName: string;
@@ -874,8 +898,6 @@ namespace ts.pxtc {
 
             hex.setupFor(opts.target, opts.extinfo || emptyExtInfo(), opts.hexinfo);
             hex.setupInlineAssembly(opts);
-
-            opts.breakpoints = true
         }
 
         let bin = new Binary()
@@ -895,7 +917,6 @@ namespace ts.pxtc {
                 length: 0,
                 line: 0,
                 column: 0,
-                successors: null
             }]
         }
 
@@ -2884,6 +2905,8 @@ ${lbl}: .short 0xffff
         }
 
         function emitBrk(node: Node) {
+            if (!opts.breakpoints)
+                return
             let src = getSourceFileOfNode(node)
             if (opts.justMyCode && U.startsWith(src.fileName, "pxt_modules"))
                 return;
@@ -2902,7 +2925,6 @@ ${lbl}: .short 0xffff
                 endLine: e.line,
                 column: p.character,
                 endColumn: e.character,
-                successors: null
             }
             res.breakpoints.push(brk)
             let st = ir.stmt(ir.SK.Breakpoint, null)
@@ -3811,6 +3833,7 @@ ${lbl}: .short 0xffff
         usedClassInfos: ClassInfo[] = [];
         sourceHash = "";
         checksumBlock: number[];
+        numStmts = 1;
 
         strings: Map<string> = {};
         doubles: Map<string> = {};
diff --git a/pxtcompiler/emitter/hexfile.ts b/pxtcompiler/emitter/hexfile.ts
index d4ee80a46220..1621b72addd8 100644
--- a/pxtcompiler/emitter/hexfile.ts
+++ b/pxtcompiler/emitter/hexfile.ts
@@ -605,17 +605,16 @@ namespace ts.pxtc {
             // string representation of DAL - 0xffff in general for ref-counted objects means it's static and shouldn't be incr/decred
             bin.otherLiterals.push(`
 .balign 4
-${lbl}meta: .short 0xffff, ${target.taggedInts ? "1," : ""} ${s.length}
+${lbl}meta: .short 0xffff, ${target.taggedInts ? pxt.REF_TAG_STRING + "," : ""} ${s.length}
 ${lbl}: .string ${stringLiteral(s)}
 `)
         }
 
         for (let data of Object.keys(bin.doubles)) {
             let lbl = bin.doubles[data]
-            // this is REF_TAG_NUMBER in pxt.h
             bin.otherLiterals.push(`
 .balign 4
-${lbl}: .short 0xffff, 32
+${lbl}: .short 0xffff, ${pxt.REF_TAG_NUMBER}
         .hex ${data}
 `)
         }
@@ -771,7 +770,7 @@ ${hex.hexPrelude()}
         let b = mkProcessorFile(nativeType)
         b.emit(src);
 
-        src = b.getSource(!peepDbg);
+        src = b.getSource(!peepDbg, bin.numStmts);
 
         throwAssemblerErrors(b)
 
@@ -857,6 +856,7 @@ __flash_checksums:
 `
         }
         bin.writeFile(pxtc.BINARY_ASM, src)
+        bin.numStmts = cres.breakpoints.length
         let res = assemble(opts.target.nativeType, bin, src)
         if (res.src)
             bin.writeFile(pxtc.BINARY_ASM, res.src)
diff --git a/pxtcompiler/emitter/ir.ts b/pxtcompiler/emitter/ir.ts
index a6dd49758ba4..37be5fb6f343 100644
--- a/pxtcompiler/emitter/ir.ts
+++ b/pxtcompiler/emitter/ir.ts
@@ -251,6 +251,7 @@ namespace ts.pxtc.ir {
         _isRef = false;
         _isLocal = false;
         _isGlobal = false;
+        _debugType = "?";
         bitSize = BitSize.None;
 
         constructor(public index: number, public def: Declaration, public info: VariableAddInfo) {
@@ -266,7 +267,8 @@ namespace ts.pxtc.ir {
         getDebugInfo(): CellInfo {
             return {
                 name: this.getName(),
-                type: "TODO"
+                type: this._debugType,
+                index: this.index,
             }
         }
 
@@ -302,6 +304,8 @@ namespace ts.pxtc.ir {
             let r = this.loadCore()
 
             if (target.taggedInts && this.bitSize != BitSize.None) {
+                if (this.bitSize == BitSize.UInt32)
+                    return rtcall("pxt::fromUInt", [r])
                 return rtcall("pxt::fromInt", [r])
             }
 
@@ -332,7 +336,8 @@ namespace ts.pxtc.ir {
             } else {
                 if (target.taggedInts && this.bitSize != BitSize.None) {
                     src = shared(src)
-                    let iv = shared(rtcall("pxt::toInt", [src]))
+                    let cnv = this.bitSize == BitSize.UInt32 ? "pxt::toUInt" : "pxt::toInt"
+                    let iv = shared(rtcall(cnv, [src]))
                     return op(EK.Sequence, [
                         iv,
                         op(EK.Decr, [src]),
@@ -665,40 +670,10 @@ namespace ts.pxtc.ir {
                 }
             }
 
-            let findIdx = 1
-            let findNext = (i: number) => {
-                let res: Breakpoint[] = []
-                let loop = (i: number) => {
-                    while (i < this.body.length) {
-                        let s = this.body[i]
-                        if (s.findIdx === findIdx)
-                            return
-                        s.findIdx = findIdx
-                        switch (s.stmtKind) {
-                            case ir.SK.Jmp:
-                                if (s.jmpMode == ir.JmpMode.Always)
-                                    i = s.lbl.stmtNo - 1
-                                else
-                                    loop(s.lbl.stmtNo) // fork
-                                break;
-                            case ir.SK.Breakpoint:
-                                res.push(s.breakpointInfo)
-                                return
-                        }
-                        i++;
-                    }
-                }
-
-                findIdx++
-                loop(i)
-                return res
-            }
-
             let allBrkp: Breakpoint[] = []
 
             for (let s of this.body) {
                 if (s.stmtKind == ir.SK.Breakpoint) {
-                    s.breakpointInfo.successors = findNext(s.stmtNo + 1).map(b => b.id)
                     allBrkp[s.breakpointInfo.id] = s.breakpointInfo
                 }
             }
@@ -712,10 +687,6 @@ namespace ts.pxtc.ir {
 
                     s += `${b.line + 1}: `
                     let n = allBrkp[i + 1]
-                    if (n && b.successors.length == 1 && b.successors[0] == n.id)
-                        s += "."
-                    else
-                        s += b.successors.map(b => `${allBrkp[b].line + 1}`).join(", ")
                     s += "\n"
                 }
                 console.log(s)
diff --git a/pxtcompiler/emitter/thumb.ts b/pxtcompiler/emitter/thumb.ts
index 712f5b5d1df0..21e3e20e4f1d 100644
--- a/pxtcompiler/emitter/thumb.ts
+++ b/pxtcompiler/emitter/thumb.ts
@@ -93,7 +93,7 @@ namespace ts.pxtc.thumb {
             this.addInst("eors  $r0, $r1", 0x4040, 0xffc0);
             this.addInst("ldmia $r5!, $rl0", 0xc800, 0xf800);
             this.addInst("ldmia $r5, $rl0", 0xc800, 0xf800);
-            this.addInst("ldr   $r0, [$r1, $i5]", 0x6800, 0xf800).canBeShared = true;
+            this.addInst("ldr   $r0, [$r1, $i5]", 0x6800, 0xf800); // this is used for debugger breakpoint - cannot be shared
             this.addInst("ldr   $r0, [$r1, $r4]", 0x5800, 0xfe00);
             this.addInst("ldr   $r5, [pc, $i1]", 0x4800, 0xf800);
             this.addInst("ldr   $r5, $la", 0x4800, 0xf800);
diff --git a/pxtlib/cpp.ts b/pxtlib/cpp.ts
index 28dbf41e9b26..e1fc44ce7643 100644
--- a/pxtlib/cpp.ts
+++ b/pxtlib/cpp.ts
@@ -17,29 +17,29 @@ namespace pxt {
     export function lzmaDecompressAsync(buf: Uint8Array): Promise<string> { // string
         return getLzmaAsync()
             .then(lzma => new Promise<string>((resolve, reject) => {
-            try {
-                lzma.decompress(buf, (res: string, error: any) => {
-                    resolve(error ? undefined : res);
-                })
-            }
-            catch (e) {
-                resolve(undefined);
-            }
-        }));
+                try {
+                    lzma.decompress(buf, (res: string, error: any) => {
+                        resolve(error ? undefined : res);
+                    })
+                }
+                catch (e) {
+                    resolve(undefined);
+                }
+            }));
     }
 
     export function lzmaCompressAsync(text: string): Promise<Uint8Array> {
         return getLzmaAsync()
             .then(lzma => new Promise<Uint8Array>((resolve, reject) => {
-            try {
-                lzma.compress(text, 7, (res: any, error: any) => {
-                    resolve(error ? undefined : new Uint8Array(res));
-                })
-            }
-            catch (e) {
-                resolve(undefined);
-            }
-        }));
+                try {
+                    lzma.compress(text, 7, (res: any, error: any) => {
+                        resolve(error ? undefined : new Uint8Array(res));
+                    })
+                }
+                catch (e) {
+                    resolve(undefined);
+                }
+            }));
     }
 }
 
@@ -219,11 +219,18 @@ namespace pxt.cpp {
                 switch (tp.replace(/\s+/g, "")) {
                     case "void": return "void";
                     // TODO: need int16_t
-                    case "TNumber":
                     case "int32_t":
+                    case "int":
+                        return "int32";
+
                     case "uint32_t":
                     case "unsigned":
-                    case "int": return "number";
+                        return "uint32";
+
+                    case "TNumber":
+                    case "float":
+                    case "double":
+                        return "number";
 
                     case "uint16_t": return "uint16";
 
diff --git a/pxtlib/emitter/assembler.ts b/pxtlib/emitter/assembler.ts
index f901acd9d110..6a1e2549b5e5 100644
--- a/pxtlib/emitter/assembler.ts
+++ b/pxtlib/emitter/assembler.ts
@@ -836,7 +836,7 @@ namespace ts.pxtc.assembler {
         }
 
 
-        public getSource(clean: boolean) {
+        public getSource(clean: boolean, numStmts = 1) {
             let lenTotal = this.buf ? this.buf.length * 2 : 0
             let lenThumb = this.labels["_program_end"] || lenTotal;
             let lenFrag = this.labels["_frag_start"] || 0
@@ -847,7 +847,9 @@ namespace ts.pxtc.assembler {
                 // ARM-specific
                 lf("; code sizes (bytes): {0} (incl. {1} frags, and {2} lits); src size {3}\n",
                     lenThumb, lenFrag, lenLit, lenTotal - lenThumb) +
-                lf("; assembly: {0} lines\n", this.lines.length) +
+                lf("; assembly: {0} lines; density: {1} bytes/stmt\n",
+                    this.lines.length,
+                    Math.round(100 * (lenThumb - lenLit) / numStmts) / 100) +
                 this.stats + "\n\n"
 
             let skipOne = false
diff --git a/pxtlib/hf2.ts b/pxtlib/hf2.ts
index e5a3bc84363c..e7c7b2849f96 100644
--- a/pxtlib/hf2.ts
+++ b/pxtlib/hf2.ts
@@ -17,6 +17,7 @@ namespace pxt.HF2 {
         sendPacketAsync(pkt: Uint8Array): Promise<void>;
         onData: (v: Uint8Array) => void;
         onError: (e: Error) => void;
+        onEvent: (v: Uint8Array) => void;
         error(msg: string): any;
         reconnectAsync(): Promise<void>;
 
@@ -27,7 +28,6 @@ namespace pxt.HF2 {
     }
 
     // see https://github.com/Microsoft/uf2/blob/master/hf2.md for full spec
-
     export const HF2_CMD_BININFO = 0x0001 // no arguments
     export const HF2_MODE_BOOTLOADER = 0x01
     export const HF2_MODE_USERSPACE = 0x02
@@ -95,17 +95,21 @@ namespace pxt.HF2 {
     // no arguments
     // results is utf8 character array
 
-    const HF2_FLAG_SERIAL_OUT = 0x80
-    const HF2_FLAG_SERIAL_ERR = 0xC0
-    const HF2_FLAG_CMDPKT_LAST = 0x40
-    const HF2_FLAG_CMDPKT_BODY = 0x00
-    const HF2_FLAG_MASK = 0xC0
-    const HF2_SIZE_MASK = 63
+    export const HF2_FLAG_SERIAL_OUT = 0x80
+    export const HF2_FLAG_SERIAL_ERR = 0xC0
+    export const HF2_FLAG_CMDPKT_LAST = 0x40
+    export const HF2_FLAG_CMDPKT_BODY = 0x00
+    export const HF2_FLAG_MASK = 0xC0
+    export const HF2_SIZE_MASK = 63
 
-    const HF2_STATUS_OK = 0x00
-    const HF2_STATUS_INVALID_CMD = 0x01
-    const HF2_STATUS_EXEC_ERR = 0x02
+    export const HF2_STATUS_OK = 0x00
+    export const HF2_STATUS_INVALID_CMD = 0x01
+    export const HF2_STATUS_EXEC_ERR = 0x02
+    export const HF2_STATUS_EVENT = 0x80
 
+    // the eventId is overlayed on the tag+status; the mask corresponds
+    // to the HF2_STATUS_EVENT above
+    export const HF2_EV_MASK = 0x800000
 
     export function write32(buf: ArrayLike<number>, pos: number, v: number) {
         buf[pos + 0] = (v >> 0) & 0xff;
@@ -127,6 +131,22 @@ namespace pxt.HF2 {
         return buf[pos] | (buf[pos + 1] << 8)
     }
 
+    export function encodeU32LE(words: number[]) {
+        let r = new Uint8Array(words.length * 4)
+        for (let i = 0; i < words.length; ++i)
+            write32(r, i * 4, words[i])
+        return r
+    }
+
+    export function decodeU32LE(buf: Uint8Array) {
+        let res: number[] = []
+        for (let i = 0; i < buf.length; i += 4)
+            res.push(read32(buf, i))
+        return res
+    }
+
+
+
     export interface BootloaderInfo {
         Header: string;
         Parsed: {
@@ -170,7 +190,21 @@ namespace pxt.HF2 {
                         ptr += f.length
                     }
                     frames = []
-                    this.msgs.push(r)
+                    if (r[2] & HF2_STATUS_EVENT) {
+                        // asynchronous event
+                        io.onEvent(r)
+                    } else {
+                        this.msgs.push(r)
+                    }
+                }
+            }
+            io.onEvent = buf => {
+                let evid = read32(buf, 0)
+                let f = U.lookup(this.eventHandlers, evid + "")
+                if (f) {
+                    f(buf.slice(4))
+                } else {
+                    log("unhandled event: " + evid.toString(16))
                 }
             }
             io.onError = err => {
@@ -188,6 +222,7 @@ namespace pxt.HF2 {
         bootloaderMode = false;
         reconnectTries = 0;
         msgs = new U.PromiseBuffer<Uint8Array>()
+        eventHandlers: pxt.Map<(buf: Uint8Array) => void> = {}
 
         onSerial = (buf: Uint8Array, isStderr: boolean) => { };
 
@@ -202,6 +237,11 @@ namespace pxt.HF2 {
             this.msgs.drain()
         }
 
+        onEvent(id: number, f: (buf: Uint8Array) => void) {
+            U.assert(!!(id & HF2_EV_MASK))
+            this.eventHandlers[id + ""] = f
+        }
+
         reconnectAsync(first = false): Promise<void> {
             this.resetState()
             if (first) return this.initAsync()
@@ -322,6 +362,13 @@ namespace pxt.HF2 {
                 .then(() => this.reconnectAsync())
         }
 
+        writeWordsAsync(addr: number, words: number[]) {
+            U.assert(words.length <= 64) // just sanity check
+            return this.talkAsync(HF2_CMD_WRITE_WORDS,
+                encodeU32LE([addr, words.length].concat(words)))
+                .then(() => { })
+        }
+
         readWordsAsync(addr: number, numwords: number) {
             let args = new Uint8Array(8)
             write32(args, 0, addr)
diff --git a/pxtlib/hwdbg.ts b/pxtlib/hwdbg.ts
new file mode 100644
index 000000000000..a7d36d58d037
--- /dev/null
+++ b/pxtlib/hwdbg.ts
@@ -0,0 +1,385 @@
+namespace pxt {
+    // keep in sync with RefCounted.h in Codal
+    export const REF_TAG_STRING = 1
+    export const REF_TAG_BUFFER = 2
+    export const REF_TAG_IMAGE = 3
+    export const REF_TAG_NUMBER = 32
+}
+
+namespace pxt.HWDBG {
+    import Cloud = pxt.Cloud;
+    import U = pxt.Util;
+    import H = pxt.HF2;
+
+    const HF2_DBG_GET_GLOBAL_STATE = 0x53fc66e0
+    const HF2_DBG_RESUME = 0x27a55931
+    const HF2_DBG_RESTART = 0x1120bd93
+    const HF2_DBG_GET_STACK = 0x70901510
+
+    const HF2_EV_DBG_PAUSED = 0x3692f9fd
+
+    const r32 = H.read32
+
+    export interface StateInfo {
+        numGlobals: number;
+        globalsPtr: number;
+    }
+
+    let isHalted = false
+    let lastCompileResult: pxtc.CompileResult;
+    let onHalted = Promise.resolve();
+    let haltHandler: () => void;
+    let cachedStaticState: StateInfo
+    let currBreakpoint: pxtc.Breakpoint;
+    let callInfos: pxt.Map<ExtCallInfo>;
+    let lastFlash: pxtc.UF2.ShiftedBuffer
+
+    let hid: pxt.HF2.Wrapper
+
+    interface ExtCallInfo {
+        from: pxtc.ProcDebugInfo;
+        to: pxtc.ProcDebugInfo;
+        stack: number;
+    }
+
+
+    function taggedSpecialValue(n: number) { return (n << 2) | 2 }
+    export const taggedUndefined = 0
+    export const taggedNull = taggedSpecialValue(1)
+    export const taggedFalse = taggedSpecialValue(2)
+    export const taggedTrue = taggedSpecialValue(16)
+
+    export var postMessage: (msg: pxsim.DebuggerMessage) => void = msg => console.log(msg)
+
+    function clearAsync() {
+        isHalted = false
+        lastCompileResult = null
+        cachedStaticState = null
+        return Promise.resolve()
+    }
+
+    export function decodeValue(n: number): any {
+        if (n & 1)
+            return n >> 1
+
+        if (n == 0)
+            return undefined
+
+        if (n & 2) {
+            if (n == taggedNull) return null
+            if (n == taggedFalse) return false
+            if (n == taggedTrue) return true
+            return { tagged: n >> 2 }
+        }
+
+        return { ptr: n }
+    }
+
+    function readMemAsync(addr: number, numbytes: number): Promise<Uint8Array> {
+        U.assert(!(addr & 3))
+        U.assert(addr >= 0)
+        if (addr < 2 * 1024 * 1024) {
+            // assume these sit in flash
+            let res = new Uint8Array(numbytes)
+            addr -= lastFlash.start
+            U.memcpy(res, 0, lastFlash.buf, addr, numbytes)
+            return Promise.resolve(res)
+        }
+        let maxBytes = hid.maxMsgSize - 32
+        if (numbytes > maxBytes) {
+            let promises: Promise<Uint8Array>[] = []
+            while (numbytes > 0) {
+                let n = Math.min(maxBytes, numbytes)
+                promises.push(readMemAsync(addr, n))
+                numbytes -= n
+                addr += n
+            }
+            return Promise.all(promises)
+                .then(U.uint8ArrayConcat)
+        } else {
+            return hid.readWordsAsync(addr, Math.ceil(numbytes / 4))
+                .then(rr => {
+                    if (rr.length > numbytes)
+                        return rr.slice(0, numbytes)
+                    else
+                        return rr
+                })
+        }
+    }
+
+    export function heapExpandAsync(v: any): Promise<any> {
+        if (typeof v != "object" || !v) return Promise.resolve(v)
+        if (typeof v.ptr == "number") {
+            // there should be no unaligned pointers
+            if (v.ptr & 3)
+                return Promise.resolve({ unalignedPtr: v.ptr })
+            let tag = 0
+            // 56 bytes of data fit in one HID packet (with 5 bytes of header and 3 bytes of padding)
+            return readMemAsync(v.ptr, 56)
+                .then(buf => {
+                    tag = H.read16(buf, 2)
+                    let neededLength = buf.length
+                    if (tag == REF_TAG_STRING || tag == REF_TAG_BUFFER) {
+                        neededLength = H.read16(buf, 4) + 6
+                    } else if (tag == REF_TAG_IMAGE) {
+                        neededLength = H.read16(buf, 4) * H.read16(buf, 8) + 8
+                    } else if (tag == REF_TAG_NUMBER) {
+                        neededLength = 8 + 4
+                    } else {
+                        // TODO
+                    }
+                    if (neededLength > buf.length) {
+                        return readMemAsync(v.ptr + buf.length, neededLength - buf.length)
+                            .then(secondary => U.uint8ArrayConcat([buf, secondary]))
+                    } else if (neededLength < buf.length) {
+                        return buf.slice(0, neededLength)
+                    } else {
+                        return buf
+                    }
+                })
+                .then<any>(buf => {
+                    if (tag == REF_TAG_STRING)
+                        return U.uint8ArrayToString(buf.slice(6))
+                    else if (tag == REF_TAG_STRING)
+                        return { type: "buffer", data: buf.slice(6) }
+                    else if (tag == REF_TAG_IMAGE)
+                        return {
+                            type: "image",
+                            data: buf.slice(8),
+                            width: H.read16(buf, 4),
+                            height: H.read16(buf, 8),
+                        }
+                    else if (tag == REF_TAG_NUMBER)
+                        return new Float64Array(buf.buffer.slice(4))[0]
+                    else
+                        return {
+                            type: "unknown",
+                            tag: tag,
+                            refcnt: H.read16(buf, 0),
+                            data: buf.slice(4)
+                        }
+                })
+        } else {
+            return Promise.resolve(v)
+        }
+    }
+
+    export function heapExpandMapAsync(vars: pxsim.Variables) {
+        let promises: Promise<void>[] = []
+        for (let k of Object.keys(vars)) {
+            promises.push(heapExpandAsync(vars[k])
+                .then((r: any) => {
+                    vars[k] = r
+                    //console.log("set", k, "to", r, "prev", vars[k], "NOW", vars)
+                }))
+        }
+        return Promise.all(promises)
+            .then(() => {
+                //console.log("FIN", vars)
+            })
+    }
+
+    function buildFrames(stack: number[], msg: pxsim.DebuggerBreakpointMessage) {
+        let currAddr = currBreakpoint.binAddr
+        let sp = 0
+        let pi = lastCompileResult.procDebugInfo.filter(p =>
+            p.codeStartLoc <= currAddr && currAddr <= p.codeEndLoc)[0]
+
+        while (true) {
+            if (!pi)
+                break // ???
+            if (pi == lastCompileResult.procDebugInfo[0])
+                break // main
+
+            let bp = findPrevBrkp(currAddr)
+            let info = U.clone(bp) as any as pxtc.FunctionLocationInfo
+            info.functionName = pi.name
+            msg.stackframes.push({
+                locals: {},
+                funcInfo: info,
+                breakpointId: bp.id,
+            })
+            let frame = msg.stackframes[msg.stackframes.length - 1]
+            let idx = 0
+            for (let l of pi.locals) {
+                U.assert(l.index == idx++)
+                frame.locals[l.name] = decodeValue(stack[sp++])
+            }
+            currAddr = stack[sp++] & 0x7ffffffe
+            let ci = callInfos[currAddr + ""]
+            for (let l of pi.args) {
+                frame.locals[l.name] = decodeValue(stack[sp + (pi.args.length - 1 - l.index)])
+            }
+
+            if (!ci) break
+
+            pi = ci.from
+            sp += ci.stack - pi.localsMark
+        }
+    }
+
+    function findPrevBrkp(addr: number) {
+        let bb = lastCompileResult.breakpoints
+        let brkMatch = bb[0]
+        let bestDelta = Infinity
+        for (let b of bb) {
+            let delta = addr - b.binAddr
+            // console.log(`${b.line+1}: addr=${b.binAddr} d=${delta}`)
+            if (delta >= 0 && delta < bestDelta) {
+                bestDelta = delta
+                brkMatch = b
+            }
+        }
+        return brkMatch
+    }
+
+    function corePaused(buf: Uint8Array) {
+        if (isHalted) return Promise.resolve()
+        isHalted = true
+        let msg: pxsim.DebuggerBreakpointMessage
+        return getHwStateAsync()
+            .then(st => {
+                let w = H.decodeU32LE(buf)
+                let pc = w[0]
+
+                let globals: pxsim.Variables = {}
+
+                for (let l of lastCompileResult.procDebugInfo[0].locals) {
+                    let gbuf = st.globals
+
+                    let readV = () => {
+                        switch (l.type) {
+                            case "uint32": return H.read32(gbuf, l.index)
+                            case "int32": return H.read32(gbuf, l.index) | 0
+                            case "uint16": return H.read16(gbuf, l.index)
+                            case "int16": return (H.read16(gbuf, l.index) << 16) >> 16
+                            case "uint8": return gbuf[l.index]
+                            case "int8": return (gbuf[l.index] << 24) >> 24
+                            default: return null
+                        }
+                    }
+
+                    let v: any = readV()
+                    if (v === null) {
+                        U.assert((l.index & 3) == 0)
+                        v = decodeValue(H.read32(gbuf, l.index))
+                    }
+                    globals[l.name] = v
+                }
+
+                currBreakpoint = findPrevBrkp(pc)
+                msg = {
+                    type: 'debugger',
+                    subtype: 'breakpoint',
+                    breakpointId: currBreakpoint.id,
+                    globals: globals,
+                    stackframes: []
+                }
+
+                haltHandler()
+                return hid.talkAsync(HF2_DBG_GET_STACK)
+            })
+            .then(stack => {
+                buildFrames(H.decodeU32LE(stack), msg);
+                let maps = [msg.globals].concat(msg.stackframes.map(s => s.locals))
+                return Promise.map(maps, heapExpandMapAsync)
+            })
+            .then(() => postMessage(msg))
+    }
+
+    function clearHalted() {
+        isHalted = false
+        onHalted = new Promise<void>((resolve, reject) => {
+            haltHandler = resolve
+        })
+    }
+
+    export function startDebugAsync(compileRes: pxtc.CompileResult, hidWr: H.Wrapper) {
+        hid = hidWr
+        hid.onEvent(HF2_EV_DBG_PAUSED, corePaused)
+
+        return clearAsync()
+            .then(() => {
+                lastCompileResult = compileRes
+                callInfos = {}
+
+                let procLookup: pxtc.ProcDebugInfo[] = []
+                for (let pdi of compileRes.procDebugInfo) {
+                    procLookup[pdi.idx] = pdi
+                }
+                for (let pdi of compileRes.procDebugInfo) {
+                    //console.log(pdi)
+                    for (let ci of pdi.calls) {
+                        callInfos[ci.addr + ""] = {
+                            from: pdi,
+                            to: procLookup[ci.procIndex],
+                            stack: ci.stack
+                        }
+                    }
+                }
+            })
+            .then(() => {
+                let f = lastCompileResult.outfiles[pxtc.BINARY_UF2]
+                let blockBuf = U.stringToUint8Array(atob(f))
+                lastFlash = pxtc.UF2.toBin(blockBuf)
+                let blocks = pxtc.UF2.parseFile(blockBuf)
+                return hid.reflashAsync(blocks) // this will reset into app at the end
+            })
+            .then(() => hid.talkAsync(HF2_DBG_RESTART).catch(e => { }))
+            .then(() => Promise.delay(200))
+            .then(() => hid.reconnectAsync())
+            .then(clearHalted)
+            .then(waitForHaltAsync)
+    }
+
+    export function handleMessage(msg: pxsim.DebuggerMessage) {
+        console.log("HWDBGMSG", msg)
+        if (msg.type != "debugger")
+            return
+        let stepInto = false
+        switch (msg.subtype) {
+            case 'stepinto':
+                stepInto = true
+            case 'stepover':
+                resumeAsync(stepInto)
+                break
+        }
+    }
+
+    export function resumeAsync(into = false) {
+        return Promise.resolve()
+            .then(() => hid.talkAsync(HF2_DBG_RESUME, H.encodeU32LE([into ? 1 : 3])))
+            .then(clearHalted)
+    }
+
+    export interface HwState {
+        staticState: StateInfo;
+        globals: Uint8Array;
+    }
+
+    export function waitForHaltAsync() {
+        return onHalted
+    }
+
+    function getStaticStateAsync() {
+        if (cachedStaticState) return Promise.resolve(cachedStaticState)
+        return hid.talkAsync(HF2_DBG_GET_GLOBAL_STATE)
+            .then(buf => (cachedStaticState = {
+                numGlobals: r32(buf, 0),
+                globalsPtr: r32(buf, 4)
+            }))
+    }
+
+    export function getHwStateAsync() {
+        return getStaticStateAsync()
+            .then(st => hid.readWordsAsync(st.globalsPtr, st.numGlobals))
+            .then(buf => {
+                let res: HwState = {
+                    staticState: cachedStaticState,
+                    globals: buf
+                }
+                return res
+            })
+    }
+
+}
\ No newline at end of file
diff --git a/pxtlib/service.ts b/pxtlib/service.ts
index 16612fd0dd96..b35a6aeb84a0 100644
--- a/pxtlib/service.ts
+++ b/pxtlib/service.ts
@@ -194,13 +194,13 @@ namespace ts.pxtc {
     export interface Breakpoint extends LocationInfo {
         id: number;
         isDebuggerStmt: boolean;
-        successors: number[]; // ids of all breakpoints that we could hit next
         binAddr?: number;
     }
 
     export interface CellInfo {
         name: string;
         type: string;
+        index: number;
     }
 
     export interface ProcCallInfo {
@@ -215,12 +215,23 @@ namespace ts.pxtc {
         idx: number;
         bkptLoc: number;
         codeStartLoc: number;
+        codeEndLoc: number;
         locals: CellInfo[];
         args: CellInfo[];
         localsMark: number;
         calls: ProcCallInfo[];
     }
 
+    export const enum BitSize {
+        None,
+        Int8,
+        UInt8,
+        Int16,
+        UInt16,
+        Int32,
+        UInt32,
+    }
+
     export function computeUsedParts(resp: CompileResult, ignoreBuiltin = false): string[] {
         if (!resp.usedSymbols || !pxt.appTarget.simulator || !pxt.appTarget.simulator.parts)
             return [];
@@ -515,7 +526,12 @@ namespace ts.pxtc {
             return r
         }
 
-        export function toBin(blocks: Uint8Array) {
+        export interface ShiftedBuffer {
+            start: number;
+            buf: Uint8Array;
+        }
+
+        export function toBin(blocks: Uint8Array): ShiftedBuffer {
             if (blocks.length < 512)
                 return null
             let curraddr = -1
diff --git a/pxtlib/util.ts b/pxtlib/util.ts
index fd27643f541e..fcbc146ce553 100644
--- a/pxtlib/util.ts
+++ b/pxtlib/util.ts
@@ -108,6 +108,18 @@ namespace ts.pxtc.Util {
             trg[trgOff + i] = src[srcOff + i]
     }
 
+    export function uint8ArrayConcat(chunks: Uint8Array[]) {
+        let numbytes = 0
+        for (let c of chunks) numbytes += c.length
+        let r = new Uint8Array(numbytes)
+        let ptr = 0
+        for (let c of chunks) {
+            memcpy(r, ptr, c)
+            ptr += c.length
+        }
+        return r
+    }
+
     export function jsonMergeFrom(trg: any, src: any) {
         if (!src) return;
         Object.keys(src).forEach(k => {
@@ -883,7 +895,7 @@ namespace ts.pxtc.BrowserImpl {
 
             client = new XMLHttpRequest();
             if (options.responseArrayBuffer)
-               client.responseType = "arraybuffer";
+                client.responseType = "arraybuffer";
             client.onreadystatechange = () => {
                 if (resolved) return // Safari/iOS likes to call this thing more than once
 
diff --git a/pxtlib/webusb.ts b/pxtlib/webusb.ts
index 2460dac5f21c..49f6b92fc785 100644
--- a/pxtlib/webusb.ts
+++ b/pxtlib/webusb.ts
@@ -101,6 +101,7 @@ namespace pxt.usb {
         epOut: USBEndpoint;
         onData = (v: Uint8Array) => { };
         onError = (e: Error) => { };
+        onEvent = (v: Uint8Array) => { };
 
         constructor(public dev: USBDevice) {
             this.readLoop()
diff --git a/pxtsim/debugger.ts b/pxtsim/debugger.ts
index fc75d37e04c1..55f992cc56f6 100644
--- a/pxtsim/debugger.ts
+++ b/pxtsim/debugger.ts
@@ -2,56 +2,6 @@
 /// <reference path="./utils.ts" />
 
 namespace pxsim {
-    // type=debugger
-    export interface DebuggerMessage extends SimulatorMessage {
-        subtype: string;
-    }
-
-    // subtype=config
-    export interface DebuggerConfigMessage extends DebuggerMessage {
-        setBreakpoints?: number[];
-    }
-
-    // subtype=resume
-    // subtype=stepover
-    // subtype=stepinto
-
-    //
-    // Responses from simulator
-    //
-
-    // subtype=breakpoint
-    export interface DebuggerBreakpointMessage extends DebuggerMessage {
-        breakpointId: number;
-        globals: Variables;
-        stackframes: {
-            locals: Variables;
-            funcInfo: any; // pxtc.FunctionLocationInfo
-            breakpointId: number;
-        }[];
-        exceptionMessage?: string;
-        exceptionStack?: string;
-    }
-
-    // subtype=trace
-    export interface TraceMessage extends DebuggerMessage {
-        breakpointId: number;
-    }
-
-    // subtype=traceConfig
-    export interface TraceConfigMessage extends DebuggerMessage {
-        interval: number;
-    }
-
-    export interface DebuggerWarningMessage extends DebuggerMessage {
-        message: string;
-        breakpointIds: number[];
-    }
-
-    export interface Variables {
-        [name: string]: any;
-    }
-
     export function getWarningMessage(msg: string) {
         let r: DebuggerWarningMessage = {
             type: "debugger",
diff --git a/pxtsim/embed.ts b/pxtsim/embed.ts
index 032a879266d0..adaac62a7302 100644
--- a/pxtsim/embed.ts
+++ b/pxtsim/embed.ts
@@ -1,10 +1,6 @@
 /// <reference path="../localtypings/pxtparts.d.ts"/>
 
 namespace pxsim {
-    export interface SimulatorMessage {
-        type: string;
-    }
-
     export interface SimulatorRunMessage extends SimulatorMessage {
         type: "run";
         id?: string;
diff --git a/pxtsim/langsupport.ts b/pxtsim/langsupport.ts
index 8593d58e5c0c..09c2a272cf06 100644
--- a/pxtsim/langsupport.ts
+++ b/pxtsim/langsupport.ts
@@ -356,6 +356,10 @@ namespace pxsim {
             return v | 0
         }
 
+        export function toUInt32(v: number) {
+            return v >>> 0
+        }
+
         export function toUInt8(v: number) {
             return v & 0xff
         }
diff --git a/webapp/src/app.tsx b/webapp/src/app.tsx
index 6d64e18326af..82e2a96d723f 100644
--- a/webapp/src/app.tsx
+++ b/webapp/src/app.tsx
@@ -37,7 +37,6 @@ import * as blocks from "./blocks"
 import * as codecard from "./codecard"
 import * as logview from "./logview"
 import * as draganddrop from "./draganddrop";
-import * as hwdbg from "./hwdbg"
 import * as electron from "./electron";
 
 type ISettingsProps = pxt.editor.ISettingsProps;
@@ -1109,11 +1108,14 @@ export class ProjectView
         return start.then(() => {
             simulator.driver.setHwDebugger({
                 postMessage: (msg) => {
-                    hwdbg.handleMessage(msg as pxsim.DebuggerMessage)
+                    pxt.HWDBG.handleMessage(msg as pxsim.DebuggerMessage)
                 }
             })
-            hwdbg.postMessage = (msg) => simulator.driver.handleHwDebuggerMsg(msg)
-            return hwdbg.startDebugAsync()
+            pxt.HWDBG.postMessage = (msg) => simulator.driver.handleHwDebuggerMsg(msg)
+            return Promise.join<any>(
+                compiler.compileAsync({ debug: true, native: true }),
+                hidbridge.initAsync()
+            ).then(vals => pxt.HWDBG.startDebugAsync(vals[0], vals[1]))
         })
     }
 
@@ -1894,7 +1896,6 @@ let myexports: any = {
     sim: simulator,
     apiAsync: core.apiAsync,
     showIcons,
-    hwdbg,
     assembleCurrent,
     log
 };
diff --git a/webapp/src/cmds.ts b/webapp/src/cmds.ts
index 5271f36f6346..7ed56d87de4b 100644
--- a/webapp/src/cmds.ts
+++ b/webapp/src/cmds.ts
@@ -1,7 +1,6 @@
 /// <reference path="../../built/pxtlib.d.ts"/>
 import * as core from "./core";
 import * as pkg from "./package";
-import * as hwdbg from "./hwdbg";
 import * as hidbridge from "./hidbridge";
 import Cloud = pxt.Cloud;
 
diff --git a/webapp/src/hidbridge.ts b/webapp/src/hidbridge.ts
index 2c9dc88d0bab..57a77b0368c7 100644
--- a/webapp/src/hidbridge.ts
+++ b/webapp/src/hidbridge.ts
@@ -64,26 +64,25 @@ export function shouldUse() {
 
 export function mkBridgeAsync(): Promise<pxt.HF2.PacketIO> {
     init()
-    return iface.opAsync("list", {})
-        .then((devs: any) => {
-            let d0 = (devs.devices as HidDevice[]).filter(d => (d.release & 0xff00) == 0x4200)[0]
-            if (d0) return new BridgeIO(d0)
-            else throw new Error("No device connected")
-        })
-        .then(b => b.initAsync().then(() => b))
+    let b = new BridgeIO()
+    return b.initAsync()
 }
 
 class BridgeIO implements pxt.HF2.PacketIO {
     onData = (v: Uint8Array) => { };
+    onEvent = (v: Uint8Array) => { };
     onError = (e: Error) => { };
     onSerial = (v: Uint8Array, isErr: boolean) => { };
+    public dev: HidDevice;
 
-    constructor(public dev: HidDevice) {
+    constructor() {
     }
 
     onOOB(v: OOB) {
         if (v.op == "serial") {
             this.onSerial(U.fromHex(v.result.data), v.result.isError)
+        } else if (v.op = "event") {
+            this.onEvent(U.fromHex(v.result.data))
         }
     }
 
@@ -118,10 +117,20 @@ class BridgeIO implements pxt.HF2.PacketIO {
     }
 
     initAsync() {
-        bridgeByPath[this.dev.path] = this
-        return iface.opAsync("init", {
-            path: this.dev.path
-        })
+        return iface.opAsync("list", {})
+            .then((devs: any) => {
+                let d0 = (devs.devices as HidDevice[]).filter(d => (d.release & 0xff00) == 0x4200)[0]
+                if (d0) {
+                    if (this.dev)
+                        delete bridgeByPath[this.dev.path]
+                    this.dev = d0
+                    bridgeByPath[this.dev.path] = this
+                }
+                else throw new Error("No device connected")
+            })
+            .then(() => iface.opAsync("init", {
+                path: this.dev.path
+            }))
     }
 }
 
diff --git a/webapp/src/hwdbg.ts b/webapp/src/hwdbg.ts
deleted file mode 100644
index 73ccee810c7e..000000000000
--- a/webapp/src/hwdbg.ts
+++ /dev/null
@@ -1,428 +0,0 @@
-import * as workspace from "./workspace";
-import * as data from "./data";
-import * as pkg from "./package";
-import * as core from "./core";
-import * as compiler from "./compiler"
-
-import Cloud = pxt.Cloud;
-import U = pxt.Util;
-
-let iface: pxt.worker.Iface
-let isHalted = false
-let lastCompileResult: pxtc.CompileResult;
-let haltCheckRunning = false
-let onHalted = Promise.resolve();
-let haltHandler: () => void;
-let cachedStateInfo: StateInfo
-let nextBreakpoints: number[] = []
-let currBreakpoint: pxtc.Breakpoint;
-let lastDebugStatus: number;
-let callInfos: pxt.Map<ExtCallInfo>;
-
-interface ExtCallInfo {
-    from: pxtc.ProcDebugInfo;
-    to: pxtc.ProcDebugInfo;
-    stack: number;
-}
-
-
-export var postMessage: (msg: pxsim.DebuggerMessage) => void;
-
-export interface MachineState {
-    registers: number[];
-    stack: number[];
-}
-
-function init() {
-    if (!iface) {
-        if (!Cloud.isLocalHost() || !Cloud.localToken)
-            return;
-        pxt.debug('initializing debug pipe');
-        iface = pxt.worker.makeWebSocket(`ws://localhost:${pxt.options.wsPort}/${Cloud.localToken}/debug`)
-    }
-}
-
-export function readMemAsync(addr: number, numwords: number) {
-    return workerOpAsync("mem", { addr: addr, words: numwords })
-        .then(resp => resp.data as number[])
-}
-
-export function writeMemAsync(addr: number, words: number[]) {
-    return workerOpAsync("wrmem", { addr: addr, words: words })
-        .then(() => { })
-}
-
-let asm = ""
-function callAndPush(prc: string) {
-    let idx = asm.length
-    asm += `
-    ldr r4, .proc${idx}
-    blx r4
-    push {r0}
-    b .next${idx}
-    .balign 4
-.proc${idx}:
-    .word ${prc}|1
-.next${idx}:
-`
-}
-
-let stateProcs = [
-    "pxt::getNumGlobals/numGlobals",
-    "pxtrt::getGlobalsPtr/globalsPtr",
-]
-
-
-interface StateInfo {
-    numGlobals: number;
-    globalsPtr: number;
-}
-
-function callForStateAsync(st: MachineState) {
-    if (cachedStateInfo) return Promise.resolve(cachedStateInfo)
-
-    asm = ""
-
-    for (let p of stateProcs) {
-        callAndPush(p.replace(/\/.*/, ""))
-    }
-
-    asm += `
-    bkpt 42
-    @nostackcheck
-`
-
-    return compiler.assembleAsync(asm)
-        .then(res => workerOpAsync("exec", { code: res.words, args: [] }))
-        .then(() => snapshotAsync())
-        .then(st => {
-            let fields = stateProcs.map(s => s.replace(/.*\//, ""))
-            fields.reverse()
-            let r: any = {}
-            fields.forEach((f, i) => {
-                r[f] = st.stack[i]
-            })
-            cachedStateInfo = r
-        })
-        .then(() => restoreAsync(st))
-        .then(() => cachedStateInfo)
-}
-
-function clearAsync() {
-    isHalted = false
-    lastCompileResult = null
-    cachedStateInfo = null
-    lastDebugStatus = null
-    return Promise.resolve()
-}
-
-function coreHalted() {
-    return getHwStateAsync()
-        .then(st => {
-            nextBreakpoints = []
-
-            let globals: pxsim.Variables = {}
-            st.globals.slice(1).forEach((v, i) => {
-                let loc = lastCompileResult.procDebugInfo[0].locals[i]
-                if (loc)
-                    globals[loc.name] = v
-                else
-                    globals["?" + i] = v
-            })
-
-            let pc = st.machineState.registers[15]
-
-            let final = () => Promise.resolve()
-
-            let stepInBkp = lastCompileResult.procDebugInfo.filter(p => p.bkptLoc == pc)[0]
-            if (stepInBkp) {
-                pc = stepInBkp.codeStartLoc
-                st.machineState.registers[15] = pc
-                final = () => restoreAsync(st.machineState)
-            }
-
-            let bb = lastCompileResult.breakpoints
-            let brkMatch = bb[0]
-            let bestDelta = Infinity
-            for (let b of bb) {
-                let delta = pc - b.binAddr
-                if (delta >= 0 && delta < bestDelta) {
-                    bestDelta = delta
-                    brkMatch = b
-                }
-            }
-            currBreakpoint = brkMatch
-            let msg: pxsim.DebuggerBreakpointMessage = {
-                type: 'debugger',
-                subtype: 'breakpoint',
-                breakpointId: brkMatch.id,
-                globals: globals,
-                stackframes: []
-            }
-            postMessage(msg)
-            return final()
-        })
-        .then(haltHandler)
-}
-
-function haltCheckAsync(): Promise<void> {
-    if (isHalted)
-        return Promise.delay(100).then(haltCheckAsync)
-    return workerOpAsync("status")
-        .then(res => {
-            if (res.isHalted) {
-                isHalted = true
-                coreHalted()
-            }
-            return Promise.delay(300)
-        })
-        .then(haltCheckAsync)
-}
-
-function clearHalted() {
-    isHalted = false
-    onHalted = new Promise<void>((resolve, reject) => {
-        haltHandler = resolve
-    })
-    if (!haltCheckRunning) {
-        haltCheckRunning = true
-        haltCheckAsync()
-    }
-}
-
-function writeDebugStatusAsync(v: number) {
-    if (v === lastDebugStatus) return Promise.resolve()
-    lastDebugStatus = v
-    return writeMemAsync(cachedStateInfo.globalsPtr, [v])
-}
-
-function setBreakpointsAsync(addrs: number[]) {
-    return workerOpAsync("breakpoints", { addrs: addrs })
-}
-
-export function startDebugAsync() {
-    return clearAsync()
-        .then(() => compiler.compileAsync({ native: true }))
-        .then(res => {
-            lastCompileResult = res
-            callInfos = {}
-
-            let procLookup: pxtc.ProcDebugInfo[] = []
-            for (let pdi of res.procDebugInfo) {
-                procLookup[pdi.idx] = pdi
-            }
-            for (let pdi of res.procDebugInfo) {
-                for (let ci of pdi.calls) {
-                    callInfos[ci.addr + ""] = {
-                        from: pdi,
-                        to: procLookup[ci.procIndex],
-                        stack: ci.stack
-                    }
-                }
-            }
-
-            let bb = lastCompileResult.breakpoints
-            let entry = bb[1]
-            for (let b of bb) {
-                if (b.binAddr && b.binAddr < entry.binAddr)
-                    entry = b
-            }
-            return setBreakpointsAsync([entry.binAddr])
-        })
-        .then(() => workerOpAsync("reset"))
-        .then(clearHalted)
-        .then(waitForHaltAsync)
-        .then(res => writeDebugStatusAsync(1).then(() => res))
-}
-
-export function handleMessage(msg: pxsim.DebuggerMessage) {
-    console.log("HWDBGMSG", msg)
-    if (msg.type != "debugger")
-        return
-    let stepInto = false
-    switch (msg.subtype) {
-        case 'stepinto':
-            stepInto = true
-        case 'stepover':
-            nextBreakpoints = currBreakpoint.successors.map(id => lastCompileResult.breakpoints[id].binAddr)
-            resumeAsync(stepInto)
-            break
-    }
-}
-
-export function snapshotAsync(): Promise<MachineState> {
-    return workerOpAsync("snapshot")
-        .then(r => r.state as MachineState)
-}
-
-export function restoreAsync(st: MachineState): Promise<void> {
-    return workerOpAsync("restore", { state: st })
-        .then(() => { })
-}
-
-export function resumeAsync(into = false) {
-    return Promise.resolve()
-        .then(() => writeDebugStatusAsync(into ? 3 : 1))
-        .then(() => setBreakpointsAsync(nextBreakpoints))
-        .then(() => workerOpAsync("resume"))
-        .then(clearHalted)
-}
-
-export interface HwState {
-    machineState: MachineState;
-    globals: number[];
-}
-
-export function waitForHaltAsync() {
-    U.assert(haltCheckRunning)
-    return onHalted
-}
-
-export function getHwStateAsync() {
-    let res: HwState = {
-        machineState: null,
-        globals: []
-    }
-    return snapshotAsync()
-        .then(v => {
-            res.machineState = v
-            return callForStateAsync(v)
-        })
-        .then(info => readMemAsync(info.globalsPtr, info.numGlobals))
-        .then(g => {
-            res.globals = g
-            return res
-        })
-}
-
-let devPath: Promise<string>;
-
-export function workerOpAsync(op: string, arg: any = {}) {
-    init()
-    if (!devPath)
-        devPath = iface.opAsync("list", {})
-            .then((devs: any) => {
-                let d0 = devs.devices[0]
-                if (d0) return d0.path
-                else throw new Error("No device connected")
-            })
-    return devPath
-        .then(path => {
-            arg["path"] = path;
-            return iface.opAsync(op, arg)
-        })
-}
-
-export function flashDeviceAsync(startAddr: number, words: number[]) {
-    let cfg: FlashData = {
-        flashWords: words,
-        flashCode: [],
-        bufferAddr: 0x20000400,
-        numBuffers: 2,
-        flashAddr: startAddr
-    }
-    return compiler.assembleAsync(nrfFlashAsm)
-        .then(res => { cfg.flashCode = res.words })
-        .then(res => workerOpAsync("wrpages", cfg))
-}
-
-export interface FlashData {
-    flashCode: number[];
-    flashWords: number[];
-    numBuffers: number;
-    bufferAddr: number;
-    flashAddr: number;
-}
-
-/*
-#define PAGE_SIZE 0x400
-#define SIZE_IN_WORDS (PAGE_SIZE/4)
-
-void setConfig(uint32_t v) {
-    NRF_NVMC->CONFIG = v;
-    while (NRF_NVMC->READY == NVMC_READY_READY_Busy);    
-}
-
-void overwriteFlashPage(uint32_t* to, uint32_t* from)
-{
-    // Turn on flash erase enable and wait until the NVMC is ready:
-    setConfig(NVMC_CONFIG_WEN_Een << NVMC_CONFIG_WEN_Pos);
-
-    // Erase page:
-    NRF_NVMC->ERASEPAGE = (uint32_t)to;
-    while (NRF_NVMC->READY == NVMC_READY_READY_Busy);    
-
-    // Turn off flash erase enable and wait until the NVMC is ready:
-    setConfig(NVMC_CONFIG_WEN_Ren << NVMC_CONFIG_WEN_Pos);
-
-    // Turn on flash write enable and wait until the NVMC is ready:
-    setConfig(NVMC_CONFIG_WEN_Wen << NVMC_CONFIG_WEN_Pos);
-
-    for(int i = 0; i <= (SIZE_IN_WORDS - 1); i++) {
-        *(to + i) = *(from + i);
-        while (NRF_NVMC->READY == NVMC_READY_READY_Busy);    
-    }
-
-    // Turn off flash write enable and wait until the NVMC is ready:
-    setConfig(NVMC_CONFIG_WEN_Ren << NVMC_CONFIG_WEN_Pos);
-}
-*/
-
-let nrfFlashAsm = `
-overwriteFlashPage:
-        cpsid i
-        push    {r4, r5, r6, lr}
-        movs    r5, r0
-        movs    r0, #2
-        movs    r6, r1
-        bl      .setConfig
-        movs    r3, #161        ; 0xa1
-        movs    r2, #128        ; 0x80
-        ldr     r4, .NRF_NVMC
-        lsls    r3, r3, #3
-        str     r5, [r4, r3]
-        lsls    r2, r2, #3
-.overLoop:
-        ldr     r3, [r4, r2]
-        cmp     r3, #0
-        beq     .overLoop
-        movs    r0, #0
-        bl      .setConfig
-        movs    r0, #1
-        bl      .setConfig
-        movs    r2, #128
-        lsls    r2, r2, #3
-        movs    r3, #0
-        movs    r1, r2
-.overOuterLoop:
-        ldr     r0, [r6, r3]
-        str     r0, [r5, r3]
-.overLoop2:
-        ldr     r0, [r4, r2]
-        cmp     r0, #0
-        beq     .overLoop2
-        adds    r3, #4
-        cmp     r3, r1
-        bne     .overOuterLoop
-        movs    r0, #0
-        bl      .setConfig
-        pop     {r4, r5, r6, pc}
-
-.setConfig:
-        movs    r1, #128
-        ldr     r3, .NRF_NVMC
-        ldr     r2, .v504
-        lsls    r1, r1, #3
-        str     r0, [r3, r2]
-.cfgLoop:
-        ldr     r2, [r3, r1]
-        cmp     r2, #0
-        beq     .cfgLoop
-        bx      lr
-
-
-                .balign 4
-.NRF_NVMC:      .word   0x4001e000
-.v504:          .word   0x504
-`
-