Atlas

Atlas is a modularization system and dynamic component framework for Android. It functions as a class isolation layer and incremental update engine, allowing application logic and resources to be decoupled into independent bundles that are loaded at runtime.

The project distinguishes itself by providing physical bundle isolation through custom class loaders to prevent dependency conflicts and bypass method count limits. It enables the deployment of remote components and incremental patches, using bytecode diffs and resource patching to update specific application parts without requiring a full binary reinstall.

The framework covers a broad range of capabilities including on-demand module loading, remote component fetching, and lifecycle management for dynamic bundles. It also provides tools for baseline package versioning and a development workflow that allows for the independent debugging of individual modules.

The system optimizes app startup by utilizing interpreted-first execution to reduce initial launch latency.

Features

Classloader Isolation - Implements custom class loader isolation to maintain separate namespaces for application bundles and prevent dependency conflicts.
Android Class Namespace Isolation - Acts as a class isolation layer that routes class lookups through custom loaders to maintain separate namespaces.
Application Component Hotfixes - Delivers rapid updates and hotfixes to specific application components without requiring a full installation.
Application Bundle Patching - Provides the ability to push incremental code and resource patches to specific bundles without a full application reinstall.
Remote Application Bundles - Downloads and initializes functional bundles from a remote server at runtime to avoid initial bundling.
Application Updaters - Replaces specific application bundles with patched versions to enable incremental updates without a full reinstall.
Bundle Isolation - Groups features into independent containers with their own dependencies to prevent class conflicts and bypass method limits.
Layered Incremental Deployments - Generates and deploys bytecode diffs to update only changed classes and resources for rapid hot-fixes.
Binary Diff Patching - Produces small update packages by including only changed components to reduce data transfer during deployment.
Android App Modularization - Organizes large applications into independent modules with their own lifecycles to simplify development for large teams.
Android Application Update Systems - Pushes small code and resource patches to specific application components without requiring a full binary reinstall.
Android Binary Patching Engines - Deploys bytecode diffs and resource patches to update specific application components without a full reinstall.
Android Plugin Frameworks - Provides a framework for loading external business logic and resources into an Android application without modifying the main binary.
Dynamic Feature Deployment - Updates application features via patch packages without requiring a full reinstall of the main binary.
Incremental Application Updates - Delivers rapid updates and hotfixes to specific application parts without requiring a full package reinstall.
Remote Component Loading - Downloads and loads feature bundles from a remote server at runtime instead of including them in the binary.
Remote Module Loaders - Provides a system to fetch and initialize functional application bundles from remote servers on demand to reduce initial installation size.
Dynamic Android Component Loading - Loads Android-specific business logic and resources from external binaries at runtime to optimize memory and startup.
Class Loader Hierarchies - Uses custom class loader hierarchies to maintain separate namespaces and prevent class conflicts between dynamic bundles.
Application Baselines - Provides a mechanism to create foundational application artifacts used as reference points for incremental update patches.
Patch - Creates a base artifact containing core products to serve as the foundation for incremental updates.
Baseline Package Versioning - Generates foundational application packages required to calculate and apply incremental updates.
Resource Patching - Provides optimized binary manipulation to update application resources independently of the main binary.
Bytecode Patching - Applies bytecode diffs to existing components at runtime to update application logic without a full reinstall.
Dynamic Component Lifecycles - Manages the installation, operational state, and updating of dynamic application bundles at runtime.
Dependency Isolation Strategies - Implements architectural patterns to enforce strict boundaries and isolation between application bundles and their dependencies.
Android Bundle Isolation - Separates business logic and dependencies into isolated bundles to prevent class conflicts and enable independent feature development.
Isolated Feature Packaging - Groups application features into isolated bundles with unique classes to develop and deploy them independently.
Isolated Module Packaging - Bundles application components into independent, isolatable modules that maintain their own context and dependencies.
Modular Application Composition - Decouples application logic into independent bundles with separate dependencies to enable modular development.
Custom ClassLoader Isolation - Prevents class conflicts and maintains stability by creating distinct execution boundaries for components at runtime.
On-Demand Component Loading - Downloads and initializes functional bundles from remote servers only when specific business logic is triggered.
Cross-Bundle Resource Sharing - Allows separate application bundles to access code and assets residing in the base host application.
Bundle Resource Management - Provides globally unique resource access for each bundle and independently updates asset managers during installation.
Bundle-Specific Debugging - Installs targeted updates for a single feature bundle during development to verify changes without a full deployment.
Runtime Logic Hot-Updates - Allows updating client logic and protocols at runtime without requiring a full application reinstall.
Module-Specific Debugging - Installs updates to a single component over a development bridge to verify changes without a full deployment.
Package Development Isolation - Provides physical bundle isolation to enable isolated testing and development of individual features within a larger workspace.
Interpreted-First Startup - Reduces startup latency by bypassing heavy bytecode optimization on first launch through interpreted-first execution.
Remote File Downloads - Retrieves infrequently used functional bundles from remote URLs to reduce the initial installation size.
Host Resource Access - Grants dynamic modules access to shared code and assets located within the main application shell.
Component-Based Development - Enables engineers to develop and debug independent software building blocks in isolation.
Component Isolation Environments - Decouples development and runtime environments using physical class isolation to debug features independently.
Dynamic Resource Routing - Routes application resource access so that updated assets in dynamic bundles take effect immediately.
Startup Optimizers - Reduces initial launch latency by skipping verification and optimizing bytecode in the background.
Android App Startup Optimizations - Reduces first-launch wait times using interpreted execution and background bytecode optimization for dynamic components.
Host-Bundle Resource Sharing - Allows dynamic modules to access shared code and assets residing within the main application shell.
Component Lifecycle Management - Manages the installation, operation, and updates of application bundles throughout their operational cycle.
Package On-Demand Fetching - Downloads specific application components from a cloud server on demand to optimize the initial app size.
Interpreted-First Execution - Uses interpreted execution to bypass heavy optimization steps during the first load for faster component startup.

didi/VirtualAPK

9,055View on GitHub

VirtualAPK is an Android plugin framework and runtime environment designed to load and execute external Android packages dynamically. It functions as a component host that allows a main application to run activities, services, and providers delivered via external modules without requiring system installation or manifest registration. The framework enables dynamic feature delivery by loading external packages at runtime, allowing application functionality to be updated without redeploying the entire app. It provides a mechanism for Android sandbox execution, running isolated components within

Qihoo360/RePlugin

7,346View on GitHub

RePlugin is an Android plugin framework and component orchestrator designed to load external activities, services, and receivers into an application without updating the main binary. It functions as a dynamic feature delivery system that decouples application modules into independent plugins. The framework provides a communication bridge for bidirectional data exchange between the host application and external plugins, as well as inter-plugin synchronization. It manages the entire plugin lifecycle, including installation, version management, and integrity verification to ensure the safety of

Tencent/Shadow

7,772View on GitHub

Shadow is an Android plugin framework designed to dynamically load and execute Android components and native libraries from external modules into a host application. It functions as a dynamic component loader that integrates activities, services, and broadcast receivers without requiring modifications to the host application code. The system includes a native library loader to execute C/C++ binary files from plugin modules directly within the host process. It also features a module dependency manager that supports segmented loading and explicit dependency chains across multiple plugin package

singwhatiwanna/dynamic-load-apk

6,009View on GitHub

Dynamic-load-apk is an Android plugin framework that enables a host application to load and run uninstalled APK files as plugins at runtime. It provides the core infrastructure for loading APKs from storage, launching their activities, and managing their lifecycle without requiring the user to install them through the system package manager. The framework handles the fundamental challenges of running uninstalled code on Android through several key mechanisms. It isolates plugin classes in a separate DexClassLoader to prevent conflicts with the host class hierarchy, merges plugin resources int

alibabaatlas

Features