Top Related Projects
Termux - a terminal emulator application for Android OS extendible by variety of packages.
Main UserLAnd Repository
Anbox is a container-based approach to boot a full Android system on a regular GNU/Linux system
Quick Overview
LinuxDeploy is an open-source project that enables users to install and run various Linux distributions on Android devices without rooting. It provides a user-friendly interface for installing and managing Linux environments, allowing users to run desktop environments, servers, and command-line tools directly on their Android devices.
Pros
- Easy installation of Linux distributions on Android without rooting
- Supports multiple Linux distributions and desktop environments
- Provides a graphical user interface for easy management
- Allows running Linux applications and servers on Android devices
Cons
- Performance may be limited compared to native Linux installations
- Some advanced features may require root access
- Compatibility issues with certain Android devices or versions
- Limited storage space on Android devices may restrict Linux installations
Getting Started
- Download and install the LinuxDeploy app from the Google Play Store or F-Droid.
- Open the app and select your desired Linux distribution.
- Configure installation settings (e.g., installation path, user name, desktop environment).
- Click "Install" and wait for the process to complete.
- Once installed, click "Start" to boot up your Linux environment.
- Use the built-in VNC viewer or a third-party VNC client to access the Linux desktop.
For command-line access:
# Install a terminal emulator app (e.g., Termux)
# In the terminal, connect to the Linux environment
ssh username@localhost -p 22222
Replace "username" with the user you created during installation. The default port is 22222, but you can change it in the LinuxDeploy settings.
Competitor Comparisons
Termux - a terminal emulator application for Android OS extendible by variety of packages.
Pros of Termux
- More active development and larger community support
- Broader range of packages and tools available through its package manager
- Offers a more complete terminal emulator experience on Android
Cons of Termux
- Requires more technical knowledge to set up and use effectively
- May consume more system resources due to its comprehensive feature set
Code Comparison
LinuxDeploy:
#!/system/bin/sh
# LinuxDeploy bootstrap script
...
Termux:
#!/data/data/com.termux/files/usr/bin/sh
# Termux bootstrap script
...
Key Differences
LinuxDeploy focuses on deploying full Linux distributions on Android devices, while Termux provides a terminal emulator and Linux environment directly within Android. LinuxDeploy may offer more flexibility in choosing specific distributions, but Termux provides a more integrated and streamlined experience for running Linux tools on Android.
Both projects aim to bring Linux capabilities to Android, but they approach this goal differently. LinuxDeploy is better suited for users who need a complete Linux distribution, while Termux is ideal for those who want quick access to Linux tools and commands without the overhead of a full distribution.
Main UserLAnd Repository
Pros of UserLAnd
- More user-friendly interface, making it easier for non-technical users
- Supports a wider range of Linux distributions out-of-the-box
- Active development with frequent updates and community support
Cons of UserLAnd
- Larger app size and potentially higher resource usage
- May have fewer advanced customization options for power users
- Some features require in-app purchases
Code Comparison
UserLAnd uses Kotlin for its Android app, while LinuxDeploy primarily uses Java. Here's a brief comparison:
UserLAnd (Kotlin):
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
LinuxDeploy (Java):
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
Both projects aim to provide Linux environments on Android devices, but UserLAnd focuses on ease of use and a broader range of distributions, while LinuxDeploy offers more flexibility for advanced users. The choice between them depends on the user's technical expertise and specific requirements.
Anbox is a container-based approach to boot a full Android system on a regular GNU/Linux system
Pros of Anbox
- Provides a full Android system container, allowing for a more complete Android experience
- Supports running Android apps alongside native Linux applications seamlessly
- Offers better performance and integration with the host system due to its container-based approach
Cons of Anbox
- Requires more system resources due to running a full Android container
- Limited compatibility with some Android apps and games
- More complex setup process compared to LinuxDeploy
Code Comparison
LinuxDeploy (shell script):
#!/bin/sh
# LinuxDeploy installation script
set -e
...
Anbox (C++):
// Anbox main entry point
int main(int argc, char **argv) {
anbox::Runtime runtime;
return runtime.run(anbox::Runtime::Configuration{argc, argv});
}
LinuxDeploy focuses on deploying Linux distributions on Android devices using chroot, while Anbox aims to run Android applications on Linux systems using containers. LinuxDeploy is primarily written in shell scripts, making it easier to modify but potentially less performant. Anbox, written in C++, offers better performance but may be more challenging to customize for end-users.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Linux Deploy
Copyright (C) 2012-2019 Anton Skshidlevsky, GPLv3
This application is open source software for quick and easy installation of the operating system (OS) GNU/Linux on your Android device.
The application creates a disk image or a directory on a flash card or uses a partition or RAM, mounts it and installs an OS distribution. Applications of the new system are run in a chroot environment and working together with the Android platform. All changes made on the device are reversible, i.e. the application and components can be removed completely. Installation of a distribution is done by downloading files from official mirrors online over the internet. The application can run better with superuser rights (root).
The program supports multi language interface. You can manage the process of installing the OS, and after installation, you can start and stop services of the new system (there is support for running your scripts) through the UI. The installation process is reported as text in the main application window. During the installation, the program will adjust the environment, which includes the base system, SSH server, VNC server and desktop environment. The program interface can also manage SSH and VNC settings.
Installing a new operating system takes about 15 minutes. The recommended minimum size of a disk image is 1024 MB (with LXDE), and without a GUI - 512 MB. When you install Linux on the flash card with the FAT32 file system, the image size should not exceed 4095 MB! After the initial setup the password for SSH and VNC generated automatically. The password can be changed through "Properties -> User password" or standard OS tools (passwd, vncpasswd).
The app is available for download in Google Play and GitHub.
Features
- Bootstrap: Alpine, Arch, CentOS, Debian, Fedora, Kali, Slackware, Ubuntu, Docker or from rootfs.tar
- Installation type: image file, directory, disk partition, RAM
- Supported file systems: ext2, ext3, ext4
- Supported architectures: arm, arm64, x86, x86_64, emulation mode (ARM ~ x86)
- Control interface: CLI, SSH, VNC, X11, Framebuffer
- Desktop environment: XTerm, LXDE, Xfce, MATE, other (manual configuration)
- Supported languages: multilingual interface
FAQ
Do not work update operating environment or errors appear in debug mode: "Permission denied", "Socket operation on non-socket" or other.
Install compatible BusyBox in /system/xbin, add path /system/xbin in "Settings -> PATH variable", update the operating environment "Settings -> Update ENV". Before upgrading the environment, it is desirable restart the device. After that, the container options must be selected "Properties -> File system -> Auto" and "Propetries -> Image size (MB) -> 2000", because "busybox mke2fs" is not supperted an option "-t" to specify type of file system and not supperted image greater 2 GB. Now you can start a new installation "Menu -> Install".
Making an image on sdcard return an error "Read-only file system".
If you are using SuperSU utility you need to uncheck "mount namespace separation" in SuperSU settings. See documentation.
Installing an application on Google Play fails with the message "Unknown error code during application installation: -24".
You need to remove the application directory: /data/data/ru.meefik.linuxdeploy
Performance
SD card read / write speed (10 class) on Android (Samsung Galaxy S II) for file systems vfat, ext2, ext4:
- vfat: read speed 14.1 MB/s; write speed 12.0 MB/s
- ext2: read speed 14.9 MB/s; write speed 3.9 MB/s
- ext4: read speed 14.9 MB/s; write speed 16.6 MB/s
- ext2 (loop): read speed 17.0 MB/s; write speed 7.4 MB/s
- ext4 (loop): read speed 17.2 MB/s; write speed 8.8 MB/s
Installation time and use space on disk (Debian wheezy/armhf on Samsung Galaxy S II):
- Without GUI ~ 0:12 / 260 MB
- XTerm ~ 0:14 / 290 MB
- LXDE ~ 0:19 / 450 MB
- XFCE ~ 0:20 / 495 MB
- GNOME ~ 0:55 / 1.3 GB
- KDE ~ 1:20 / 1.3 GB
Links
Source code:
- Linux Deploy App: https://github.com/meefik/linuxdeploy
- Linux Deploy CLI: https://github.com/meefik/linuxdeploy-cli
Donations:
Top Related Projects
Termux - a terminal emulator application for Android OS extendible by variety of packages.
Main UserLAnd Repository
Anbox is a container-based approach to boot a full Android system on a regular GNU/Linux system
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot