Self-hosted service
remote-android/redroid-doc avatar
remote-android/redroid-doc

redroid versions itself by image tag, from Android 8.1 to 16

redroid (Remote-Android) is a multi-arch, GPU enabled, Android in Cloud solution. Track issues / docs here

7,157 stars504 forksShellLicense varies

At a glance

What is it?
redroid boots Android 8.1 through 16 as privileged containers on a Linux host, configured by androidboot arguments appended after the image name. Rendering defaults to software, Play services are not bundled, and the binder kernel modules have to be loaded by hand.
Who is it for?
redroid fits an engineer who needs many disposable Android instances on a Linux host for automated testing or phone virtualization, and who can load the binder kernel modules and keep port 5555 off a public network. It does not fit a Windows or macOS laptop, and it does not hand you an emulator with Play services or streaming already working.
Can I use it commercially?
Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
Is it still maintained?
Activity is slowing. The repository last received commits 6 months ago.
What is it written in?
Mainly Shell, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • remote-android/redroid-doc7,157 β˜… Β· +310
Star history
Repository2026-09-232026-11-15
remote-android/redroid-doc6.8k7.2k

310 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The image tag is the version, and latest will not stay put

There is no version file and no release history in this documentation repository. What you choose is the tag of the image you run, and the supported set is spelled out as a list: Android 16, 15, 14, 13 and 12, each with a 64 bit only variant, then Android 11, 10, 9 and 8.1. The quick start adds `--pull always`, which means a long lived data directory can find itself sitting under a newer Android build than the one it was created with, with no changelog in between to explain the move. Two architectures are covered, arm64 and amd64. What you cannot get from here is a rollback: the repository has no GitHub releases, and the docs document no way back, so stepping back means knowing an older tag yourself and pulling it deliberately.

binder modules decide whether the container lives or vanishes

redroid is not a self contained binary. It boots an Android userland inside a container that expects two kernel interfaces to exist on the host, and the documented path loads them by hand. Docker itself comes from its own documentation, linked at the top of the first block.

bash
## install docker https://docs.docker.com/engine/install/#server

## install required kernel modules
apt install linux-modules-extra-`uname -r`
modprobe binder_linux devices="binder,hwbinder,vndbinder"
modprobe ashmem_linux

## running redroid
docker run -itd --rm --privileged \
    --pull always \
    -v ~/data:/data \
    -p 5555:5555 \
    redroid/redroid:12.0.0_64only-latest

That run is detached, with a host directory mounted at /data so the instance keeps its files, and port 5555 published so adb can reach it. The same page warns against exposing that adb port on a public network, which matters more than usual because `--privileged` is not a narrow grant. The documented failures both point at the kernel rather than at Android. A container that disappears immediately means the modules are missing, and `dmesg -T` shows why. If the container runs but adb calls the device offline, the route is a shell inside it:

bash
docker exec -it <container> sh

then read `ps -A` and `logcat`, falling back to `dmesg -T` when no shell can be had at all. Collecting a bundle is one command, with the container name optional if it no longer exists:

bash
curl -fsSL https://raw.githubusercontent.com/remote-android/redroid-doc/master/debug.sh | sudo bash -s -- [CONTAINER]

That pipes a script out of the repository straight into a root shell, so it is worth reading `debug.sh` first.

Every setting is an androidboot argument after the image name

Configuration is not a file. Each knob is an androidboot argument appended after the image name, which is why the example that raises the display size repeats the entire run command and then adds three lines to it:

bash
## running redroid with custom settings (custom display for example)
docker run -itd --rm --privileged \
    --pull always \
    -v ~/data:/data \
    -p 5555:5555 \
    redroid/redroid:12.0.0_64only-latest \
    androidboot.redroid_width=1080 \
    androidboot.redroid_height=1920 \
    androidboot.redroid_dpi=480 \

The defaults come as a table: 720 wide, 1280 high, 320 dpi, and a frame rate of 30 when the GPU is enabled against 15 when it is not. That single split is the clearest sign that graphics are the decision to make first. The rest of the table covers DNS, where `androidboot.redroid_net_ndns` counts the servers and 8.8.8.8 is used when none is given, with `androidboot.redroid_net_dns<1..N>` naming each one. A four field proxy block follows: `type` choosing from `static`, `pac`, `none` or `unassigned`, then `host`, `port` defaulting to 3128, `exclude_list` as a comma separated list, and `pac`. Last comes `androidboot.redroid_gpu_node`, which auto detects. What the table withholds is any range or validation rule. No accepted value is given for width beyond the default, and nothing states what a misspelled parameter does at boot.

The default GPU mode is the software renderer

`androidboot.redroid_gpu_mode` takes `auto`, `host` or `guest`, and it defaults to `guest`, which the table defines as software rendering. Host mode is the GPU accelerated path, and `auto` hands the choice to detection. So the configuration you get on first contact is the slow one, and the frame rate default is quietly tied to that choice: 30 fps with the GPU enabled, 15 without it. Neither the quick start nor the example display block changes this. Nothing in the troubleshooting section covers a container that starts and then renders nothing, so the sensible first move after a boot is to pass `androidboot.redroid_gpu_mode=host` and watch whether the frame rate follows. The docs leave two gaps here. They do not list which GPUs, drivers or hosts host mode was checked against, and they give no way to read the active mode back out of a running instance.

ashmem is deprecated and the memfd switch is still off

The quick start loads `ashmem_linux`, and the configuration table calls that same interface deprecated. The replacement exists and is not the default: `androidboot.use_memfd` swaps `memfd` in for `ashmem`, is marked as planned to become the default, and ships as false. Following the documented path step by step therefore means loading a module the same page has already retired, unless you pass the switch yourself. No error text is given for a host kernel where the older interface is missing, so that failure can only be read out of `dmesg -T` after the container has exited. The two data flags share a shape worth noticing, because both are off by default and both change how the data partition is backed rather than what runs inside it. That makes them the part of redroid most likely to need a deliberate choice rather than the shipped one.

overlayfs turns one data directory into a shared base and a private diff

`androidboot.use_redroid_overlayfs` is set to 0, and setting it replaces a plain data partition with an overlayfs one split across two paths: `/data-base` holds the data that instances share, and `/data-diff` holds what each one keeps to itself. In the quick start there is no such split, since a single host directory mounted at /data is all you get. That is the right shape for one throwaway instance and the wrong shape for a pool where shared files should not be rewritten by every container that boots. The docs name both directories and stop there. They do not describe how to move an existing /data into the base and diff layout, do not say what happens when the two disagree, and do not say which of them a running instance treats as writable. Turning this on under an existing data directory is a migration you do yourself.

Arm apps on x86 need a bridge tarball placed by hand

An arm binary on an amd64 instance needs a translation layer, and three are named: `libhoudini`, `libndk_translation` and a QEMU translator. The published images already ship `libndk_translation`, so the common case needs no work, and what remains is a tarball you add yourself. The layout given for it is a system tree with per architecture directories and the bridge library present in both lib and lib64:

bash
# example structure, be careful the file owner and mode

system/
β”œβ”€β”€ bin
β”‚   β”œβ”€β”€ arm
β”‚   └── arm64
β”œβ”€β”€ etc
β”‚   β”œβ”€β”€ binfmt_misc
β”‚   └── init
β”œβ”€β”€ lib
β”‚   β”œβ”€β”€ arm
β”‚   └── libnb.so
└── lib64
    β”œβ”€β”€ arm64
    └── libnb.so

The warning about file owner and mode is the only constraint stated, and no correct value is given for either, which is what makes this awkward under a particular umask. The tarball then goes into a derived image:

dockerfile
# Dockerfile
FROM redroid/redroid:11.0.0-latest

ADD native-bridge.tar /

and the build and run are ordinary Docker steps, pointed at a different data directory from the stock one:

bash
# build docker image
docker build . -t redroid:11.0.0-nb

# running
docker run -itd --rm --privileged \
    -v ~/data11-nb:/data \
    -p 5555:5555 \
    redroid:11.0.0-nb \

The base image there is Android 11 while the quick start uses Android 12, so the two examples are not meant to be pasted together. Two things stay unanswered: when to reach for `libhoudini` rather than `libndk_translation`, and how to confirm the bridge is in use, since `binfmt_misc` appears in the tree with no command shown that registers it.

Play services, WebRTC and the build recipe sit in another repository

Three things a reader tends to expect are pointed elsewhere. Google Play services are not in the image: they can be added through Open GApps, MicroG or MindTheGapps, and the procedure lives in the `android-builder-docker` directory rather than in the published tags. Streaming is not there either. WebRTC support is written as a plan to port the frontend, the backend and a set of virtual HALs from cuttlefish, so there is nothing to switch on today. Building the image follows the AOSP process, with the same suggestion to do it inside Docker, again by way of `android-builder-docker`. That leaves this repository as the manual: a README, a Simplified Chinese README, the `deploy` directory for distributions other than Ubuntu 20.04, an `assets` directory, and `debug.sh`. It is a documentation tree with one script in it.

Editorial conclusion

redroid fits an engineer who needs many disposable Android instances on a Linux host for automated testing or phone virtualization, and who can load the binder kernel modules and keep port 5555 off a public network. It does not fit a Windows or macOS laptop, and it does not hand you an emulator with Play services or streaming already working. Before you commit, check that your kernel offers binder_linux, decide who may reach the adb port, and confirm whether the apps you care about are arm binaries that need a native bridge. Then read the licence of the image you build: redroid is under the Apache License, its kernel modules are under GPL v2, and the docs warn that many third party modules are bundled in.

Frequently asked questions

What is Redroid?

Redroid (Remote-Android) is a GPU accelerated Android in Cloud solution that boots many instances on a Linux host through Docker, podman or Kubernetes, on both arm64 and amd64. Published images cover Android 8.1 through 16, and each instance is configured with androidboot arguments appended to the run command rather than with a config file.

How do I run an Android emulator in Docker with redroid?

Redroid is a container rather than an emulator, so nothing has to be emulated. Load the binder kernel modules on the host, then run a privileged container with a data volume mounted at /data and port 5555 published for adb. The quick start is written for Ubuntu 20.04, with other distributions covered in the deploy directory.

Does redroid include Google Play services?

No. Play services are added separately through Open GApps, MicroG or MindTheGapps, and the steps are kept in the android-builder-docker directory instead of the published images. Any app that depends on Play services therefore needs an image you build yourself before it will run.

Official sources

  1. Issues
  2. README
  3. remote-android/redroid-doc on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/remote-android-redroid-doc.svg)](https://hysenlabs.com/projects/remote-android-redroid-doc)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/remote-android-redroid-doc.svg)](https://hysenlabs.com/projects/remote-android-redroid-doc)

Was this useful?