skylot/jadx

This system is JADX, a comprehensive tool for decompiling Android application packages (APK, AAB, XAPK) and Java bytecode into readable Java source code. It provides both a command-line interface and a graphical desktop application that features interactive code browsing, syntax highlighting, and integrated debugging capabilities for Smali bytecode. The platform supports advanced analysis through call graph visualization, precise source mapping, and a modular plugin architecture that enables extensible deobfuscation and custom input handling.

79 changes.

This period focused on a comprehensive rewrite of the JADX core engine, restructuring internal data models, control-flow analysis, and type inference to significantly improve decompilation accuracy. Concurrently, the project launched the initial version of the graphical user interface (jadx-gui) and expanded the command-line tool with plugin support and Gradle export capabilities. The work was underpinned by the establishment of a robust, modular test suite to validate these complex architectural changes.

82 changes.

The project expanded its input capabilities by introducing a modular plugin system for DEX, Java, and Smali files, while significantly enhancing the GUI with a built-in Smali debugger and ADB integration. Core decompilation accuracy was improved through major rewrites of the control-flow graph, exception handling, and variable handling logic. This period also saw the addition of JSON output, code comments, and extensive test coverage to support these new features and stability improvements.

94 changes.

This period focused on establishing a robust, extensible plugin architecture with comprehensive APIs for GUI integration, metadata, and input handling. The GUI was significantly modernized with features like live reload, disk caching, customizable shortcuts, and a new settings interface, while the build system was migrated to Kotlin DSL.

34 changes.

This period focused on significantly expanding the JADX GUI with interactive graph visualizations, a new hex viewer, and dynamic theming, while introducing robust support for split Android package formats like XAPK, APKS, and APKM. The work also included a major security overhaul of the ZIP parsing infrastructure and the implementation of a new global-scoped plugin architecture to improve extensibility and user experience.

The APKM input plugin is now registered in the application, enabling the tool to recognize and process APKM (Android Package Bundle) files as an input format.

jadx-plugins/jadx-apkm-input · high confidence

Users can now manage Jadx plugins directly from the command line using the new 'plugins' subcommand. This includes installing plugins from a location ID or local JAR file, listing installed or available plugins, updating installed plugins, uninstalling specific plugins, and enabling or disabling installed plugins.

jadx-cli/src/main/java/jadx/cli/commands · high confidence

JADX can now export decompiled code as complete Gradle projects for both Android applications/libraries and simple Java projects. The new Android generator creates standard module structures (app or lib) and populates build.gradle files with metadata extracted from the AndroidManifest.xml, such as compileSdkVersion, targetSdkVersion, and version information. A separate generator handles simple Java projects using Kotlin DSL (build.gradle.kts). Both generators include built-in sanitization of string values to ensure the generated Gradle scripts are safe and valid.

jadx-core/src/main/java/jadx/core/export/gen · high confidence

Users can now export decompilation results in JSON format. The new JsonCodeGen generates a JSON representation of classes, including their package, type, inheritance, fields, methods, inner classes, and decompiled code lines with source offsets. Additionally, JsonMappingGen creates a mapping.json file in the output directory that maps original class, field, and method names to their decompiled aliases and links to the corresponding class JSON files, facilitating automated analysis and tooling integration.

jadx-core/src/main/java/jadx/core/codegen/json · high confidence

The Jadx GUI now includes a new plugin for analyzing APK and DEX files using the Quark Engine. This feature adds a dialog to select target files, a background manager that handles automatic installation of Quark and its Python virtual environment, and a report viewer that displays detected malicious activities and confidence scores directly within the Jadx tree and tabbed interface.

jadx-gui/src/main/java/jadx/gui/plugins/quark · high confidence

A new WrapLayout class has been added to the layout utilities, extending Java's FlowLayout to fully support wrapping of components. This layout manager calculates preferred and minimum sizes by fitting visible components into rows based on the container's available width, ensuring that UI elements (such as options in dialogs) wrap correctly rather than overflowing or being cut off.

jadx-gui/src/main/java/jadx/gui/utils/layout · high confidence

The Smali input plugin now exposes configuration options for the Android API level (defaulting to 27) and the number of processing threads. Users can now adjust these settings to control how Smali files are parsed and processed, allowing for better performance tuning or compatibility with specific Android versions.

jadx-plugins/jadx-smali-input/src/main/java/jadx/plugins/input · high confidence

A .desktop file has been added to the contrib directory to enable proper integration of the JADX GUI application with Linux desktop environments. This allows the application to appear in application menus and handle file associations for Dex files directly from the desktop interface.

contrib · high confidence

A new desktop entry template (jadx-gui.desktop.tmpl) has been added to the application resources. This template defines the application as a Development tool and explicitly registers support for Android package archives (.apk) and Java archives (.jar) via the MimeType field, enabling proper file association and opening of these archive types directly from the desktop environment.

jadx-gui/src/main/resources/files · high confidence

JADX now includes an internal event system that allows plugins to subscribe to and receive asynchronous notifications. This change introduces the core implementation classes (JadxEventsImpl and JadxEventsManager) which manage event listeners and dispatch events via a dedicated single-thread executor, enabling plugins to react to specific JADX events without blocking the main processing thread.

jadx-core/src/main/java/jadx/core/plugins/events · high confidence

Users can now provide .raung files as input to JADX. A new input plugin registers to handle these files by converting them into a temporary JAR via the RaungAsm library, which is then processed by the existing Java input plugin.

jadx-plugins/jadx-raung-input/src/main/java/jadx/plugins/input · high confidence

New input plugins have been added to handle Android APKM and APKS files. The \ApkmInputPlugin\ and \ApksInputPlugin\ register custom code and resource loaders that extract individual \.apk\ modules from the container archives, load their code and resources via the existing Dex input infrastructure, and clean up temporary files after processing.

jadx-apkm-input, jadx-plugins/jadx-apkm-input/src/main/kotlin/jadx/plugins/input, jadx-plugins/jadx-apks-input/src/main/kotlin/jadx/plugins/input · high confidence

The AAB input plugin now includes a new factory that detects and parses resource files ending in .pb with the ARSC resource type. This enables the decompiler to correctly handle Android App Bundles that utilize protobuf-encoded resource tables, ensuring these resources are decoded and available for analysis.

jadx-aab-input · high confidence

The application now includes the necessary JFlex source files (SmaliTokenMaker.flex, skeleton.default) and build configuration to generate a tokenizer for Smali code. This enables syntax highlighting for Smali code within the GUI's code view area, as indicated by the package declaration and the .gitignore entry for the generated SmaliTokenMaker.java.

config/jflex · high confidence

A new UIWatchDog utility has been introduced to monitor the Java Swing event dispatch thread. It periodically checks for UI freezes lasting longer than 200ms and logs a warning with a stack trace if the interface becomes unresponsive, helping users and developers identify performance bottlenecks during class loading or other heavy operations.

jadx-gui/src/main/java/jadx/gui/utils/dbg · high confidence

A new ValueCache class has been added to the jadx-gui utils cache package. This utility provides a simple, thread-safe mechanism to store and retrieve values based on a specific key, automatically reloading the value via a provided function when the key changes. This component supports the fix for properly handling excluded classes in code search by providing a caching layer for search-related data.

jadx-gui/src/main/java/jadx/gui/utils/cache · high confidence

A new command-line tool, SyncNLSLines, has been added to the jadx-gui utilities to automatically synchronize internationalization (i18n) property files. This tool uses the English reference file (Messages\_en\_US.properties) as the source of truth, adding new keys as commented-out lines to other language files, removing obsolete keys, and updating empty or commented-out translations with the reference text. This helps maintain consistency across localized resource bundles.

jadx-gui/src/main/java/jadx/gui/utils/tools · high confidence

The Jadx GUI now automatically reloads the decompiled project when source files are modified on disk. This is implemented via a new file watching system (FilesWatcher) that monitors directory changes and a background worker (LiveReloadWorker) that triggers a project reopen after a brief debounce period, allowing users to see updates to their code without manually refreshing.

jadx-gui/src/main/java/jadx/gui/utils/fileswatcher · high confidence

Users can now enable an alternative file chooser in the settings, which provides improved usability features such as pasting a list of file paths directly from the clipboard into the file name field. This new dialog also correctly handles files with multiple extensions (like .jadx.kts) that were previously filtered out by the standard Swing file chooser, and it disables problematic Windows shell folder shortcuts to prevent crashes. The change introduces a new FileDialogWrapper and CustomFileChooser implementation to support these behaviors alongside the existing standard dialog.

jadx-gui/src/main/java/jadx/gui/ui/filedialog · high confidence

The Preferences window now includes a Cache Settings group that lets users choose the disk code cache location (default, local, or custom directory) and select the cache mode for both code and usage data. A table lists existing caches by project, showing their disk usage (rounded to block size for accuracy) and allowing users to recalculate sizes, delete selected entries, or delete all caches, with automatic project reloads when the current project's cache is removed.

jadx-gui/src/main/java/jadx/gui/settings/ui/cache · high confidence

The jadx-app-commons module now provides a unified foundation for handling system directories and environment variables across all Jadx applications. A new JadxCommonEnv utility standardizes reading environment variables, while JadxCommonFiles manages config and cache directories, allowing users to override their locations via the JADX\_CONFIG\_DIR and JADX\_CACHE\_DIR environment variables. Additionally, JadxTempFiles centralizes temporary file creation, supporting the JADX\_TMP\_DIR override, and JadxSystemInfo consolidates OS and architecture detection (such as AMD64 checks) previously scattered across the codebase.

jadx-commons/jadx-app-commons · high confidence

The application now supports user-defined keyboard shortcuts for menu items. This is implemented via a new \ShortcutsController\ that binds actions to key strokes, a \JadxMenu\ class that manages these bindings and updates accelerators, and a \JadxMenuBar\ that propagates shortcut reloads across all menus. A \HiddenMenuItem\ helper class is also introduced to support internal menu structures without visual clutter.

jadx-gui/src/main/java/jadx/gui/ui/menu · high confidence

The Jadx application now supports opening APK-Split (.apks) files. This capability is enabled by registering the ApksInputPlugin through the standard Java Service Provider interface, allowing the tool to recognize and process this specific archive format.

jadx-plugins/jadx-apks-input · high confidence

Users can now export decompiled code as a complete Android Gradle project (app or library) or a simple Java Gradle project. The system automatically detects the project type based on the presence of an Android manifest, ARSC resources, or classes.jar, and generates the corresponding Gradle build files and directory structure using a new template engine.

jadx-core/src/main/java/jadx/core/export · high confidence

The \jadx-input-api\ module has been extracted into a dedicated library, introducing new implementation classes for the plugin input data model. This includes \AnnotationsAttr\ for managing annotation lists, \CallSite\ for handling call site values, and specific \MethodHandle\ implementations (\FieldRefHandle\, \MethodRefHandle\) for field and method references. Additionally, a \MergeCodeLoader\ has been added to aggregate multiple code loaders, enabling plugins to combine input sources.

jadx-input-api · high confidence

The Jadx GUI now features a robust, multi-strategy synchronization system for the code and Smali panels. When you click or place your cursor in one view, the other view automatically scrolls to and highlights the corresponding code. This sync works using debug line mappings, instruction offsets (when available), and a regex-based fallback for matching identifiers, methods, and classes, ensuring a consistent navigation experience across decompiled Java, simple Java, fallback Java, and Smali bytecode views.

jadx-gui/src/main/java/jadx/gui/ui/codearea/sync · high confidence

The jadx-gui application is introduced, providing a graphical interface for the JADX decompiler. This release adds support for macOS-specific open file handlers, allowing users to open files directly from the Finder. It also implements a disk-based code cache mechanism to improve performance and reduce memory usage during decompilation, configurable via settings. The GUI initializes with system locale and font settings, and integrates with the core JADX decompiler through a wrapper that manages plugin loading and project state.

jadx-gui/src/main/java/jadx/gui · high confidence

The jadx-java-convert plugin now includes a new ConvertResult class to handle the results of Java conversion processes. This class tracks converted file paths and temporary resources, ensuring that temporary files are automatically cleaned up when the result object is closed, thereby improving resource management during the conversion workflow.

jadx-java-convert · high confidence

A new Quick Tabs tree has been added to the left-hand navigation panel, providing a hierarchical view of all open tabs categorized into Open, Pinned, and Bookmarked sections. This feature allows users to quickly locate and switch between tabs directly from the tree, while also offering context menu actions to pin, unpin, bookmark, unbookmark, or close tabs and groups of tabs. The implementation includes a new \ITabStatesListener\ interface to synchronize tab state changes (open, close, pin, bookmark) with the tree UI, and a \TabBlueprint\ model to track the metadata of each tab.

jadx-gui/src/main/java/jadx/gui/ui/tab · high confidence

The SSA (Static Single Assignment) transformation visitor has been implemented to convert method registers into SSA variables. This new capability introduces live variable analysis, phi-node placement, and variable renaming, which collectively improve the accuracy of variable tracking and naming in the decompiled output.

jadx-core/src/main/java/jadx/core/dex/visitors/ssa · high confidence

Jadx now uses a dedicated classpath graph (ClsSet/ClspGraph) to store and resolve class hierarchy, method signatures, and generic type information from Android system libraries and Apache HTTP legacy support. This enables more accurate decompilation of code that relies on standard library types, particularly for resolving generic types, method overrides, and inheritance relationships that were previously ambiguous or missing.

jadx-core/src/main/java/jadx/core/clsp · high confidence

Added a new cache management system that allows users to specify a custom location for the decompilation cache, view existing cache entries, and delete them. The implementation includes a CacheManager and CacheEntry classes to track project cache directories, handle path resolution (including local vs. global cache bases), and persist cache metadata to disk, ensuring that cache entries are verified and updated when project paths change.

jadx-gui/src/main/java/jadx/gui/cache/manager · high confidence

The API data layer now includes concrete implementations for code comments and renames, enabling users to attach styled comments to specific code nodes and track custom renames. The new JadxCodeComment class supports line-style comments with sanitization to prevent injection issues, while JadxCodeRename stores new names for deobfuscated or manually renamed elements. These are managed via JadxCodeData, which aggregates comments and renames, and rely on JadxNodeRef and JadxCodeRef to precisely identify classes, methods, fields, and specific code instructions or variables.

jadx-core/src/main/java/jadx/api/data/impl · high confidence

Added a new plugin file access abstraction consisting of the IJadxFilesGetter interface and its implementations (SingleDirFilesGetter and TempFilesGetter), along with the JadxFilesData class that exposes plugin-specific config, cache, and temp directories to plugins.

jadx-core/src/main/java/jadx/core/plugins/files · high confidence

The plugin system now uses a dedicated \JadxPass\ interface hierarchy with explicit \JadxPassInfo\ to define pass metadata and execution order. Users can now control the sequence of custom passes using \runAfter\ and \runBefore\ lists, with support for \START\ and \END\ markers to place passes at the beginning or end of the pipeline. New pass types (\AfterLoadPass\, \DecompilePass\, \PreparePass\) provide typed entry points for different stages of the decompilation process, and helper classes like \OrderedJadxPassInfo\ and \SimpleAfterLoadPass\ simplify the creation of custom passes with fluent ordering APIs.

jadx-core/src/main/java/jadx/api/plugins/pass · high confidence

The new Java Convert plugin allows users to load Java bytecode directly by converting .class files, .jar archives, and .aar packages into DEX format for decompilation. It introduces a configurable conversion mode (DX, D8, or both) and a D8 desugaring option, enabling flexible handling of various Java input types including Spring Boot JARs and AARs containing embedded JARs.

jadx-plugins/jadx-java-convert/src/main/java/jadx/plugins/input · high confidence

A new dedicated plugin (aab-input) has been added to handle .aab files. It registers a set of resource container factories and a proto-based resource table parser to decode AAB-specific protobuf resources (such as BundleConfig, assets, native libraries, and app dependencies) and convert binary XML/manifest data into readable text, enabling users to inspect the internal structure and resources of Android App Bundles.

jadx-plugins/jadx-aab-input/src/main/java/jadx/plugins/input · high confidence

The Jadx GUI now includes a new low-level ADB protocol implementation in the \jadx.gui.device.protocol\ package, introducing \ADB\, \ADBDevice\, and \ADBDeviceInfo\ classes. This change adds support for connecting to Android devices via ADB, retrieving device information, launching applications, and capturing logcat output, forming the foundation for the new smali debugger and device interaction features.

jadx-gui/src/main/java/jadx/gui/device/protocol · high confidence

The jadx-core API now exposes a new data package containing interfaces (ICodeComment, ICodeRename, ICodeData) and supporting types (CommentStyle, CodeRefType) that allow users to access and manipulate code comments and rename information programmatically. This includes the ability to specify comment styles (line, block, javadoc) and track specific code references for renaming.

jadx-core/src/main/java/jadx/api/data · high confidence

Added a new set of utility classes in jadx-core to improve Android-specific decompilation. AndroidManifestParser now safely parses manifest attributes (SDK versions, labels, activities) using safe integer parsing to handle null or malformed values. AndroidResourcesUtils handles the generation and population of the R class, including creating synthetic classes when the original is missing and ensuring resource fields are correctly named and preserved. AndroidResourcesMap provides a mechanism to load and use a bundled resource ID-to-name mapping file (res-map.txt) for better resource identification. Additionally, new classes like ExtDataInput and Res9patchStreamDecoder support robust binary resource reading and 9-patch image decoding.

jadx-core/src/main/java/jadx/core/utils/android · high confidence

A new command-line utility, ConvertArscFile, has been added to the JADX CLI tools. This tool allows users to convert .arsc files (or resources.arsc entries within android.jar files) into a simple text file that maps resource IDs to their corresponding names. It supports processing multiple input files or directories, automatically merging and updating existing resource maps, and handles both standalone .arsc files and those embedded in JARs.

jadx-cli/src/main/java/jadx/cli/tools · high confidence

A new 'Dex Input' plugin has been added to jadx, enabling the loading of .dex and .apk files as input sources. This plugin implements the JadxPlugin interface to register options and code input handlers, utilizing a custom DexFileLoader and DexReader to parse DEX headers, class definitions, fields, and methods. It also includes a Smali instruction formatter to support bytecode representation, providing a dedicated pathway for processing Android DEX bytecode within the plugin architecture.

jadx-dex-input · high confidence

Users can now export decompiled code as complete Gradle projects. The update adds new template files for Android applications (app.build.gradle.tmpl), Android libraries (lib.build.gradle.tmpl), and standard Java projects (build.gradle.kts.tmpl), along with corresponding settings files. The Android templates are configured to use the Android Gradle Plugin version 8.10.1, set Java compatibility to version 1.8, and include placeholders for SDK versions, application IDs, and other standard build configurations.

jadx-core/src/main/resources/export · high confidence

The Hex Viewer has been replaced with a new implementation that supports lazy loading of large binary files via 512 KB blocks to improve performance. It includes a dedicated search bar allowing users to search for both text strings and raw binary data, with options for case sensitivity and match highlighting. The viewer also features an inspector panel that displays the current byte offset interpreted as various data types (signed/unsigned 8/16/32/64-bit integers, floats, hex, octal, binary) with configurable little-endian support, and a header bar showing selection range and file length.

jadx-gui/src/main/java/jadx/gui/ui/hexviewer · high confidence

A new ITreeNode interface has been introduced in the jadx API to standardize metadata for tree nodes. This interface extends javax.swing.tree.TreeNode and defines methods to retrieve a locale-independent ID, display name, icon, and a reference to the related code node (ICodeNodeRef). This provides a consistent contract for tree node implementations within the GUI layer.

jadx-core/src/main/java/jadx/api/gui · high confidence

The jadx-java-input plugin now supports loading Java classes directly from byte arrays or input streams, enabling users to analyze bytecode without requiring intermediate file storage. This new input plugin parses the Java class file format, including the constant pool, fields, methods, attributes, and bytecode instructions, and exposes this data through the standard input plugin API. It handles various bytecode opcodes, including lambda decoding, modified UTF-8 strings, and stack map tables, providing a comprehensive view of Java bytecode structure and behavior.

jadx-java-input · high confidence

A new input plugin has been added to Jadx that enables the direct loading and decompilation of Java bytecode files (.class) and archives (.jar). This feature introduces a dedicated plugin architecture (JavaInputPlugin) and a comprehensive set of internal classes to parse the Java class file format, including constant pool handling, attribute reading (such as Code, StackMapTable, and annotations), and method/field data structures. Users can now provide Java class files as input to the decompiler, expanding Jadx's capabilities beyond standard Android APK/DEX analysis to include general Java bytecode.

jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input · high confidence

A new plugin has been added to Jadx that reads the \kotlin.Metadata\ annotation from compiled Kotlin classes to significantly improve deobfuscation. This feature allows users to restore original names for class aliases, package names, method arguments, fields, companion objects, and getters. It also fixes data class flags and renames classes/fields based on the generated \toString\ implementation. The plugin is configurable via options to enable or disable specific renaming behaviors, ensuring that decompiled code is more readable and closer to the original source.

jadx-plugins/jadx-kotlin-metadata/src/main/kotlin/jadx/plugins/kotlin · high confidence

Added ResTableHelper to build the UI tree for resource table containers, handling the creation of directory and file nodes for the resource view.

jadx-gui/src/main/java/jadx/gui/utils/res · high confidence

The Jadx GUI now includes a built-in Smali debugger, allowing users to attach to running Android applications via ADB and debug their decompiled Smali code. This feature adds a new debugger panel with support for setting breakpoints, stepping through code (step over, into, and out), and inspecting runtime registers and variables. It also integrates a live Logcat viewer to monitor application output during debugging sessions. The debugger handles JDWP communication, manages breakpoint persistence across sessions, and adapts to different Android ART runtime versions to ensure accurate register mapping and null object handling.

jadx-gui/src/main/java/jadx/gui/device/debugger · high confidence

The Jadx GUI now includes a new Smali disassembler and debugger subsystem located in jadx-gui/src/main/java/jadx/gui/device/debugger/smali. This adds the ability to view and debug Android Smali bytecode directly within the interface, featuring register tracking (SmaliRegister, RegisterInfo), method node management (SmaliMethodNode), and a dedicated SmaliWriter for output generation. Users can now inspect Smali code with improved parameter handling and debug information integration.

jadx-gui/src/main/java/jadx/gui/device/debugger/smali · high confidence

Added several new utility classes in the UI utils package to support recent GUI enhancements. ActionHandler provides a flexible wrapper for Swing actions with key binding support. ActionMessageBox offers a simple dialog with customizable action buttons. FileOpenerHelper enables exporting and opening resource files via the system desktop. ZoomActions implements text zooming functionality using keyboard shortcuts and mouse wheel, integrating with the font settings. NodeLabel provides a JLabel variant with HTML disabling capabilities. ListenersHelper manages UI listener lifecycle. MouseListenerAdapter and MousePressedHandler simplify mouse event handling. SimpleMenuItem creates menu items with actions. DocumentUpdateListener handles document change events.

jadx-gui/src/main/java/jadx/gui/utils/ui · high confidence

A new plugin has been added to support XAPK files, which are ZIP archives containing a manifest and multiple split APKs. The implementation extracts the archive contents to a temporary directory, parses the manifest to identify split APKs and additional resource files, and then delegates the actual decompilation of the APKs to the existing Dex input plugin. This allows users to decompile complex XAPK packages directly, handling both the split APKs and any non-APK files included in the package.

jadx-xapk-input · high confidence

A new input plugin has been added to support loading .xapk files. This change introduces the XApkInputPlugin which registers a custom code input and resources loader, along with supporting data models (XApkData, XApkManifest, SplitApk) to parse the XApk manifest and manage the associated split APKs and files.

jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input · high confidence

The \jadx-core/src/main/java/jadx/core/xmlgen\ package now includes a complete rewrite of the Android resource decoding infrastructure. This introduces \BinaryXMLParser\ and \ResTableBinaryParser\ to handle binary XML (AXML) and resource table (resources.arsc) files, replacing previous ad-hoc parsing. The new implementation features \BinaryXMLStrings\ for robust string pool extraction (including UTF-8/16 and handling of invalid offsets via \INVALID\_STRING\_PLACEHOLDER\), \ManifestAttributes\ for decoding Android-specific enum/flag attributes, and \ResXmlGen\ for generating structured XML output. It also adds \ParserStream\ for low-level binary reading, \ResourceStorage\ for managing resource entries, and \ResNameUtils\ for sanitizing resource names to valid Java identifiers. This change improves the accuracy and performance of decompiling Android resources.

jadx-core/src/main/java/jadx/core/xmlgen · high confidence

A new resource file, jadx-build-info.properties, has been added to the core resources. This file exposes the application version and the specific bundle type (e.g., full, minimal) via the properties jadx-version and jadx-bundle-type, allowing users or tools to programmatically identify the build configuration.

jadx-core/src/main/resources · high confidence

The jadx-analysis module now includes a new call graph analysis library. This adds the ability to build a call graph from decompiled code, with options to filter by package and include only resolved calls. The analysis results can be exported to DOT format for visualization or to JSON for programmatic use, and the module includes tests to verify the functionality.

jadx-analysis, jadx-commons/jadx-analysis · high confidence

This change introduces a new metadata subsystem in jadx-core that enables precise mapping between decompiled code and original source positions. It adds interfaces (ICodeMetadata, ICodeAnnotation) and implementations (CodeMetadataStorage) to store and query annotations such as variable definitions, method/class declarations, and instruction offsets. This allows the decompiler to provide accurate line mappings and support features like code pane synchronization and graph views by exposing structured metadata about the decompiled output.

jadx-core/src/main/java/jadx/api/metadata · high confidence

The GUI now provides dedicated right-click (context) menus for JClass, JPackage, JResource, and debugger variable tree nodes. Users can export classes to Java or Smali formats (including Simple and Fallback decompilation modes), export entire packages or resource directories/files to disk, and interact with debugger variables by copying values, setting new values, or changing numeric values to zero or one. A new RecentProjectsMenuListener also populates the recent projects menu with clickable paths to open previous projects.

jadx-gui/src/main/java/jadx/gui/ui/popupmenu · high confidence

The DEX input plugin has been replaced with a new implementation that includes a custom zip reader to prevent zipbomb attacks and validates DEX file checksums before parsing (enabled by default via the verify-checksum option). It also adds support for loading DEX v41 files, which can contain multiple sub-DEX structures within a single container, and improves error reporting for invalid magic bytes and checksums.

jadx-plugins/jadx-dex-input/src/main/java/jadx/plugins/input · high confidence

The jadx-zip module now includes a custom ZIP parser implementation (JadxZipParser) alongside a new set of interfaces (IZipEntry, IZipParser) and configuration options (ZipReaderFlags, ZipReaderOptions). This change introduces direct InputStream access for ZIP entries, enabling more efficient memory usage for large files. It also adds robust security features, including path traversal prevention (rejecting absolute paths and CWD-relative entries), zip bomb detection based on compressed/uncompressed size ratios, and configurable limits on the maximum number of entries. The parser supports fallback to the standard Java implementation for compatibility and includes flags to ignore central directory entries or disable fallback behavior.

jadx-commons/jadx-zip · high confidence

Added two new visitors to the decompilation pipeline: DebugInfoAttachVisitor, which parses and attaches source line mappings and local variable debug information to instructions before block splitting, and DebugInfoApplyVisitor, which applies this debug data to SSA variables after type inference. This ensures that variable names, types, and source line numbers from the original DEX debug info are correctly propagated to the final Java code, improving the readability and accuracy of the decompiled output.

jadx-core/src/main/java/jadx/core/dex/visitors/debuginfo · high confidence

The deobfuscation module now supports loading and saving deobfuscation maps (\.jobf\ files) to preserve and restore renamed packages, classes, fields, and methods across sessions. A new \DeobfAliasProvider\ generates deterministic aliases based on class hierarchy and type, while \FileTypeDetector\ uses file headers to detect extensions for obfuscated resources. The \NameMapper\ ensures generated names are valid Java identifiers by removing invalid characters and respecting reserved keywords.

jadx-core/src/main/java/jadx/core/deobf · high confidence

The jadx-gui now includes a suite of new dialog windows to enhance debugging, code inspection, and project configuration. Users can connect to Android devices and manage processes via the new ADB dialog, and modify debugger variable values using the SetValue dialog. Code analysis is improved with the Usage dialog for tracking references and the Methods dialog for selecting methods for script generation. Project management features include the ExcludePkg dialog to filter packages during decompilation, the Charset dialog to select file encodings, and the Comment dialog to add or edit code comments. Additional utilities include the GotoAddress dialog for hex viewer navigation, the LogViewer dialog for application logs, and the Rename dialog for renaming project nodes.

jadx-gui/src/main/java/jadx/gui/ui/dialog · high confidence

The code area now supports a 'Dynamic' theme that automatically adapts syntax highlighting and UI colors to match the current system light or dark mode, ensuring consistent visual appearance. Additionally, the editor now allows users to load custom themes via external XML files, providing greater flexibility for personalization beyond the built-in options like Eclipse, IDEA, and VS.

jadx-gui/src/main/java/jadx/gui/ui/codearea/theme · high confidence

The jadx-plugins-tools module now includes a new JadxExternalPluginsLoader class that handles loading external plugins from JAR files and directories. This loader uses URLClassLoader to isolate plugin classes and supports loading plugins from both individual JAR files and directories containing JARs. The implementation includes proper resource cleanup through the close() method and validates that only one plugin is loaded per JAR file. A test resource file has also been added to support testing with GitHub plugin list releases in ZIP format.

jadx-plugins-tools · high confidence

Jadx-GUI now supports a new plugin architecture that distinguishes between global and project-scoped plugins. A new \jadx-gui-api\ module introduces \JadxGlobalGuiPlugin\ and \JadxGuiContextExt\, allowing plugins to register options and access the main window at application startup, independent of any specific project. The \GuiPluginsManager\ in the GUI module handles the loading, initialization, and unloading of these global plugins, ensuring they are available across all projects and properly cleaned up when the main window closes.

jadx-gui-api, jadx-gui/src/main/java/jadx/gui/plugins · high confidence

The Jadx GUI now includes a new graph visualization module in the ui.graphs package, providing interactive views for class inheritance, method call relationships, and control flow. Users can open a Class Inheritance Graph to explore super/subclass hierarchies with options to show overrides and siblings, a Call Graph to trace caller/callee relationships with adjustable depth limits, a Class Method Graph to view intra-class method calls, and a Control Flow Graph (CFG) with presets to inspect the method at different decompilation stages. All graphs are rendered using Graphviz, support zooming and panning, and can be exported as SVG files.

jadx-gui/src/main/java/jadx/gui/ui/graphs · high confidence

The jadx-core module introduces a suite of new internal attribute classes in the \jadx.core.dex.attributes.nodes\ package to support advanced decompilation logic. These additions include \AnonymousClassAttr\ and \InlinedAttr\ for tracking anonymous and inlined classes, \ClassTypeVarsAttr\ and \MethodTypeVarsAttr\ for resolving generic type variables, and \EnumClassAttr\ and \EnumMapAttr\ for restoring enum structures. The update also adds \JadxCommentsAttr\ for managing decompiler comments, \CodeFeaturesAttr\ for identifying code patterns like switches, and various control-flow attributes such as \LoopInfo\, \JumpInfo\, and \ExcSplitCrossAttr\ to improve the handling of loops and exception handlers.

jadx-core/src/main/java/jadx/core/dex/attributes/nodes · high confidence

The application now includes a dedicated log viewer panel that allows users to filter logs by level (Debug, Info, Warn, Error, Off) and mode (All, All Scripts, Current Script). The viewer supports docking to the main window and automatically filters logs to the currently active script when in 'Current Script' mode, providing real-time updates and a clear view of script-specific output.

jadx-gui/src/main/java/jadx/gui/logs · high confidence

The jadx-core module now exposes a new \jadx.api.plugins.gui\ package containing interfaces that allow plugins to interact directly with the GUI environment. \IJadxGuiPlugin\ marks plugins as GUI-only, preventing them from loading in the CLI. \JadxGuiContext\ provides methods for plugins to add global menu entries, code viewer and tree node popup menu actions, register global key bindings, access the main window frame, load SVG icons, and perform code navigation actions like jumping to nodes under the caret or mouse, opening usage dialogs, and reloading tabs. \ISettingsGroup\ and \JadxGuiSettings\ enable plugins to define and register custom settings pages within the preferences window.

jadx-core/src/main/java/jadx/api/plugins/gui · high confidence

The Jadx GUI now exposes a new plugin API that allows extensions to interact directly with the user interface context. Plugins can register custom actions that appear in the code editor's right-click menu, add entries to the file tree's context menu, and define custom categories for the Inputs tree view. Additionally, plugins can now retrieve the code node currently under the caret or mouse cursor, enabling more context-aware automation and analysis tools.

jadx-gui/src/main/java/jadx/gui/plugins/context · high confidence

The jadx-core module now includes a new event system in the \jadx.api.plugins.events\ package, allowing plugins to react to specific GUI actions. This introduces interfaces for sending and listening to events (\IJadxEvents\, \IJadxEvent\) and defines three concrete event types: \NodeRenamedByUser\ (to notify when a user renames a code node), \ReloadProject\ (to request a project reload), and \ReloadSettingsWindow\ (to request a settings window reload). This infrastructure enables plugins to synchronize their state with user interactions in the GUI.

jadx-core/src/main/java/jadx/api/plugins/events · high confidence

The Preferences window now includes a dedicated Plugins section where users can install, uninstall, and disable plugins, as well as view and install available plugins from the official list. This new UI replaces the previous plugin configuration approach, providing a centralized location to manage plugin settings and updates.

jadx-gui/src/main/java/jadx/gui/settings/ui/plugins · high confidence

JADX now includes a new plugin management system that allows users to install, update, and uninstall plugins from GitHub releases or local files. The system introduces a plugin registry with resolvers for GitHub (pattern: \github:\<owner\>:\<repo\>\) and local files (\file:\<path\>\), supporting both \.jar\ and \.zip\ artifacts. It features automatic version compatibility checking against the current JADX version, caching of the available plugin list to reduce update checks, and metadata storage for installed plugins. This infrastructure enables future CLI and GUI features for plugin discovery and management.

jadx-plugins-tools/src/main/java/jadx/plugins/tools · high confidence

The core library now exposes a structured API for plugin settings via the new \jadx.api.plugins.options\ package. Plugins can define options with specific types (STRING, NUMBER, BOOLEAN) and descriptions, while the \OptionFlag\ enum allows fine-grained control over how these options appear in the GUI. Specifically, the \PER\_PROJECT\ flag enables settings to be stored per-project rather than globally, \HIDE\_IN\_GUI\ allows plugins to manage their own UI, and \DISABLE\_IN\_GUI\ marks options as read-only. This change provides a standardized way for plugins to expose configurable parameters with clear scope and visibility rules.

jadx-core/src/main/java/jadx/api/plugins/options · high confidence

Adds the 'rename-mappings' plugin, which allows users to load external mapping files (via the new \LoadMappingsPass\) to apply names during decompilation and export any manual renames or comments back to a mapping file (via \MappingExporter\). This enables round-trip support for deobfuscation workflows, letting users preserve and extend mapping data across JADX sessions.

jadx-rename-mappings · high confidence

The UI panel layer now includes dedicated viewers for specific resource types: FontPanel renders font previews, ImagePanel displays images, and HtmlPanel shows HTML content. ResourcePanel provides a tabbed interface that switches between code, hex, and type-specific views (like font or image) based on the resource type. Additionally, JDebuggerPanel and LogcatPanel introduce a new integrated debugger interface with stack frame inspection, variable trees, and Android logcat filtering, while IssuesPanel offers a summary view of analysis errors and warnings.

jadx-gui/src/main/java/jadx/gui/ui/panel · high confidence

A new SignatureParser class has been added to handle the parsing of Java generic signatures. This component extracts signature attributes from class nodes and processes type variables, object types, arrays, and primitives to reconstruct generic type information for methods and classes.

jadx-core/src/main/java/jadx/core/dex/nodes/parser · high confidence

The main window now displays a start page on launch, featuring a list of recent projects that can be opened via double-click or removed individually. Users can also load APK files directly by dragging and dropping them onto the main window.

jadx-gui/src/main/java/jadx/gui/ui · high confidence

The tree view now includes a new Summary node that displays a detailed report of the decompiled input, including file paths, code sources, class/method/field/instruction counts, native library information (architectures and counts), and decompilation status (loaded, processed, generated classes) along with error and warning statistics. Additionally, a new UndisplayedStrings node has been added to the tree to notify users when the current font cannot display certain characters found in the code, providing a dedicated panel to view these strings.

jadx-gui/src/main/java/jadx/gui/ui/treenodes · high confidence

A new \TaskExecutor\ implementation has been introduced to manage background tasks, supporting both parallel and sequential execution stages. This component allows users to configure the number of threads used for parallel processing and provides mechanisms to monitor progress, terminate execution, and handle errors such as \OutOfMemoryError\ during processing.

jadx-core/src/main/java/jadx/core/utils/tasks · high confidence

The tree model layer now includes a comprehensive set of new node classes (JNode, JClass, JMethod, JField, JPackage, JResource, JInputFile, JInputSmaliFile, JRoot, JSources, JInputs, JEditableNode, JLoadableNode, JSubResource, JVariable, JResSearchNode, JInputFiles, JRenameNode, CodeNode, and ApkSignatureNode) that define the hierarchical structure of the decompiled code, resources, and input files in the GUI. These classes provide the foundation for displaying packages, classes, methods, fields, and resources in the tree view, handling lazy loading, renaming, editing, and content display for various file types including smali files and APK signatures.

jadx-gui/src/main/java/jadx/gui/treemodel · high confidence

The Jadx GUI now uses a new \JadxUpdate\ component to handle version checks, introducing support for both stable and unstable (nightly) release channels. For stable releases, the application compares the current version against the latest GitHub release tag, while for unstable releases, it fetches the most recent build artifacts from the master branch workflow. This change replaces the previous update logic, ensuring that development versions are correctly ignored and that version comparisons work accurately for both release types.

jadx-gui/src/main/java/jadx/gui/update · high confidence

Added a new \UsageInfoVisitor\ and supporting \UsageInfo\ and \UseSet\ classes in the core decompiler to systematically scan classes and methods for usage data. This visitor collects dependencies between classes, tracks which methods use or are used by other methods (including unresolved ones), records field usage, and identifies self-calls, providing a structured foundation for features like rename and graph views.

jadx-core/src/main/java/jadx/core/dex/visitors/usage · high confidence

Added several new utility classes in jadx-gui/src/main/java/jadx/gui/utils to support GUI state management and display. CacheObject manages search state and node caching. CaretPositionFix preserves cursor position during code refreshes. CertificateManager handles X.509 certificate display. FontUtils provides composite font loading for CJK support. Icons and IconsCache manage SVG icon loading. JNodeCache handles Java node caching. JumpManager and JumpPosition manage navigation history. LafManager handles FlatLaf theme switching. NLS manages internationalization. PathTypeAdapter, RectangleTypeAdapter, and RelativePathTypeAdapter handle JSON serialization. ObjectPool provides object pooling. OverlayIcon supports icon overlays. SimpleListener provides event notification. DesktopEntryUtils handles Linux desktop integration. Link provides safe URL opening. HexUtils handles hex string validation. IOUtils provides stream utilities. ILoadListener defines load state notifications. DefaultPopupMenuListener provides popup menu event handling.

jadx-gui/src/main/java/jadx/gui/utils · high confidence

A new command-line utility, ConvertToClsSet, has been added to the CLI module. This tool allows users to convert dex or jar input files into a Jadx class set (.jcst) file for a specific Android API level. It is designed to help maintain the core class set by disabling unnecessary deobfuscation and renaming passes during the conversion process, ensuring that the resulting class set accurately reflects the input bytecode structure for that API level.

jadx-cli/src/main/java/jadx/cli/clst · high confidence

The Jadx GUI now saves decompiled code and associated metadata (such as line mappings and code annotations) to the local disk cache. This change introduces a new disk-backed caching layer that persists decompiled classes across sessions, allowing the GUI to load previously analyzed code directly from disk rather than re-decompiling it, which improves startup and navigation performance for large projects.

jadx-gui/src/main/java/jadx/gui/cache/code/disk · high confidence

The Jadx GUI now integrates plugin configuration and custom tree inputs directly into the user interface. Users can view and modify plugin options through the Preferences window, with settings grouped by plugin and wrapped to handle errors gracefully. Additionally, plugins can now contribute custom nodes to the input tree based on file filters, allowing for more flexible organization of decompiled sources.

jadx-gui/src/main/java/jadx/gui/utils/plugins · high confidence

The repository is initialized with essential project scaffolding: a Gradle wrapper (gradlew/gradlew.bat) for building, a GitLab CI configuration (.gitlab-ci.yml) to run tests on Java 11, and standard configuration files (.editorconfig, .gitattributes, .gitignore) to enforce code style and line endings. Documentation and legal files are added, including a comprehensive README.md with usage instructions, a CONTRIBUTING.md guide, a CODE\_OF\_CONDUCT.md, a SECURITY.md policy, the Apache 2.0 LICENSE, and a NOTICE file listing third-party dependencies like ASM and RSyntaxTextArea.

(repo-wide) · high confidence

The code display components have been restructured into a new package-based hierarchy (AbstractCodeArea, CodeArea, SmaliArea, etc.) to support multiple code views. This change introduces a split-view mode for Java classes, allowing users to view Java source and Smali bytecode side-by-side with synchronized scrolling. It also adds dedicated Smali code areas with specific syntax highlighting and folding, a binary resource viewer for hex inspection, and improved line number formatting that can switch between normal and debug source lines.

jadx-gui/src/main/java/jadx/gui/ui/codearea · high confidence

The Java bytecode input plugin is now automatically discovered and loaded by the JADX core. A new service provider configuration file registers the \jadx.plugins.input.java.JavaInputPlugin\ implementation, enabling the application to recognize and process Java class files without manual plugin configuration.

jadx-plugins/jadx-java-input · high confidence

The XApkInputPlugin is now registered in the Jadx plugin service configuration, enabling the application to automatically discover and use the new XAPK input handler without manual configuration.

jadx-plugins/jadx-xapk-input · high confidence

The jadx-kotlin-source-debug-extension plugin now parses the Kotlin SourceDebugExtension attribute (SMAP) to rename decompiled classes and packages to their original source names. This behavior is controlled by the new 'kotlin-smap.class-alias-source-dbg' option (defaulting to false); when enabled, the plugin extracts the original class and package names from the SMAP mapping and applies them during the decompilation process, improving the readability of Kotlin code.

jadx-kotlin-source-debug-extension, jadx-plugins/jadx-kotlin-source-debug-extension, jadx-plugins/jadx-kotlin-source-debug-extension/src/main/kotlin/jadx/plugins/kotlin · high confidence

The rename mappings functionality has been restructured into a dedicated plugin module (\jadx-rename-mappings\), introducing a new \RenameMappingsData\ attribute to store the loaded mapping tree and \RenameMappingsOptions\ to handle configuration such as format selection and inversion. The core logic is now split into two distinct passes: \ApplyMappingsPass\ handles renaming classes, fields, and methods during the prepare phase, while the new \CodeMappingsPass\ applies mappings to method arguments and variables during decompilation. Supporting utilities like \DalvikToJavaBytecodeUtils\ and \VariablesUtils\ have been added to accurately map Dalvik register indices to Java local variable indices, ensuring that argument and variable names from mapping files are correctly applied to the decompiled code.

jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings · high confidence

The search functionality in the jadx-gui has been rewritten to use a new provider architecture (BaseSearchProvider and specific providers for classes, methods, fields, code, comments, and resources). This change introduces the ability to limit code and method searches to a specific package via the SearchSettings. Additionally, resource searches now support filtering by content type (text or binary) and file extension using a new ResourceFilter, and include a configurable size limit to skip large files during search.

jadx-gui/src/main/java/jadx/gui/search/providers · high confidence

The search functionality has been restructured to use a new provider-based model (ISearchProvider, SearchJob) that allows for more flexible and parallelized search execution. Users can now configure search settings including regex support, case-insensitivity, package-specific searching, and resource size limits. The new architecture also introduces a results limit feature to prevent excessive memory usage and improves performance by optimizing background task execution.

jadx-gui/src/main/java/jadx/gui/search · high confidence

JADX now includes support for the JSR (jump to subroutine) and RET (return from subroutine) opcodes, which were previously unsupported. This change enables the decompiler to correctly process Java bytecode containing subroutine calls, improving the accuracy of decompiled output for older Java versions or specific library code that utilizes these instructions.

jadx-core/src/main/java/jadx/core/dex/instructions/java · high confidence

The rename visitor now applies user-defined renames (stored in ICodeData) to classes, fields, methods, and packages. This allows users to customize names via the API or GUI, with the changes persisted in the project. The system handles class, field, and method renames by resolving references and applying new names, while also supporting package renames. It includes checks for validity, uniqueness, and case-sensitivity on different filesystems, and integrates with the existing rename logic to ensure consistency.

jadx-core/src/main/java/jadx/core/dex/visitors/rename · high confidence

Users can now configure custom keyboard and mouse shortcuts for application actions. This change introduces a new shortcut management system that validates key combinations, prevents invalid modifiers, and supports mouse button bindings via a global event listener, allowing users to tailor the interface to their preferences.

jadx-gui/src/main/java/jadx/gui/utils/shortcut · high confidence

JADX now allows users to load .smali source files (and directories containing them) as input. The new smali-input plugin compiles these files into DEX format in-memory using the Google fork of the Smali library, supporting multi-threaded compilation and configurable API levels, and then passes the resulting DEX data to the standard DexInputPlugin for decompilation.

jadx-smali-input · high confidence

Users can now view the same class using different decompilation strategies. A new JCodeMode node has been added to the tree structure, allowing the GUI to present distinct views of a class based on the selected DecompilationMode, which triggers the appropriate decompilation logic when the node is accessed.

jadx-gui/src/main/java/jadx/gui/ui/codearea/mode · high confidence

Users can now drag and drop tabs to reorder them within the Jadx GUI. This change introduces a new drag-and-drop controller that handles the gesture, manages a visual 'ghost' indicator (which can be an image, outline, or target mark based on settings), and automatically scrolls the tab bar when dragging near the edges. The implementation adds the necessary Swing components and listeners to detect the drag origin, track the drop target, and swap the tab positions upon release.

jadx-gui/src/main/java/jadx/gui/ui/tab/dnd · high confidence

The decompiler now supports applying specific styles to code comments via the new CodeComment utility and CommentStyle integration, allowing for more structured output. Additionally, the logic for adding file source information has been refined to prevent duplicate 'loaded from:' comments from appearing for inner classes that share the same input file as their declaring class.

jadx-core/src/main/java/jadx/core/codegen/utils · high confidence

The mappings plugin now allows users to view and edit the content of loaded mapping files directly within the JADX GUI. A new 'JInputs' node appears in the project tree, displaying the currently loaded mapping file (e.g., Proguard, R8, or other supported formats) as an editable text node. Users can open mapping files via the new 'Open Mappings' menu, and any changes made in the editor are reflected in the underlying mapping data. The plugin also integrates with the existing save functionality, allowing users to save changes back to the original file or export them in various formats using the 'Save Mappings As' menu.

jadx-gui/src/main/java/jadx/gui/plugins/mappings · high confidence

The macOS distribution now includes configuration files that register specific file extensions with the system, allowing users to open Android-related files directly in jadx. This change adds support for opening .aab, .aar, .apk, .apkm, .apks, .arsc, .dex, .smali, and .xapk files as viewers, while .jadx project files are set as the default owner/editor for that format.

jadx-gui/dist · high confidence

A new LogUtils class has been introduced to sanitize strings and byte arrays before they are passed to the logger. This change addresses a CodeQL security advisory regarding Java log injection by replacing non-alphanumeric characters (with specific exceptions like underscores and punctuation) with dots, ensuring that untrusted input cannot manipulate log output.

jadx-core/src/main/java/jadx/core/utils/log · high confidence

The Jadx API has been restructured to improve usability and extensibility. The central configuration class is now JadxArgs, which exposes granular options for decompilation behavior (such as DecompilationMode, CommentsLevel, and IntegerFormat), deobfuscation controls, and output settings. The core entry point remains JadxDecompiler, but it now relies on new interfaces like ICodeWriter and ICodeInfo to manage code generation and metadata. Additionally, the API introduces dedicated wrapper classes for decompiled elements (JavaClass, JavaMethod, JavaField, JavaVariable, JavaPackage) and resource handling (ResourceFile, ResourceType), providing a cleaner programmatic interface for accessing decompiled code and resources.

jadx-core/src/main/java/jadx/api · high confidence

The build configuration has been rewritten from Groovy to Kotlin DSL, introducing new shared Gradle convention plugins (jadx-java, jadx-kotlin, jadx-library) to standardize Java/Kotlin compilation, testing, and Maven publishing across subprojects. This change centralizes dependency management via a version catalog (libs.versions.toml), enforces Java 11 as the baseline toolchain, and configures consistent publishing settings for Maven Central, including source/javadoc jars and signing.

buildSrc · high confidence

The input API has been extracted into a dedicated library module, introducing a new set of interfaces and data classes in the \jadx.api.plugins.input\ package to represent decompiled code structures. This includes \ICodeLoader\ and \JadxCodeInput\ for managing input sources, and detailed data models like \IClassData\, \IMethodData\, \IFieldData\, and \ICodeReader\ to expose class hierarchy, methods, fields, and instruction streams. The diff also adds support for specific bytecode features such as JSR/RET opcodes via the \JAVA\_JSR\ opcode, and introduces a comprehensive attribute system (\IJadxAttribute\, \JadxAttrType\) to handle annotations, signatures, and other metadata, along with \AccessFlags\ formatting for better readability of class, field, and method modifiers.

jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input · high confidence

The core deobfuscation and class-info handling in jadx-core has been refactored to use new, immutable info classes (AccessInfo, ClassAliasInfo, ClassInfo, FieldInfo, MethodInfo, PackageInfo) and a centralized InfoStorage. AccessInfo now provides immutable flag manipulation and visibility checks. ClassInfo and ClassAliasInfo handle class naming, package changes, and inner-class relationships with proper aliasing. FieldInfo and MethodInfo now support aliases and generate stable short/full IDs for identification. ConstStorage uses ConcurrentHashMap for value storage and tracks duplicates to avoid redundant constant replacements. InfoStorage ensures single-instance caching for classes, fields, and methods, improving memory efficiency and consistency during deobfuscation and renaming operations.

jadx-core/src/main/java/jadx/core/dex/info · high confidence

The internal mechanism for storing decompiler attributes (flags and metadata) on code nodes has been rewritten. A new lazy-initialization pattern uses a singleton empty storage instance, allocating memory only when attributes are actually added, which reduces overhead for nodes with no attributes. The storage implementation is now thread-safe, using synchronization to prevent race conditions during concurrent writes. Additionally, the system now supports unloading attributes from memory when they are no longer needed, helping to reduce the application's memory footprint during large-scale decompilation tasks.

jadx-core/src/main/java/jadx/core/dex/attributes · high confidence

The code shrink visitor in jadx-core has been refactored to improve variable inlining logic. This change introduces new internal classes, ArgsInfo and WrapInfo, to better manage instruction arguments and inlining states. The refactoring aims to enhance the efficiency and correctness of the code shrinking process, which inlines variables to reduce code size.

jadx-core/src/main/java/jadx/core/dex/visitors/shrink · high confidence

The code generation logic in jadx-core has been restructured from a monolithic implementation into a set of specialized classes (AnnotationGen, ClassGen, CodeGen, ConditionGen, InsnGen, MethodGen, NameGen, RegionGen, SimpleModeHelper, and TypeGen). This refactoring improves code organization and maintainability, allowing distinct concerns like annotation formatting, instruction handling, and region processing to be managed independently without changing the decompiled output for users.

jadx-core/src/main/java/jadx/core/codegen · high confidence

The internal structure of the decompilation engine has been reorganized to improve modularity and maintainability. This change introduces a new \PackageNode\ to explicitly represent package hierarchies, allowing for better package renaming and navigation. The core tree nodes (\ClassNode\, \MethodNode\, \FieldNode\, \BlockNode\) have been refactored to implement specific interfaces (\ICodeNode\, \ILoadable\, \IBlock\, etc.), standardizing how code generation, loading, and usage information are handled. Additionally, new utility classes like \InsnContainer\ and \Edge\ have been added to support more flexible control-flow graph representations and instruction grouping.

jadx-core/src/main/java/jadx/core/dex/nodes · high confidence

The internal representation of instruction arguments and types has been restructured to improve type inference and SSA (Static Single Assignment) variable handling. This change introduces a new \ArgType\ hierarchy with specific types for primitives, objects, arrays, and wildcards, alongside dedicated argument classes like \RegisterArg\, \LiteralArg\, and \InsnWrapArg\. The \SSAVar\ class now centrally manages variable types and usage, enabling more accurate type propagation and immutable type tracking. Users will benefit from more precise decompiled code, especially regarding generic types, array handling, and variable naming, as the new structure supports better type resolution and reduces redundant casts.

jadx-core/src/main/java/jadx/core/dex/instructions/args · high confidence

The internal representation of Dalvik bytecode instructions has been restructured to use specific node classes (such as ArithNode, IfNode, InvokeNode, and SwitchInsn) instead of generic instruction nodes. This change introduces dedicated enums for operation types (ArithOp, IfOp, InvokeType) and separates instruction logic from data payloads (e.g., FillArrayData), resulting in a more robust and maintainable core that improves the accuracy of decompiled output for arithmetic, conditional, and invocation instructions.

jadx-core/src/main/java/jadx/core/dex/instructions · high confidence

The core decompilation logic in jadx-core has been restructured to improve the reliability and readability of generated Java code. A new iterative depth-first traversal engine (DepthRegionTraversal) replaces previous recursive approaches, preventing stack overflows on deeply nested methods and enabling partial or iterative visits. This infrastructure supports a suite of specialized visitors that now handle specific control-flow patterns: loops are converted to indexed or for-each variants, if-else chains are optimized and reordered, switch statements (including string switches) are restored and breaks are extracted, and try-catch/finally blocks are correctly wrapped. Additionally, redundant code such as unnecessary returns in void methods and empty regions is cleaned up, resulting in cleaner, more idiomatic decompiled output.

jadx-core/src/main/java/jadx/core/dex/visitors/regions · high confidence

The rename mappings functionality has been extracted into its own dedicated plugin module (jadx-rename-mappings). This change includes the necessary service provider configuration to register the RenameMappingsPlugin and adds test resources to verify inner class renaming behavior, ensuring the feature remains available as a distinct, loadable component within the JADX architecture.

jadx-plugins/jadx-rename-mappings · high confidence

The core decompilation logic in jadx-core has been reorganized into a dedicated \jadx.core.dex.visitors\ package. This change introduces a new \AbstractVisitor\ base class to standardize the visitor interface and groups specific analysis and transformation passes—such as \AnonymousClassVisitor\, \ConstInlineVisitor\, \ConstructorVisitor\, and \AttachTryCatchVisitor\—into distinct, manageable files. This modularization improves code maintainability and clarifies the execution order of the decompilation pipeline.

jadx-core/src/main/java/jadx/core/dex/visitors · high confidence

Android App Bundle (AAB) input support has been extracted from the core into a new standalone plugin (jadx-aab-input). To facilitate this, new extension interfaces (IResContainerFactory, IResTableParserProvider, IResourcesLoader) were added to the core resource loading API, allowing plugins to register custom resource parsers and container factories. The AAB plugin registers itself via the standard service provider mechanism.

jadx-core/src/main/java/jadx/api/plugins/resources, jadx-plugins/jadx-aab-input · high confidence

A new utility class, InsnDataUtils, has been added to the core input processing package. It provides static helper methods to safely extract ICallSite, IMethodRef, and IMethodHandle objects from instruction data, handling cases where custom payloads are present or where standard index casting is required. This supports more robust handling of dynamic string concatenation and method handle invocations during decompilation.

jadx-core/src/main/java/jadx/core/utils/input · high confidence

The CLI has been restructured to support a command-based interface, introducing a 'plugins' command for installing and managing plugins from the command line. This change also adds the ability to disable specific plugins via a new CLI option and introduces a 'single-class' mode to decompile and save only a specific class file. Additionally, the CLI now supports saving decompiled output as a call graph in JSON or DOT formats, and improves the handling of deobfuscation mapping files with new options to specify the file path and its handling mode.

jadx-cli/src/main/java/jadx/cli · high confidence

The JadxFiles utility class now serves as the single source of truth for locating the GUI configuration file (gui.json), the cache list file (caches.json), and the main cache directory. These paths are resolved via the shared JadxCommonFiles interface, ensuring that the GUI consistently uses the same base directories for user settings and cached data as the rest of the application.

jadx-gui/src/main/java/jadx/gui/utils/files · high confidence

The project now enforces a standardized Java code style using an Eclipse-based formatter and explicit import ordering rules. A new \eclipse.xml\ profile defines specific formatting settings (such as indentation, spacing, and brace placement), while \eclipse.importorder\ establishes a strict hierarchy for imports (java, javax, org, com, jadx). This ensures that all source code is formatted consistently, reducing stylistic noise in diffs and improving readability across the codebase.

config/code-formatter · high confidence

The Jadx GUI now provides more complete and updated translations for its interface in German, English, Spanish, Indonesian, Korean, Brazilian Portuguese, Russian, Simplified Chinese, and Traditional Chinese. These updates to the i18n resource files ensure that menus, dialogs, search options, and status messages are accurately displayed in the user's preferred language, improving the overall usability of the application.

jadx-gui/src/main/resources/i18n · high confidence

The decompiler now inserts Android resource IDs as \android.R\ fields when the resource mapping is available, making Android-specific constants more readable. Additionally, it prevents the replacement of constant fields that are still actively used in the code, avoiding incorrect decompilation of inlined values. These changes are implemented via new visitor passes (\AddAndroidConstants\ and \CollectConstValues\) that manage constant collection and replacement logic more precisely.

jadx-core/src/main/java/jadx/core/dex/visitors/prepare · high confidence

The package view now correctly handles renaming operations and ensures that non-leaf packages containing classes are visible in the sources tree. A new JRenamePackage utility class manages package rename logic and validation, while PackageHelper refactors the tree preparation to flatten package structures where appropriate, fixing issues where intermediate packages were previously hidden.

jadx-gui/src/main/java/jadx/gui/utils/pkgs · high confidence

The new FileUtils class in jadx-core provides a unified set of file operations, replacing previous ad-hoc handling. It introduces NIO-based directory listing and expansion, safe directory deletion with existence checks, and centralized temporary directory management (creating and updating a temp root dir). This centralizes file I/O logic, improving consistency and reliability for core file operations.

jadx-core/src/main/java/jadx/core/utils/files · high confidence

The jadx-kotlin-metadata plugin now exposes a dedicated options class that allows users to enable or disable specific Kotlin metadata features, including class alias renaming, method argument renaming, field renaming, companion object handling, data class modifier addition, toString-based field renaming, and getter renaming. This change introduces a new plugin options structure that controls which metadata-driven transformations are applied during decompilation, giving users finer control over how Kotlin-specific constructs are presented in the decompiled output.

jadx-kotlin-metadata · high confidence

The Jadx GUI now supports three distinct code caching strategies—Memory, Disk with Cache, and Disk—allowing users to choose how decompiled code is stored. This change introduces a new CodeCacheMode enum for localized preference labels and implements the underlying caching logic: CodeStringCache adds a memory-resident string cache that automatically clears itself when free memory is low to prevent out-of-memory issues, while FixedCodeCache provides a mode where the cache size is fixed and additions/removals are ignored, effectively disabling dynamic cache growth.

jadx-gui/src/main/java/jadx/gui/cache/code · high confidence

The jadx-zip module now uses a new custom ZIP parser (JadxZipParser) by default for APK files, replacing the standard Java implementation to improve security against tampering and zip-slip attacks. This parser enforces limits on the number of entries and data stream sizes, and logs warnings for duplicate entry names. For non-APK ZIP files, the system attempts to use the custom parser but falls back to the standard Java implementation if the custom parser cannot open the file, ensuring compatibility with a wider range of archives. The change also introduces a new ZipReader API that provides direct InputStream access to ZIP entries and supports visiting entries with a visitor pattern.

jadx-zip · high confidence

The reactive utility classes in the GUI module have been updated to use RxJava 3 instead of the previous RxJava 2 version. This migration introduces new helper classes such as CustomDisposable for managing resource cleanup and DebounceUpdate for handling input throttling, alongside updated utility methods in RxUtils that now emit RxJava 3 Flowables for tracking changes in text fields, spinners, and scroll bars.

jadx-gui/src/main/java/jadx/gui/utils/rx · high confidence

The Jadx GUI now uses a new \BackgroundExecutor\ and task interface system to run operations like decompilation, loading, and exporting in the background. This new architecture introduces built-in memory and time limits, allowing the application to automatically cancel or skip tasks if resources are exhausted, which prevents UI freezes and improves stability during large file processing. Users will see a more responsive interface with accurate progress indicators and clearer feedback when tasks are interrupted due to timeouts or memory constraints.

jadx-gui/src/main/java/jadx/gui/jobs · high confidence

JADX now includes a new security API (IJadxSecurity) that allows users to enable specific security flags to harden the decompilation process. When enabled, the secure XML parser disables external DTDs, entities, and XInclude to prevent XXE attacks. The secure ZIP reader validates entry names and paths to prevent directory traversal. Additionally, when exporting Gradle scripts, string values are sanitized by removing dangerous characters (such as quotes, semicolons, and shell metacharacters) to prevent injection vulnerabilities. Users can toggle these protections (VERIFY\_APP\_PACKAGE, SECURE\_XML\_PARSER, SECURE\_ZIP\_READER, SANITIZE\_STRINGS) via JadxArgs.

jadx-core/src/main/java/jadx/api/security · high confidence

The GUI now uses a dedicated event system to handle internal state changes, replacing direct calls with an event bus. This introduces a \RenameService\ that listens for user-initiated rename events, ensuring that code data, class trees, and open tabs are consistently refreshed in the background. It also defines a \TreeUpdate\ event to signal when the class tree structure changes, allowing other components to react to these updates without tight coupling.

jadx-gui/src/main/java/jadx/gui/events · high confidence

The decompiler now introduces dedicated instruction modifiers to better represent Java bytecode structures. A new \ConstructorInsn\ class distinguishes between standard object construction, \super\ calls, and constructor chaining (\this\/\self\), enabling more accurate reconstruction of object initialization logic. Additionally, a \TernaryInsn\ class is added to handle ternary conditional expressions, allowing the decompiler to preserve the structure of \condition ? trueVal : falseVal\ statements rather than flattening them into basic if-else blocks.

jadx-core/src/main/java/jadx/core/dex/instructions/mods · high confidence

The GUI now uses a dedicated renderer for method lists that displays method signatures with icons indicating access modifiers and static/final status, supporting selection via checkboxes. Additionally, the usage tree view now highlights the selected path with distinct colors and applies level-based background shading to improve navigation clarity.

jadx-gui/src/main/java/jadx/gui/ui/cellrenders · high confidence

The plugin system now exposes a new set of core interfaces in jadx-core to define plugin behavior and metadata. JadxPlugin serves as the base interface with init and unload lifecycle methods, while JadxPluginContext provides the runtime environment for registering passes, code inputs, options, and accessing events or GUI context. JadxPluginInfo and its builder introduce structured metadata including plugin ID, name, description, homepage, conflict resolution via 'provides', and a new requiredJadxVersion field to enforce compatibility. Additionally, CustomResourcesLoader allows plugins to define custom resource loading logic.

jadx-core/src/main/java/jadx/api/plugins · high confidence

The plugin system now supports explicit loading, initialization, and unloading of plugins via the new \JadxPluginManager\, allowing plugins to be dynamically added or removed during runtime. Additionally, plugins can now declare a minimum required JADX version, and the system will automatically verify compatibility and prevent loading incompatible plugins.

jadx-core/src/main/java/jadx/core/plugins · high confidence

The plugin options implementation in jadx-core has been updated to use a new \BasePluginOptionsBuilder\ class, which provides a fluent builder API for defining plugin options with specific types (boolean, string, integer, enum), parsers, and formatters. This replaces the older, deprecated \BaseOptionsParser\ approach, allowing plugins to declare their configuration options more robustly and consistently. A \NoPluginOptions\ singleton and an \OptionBuilder\ interface are also introduced to support this new structure.

jadx-core/src/main/java/jadx/api/plugins/options/impl · high confidence

The resource decoding subsystem now uses new data structures (EntryConfig, ResourceEntry, ProtoValue, RawValue) and a dedicated ValuesParser to handle Android resource configurations and value decoding. This introduces support for grammatical inflection qualifiers (masculine, feminine, neuter) in resource configurations and improves the decoding of resource references by mapping them to android.R fields when a local resource map is unavailable, resulting in more accurate and readable decompiled resource values.

jadx-core/src/main/java/jadx/core/xmlgen/entry · high confidence

The Jadx GUI settings system has been restructured to support granular user preferences and improved state management. Users can now configure custom keyboard shortcuts via a dedicated settings panel, adjust the UI zoom factor, and select from various line number display modes. The application now persists the state of open tabs, tree expansions, and window positions across sessions, ensuring a consistent workspace upon restart. Additionally, the settings data model has been updated to version 23, introducing new options for cache directory configuration, code comment levels, and Xposed code generation language, while excluding transient environment data from exportable settings.

jadx-gui/src/main/java/jadx/gui/settings · high confidence

This change introduces two new utility classes, CommonFileUtils and Utils, in the jadx.api.plugins.utils package to provide shared helpers for file operations (such as saving to temp files, loading bytes, and handling ZIP extensions) and collection manipulation (concatenation, distinct merging, and formatting). It also adds a new ZipSecurity class that wraps the core ZIP reader and security logic, exposing methods to validate entry names, check for ZIP bombs, and retrieve input streams with size limits; this class is marked as deprecated in favor of using the ZipReader directly via JadxDecompiler or JadxPluginContext.

jadx-core/src/main/java/jadx/api/plugins/utils · high confidence

The project file format has been updated to persist the state of open tabs (including their position, scroll offset, and pinned/bookmarked status), the user's search history, and custom keyboard shortcuts. Additionally, the project data model now stores the cache directory path, live reload preference, and search resource filters, ensuring these settings are restored when a project is reopened.

jadx-gui/src/main/java/jadx/gui/settings/data · high confidence

The GUI action system has been restructured to use a centralized \ActionModel\ enum and \ActionCategory\ for defining all menu items, toolbar buttons, and context menu options, replacing the previous scattered implementation. This change introduces a unified action framework (\JadxGuiAction\, \CodeAreaAction\, \JNodeAction\) that supports custom user-defined keyboard shortcuts and proper lifecycle management. New actions added to the interface include 'Copy Reference' for classes, methods, and fields, a 'Go to Android Manifest' button, and improved Frida/Xposed snippet generation with method selection dialogs. The refactoring also ensures that all NLS keys are strictly validated and that action states are correctly synchronized with the UI context.

jadx-gui/src/main/java/jadx/gui/ui/action · high confidence

The code generation pipeline has been refactored to introduce a new \ICodeInfo\ interface and associated implementations (\SimpleCodeInfo\, \AnnotatedCodeInfo\) that separate generated code from its metadata. This enables the \AnnotatedCodeWriter\ to attach source line mappings and code annotations during decompilation, providing richer context for the output. Additionally, a new \ICodeCache\ abstraction with implementations like \InMemoryCodeCache\ and \NoOpCodeCache\ has been added to support caching decompiled code, improving performance for repeated access.

jadx-core/src/main/java/jadx/api/impl · high confidence

The deobfuscation logic in jadx-core has been restructured into a set of distinct, pluggable condition classes (such as BaseDeobfCondition, DeobfWhitelist, and ExcludePackageWithTLDNames) that implement a common interface. This change allows the tool to apply specific renaming rules—like avoiding collisions between class and package names, respecting user whitelists, or excluding Android R classes—more cleanly and independently, improving the maintainability and extensibility of the deobfuscation process.

jadx-core/src/main/java/jadx/core/deobf/conditions · high confidence

The exception handling structure in jadx-core has been reorganized to provide more specific error types for different failure modes. A new base checked exception, JadxException, has been introduced to replace the previous generic RuntimeException, allowing callers to distinguish between recoverable and unrecoverable errors. Additionally, specialized exceptions such as CodegenException, DecodeException, JadxOverflowException, and JadxArgsValidateException have been added to provide context-specific error reporting for code generation, decoding, resource limits, and argument validation respectively. All new exception classes include a serialVersionUID to ensure serialization compatibility.

jadx-core/src/main/java/jadx/core/utils/exceptions · high confidence

The application now explicitly registers the DEX input plugin (jadx.plugins.input.dex.DexInputPlugin) and the Java conversion plugin (jadx.plugins.input.javaconvert.JavaConvertPlugin) via their respective META-INF/services descriptors. This ensures these components are discovered and loaded by the plugin system, enabling the tool to process DEX files and convert Java code as intended.

jadx-plugins/jadx-dex-input, jadx-plugins/jadx-java-convert · high confidence

The type inference logic in jadx-core has been completely rewritten to use a new constraint-based system. This introduces a visitor pipeline (TypeInferenceVisitor, FixTypesVisitor, FinishTypeInference) that calculates types for SSA variables by collecting bounds and resolving them via propagation or a multi-variable search algorithm. The new system handles complex generic types, wildcards, and field/invoke assignments more accurately, while also preventing stack overflows and infinite loops during the inference process.

jadx-core/src/main/java/jadx/core/dex/visitors/typeinference · high confidence

The font selection interface in the settings has been replaced with a custom dialog (JadxFontDialog) that wraps the FontChooser library. This new dialog enforces monospace-only selection when appropriate and hides the font preview pane to simplify the user experience. It also integrates with FontUtils to ensure selected fonts are properly composed, particularly supporting CJK characters.

jadx-gui/src/main/java/jadx/gui/settings/ui/font · high confidence

The try-catch analysis engine in jadx-core has been rewritten to use a new set of classes (CatchAttr, ExcHandlerAttr, TryCatchBlockAttr, TryEdge, TryEdgeScopeGroupMap) that model exception handling as a graph of edges and scopes. This structural change improves the handling of complex control flow, including nested try-catches with overlapping blocks, multi-catch blocks, and all-catch (Throwable) handlers, leading to more accurate decompilation of exception handling logic.

jadx-core/src/main/java/jadx/core/dex/trycatch · high confidence

The Jadx settings window has been redesigned to organize options into a hierarchical tree on the left and a scrollable content panel on the right. This change introduces a new \JadxSettingsWindow\ that manages distinct settings groups (such as Decompilation, Deobfuscation, Rename, Cache, Appearance, Shortcuts, Project, Plugins, and Other) via a \SettingsTree\ component, replacing the previous linear layout. Users will now navigate settings by selecting categories in the tree, with the corresponding configuration controls displayed in the adjacent pane, improving discoverability and reducing visual clutter.

jadx-gui/src/main/java/jadx/gui/settings/ui · high confidence

The Jadx GUI now uses a centralized exception handling system that provides users with more actionable error feedback. When an uncaught exception occurs, the application displays a detailed dialog containing environment information (Jadx/Java version, platform, heap size) and the full stack trace, along with a direct link to open a new GitHub issue for the relevant project. If the exception originates from a plugin, the issue link points to that plugin's specific GitHub repository rather than the main Jadx project. Additionally, file-related errors (such as 'File not found' or 'Access denied') are handled by a separate, simpler message box that offers a 'Report' button to trigger the full error dialog, ensuring users get clear, context-aware guidance without overwhelming them with technical details for common I/O mistakes.

jadx-gui/src/main/java/jadx/gui/report · high confidence

Jadx now detects and correctly handles cases where Android resource constants are used in contexts requiring constant expressions, a behavior introduced in AGP 8.0.0 where resource IDs are no longer final. A new visitor scans for resource references in annotations and switch statements, flagging these instances to ensure accurate decompilation of modern Android projects.

jadx-core/src/main/java/jadx/core/dex/visitors/gradle · high confidence

The Jadx GUI now saves and loads method, field, and class usage information to a disk cache file, significantly speeding up subsequent analysis of the same inputs. This change introduces a new serialization format (version 3) for usage data, including support for unresolved method references, and ensures that cached data is invalidated if the input files change.

jadx-gui/src/main/java/jadx/gui/cache/usage · high confidence

A fix in jadx-core/src/main/resources/clst — 5 commits (4 fixs), 1 file.

jadx-core/src/main/resources/clst · medium confidence · unverified

New wrapper classes (DecompilePassWrapper, PreparePassWrapper) and an interface (IPassWrapperVisitor) have been added to the pass execution layer. These wrappers encapsulate the actual plugin passes, ensuring that exceptions (including StackOverflowError in the decompile pass) during initialization or traversal are caught, logged, and recorded on the affected nodes rather than crashing the entire processing pipeline.

jadx-core/src/main/java/jadx/api/impl/passes · high confidence

The decompiler now includes a dedicated pass to correct class and method access modifiers when the 'respect bytecode access modifiers' option is disabled. This ensures that private or package-private members are promoted to public or protected as needed when they are accessed by other classes or methods, preventing decompilation errors and producing valid Java code that compiles correctly.

jadx-core/src/main/java/jadx/core · high confidence

The new ProcessKotlinInternals visitor now correctly identifies the Kotlin Intrinsics class by checking class aliases, ensuring that variable names extracted from intrinsic methods are reliably applied during decompilation.

jadx-core/src/main/java/jadx/core/dex/visitors/kotlin · high confidence

The decompiler now provides better support for complex invokedynamic (invoke-custom) instructions. It correctly handles lambda calls by recognizing both \LambdaMetafactory.metafactory\ and \altMetafactory\, supports dynamic string concatenation via \StringConcatFactory.makeConcatWithConstants\, and outputs unknown invoke-custom sites as polymorphic calls to prevent decompilation errors.

jadx-core/src/main/java/jadx/core/dex/instructions/invokedynamic · high confidence

The deobfuscation engine now uses a new 'BetterName' utility to select more readable class and resource names by preferring identifiers with fewer digits and greater length, replacing the previous rating-based approach. Additionally, a new 'DebugChecks' system has been added to the core processing pipeline to validate SSA variable consistency, block registration, and instruction invariants after every visitor pass, helping to catch internal state errors during decompilation.

jadx-core/src/main/java/jadx/core/utils · high confidence

The Jadx GUI now uses composite fonts to ensure consistent rendering and better support for CJK characters across different platforms. On non-macOS systems, the application bundles and installs FlatLaf fonts (Inter and JetBrains Mono) as defaults, while macOS retains the system default font to avoid CJK rendering issues with bundled fonts. Font sizes now scale dynamically with the UI zoom level, allowing users to adjust text size seamlessly when changing the interface zoom.

jadx-gui/src/main/java/jadx/gui/settings/font · high confidence

This update introduces new utility classes to enhance the decompiler's handling of complex Java features. MethodUtils now provides robust logic for resolving method details, including support for method overrides, bridge methods, and argument skipping, which leads to more accurate method signatures in the output. TypeUtils expands the engine's capability to resolve generic type variables by traversing class hierarchies and outer classes, ensuring that generic types are correctly instantiated even in nested or inherited contexts. Additionally, SelectFromDuplicates implements a deterministic strategy for choosing the best class definition when multiple duplicates exist, prioritizing classes from lower-numbered dex files (e.g., classes2.dex over classes3.dex) to improve consistency in multi-dex applications.

jadx-core/src/main/java/jadx/core/dex/nodes/utils · high confidence

The tree view now correctly saves and restores the user's expansion state (which nodes are expanded) across sessions. A new \TreeExpansionService\ handles this by serializing expanded paths into a specific format (identifying packages, classes, or generic nodes) and restoring them asynchronously after the tree model has loaded, ensuring the UI reflects the user's previous navigation preferences without blocking the main thread.

jadx-gui/src/main/java/jadx/gui/tree · high confidence

Added three new utility classes in jadx-core to improve the handling of basic block graphs: BlockPair provides a simple immutable pair for block relationships; BlockSet offers a BitSet-backed set for efficient block membership, iteration, and intersection operations; and DFSIteration implements a depth-first search traversal over blocks. These utilities support more robust control-flow analysis, including better handling of exception handlers and path-based checks.

jadx-core/src/main/java/jadx/core/utils/blocks · high confidence

A new \MutableMethodDetails\ class has been added to the method visitor package to provide a mutable wrapper around method signatures. This component allows the decompiler to temporarily modify return types, argument types, type parameters, and throw types during the analysis phase, which is necessary to support improved generics handling and type variable resolution from super types without altering the original immutable method definitions.

jadx-core/src/main/java/jadx/core/dex/visitors/methods · high confidence

The decompiler now uses dedicated region classes (SwitchRegion, SynchronizedRegion, TryCatchRegion) to model control-flow structures more explicitly. This allows the tool to correctly track switch cases, synchronized block entry/exit points, and try/catch/finally boundaries, leading to more accurate reconstruction of these constructs in the decompiled output.

jadx-core/src/main/java/jadx/core/dex/regions · high confidence

The decompiler's condition analysis has been restructured to use a new set of classes (Compare, IfCondition, IfInfo, ConditionRegion, IfRegion) for managing if-statement logic. This change introduces a more robust model for representing and simplifying boolean conditions, including support for ternary operators, logical AND/OR, and negation, which improves the accuracy of decompiled code for complex conditional structures.

jadx-core/src/main/java/jadx/core/dex/regions/conditions · high confidence

The loop handling logic in jadx-core has been refactored to introduce dedicated region classes (LoopRegion, ForEachLoop, ForLoop) that explicitly model loop structures. This change ensures that code semantics are preserved during the decompilation of for-each loops over arrays and iterables, as well as indexed for-loops, by storing loop arguments in fake instructions with inlining disabled. Users will see more accurate and semantically correct Java code when decompiling these specific loop constructs.

jadx-core/src/main/java/jadx/core/dex/regions/loops · high confidence

The monolithic region maker logic has been split into dedicated classes (ExcHandlersRegionMaker, IfRegionMaker, LoopRegionMaker, SwitchRegionMaker, SynchronizedRegionMaker) to improve maintainability and fix various control-flow reconstruction issues, including preventing endless loops on dead code, correcting if-region out-block selection, and handling static synchronized methods more accurately.

jadx-core/src/main/java/jadx/core/dex/visitors/regions/maker · high confidence

The variable declaration logic in jadx-core has been rewritten to improve the accuracy of decompiled code. This change introduces a new visitor (CollectUsageRegionVisitor) that more precisely tracks variable usage across regions, including specific handling for loop initialization and increment instructions. It also adds logic to remove unused SSA variables and results, check for type conflicts between immutable types and code variables, and correctly handle constructor arguments. This results in cleaner variable declarations and better handling of edge cases like unused results and type mismatches.

jadx-core/src/main/java/jadx/core/dex/visitors/regions/variables · high confidence

The Jadx application now correctly recognizes and processes Smali files as an input format. This is achieved by adding the service provider configuration file (META-INF/services/jadx.api.plugins.JadxPlugin) which registers the SmaliInputPlugin, ensuring the plugin is loaded and available for decompiling Smali sources.

jadx-plugins/jadx-smali-input · high confidence

The internal logic for building the control-flow graph and processing exception handlers has been completely rewritten. This change introduces dedicated classes for splitting basic blocks, computing dominator and post-dominator trees, and handling multi-entry loops, which collectively improve the accuracy of decompiled code for complex structures like nested try/catch/finally blocks, switch fallthroughs, and legacy JSR/RET subroutines.

jadx-core/src/main/java/jadx/core/dex/visitors/blocks · high confidence

The \jadx-core\ finally block extraction visitor has been completely rewritten to improve the accuracy of decompiling nested try/catch/finally structures. The new implementation introduces a dedicated \MarkFinallyVisitor\ that utilizes a graph-based \TraverserController\ to compare control flow paths and identify duplicate instructions across different branches. This approach replaces the previous logic with a more robust strategy for detecting common code segments, handling variable merging, and preventing null pointer exceptions during the analysis of complex exception handlers.

jadx-core/src/main/java/jadx/core/dex/visitors/finaly · high confidence

Add test utility classes for API testing; Added AssertJ-based assertion utilities for Jadx test code; Added CLI integration tests for input formats and Gradle export; Added base test class for simplified APK debugging; Added comprehensive test coverage for Jadx-GUI components; Added empty test class for try-catch block attributes; Added functional tests for core decompilation components; Added integration tests for 'this' reference handling; Added integration tests for Android R field restoration and constant replacement; Added integration tests for Java 8 lambda decoding; Added integration tests for Java deobfuscation name collision handling; Added integration tests for annotation handling and deobfuscation; Added integration tests for arithmetic instruction decompilation; Added integration tests for array access reordering and code comment styling; Added integration tests for array initialization and filling; Added integration tests for condition handling and code style; Added integration tests for debug information accuracy; Added integration tests for decompiler core behaviors; Added integration tests for deobfuscation edge cases; Added integration tests for fallback decompilation mode; Added integration tests for generic type resolution and decompilation; Added integration tests for inner and anonymous class decompilation; Added integration tests for loop decompilation patterns; Added integration tests for method inlining edge cases; Added integration tests for method invocation and overload resolution; Added integration tests for stack manipulation and exception handling; Added integration tests for switch statement decompilation; Added integration tests for synchronized block handling; Added integration tests for the rename feature; Added integration tests for try/catch/finally decompilation; Added integration tests for type inference and resolution; Added integration tests for variable handling and SSA correctness; Added regression test for enum with no-arg constructor; Added smali test cases for array initialization and fill-array-data instructions; Added smali test fixtures for complex enum patterns; Added smali test fixtures for edge-case decompilation scenarios; Added test case for Java 8 lambda instance decoding; Added test case for anonymous class inlining; Added test case for constructor type resolution in smali decompilation; Added test case for loop condition branch restoration; Added test case for reserved package name handling; Added test case for source file name class aliasing; Added test case for variable name propagation in debug info; Added test cases for anonymous class self-inlining; Added test cases for anonymous classes with non-default constructors; Added test cases for arithmetic instructions; Added test cases for boolean-to-primitive casts and complex conditional logic; Added test cases for case-sensitive name checks; Added test cases for case-sensitive name resolution; Added test cases for class names with invalid characters; Added test cases for complex generics, synthetic overrides, and missing type signatures; Added test cases for complex loop structures in Jadx core; Added test cases for complex method inlining scenarios; Added test cases for complex switch-over-string patterns; Added test cases for complex synchronized block structures; Added test cases for complex variable handling in decompiled code; Added test cases for constructor instruction ordering; Added test cases for default package class renaming; Added test cases for field name collision with package names; Added test cases for invoke instruction handling; Added test cases for local variable name collision with package names; Added test cases for method inlining and class access modifier fixes; Added test cases for method override resolution with same name; Added test cases for nested anonymous classes; Added test cases for nested class access modifier handling; Added test cases for package-private method override visibility; Added test cases for reserved names and duplicated fields; Added test cases for super-class loop handling; Added test cases for synthetic constructor handling; Added test cases for synthetic inline method handling in Kotlin lambdas; Added test cases for synthetic lambda accessor inlining; Added test cases for synthetic method renaming in inner classes; Added test cases for type inference with inner classes; Added test coverage for Gradle export configuration options; Added test coverage for wildcard handling in invoke type resolution; Added test fixtures for bad method access modifiers; Added test fixtures for full inner class generic types; Added test fixtures for instance lambda inlining; Added test fixtures for synthetic constructor and method renaming; Added test for Android resource map loading; Added test for StackMapTable stack info handling; Added test for deobfuscation rename disablement; Added test for fallback mode with many NOP instructions; Added test for handling NOP instructions in unexpected places; Added test infrastructure for tracking known failures; Added test input for switch-over-enum-by-ordinal; Added test inputs for specific JVM opcodes and Java features; Added test resources and configuration files; Added tests for AccessInfo visibility changes; Added tests for ArgType generic and wildcard handling; Added tests for GitHub plugin release resolution and error handling; Added tests for Java input plugin loading and utility decoders; Added tests for LogUtils escape functionality; Added tests for NameMapper identifier validation and sanitization; Added tests for core utility classes; Added tests for duplicate class selection and type variable replacement; Added tests for inner class renaming via mappings; Added tests for package-info class handling; Added tests for plugin manager loading and GUI plugin scoping; Added tests for plugin version compatibility and comparison logic; Added tests for plugin version extraction utility; Added tests for primitive type conversions and type comparison logic; Added tests for string sanitization in Gradle script exports; Added tests for the Dex input plugin; Added try/catch test fixtures for complex control flow scenarios; Added unit tests for JadxDecompiler API and argument validation; Added unit tests for resource XML generation and name sanitization; Expanded integration tests for enum decompilation edge cases; Expanded test coverage for type inference and resolution; New test infrastructure for API-level integration and Gradle export validation; New test infrastructure for compiling and verifying decompiled Java code.

The project's Gradle wrapper has been updated to use Gradle 9.7.1. This ensures that builds are executed with a consistent, specific version of the Gradle build tool, improving reproducibility and potentially leveraging new features or performance improvements available in this release.

gradle · high confidence

The project build has been migrated from Groovy to Kotlin DSL (build.gradle.kts) and now uses a centralized version catalog (gradle/libs.versions.toml) to manage dependencies. This change introduces specific library updates including Kotlin 2.4.10, FlatLaf 3.7.2, and the Google fork of Smali 3.0.9, while also configuring Spotless for code formatting and enabling the Gradle version catalog update plugin.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 65 (+4.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 75 → 85 (+9.2)
• Architecture 100 → 94 (-6.1)
• Maturity 58 → 58 (+0.1)
• Readiness 59 → 61 (+2.2)
• Security 55 → 72 (+17.4)

• Change coupling: BackgroundExecutor.java ↔ DecompileTask.java (jadx-gui/src/main/java/jadx/gui/jobs/BackgroundExecutor.java)
• Change coupling: DebugController.java ↔ ADBDialog.java (jadx-gui/src/main/java/jadx/gui/device/debugger/DebugController.java)
• Change coupling: TabbedPane.java ↔ JumpManager.java (jadx-gui/src/main/java/jadx/gui/ui/tab/TabbedPane.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (jadx-core/src/main/java/jadx/api/plugins/utils/Utils.java)
• Duplicated block (10 lines × 2) (jadx-core/src/main/java/jadx/core/xmlgen/entry/EntryConfig.java)
• Duplicated block (10 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/MainWindow.java)
• Duplicated block (10 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/action/ViewClassInheritanceGraphAction.java)
• Duplicated block (10 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/codearea/sync/InsnOffsetJavaSyncer.java)
• Duplicated block (10 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/dialog/UsageDialog.java)
• Duplicated block (10 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/dialog/UsageDialog.java)
• Duplicated block (10 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/graphs/CallGraphDialog.java)
• Duplicated block (10 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/hexviewer/search/service/BinarySearchServiceImpl.java)
• Duplicated block (10 lines × 2) (jadx-plugins/jadx-dex-input/src/main/java/jadx/plugins/input/dex/insns/DexInsnData.java)
• Duplicated block (11 lines × 2) (jadx-core/src/main/java/jadx/core/utils/BlockUtils.java)
• Duplicated block (11 lines × 2) (jadx-core/src/main/java/jadx/core/xmlgen/ResXmlGen.java)
• Duplicated block (11 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/dialog/SearchDialog.java)
• Duplicated block (11 lines × 2) (jadx-gui/src/main/java/jadx/gui/ui/popupmenu/VarTreePopupMenu.java)
• Duplicated block (11 lines × 2) (jadx-plugins/jadx-dex-input/src/main/java/jadx/plugins/input/dex/DexFileLoader.java)
• …and 116 more

• ClassInheritanceGraphDialog.visitClass (cognitive 17) (jadx-gui/src/main/java/jadx/gui/ui/graphs/ClassInheritanceGraphDialog.java)
• ClassTooLong: ADBDialog (jadx-gui/src/main/java/jadx/gui/ui/dialog/ADBDialog.java)
• ClassTooLong: ArgType (jadx-core/src/main/java/jadx/core/dex/instructions/args/ArgType.java)
• ClassTooLong: BlockProcessor (jadx-core/src/main/java/jadx/core/dex/visitors/blocks/BlockProcessor.java)
• ClassTooLong: BlockUtils (jadx-core/src/main/java/jadx/core/utils/BlockUtils.java)
• ClassTooLong: ClassNode (jadx-core/src/main/java/jadx/core/dex/nodes/ClassNode.java)
• ClassTooLong: DebugController (jadx-gui/src/main/java/jadx/gui/device/debugger/DebugController.java)
• ClassTooLong: EntryConfig (jadx-core/src/main/java/jadx/core/xmlgen/entry/EntryConfig.java)
• ClassTooLong: EnumVisitor (jadx-core/src/main/java/jadx/core/dex/visitors/EnumVisitor.java)
• ClassTooLong: FixTypesVisitor (jadx-core/src/main/java/jadx/core/dex/visitors/typeinference/FixTypesVisitor.java)
• ClassTooLong: IfRegionMaker (jadx-core/src/main/java/jadx/core/dex/visitors/regions/maker/IfRegionMaker.java)
• ClassTooLong: InsnDecoder (jadx-core/src/main/java/jadx/core/dex/instructions/InsnDecoder.java)
• ClassTooLong: JadxArgs (jadx-core/src/main/java/jadx/api/JadxArgs.java)
• ClassTooLong: JadxCLIArgs (jadx-cli/src/main/java/jadx/cli/JadxCLIArgs.java)
• ClassTooLong: JadxDecompiler (jadx-core/src/main/java/jadx/api/JadxDecompiler.java)
• ClassTooLong: JadxSettings (jadx-gui/src/main/java/jadx/gui/settings/JadxSettings.java)
• ClassTooLong: JadxSettingsWindow (jadx-gui/src/main/java/jadx/gui/settings/ui/JadxSettingsWindow.java)
• ClassTooLong: LoopRegionMaker (jadx-core/src/main/java/jadx/core/dex/visitors/regions/maker/LoopRegionMaker.java)
• ClassTooLong: MainWindow (jadx-gui/src/main/java/jadx/gui/ui/MainWindow.java)
• ClassTooLong: MethodNode (jadx-core/src/main/java/jadx/core/dex/nodes/MethodNode.java)
• …and 429 more

• 15 commits — 7 feature/other, 8 fixes

• jadx-gui/src — 9 commits
• .github/workflows — 2 commits
• jadx-core/src — 2 commits
• gradle/wrapper — 1 commit
• jadx-plugins/jadx-apkm-input — 1 commit

• fix: fix(gui): allow adb serial numbers with 8 and 9 characters (#2927, PR #2928)
• fix: fix(gui): avoid project reload when saving settings on start page (PR #2943)
• fix: fix(gui): improve Chinese localization in Messages_zh_CN.properties (PR #2934)
• fix: fix(gui): load next binary block at block boundary (PR #2948)
• fix: fix(gui): use save mode for package directory export (PR #2937)
• fix: fix(quark): fix missing string escape in report panel, resolve some code warnings
• fix: fix(test): resolve unstable test
• fix: fix: sanitize user comments (PR #2940)
• change: build(deps): bump actions/setup-dotnet from 5 to 6 (PR #2931)
• change: build(deps): bump actions/setup-java from 5 to 6 (PR #2944)
• change: build(gradle): migrate to libs version catalog
• change: chore: update gradle
• change: feat(api): new jadx-gui-api and global scoped gui plugins (PR #2945)
• change: feat(gui): add tree filter (PR #2941)
• change: feat(gui): make inheritance graphs display both super and subclass relations (PR #2935)

• Containers 0 added · 0 removed · contexts 16 added · 1 removed · edges 27 added · 0 removed

• jadx-aab-input
• jadx-analysis
• jadx-apkm-input
• jadx-cli
• jadx-core
• jadx-dex-input
• jadx-gui
• jadx-input-api
• jadx-java-convert
• jadx-java-input
• jadx-kotlin-metadata
• jadx-kotlin-source-debug-extension
• jadx-plugins-tools
• jadx-rename-mappings
• jadx-smali-input
• jadx-zip

• .

• jadx-aab-input → jadx-core
• jadx-analysis → jadx-core
• jadx-cli → jadx-core
• jadx-cli → jadx-plugins-tools
• jadx-core → jadx-input-api
• jadx-core → jadx-zip
• jadx-dex-input → jadx-core
• jadx-dex-input → jadx-input-api
• jadx-dex-input → jadx-zip
• jadx-gui → jadx-cli
• jadx-gui → jadx-core (coupling)
• jadx-gui → jadx-input-api
• jadx-gui → jadx-plugins-tools
• jadx-java-convert → jadx-core
• jadx-java-convert → jadx-input-api
• jadx-java-convert → jadx-zip
• jadx-java-input → jadx-core
• jadx-java-input → jadx-input-api
• jadx-java-input → jadx-zip
• jadx-plugins-tools → jadx-core
• …and 7 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

skylot/jadx was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.