τTau SolutionsHerramientas

Decompiladores a Java

Antes conviene leer «Anatomía de un APK», «Bytecode Dalvik»

referencia técnica · Actualizado el 15 de noviembre de 2026

1. Qué es y por qué existe

Un APK no lleva dentro código fuente. Lleva classes*.dex: bytecode Dalvik, instrucciones que trabajan con casillas numeradas (registros v0, v1…). Dicen qué hace el programa, pero no cómo estaba escrito. Decompilar a Java es intentar el camino inverso, de las instrucciones a un texto que una persona pueda leer como si fuera el original.

La palabra clave es intento. Compilar Java o Kotlin a DEX pierde información a propósito: descarta nombres, aplana construcciones del lenguaje, reordena instrucciones y borra tipos. Un decompilador no puede deshacer eso, porque no hay vuelta atrás; produce un programa distinto que se comporta igual. Cuando acierta, la diferencia es cosmética y ni la notas. Cuando falla, el resultado va desde un método que no compila hasta el caso peligroso: un método que compila, parece razonable y no dice lo que la aplicación hace.

Aquí repasamos las herramientas que hacen ese trabajo y, sobre todo, dónde fallan. El nivel de abajo, el bytecode que se decompila, está en «Bytecode Dalvik». El nivel intermedio, que es fiel en lugar de reconstruido, está en «Desensambladores smali».

2. Qué se pierde, y por qué no vuelve

Antes de comparar herramientas conviene fijar el techo. Ninguna de las de este documento puede recuperar lo que sigue, porque no está en el fichero.

2.1 Los genéricos

La JVM implementa los genéricos por borrado de tipos (type erasure): en tiempo de ejecución List<String> y List<Integer> son la misma clase. Parte de la información sobrevive en el atributo Signature, que D8 propaga al DEX como la anotación dalvik.annotation.Signature, y los decompiladores buenos la leen. Pero es un atributo opcional: R8 no detecta quién lo lee por reflexión, así que lo descarta salvo que se pida -keepattributes Signature (y en modo completo, incluso entonces, solo lo conserva en las clases que cubre una regla -keep). Sin él, la firma genérica desaparece sin dejar rastro y el decompilador solo puede escribir el tipo crudo.

Consecuencia práctica: un Map<String, List<Usuario>> puede salir como Map. El programa sigue siendo correcto; la intención del autor, no.

Cuántas apps conservan las firmas genéricas no lo hemos contado. Lo que sí sabemos es que el modo completo de R8, el que solo las guarda en las clases con una regla -keep, es lo normal. Lo usan casi nueve de cada diez apps de F-Droid, IzzyOnDroid y el sorteo de Google Play que declaran su modo, y el 72 % de las más instaladas de Google Play.

2.2 El azúcar sintáctico

Todo lo que el compilador de Java o de Kotlin traduce a construcciones más simples se pierde como forma, aunque se conserve como comportamiento:

En el fuente En el DEX Qué recupera el decompilador
for (X x : lista) Bucle con Iterator explícito El for extendido, casi siempre
switch sobre String Dos switch: uno sobre hashCode(), otro sobre el índice A veces; si no, dos switch anidados sin sentido aparente
Lambda / referencia a método Clase sintética: D8 reescribe el invokedynamic de LambdaMetafactory con cualquier --min-api Depende del decompilador; es de lo más frágil
try-with-resources try/finally anidados con addSuppressed Rara vez; suele salir el finally expandido
Autoboxing Integer.valueOf(...) Se ve la llamada, no el azúcar
Concatenación con + StringBuilder, con el desazucarado activo: D8 reescribe el invokedynamic de StringConcatFactory, que entonces no llega al DEX Normalmente sí
Clases internas Clases separadas con this$0 y accesores sintéticos Se reconstruyen, con cicatrices
enum Clase con campos estáticos y array $VALUES Normalmente sí

En el DEX de una app normal no hay instrucciones especiales para las lambdas ni para concatenar texto: D8 las convierte en clases y llamadas corrientes. Las lambdas dejan una huella fácil de contar, unas clases sintéticas llamadas $$ExternalSyntheticLambda. Las llevan algo más de una de cada tres apps de F-Droid e IzzyOnDroid, la mitad de las más instaladas de Google Play, siete de cada diez en el sorteo de Google Play y dos de cada diez en el mercado chino.

En cambio, casi ninguna app trae call sites, las entradas que usa la instrucción invoke-custom. Solo hemos visto una, en IzzyOnDroid: com.droidheat.musicplayer 35, con minSdk 26 y 24 call sites. Entre las apps con minSdk 26 o más son 1 de 489 en IzzyOnDroid y ninguna en los demás grupos; con minSdk menor de 26 no hay ninguna. No hemos investigado por qué esa app los conserva.

Nada de esto es un fallo del decompilador. Es que la información no viaja.

2.3 Los nombres de las variables locales

Los nombres de parámetros y de variables locales viven en debug_info_item, un bloque de información de depuración que acompaña al código (code_item) de cada método. Es una estructura opcional, y es lo único que guarda esos nombres. R8 no la borra entera: casi siempre deja los números de línea (qué línea del fuente corresponde a cada instrucción), pero quita los nombres.

Con R8, los nombres prácticamente desaparecen. Entre las apps que lo usan, entre el 83 % y el 94 % conserva los números de línea según la fuente, pero casi ninguna los nombres: 10 de más de 2.700 en F-Droid y ninguna de 409 entre las más instaladas de Google Play. Sin R8 es al revés: los conservan más de la mitad de las apps en todos los grupos (del 55 % al 91 %).

Dos aclaraciones sobre la medida. «Con R8» quiere decir que el DEX lleva el marcador ~~R8. Y «algún nombre» quiere decir que un bloque de depuración nombra un parámetro, una variable local o el fichero fuente; como no separa los tres, da un máximo. Por eso, en una app con R8, jadx escribe nombres inventados (str, i, list2) aunque el APK lleve números de línea.

Dos ejemplos de F-Droid sin ningún nombre: com.termux 1022, con R8 2.2.71 en modo compatibilidad, tiene 16.758 de sus 17.898 code_item con debug_info y 0 con nombres; org.fossify.math 10, con R8 8.11.18 en modo completo, tiene 2.592 de 27.616 con debug_info y 0 con nombres. Dos de las pocas apps de F-Droid con R8 que sí conservan algún nombre son pw.thedrhax.mosmetro 77 y com.mishiranu.dashchan 1043. D8 tiene una opción para quitar la información de depuración, --no-debug-info; no hemos medido su uso, porque en el DEX no consta con qué opciones se compiló.

Sin debug_info, el decompilador tiene que inventar nombres. jadx los deriva del tipo y del número de registro (str, i, list2, obj), lo cual es legible pero no es el nombre original y no debe citarse como tal. Los nombres de campos y de métodos son otra cosa: esos sí están en las tablas del DEX, salvo que R8 los haya ofuscado, y entonces el problema ya no es la decompilación sino la ofuscación, que trata «R8 y ProGuard».

Puedes comprobarlo con el ejemplo mínimo de la «sección 4 de Desensambladores smali · .registers sobre código real». javac -g pone los nombres en el .class, pero quien decide si llegan al DEX es d8: con --debug, su valor por defecto, el bloque locals de dexdump los muestra (restante, cantidad, forzar); con --release, el del ejemplo, salen como (null). Y sin -g no llegan ni con --debug. Lo comprobamos el 18 de octubre de 2026 con el D8 9.2.4-dev de build-tools 37.0.0.

2.4 El orden real del código

R8 no se limita a renombrar. Hace inlining de métodos pequeños, outlining de secuencias repetidas a un método sintético compartido, elimina ramas muertas, fusiona clases y mueve código entre métodos. Lo que sale del decompilador es el programa después de esas transformaciones.

En cristiano: R8 copia el cuerpo de los métodos pequeños dentro de quien los llama (inlining) y, al revés, saca los trozos repetidos a un método común (outlining). El inlining no deja marca que se pueda contar. Un tipo concreto de outlining, el de las llamadas a APIs nuevas de Android, sí: las clases sintéticas $$ExternalSyntheticApiModelOutline. Aparecen en una minoría de las apps con R8, entre el 8 % y el 16 % según la fuente, y en 1 de 28 del mercado chino.

Esto sorprende a quien llega: un método que en el fuente tenía diez líneas puede aparecer con doscientas porque le han inyectado el cuerpo de cinco llamadas, y un método que existía puede no aparecer en absoluto. Buscar «el método que hace X» en la salida de un decompilador y no encontrarlo no prueba que la aplicación no haga X.

2.5 El salto de modelo

El bytecode de la JVM está basado en pila; el de Dalvik, en registros. Los decompiladores de Java (CFR, Vineflower, Procyon, Fernflower) están escritos para el primero. Para usarlos sobre un APK hace falta una traducción previa de registros a pila (dex2jar), y esa traducción es otra fuente de pérdida y de error, encadenada a la primera. jadx evita el rodeo porque lee DEX de forma nativa; es su ventaja estructural.

2.6 Lo que jadx no ve

Si la app no está escrita en Java ni en Kotlin, jadx solo enseña la envoltura. Y no es raro: llevan algún marco de los que sacan la lógica del DEX (el medidor cuenta 22) en torno a una de cada seis apps de F-Droid e IzzyOnDroid, y bastantes más en Google Play (36 % las más instaladas, 60 % el sorteo) y en el mercado chino (67 %). «Llevar» un marco quiere decir que hay una prueba fuerte: el nombre de una biblioteca .so en lib/<abi>/, una entrada del ZIP o un paquete entre los 40 más poblados del DEX. No quiere decir que toda la app esté hecha con él. Los más frecuentes:

Marco F-Droid IzzyOnDroid Play, más instaladas Play, sorteo Mercado chino
Flutter 11 % 11 % 5 % 18 % 17 de 100
React Native 2 % 1 % 8 % 10 % 25 de 100
Unity (todo con IL2CPP) 0 0 17 % 23 % 13 de 100
Capacitor 1,5 % 2 % menos del 1 % 2 % 0
Cordova 0,5 % 0,5 % menos del 1 % 2 % 0
Xamarin / .NET 0 0,6 % 1 app 1 app 0

Los porcentajes no se suman, y una app puede llevar más de un marco. No lo atribuyas solo a Flutter, Unity y React Native: esos tres juntos están en el 13 % de las apps de F-Droid, el 12 % de IzzyOnDroid, el 29 % de las más instaladas de Google Play, la mitad del sorteo de Google Play y 52 de cada 100 en el mercado chino.

Dónde buscar la lógica, según las pruebas que usa el medidor (nombres de .so y entradas del ZIP; no abrimos cada app para comprobarlo):

  • Flutter: en la biblioteca libapp.so.
  • React Native: en assets/index.android.bundle, o en el JavaScript. El bundle viene ya compilado a bytecode de Hermes en la gran mayoría de los casos de F-Droid y IzzyOnDroid y en más de la mitad de los de Google Play; en texto JavaScript, en una veintena de apps de F-Droid y muy pocas más. En 24 de las 50 apps de React Native de las más instaladas de Google Play y en 23 de las 25 del mercado chino no hay assets/index.android.bundle: la lógica puede estar en otra ruta o fuera del APK.
  • Unity con IL2CPP: en libil2cpp.so y su global-metadata.dat.
  • Xamarin: en los ensamblados .NET.
  • Capacitor y Cordova: en assets/www.

Un ejemplo de Unity con IL2CPP, de Google Play: com.JindoBlu.Antistress 11.4.3, en el APK de APKMirror.

2.7 Qué se pierde, con datos

La tabla junta lo que hemos medido de lo que esta sección dice que se pierde o se transforma. La unidad es la app con DEX.

Qué F-Droid IzzyOnDroid Play, más instaladas Play, sorteo Mercado chino
Compiladas con R8 58 % 66 % 62 % 43 % 28 %
Con los nombres ofuscados (al menos la mitad de los identificadores tiene de 1 a 3 caracteres) 44 % 52 % 41 % 37 % 17 %
Que llevan Kotlin 83 % 86 % 90 % 97 % 94 %
Que conservan kotlin.Metadata 34 % 34 % 68 % 66 % 52 %
Que conservan algún nombre de variable, de parámetro o de fichero fuente 27 % 25 % 21 % 53 % 44 %
Que conservan las anotaciones Signature sin dato sin dato sin dato sin dato sin dato

«Ofuscada» usa el umbral del 50 % y como denominador las apps con al menos 200 identificadores. kotlin.Metadata se cuenta sobre todas las apps con DEX; sobre las que llevan Kotlin sale otra proporción («sección 3.4 · Plugins»). Los nombres son una cota máxima, como dijimos en 2.3.

«Compilada con R8» no implica «ofuscada». com.termux 1022, de F-Droid, usa R8 en modo compatibilidad pero no renombra nada: el 2,3 % de sus identificadores tiene de 1 a 3 caracteres, así que sale «sin ofuscar». Lleva Kotlin y no conserva kotlin.Metadata. Los porcentajes de R8 y de ofuscada se explican también en «R8 y ProGuard».

3. jadx

3.1 Ficha

Dato Valor
Repositorio https://github.com/skylot/jadx
Licencia Apache-2.0
Lenguaje Java
Versión estable 1.5.6, publicada el 10 de julio de 2026
Último push al repositorio 5 de agosto de 2026
Creado 18 de marzo de 2013
Tracción 50.030 ★ · 5.719 forks
Issues abiertas 441
Archivado No

Consultado el 12 de agosto de 2026 vía la API de GitHub. Es la referencia, y no está cerca de dejar de serlo. Saca versiones con regularidad: 1.5.4 (13 de febrero de 2026), 1.5.5 (25 de febrero de 2026) y 1.5.6 (10 de julio de 2026). Suma trece años de historia, licencia permisiva y más estrellas que ninguna otra herramienta de este bloque.

No te asusten las 441 issues abiertas. Un decompilador falla por definición en algún porcentaje de los métodos, y cada fallo es un caso concreto que alguien reporta: es superficie, no abandono.

3.2 La arquitectura, en cuatro etapas

jadx lee DEX directamente y no pasa por .class. El recorrido conceptual es:

classes.dexplugin deentradadex-input(también .apk),smali-input,java-convert…1. Carga: tablasdel DEX a unmodelo declases, campos,métodos einstrucciones2. IR: grafo debloquesbásicos, formaSSA einferencia detipos sobre losregistros3.Reconstrucciónde control deflujo: delgrafo de saltosa regionesanidadas —if, bucles,switch, try/catch4. Generaciónde código Java

Tres términos del esquema. IR es una representación interna del código, más fácil de analizar que el DEX. SSA es una forma en la que cada variable recibe valor una sola vez, lo que permite deducir su tipo. Una región es un trozo del grafo que se puede escribir como if, bucle o try.

La etapa 3 es donde se juega todo. El DEX no tiene bucles ni condicionales: tiene saltos. Recuperar una estructura anidada a partir de un grafo arbitrario no siempre es posible con las construcciones del lenguaje Java, y de ahí vienen directamente los modos de fallo de la «sección 3.5 · Los modos de fallo, y qué significa cada uno».

Las cuatro etapas son las del propio código. En jadx 1.5.6, Jadx.getRegionsModePasses() (jadx-core/src/main/java/jadx/core/Jadx.java, líneas 123-216) ordena las pasadas en tres representaciones intermedias que el fichero marca con comentarios (// instructions IR, // blocks IR y // regions IR) y termina en PrepareForCodeGen: la etapa 1 acaba en ProcessInstructionsVisitor; la 2 son BlockSplitter, BlockProcessor, BlockFinisher, SSATransform y TypeInferenceVisitor; la 3 empieza en RegionMakerVisitor y sigue con IfRegionVisitor, LoopRegionVisitor y compañía; y la 4 es el paquete jadx.core.codegen (ClassGen, MethodGen, RegionGen, InsnGen). Los modos -m simple y -m fallback usan listas más cortas, sin la etapa 3. jadx --help describe simple como «simplified instructions (linear, with goto's)», y es literal: sobre la clase de la «sección 4 de Desensambladores smali · .registers sobre código real», el método sale con if (r0 >= 0) goto L7; y una etiqueta L7: donde el modo normal escribe un if.

3.3 jadx-gui

El proyecto distribuye dos binarios: jadx (línea de órdenes) y jadx-gui (interfaz gráfica). La interfaz no es un envoltorio de la CLI: decompila bajo demanda, clase a clase, y por eso se puede usar en aplicaciones donde la decompilación completa tardaría minutos. Aporta además búsqueda global por texto, clase, método o campo; navegación por referencias («quién llama a esto»); renombrado interactivo con persistencia; y la vista del smali del método al lado del Java, que es la forma práctica de comprobar si el Java es fiel.

Esa vista lado a lado es la respuesta operativa a todo lo de la «sección 2 · Qué se pierde, y por qué no vuelve»: cuando el Java no cuadra, mira el smali, que no miente.

Decompilar una app entera por línea de órdenes lleva de segundos a minutos, y con las más grandes no acaba. En el muestrario (-j 4), la mediana fue de unos 17 s en F-Droid y de 72 s en las más instaladas de Google Play; las demás fuentes quedan en medio (la tabla de la «sección 6.5 · Lo que da jadx 1.5.6 sobre el muestrario» las da todas). Pasaron de 5 minutos 6 de 25 piezas de las más instaladas de Google Play y 5 de 20 del mercado chino. Siete de las 117 no acabaron: seis agotaron los 900 s y una se quedó sin memoria (cuentan 900 s en la mediana). Un ejemplo que agotó el tiempo es la pieza base.apk del .apkm de com.mercadolibre 10.583.2, con 533.712 métodos.

Por eso jadx-gui, que decompila clase a clase al abrirlas, es la opción práctica. Ojo: jadx-gui no lo hemos medido; las cifras solo apoyan que la decompilación completa tarda.

3.4 Plugins

Desde la rama 1.5 jadx tiene un sistema de plugins con gestión desde la CLI. Los de entrada determinan qué formatos acepta. Estos son los que trae la 1.5.6, ejecutada el 18 de octubre de 2026 (instalación de Homebrew):

jadx plugins --list-all
Installed plugins: 0
Other plugins: 11
 - aab-input - .AAB Input: Loads .AAB files.
 - apkm-input - APKM Input: Load .apkm files
 - apks-input - APKS Input: Load .apks files
 - dex-input - Dex Input: Load .dex and .apk files
 - java-convert - Java Convert: Convert .class, .jar and .aar files to dex
 - java-input - Java Input: Load .class and .jar files
 - kotlin-metadata - Kotlin Metadata: Use kotlin.Metadata annotation for code generation
 - kotlin-smap - Kotlin SMAP: Use kotlin.SourceDebugExtension annotation for rename class alias
 - rename-mappings - Rename Mappings: various mappings support
 - smali-input - Smali Input: Load .smali files
 - xapk-input - XApk Input: Load .xapk files
Plugin Qué añade
dex-input .dex y .apk, con verificación opcional de checksum
java-convert .class, .jar y .aar, convirtiéndolos a DEX con dx o d8
java-input .class y .jar, cargados directamente, sin convertir
smali-input Ficheros .smali, con nivel de API configurable (27 por defecto)
aab-input · apks-input · apkm-input · xapk-input Los contenedores: .aab, .apks, .apkm y .xapk se abren directamente, sin fusionar nada antes

jadx abre estos contenedores directamente. Lo probamos con un .apkm, un .xapk y una carpeta de adb (base.apk más sus split_config.*): en los tres jadx cargó el código, escribió Java y terminó con salida 3, porque hubo métodos fallidos. Cada ejemplo es una sola ejecución, sin tiempos de referencia, y no es una proporción:

  • Un .apkm: com.google.android.apps.bard 1.0.995038376-345, pieza base.apk. Lleva 38 APK dentro y solo base.apk tiene DEX (3). Resultado: 5.139 .java y 41 errores.
  • Un .xapk: la app de multas de la DGT rusa de APKPure (ru.gibdd_pay.app, versión 6.10). Lleva 4 APK y solo el principal tiene DEX (2). Resultado: 17.872 .java y 292 errores.
  • Una carpeta de adb: com.kidzoye.parentalcontrol, con base.apk, split_config.arm64_v8a.apk y split_config.xxhdpi.apk. Con los tres ficheros juntos: 5.963 .java y 29 errores.

El código vive en la base. Hay DEX en algún split de funcionalidad (no de configuración) en el 6 % de las apps de Google Play más instaladas (37 de 658) y en 4 de 369 del sorteo; en F-Droid, IzzyOnDroid y el mercado chino, en ninguna. Los split_config.* solo traen recursos y bibliotecas nativas: ninguno lleva DEX. El muestrario tiene 388 .apkm, 72 .xapk y 365 carpetas de adb (todas del sorteo de Google Play), y ningún .aab ni .apks: el plugin los acepta, pero no lo hemos probado. La orden está en la «sección 7 · Recetas de jadx CLI».

Sobre las versiones del formato DEX: en las 117 piezas de la submuestra jadx 1.5.6 no devolvió salida 2 («no se pudo cargar») en ninguna. La versión más alta del DEX de cada app del muestrario es la 035, la 037, la 038 o la 039; la 035 sigue siendo la más repetida en todos los grupos. No hay ninguna app con DEX 040 ni 041 (el formato contenedor de Android 15 en adelante), así que no podemos decir si jadx las lee.

Dos detalles que no cuadran a primera vista. La línea de uso de jadx --help enumera .apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab, .xapk, .apkm, .jadx.kts y no menciona .apks, aunque apks-input viene incluido: esa línea es una cadena fija de JadxCLIArgs.java. Y jadx-raung-input, para el ensamblador de bytecode de Java Raung, está en el árbol del proyecto (jadx-plugins/) pero no va en la distribución: jadx-cli/build.gradle.kts de la 1.5.6 no lo declara y --list-all no lo lista.

Otros tres no añaden formatos, sino pasadas sobre el código:

Plugin Qué hace
kotlin-metadata Lee la anotación kotlin.Metadata para mejorar la salida de Kotlin
kotlin-smap Usa SourceDebugExtension para renombrar alias de clases
rename-mappings Aplica ficheros de mapping externos

La gestión se hace con el subcomando plugins: -l/--list lista los instalados, -a/--available los del marketplace, -i/--install <locationId> instala y --uninstall <pluginId> desinstala.

El kotlin-metadata importa más de lo que parece. Una parte grande del Android moderno es Kotlin, y sin esa anotación el decompilador escribe el Java equivalente (con null checks inyectados, clases Companion, funciones de extensión convertidas en estáticas), que es correcto y bastante ilegible.

Kotlin está en casi todas partes: lo lleva más del 80 % de las apps en todos los grupos del muestrario. La anotación, en cambio, falta a menudo. Entre las apps con Kotlin la conserva solo el 40 % en F-Droid y en IzzyOnDroid, y el 76 % en las más instaladas de Google Play. Sobre todas las apps con DEX, y no solo las de Kotlin, la proporción es otra: la de la tabla de la «sección 2.7 · Qué se pierde, con datos».

Jetpack Compose y las corrutinas de Kotlin (kotlinx.coroutines) generan código con lambdas anidadas y máquinas de estados. Compose va del 18 % de las apps (sorteo de Google Play) al 55 % (las más instaladas). Las corrutinas son aún más habituales: entre el 73 % y el 97 % según el grupo. Un ejemplo: com.termux 1022 lleva Kotlin y no conserva kotlin.Metadata; 2 de los 6 métodos que jadx no decompila en esa app son <clinit> de kotlinx.coroutines (DebugKt y CoroutineContextKt).

3.5 Los modos de fallo, y qué significa cada uno

Es la parte más útil de conocer, porque te los vas a encontrar.

Sobre los marcadores literales. Circulan por foros y por documentación de terceros dos cadenas que no existen en el jadx actual. // decompilation failed no aparece en ninguna de las versiones revisadas, de la 0.6.1 a la 1.5.6. // JADX WARNING: inconsistent code es un resto de versiones antiguas: ClassGen escribía /* JADX WARNING: inconsistent code. */ hasta la 0.7.1 (marzo de 2018); de la 0.8.0 a la 1.2.0 el prefijo fue /* JADX WARNING: <mensaje> */, y desde la 1.3.0 (noviembre de 2021) es JADX WARN:. Las reales hoy son las de abajo, verificadas contra el árbol del proyecto. La «sección 6 de Diagnóstico de fallos · jadx» explica por qué la forma actual no se puede encontrar grepeando el repositorio: se compone en ejecución.

/* JADX ERROR: <mensaje> */ — con dos espacios tras /*, que es como lo escribe codegen/utils/CodeGenUtils.java. La etapa 3 no consiguió estructurar el método. Si hay una causa asociada, la traza de pila Java completa va incrustada dentro del comentario. Según la configuración, debajo aparece el volcado de instrucciones de jadx. El método no está decompilado en absoluto: lo que lees es el desensamblado. Es el fallo honesto, porque se ve.

/* JADX WARN: <mensaje> */ (y sus hermanos JADX INFO: y JADX DEBUG:). jadx sí produjo Java, pero detectó que su propia reconstrucción no es coherente con el grafo de partida. Mensajes habituales tras el prefijo: «Multi-variable type inference failed», «Code restructure failed», «Removed duplicated region». Por defecto --comments-level es info, así que WARN e INFO se emiten y DEBUG no.

Code decompiled incorrectly, please refer to instructions dump. — jadx reconstruyó el método pero lo marcó como incoherente (AFlag.INCONSISTENT_CODE). Con el valor por defecto no enseña ese Java: escribe el aviso, la línea To view partially-correct add '--show-bad-code' argument, el volcado de instrucciones en un comentario y un cuerpo que solo lanza una excepción (el marcador siguiente); lo deciden ClassGen.addMethodCode y MethodGen.dumpInstructions. Con --show-bad-code el Java sí sale, debajo del mismo aviso, y ese es el peligroso: código plausible que puede no corresponder al comportamiento real. El aviso está para leerse, no para ignorarse.

throw new UnsupportedOperationException("Method not decompiled: <clase>.<método>(…)"); — el cuerpo que jadx escribe cuando no genera Java para un método: tras un JADX ERROR, tras un Code decompiled incorrectly sin --show-bad-code y, en general, debajo de cada volcado de instrucciones (MethodGen.dumpInstructions). Compila, pero si se ejecuta lanza la excepción. Es la cadena que la receta de la «sección 7 · Recetas de jadx CLI» cuenta con grep 'Method not decompiled:'.

Class decompilation failed es otra cosa: es el mensaje de una JadxRuntimeException del modo --single-class, no un comentario del código generado. Si los confundes, acabarás buscando en la salida algo que solo aparece en la consola.

Métodos que salen como volcado de instrucciones. Consecuencia del primero. jadx cae al modo fallback para ese método concreto y escribe su representación interna de bajo nivel, que no es smali: la escribe MethodGen.addFallbackInsns con InsnGen, y empieza por líneas del tipo r0 = this (sin punto y coma). El smali de verdad solo aparece en la pestaña correspondiente de jadx-gui, vía JavaClass.getSmali(). Puedes forzarlo en toda la app con -m fallback, que renuncia a decompilar y vuelca esa representación de todo; sirve cuando importa más no perder nada que la estructura.

Nombres p0, i, str2, C0123a. No es un fallo: es la «sección 2.3 · Los nombres de las variables locales» más la ofuscación. Los nombres que empiezan por C y llevan dígitos (C0303R) son nombres que jadx inventa para clases cuyo nombre original no sirve: demasiado corto (menos de 3 caracteres con --deobf, que es el valor por defecto de --deobf-min) y, según la convención de jadx, también inválido o repetido; este último caso no lo probamos. En una app sin ofuscar esos nombres solo aparecen con --deobf. En com.termux 1022, sin la opción hay 0 ficheros con nombre C más dígitos; con ella hay 1, androidx/window/C0303R.java, que sin la opción se llama R.java. La causa del umbral está en la ayuda de jadx 1.5.6 (jadx --help). El recuento es find salida/sources -name 'C[0-9]*.java' | wc -l.

Salida 0 y casi nada de Java. Es el modo de fallo que no avisa. En una app empaquetada (Jiagu, Bangcle, Ijiami, Baidu…) el código real va cifrado en los assets o en una biblioteca nativa, y jadx solo ve el cargador. Termina bien, con salida 0, y escribe unos pocos ficheros. Un 0 aquí no dice nada del código de la app.

Es casi exclusivo del mercado chino. Allí llevan alguna prueba fuerte de empaquetador o protector (sin contar PairIP) 38 de cada 100 apps, sobre todo Bangcle/SecNeo (21) e Ijiami (7). En Google Play son el 2 % de las más instaladas y una del sorteo; en F-Droid e IzzyOnDroid, ninguna. jadx terminó en las 7 piezas chinas empaquetadas que le pasamos. Seis salieron con 0 y menos de 50 ficheros .java (de 4 a 31). La séptima escribió 3.623 y salió con 3, con 27 métodos sin decompilar: parte del código sigue en el DEX, así que no podemos decir que todas devuelvan solo un cargador. De las 5 piezas de protectores elegidas a propósito como ejemplo, 2 salieron con 0 y 3 con 3, con entre 4.025 y 9.608 .java. Ejemplos:

  • com.cn21.ecloud 638 (mercado chino, Ijiami): salida 0, 5 ficheros .java, 3 clases en el DEX.
  • com.cmbchina.ccd.pluto.cmbActivity 160 (mercado chino, Bangcle/SecNeo): salida 3, 3.623 .java, 27 métodos sin decompilar.
  • com.tuniu.app.ui 384 (protegida con Baidu): salida 0, 31 .java; jadx no pudo leer assets/baiduprotect*.dex.
  • com.pplive.androidphone 465 (protegida con Jiagu 360): salida 0, 6 .java.

No medimos los fallos de jadx sobre el código real de estas apps, porque no está en el APK. Más sobre los protectores en «Packers y protectores».

OutOfMemoryError y cuelgues. En las aplicaciones muy grandes el problema suele ser el tiempo antes que la memoria. Con 5.734 MB de memoria Java y un tope de 15 minutos (900 s), jadx no terminó 7 de las 117 piezas: 6 agotaron el tiempo y 1 se quedó sin memoria, y ninguna era de F-Droid, IzzyOnDroid ni el sorteo de Google Play. Todas son enormes: seis tienen más de 500.000 métodos definidos (de 533.712 a 1.674.186) y la séptima, WhatsApp, 320.394. La mayor que sí terminó tenía 469.660.

Para hacerse una idea, una app de F-Droid tiene de mediana unos 18.000 métodos, y una de las más instaladas de Google Play, unos 210.000. Tres ejemplos de las que no acabaron:

  • com.ss.android.ugc.aweme.lite 400901 (mercado chino), con 1.674.186 métodos: se quedó sin memoria a los 618 s, con 0 .java y salida 1.
  • com.xingin.xhs 9510803 (mercado chino), con 910.250 métodos: agotó los 900 s con 54.549 .java escritos.
  • WhatsApp, de la web del autor: 900 s y 72.718 .java.

El tope de 5.734 MB lo fijó la prueba, con dos trabajos a la vez. El lanzador de jadx usa por defecto el 70 % de la memoria física (ver abajo), así que en una máquina con más memoria alguna de las 7 podría acabar.

La documentación del proyecto recomienda bajar el número de hilos con -j, excluir paquetes que no interesan, usar la caché en disco de jadx-gui, y subir el heap de la JVM. La wiki lo explica editando DEFAULT_JVM_OPTS en el lanzador para pasar de -Xmx4g a -Xmx8g, pero el lanzador de la 1.5.6 no fija -Xmx: lleva -XX:MaxRAMPercentage=70.0 (el heap máximo es el 70 % de la memoria física, unos 11,2 GiB en una máquina de 16 GiB) y añade detrás JAVA_OPTS y JADX_OPTS, así que un tope distinto se pone sin editar nada, con JAVA_OPTS="-Xmx8g" («sección 7 · Recetas de jadx CLI»).

Esto tiene una consecuencia práctica: si automatizas jadx, hazlo bien invocándolo como proceso separado, con límite de memoria y timeout, porque un fallo de memoria del decompilador se llevaría por delante al proceso que lo hospede.

3.6 --deobf y mapping.txt: dos cosas distintas

Se confunden constantemente y no tienen nada que ver.

--deobf es heurístico. Detecta identificadores que parecen ofuscados (por longitud, con los umbrales --deobf-min y --deobf-max) y les asigna nombres generados y estables dentro de una misma ejecución. No recupera nada: cambia a.b.c por algo pronunciable. Sirve para poder hablar del código y para que las referencias cruzadas se sigan; no para saber cómo se llamaba.

--mappings-path es determinista. Carga un fichero de correspondencias y aplica los nombres reales. El plugin rename-mappings acepta, entre otros formatos, el mapping.txt de ProGuard y R8, además de Tiny, Enigma, SRG, XSRG, JAM, CSRG, TSRG, migración de IntelliJ, Recaf y el JOBF propio de jadx. --mappings-mode controla si los cambios se autoguardan. La ayuda de --mappings-path solo nombra «Tiny and Tiny v2 (both '.tiny'), Enigma (.mapping) or Enigma directory», pero el mapping.txt de ProGuard funciona igual: el plugin detecta el formato (-Prename-mappings.format, AUTO por defecto, admite PROGUARD_FILE). Lo reproducimos el 18 de octubre de 2026 con el ejemplo de abajo.

Pero hay que invertirlo, y nadie avisa de ello. R8 escribe el mapping.txt en el sentido original -> ofuscado; jadx aplica el mapeo de izquierda a derecha, así que con el fichero tal cual busca en el DEX clases con el nombre original (que por definición no están) y no renombra nada. No es un error recuperable: termina con exit=0, sin aviso, y produce exactamente el informe falso contra el que previene esta sección. La opción que lo arregla es de plugin y no sale en la lista principal de --help:

jadx -d salida/ -Prename-mappings.invert=yes --mappings-path mapping.txt app.apk

Lo comprobamos con jadx 1.5.6 sobre un DEX con la clase a.b y el mapeo com.ejemplo.Real -> a.b:. Sin el -P: sources/a/b.java. Con él: sources/com/ejemplo/Real.java, con el comentario /* JADX INFO: renamed from: a.b */ que confirma que la correspondencia se aplicó. Y ojo con el mismo silencio en el caso trivial: si el fichero de mapeo no existe, jadx también responde done y 0.

La regla de lectura: si hay mapping.txt invertido, los nombres son los originales; si solo hay --deobf, son invención; y si el mapping.txt va sin invertir, los nombres siguen siendo los ofuscados aunque la orden parezca haber funcionado. Confundirlos es cómo se escriben informes falsos.

4. La ruta alternativa: dex2jar más un decompilador de Java

4.1 El rodeo

classes.dex ──dex2jar──▶ classes.jar ──CFR / Vineflower / Procyon / Fernflower──▶ .java

Se traduce el bytecode de registros a bytecode de pila, y luego se usa cualquiera de los decompiladores de Java de los últimos quince años. Dos pasos, dos oportunidades de fallar.

4.2 dex2jar

Dato Valor
Repositorio https://github.com/pxb1988/dex2jar
Licencia Apache-2.0
Versión estable 2.4, publicada el 3 de octubre de 2023
Último push 21 de julio de 2024
Tracción 13.132 ★ · 2.186 forks · 379 issues abiertas
Archivado No

Consultado el 12 de agosto de 2026. Estado real: mantenimiento mínimo. Dos años sin release y más de dos años sin commits, con 379 issues abiertas. No está archivado y no ha sido declarado muerto, pero tampoco se mueve.

El fork vivo sí está identificado. Consultamos la lista de forks por número de estrellas el 13 de agosto de 2026 con gh api repos/pxb1988/dex2jar/forks:

Fork ★ Último push
ThexXTURBOXx/dex2jar 308 22 de julio de 2026
DexPatcher/dex2jar 219 11 de diciembre de 2019

El primero es el único con tracción y desarrollo reciente; el segundo lleva parado casi siete años. Los demás forks del listado tienen cero estrellas y son clones personales. Si necesitas dex2jar hoy, mira ThexXTURBOXx/dex2jar antes que el original. Lo que hemos comparado es su actividad, no su cobertura. Su README enumera arreglos («many NullPointerExceptions and other crashes», las excepciones de firmas genéricas, TypeTransformer), pero sus releases, de la 2.4.26 a la 2.4.38 (22 de julio de 2026), no llevan notas, y ninguna medición pública dice cuántas aplicaciones más convierte: que se mueva no garantiza que convierta más.

El dato que importa para elegir ruta sí está medido: en el estudio de la «sección 6 · La comparación honesta: qué dicen las mediciones», dex2jar falló al convertir 394 de las 13.601 aplicaciones de Google Play y 33 de las 24.553 muestras de malware, frente a 0 de las 3.018 de F-Droid. Es decir, la ruta alternativa empieza perdiendo aproximadamente un 2,9 % de las aplicaciones comerciales antes de que el decompilador de Java llegue a intervenir.

4.3 Los decompiladores de Java

Herramienta Repositorio Licencia Última versión Último push Estado
CFR leibnitz27/cfr MIT 0.152 (11-12-2021) 04-06-2026 Repositorio vivo, sin release desde 2021
Vineflower Vineflower/vineflower Apache-2.0 1.12.0 (29-04-2026) 11-07-2026 Activo
Procyon mstrobel/procyon Apache-2.0, según su License.txt (GitHub no la reconoce) 0.6.0 (21-02-2022) 12-06-2022 Parado desde 2022
Fernflower Dentro de JetBrains/intellij-community Apache-2.0 — — Vive como componente de IntelliJ

Consultado el 12 de agosto de 2026 vía la API de GitHub.

CFR es el más sólido de los clásicos y el que mejor sigue las versiones modernas del lenguaje Java. Su anomalía de mantenimiento merece leerse con cuidado: el repositorio recibió commits el 4 de junio de 2026, pero la última release etiquetada es la 0.152, de diciembre de 2021, y la web oficial del autor sigue anunciando esa misma versión. Hay desarrollo; no hay publicación. Quien lo use en producción está usando un binario de hace casi cinco años o compilando de master.

Vineflower es el sucesor real de Fernflower: se declara en su propia descripción como «fork of the Fernflower decompiler», con énfasis en la calidad de salida. Es el único de los cuatro con release reciente (1.12.0, abril de 2026) y desarrollo continuo. Si hay que elegir un decompilador de Java hoy, es este.

Procyon está parado: última release en febrero de 2022, último commit en junio de 2022. Conserva valor histórico y sigue siendo interesante por su tratamiento de ciertas construcciones, pero no recibe correcciones.

Fernflower es el decompilador que JetBrains integra en IntelliJ IDEA y en Android Studio: cuando abres una clase compilada en el IDE, es él quien la muestra. No se distribuye como proyecto independiente con releases propias; vive dentro del árbol de intellij-community.

Confirmado el 13 de agosto de 2026 vía la API de GitHub: está en plugins/java-decompiler/, dividido en engine (el decompilador propiamente dicho) y plugin (su integración con el IDE), y plugins/java-decompiler/engine/LICENSE.txt es la Apache License 2.0. El motor tiene además repositorio propio, JetBrains/fernflower, vivo y con su uso por línea de órdenes documentado (java -jar fernflower.jar …), pero sin releases: si lo quieres, compila el .jar o usa Vineflower, que es el mismo linaje mantenido aparte.

4.4 Cuándo esta ruta gana y cuándo pierde

Gana en un caso concreto y real: cuando jadx falla en un método determinado. El estudio de la «sección 6 · La comparación honesta: qué dicen las mediciones» lo cuantifica: en aproximadamente el 96 % de los casos en que jadx falla al decompilar un método, al menos otro decompilador lo consigue. La cifra sale de la tabla VIII, medida solo sobre F-Droid y con CFR, Fernflower y Procyon (no con Vineflower), y el propio estudio pide tomarla como orientativa («indicative, rather than exact»). Si quieres leer ese método y jadx ha escrito JADX ERROR, probar CFR o Vineflower sobre el .jar de dex2jar es justo lo que toca.

También gana cuando el objetivo no es un APK sino un .jar suelto, donde el rodeo desaparece.

Pierde en todo lo demás:

  • dex2jar puede fallar antes de empezar, y falla en un 2,9 % de las aplicaciones de Play.
  • Las tasas de fallo por método son entre 50 y 1.100 veces peores que las de jadx («sección 6 · La comparación honesta: qué dicen las mediciones»).
  • No entiende de recursos: no decodifica el AndroidManifest.xml ni res/.
  • No sabe nada de Kotlin metadata ni de las convenciones de Android.
  • Son dos herramientas encadenadas en vez de una.

La conclusión operativa es que no es una alternativa a jadx: es un segundo intento para los métodos que jadx no ha podido.

5. Las comerciales y las suites

5.1 JEB (PNF Software)

Plataforma comercial y de código cerrado de PNF Software, descrita por el fabricante como una plataforma de ingeniería inversa para desensamblado, decompilación, depuración y análisis. Lo que la distingue del resto de este documento:

  • Un decompilador de Dalvik propio, independiente de jadx, con reputación de aguantar mejor el código muy ofuscado.
  • Decompiladores nativos en el mismo entorno: x86/x86-64, ARM/ARM64, MIPS/MIPS64, RISC-V, además de WebAssembly, EVM de Ethereum, PLC Simatic S7 y kernels SASS de Nvidia. Cubre en un solo producto lo que aquí se reparte entre este documento y «Análisis binario y estático».
  • API de scripting en Java y Python para automatizar, con plugins de ejemplo publicados en GitHub aunque el núcleo sea propietario.
  • Depurador que se acopla tanto al Dalvik como al nativo.

Ediciones: Community Edition y demo gratuitas; JEB Pro y JEB Android comerciales. Versión observada en la página del fabricante: JEB 5.36, de enero de 2026. Consultado el 12 de agosto de 2026.

Los precios se publican en la página de compra, por año: JEB Android, 1.200 $ por usuario (o 140 $ al mes); JEB Pro, 2.000 $ por usuario; JEB Pro Floating, 4.000 $ por puesto, y JEB Pro OEM, 8.000 $ por servidor. Consultado el 25 de septiembre de 2026.

El punto ciego: es de pago, es cerrado y no se puede auditar. Para trabajo reproducible o para una cadena de herramientas verificable, eso es un problema real.

5.2 Bytecode Viewer

Dato Valor
Repositorio https://github.com/Konloch/bytecode-viewer
Licencia GPL-3.0
Última versión 2.13.2 (1 de enero de 2026), etiquetada «2026 Release (In-Dev)»
Último push 17 de julio de 2026
Tracción 15.590 ★ · 1.271 forks · 103 issues abiertas

Consultado el 12 de agosto de 2026. Su propia descripción: «A Java 8+ Jar & Android APK Reverse Engineering Suite (Decompiler, Editor, Debugger & More)».

Lo que aporta es agregación: ejecuta varios decompiladores a la vez sobre la misma clase y los muestra en paneles paralelos. Eso convierte el hallazgo del 96 % de la «sección 4.4 · Cuándo esta ruta gana y cuándo pierde» en una operación de un clic en lugar de un montaje manual de dos herramientas. Añade además editor, buscador y visor de bytecode.

El punto ciego: lo que aporta solo existe en la interfaz gráfica. Tiene línea de órdenes (-i, -o, -t, -decompiler, -nowait), pero con un decompilador cada vez, así que en CI no da nada que no dé el decompilador suelto. Es el mismo patrón que el de doce de las trece herramientas de manipulación de APK de la «sección 4.2 de Comparativa y selección · Cuántas tienen modo desatendido de verdad», interfaces sin modo desatendido. Y su licencia, GPL-3.0, obliga a distribuir bajo la misma licencia lo que lo enlace: para integrarlo en otra herramienta hay que llamarlo como proceso aparte («Mapa del ecosistema → §6 · Licencias y sus consecuencias prácticas»).

6. La comparación honesta: qué dicen las mediciones

El estudio no lo hemos repetido con todas las herramientas: haría falta un corpus de decenas de miles de aplicaciones. Sí medimos jadx 1.5.6 en una submuestra, ver 6.5. Lo que sigue en 6.1 a 6.4 son mediciones publicadas, con la fuente identificada. Las que ejecutamos en esta máquina, sobre un solo APK, están en la «sección 7 · Recetas de jadx CLI».

La referencia es A Large-Scale Empirical Study of Android App Decompilation, de Noah Mauthe (Universidad del Sarre), Ulf Kargén y Nahid Shahmehri (Universidad de Linköping), presentado en SANER 2021. Es el primer estudio sistemático a gran escala de tasas de fallo de decompilación en Android. Tres conjuntos:

Conjunto Aplicaciones Media de métodos por aplicación
F-Droid (código abierto) 3.018 13.532
Google Play (crawl reciente) 13.601 63.748
Malware 24.553 5.142

6.1 Tasa media de fallo por método

Tabla VI del estudio: porcentaje medio de métodos fallidos por aplicación, incluyendo los timeouts como fallo total y excluyendo las aplicaciones en que dex2jar falló:

Conjunto CFR Fernflower jadx Procyon
F-Droid 0,741 % 5,966 % 0,005 % 1,522 %
Google Play 1,032 % 58,418 % 0,019 % 11,006 %
Malware 1,838 % 9,726 % 0,044 % 1,672 %
Media ponderada 1,204 % 24,703 % 0,023 % 4,733 %

Excluyendo también los timeouts (tabla V), la media ponderada queda en CFR 1,094 %, Fernflower 1,024 %, jadx 0,021 % y Procyon 0,564 %. La diferencia entre las dos tablas para Fernflower, del 24,7 % al 1,0 %, dice que su problema principal no es decompilar mal sino agotar el tiempo: el estudio registra un número muy grande de timeouts para él, frente a solo 5 para jadx.

Lectura: en la media ponderada de la tabla VI, a jadx le fallan entre 50 y 1.100 veces menos métodos que a los demás: unas 52 veces menos que a CFR, 200 menos que a Procyon y 1.070 menos que a Fernflower. No es una mejora marginal. Eso sí, la tabla VI cuenta los timeouts como fallo total. Y todo esto era en 2021: con jadx 1.5.6 y apps de 2026 la tasa de fallo es mayor, ver 6.5.

6.2 El dato que de verdad importa

Tabla VII: porcentaje de aplicaciones en las que todos los métodos se decompilaron sin un solo fallo:

Conjunto Solo jadx Ensemble de los cuatro Los cuatro a la vez
F-Droid 74,52 % 74,69 % 8,65 %
Google Play 21,02 % 21,03 % 0,15 %
Malware 78,81 % 79,68 % 0,60 %

Aquí está la conclusión del estudio de 2021: solo una de cada cinco aplicaciones de Google Play decompila entera sin un solo método fallido. Y combinar los cuatro decompiladores no arregla nada a nivel de aplicación: sube del 21,02 % al 21,03 %.

Con jadx 1.5.6 y aplicaciones de 2026 el resultado es otro. Entre las piezas en que jadx terminó, ninguna de las 24 de Google Play (las más instaladas) decompiló entera. En F-Droid lo hicieron 2 de 25; en IzzyOnDroid, 0 de 15; en el sorteo de Google Play, 0 de 20; y en las webs de los autores, 0 de 6. En el mercado chino son 6 de 15, pero las 6 están empaquetadas y jadx solo ve el cargador: sin ellas, 0 de 8. «Sin ningún método fallido» quiere decir sin ningún Method not decompiled:, JADX ERROR: ni Code decompiled incorrectly en los .java. Las 7 piezas que no terminaron no entran; contarlas como fallo no cambia el resultado. La cifra de una de cada cinco ya no se sostiene para las aplicaciones actuales. Dos ejemplos de F-Droid que no cuentan como limpias, aunque jadx salga con 0: com.jvillalba.apod.md 11, con 2 métodos sin decompilar y 2 con «Code decompiled incorrectly», y com.reteclock 90, con 1 método sin decompilar.

El propio estudio lo atribuye, «probably due in part», a que las aplicaciones de Play tienen 63.748 métodos de media. Si los fallos cayeran al azar, con más de 60.000 métodos por aplicación casi ninguna saldría limpia; y en 2021 salía limpia una de cada cinco, así que los fallos se amontonaban en ciertas aplicaciones. La cuenta es esta: con una tasa de 0,019 % y fallos independientes, la probabilidad de que ninguno falle sería (1 − 0,00019)^63.748 ≈ 0,0006 %.

Hoy las apps son mucho más grandes, y con eso basta para explicar el resultado. Las más instaladas de Google Play del muestrario tienen de media 246.269 métodos definidos (sin contar constructores), casi cuatro veces los 63.748 del estudio; con una tasa media de 0,24 %, que ninguna salga limpia es lo esperable. Superan los 63.748 métodos el 84 % de esas apps, frente a en torno al 13,5 % de las de F-Droid e IzzyOnDroid, cuya media ronda los 32.000. Los fallos se siguen concentrando algo: la app o las dos apps peores de cada grupo (el 10 % de la submuestra) acumulan entre el 26 % y el 41 % de los fallos.

El corolario incómodo: si nadie te dice qué métodos fallaron, no sabes qué parte de lo que estás leyendo no es lo que la aplicación hace. De ahí que la «cobertura de decompilación explícita» sea lo que más se echa en falta: hoy los fallos son silenciosos.

6.3 Y una conclusión que consuela

El estudio también responde a si la ofuscación está rompiendo la decompilación a propósito, y la respuesta es que no: los autores no encontraron ni un caso de ofuscación de control de flujo con ramas falsas hacia posiciones inválidas, la técnica «irrompible» habitual en código nativo o JVM de escritorio. Los fallos se deben mayoritariamente a limitaciones técnicas de los decompiladores (control de flujo muy complejo, anidamiento profundo, agotamiento de recursos en métodos grandes) y no a defensas deliberadas. La conclusión de los autores es que la decompilación casi perfecta de Android es alcanzable con mejoras de implementación.

El muestrario la apoya en parte. Ninguna app lleva un opcode no válido en el DEX, la señal más burda de un DEX hecho para romper decompiladores: 0 en todos los grupos. Lo que hoy esconde el código no rompe el decompilador: lo oculta (ver «Salida 0 y casi nada de Java» en 3.5). Por ejemplo, com.cn21.ecloud 638, del mercado chino y con Ijiami, no rompe jadx: lo deja con 5 ficheros .java. Los saltos hacia posiciones inválidas no los hemos medido, y esta comprobación no prueba que ninguna app use ofuscación de control de flujo: solo medimos el opcode.

6.4 Límites de estos datos

Conviene decirlo con claridad:

  • Es un estudio de 2021. Cita jadx con una referencia de 2020, sin fijar número de versión; la versión actual es la 1.5.6, de julio de 2026. Con jadx 1.5.6 sobre apps de 2026 la tasa media de métodos sin decompilar por app no es mejor sino mayor: en F-Droid 0,27 % (25 apps) frente al 0,005 % del estudio (unas 55 veces más) y en Google Play 0,24 % (24 apps) frente al 0,019 % (unas 13 veces más). Puede deberse a que las aplicaciones de hoy son más grandes y usan más Kotlin, Compose y R8, o a lo que cada medición llama «fallo»; no lo hemos separado. Si las piezas que no terminaron cuentan como fallo total, la media sube a 4,23 % en Google Play, 25 % en el mercado chino y 14,6 % en las webs de los autores. Son medias de tasas por app, con muestras de 15 a 25 apps. Lo que conserva valor es la comparación entre herramientas, no las cifras absolutas; y esa comparación no la hemos repetido, porque CFR, Fernflower, Procyon y dex2jar (ni la 2.4 ni el fork ThexXTURBOXx) no están en nuestras pruebas.
  • Mide fallo declarado, no corrección. Un método que decompila «bien» puede producir Java que no refleja el comportamiento; los propios autores lo advierten.
  • No incluye Vineflower, que no existía como tal, ni JEB, que es de pago.
  • Las tablas III y IV del estudio documentan que parte de los fallos contabilizados son artefactos de la medición: coincidencias superfluas por clases internas y métodos irreconciliables por genéricos. Para jadx, el 34,0 % de los fallos en Google Play entran en esta segunda categoría.
  • No hay mediciones públicas equivalentes de 2025 o 2026 sobre las versiones actuales de estas herramientas, según una búsqueda del 25 de septiembre de 2026 en la API de arXiv y en buscadores generales. La más reciente que localizamos es la versión en revista del mismo estudio (Kargén, Mauthe y Shahmehri, Empirical Software Engineering 28:48, febrero de 2023), que repite la metodología, añade 54.945 muestras de malware de AndroZoo y tampoco fija versiones de los decompiladores; las cifras de arriba siguen siendo lo mejor disponible.

6.5 Lo que da jadx 1.5.6 sobre el muestrario

El estudio de 2021 no incluye las aplicaciones de hoy. Pasamos jadx 1.5.6 por una submuestra de 117 piezas del «muestrario», con 4 hilos, 5.734 MB de memoria y 15 minutos de tope por pieza, y dos piezas a la vez. Son las primeras de cada grupo por SHA-256, sin repetir paquete: 25 de F-Droid, 15 de IzzyOnDroid, 25 de las más instaladas de Google Play, 20 del sorteo, 20 del mercado chino, 7 de las webs de los autores y 5 de protectores (estas solo como ejemplo). Tres resultados:

  1. Casi todas las piezas acaban con salida 3, y ninguna decompila entera salvo 2 de F-Droid y las empaquetadas del mercado chino.
  2. La tasa de métodos sin decompilar es de 0,18 % a 0,32 % por aplicación en todos los grupos menos el chino, bastante más que en el estudio; en el mercado chino sale 0,06 % porque 6 de las 15 piezas están empaquetadas.
  3. Las aplicaciones grandes no acaban: en 7 de las 117 piezas jadx se quedó sin tiempo o sin memoria.
Grupo Piezas Acabaron Salida 3 Salida 0 Sin ningún método fallido Tasa media por app Mediana de tiempo Más de 5 min
F-Droid 25 25 21 de 25 4 (2 con métodos sin decompilar) 2 de 25 0,27 % 17 s 2 de 25
IzzyOnDroid 15 15 15 de 15 0 0 de 15 0,26 % 23 s 0 de 15
Play, más instaladas 25 24 (1 agotó los 900 s) 24 de 24 0 0 de 24 0,24 % 72 s 6 de 25
Play, sorteo 20 20 20 de 20 0 0 de 20 0,18 % 60 s 0 de 20
Mercado chino 20 15 (4 agotaron los 900 s y 1 se quedó sin memoria) 9 de 15 6 6 de 15 (las 6, empaquetadas) 0,06 % 34 s 5 de 20
Webs de los autores 7 6 (1 agotó los 900 s) 6 de 6 0 0 de 6 0,32 % 54 s 1 de 7

Las piezas de protectores (5, solo ejemplo) dieron salida 3 en 3 y salida 0 en 2. Hubo una salida 1 (la pieza que se quedó sin memoria) y ninguna salida 2. La tasa media es la media de la tasa de cada app; el tiempo de las piezas que llegaron al tope cuenta como 900 s. Lo que la prueba no mide es si el Java que sí escribe es correcto. Los modos de fallo están en la «sección 3.5 · Los modos de fallo, y qué significa cada uno». Ejemplos de F-Droid: com.reteclock 90, salida 0 con 1 método sin decompilar, y com.jvillalba.apod.md 11, salida 0 con 2 métodos sin decompilar. Termux 1022 no está en la submuestra: lo ejecutamos aparte («sección 7 · Recetas de jadx CLI»).

7. Recetas de jadx CLI

Todas las recetas de esta sección las ejecutamos con jadx 1.5.6 (OpenJDK 21) el 31 de octubre de 2026 sobre com.termux 1022 de F-Droid (Termux 0.119.0-beta.3), en un equipo de 10 núcleos.

Los seis modos principales, con lo que producen sobre el mismo APK (114.920.926 bytes, unos 115 MB, con 745 entradas en el ZIP; solo 3,2 MB son código: sus 2 DEX ocupan 3.204.332 bytes):

Orden Salida .java en sources/ Ficheros en resources/ Código de salida
jadx -d o1 Código y recursos 1.415 960 3
jadx -d o2 --no-res Solo código 1.415 0 3
jadx -d o3 --no-src Solo recursos 0 960 0
jadx -d o4 --deobf … Código y recursos 1.415 960 3
jadx -d o5 --show-bad-code Código y recursos 1.415 960 3
jadx -d o6 -m fallback Código y recursos 1.415 960 0

Cada fila es una ejecución. Los recuentos son find salida/sources -name '*.java' | wc -l y find salida/resources -type f | wc -l, y el código de salida es $? al terminar.

Los tiempos no los comparamos, porque bailan entre ejecuciones: rondan los 8 s, y la mitad con --no-src. -m fallback tardó 8,7 s en una pasada y 3,9 s en otra, con el equipo cargado, así que no digas que es más rápido. Los recuentos y los códigos de salida, en cambio, salieron iguales las dos veces.

Tres lecturas de esa tabla que no salen en la documentación del proyecto:

  • --no-res ahorra bastantes ficheros y menos de un segundo. Los 1.415 .java son los mismos; lo que desaparece son los 960 ficheros de resources/. La ganancia (8,2 s a 8,0 s en una ejecución; 8,5 s a 7,4 s en otra) no justifica usarlo salvo que estorben. No lo medimos con apps grandes, así que no sabemos si cambia con un resources.arsc de decenas de MB.
  • --no-src y -m fallback devuelven 0, y por el mismo motivo: si no se intenta estructurar el código, no hay métodos que fallen. El código de salida 3 de los otros cuatro es la señal de los seis errores de decompilación, no de un problema de la invocación. Con --no-src jadx no escribe ningún .java en sources/: los 31 .java que aparecían en un recuento antiguo eran fuentes de la biblioteca jsr305 (javax/annotation) que Termux lleva dentro del APK, y jadx las copia entre los recursos, en resources/javax/annotation/.
  • --deobf sobre una aplicación sin ofuscar sí cambia cosas, y no avisa. En Termux, que no está ofuscada, cambió 193 de los 1.415 ficheros .java: 161 de los 1.383 que conservan la ruta cambian de contenido y 32 cambian de ruta. --deobf renombra las clases y los paquetes de menos de 3 caracteres (es el valor de --deobf-min): R pasa a C0303R (así, androidx/window/R.java pasa a C0303R.java) e io a p001io (com/google/common/io pasa a p001io). Los comentarios «renamed from» son 86 en 58 ficheros sin --deobf y 178 en 92 con él. Si dejas --deobf puesto en un guion, obtendrás nombres que no son los del autor. Solo lo probamos en una app; no en una de Play con R8. El recuento se hace comparando las carpetas sources/ de jadx -d o1 y jadx -d o4 --deobf, y con grep -r 'renamed from'.

Y -m fallback produce un Java radicalmente distinto, con los nombres completamente cualificados y sin import, que es lo que se quiere cuando lo normal falla. Este fragmento es de sources/com/termux/app/TermuxActivity.java (líneas 20-36) de com.termux 1022:

    com.termux.app.terminal.TermuxTerminalViewClient mTermuxTerminalViewClient;

    class TermuxActivityBroadcastReceiver extends android.content.BroadcastReceiver {
        final /* synthetic */ com.termux.app.TermuxActivity this$0;

        TermuxActivityBroadcastReceiver(com.termux.app.TermuxActivity r1) {
                r0 = this
                r0.this$0 = r1
                r0.<init>()
                return
        }

La misma clase en el modo normal empieza por package y un bloque de import, y usa nombres cortos.

Decompilación completa a un directorio:

jadx -d salida/ app.apk

Solo el código, sin decodificar recursos — mucho más rápido, y suficiente si solo vas a leer lógica:

jadx -d salida/ --no-res app.apk

Solo los recursos, sin decompilar:

jadx -d salida/ --no-src app.apk

Con deofuscación heurística y umbrales de longitud:

jadx -d salida/ --deobf --deobf-min 3 --deobf-max 64 app.apk

Con mapping.txt real, que es lo que de verdad recupera nombres. El -P no es opcional: sin él la orden termina bien y no renombra nada («sección 3.6 · --deobf y mapping.txt: dos cosas distintas»).

jadx -d salida/ -Prename-mappings.invert=yes --mappings-path mapping.txt app.apk

Mostrando los métodos marcados como incoherentes, para poder auditarlos:

jadx -d salida/ --show-bad-code app.apk

Renunciando a estructurar y volcando la representación de bajo nivel:

jadx -d salida/ -m fallback app.apk

Una sola clase, útil cuando la aplicación es enorme:

jadx --single-class com.ejemplo.MiClase -d salida/ app.apk

Control de recursos, que es el problema práctico en aplicaciones grandes:

JAVA_OPTS="-Xmx8g" jadx -j 4 -d salida/ app.apk

Gestión de plugins:

jadx plugins --list
jadx plugins --available
jadx plugins --install <locationId>

Códigos de salida. Los verificamos el 13 de agosto de 2026 leyendo JadxCLI.java en el repositorio, y los comprobamos otra vez el 31 de octubre de 2026 ejecutando jadx 1.5.6. Son cuatro:

Código Cuándo Origen en JadxCLI.java
0 Todo salió bien, o solo se pidió la ayuda return 0 al final de runSave
1 Argumentos incorrectos o excepción no controlada catch (JadxArgsValidateException) y catch (Throwable)
2 Fallo al cargar la entrada: no hay clases que decompilar if (checkForErrors(jadx)) return 2
3 Cargó bien pero la decompilación terminó con errores if (errorsCount != 0) … return 3

Comprobado sobre el «muestrario»:

jadx -d salida $MUESTRAS/com.termux_1022.apk ; echo "EXIT=$?"
ERROR - finished with errors, count: 6
EXIT=3
jadx -d salida $MUESTRAS/NO-EXISTE.apk ; echo "EXIT=$?"
ERROR - Incorrect arguments: File not found …/NO-EXISTE.apk
EXIT=1

jadx sí señala los fallos de decompilación en su código de salida. Termux, que es software libre y no renombra nada (aunque se compila con R8, en modo compatibilidad: solo el 2,3 % de sus identificadores tiene de 1 a 3 caracteres), produce seis errores y devuelve 3 habiendo escrito 1.415 ficheros .java utilizables. Y es lo normal. En el muestrario, jadx devuelve 3 en todas las piezas que terminó de IzzyOnDroid, de Google Play y de las webs de los autores; en F-Droid, en 21 de 25, y en el mercado chino, en 9 de 15. Las demás salen con 0. El código 2 no apareció en ninguna de las 117 piezas.

Y ahí está el matiz que sigue importando: un 3 no significa que el resultado no sirva, significa que hay métodos que fallaron. La decompilación parcial es el comportamiento normal de jadx sobre cualquier aplicación real. El 3 se puede fiar: ninguna de las 95 piezas con salida 3 carecía de marcadores de fallo. El 0 no: 2 de las 10 piezas de F-Droid y del mercado chino con salida 0 tenían métodos sin decompilar (las dos de F-Droid). Por eso, para medir cuánto se perdió, hay que contar los marcadores también cuando el código de salida es 0. Dos ejemplos: com.reteclock 90, salida 0 con 1 método Method not decompiled: en Thumbnails.write y nada en el registro; y com.jvillalba.apod.md 11, salida 0 con 2 métodos sin decompilar y 2 con «Code decompiled incorrectly». Si automatizas, no trates el 3 como fallo del pipeline; distingue el 2 (no hay nada que decompilar, esto sí es un fallo) del 3, y para medir cuánto se perdió, cuenta los marcadores de fallo en la salida generada:

find salida/sources -name '*.java' | wc -l
grep -rl 'JADX ERROR:'              salida/sources | wc -l
grep -rl 'Method not decompiled:'   salida/sources | wc -l
grep -rl 'Code decompiled incorrectly' salida/sources | wc -l
grep -rlE 'JADX ERROR:|Method not decompiled:|Code decompiled incorrectly' salida/sources | wc -l
    1415
       3
       6
       1
       6

6 de los 1.415 ficheros .java (0,42 %) tienen algún método sin decompilar. Es una tasa por fichero: no se puede comparar con las tasas por método de la «sección 6 · La comparación honesta: qué dicen las mediciones». Por método son 6 de 17.898 con código (0,03 %). Ese cociente, y no el código de salida, es la medida útil de la calidad del resultado. Salen 6 y no 4 porque los 3 JADX ERROR y el Code decompiled incorrectly suman 4 ficheros, y los otros 2 (kotlinx/coroutines/CoroutineContextKt y DebugKt, ambos <clinit>) llevan un JADX WARN: Code restructure failed y también acaban en «Method not decompiled:». Los 6 ficheros son androidx/fragment/app/FragmentManager, androidx/recyclerview/widget/DiffUtil, androidx/recyclerview/widget/GridLayoutManager, androidx/constraintlayout/solver/widgets/ConstraintWidget, kotlinx/coroutines/CoroutineContextKt y kotlinx/coroutines/DebugKt, todos de com.termux 1022. El resultado de grep depende del idioma de los marcadores de jadx 1.5.6; con otra versión puede cambiar.

Hay que grepear los tres marcadores. La cadena Failed to decompile no existe en la salida de jadx: solo aparece en un comentario de AType.java y en el logger de la GUI (DecompileTask.java), nunca en los .java generados. Una receta que la busque devuelve cero por esa rama y deja fuera el marcador que más importa: en este APK, el único fichero con Code decompiled incorrectly es androidx/recyclerview/widget/GridLayoutManager.java (también con --show-bad-code), y es precisamente el que con --show-bad-code enseñaría Java plausible que puede no corresponder al comportamiento real («sección 3.5 · Los modos de fallo, y qué significa cada uno»). Los 6 métodos que fallan en Termux 1022 están en bibliotecas (androidx y kotlinx), no en el código de la aplicación.

Los contenedores se abren igual, sin fusionar nada antes («sección 3.4 · Plugins»). Ejecutamos estas órdenes el 31 de octubre de 2026 sobre un .apkm, un .xapk y una carpeta de adb del muestrario (las piezas están en la «sección 3.4 · Plugins»):

jadx -d salida/ app.apkm
jadx -d salida/ app.xapk
jadx -d salida/ base.apk split_config.arm64_v8a.apk   # carpeta de adb: la base y sus splits

El plugin también acepta .aab y .apks, pero no tenemos ninguno y no los probamos.

8. Cómo elegir, en una tabla

Situación Qué usar
Leer código de un APK, caso general jadx
Leer código, exploración interactiva jadx-gui, con la vista de smali al lado
jadx escribió JADX ERROR en el método que me importa dex2jar + Vineflower, o CFR; o Bytecode Viewer para probarlos a la vez
Un .jar o .class suelto, sin APK Vineflower o CFR directamente
Código muy ofuscado y hay presupuesto JEB
Necesito el comportamiento exacto, sin reconstrucción No decompiles: «smali»
La app es de Flutter, React Native, Unity o similar jadx solo enseña la envoltura: mirar libapp.so, el bundle de JavaScript o libil2cpp.so («sección 2.6 · Lo que jadx no ve»)
La app está empaquetada (Jiagu, Bangcle, Ijiami…) jadx solo ve el cargador; un código de salida 0 no dice nada («sección 3.5 · Los modos de fallo, y qué significa cada uno»)
Automatizar en CI jadx en subproceso, contando marcadores de fallo aunque el código de salida sea 0

Y la regla que resume el documento: cuando el Java y el smali discrepan, el smali tiene razón.

Fuentes

  1. jadx — repositorio oficial — https://github.com/skylot/jadx Consultado el 12 de agosto de 2026 vía https://api.github.com/repos/skylot/jadx. De aquí salen la licencia Apache-2.0, la fecha de creación, el recuento de estrellas, forks e issues, y la fecha del último push de la ficha de la «sección 3.1 · Ficha».
  2. jadx — releases — https://api.github.com/repos/skylot/jadx/releases Consultado el 12 de agosto de 2026. De aquí salen la versión 1.5.6 y su fecha de publicación, y el historial de releases citado en la «sección 3.1 · Ficha».
  3. jadx — README oficial — https://github.com/skylot/jadx#readme Consultado el 12 de agosto de 2026. De aquí salen la lista de opciones de la CLI de la «sección 7 · Recetas de jadx CLI», la lista de plugins de entrada de la «sección 3.4 · Plugins», los subcomandos de plugins, y la advertencia literal de que «in most cases jadx can't decompile all 100% of the code».
  4. jadx — Troubleshooting Q&A (wiki) — https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A Consultado el 12 de agosto de 2026. De aquí salen el significado de --show-bad-code y las recomendaciones de memoria e hilos de la «sección 3.5 · Los modos de fallo, y qué significa cada uno». Consultado de nuevo el 18 de octubre de 2026 (raw.githubusercontent.com/wiki/skylot/jadx/Troubleshooting-Q&A.md): sigue proponiendo cambiar -Xmx4g por -Xmx8g en DEFAULT_JVM_OPTS. Los marcadores literales de la «sección 3.5 · Los modos de fallo, y qué significa cada uno» no salen de aquí: están verificados contra el árbol del proyecto y contrastados en la «sección 6 de Diagnóstico de fallos · jadx».
  5. A Large-Scale Empirical Study of Android App Decompilation — Noah Mauthe, Ulf Kargén, Nahid Shahmehri. SANER 2021. https://www.ida.liu.se/~ulfka17/papers/SANER2021.pdf Consultado el 12 de agosto de 2026; PDF descargado y extraído con pdftotext para leer las tablas directamente. De aquí sale toda la «sección 6 · La comparación honesta: qué dicen las mediciones»: tamaños de los conjuntos, tablas V, VI y VII, medias de métodos por aplicación, el 96 % de complementariedad, los fallos de dex2jar, y las conclusiones sobre ofuscación.
  6. dex2jar — repositorio oficial — https://github.com/pxb1988/dex2jar Consultado el 12 de agosto de 2026 vía la API de GitHub. De aquí salen la licencia, la versión 2.4, la fecha del último push y los recuentos de la «sección 4.2 · dex2jar».
  7. CFR — repositorio oficial — https://github.com/leibnitz27/cfr Consultado el 12 de agosto de 2026 vía la API de GitHub y su lista de tags. De aquí salen la licencia MIT, la release 0.152 y el contraste entre el push de junio de 2026 y la ausencia de releases desde 2021.
  8. CFR — página oficial del autor — https://www.benf.org/other/cfr/ Consultado el 12 de agosto de 2026. Confirma que la versión anunciada sigue siendo la 0.152 de diciembre de 2021, y de aquí sale su sintaxis de invocación.
  9. Vineflower — repositorio oficial — https://github.com/Vineflower/vineflower Consultado el 12 de agosto de 2026 vía la API de GitHub. De aquí salen la licencia Apache-2.0, la versión 1.12.0 del 29 de abril de 2026, y su declaración de ser un fork de Fernflower.
  10. Procyon — repositorio oficial — https://github.com/mstrobel/procyon Consultado el 12 de agosto de 2026 vía la API de GitHub y su lista de releases. De aquí salen la versión 0.6.0 de febrero de 2022 y la fecha del último push, que sostienen la afirmación de que está parado.
  11. Bytecode Viewer — repositorio oficial — https://github.com/Konloch/bytecode-viewer Consultado el 12 de agosto de 2026 vía la API de GitHub. De aquí salen la licencia GPL-3.0, la versión 2.13.2 y los recuentos de la «sección 5.2 · Bytecode Viewer».
  12. JEB Decompiler — página oficial de PNF Software — https://www.pnfsoftware.com/jeb/ Consultado el 12 de agosto de 2026. De aquí salen las ediciones, la lista de arquitecturas decompiladas y la versión 5.36 de la «sección 5.1 · JEB (PNF Software)».
  13. skylot/jadx, jadx-cli/src/main/java/jadx/cli/JadxCLI.java — https://github.com/skylot/jadx/blob/d25eda4839f2806b0bfefab303b7e00685520b91/jadx-cli/src/main/java/jadx/cli/JadxCLI.java Leído el 13 de agosto de 2026 vía la API de GitHub. De aquí sale la tabla de códigos de salida de la «sección 7 · Recetas de jadx CLI»: los return 0/1/2/3 de execute y runSave.
  14. jadx 1.5.6 ejecutado localmente — instalado con Homebrew y ejecutado el 31 de octubre de 2026 sobre com.termux 1022 del muestrario. De aquí salen los códigos de salida comprobados, el recuento de 1.415 ficheros .java y los 6 con algún marcador de fallo, 3 de ellos con JADX ERROR: («sección 7 · Recetas de jadx CLI»).
  15. Forks de pxb1988/dex2jar — https://github.com/ThexXTURBOXx/dex2jar Consultada la lista de forks por estrellas el 13 de agosto de 2026 con gh api repos/pxb1988/dex2jar/forks. De aquí sale la tabla de la «sección 4.2 · dex2jar».
  16. JetBrains/intellij-community, plugins/java-decompiler/ — https://github.com/JetBrains/intellij-community/tree/72eeeb1028656bb95f701fe6d461bd3c1bac589c/plugins/java-decompiler Consultado el 13 de agosto de 2026 vía la API de GitHub. De aquí salen la ubicación de Fernflower, su división en engine y plugin, y su licencia Apache-2.0 de la «sección 4.3 · Los decompiladores de Java».
  17. JEB — página de compra de PNF Software — https://www.pnfsoftware.com/jeb/buy Consultado el 25 de septiembre de 2026. De aquí salen los precios anuales de JEB Android, JEB Pro, JEB Pro Floating y JEB Pro OEM de la «sección 5.1 · JEB (PNF Software)».
  18. jadx 1.5.6 — jadx-core/src/main/java/jadx/core/Jadx.java — https://github.com/skylot/jadx/blob/v1.5.6/jadx-core/src/main/java/jadx/core/Jadx.java Consultado el 25 de septiembre de 2026. De aquí salen las pasadas de las cuatro etapas de la «sección 3.2 · La arquitectura, en cuatro etapas».
  19. Kargén, Mauthe y Shahmehri, «Android decompiler performance on benign and malicious apps: an empirical study», Empirical Software Engineering 28(2):48, 2023 — https://doi.org/10.1007/s10664-022-10281-9 (texto completo en https://liu.diva-portal.org/smash/get/diva2:1743022/FULLTEXT01) Consultado el 25 de septiembre de 2026. Es la versión en revista del estudio de SANER 2021, con el seguimiento sobre malware de la «sección 6 · La comparación honesta: qué dicen las mediciones».
  20. jadx 1.5.6 ejecutado localmente, y su árbol en la etiqueta v1.5.6 — https://github.com/skylot/jadx/blob/v1.5.6/jadx-cli/build.gradle.kts y https://github.com/skylot/jadx/tree/v1.5.6/jadx-plugins Ejecutado el 18 de octubre de 2026 (jadx --version, jadx --help, jadx plugins --list-all, instalación de Homebrew) y consultado el mismo día vía la API de GitHub. De aquí salen la lista de plugins de la «sección 3.4 · Plugins», la línea de uso de --help (JadxCLIArgs.java, línea 51) y que jadx-raung-input existe en el árbol pero no figura entre las dependencias de jadx-cli.
  21. jadx — ClassGen.java, MethodGen.java y JadxCommentsAttr.java en varias etiquetas — https://github.com/skylot/jadx/blob/v0.7.1/jadx-core/src/main/java/jadx/core/codegen/ClassGen.java, https://github.com/skylot/jadx/blob/v1.2.0/jadx-core/src/main/java/jadx/core/codegen/ClassGen.java, https://github.com/skylot/jadx/blob/v1.3.0/jadx-core/src/main/java/jadx/core/dex/attributes/nodes/JadxCommentsAttr.java y https://github.com/skylot/jadx/blob/v1.5.6/jadx-core/src/main/java/jadx/core/codegen/MethodGen.java Consultados el 18 de octubre de 2026 sobre los tarballs de las etiquetas v0.6.1, v0.7.1, v0.8.0, v1.0.0, v1.1.0, v1.2.0, v1.3.0 y v1.5.6. De aquí salen la historia de JADX WARNING: y de // decompilation failed de la «sección 3.5 · Los modos de fallo, y qué significa cada uno», y lo que jadx 1.5.6 escribe para un método con INCONSISTENT_CODE con y sin --show-bad-code (ClassGen.addMethodCode, MethodGen.getFallbackMethodGen y MethodGen.dumpInstructions). Las fechas de la 0.7.1 (25 de marzo de 2018) y de la 1.3.0 (20 de noviembre de 2021) salen de GET /repos/skylot/jadx/releases/tags/<etiqueta> de la API de GitHub, consultada el mismo día.
  22. R8/D8 — código de desazucarado — https://r8.googlesource.com/r8/+/a0a267b9159ab189c40805418a3e8e207d3b3628/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java, https://r8.googlesource.com/r8/+/a0a267b9159ab189c40805418a3e8e207d3b3628/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java y https://r8.googlesource.com/r8/+/a0a267b9159ab189c40805418a3e8e207d3b3628/src/main/java/com/android/tools/r8/utils/InternalOptions.java Consultados el 18 de octubre de 2026. De aquí sale la tabla de la «sección 2.2 · El azúcar sintáctico»: el desazucarado de lambdas se registra sin condición de API y solo reconoce los bootstrap de LambdaMetafactory (isLambdaMetafactoryMethod); canUseInvokeCustomWithIndyStringConcat solo es cierto al generar .class, nunca DEX; e invokeCustomApiLevel() e invokePolymorphicOnMethodHandleApiLevel() devuelven AndroidApiLevel.O, la API 26, e invokePolymorphicOnVarHandleApiLevel(), AndroidApiLevel.P, la 28.
  23. Java 8+ language features — documentación oficial de Android — https://developer.android.com/studio/write/java8-support Consultado el 18 de octubre de 2026. De aquí salen que las lambdas y las referencias a método están disponibles «on any API level» y que MethodHandle.invoke e invokeExact exigen minSdkVersion 26 («sección 2.2 · El azúcar sintáctico»).
  24. D8 ejecutado localmente — el 18 de octubre de 2026, D8 9.2.4-dev de build-tools 37.0.0, javac 21.0.10 con --release 17 y dexdump, sobre una clase de prueba con dos lambdas y dos concatenaciones, compilada con --min-api 21, 26 y 36. De aquí sale la comprobación de la «sección 2.2 · El azúcar sintáctico».
  25. AOSP — VarHandle.java de libcore y el intérprete de ART en android-17.0.0_r1 — https://android.googlesource.com/platform/libcore/+/refs/tags/android-17.0.0_r1/ojluni/src/main/java/java/lang/invoke/VarHandle.java y https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/runtime/interpreter/interpreter_common.cc Consultados el 18 de octubre de 2026. De aquí sale que los métodos de acceso de VarHandle están marcados @MethodHandle.PolymorphicSignature y que invoke-polymorphic los despacha (DoInvokePolymorphic, líneas 540-566, y los DoVarHandle…, líneas 494-532), de la «sección 2.2 · El azúcar sintáctico».
  26. R8 — Compatibility FAQ — https://r8.googlesource.com/r8/+/refs/heads/main/compatibility-faq.md Consultado el 18 de octubre de 2026. De aquí sale la «sección 2.1 · Los genéricos»: la firma genérica que se lee por reflexión obliga a pedir -keepattributes Signature —el ejemplo de TypeToken de Gson, «also needed for R8 in compat mode»—, y en modo completo los atributos «are only kept for classes, methods and fields which are matched by keep rules even when -keepattributes is specified».
  27. javac, D8, dexdump y jadx ejecutados localmente — el 18 de octubre de 2026, con javac 21.0.10, el D8 9.2.4-dev y dexdump de build-tools 37.0.0 y jadx 1.5.6 de Homebrew. De aquí salen: el bloque locals de la clase Saldo compilada con y sin -g y con d8 --debug y --release («sección 2.3 · Los nombres de las variables locales»); su salida con -m simple y la descripción de ese modo en jadx --help («sección 3.2 · La arquitectura, en cuatro etapas»); el mapping.txt de ProGuard aplicado sin -P y con -Prename-mappings.invert=yes, y la línea de ayuda de --mappings-path («sección 3.6 · --deobf y mapping.txt: dos cosas distintas»); y jadx --no-src sobre un APK mínimo con clase R, que no escribe ningún .java («sección 7 · Recetas de jadx CLI»).
  28. jadx 1.5.6 — lanzador libexec/bin/jadx de Homebrew — leído el 18 de octubre de 2026: DEFAULT_JVM_OPTS (línea 47) lleva -XX:MaxRAMPercentage=70.0 y ningún -Xmx, y la línea 181 añade $JAVA_OPTS $JADX_OPTS detrás. Con la JVM que usa el lanzador (OpenJDK 26.0.1 de Homebrew), -XX:+PrintFlagsFinal da un MaxHeapSize de 12.029.263.872 bytes en una máquina de 16 GiB, y de 8.589.934.592 si se añade -Xmx8g («sección 3.5 · Los modos de fallo, y qué significa cada uno»).
  29. jadx 1.5.6 — JadxDecompiler.java — https://github.com/skylot/jadx/blob/v1.5.6/jadx-core/src/main/java/jadx/api/JadxDecompiler.java Consultado el 18 de octubre de 2026. getSaveTasks solo añade appendSourcesSave si no se ha pedido --no-src («sección 7 · Recetas de jadx CLI»).
  30. jadx 1.5.6 sobre una submuestra de 117 piezas del muestrario — «sección 6.5 · Lo que da jadx 1.5.6 sobre el muestrario». Pasada del 31 de octubre de 2026 con -j 4, 5.734 MB de memoria Java y un tope de 900 s por pieza; la submuestra se describe en «El muestrario». De aquí salen las cifras de las secciones «3.3», «3.5», «6.2», «6.4», «6.5» y «7» que se refieren a la submuestra.