Skip to content

Processor Reference

nativify's GUI (and its headless mode) ships a library of bytecode processors — self-contained transformations you can run over a JAR/APK individually or chain together. Each processor declares a category, a one-line description, and a set of tags that warn you about its behaviour (e.g. whether it may break code or shrink the file).

List every processor available in your build at any time:

dist/bin/nativify-gui --headless --list-processors

Run one (or several, in order):

dist/bin/nativify-gui --headless \
  --input app.jar --output app-out.jar \
  --processor "Remove Attributes" \
  --processor "Remove Unnecessary"

Tag legend

Tags appear next to each processor below. They describe what to expect, not what the processor does:

Tag Meaning
Native Compiles selected methods to native code via LLVM.
Bytecode transform Rewrites bytecode directly (no native step).
Stronger protection Provides stronger protection against reversing.
Analysis resistant Makes static analysis harder.
Shrink Reduces file size.
Runnable Output is expected to remain executable.
Possible damage Code can possibly become inexecutable — verify output.
Possible verify error Output could throw VerifyError.
Slow Processing may take a long time.
Uses internet Requires a network connection.

Obfuscation

Processors that make your code harder to understand and reverse-engineer.

Processor What it does Tags
Native Code Obfuscation Compiles methods to native and applies LLVM-level obfuscation passes — control-flow flattening, bogus control flow, and instruction substitution. This is nativify's core feature. Native · Stronger protection · Analysis resistant · Possible damage

Configuration: Native Code Obfuscation is configurable (method selection, annotation gating, complexity thresholds). See the Usage Guide for the headless defaults and how to select methods.

Optimization

Processors that clean up and shrink bytecode. Safe to run as a pre- or post-pass.

Processor What it does Tags
Inline Methods Inlines trivial methods that only return or throw. Runnable · Shrink
Remove Attributes Removes unnecessary class attributes. Runnable · Shrink
Remove Unnecessary Removes unnecessary instructions and dead code. Runnable · Shrink
Remove Unused Variables Removes unused local variables. Runnable · Shrink
Simplify Bit Operations Simplifies bitwise operations. Runnable

Analysis & Deobfuscation

Processors that undo common obfuscation patterns or recover readable structure — useful when analysing third-party code or cleaning up already-obfuscated input.

Processor What it does Tags
Reobfuscate Class Names Generates human-readable names for obfuscated classes. Possible damage · Runnable
Reobfuscate Members Renames obfuscated methods and fields. Possible damage · Runnable
Reobfuscate Variable Names Renames obfuscated local variable names. Runnable
Restore Source Files Restores SourceFile attributes based on the class name. Runnable
Convert compare instructions Converts compare instructions to simpler forms. Runnable
Remove predictable conditional jumps Removes conditional jumps whose outcome is predictable. Possible verify error · Runnable
Fix obfuscated access Removes synthetic and bridge access flags. Runnable
Remove try-catch obfuscation Removes try-catch blocks that catch exceptions that can never be thrown. Possible damage · Runnable
Remove Monitors Removes all monitor (monitorenter/monitorexit) instructions. Possible damage · Runnable
Remove Try-Catch Blocks Removes all try-catch blocks. Possible damage · Runnable

Tools

General-purpose utilities for compatibility, debugging, and class housekeeping.

Processor What it does Tags
Add Line Numbers Adds line-number debug information to methods. Runnable
Isolate Possibly Malicious Isolates calls to potentially malicious code. Possible damage · Runnable
Java 7 Compatibility Downgrades class version to Java 7. Possible damage · Runnable
Java 8 Compatibility Ensures Java 8 compatibility. Runnable
Log All Exceptions Adds logging to all catch blocks. Runnable
Remove Maxs Resets maxLocals/maxStack to force recalculation. Runnable

Choosing processors

  • Just want native obfuscation? Use Native Code Obfuscation alone — or the CLI, which wraps the same engine with @Nativify annotation support.
  • Shrinking a JAR? Chain the Optimization processors (Remove Attributes → Remove Unnecessary → Remove Unused Variables).
  • Analysing obfuscated input? Start with the Analysis & Deobfuscation group.
  • Processors tagged Possible damage / Possible verify error can produce non-runnable output — always test the result before shipping.

Processors run in the exact order you list them, so order your chain so that cleanup/optimization runs before obfuscation.