Decompilador Java online para archivos .class. Inspecciona bytecode, invokedynamic, StringConcatFactory, campos y métodos directamente en tu navegador.
Arrastra un archivo .class aquí o haz clic para subir
Arrastra un archivo .class al área de carga o pega bytecode en formato hexadecimal.
El decompilador analiza el archivo class y reconstruye el código fuente Java automáticamente.
Activa 'Mostrar bytecode' para ver el desensamblado de instrucciones JVM dentro de los métodos.
Copia el código fuente decompilado o descárgalo como archivo .java.
Lee el formato de archivos class de Java incluyendo el pool de constantes, campos, métodos, atributos y tablas de excepciones.
Desensambla instrucciones de bytecode JVM con resolución simbólica de operandos desde el pool de constantes.
Genera código Java legible con declaraciones de paquete, jerarquía de clases, tipos de campos y firmas de métodos.
Toda la decompilación se ejecuta localmente en tu navegador. Tus archivos class y código propietario nunca abandonan tu dispositivo.
A diferencia de los decompiladores basados en servidor que suben tus archivos class para procesarlos, esta herramienta se ejecuta completamente en tu navegador mediante JavaScript. El bytecode propietario, las bibliotecas internas y el código sensible de aplicaciones permanecen en tu máquina. Ningún dato se transmite, registra o almacena en ningún servidor — ideal para entornos corporativos con políticas estrictas de manejo de datos.
Sin instalación de JDK, sin plugins de IDE, sin herramientas de línea de comandos. Arrastra un archivo .class y obtén código fuente decompilado en milisegundos. La herramienta funciona en cualquier dispositivo con un navegador moderno — escritorio, portátil o tablet — perfecta para inspecciones rápidas cuando no tienes un entorno de desarrollo completo disponible.
Activa el modo bytecode para ver las instrucciones JVM reales junto al código fuente reconstruido. Cada opcode está anotado con referencias al pool de constantes resueltas a nombres de clase, firmas de métodos y valores literales legibles. Este nivel de detalle es invaluable para análisis de rendimiento, auditoría de seguridad y comprensión de cómo el compilador traduce las construcciones Java.
El analizador maneja archivos class de todas las versiones principales de Java, leyendo correctamente las entradas del pool de constantes incluyendo MethodHandle, InvokeDynamic, Module y Package introducidos en versiones recientes. Ya sea que estés analizando un archivo J2EE antiguo o un microservicio Spring Boot moderno, la herramienta lo maneja.
Cada programa Java se compila mediante javac en uno o más archivos .class que contienen bytecode — una representación intermedia independiente de la plataforma que la Máquina Virtual Java (JVM) interpreta o compila JIT en tiempo de ejecución. La decompilación invierte este proceso, transformando el bytecode en código fuente Java legible. Comprender cómo funciona esto es esencial para auditores de seguridad, mantenedores de bibliotecas y desarrolladores que depuran dependencias opacas de terceros.
Un archivo class comienza con el número mágico 0xCAFEBABE, seguido de números de versión menor y mayor que identifican la versión de Java utilizada para compilarlo. A continuación viene el pool de constantes — una tabla de cadenas, nombres de clases, firmas de métodos, literales numéricos y referencias a métodos bootstrap que todas las demás estructuras del archivo indexan. El pool de constantes es la estructura más importante para la decompilación porque proporciona los nombres simbólicos que hacen legible el bytecode.
Después del pool de constantes, el archivo declara los flags de acceso de la clase (public, final, abstract, interface, enum), los nombres de clase y superclase, e interfaces implementadas. Luego vienen las tablas de campos y métodos, cada entrada conteniendo flags de acceso, un nombre, un descriptor de tipo y una lista de atributos. El atributo más importante es Code, que contiene las instrucciones de bytecode reales de un método.
El bytecode JVM opera sobre una máquina de pila. En lugar de registros, los operandos se empujan y sacan de una pila de operandos. Instrucciones como iload_1 empujan una variable local a la pila; iadd saca dos enteros, los suma y empuja el resultado. Las invocaciones de métodos (invokevirtual, invokestatic, invokeinterface, invokedynamic) sacan argumentos de la pila, llaman al método destino y empujan el valor de retorno.
Las instrucciones de salto (ifeq, goto, tableswitch) controlan el flujo saltando a diferentes offsets de bytecode. Un decompilador reconstruye estructuras de control de alto nivel (if/else, for, while, switch) analizando estos patrones de salto — un proceso llamado análisis de flujo de control.
El bytecode Java retiene mucha más metadata que el código máquina nativo. Los nombres de clases, métodos, campos y descriptores de tipo se almacenan en el pool de constantes como cadenas de texto. Cuando se compila con información de depuración (javac -g), los nombres de variables locales y tablas de números de línea también se preservan. Esta rica metadata hace relativamente sencillo reconstruir la estructura del código fuente original.
javac traduce expresiones lambda, genéricos, try-with-resources y pattern matching a bytecode.Los comentarios nunca se almacenan en el bytecode y no pueden recuperarse. El formato, los espacios en blanco y el orden de los imports se pierden. Los nombres de variables solo están disponibles cuando hay información de depuración presente. Las herramientas de ofuscación (ProGuard, R8) renombran clases y métodos a identificadores sin significado, integran código en línea y reestructuran el flujo de control, haciendo la salida decompilada más difícil de leer — aunque la lógica permanece funcionalmente equivalente.
El pool de constantes es la estructura más crítica para la decompilación. Contiene todas las referencias simbólicas del archivo class: nombres de clases, descriptores de métodos, cadenas literales, valores numéricos y referencias a métodos bootstrap para invokedynamic. Cada instrucción de bytecode que accede a un campo, invoca un método o carga una constante referencia una entrada del pool de constantes por su índice. Al resolver estas referencias, el decompilador puede reconstruir nombres legibles de clases, tipos de parámetros y valores de retorno, transformando instrucciones opacas como invokevirtual #42 en llamadas comprensibles como System.out.println().
La mejor forma de entender la decompilación es asumir que el bytecode conserva muy bien el comportamiento, pero conserva peor la intención de autoría. Puedes recuperar con gran fiabilidad el nombre del paquete, la clase, los campos, los métodos, los descriptores de tipo, la jerarquía de herencia, muchas anotaciones presentes en el bytecode y la lógica de instrucciones que ejecuta la JVM. Lo que normalmente no puedes recuperar es el comentario original, el formato, el orden de imports y, en muchos casos, los nombres exactos de variables locales si el compilado no incluye información de depuración. Los genéricos se preservan parcialmente mediante atributos de firma, pero parte de su expresividad se pierde por type erasure.
Las características modernas de Java también se reconstruyen con fidelidad desigual. Las lambdas se convierten en patrones invokedynamic y pueden decompilarse otra vez como lambdas legibles, pero el resultado depende del compilador y del decompilador. Las inner classes, los métodos puente sintéticos y los miembros generados para records pueden aparecer en formas que nunca fueron escritas tal cual en el código fuente. La ofuscación añade otra capa: la lógica sigue disponible, pero los nombres humanos se sustituyen por identificadores sin sentido. En la práctica, la decompilación es excelente para auditar comportamiento y entender dependencias, pero no debe confundirse con una copia perfecta del repositorio original.
| Elemento del bytecode | Fidelidad de recuperación | Limitación típica |
|---|---|---|
| Nombres de clase, campo y método | Alta | Los ofuscadores pueden renombrarlos |
| Flujo de control | Alta | Switches complejos y ramas sintéticas pueden verse distintos al fuente |
| Nombres de variables locales | Media | Requieren símbolos de depuración; si no, se generan placeholders |
| Genéricos y anotaciones | Media a alta | Type erasure elimina parte de la intención del fuente |
| Comentarios y formato | Nula | No se almacenan en el bytecode |
No. Toda la decompilación se ejecuta 100% en tu navegador usando JavaScript. Tus archivos .class nunca abandonan tu dispositivo. Ningún dato se transmite, registra o almacena en ningún servidor.
La herramienta soporta archivos class desde Java 1.1 (versión mayor 45) hasta Java 24 (versión mayor 68), cubriendo todos los tipos de tags del pool de constantes incluyendo MethodHandle, InvokeDynamic, Dynamic, Module y Package.
Los nombres de variables solo están disponibles si la clase fue compilada con información de depuración (javac -g). Sin información de depuración, la herramienta genera nombres placeholder como arg0, arg1. Los nombres de métodos y campos siempre se preservan en el pool de constantes.
Sí, la herramienta puede analizar y decompilar archivos class ofuscados. Sin embargo, la salida contendrá identificadores ofuscados (ej. a.b.c en lugar de nombres significativos). La lógica del bytecode siempre es completamente recuperable independientemente de la ofuscación.
El desensamblado convierte bytecode en instrucciones JVM legibles (como javap -c). La decompilación va más allá, reconstruyendo código fuente Java de alto nivel con declaraciones de clases, firmas de métodos e información de tipos. Esta herramienta proporciona ambas funciones — activa 'Mostrar bytecode' para ver el desensamblado.
Esta herramienta procesa archivos .class individuales. Para decompilar un JAR, primero extráelo (un JAR es un archivo ZIP), luego sube archivos .class individuales. Cada archivo .class corresponde a una clase Java.
La herramienta reconstruye con precisión la estructura de clases, declaraciones de campos, firmas de métodos y manejadores de excepciones. Muestra desensamblado de bytecode con referencias al pool de constantes resueltas. Para decompilación completa a nivel de código fuente con flujo de control reconstruido, considera complementar con herramientas offline como CFR o Procyon.
Sí. Una vez que la página está cargada, el decompilador funciona completamente sin conexión a internet.
La herramienta acepta archivos .class de Java (formato binario que comienza con 0xCAFEBABE) y bytecode codificado en hexadecimal pegado directamente en el área de texto. No acepta archivos .java de código fuente ni archivos .jar directamente.
La decompilación para interoperabilidad, investigación de seguridad y aprendizaje personal es generalmente legal en la mayoría de jurisdicciones. La Directiva de Software de la UE y la doctrina de uso justo de EE.UU. proporcionan protecciones. Sin embargo, siempre verifica las leyes locales y cualquier acuerdo de licencia que pueda restringir la ingeniería inversa de software específico.
Sí. La ofuscación dificulta la lectura al renombrar clases, métodos y variables, pero no impide que el bytecode se analice. Seguirás recuperando la lógica y la estructura de llamadas, aunque con nombres menos útiles y un flujo de control visualmente más áspero.
Un archivo .class contiene una clase Java compilada. Un .jar es un contenedor ZIP que puede incluir muchas clases, recursos y metadatos. Decompilar un JAR suele implicar extraerlo primero y luego abrir las clases individuales que te interesan.
Sí. Mientras el decompilador entienda las etiquetas y atributos de las versiones modernas, el bytecode sigue siendo inspeccionable. Las construcciones recientes del lenguaje pueden traducirse a patrones generados por el compilador, pero la estructura general y las instrucciones JVM se siguen pudiendo revisar.
Aprende a inspeccionar y decompilar archivos JAR de Java paso a paso, desde extraer clases hasta comparar decompiladores y validar bytecode.
Leer más →Aprende un flujo práctico para decompilar clases Java con herramientas locales, IntelliJ, CFR y comprobaciones de bytecode para depurar y auditar mejor.
Leer más →Entiende la estructura del bytecode Java, el constant pool, los descriptores, los stack frames y invokedynamic para inspeccionar clases con confianza.
Leer más →Aprende cómo están estructurados los archivos .class de Java, cómo el bytecode se mapea al código fuente y cómo los decompiladores reconstruyen Java legible.
Leer más →