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:
| Package | Size | When it makes sense |
|---|---|---|
Microsoft Store .msix | bundled runtime | you want the Store to handle updates |
| full portable zip | ~830 MB, ~1.3 GB unpacked | no install, no download on first run |
installer .exe | ~1.3 GB | desktop and Start menu shortcuts, uninstall entry |
| light portable zip | 96 MiB, ~227 MB unpacked | try 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.

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
Six Amateurs, 1,113 Episodes, a Thousand Yuan of Compute an Episode: How an AI Drama Got Hand-Built
The first ten seasons of Armed Into Song run to roughly a thousand episodes and have passed ten billion cumulative views, with six core creators and not one of them film-school trained. Compute runs 1,000–2,000 yuan an episode; a normal shot takes three rolls, a battle twenty-plus, and anything that looks flat is graded a sixty and thrown out.
One server, one AI streamer: inside the code that runs a nightly livestream
open-yoki is the production code behind an AI host who streams nightly on Binance Square, with the persona, voice and money features stripped out. Headless Chrome draws the frame, ffmpeg pushes RTMP, a folder of Markdown decides what she feels and what she posts.
Pinky lets an agent drive your phone, and holds the Send button until you click Allow
Pinky connects any MCP agent to a real iPhone or Android phone and enforces approval in its own gateway rather than in a prompt. Banking apps are invisible, password fields are off limits, and on Android 13 the agent gets a hidden second screen.
ByteDance's SeedRealtime takes two frames a second and decides when to speak
Doubao-Seed-Realtime-1.0 folds camera frames, screen frames and speech into one full-duplex session, at no more than two frames per second. The interesting decisions are the frame rate, the proactive speaking, and the audit reply that ships switched on.