alibaba/atlas

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.

Star history