@@ -801,6 +801,7 @@ declare namespace ts.pxtc {
         rawELF?: boolean;
         multiVariant?: boolean;
         size?: boolean;
+        noBoolLower?: boolean; // disable boolean condition lowering optimizations
     }
 
     interface CompileTarget {
 
@@ -28,6 +28,19 @@ namespace ts.pxtc {
         "pxt::switch_eq": "_pxt_switch_eq",
     }
 
+    // Boolean conversion fast paths, kept out of inlineArithmetic so the
+    // `noBoolLower` flag can drop the group (redirects and helper bodies alike).
+    const inlineBoolOps: pxt.Map<string> = {
+        "pxt::fromBool": "_pxt_fromBool",
+        "numops::toBool": "_numops_toBool",
+        "numops::toBoolDecr": "_numops_toBoolDecr",
+        "Boolean_::bang": "_pxt_boolean_bang",
+    }
+
+    function boolLowerEnabled() {
+        return !target.switches.noBoolLower
+    }
+
     // snippets for ARM Thumb assembly
     export class ThumbSnippets extends AssemblerSnippets {
         stackAligned() {
@@ -135,6 +148,8 @@ ${lbl}:`
         }
         call_lbl(lbl: string, saveStack?: boolean, stackAlign?: number) {
             let o = U.lookup(inlineArithmetic, lbl)
+            if (!o && boolLowerEnabled())
+                o = U.lookup(inlineBoolOps, lbl)
             if (o) {
                 lbl = o
                 saveStack = false
@@ -326,6 +341,100 @@ _numops_fromInt:
     ${this.callCPPPush("pxt::fromInt")}
 `
 
+            // skipped under `noBoolLower` flag: unreferenced helper text still costs image space
+            if (boolLowerEnabled())
+                r += `
+; Tag a raw 0/1 truth value into a boolean object (taggedTrue/taggedFalse).
+; Inverse of the toBool fast paths below; matches C++ pxt::fromBool.
+_pxt_fromBool:
+    @scope _pxt_fromBool
+    cmp r0, #0
+    beq .false
+.true:
+    movs r0, #${taggedTrue}
+    blx lr
+.false:
+    movs r0, #${taggedFalse}
+    blx lr
+
+; Logical NOT of a raw 0/1 truth value -> raw 0/1 (matches C++ bool bang(bool)).
+; Callers pass an already-tested condition, so this is raw-in / raw-out; value
+; context (x = !y) wraps the result with fromBool to re-tag it.
+_pxt_boolean_bang:
+    @scope _pxt_boolean_bang
+    cmp r0, #0
+    beq .true
+.false:
+    movs r0, #0
+    blx lr
+.true:
+    movs r0, #1
+    blx lr
+
+; Fast-path truthiness test: tagged value in r0 -> raw 0/1 in r0.
+; Value encodings (see taggedSpecialValue in emitter.ts): tagged int = (n<<1)|1
+; (low bit set); special tags = (n<<2)|2 with undefined=0, null, false, NaN,
+; true; heap objects have low 2 bits 00.
+; Only non-pointer values are decided inline here; any heap object is handed to
+; the C++ helper at .boxed (which also handles boxed numbers/strings like 0.0
+; and ""). INVARIANT: the falsy set below must match C++ numops::toBool exactly
+; -- if a new falsy tagged value is ever added, it must be added here too, or it
+; will fall through to .true.
+_numops_toBool:
+    @scope _numops_toBool
+    cmp r0, #0          ; undefined (0)            -> false
+    beq .false
+    cmp r0, #1          ; integer 0 ((0<<1)|1)     -> false
+    beq .false
+    lsls r1, r0, #31    ; odd => nonzero tagged int -> true
+    bne .true
+    cmp r0, #${taggedNull}   ; null  -> false
+    beq .false
+    cmp r0, #${taggedFalse}  ; false -> false
+    beq .false
+    cmp r0, #${taggedNaN}    ; NaN   -> false
+    beq .false
+    lsls r1, r0, #30    ; low 2 bits 00 => heap object -> defer to C++
+    beq .boxed
+.true:                  ; remaining specials (e.g. true) are truthy
+    movs r0, #1
+    blx lr
+.false:
+    movs r0, #0
+    blx lr
+.boxed:
+    ${this.callCPPPush("numops::toBool")}
+
+; Same truthiness classification as _numops_toBool (see comments above), but
+; this variant also consumes (ref-decrements) its argument. Only heap objects
+; are ref-counted, and those go through the C++ fallback which does the decr;
+; the inline non-pointer paths carry no refcount, so they need none.
+_numops_toBoolDecr:
+    @scope _numops_toBoolDecr
+    cmp r0, #0          ; undefined (0)            -> false
+    beq .false
+    cmp r0, #1          ; integer 0 ((0<<1)|1)     -> false
+    beq .false
+    lsls r1, r0, #31    ; odd => nonzero tagged int -> true
+    bne .true
+    cmp r0, #${taggedNull}   ; null  -> false
+    beq .false
+    cmp r0, #${taggedFalse}  ; false -> false
+    beq .false
+    cmp r0, #${taggedNaN}    ; NaN   -> false
+    beq .false
+    lsls r1, r0, #30    ; low 2 bits 00 => heap object -> defer to C++
+    beq .boxed
+.true:
+    movs r0, #1
+    blx lr
+.false:
+    movs r0, #0
+    blx lr
+.boxed:
+    ${this.callCPPPush("numops::toBoolDecr")}
+`
+
 
             for (let op of Object.keys(thumbCmpMap)) {
                 op = op.replace(/.*::/, "")
@@ -350,9 +459,10 @@ _cmp_${op}:
                 // the cmp isn't really needed, given how toBoolDecr() is compiled,
                 // but better not rely on it
                 // Also, cmp isn't needed when ref-counting (it ends with movs r0, r4)
+                const toBoolDecr = boolLowerEnabled() ? "_numops_toBoolDecr" : "numops::toBoolDecr"
                 r += boxedOp(`
                         bl numops::${op}
-                        bl numops::toBoolDecr
+                        bl ${toBoolDecr}
                         cmp r0, #0`)
             }
 
 
@@ -4165,7 +4165,43 @@ ${lbl}: .short 0xffff
         function emitExpressionStatement(node: ExpressionStatement) {
             emitExprAsStmt(node.expression)
         }
-        function emitCondition(expr: Expression, inner: ir.Expr = null) {
+        function emitCondition(expr: Expression, inner: ir.Expr = null): ir.Expr {
+            // with `noBoolLower` flag, the generic paths below handle every condition
+            const boolLower = !target.switches.noBoolLower
+            // Lower `&&` / `||` used as a condition into short-circuiting jumps
+            // that yield 0/1 directly, instead of boxing the intermediate
+            // booleans and converting them back with a runtime helper.
+            if (boolLower && !inner && !isStackMachine() && expr.kind == SK.BinaryExpression) {
+                const binary = expr as BinaryExpression
+                const op = binary.operatorToken.kind
+                if (op == SK.AmpersandAmpersandToken || op == SK.BarBarToken) {
+                    const shortCircuitLabel = proc.mkLabel("lazycond")
+                    const doneLabel = proc.mkLabel("lazycondfin")
+                    if (op == SK.AmpersandAmpersandToken) {
+                        proc.emitJmp(shortCircuitLabel, emitCondition(binary.left), ir.JmpMode.IfZero)
+                        proc.emitJmp(shortCircuitLabel, emitCondition(binary.right), ir.JmpMode.IfZero)
+                        proc.emitJmp(doneLabel, ir.numlit(1), ir.JmpMode.Always)
+                        proc.emitLbl(shortCircuitLabel)
+                        proc.emitJmp(doneLabel, ir.numlit(0), ir.JmpMode.Always)
+                    } else {
+                        proc.emitJmp(shortCircuitLabel, emitCondition(binary.left), ir.JmpMode.IfNotZero)
+                        proc.emitJmp(shortCircuitLabel, emitCondition(binary.right), ir.JmpMode.IfNotZero)
+                        proc.emitJmp(doneLabel, ir.numlit(0), ir.JmpMode.Always)
+                        proc.emitLbl(shortCircuitLabel)
+                        proc.emitJmp(doneLabel, ir.numlit(1), ir.JmpMode.Always)
+                    }
+                    proc.emitLbl(doneLabel)
+                    return captureJmpValue()
+                }
+            }
+            // Lower `!expr` used as a condition by negating the operand's
+            // condition directly, avoiding a boxed boolean just to invert it.
+            if (boolLower && !inner && !isStackMachine() && expr.kind == SK.PrefixUnaryExpression) {
+                const unary = expr as PrefixUnaryExpression
+                if (unary.operator == SK.ExclamationToken) {
+                    return ir.rtcall("Boolean_::bang", [emitCondition(unary.operand)])
+                }
+            }
             if (!inner && isThumb() && expr.kind == SK.BinaryExpression) {
                 let be = expr as BinaryExpression
                 let mapped = U.lookup(thumbCmpMap, simpleInstruction(be, be.operatorToken.kind))
 
@@ -68,6 +68,22 @@ export function assertAtLeast(asm: string, re: RegExp, min: number, what: string
     chai.assert(n >= min, "expected at least " + min + " " + what + ", found " + n);
 }
 
+/** Fails unless `re` matches the listing at most `max` times. */
+export function assertAtMost(asm: string, re: RegExp, max: number, what: string) {
+    const n = countMatches(asm, re);
+    chai.assert(n <= max, "expected at most " + max + " " + what + ", found " + n);
+}
+
+/**
+ * Listing up to _code_end: the program's own code, without the appended
+ * runtime helper text (whose bodies make their own C++ fallback calls).
+ */
+export function userCode(asm: string): string {
+    const i = asm.search(/^_code_end:/m);
+    chai.assert(i >= 0, "no _code_end marker in listing");
+    return asm.substr(0, i);
+}
+
 /**
  * Fails unless `actual` is within `pct` percent of `expected`. Bands are wide
  * on purpose: they catch silent large regressions in either direction without
@@ -87,30 +103,42 @@ function escapeRegExp(s: string): string {
 
 // --- per-case expectations -----------------------------------------------
 //
-// The *baseline cases pin how the compiler in this tree lowers specific
-// constructs, partly by asserting which specialized helpers are ABSENT from
-// the listing. They are the reference half of a differential pair: work that
-// specializes those constructs flips or extends these expectations alongside
-// its codegen change, and a mismatch in either direction is the signal (the
-// specialization silently stopped firing, or it appeared where it was not
-// expected). The helper names and label patterns asserted absent here are
-// therefore a naming contract with that work -- renaming an emitted helper or
-// thunk label means updating the patterns below in the same change.
+// The *baseline cases pin the emitted codegen in both directions: which
+// helpers the listing must contain and which it must not. Where an opt-out
+// compile switch exists, a `variantChecks` entry below compiles the same case
+// with the switch set and pins the codegen it restores; a mismatch in either
+// half is the signal. Helper and label names here are a naming contract with
+// the codegen -- renaming an emitted label means updating these patterns in
+// the same change.
 
 export const asmChecks: pxt.Map<AsmCheck> = {
 
     "boolbaseline.ts": (asm) => {
-        // Conditions are materialized as tagged values and narrowed by a call
-        // into the runtime at each test site.
-        assertAtLeast(asm, /bl numops::toBoolDecr/g, 12, "calls to numops::toBoolDecr");
+        // Boolean condition lowering emits thumb fast paths for the boolean
+        // conversion runtime calls.
+        for (const helper of ["_numops_toBool", "_numops_toBoolDecr",
+            "_pxt_fromBool", "_pxt_boolean_bang"])
+            chai.assert(hasLabel(asm, helper), "no " + helper + " helper in listing");
 
-        // Helpers introduced by boolean condition lowering. Absent here.
-        assertAbsent(asm, [
-            "_numops_toBool",
-            "_numops_toBoolDecr",
-            "_pxt_fromBool",
-            "_pxt_boolean_bang",
-        ]);
+        const code = userCode(asm);
+
+        // Every condition site narrows through the fast path; nothing in the
+        // program still calls the C++ entry point directly.
+        assertAtLeast(code, /bl _numops_toBoolDecr/g, 8, "calls to _numops_toBoolDecr");
+        assertNoMatch(code, /bl numops::toBoolDecr/g, "calls to numops::toBoolDecr");
+
+        // `&&` / `||` in condition position short-circuit to a raw 0/1 instead
+        // of building a tagged boolean. numops::toBool is only reached from
+        // that boxed path, so neither entry point is called at all.
+        assertNoMatch(code, /bl (numops::toBool|_numops_toBool)\b/g,
+            "calls to a toBool entry point");
+
+        // `!` in condition position is raw-in / raw-out, so its result is no
+        // longer re-tagged. The one remaining fromBool is the single `!` this
+        // case uses in value position (an argument), which must still box.
+        assertAtLeast(code, /bl _pxt_boolean_bang/g, 5, "calls to _pxt_boolean_bang");
+        assertAtMost(code, /bl (pxt::fromBool|_pxt_fromBool)\b/g, 1,
+            "calls to a fromBool entry point");
     },
 
     "ifacebaseline.ts": (asm) => {
@@ -156,6 +184,45 @@ export const asmChecks: pxt.Map<AsmCheck> = {
     },
 };
 
+// --- switch variants -----------------------------------------------------
+
+/**
+ * A case compiled a second time with extra compile switches and checked
+ * against different expectations -- the opt-out half of the differential
+ * pair described above asmChecks.
+ */
+export interface VariantCheck {
+    /** Case file in tests/thumb-test/cases. */
+    caseFile: string;
+    /** Merged over the case's normal switches. */
+    switches: pxtc.CompileSwitches;
+    /** Names the variant in the test title; keep it short. */
+    label: string;
+    check: AsmCheck;
+}
+
+export const variantChecks: VariantCheck[] = [
+
+    {
+        caseFile: "boolbaseline.ts",
+        switches: { noBoolLower: true },
+        label: "noBoolLower",
+        check: (asm) => {
+            // Conditions are materialized as tagged values and narrowed by a
+            // call into the runtime at each test site.
+            assertAtLeast(asm, /bl numops::toBoolDecr/g, 12, "calls to numops::toBoolDecr");
+
+            // The thumb fast paths are neither emitted nor called.
+            assertAbsent(asm, [
+                "_numops_toBool",
+                "_numops_toBoolDecr",
+                "_pxt_fromBool",
+                "_pxt_boolean_bang",
+            ]);
+        },
+    },
+];
+
 // --- external case programs ----------------------------------------------
 
 /**
 
@@ -8,7 +8,7 @@ import * as zlib from 'zlib';
 import "mocha";
 import * as chai from "chai";
 
-import { asmChecks, externalCases } from "./asmchecks";
+import { asmChecks, externalCases, variantChecks } from "./asmchecks";
 
 const testDir = path.join(process.cwd(), "tests", "thumb-test");
 const casesDir = path.join(testDir, "cases");
@@ -42,7 +42,8 @@ function loadFixtureText(): string {
     return zlib.gunzipSync(fs.readFileSync(fixturePath)).toString("utf8");
 }
 
-function optionsFor(fixtureText: string, programText: string): pxtc.CompileOptions {
+function optionsFor(fixtureText: string, programText: string,
+    switches?: pxtc.CompileSwitches): pxtc.CompileOptions {
     const opts: pxtc.CompileOptions = JSON.parse(fixtureText).options;
 
     opts.fileSystem[pxt.MAIN_TS] = programText;
@@ -52,6 +53,8 @@ function optionsFor(fixtureText: string, programText: string): pxtc.CompileOptio
     opts.target.switches = opts.target.switches || {};
     // Emits the code-size stats header at the top of the listing.
     opts.target.switches.size = true;
+    if (switches)
+        Object.assign(opts.target.switches, switches);
 
     return opts;
 }
@@ -108,6 +111,29 @@ describe("thumb codegen", () => {
         });
     });
 
+    // Second compile of a case with extra compile switches; see variantChecks.
+    variantChecks.forEach(variant => {
+        it("compiles " + variant.caseFile + " to thumb with " + variant.label, function () {
+            this.timeout(TIMEOUT_MS);
+
+            const casePath = path.join(casesDir, variant.caseFile);
+            chai.assert(fs.existsSync(casePath), "missing case " + casePath);
+
+            const programText = fs.readFileSync(casePath, "utf8");
+            const opts = optionsFor(fixtureText, programText, variant.switches);
+
+            const res = pxtc.compile(opts);
+            chai.assert(res.success,
+                "native compile of " + variant.caseFile + " with " + variant.label +
+                " failed:\n" + describeDiagnostics(res));
+
+            const asm = res.outfiles[pxtc.BINARY_ASM];
+            chai.assert(!!asm, "no " + pxtc.BINARY_ASM + " in compile result");
+
+            variant.check(asm, res);
+        });
+    });
+
     // Semantic case programs kept elsewhere in the tree; see externalCases.
     // They are compiled and assembled here, not executed.
     const externalPaths = Object.keys(externalCases).sort();
Original file line number	Diff line number	Diff line change
`@@ -801,6 +801,7 @@ declare namespace ts.pxtc {`
`801`	`801`	`rawELF?: boolean;`
`802`	`802`	`multiVariant?: boolean;`
`803`	`803`	`size?: boolean;`
	`804`	`+ noBoolLower?: boolean; // disable boolean condition lowering optimizations`
`804`	`805`	`}`
`805`	`806`
`806`	`807`	`interface CompileTarget {`