How to Run an Android Emulator in Docker Without KVM (2026)

If you've tried to start an Android emulator on a cloud VM or a CI runner and hit /dev/kvm not found or KVM is required, you've run into the core problem: most cloud instances and CI runners don't expose nested virtualization. The good news is that hardware acceleration is optional. This guide covers the two real ways to run Android in Docker with no KVM, the exact commands, how to wire it into CI, and the errors you'll hit along the way.

Can you run an Android emulator without KVM?

Yes, two different ways — and they are not the same technology:

• Redroid (recommended for headless/CI): a container image that runs Android as a normal Linux process tree on your host kernel. It is not the QEMU-based SDK emulator and has zero KVM dependency. It runs on x86_64 and ARM64 hosts.
• Google SDK emulator in software mode: the official emulator binary can boot without acceleration using SwiftShader for the GPU and a software CPU path. Correct when you specifically need Google Play system images or the exact behavior of the official emulator — but expect slow boots and laggy interaction.

For automated testing, app smoke tests, and bulk device farms, Redroid is almost always the better no-KVM choice. For Play-Store-dependent flows on the official emulator, use software mode.

Redroid vs the SDK emulator: which no-KVM path?

How to run Redroid in Docker without KVM

Redroid ("remote android") publishes images on Docker Hub at redroid/redroid, covering Android 8.1 through 16. Because it runs the Android userspace on your host kernel, the host needs the binder and ashmem kernel modules — but it needs no virtualization extensions at all.

Step 1 — Load the kernel modules

On Ubuntu, pull in the extra modules for your running kernel, then load them:

sudo apt install linux-modules-extra-$(uname -r)
sudo modprobe binder_linux devices="binder,hwbinder,vndbinder"
sudo modprobe ashmem_linux

On newer custom kernels (5.0+) that build CONFIG_ANDROID_BINDERFS and ashmem in, the external modules aren't needed — Redroid will find them automatically.

Step 2 — Start the container

docker run -itd --rm --privileged --pull always \
  -v ~/redroid-data:/data \
  -p 5555:5555 \
  redroid/redroid:15.0.0-latest

The --privileged flag is required so the container can access binder/ashmem. The -v mount persists app data across restarts. Tags follow <version>.0.0-latest (for example 14.0.0-latest, 15.0.0-latest, 16.0.0-latest) plus _64only-latest variants — check Docker Hub for the current tag when you set this up.

Step 3 — Set resolution and GPU mode (optional)

Redroid defaults to gpu_mode=guest, which renders in software (ANGLE/SwiftShader). That's exactly what you want on a headless server with no GPU — no extra flags needed. To set a display size, append boot properties:

docker run -itd --rm --privileged \
  -v ~/redroid-data:/data -p 5555:5555 \
  redroid/redroid:15.0.0-latest \
  androidboot.redroid_width=1080 \
  androidboot.redroid_height=1920 \
  androidboot.redroid_dpi=480 \
  androidboot.redroid_gpu_mode=guest

How do you connect ADB and view the screen?

Redroid exposes ADB on port 5555. Connect and confirm the device, then mirror it with scrcpy:

adb connect localhost:5555   # use the remote IP for a cloud host
adb devices
scrcpy -s localhost:5555

From here it's a normal device: adb install app.apk, adb shell, instrumentation tests, the lot.

How do you run the SDK emulator without KVM?

If you must use the official emulator (for Play system images), boot it in software mode:

emulator -avd test_device \
  -no-accel \
  -no-window \
  -no-snapshot \
  -gpu swiftshader_indirect

-no-accel disables hardware CPU acceleration, -gpu swiftshader_indirect renders the GPU on the CPU, and -no-window runs it headless. It will boot — just slowly, because both CPU and GPU work happen in software. Use this only when Redroid can't satisfy your requirement.

How do you run an Android emulator in CI without KVM?

This is where the no-KVM question usually comes from. Two notes that save hours:

• Standard GitHub-hosted ubuntu-latest (x86_64) runners do now expose /dev/kvm — but you must fix group permissions first with a udev rule before launching the SDK emulator.
• GitHub-hosted ARM runners (ubuntu-24.04-arm) do not expose /dev/kvm. There, Redroid is the clean answer because it needs no KVM at all.

The KVM permission fix for the SDK emulator path:

echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' \
  | sudo tee /etc/udev/rules.d/99-kvm4all.rules
sudo udevadm control --reload-rules
sudo udevadm trigger --name-match=kvm

For the Redroid path in CI, you load the modules on the runner and start the container — no KVM, no nested virt:

sudo apt-get update
sudo apt-get install -y linux-modules-extra-$(uname -r)
sudo modprobe binder_linux devices="binder,hwbinder,vndbinder"
sudo modprobe ashmem_linux
docker run -itd --rm --privileged -p 5555:5555 redroid/redroid:15.0.0-latest
# give Android time to boot, then:
adb connect localhost:5555

Running on ARM cloud servers (Graviton, Ampere)

ARM64 instances (AWS Graviton, Ampere Altra, Apple-silicon hosts running Linux VMs) are a perfect fit for Redroid: pull an ARM Android image and it runs natively with no KVM and no Houdini translation layer. This is often the cheapest way to stand up a no-KVM Android device farm, since ARM compute is inexpensive and you skip the virtualization tax entirely.

Common errors and fixes

• failed to find binder device — the binder module isn't loaded. Run the modprobe binder_linux … command above, and install linux-modules-extra-$(uname -r) if modprobe can't find it.
• operation not permitted / permission denied — you're missing --privileged on the docker run.
• ADB shows the device as offline with gpu_mode=host — fall back to the default gpu_mode=guest (software rendering). Host GPU passthrough is fragile, especially on NVIDIA.
• App won't install (ABI mismatch) — you're on an x86 image installing an ARM-only APK (or vice versa). Match the image ABI to the APK, or use an ARM host image.
• SDK emulator hangs at boot — confirm you passed -no-accel and a software GPU flag; without them it waits for KVM that isn't there.

FAQ

Can I run an Android emulator without KVM?

Yes. Use Redroid (containerized Android, which never uses /dev/kvm), or run the official SDK emulator with -no-accel -gpu swiftshader_indirect. Redroid is much faster headless because it uses the real host kernel.

Does Redroid need KVM?

No. Redroid runs the Android userspace directly on the host Linux kernel through binder and ashmem. It has no QEMU layer and never touches /dev/kvm, which is why it works on cloud VMs and CI runners that lack nested virtualization.

How do I run an Android emulator in GitHub Actions?

For Redroid, load the binder/ashmem modules and docker run --privileged redroid/redroid. For the official emulator, use an x86_64 ubuntu-latest runner, add the KVM udev rule for group permissions, then launch with the android-emulator-runner action. Note that GitHub's ARM runners don't expose /dev/kvm.

Why is the no-acceleration emulator so slow?

Without KVM the CPU instructions are emulated in software, and with SwiftShader the GPU work is done on the CPU too. Everything runs in software, so boots and interactions are far slower than an accelerated emulator.

Can Redroid run on ARM servers like Graviton or Ampere?

Yes, natively, using ARM Android images — no KVM and no translation layer. ARM cloud instances are one of the cheapest ways to run a no-KVM Android device farm.

What kernel modules does Redroid require?

binder_linux and ashmem_linux. On kernels 5.0+ that build binderfs and ashmem in (CONFIG_ANDROID_BINDERFS), you don't need the external modules.

How do I see the Redroid screen?

Connect over ADB (adb connect ip:5555) and mirror the display with scrcpy -s ip:5555.