Actual Virtual Machines Come to Android via UserLAnd

For years, UserLAnd (and its predecessor GNURoot) has had one job: get a real Linux distribution running on your Android phone or tablet, with no root, no unlocked bootloader, and no PC involved. The engine behind that has always been proot - a clever piece of software that fakes a Linux root filesystem on top of Android's own kernel.

Clever, but faking it has limits. So we added a second engine. Starting with this release, UserLAnd can run your distro inside an actual virtual machine - a separate Linux kernel, booted on your device, using the same hardware virtualization the OS itself uses.

You pick it per filesystem, right where you always chose your connection type. The dropdown now reads:

• Standard (proot) - the classic UserLAnd experience, on every device
• Virtual Machine (pro) - a genuine VM, on devices that support it

What proot actually does - and why it hits a wall

proot doesn't create a Linux system. It intercepts your programs' system calls one at a time and rewrites them on the fly, so that when Debian's apt asks for /etc/apt/sources.list, it quietly gets a file inside UserLAnd's private app directory instead. Every path is translated. Every "root" operation is pretended at. Underneath, you are still an ordinary, unprivileged Android app talking to Android's kernel.

That design is why UserLAnd works at all without root, and it deserves enormous credit. But it also means:

• Every syscall pays a toll. Interception adds overhead to file and process operations — the exact things package managers, compilers, and build systems do millions of times.
• You are not really root. You can't mount filesystems, load kernel modules, create network namespaces, or manage devices. Software that expects those things — containers, some daemons, anything that touches the kernel directly — simply doesn't work.
• Android's rules are still your rules. SELinux policy, the phantom-process killer, background execution limits, and the kernel's own restrictions apply to everything running inside your "Linux" session, because it isn't a separate system.
• Isolation is thin. Your Linux processes are Android processes wearing a costume. They share the host kernel with everything else on the device.

What a virtual machine changes

The new backend is built on the Android Virtualization Framework (AVF) and pKVM, the protected hypervisor built into modern Android devices. UserLAnd boots a real Linux kernel with your distribution's root filesystem on a virtual disk. Nothing is intercepted or rewritten, because nothing needs to be — inside the VM, Linux is just Linux.

Concretely, that buys you:

• Real root, real kernel. Mounting filesystems, loading modules, namespaces, cgroups, raw sockets, device nodes — the whole kernel surface is yours, because it's your kernel. Software that flatly refused to run under proot has a real chance here.
• Native syscall speed. No ptrace interception in the hot path. Compiles, package installs, and anything filesystem-heavy stop paying the translation tax.
• Real isolation. A VM is a hardware-enforced boundary. Whatever you install, break, or experiment with inside your distro is contained by the hypervisor. Wreck the guest and Android doesn't blink — and the repair option rebuilds the disk from scratch.
• Freedom from Android's process rules. Your VM's processes aren't Android processes. Android's app lifecycle policies don't reach inside them.
• A predictable machine. A stock kernel and a normal disk means normal Linux behavior — the kind that matches the documentation instead of a footnote about "unless you're on proot."

How it feels to use

Almost exactly like UserLAnd always has, which was the whole point.

You still tap a filesystem, you still get a terminal or desktop the same way you always did. What's different is what's underneath, plus a handful of new controls that only a real VM can offer:

• Per-launch CPU and RAM. The connection dialog now has a "Use all CPU cores" checkbox and a memory slider, bounded by what your device actually has. Give a build job every core and half your RAM; give a background shell far less. It's a choice you make each launch, not a buried global setting.
• Optional Android storage sharing. Tick "Share Android storage" and your device's shared storage is mounted inside the guest at /sdcard. Leave it unticked and the VM is fully sealed off from your files. Also a per-launch choice.
• Sound and microphone. Audio works in VM sessions, matching what proot sessions have.
• Roomy disks. Each VM filesystem gets a 32 GB sparse ext4 image that only consumes what you actually use.
• The same distros. Debian, Ubuntu, Kali, Arch, and Alpine, with desktop flavors like XFCE and LXDE, pulled as standard OCI images.

Requirements, honestly stated

Hardware virtualization isn't available everywhere, and we'd rather tell you up front than let you find out halfway through a download. The VM option appears only when your device genuinely supports it:

• Android 14 or newer. Custom VM images simply don't exist as an OS feature before that.
• A 64-bit ARM device. pKVM is ARM64-only.
• An OEM that shipped virtualization support. UserLAnd checks the device's own virtualization feature flag rather than guessing from a model list, so the answer is your manufacturer's, not ours.

There's also a one-time setup wizard. The VM engine lives in a small companion app, UserLAnd VM, which needs permissions Android only grants over ADB. The wizard walks you through enabling Developer Options and Wireless Debugging, pairs with your own device locally using a 6-digit code, then installs and configures the companion app for you. Nothing leaves your device and no PC is required — UserLAnd talks to itself over the loopback interface. You'll see exactly what's being installed and what it's being granted before anything happens, and you can cancel.

The Virtual Machine backend is a pro feature. proot remains free, unchanged, and fully supported.

So should you switch?

Not always — and that's why both engines ship side by side, selectable per app.

Stay on proot when your device is older, isn't ARM64, or is short on RAM. For a quick shell, a text editor, or a Python script, proot is still an excellent answer.

Reach for the VM when you're compiling something big, running services or containers, doing security work that needs real kernel features, or you simply want a Linux box that behaves like a Linux box. That's the ceiling proot could never raise — and it's gone now.

Grab the update, create a new filesystem, and look for Virtual Machine in the execution backend list. If your device can do it, so can you.