← Back to blog
AiAbout 6 min read

Double-click an APK, get a Windows app: ApkStart treats each Android app as a window

Published Nov 21, 2026
Double-click an APK, get a Windows app: ApkStart treats each Android app as a window

Most Android-on-Windows solutions ask you to open a launcher, click an app, and accept that you are inside an emulator. ApkStart, a project by RoutineMiku that reached 8,815 stars after appearing on 29 October 2026, makes a different bet: the emulator should never be the interface.

You double-click an .apk in File Explorer. It parses the package, installs it, extracts the icon, and drops a shortcut on the desktop. From then on you double-click the icon like any other program. A window opens with the app's own icon in the title bar and the app's own name in the taskbar.

The program behind the window is still an Android emulator. The trick is that you stop seeing one.

What actually gets installed

There are four distribution shapes, and they exist for different reasons:

PackageSizeWhen it makes sense
Microsoft Store .msixbundled runtimeyou want the Store to handle updates
full portable zip~830 MB, ~1.3 GB unpackedno install, no download on first run
installer .exe~1.3 GBdesktop and Start menu shortcuts, uninstall entry
light portable zip96 MiB, ~227 MB unpackedtry it first, fetch the runtime on launch

The shell itself has zero third-party dependencies. ZIP, PNG, ICO and Android's binary XML format are all parsed with hand-written code, which is why the light portable build fits in 96 MiB while carrying a UI and an installer. The Android runtime is pulled in on demand and reclaimed when idle, or reused if you already have one on the machine.

That last option is worth pausing on. If you already run an Android emulator with API 34, ApkStart can attach to it instead of shipping a second copy of the same system image. The extra disk cost becomes zero.

The orientation problem, solved at install time

Here is the detail that explains why this project is more interesting than it looks.

An Android emulator has a physical panel orientation, set by hw.lcd.width and hw.lcd.height. When the panel is landscape and the app declares portrait, Android gives the app a letterboxed strip in the middle with black bars on both sides. Resizing the window does not help. wm size does not help. Letterbox styling does not help. The author tried all of them and left notes in src/core/apk.js.

So ApkStart reads AndroidManifest.xml offline at install time, weighs the launcher activities, and decides whether the app is natively portrait or landscape. Apps that declare only sensor or fullSensor get asked once at first launch. The answer goes into apps.json, and the runtime starts with the matching panel: 720×1280 portrait for something like a short-drama app, 1280×720 landscape for a reader.

Only the first launch in a mismatched orientation costs a runtime restart, about 40 seconds with a notice in the title bar. After that, apps of the same orientation open instantly, and a rotate button in the title bar remembers the choice per app.

Why 190 dpi is a product decision

The second half of that trick is density.

A 720-wide panel at 190 dpi is 606 dp of logical width. Android's tablet breakpoint is 600 dp. Cross it, and an app that ships a two-column tablet layout will actually draw it: split settings panes, double-column episode grids. The stock emulator image runs at 320 dpi, which gives 360 dp, which is a phone layout.

That single number is the difference between "an Android app in a small window" and "an Android app that uses the window it was given". It is exposed as a "tablet layout" switch, on by default, and it is the kind of decision that only gets made by someone who wanted to read a comic or watch a drama on a monitor.

A ruled wooden board with a single rectangular window cut into it, a small phone-sized frame resting behind the cutout.

Window handling has the same flavour. The app runs in windowed mode because headless Android has no VSYNC, and a headless app is alive but renders nothing. ApkStart takes that window, retitles it, swaps in the real icon, sizes it to the phone aspect, and centres it. Full screen fills the height without stretching. Windowed mode is draggable and resizable, and remembers size per app.

Networking without a virtual adapter

Android inside QEMU normally means a virtual network interface on the host. ApkStart goes through QEMU's user-mode NAT instead, so traffic leaves through the host's physical adapter. Nothing appears in Network Connections. No driver, no bridge, no second IP.

For a tool aimed at people who just want to run an app, that is the correct amount of networking: invisible.

The shared folder follows the same logic. %USERPROFILE%\ApkStartShared maps to /sdcard/ApkStartShared and syncs both ways, so a file an app saves shows up in Explorer without an export step.

An updater that measures before it downloads

The update path is where the project stops being a hobby and starts being a small piece of infrastructure.

Instead of pointing at GitHub and hoping, the client asks both GitHub and Gitee for the latest version and takes the higher one, so one blocked source cannot stall the update. Then it builds a candidate list: direct source, the same asset on the other host, mirror prefixes. It downloads 256 KB from each candidate and measures throughput after the first byte arrives, because a handshake-inclusive measurement misranks high-latency, high-bandwidth mirrors as slow. The fastest candidate gets the download, chunked and parallel, with automatic failover.

The light portable package is compressed with 7-Zip deflate at maximum settings to land at 95.0 MB, because Gitee caps attachments at 100 MB. That constraint produced a better package.

Replacement runs through a separate PowerShell script that waits for the main process to exit, overwrites the program directory, and relaunches. Application data and runtime live outside the program directory, so an update does not delete installed apps or snapshots.

What it is not

The README is unusually candid: early version, a hobby project built on evenings and weekends, free, no ads, "not very good to use yet". Take that seriously.

It is an emulator wrapper, so anything that detects emulation will still detect it. Apps with hardware-backed DRM, banking apps with root and emulator checks, and games with anti-cheat are not the target. Boot time is not instant: a cold runtime start plus the 18-second liveness check means the first launch of a session is slow, and a mismatched orientation adds a restart on top.

The 18-second liveness probe is a nice detail in itself. If an app crashes on launch, ApkStart retries, resets app data if needed, and grants the runtime permissions the app requested so it does not hang on a system dialog.

Why this is worth a look

There is a category of software that never gets written because the platform vendors do not care: running the two or three Android apps you actually use, on the desktop you actually work on, without a launcher in the way.

ApkStart is that, assembled from manifest parsing, one density constant, a NAT decision, and an updater that measures the network instead of trusting it. None of those are new ideas. The combination makes an emulator disappear, which is the whole product.

Related articles