# How to Restore Debloated Apps Using Universal Android Debloater Next Generation

> Easily restore debloated apps with Universal Android Debloater Next Generation. This guide explains how to use ADB commands to revert package states via CLI or GUI, making app recovery simple.

- Repository: [Universal-Debloater-Alliance/universal-android-debloater-next-generation](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation)
- Tags: how-to-guide
- Published: 2026-06-18

---

**Universal Android Debloater Next Generation (UAD-NG) restores debloated apps by reading a JSON backup file and reverting package states through ADB commands, available via both CLI and GUI interfaces.**

Universal Android Debloater Next Generation (UAD-NG) provides a reliable restore workflow to recover apps previously disabled or uninstalled during debloating sessions. The tool generates JSON backup snapshots that record package states, allowing you to revert changes safely. Understanding how to restore debloated apps using Universal Android Debloater Next Generation ensures you can recover critical functionality if you accidentally remove essential system components.

## The Core Restore Architecture

### Backup-Driven Recovery

UAD-NG implements restore functionality through three integrated components defined in the core library. The **backup logic** resides in [`crates/uad-core/src/save.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/save.rs), containing the `backup_phone` and `restore_backup` functions that handle JSON serialization. The **CLI interface** exposes these capabilities through the `restore` sub-command defined in [`crates/uad-cli/src/main.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-cli/src/main.rs). The **GUI integration** provides a user-friendly Restore button in the Settings view, handled by `handle_restore_device` in [`crates/uad-gui/src/views/settings.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-gui/src/views/settings.rs).

### How the Restore Routine Works

The restoration process follows a precise sequence to ensure safe recovery. First, it loads the selected backup file from `settings.backup.selected.path` and parses the JSON into a `PhoneBackup` struct (lines 111-126 in [`save.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/save.rs)). For each user recorded in the backup, the system locates the matching user on the connected device, then iterates through every stored package to verify its existence in the current package list.

If a package exists, the routine computes the necessary ADB commands to revert its state—enabling previously disabled apps or reinstalling uninstalled ones—via `apply_pkg_state_commands`. The function returns a `RestoreResult` containing command batches (`BackupPackage`) that the UI or CLI executes sequentially. Missing packages trigger a warning and increment the `skipped_count` (lines 144-149), while successful restores report the number of reverted applications.

## Prerequisites for Restoration

Before initiating a restore operation, verify three conditions. The device must maintain an active ADB connection recognized by UAD-NG. You must possess a previously generated backup file created through the GUI Backup button or `uad backup` CLI command. The restore operation only affects packages that were disabled or uninstalled at backup time; it cannot reinstall packages that never existed on the device.

## How to Restore Using the CLI

The command-line interface provides precise control over restoration operations through the `restore` sub-command.

List available backups to identify your target file:

```bash
uad list-backups

```

Set the backup file environment variable and restore a specific package:

```bash
export UAD_BACKUP=~/uad_backups/2024-08-12_14-30-00.json
uad restore com.google.android.gms

```

Restore all packages from the selected backup:

```bash
uad restore --all

```

The CLI parses the `UAD_BACKUP` environment variable to populate `settings.backup.selected` (see [`main.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/main.rs) line 85), then invokes `restore_backup` from the core module to generate the restoration commands.

## How to Restore Using the GUI

The graphical interface simplifies restoration through the Settings panel. Navigate to **Settings** and locate the **Backup / Restore** section. Click **Backup** first if you haven't created a snapshot, which generates a JSON file in the folder defined by `Config::load_configuration_file().general.backup_folder`.

Click **Restore** to open a file dialog for selecting your backup JSON. After confirmation, UAD-NG displays a progress bar while executing the ADB commands. The `handle_restore_device` function (lines 225-236 in [`settings.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/settings.rs)) bridges the UI button to the core `restore_backup` routine, ensuring consistent behavior with the CLI.

## Programmatic Restoration

Developers integrating UAD-NG functionality can invoke the restore routine directly through the core library.

```rust
use uad_core::{save::restore_backup, config::Config, sync::Phone, utils::DisplayablePath};
use std::path::Path;

fn restore_from_file(phone: &Phone, backup_path: &Path) -> Result<(), String> {
    // Populate settings with the selected backup
    let mut cfg = Config::load_configuration_file();
    cfg.backup.selected = Some(DisplayablePath { 
        path: backup_path.to_path_buf() 
    });
    
    // Call the core restore routine
    let result = restore_backup(phone, &phone.package_lists, &cfg.backup)?;
    
    // Iterate over the generated ADB commands
    for pkg in result.packages {
        for cmd in pkg.commands {
            println!("ADB: {}", cmd);
        }
    }
    Ok(())
}

```

This pattern mirrors the GUI implementation, constructing a `DeviceSettings` struct pointing to the chosen backup file before calling `restore_backup` to generate the command sequence.

## Edge Cases and Safeguards

UAD-NG implements several protections against restoration failures. **Missing packages** are silently skipped with a logged warning, preventing crashes when OEMs remove apps entirely. **Multiple user profiles** resolve correctly through user index matching before command execution. **No-op detection** identifies when the device state already matches the backup, displaying "Device state is already restored" (line 264) rather than executing redundant commands.

## Summary

- UAD-NG restores apps exclusively through JSON backup files created via the backup workflow.
- The `restore_backup` function in [`crates/uad-core/src/save.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/save.rs) handles the core logic, computing ADB commands to revert package states.
- Both CLI (`uad restore`) and GUI (Settings > Restore) interfaces share identical core functionality.
- Restoration requires an active ADB connection and a previously generated backup file.
- Missing packages are skipped gracefully, while existing packages revert from disabled to enabled or uninstalled to installed states.

## Frequently Asked Questions

### Can I restore apps without a backup file?

No. UAD-NG requires a JSON backup generated through its own backup system to perform restores. The tool cannot recover packages that were debloated before the backup was created or through other tools, as it relies on the `PhoneBackup` struct data recorded in [`crates/uad-core/src/save.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/save.rs) to determine previous states.

### What happens if I try to restore an app that no longer exists on my device?

The restore routine skips missing packages and increments a `skipped_count` counter while logging a warning (lines 144-149 in [`save.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/save.rs)). This occurs when manufacturers completely remove package files from the system partition rather than merely disabling them.

### Does restoring affect user data or app settings?

Restoration only modifies package states (enabled/disabled or installed/uninstalled) through ADB commands generated by `apply_pkg_state_commands`. It does not interact with user data directories or app-specific settings, preserving your personal data while recovering the application functionality.

### Can I restore specific packages rather than everything from the backup?

Yes. The CLI supports restoring individual packages using `uad restore <package_name>`, while the GUI allows selective restoration through its package list interface. Both methods filter the backup contents before generating ADB commands, though the underlying `restore_backup` function processes the entire backup file to determine available actions.