# jclasslib: a bytecode editor for reading and rewriting compiled Java classes > jclasslib is a desktop tool and Kotlin Multiplatform library for inspecting and editing compiled Java class files. It is strongest when you need to change a constant pool entry or an opcode, not when you want readable Java source back. **ingokegel/jclasslib** — jclasslib bytecode editor is a tool that visualizes all aspects of compiled Java class files and the contained bytecode. - Repository: https://github.com/ingokegel/jclasslib - Stars: 2,994 · Forks: 424 - Language: Kotlin - License: NOASSERTION - Published: 2026-09-24 · Updated: 2026-09-24 · Language: en - Canonical page: https://hysenlabs.com/projects/ingokegel-jclasslib ## What jclasslib is for, and who actually needs it A compiled Java class file is not source code. It is a binary container holding a constant pool, method tables, attributes and a stream of bytecode instructions. When a bug only appears after compilation, or when a library behaves differently from what its source suggests, the class file is the artifact that matters. jclasslib visualizes all aspects of those files and the contained bytecode, and lets many of those aspects be edited in the UI. The README states the purpose plainly and also notes that the project ships a Kotlin Multiplatform library for reading and writing class files and bytecode. The audience splits in two. The first group works in the desktop UI: people debugging unusual compiler output, teaching how the JVM represents a method, or patching a class without a full build. The second group never opens the window. They depend on the library coordinates `org.jclasslib:jclasslib-data:` to parse or generate class files inside their own tooling. Those are different products sharing one repository, and it is worth deciding which one you are evaluating before anything else. ## How the viewer and the library fit together The UI is a class file browser. The README describes opening multiple class files at once by selecting class or JAR files, browsing a configured classpath, or dragging class files onto the window. From there, the constant pool, attributes and bytecode instructions are shown and can be modified. Editing referenced constant pool entries is possible directly from the context menu reached through the Edit button of an attribute or a pool entry, and bytecode instructions are edited from their own context menu. The library is the second half. It is published on Maven Central as a Kotlin Multiplatform artifact, with platform-specific variants under `org.jclasslib:jclasslib-data-jvm:` and `org.jclasslib:jclasslib-data-js:`. That split matters: a JVM target and a JavaScript target are both supported, so the same parsing code can run in a browser-side tool. The repository layout reflects this, with `modules/` holding the code and `lib-compile/` present at the top level alongside `build.gradle.kts` and `settings.gradle.kts`. One design consequence is worth stating directly. The tool edits class files, not source. There is no decompilation step in the README, so a round trip through jclasslib gives you a modified class file, not readable Java. If you need source, this is the wrong layer. ## Installing jclasslib and opening your first class file The README points to two install paths. Installers live in the releases section of the repository, and on macOS Homebrew is supported. The Homebrew formula name is not the project name, which is easy to get wrong. The README gives this command: ```sh brew install jclasslib-bytecode-viewer ``` After that, launching the application opens the main window. The README gives three ways to load a class: selecting class or JAR files, browsing a configured classpath, or dragging class files on top of the window. Loading a JAR lets you move through the classes it contains without extracting anything first. If you want the library instead of the application, the README lists the Maven Central coordinates for the base artifact and for the platform-specific artifacts: ```sh org.jclasslib:jclasslib-data: org.jclasslib:jclasslib-data-jvm: org.jclasslib:jclasslib-data-js: ``` The README does not include a code sample showing how to parse a file with the library, so the first real use of the library is something you will have to derive from the API rather than copy from the documentation. That gap is real and worth knowing before you budget time for an integration. For IntelliJ IDEA users there is a third route: a plugin installed through the plugin manager. The README says the action in the View menu can be invoked when a Java, Groovy or Kotlin file is open in the editor, and the bytecode appears in a jclasslib tool window on the right. Multiple class files can be open there at the same time. ## Where jclasslib stops being the right tool The most common mismatch is expecting source. People search for ways to convert a class file back to Java, and jclasslib does not do that. It shows you the structure and the instructions. Reading a stack map table or a line number attribute is not the same as reading the method body in Java, and no amount of UI polish changes that. A second limit is that editing is at the level of constant pool entries and opcodes. The README describes exactly those two editing surfaces. If your change requires restructuring control flow, adding methods, or reasoning about types, you are working below the level where the tool helps, and a source-level patch plus recompilation is the safer path. Editing a class file in place also means you own the result: the tool writes what you tell it to write. A third consideration is the desktop application itself. It is a GUI, and the README describes no command line interface for inspecting or editing a class. Anything scripted has to go through the Kotlin library, which is a different artifact with a different API surface. ## jclasslib compared with Recaf and JByteMod The searches around this project consistently pair it with Recaf and JByteMod, and the difference is in scope rather than in polish. Recaf is generally positioned as an all-in-one bytecode workspace: assembly editing, decompilation views and scripting in one environment. JByteMod is a bytecode editor in the same family. jclasslib's own README makes a narrower claim, that it visualizes all aspects of class files and edits many of them, and it pairs that with a published multiplatform library. That pairing is the actual distinction. If you want a single application to decompile, edit and reassemble, jclasslib is not competing for that job. If you want a viewer whose model of a class file is also available to you as a library with JVM and JS artifacts, the library is the reason to pick it. The IntelliJ IDEA plugin is a third option that neither Recaf nor JByteMod occupies in the same way, since it puts the bytecode in a tool window next to the source you are already editing. ## Licence, maintenance and upgrade cost The README states that jclasslib bytecode editor is released under GPL, Version 2.0, and links to the licence text. The repository's licence field reports NOASSERTION, which means the automated classification did not resolve to a standard identifier. Those two signals disagree, and anyone embedding the library in a distributed product should read the licence file at the repository root rather than rely on either summary. This is not legal advice; the point is that the discrepancy exists and is easy to miss. The maintenance picture is current. The last push was on 2026-08-31, and the most recent release listed is 7.1 from 2026-04-23, following 7.0 in December 2025 and 6.1 in January 2025. That cadence suggests releases are not frequent, so pinning a version and reading the release notes before moving is reasonable. Upgrade cost depends on which half you use. The desktop application is a download or a Homebrew formula, so upgrading is replacing an installer. The library is a Maven dependency with a version placeholder in the coordinates, and because it is multiplatform, a version bump can affect the JVM and JS artifacts separately. The README does not document rollback or compatibility guarantees between library versions, so treat a version change as something to test rather than assume. ## Conclusion Adopt jclasslib when you need to see or change what the compiler actually emitted: a constant pool entry, an opcode, a class file attribute. Do not adopt it as a decompiler; it does not turn a .class file back into Java source, and the README points to no such feature. Before relying on it, verify the licence terms yourself, since the repository's licence field is NOASSERTION while the README states GPL Version 2.0, and confirm that the installer for your platform exists in the releases section. ## FAQ ### How do I open a Java .class file with jclasslib? Install the application from the releases section or with the Homebrew formula, then load the class file in the main window. The README lists three ways: selecting class or JAR files, browsing a configured classpath, or dragging class files onto the window. ### Can jclasslib convert a .class file back to a Java file? No. jclasslib visualizes class file structure and bytecode and lets you edit constant pool entries and opcodes, but the README describes no decompilation or source generation feature. ### Is there an IntelliJ IDEA plugin for jclasslib? Yes. The README states there is a plugin installable through the plugin manager, and that its action in the View menu can be invoked when a Java, Groovy or Kotlin file is open. The bytecode appears in a jclasslib tool window on the right. ### Can I use jclasslib as a library instead of the desktop application? Yes. The Kotlin Multiplatform library for reading and writing JVM class files is on Maven Central as org.jclasslib:jclasslib-data, with platform-specific artifacts for JVM and JS. ### What can be edited in the jclasslib UI? The README says all constant pool entries can be edited, referenced entries can be edited from the context menu of the Edit button on attributes and pool entries, and bytecode instructions can be edited from their context menu. ## Sources - [ingokegel/jclasslib on GitHub](https://github.com/ingokegel/jclasslib) - [Issues](https://github.com/ingokegel/jclasslib/issues) - [README](https://github.com/ingokegel/jclasslib/blob/master/README.md) - [Releases](https://github.com/ingokegel/jclasslib/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ingokegel-jclasslib