APKTool GUI 4 Linux

A native Linux desktop GUI for Apktool workflows: decode, rebuild, align, sign, verify, inspect, and manage APK framework files.

APKTool GUI 4 Linux is a GTK desktop application inspired by the Windows APKTool GUI experience, but built for Ubuntu/Linux workflows. It wraps proven Android reverse-engineering and packaging tools behind a practical interface, with a strong focus on portability through bundled binaries.

The core workflow is simple:

APK -> decode -> edit project -> build -> zipalign -> sign -> verify

What It Is Based On

This project does not reimplement APK decoding or signing logic. It orchestrates established tools:

• iBotPeaches/Apktool for decoding and rebuilding APK projects.
• Android SDK Build Tools for aapt, aapt2, zipalign, and apksigner.
• Eclipse Temurin/OpenJDK runtime for Java-based tooling.
• AppImage packaging for portable Linux distribution.

The goal is to provide a comfortable Linux desktop frontend around those tools, similar in spirit to Windows APKTool GUI, while keeping the underlying commands transparent in the log panel.

Features

• Native GTK desktop UI for Linux.
• Decode APKs with Apktool.
• Rebuild decoded projects.
• Build, align, and sign in one pipeline.
• Create and use debug keystores.
• Verify APK signatures.
• Visual APK information panel with package name, label, version, SDK data, ABIs, densities, and permissions.
• Raw APK inspection using aapt/aapt2 dumps.
• APKCombo search integration with parsed results, package/name matching, and best-effort downloads.
• Framework management:
  • install framework
  • list frameworks
  • clean frameworks
  • publicize resources
• Bundled tool support through tools/.
• Tool availability and version checks.
• Live command output log.
• Automatic output naming:
  • MyApp.apk -> MyApp_src
  • MyApp_src -> MyApp-unsigned.apk, MyApp-aligned.apk, MyApp-signed.apk

Screens And Workflows

Decode

Select an APK and the app suggests an output folder automatically. Decode options include:

• force overwrite
• no resources
• no smali
• all sources
• no assets
• no debug info
• only manifest
• keep broken resources
• match original
• ignore raw values
• framework path/tag
• shared library
• parallel jobs
• resource resolve mode

APK Info

Select an APK to inspect it without decoding. The visual summary shows the most useful metadata first, while the action buttons expose detailed dumps:

• badging
• permissions
• manifest XML tree
• resources
• configurations
• archive contents

APK Search

Search APKCombo by app name or package name from inside the app. Results are parsed into visual cards with:

• app name
• package name
• developer
• category
• downloads/rating/size summary when available
• latest version and older versions detected from the app page
• match score and match reason
• source page link
• download page link
• best-effort direct download action

The direct download action first resolves APKCombo's variant page, selects the first available package variant, then downloads the resolved /d?u=... link with curl. A progress bar is shown while the download runs. If APKCombo changes its markup or blocks automated downloads, use Open download page and complete the download in the browser.

Build

Select a decoded project folder and the app suggests output filenames. Build options include:

• selectable AAPT backend: aapt2, legacy aapt, or custom path
• force rebuild
• debuggable manifest patch
• copy original manifest/META-INF
• network security config
• no APK repack
• no crunch
• framework path
• shared libraries
• parallel jobs

You can either build only, or run Build + align + sign in one go.

Align / Sign

Use zipalign and apksigner from one screen. Options include:

• alignment size
• native library page alignment
• Zopfli recompression
• V1/V2/V3/V4 signing scheme selection
• min/max SDK
• verity
• file size alignment
• preserve existing alignment
• signature verification with certificate output

Frameworks

Manage Apktool framework files from the GUI:

• install framework APK
• list installed frameworks
• clean frameworks
• publicize resources.arsc

Tools

The app checks and displays availability and versions for:

• Java
• Apktool
• aapt
• aapt2
• zipalign
• apksigner
• keytool

Portable Tool Layout

The app prefers bundled tools when Use tools bundled with the app is enabled.

Expected layout:

tools/
  apktool/
    apktool.jar
  android-build-tools/
    aapt
    aapt2
    zipalign
    apksigner
    lib/
    lib64/
  debug.keystore
  jre/
    bin/
      java
      keytool
    lib/

This repository workspace is prepared for:

• Apktool 3.0.2
• Eclipse Temurin JRE 21.0.11+10
• Android Build Tools 35
• appimagetool continuous build

Use the helper script to download and arrange tools:

chmod +x scripts/download_tools.sh
./scripts/download_tools.sh

Running From Source

Requirements for running the GTK frontend from source:

• Linux desktop session
• Python 3
• PyGObject with GTK 4

Run:

python3 apktoolgui4lin_gtk.py

Or:

chmod +x apktoolgui4lin_gtk.py
./apktoolgui4lin_gtk.py

Building The AppImage

Create the AppDir:

chmod +x packaging/build_appdir.sh
./packaging/build_appdir.sh

Generate the AppImage with a system appimagetool:

appimagetool dist/AppDir

Or use the downloaded appimagetool:

ARCH=x86_64 ./bin/appimagetool-x86_64.AppImage \
  dist/AppDir \
  dist/APKTool_GUI_4_Linux-x86_64.AppImage

Current generated AppImage:

sha256sum dist/APKTool_GUI_4_Linux-x86_64.AppImage

Project Structure

apktoolgui4lin_gtk.py        Main GTK application
tools/                       Bundled runtime tools
scripts/download_tools.sh    Download helper for portable tools
packaging/                   AppImage/AppDir files
dist/                        Generated AppDir and AppImage output
bin/                         Downloaded appimagetool

Notes On Portability

The generated AppImage includes Java, Apktool, and Android Build Tools. The current UI still relies on the host Ubuntu Python/GTK runtime. For complete zero-dependency portability, the next packaging milestone is to bundle Python+GTK or migrate the UI to a compiled desktop stack.

When running from an AppImage, Android Build Tools are copied to a user-writable executable cache before being passed to Apktool. This keeps sibling libraries such as libc++.so available and avoids failures caused by Apktool trying to adjust executable permissions inside the read-only AppImage mount.

The default debug signing keystore is bundled as tools/debug.keystore so align/sign workflows remain portable inside the AppImage without relying on ~/.android/debug.keystore. You can still select any other keystore manually when signing.

Some APKs contain resources that aapt2 rejects, such as PNG files with invalid signatures or resource names that are invalid for modern aapt2 compilation. In those cases, switch Build -> AAPT backend to aapt (legacy fallback) and rebuild.

Roadmap

• Bundle the Python/GTK runtime for a fully self-contained AppImage.
• Add APK/APKS/XAPK split handling.
• Add ADB install/pull helpers.
• Improve APK Info and APKCombo Search with icons and manifest component summaries.
• Add presets for common decode/build/sign workflows.
• Add project history and recent APKs.

Legal And Safety Notes

This project is intended for legitimate APK analysis, localization, compatibility work, research, and modification of applications you own or are allowed to inspect. The app executes local commands and file paths configured through the UI, so use trusted tools and review logs when working with unknown APKs.

Apktool, Android SDK Build Tools, Java runtimes, and appimagetool are third-party projects with their own licenses and distribution terms. This project is a GUI wrapper around those tools, not a replacement for them.