# What Programming Languages Are Used in Universal Android Debloater Next Generation?

> Discover the programming languages powering Universal Android Debloater Next Generation. Learn how Rust, TOML, Nix, JSON, and Bash contribute to this powerful debloating tool.

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

---

**Universal Android Debloater Next Generation is built almost entirely in Rust as a Cargo workspace containing three specialized crates, with supplementary files in TOML, Nix, JSON, and Bash supporting the build system and documentation.**

The Universal Android Debloater Next Generation (UAD-NG) repository represents a modern approach to Android device management, leveraging Rust's memory safety and performance characteristics for system-level operations. According to the source code in `Universal-Debloater-Alliance/universal-android-debloater-next-generation`, the project uses a workspace-based architecture that separates core logic from user interfaces while maintaining type safety across all components.

## The Rust Codebase Architecture

The repository structure confirms Rust as the sole implementation language for executable code, organized into three distinct crates defined in the root [`Cargo.toml`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/Cargo.toml) workspace file.

### Core Library (uad-core)

The `uad-core` crate handles all foundational operations including ADB communication, package list management, and configuration handling. In [`crates/uad-core/src/lib.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/lib.rs), the library exposes the primary API used by both the GUI and CLI variants.

The ADB communication layer resides in [`crates/uad-core/src/adb.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/adb.rs), which implements the `Adb` struct for device interaction:

```rust
use uad_core::adb::Adb;
use uad_core::utils::fetch_package_list;

async fn list_installed_packages(device_serial: &str) -> anyhow::Result<Vec<String>> {
    let adb = Adb::new(device_serial).await?;
    let output = adb.shell("pm list packages").await?;
    Ok(output
        .lines()
        .filter_map(|line| line.strip_prefix("package:"))
        .map(str::to_string)
        .collect())
}

```

This async function demonstrates how the core library uses **tokio** for asynchronous I/O and **anyhow** for error handling when querying device packages.

### Graphical Interface (uad-gui)

The `uad-gui` crate provides the desktop application using the **Iced** GUI library. The entry point in [`crates/uad-gui/src/main.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-gui/src/main.rs) initializes the application window, while [`crates/uad-gui/src/theme.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-gui/src/theme.rs) manages visual styling.

A minimal Iced implementation following the pattern found in the actual source:

```rust
use iced::{Application, Settings, Command, Element, Text};

pub fn main() -> iced::Result {
    DebloaterApp::run(Settings::default())
}

struct DebloaterApp;

impl Application for DebloaterApp {
    type Message = ();

    fn new(_flags: ()) -> (Self, Command<Self::Message>) {
        (Self, Command::none())
    }

    fn title(&self) -> String {
        "Universal Android Debloater".into()
    }

    fn view(&self) -> Element<Self::Message> {
        Text::new("Welcome to UAD‑NG!").into()
    }
}

```

### Command-Line Interface (uad-cli)

The `uad-cli` crate offers terminal-based interaction using **clap** for argument parsing and **tokio** for async runtime management. The file [`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) serves as the entry point, while [`crates/uad-cli/src/commands.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-cli/src/commands.rs) defines the available subcommands.

Device-specific operations typically reference [`crates/uad-cli/src/device.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-cli/src/device.rs) (implied by the structure) for managing ADB connections via the core library.

## Supporting Languages and Configuration Files

While Rust constitutes the executable codebase, several auxiliary languages facilitate builds, packaging, and documentation.

### TOML for Build Configuration

The [`Cargo.toml`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/Cargo.toml) files throughout the repository declare dependencies and workspace members. The root [`Cargo.toml`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/Cargo.toml) defines the workspace structure linking the three crates, while individual crate manifests specify version constraints for dependencies like `iced`, `clap`, and `tokio`.

### Nix for Development Environments

The `flake.nix` file provides a reproducible Nix development environment, ensuring consistent toolchain versions across different developer machines. This configuration language manages the Rust compiler and system dependencies required for ADB integration.

### JSON for Package Lists

The file [`resources/assets/uad_lists.json`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/resources/assets/uad_lists.json) contains the curated database of Android packages eligible for removal. This JSON data file is consumed at runtime by the Rust core to populate the debloat recommendations, separating data from application logic.

### Shell Scripts for Documentation

Bash appears exclusively in [`crates/uad-cli/examples/usage.sh`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-cli/examples/usage.sh), which demonstrates typical CLI workflows. This script serves as living documentation rather than production code, illustrating how end users interact with the compiled Rust binary:

```bash

# From a terminal

uad-cli list-devices

```

## Summary

- **Rust** is the sole implementation language for Universal Android Debloater Next Generation, organized as a Cargo workspace with three crates.
- **uad-core** manages ADB communication in [`crates/uad-core/src/adb.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/adb.rs).
- **uad-gui** builds the desktop interface using the Iced framework, with entry point at [`crates/uad-gui/src/main.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-gui/src/main.rs).
- **uad-cli** provides terminal access via [`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) using clap for argument parsing.
- **TOML** files handle dependency management and workspace configuration.
- **Nix** expressions in `flake.nix` ensure reproducible build environments.
- **JSON** stores the package database in [`resources/assets/uad_lists.json`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/resources/assets/uad_lists.json).
- **Bash** scripts appear only as usage examples in [`crates/uad-cli/examples/usage.sh`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-cli/examples/usage.sh).

## Frequently Asked Questions

### Is Universal Android Debloater Next Generation written in Python or Java?

No, the application is written entirely in Rust, not Python or Java. While many Android tools use Java for Android-specific operations, UAD-NG leverages Rust's asynchronous runtime and cross-platform compilation capabilities to interface with Android Debug Bridge (ADB) directly.

### Why does the repository contain JSON files if it's a Rust project?

The JSON files, specifically [`resources/assets/uad_lists.json`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/resources/assets/uad_lists.json), serve as data assets rather than executable code. They contain the curated lists of Android packages that can be safely removed, which the Rust core reads at runtime to populate the user interface and validation logic.

### What GUI framework does Universal Android Debloater Next Generation use?

The graphical interface uses **Iced**, a Rust-native GUI library that provides immediate mode rendering with a declarative API. This is implemented in the `uad-gui` crate, with theming logic located in [`crates/uad-gui/src/theme.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-gui/src/theme.rs).

### Can I build Universal Android Debloater Next Generation without knowing Rust?

You can build the project using the provided Nix configuration in `flake.nix`, which handles the Rust toolchain automatically. However, modifying the source code requires knowledge of Rust, as the core logic in [`crates/uad-core/src/lib.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/lib.rs) and device communication in [`crates/uad-core/src/adb.rs`](https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/blob/main/crates/uad-core/src/adb.rs) uses advanced Rust patterns including async/await and trait-based abstractions.