The Locked Machine: How Control Survives HackerRank's Desktop App

When your HackerRank invitation ships a .exe or .dmg instead of a link, the employer chose Desktop App Mode — HackerRank's strictest integrity setting — and the detection boundary moves from the browser to the operating system. The app takes over the machine for the session: other applications are blocked and can be force-closed, the screen is recorded in full, the webcam samples every 15 seconds, and the candidate is not even allowed to take their own screenshots. The natural question is whether an AI assistant can survive inside a locked machine at all, and the technical answer is that it depends entirely on which channel the assistant shows up in — and one of the five channels is winnable at a layer the desktop app's own monitoring does not reach.

This write-up is a technical analysis of that position. It reconstructs Desktop App Mode's five signal channels from HackerRank's documentation, works through how the full screen recording is actually produced at the OS level (this is the part most coverage skips), and then examines the specific mechanisms — WDA_EXCLUDEFROMCAPTURE on Windows, NSWindowSharingNone on macOS, and OS hit-test island windows — that let a desktop-native overlay be absent from the recording, absent from the app's window inventory, and absent from the focus event stream simultaneously. It then scores every competitor category — extensions, other desktop overlays, phones, VMs — against those channels, and closes the technical argument by examining why the resulting architecture is a moat: a stack of preconditions that browser-first and phone-first teams structurally lack. A verification protocol and a candid inventory of what the analysis does not cover come last, because in this mode the webcam is doing a lot of the work.

Scope, method, and evidence grades

Claims in this article are marked by their evidentiary status:

• Documented. Stated in HackerRank's candidate and recruiter documentation, or in Microsoft's and Apple's API references. Cited inline.
• Observed. Reproducible behavior of Control as shipped (island-window overlay, hit-test routing, companion dashboard). Described as product behavior.
• Inferred. Reasoning from documented OS behavior about what a given capture path includes. Stated as inference, with the condition that would falsify it.

The HackerRank passages that matter here are the candidate documentation for the Desktop App and the recruiter-side Desktop App Mode documentation. The full inventory of what the app requires, blocks, and records is covered in the Desktop App requirements guide; this article assumes you've read it and goes one layer deeper into how each control works mechanically.

What Desktop App Mode is, and why it's a different problem

HackerRank's Test Integrity documentation describes three modes — Secure, Proctor, and Desktop App — and Desktop App Mode is defined as Proctor Mode "plus operating-system-level monitoring." The recruiter documentation states the app is "available for Windows and macOS," prevents the test from running on a virtual machine, and that candidates must grant system permissions (webcam, and on macOS Screen Recording, System Events, and Accessibility) and close other applications, with a "Force Close All Apps" control available.

The architectural difference from browser-based modes is worth naming precisely, because everything else follows from it:

• In Proctor Mode, the proctor is a tenant. The exam runs in the browser; the proctoring sees what the page instruments plus a capture stream the candidate granted. The candidate's OS remains a neutral third party.
• In Desktop App Mode, the proctor is a resident. The desktop app is a native process with OS-level permissions. It records the full desktop, watches the webcam on a timer, blocks and force-closes other applications, enforces full-screen, disables the candidate's own screen capture, and logs "integrity events" whenever a control is triggered — "the system automatically flags and logs the activity," in the documentation's words.

Practical consequence for any assistant: the phone strategy that works in browser-based proctoring gets harder here (webcam still sees the glance, and the blocked-apps culture of the mode signals how closely the session is reviewed), and the extension strategy is dead on arrival — an extension doesn't survive a session where "messaging applications" are force-closed and the page owns the full screen. The surviving option is a native window, and only if it survives every channel the resident proctor watches. So: what channels are those?

The five signal channels of a locked session

Reading across the recruiter and candidate documentation, Desktop App Mode produces five distinct evidence channels, each with its own sensor and its own definition of "detected." An assistant survives the mode only if it is silent on all five — and the honest framing is that some channels are winnable, one is winnable with the right architecture, and one is only winnable with behavior.

Note the shape of the table: channels 2, 4, and 5 are about you — your face, your fingers, your code. Channel 1 is about pixels, and channel 3 is about processes and windows. An assistant's design problem, precisely stated, is: be absent from channels 1 and 3 by construction, and cheap to explain on channels 2, 4, and 5 by behavior. Every design choice below maps to that sentence.

Channel 1 in depth: how the "full recording" is actually made

This is the section most coverage of proctoring skips, and it is the one the whole analysis rests on. "The app records your screen" hides a specific pipeline.

There are no screen pixels

On Windows, a window's content is not stored somewhere as a screenshot of the display. The Desktop Window Manager (DWM) — a system composition service — holds the render state of every top-level window and composes the visible desktop on demand. When a capture client records the screen, it does not photograph a monitor; it asks the composition system for a rendered view, through one of several APIs (GDI BitBlt of the screen DC, DXGI desktop duplication, or the Windows.Graphics.Capture framework used by modern recorders). Each of these asks the DWM, and the DWM consults each window's properties when it renders.

On macOS, the window server plays the identical role. A recording client with the Screen Recording permission pulls frames from the window server's composite, and each NSWindow carries a sharingType that the window server enforces when it includes (or excludes) that window in captured output.

The operational fact on both platforms: inclusion of a window in the captured stream is a per-window property that the window's owner sets, enforced by the composition layer, upstream of any capture client. The recorder is downstream. It receives whatever the OS composites; it does not get a second vote on which windows count as part of the desktop.

The flags that change the composite

Two API calls, one per platform, are the load-bearing mechanism:

• Windows — SetWindowDisplayAffinity(hwnd, WDA_EXCLUDEFROMCAPTURE). Microsoft's reference for SetWindowDisplayAffinity documents WDA_EXCLUDEFROMCAPTURE as marking a window to be "excluded from desktop capture." The window remains visible on the monitor, fully interactive, and present in the user's field of view. It is simply not part of the image that capture APIs receive. The constant has existed since Windows 8.1; it is the same mechanism modern Windows uses to keep certain system surfaces out of recordings.
• macOS — NSWindow.sharingType = .none (NSWindowSharingNone). Apple's reference for NSWindowSharingType states that a window with this type is excluded from screen recordings and screen sharing while remaining visible and usable on the display.

The property that makes these decisive for proctoring: the exclusion happens before the capture client exists in the picture. The desktop app's recorder does not grab a frame and then fail to see the overlay. It receives frames — every frame, at full resolution, continuously — that contain the exam and nothing else, because the OS defined the desktop that way.

Why this is a different position than "hiding the overlay"

Three hiding strategies are available to software that doesn't control the flag, and each leaves a detectable signature in the recording:

• Low opacity. The overlay is faintly in every frame. In a continuous full recording — not the 15-second screenshot cadence of Proctor Mode — a semi-transparent rectangle that tracks your gaze is not subtle; it's a story.
• Off the recorded region. In Desktop App Mode the recorded region is the whole desktop in enforced full-screen. There is no region to hide outside of.
• Closed when the camera captures. There is no camera cadence to sync with — the recording is continuous. And timing-based hiding is visible as timing: the answer appears, then stops, in rhythm with nothing on screen.

The flagged-frame versus clean-frame distinction is even sharper here than in browser-based modes, because the recording is continuous and reviewed in replay. A redaction tells a reviewer "something was hidden"; a composite exclusion tells them nothing, because there is nothing in the material to point at. The recruiter's report — an integrity rating of High or Medium plus the replay — is built from exactly this material, so the goal is not to beat a detector. It is to generate material with no anomaly in it.

Channel 3 in depth: the app-control boundary

The second channel a native overlay must survive is the one Desktop App Mode adds over the browser: application control. The documentation states the app "Blocks the use of other applications during the test, including tools such as Cluely, video conferencing, messaging applications, or LLM applications," and that if "any control is bypassed, the system automatically flags and logs the activity."

Two things follow for an overlay's architecture:

1. The overlay must be a window, not an app the candidate interacts with as an app. A separate assistant application the user switches to is precisely the category the blocking targets. The design that avoids the switching event entirely is a set of always-present, hit-test islands: small windows that the OS routes clicks and keys through to the exam window beneath. The candidate never "goes to" the assistant. The assistant is scenery that happens to contain the answer, and the input stream shows exactly one focused application for the entire session — the desktop app.
2. Nothing may fire the documented controls. No Alt-Tab, no leaving full-screen, no candidate screen capture, no remote-access handshake. In Control, the assistant is driven by a global hotkey and a keyboard-adjacent flow — and by design, its "stealth mode" is a keyboard helper (the overlay's windows never change the exam window's input state), not an input-mode toggle, so activating or deactivating it costs zero events on the exam's side.

The residual risk on this channel is honest to state: "blocks the use of other applications" is documented at the level of switching to and interacting with apps. Inference: a passive, excluded, hit-test window that the exam's full-screen editor never yields focus to does not generate the events the documented controls listen for. The condition that would falsify it is a version of the desktop app that enumerates the window list and flags unknown top-level windows by name — your verification protocol below includes a check for exactly this, on your OS version.

Why phones, extensions, and other overlays can't survive this mode

The negative result is the point of the article, and it separates by tool class because each class dies in a different channel.

Extensions fail three channels at once. They are in the page's document (inspectable), they can't set window-composition flags (they own no window — the browser does, and the browser is the app under full-screen enforcement), and in a session where messaging and LLM applications are force-closed, an assistant riding on a blocked-or-scrutinized browser is a category error.

Other desktop overlays are the interesting case, because they have solved the obvious part. Several competing products now ship as desktop applications with the overlay outside the browser's rendering, and several have found the exclusion flag. Native-window status is the entry ticket, not the argument. Desktop App Mode grades the residue a window leaves in the system, and that is where the competing products separate.

• Platform fit comes first. The desktop app is documented for Windows and macOS only. As of our September 14, 2026 comparison, Cluely's desktop app ships for Mac and iOS with no Windows build — for a Windows Desktop App exam it is not a stealth question, it is a nonexistent product. Interview Coder, per our technical breakdown, is browser-based: its overlay is a DOM element in the page, visible to screen capture by definition, and its clickable UI steals focus from the exam window on click. Both are eliminated before channel 1 is measured.
• The flag's scope is a pricing and documentation question, not a physics question. Cluely's published capture claim is "completely hidden to meeting screen sharing software," gated to its $149.99/month tier. Whether it extends to an assessment platform's own recorder — the actual channel-1 path in this mode — is not stated on the site. The flag works the same wherever the OS composes; the question is whether the product sets it on its window, in that capture path, at the price you're paying.
• Window-state residue. The head-to-head tests documented in the Cluely comparison found the overlay present in the OS window state: listed as a selectable entry in Command-Tab, shown as a window on the desktop in Mission Control. Channel 1 does not care about that. Channel 3 does — the category of object a lockdown app is built to block is "other applications," and a window that registers itself as a switchable app is exactly the shape of evidence that control exists to catch. Control's islands are passive in the opposite way: the OS routes input through them, they do not surface as switchable app entries, and they never change the exam window's input state.
• Input-layer residue. The same comparison's tests found the exam page receiving the trigger's key events, and blur firing the moment the question was typed into the panel. Under Proctor Mode's 15-second screenshot cadence, those events are noise you can be lucky through. In this mode they land in a continuous recording and in the editor telemetry that already flags suspicious patterns "as potential external assistance" (channel 4). Control's hotkeys are consumed by a native input layer before the OS routes the keystroke to the frontmost application — the page never sees the chord.

The pattern underneath the list: a competing overlay typically owns one surface — pixels, or platform, or a pricing tier — while this mode grades all five channels simultaneously. Owning more of the mechanism is not the same as owning the whole record.

Phones and tablets dodge channels 1 and 3 entirely — nothing on the exam machine to see — and hand the problem to channel 2. The webcam samples every 15 seconds, does live presence checks, and flags devices in frame; gaze analysis of "eye and head movements" is documented, with "only high-confidence behavioral patterns" flagged. Sustained glances at a phone are exactly the kind of pattern a 15-second sampling cadence catches if the cadence lands right, and a reviewer replaying the session can check. The phone is a legal-but-taxing strategy in this mode; it converts a pixel problem into a performance problem, and the performance problem is graded by a camera on a timer.

Virtual machines are not a strategy at all — the app "prevents the test from running on a virtual machine" — which also closes off the "second clean machine" workaround many candidates reach for in lighter modes.

The window-exclusion mechanism is reachable only from a process that owns top-level windows with their own composition properties: a desktop-native application. That is the structural reason the trick belongs to this category of tool, and not to anything built inside the browser or on a second device — and the residue analysis above is the reason "desktop-native" alone is not sufficient.

How Control's architecture maps onto the channels

This is observed product behavior, not a projection of the mechanism onto a marketing claim:

• Channel 1 (screen recording): Control's overlay is a set of native island windows, each registered with the OS as excluded from capture — WDA_EXCLUDEFROMCAPTURE on Windows, NSWindowSharingNone on macOS. The exclusion is set per-window at composition time, so the desktop app's continuous recorder receives clean frames for the whole session. This is the product's core screen-share mechanism, documented in the technical deep dive on how Control works.
• Channel 3 (app control): the islands are OS hit-tested — clicks and keys pass straight through them to the desktop app's editor underneath. The exam window holds focus for the entire session; no switching, no blur, no full-screen exit. The overlay is summoned and driven by a global hotkey, and its stealth behavior is keyboard-driven by design: the overlay's windows never take over input, so toggling it produces no window-input events on the exam side.
• Channel 2 (webcam): the companion dashboard lets the candidate snapshot the question and pull the answer from a phone or tablet — so the exam machine's screen and the candidate's face can be pointed at the same problem instead of two different ones. (The device stays out of the 15-second frames; that discipline is yours, not the software's.)
• Channels 4 and 5 (typing and code models): no software fixes these; they are delivery problems. The overlay supplies the reasoning; your fingers still produce the keystroke record. The mitigations are behavioral and are listed in the setup section below.

The scoreboard: every competitor category against the five channels

This is the deep dive's answer laid out as a table: not "does tool X work," but where each tool class leaves residue on each channel. Evidence grades: competitor cells are from the dated head-to-head tests and published claims linked in the comparison sections; Control cells are observed behavior of the shipped desktop app, testable via the protocol below.

Read the "human factor" column as stated: no software writes it. It is you — typing cadence, gaze, code explainability. Every tool category lands on the same final mile; the differences between products live entirely in columns 1 through 4, and the only row that is silent on all four is the one built from windows up.

Why this is a moat

None of the mechanisms in this article are secret. WDA_EXCLUDEFROMCAPTURE sits in a Windows SDK header, NSWindowSharingNone in AppKit, and every competitor team has read the same documentation. A moat is not secrecy; it is a stack of preconditions, and here the stack is five layers deep:

1. A process that owns the window. The mechanism is per-window and is set by the window's owner. A team whose product is a renderer script (extension) or a second device (phone app) does not possess the object the flag attaches to. Reaching this layer means shipping a new desktop app per platform — a product rebuild, not a feature.
2. Windows designed to be excluded, on every claimed capture path. The flag must be set on the actual surfaces carrying the answer, and the claim must name the capture path and platform version rather than ending at "meeting screen sharing software." The engineering cost is small; the discipline cost is large, and it is where competitor claims stop.
3. A native input layer. The trigger must be consumed before the OS routes the keystroke to the frontmost application, with no modifier-chord leakage into the page. This is a separate subsystem from the window: a product can have the flag and still lose channel 4 on its own trigger key — the comparison's tests found exactly that residue.
4. Hit-test island architecture. Windows the OS routes input through — no switching events, no focus hand-off, no app presence in the switcher. That is a window-management design decision made before the first line of UI. Retrofitting it onto an app whose UX assumes the panel is an app you interact with is a rewrite of the UX, not a window-flag patch.
5. Verification discipline as a product. A per-platform, per-capture-path protocol that publishes what is verified, under which conditions, and what is inference — the protocol below is the same standard applied to the reader's own machine. A moat that doesn't know its own boundary is a hope, not a moat.

Each layer is individually feasible. The moat is the conjunction: all five must hold simultaneously against a proctor that grades all five channels, and the teams with distribution in this category — browser-first and phone-first — do not own the process that owns the windows. That is the structural reason the locked-machine segment is empty: not that the trick is hard, but that it is the intersection of five preconditions none of the incumbents were built to satisfy.

Verification protocol: prove it on a machine like the exam's

The desktop app blocks virtual machines, so the verification machine should be the actual exam machine — a physical Windows 10/11 or macOS 12+ system. Run this before the assessment, and record the date, OS build, and Control version, because a result is only valid under its own conditions:

1. Window inventory check. Open the overlay, then inspect the OS window list with a standard tool (e.g., a window-forensics utility, or on macOS the Accessibility inspector). Confirm the island windows exist as top-level windows, are marked excluded/non-sharing, and are owned by a plainly-named process. This is the check for the "flags unknown windows by name" falsifier from the channel-3 section.
2. Capture check. Because the desktop app disables candidate screen capture, verify with the closest equivalent you can stand up: a second physical machine filming the screen, or — before the actual test — the desktop app's own preview/camera-check phase if it shows you what it will record. In the frames, the overlay must be absent while visible to you, and the region behind it must show the desktop, not a black rectangle.
3. Focus check. Run Control's public focus test or any event-logging page, and operate the overlay entirely by hotkey. Expected result: zero blur, focus, or visibility events on the page, for the full session.
4. Blocking rehearsal. Install the desktop app from a practice invitation if the employer offers one, or rehearse the "close everything, force close, single display" sequence with Control left running, and confirm the app's setup phase does not flag or close it. This is the only step that tests channel 3 against the real binary — if the employer does not provide a practice run, ask, in writing, before the deadline.
5. Behavior pass. Ten minutes on a practice problem, webcam rolling, overlay in use. Review the playback as a hostile assessor: eye line, head position, typing rhythm, and the timing between "reading" and "typing." This is the channel no OS flag touches.

For a walkthrough of how the capture flags behave across different capture paths and their edge cases, the stealth overlay deep dive is the mechanism-level reference.

Recommended setup for a Desktop App Mode exam

1. The machine is the setup. One physical Windows or macOS display (multi-monitor and mirroring are documented flag triggers that must be disconnected, not hidden), everything unrelated force-closed, webcam framed on your face only. The documentation's "close all other applications" is not a suggestion the app waives.
2. Hotkey discipline. Choose a global hotkey the desktop app's editor does not claim, test it in the practice environment, and rehearse the full cycle — summon, read, dismiss — until it is one-motion. In a session with continuous recording, a fumbled hotkey is on film.
3. Pre-warm before the timer. Load the first question and complete one full round-trip during onboarding. The 15-second webcam cadence and the continuous recorder are both running by the time the timer starts; the only time an extra second of latency is invisible is before it.
4. Type at a human senior's cadence. "Read, think, type" with a visible pause, not "read, type." Editor telemetry flags unusual replacement speed and cursor behavior for review; the pause is what makes an assisted session look like a fast session.
5. Keep the phone a phone. The dashboard device pulls answers, it does not scroll. If a tablet appears in a 15-second frame, it gets flagged as a device in the webcam feed — and a flagged device plus a clean screen recording is a stranger combination than either one alone.

Residual risk, honestly inventoried

This mode is the strictest setting HackerRank documents, and the honest residual-risk list is longer than in browser-based proctoring:

• The webcam does most of the grading. Exclusion flags cover pixels the OS composites; they cover nothing the camera sees. Live presence checks, device detection, and the documented (limited-availability) gaze analysis all run on a 15-second cadence that no window property touches. If your eye line betrays a second information source, channels 1 and 3 winning is irrelevant.
• The app-control boundary is documented by behavior, not by API. "Blocks the use of other applications" is implemented by some combination of process and window monitoring; the documentation does not enumerate it. Inference: a passive, focus-preserving, excluded window is below the events the documented controls fire on. The verification protocol's step 4 exists because the binary is the only final authority on this.
• Remote-desktop and driver-level capture can bypass composition. If the desktop app's recording path ever runs through a remote channel or a GPU-driver-level source rather than standard composition, the exclusion flags may not apply. In the documented candidate experience the recording is local; if the employer's flow changes that, re-run step 2 against the actual path.
• Integrity ratings are holistic. The recruiter report carries a High or Medium rating built from all channels, plus a replay. A session can be clean on pixels and windows and still read as Medium if the behavior channels are noisy — or vice versa. The rating, not any single flag, is what the employer sees first.
• Policy outranks technology. Desktop App Mode is the mode employers select when they have decided to watch closely. If the assessment rules prohibit external assistance, a technically invisible session is still a rule violation if it ever surfaces. The ethics guide draws the line between concealment and permitted tool use, and the HackerRank proctoring signal inventory is the reference for what each mode contributes to the final report.

The short version

Desktop App Mode replaces the browser's polite window manager with a resident proctor: a native app that owns the display, records the whole desktop continuously, samples the face every 15 seconds, blocks and force-closes other applications, and logs every control it fires. Against that, extensions have no window to hide behind, phones have no privacy from the camera, and virtual machines are disallowed outright. The one channel with a structural escape is the recording — because the recording is not a photograph of a monitor, it is a composite the operating system produces, and the operating system will leave a window out of that composite on the window owner's say-so. WDA_EXCUDEFROMCAPTURE and NSWindowSharingNone are those say-sos. Set on a hit-tested, focus-preserving island window, they produce a session in which the proctor's own material contains no trace of the assistant: clean frames, one focused app, zero switching events. What remains — the face, the fingers, the code — is not a technology problem. It's a delivery problem, and it's the part you get to practice.

If your invitation is the browser-based flow instead, the companion analysis of HackerRank's browser proctoring channels covers the same mechanism at the lighter boundary.