Goal#

Make a basic xray by overwriting JVM classes at runtime.

Bridge#

First we will need to inject our own class to be allowed to communicate between the JVM and the DLL

1
public class JNIBridge {
2
    public static native boolean allowBlock(String blockName);
3
    public static native boolean xrayOn();
4
}

Make sure to compile it to .class with the right JDK version (for me JDK 1.6.0 because I will use Lunar 1.8.9).

allowBlock will ask the DLL if we need to render the block or not.
xrayOn will ask the DLL if xray is on.

Dump all classes#

Then we will look at which class we want to edit. Here, for my xray, I want to edit the Block class because this is where the game performs the render logic.

Find the `net/minecraft/block/Block` class#

To get the Block.class you can either unzip the JAR file, or if you want, you can also dump all classes with some dynamic class dumper (you can make your own or use this one - you can use Process Hacker to inject the DLL).

dump

If your client is not on Forge it might have some obfuscated methods and class names. If so, you can check:

Edit Block class with Recaf#

Then you will need to patch the class file. I like to use Recaf to do so.

In Recaf, find the method you would like to edit. For me, shouldSideBeRendered, because this method returns whether a side should be rendered or not, so for my xray I will be able to control what to render or not.

1
public boolean shouldSideBeRendered(IBlockAccess iBlockAccess, BlockPos blockPos, EnumFacing enumFacing) {
2
       if (JNIBridge.xrayOn()) {
3
           return JNIBridge.allowBlock(this.toString())
4
       };
5
        CallbackInfoReturnable callbackInfoReturnable = new CallbackInfoReturnable("shouldSideBeRendered", true);
6
        handler$zgg000$lunar$xrayDontRenderBlockSides(iBlockAccess, blockPos, enumFacing, callbackInfoReturnable);
7
        if (callbackInfoReturnable.isCancelled()) {
8
            return callbackInfoReturnable.getReturnValueZ();
9
        }
10
        if (enumFacing == EnumFacing.DOWN && this.minY > 0.0d) {
11
            return true;
12
        }
13
        if (enumFacing == EnumFacing.UP && this.maxY < 1.0d) {
14
            return true;
15
        }
16
        if (enumFacing == EnumFacing.NORTH && this.minZ > 0.0d) {
17
            return true;
18
        }
19
        if (enumFacing == EnumFacing.SOUTH && this.maxZ < 1.0d) {
20
            return true;
21
        }
22
        if (enumFacing != EnumFacing.WEST || this.minX <= 0.0d) {
23
            return (enumFacing == EnumFacing.EAST && this.maxX < 1.0d) || !iBlockAccess.getBlockState(blockPos).getBlock().isOpaqueCube();
24
        }
25
        return true;
26
    }

1
.method public shouldSideBeRendered (Lnet/minecraft/world/IBlockAccess;Lnet/minecraft/util/BlockPos;Lnet/minecraft/util/EnumFacing;)Z {
2
    parameters: { this, ☃, ☃2, ☃3 },
3
    code: {
4
   R:
5
       invokestatic JNIBridge.xrayOn ()Z
6
       ifeq A
7
       aload this
8
       invokevirtual java/lang/Object.toString ()Ljava/lang/String;
9
       invokestatic JNIBridge.allowBlock (Ljava/lang/String;)Z
10
       ireturn
11
    A:
12
        new org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable
13
        dup
14
        ldc "shouldSideBeRendered"
15
        iconst_1
16
        invokespecial org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.<init> (Ljava/lang/String;Z)V
17
        astore v4
18
        aload this
19
        aload ☃
20
        aload ☃2
21
        aload ☃3
22
        aload v4
23
        invokevirtual net/minecraft/block/Block.handler$zgg000$lunar$xrayDontRenderBlockSides (Lnet/minecraft/world/IBlockAccess;Lnet/minecraft/util/BlockPos;Lnet/minecraft/util/EnumFacing;Lorg/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable;)V
24
        aload v4
25
        invokevirtual org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.isCancelled ()Z
26
        ifeq B
27
        aload v4
28
        invokevirtual org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.getReturnValueZ ()Z
29
        ireturn
30
    B:
31
        line 390
32
        aload ☃3
33
        getstatic net/minecraft/util/EnumFacing.DOWN Lnet/minecraft/util/EnumFacing;
34
        if_acmpne D
35
        aload this
36
        getfield net/minecraft/block/Block.minY D
37
        dconst_0
38
        dcmpl
39
        ifle D
40
    C:
41
        line 391
42
        iconst_1
43
        ireturn
44
    D:
45
        line 393
46
        aload ☃3
47
        getstatic net/minecraft/util/EnumFacing.UP Lnet/minecraft/util/EnumFacing;
48
        if_acmpne F
49
        aload this
50
        getfield net/minecraft/block/Block.maxY D
51
        dconst_1
52
        dcmpg
53
        ifge F
54
    E:
55
        line 394
56
        iconst_1
57
        ireturn
58
    F:
59
        line 396
60
        aload ☃3
61
        getstatic net/minecraft/util/EnumFacing.NORTH Lnet/minecraft/util/EnumFacing;
62
        if_acmpne H
63
        aload this
64
        getfield net/minecraft/block/Block.minZ D
65
        dconst_0
66
        dcmpl
67
        ifle H
68
    G:
69
        line 397
70
        iconst_1
71
        ireturn
72
    H:
73
        line 399
74
        aload ☃3
75
        getstatic net/minecraft/util/EnumFacing.SOUTH Lnet/minecraft/util/EnumFacing;
76
        if_acmpne J
77
        aload this
78
        getfield net/minecraft/block/Block.maxZ D
79
        dconst_1
80
        dcmpg
81
        ifge J
82
    I:
83
        line 400
84
        iconst_1
85
        ireturn
86
    J:
87
        line 402
88
        aload ☃3
89
        getstatic net/minecraft/util/EnumFacing.WEST Lnet/minecraft/util/EnumFacing;
90
        if_acmpne L
91
        aload this
92
        getfield net/minecraft/block/Block.minX D
93
        dconst_0
94
        dcmpl
95
        ifle L
96
    K:
97
        line 403
98
        iconst_1
99
        ireturn
100
    L:
101
        line 405
102
        aload ☃3
103
        getstatic net/minecraft/util/EnumFacing.EAST Lnet/minecraft/util/EnumFacing;
104
        if_acmpne N
105
        aload this
106
        getfield net/minecraft/block/Block.maxX D
107
        dconst_1
108
        dcmpg
109
        ifge N
110
    M:
111
        line 406
112
        iconst_1
113
        ireturn
114
    N:
115
        line 408
116
        aload ☃
117
        aload ☃2
118
        invokeinterface net/minecraft/world/IBlockAccess.getBlockState (Lnet/minecraft/util/BlockPos;)Lnet/minecraft/block/state/IBlockState;
119
        invokeinterface net/minecraft/block/state/IBlockState.getBlock ()Lnet/minecraft/block/Block;
120
        invokevirtual net/minecraft/block/Block.isOpaqueCube ()Z
121
        ifne O
122
        iconst_1
123
        goto P
124
    O:
125
        iconst_0
126
    P:
127
        ireturn
128
    Q:
129
    }
130
}

You can also make a fullbright effect if xray is on:

1
public float getAmbientOcclusionLightValue() {
2
    if (JNIBridge.xrayOn()) {
3
        return 1.0f;
4
    }
5
    CallbackInfoReturnable v1 = new CallbackInfoReturnable("getAmbientOcclusionLightValue", true);
6
    handler$zgg000$lunar$setXrayLightLevel(v1);
7
    return v1.isCancelled() ? v1.getReturnValueF() : isBlockNormalCube() ? 0.2f : 1.0f;
8
}

1
.method public getAmbientOcclusionLightValue ()F {
2
    parameters: { this },
3
    code: {
4
   Z:
5
       invokestatic JNIBridge.xrayOn ()Z
6
       ifeq A
7
       fconst_1
8
       freturn
9
    A:
10
        new org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable
11
        dup
12
        ldc "getAmbientOcclusionLightValue"
13
        iconst_1
14
        invokespecial org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.<init> (Ljava/lang/String;Z)V
15
        astore v1
16
        aload this
17
        aload v1
18
        invokevirtual net/minecraft/block/Block.handler$zgg000$lunar$setXrayLightLevel (Lorg/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable;)V
19
        aload v1
20
        invokevirtual org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.isCancelled ()Z
21
        ifeq B
22
        aload v1
23
        invokevirtual org/spongepowered/asm/mixin/injection/callback/CallbackInfoReturnable.getReturnValueF ()F
24
        freturn
25
    B:
26
        line 832
27
        aload this
28
        invokevirtual net/minecraft/block/Block.isBlockNormalCube ()Z
29
        ifeq C
30
        ldc 0.200000003F
31
        goto D
32
    C:
33
        fconst_1
34
    D:
35
        freturn
36
    E:
37
    }
38
}

1
public int getLightValue() {
2
   if (JNIBridge.xrayOn()) {
3
       return 15;
4
   }
5
    return this.lightValue;
6
}

1
.method public getLightValue ()I {
2
    parameters: { this },
3
    code: {
4
   Z:
5
       invokestatic JNIBridge.xrayOn ()Z
6
       ifeq A
7
       bipush 15
8
       ireturn
9
    A:
10
        line 119
11
        aload this
12
        getfield net/minecraft/block/Block.lightValue I
13
        ireturn
14
    B:
15
    }
16
}

Implement the DLL native method logic#

Bool Enable / Disable Logic#

First, for the enable logic, I will just return a boolean variable g_xrayEnabled. I will switch it on/off with a thread that checks if I press some keys:

1
static jboolean JNICALL Native_xrayOn(JNIEnv*, jclass)
2
{
3
    return g_xrayEnabled ? JNI_TRUE : JNI_FALSE;
4
}

AllowBlock#

In this example, I will just check if it’s a _ore block. If so, allowBlock will return true, else false:

1
static jboolean JNICALL Native_allowBlock(JNIEnv* env, jclass, jstring jName)
2
{
3
    if (!jName)
4
        return JNI_FALSE;
5

6
    const char* utf = env->GetStringUTFChars(jName, nullptr);
7
    bool allowed = false;
8

9
    if (utf)
10
    {
11
        const char* suffix = "_ore}";
12
        const size_t len = std::strlen(utf);
13
        const size_t suf_len = std::strlen(suffix);
14

15
        if (len >= suf_len && std::strcmp(utf + (len - suf_len), suffix) == 0)
16
        {
17
            allowed = true;
18
        }
19

20
        env->ReleaseStringUTFChars(jName, utf);
21
    }
22

23
    return allowed ? JNI_TRUE : JNI_FALSE;
24
}

Overwriting classes#

Block Class#

For the next steps you will first need to set up JNI and JVMTI and find the Block class (tiEnv here is my JVMTI env):

1
jclass blockClass = nullptr;
2

3
for (int i = 0; i < classCount; ++i)
4
{
5
    char* sig = nullptr;
6
    if (tiEnv->GetClassSignature(classes[i], &sig, nullptr) == JVMTI_ERROR_NONE && sig)
7
    {
8
        if (std::strcmp(sig, "Lnet/minecraft/block/Block;") == 0)
9
        {
10
            blockClass = classes[i];
11
            break;
12
        }
13
    }
14
}

Then you will be able to redefine classes with JVMTI like this:

1
jvmtiClassDefinition def;
2
std::memset(&def, 0, sizeof(def));
3
def.klass = blockClass;
4
def.class_byte_count = (jint)sizeof(block_class_bytes);
5
def.class_bytes = block_class_bytes;
6

7
err = tiEnv->RedefineClasses(1, &def);

block_class_bytes here is just a char block_class_bytes[] that contains the bytes of our custom Block class that we patched before with Recaf.

Insert our Bridge class#

First, to insert a new class we will need to find the classloader. We can easily obtain it with GetClassLoader from JVMTI by using the location of the known blockClass (env here is my JNI env):

1
jobject blockLoader = nullptr;
2
err = tiEnv->GetClassLoader(blockClass, &blockLoader);
3

4
jclass jniBridgeClass = env->DefineClass(
5
    "JNIBridge",
6
    blockLoader,
7
    reinterpret_cast<const jbyte*>(JNIBridge_class),
8
    (jsize)sizeof(JNIBridge_class)
9
);

Then we will be able to register all our native methods:

1
JNINativeMethod methods[] = {
2
    {
3
        const_cast<char*>("allowBlock"),
4
        const_cast<char*>("(Ljava/lang/String;)Z"),
5
        (void*)&Native_allowBlock
6
    },
7
    {
8
        const_cast<char*>("xrayOn"),
9
        const_cast<char*>("()Z"),
10
        (void*)&Native_xrayOn
11
    }
12
};
13

14
if (env->RegisterNatives(jniBridgeClass, methods, sizeof(methods) / sizeof(methods[0])) != 0)
15
{
16
    LOGF("[MainThread] RegisterNatives(JNIBridge) failed");
17
    break;
18
}
19
LOGF("[MainThread] JNIBridge natives registered");

Reload Chunk#

To enable or disable certain rendering features (such as xray), the game must refresh the visual state of all loaded blocks. This requires triggering a full chunk reload inside Minecraft’s rendering engine.

However, Minecraft imposes strict constraints: chunk reloading may only be executed from the render thread. Calling it from any other thread (e.g., a native worker thread) can cause OpenGL context errors or Java exceptions.

To safely perform a reload from native code, the system relies on three key mechanisms:

A global reload request flag.
A function hook that intercepts execution on the render thread.
A JNI-based function that invokes Minecraft’s internal chunk-reload method.

1. Reload Request Flag (`g_needReload`)#

Any part of the native code that wants the game to refresh its chunks does not call Minecraft directly. Instead, it simply raises a flag:

1
static volatile bool g_needReload = false;

And when a reload is needed:

1
g_needReload = true;

This flag indicates:

“A reload should happen, but only when we are safely on the render thread.”

This prevents invalid thread access to rendering systems or JVM structures.

2. Render Thread Hook (`glOrtho` Detour)#

Minecraft’s rendering pipeline frequently calls an OpenGL function named glOrtho. Most importantly:

It is always called on the render thread.
It is called every frame, guaranteeing regular execution points.

The system replaces glOrtho with a custom wrapper. This wrapper performs the following:

Checks whether a reload was requested (g_needReload).
If so, resets the flag and initiates a safe reload.
Then calls the original glOrtho to preserve the normal game behavior.

Example wrapper (simplified):

1
void hk_glOrtho(...) {
2
    if (g_needReload) {
3
        g_needReload = false;
4
        ReloadChunks();   // safe to call here
5
    }
6

7
    original_glOrtho(...); // continue normal rendering
8
}

How the hook is installed#

I will uses MinHook, a lightweight and widely used Windows API hooking library.

Simplified:

1
MH_Initialize();
2
MH_CreateHook(&glOrtho, &hk_glOrtho, &original_glOrtho);
3
MH_EnableHook(MH_ALL_HOOKS);

3. Java-Based Chunk Reload (`ReloadChunks()`)#

The actual reloading is achieved by calling Minecraft’s internal method:

1
Minecraft.getMinecraft().renderGlobal.loadRenderers();

To do this safely from native code, the system uses JNI.

1
ReloadChunks() {
2
    // Get JVM thread context
3
    JNIEnv* env = ...;
4

5
    // Call Minecraft.getMinecraft()
6
    minecraftInstance = call_static_method("Minecraft", "getMinecraft");
7

8
    // Access minecraft.renderGlobal
9
    renderGlobal = get_field(minecraftInstance, "renderGlobal");
10

11
    // Perform the actual reload
12
    call_method(renderGlobal, "loadRenderers");
13
}

Conclusion#

And there we have it — with the class patches, the native bridge, the JVM runtime overwrite, and the chunk-reload system, we now have everything needed to build a fully functional xray for Minecraft.
From here, you can extend the logic, implement reach, ESP, …

xray

Feel free to dm me on discord : jsthop3

Credit#

https://www.unknowncheats.me/forum/minecraft/713887-jni-defineclass-redefineclass-runtime.html

Source Code#

The full project is available on GitHub:

https://github.com/jsthope/SimpleLunarXray