termux/proot-distro
Proot Distro
proot-distro is a rootless container runtime and Linux distribution manager that allows users to install and run isolated guest environments without requiring administrative root privileges. It utilizes PRoot to simulate root access and filesystem redirection, enabling the deployment of full Linux distributions in a non-root space.
The project functions as an OCI container image handler, capable of building, pulling, and pushing OCI-compatible images and manifests. It further serves as a cross-architecture execution layer, utilizing user-mode emulation to run binaries and containers built for different CPU architectures.
The tool covers a broad range of container lifecycle capabilities, including session monitoring and process-tree management to ensure clean shutdowns. It also provides data storage utilities for backing up, restoring, and synchronizing files between the host and guest environments.
Features
- PRoot-Based Isolation - Utilizes PRoot to simulate root access and filesystem redirection for isolated rootless environments.
- Syscall Interception Runtimes - Utilizes PRoot to intercept system calls via ptrace, simulating root privileges and filesystem redirection without administrative access.
- Compressed RootFS Packaging - Deploys Linux distributions by extracting compressed root filesystem archives into isolated local directories.
- Linux Environment Instance Management - Manages multiple independent Linux distribution instances, including session control and filesystem synchronization.
- Container Command Executors - Executes arbitrary shell commands and binaries inside a running container environment.
- Container Shell Sessions - Spawns interactive shell sessions inside installed containers for custom command execution.
- Container Entrypoint Execution - Executes the predefined entrypoint and command from an image manifest to simulate standard runtime execution.
- Container Image Layering - Implements a layered filesystem architecture for constructing guest environments following OCI specifications.
- Container Image Management - Installs rootless Linux containers by pulling images from registries or extracting local archives.
- Remote Image Pulling - Downloads container images from remote registries using a manifest-cache-first approach.
- Image Push-Pull Workflows - Implements workflows for building, pulling, and pushing OCI-compatible container images via remote registries.
- Execution Metadata Resolvers - Resolves entrypoints and working directories from image manifests to standardize command execution across distributions.
- OCI Container Engines - Acts as an OCI-compliant engine for building, pulling, and pushing container images in non-root environments.
- Unprivileged Image Building - Builds OCI-compatible container images from Dockerfiles in a rootless environment.
- Cross-Architecture Binary Analysis - Supports the execution of binaries built for different CPU architectures using user-mode emulation.
- Linux Distribution Container Execution - Deploys and executes full Linux distributions within isolated, rootless container environments.
- Rootless Deployments - Allows the deployment and running of full Linux guest environments without administrative root privileges.
- Linux Distribution Bootstrapping - Enables the bootstrapping of functional Linux distributions within a rootless subsystem.
- Guest Environment Managers - Manages the installation and running of rootless Linux distributions and isolated guest environments.
- User-Mode Emulation - Translates instructions from different CPU architectures through a user-mode emulation layer for cross-platform compatibility.
- Cross-Architecture Virtualization - Runs containers built for different CPU architectures using binary translation and user-mode emulation.
- Rootless Container Runtimes - Provides a runtime for executing isolated Linux guest environments without requiring administrative root privileges.
- CLI Entrypoints - Executes the predefined entrypoint and command from an OCI manifest to simulate standard runtime execution.
- Filesystem State Backups - Provides utilities to archive and restore the entire state of a container root filesystem.
- Checksum-Based Directory Syncs - Mirrors directories between host and container by copying only changed files based on checksums.
- Container Backup Tools - Archives the container root filesystem and manifest into a compressed tarball for backup.
- File Synchronization - Synchronizes files between two locations using size, modification time, or checksum comparisons.
- Container Lifecycle Management - Permanently removes container root filesystems and all associated data from the host machine.
- Container Lifecycle Signaling - Signals the guest process tree to terminate container sessions and prevent orphaned processes.
- Multi-Architecture Container Builds - Creates OCI-compatible container images targeting multiple hardware architectures.
- Container Restoration - Provides capabilities to archive container states and restore them to a root filesystem.
- Daemonless Container Image Building - Builds Docker-compatible images from Dockerfiles using a local build engine without requiring a root daemon.
- Recursive Process Termination - Tracks and terminates guest environments by recursively signaling all child processes to prevent orphaned background tasks.
- User Session Monitors - Monitors active container sessions by listing process IDs, users, and uptimes.
- Container File Transfers - Transfers files and directories between the host and containers or between separate containers.
- Container Inventory Management - Displays all containers currently available and stored on the local filesystem.
- Session Termination - Terminates entire process trees of running containers to ensure guest environments shut down cleanly.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
