World: Air Place puts a block where you are looking with nothing under it, and
Auto Build puts one under your feet when there is nothing there and you are on
the way down. Both go through useItemOn with a BlockHitResult built the way a
real click would have produced one, so the packet, cooldown and swing are the
game's own. A neighbouring face is preferred and only genuinely unsupported
placement falls back to clicking empty air, since that is the part a server can
refuse.

Auto Totem moves a totem to the offhand below a health threshold, through the
container path (26.2 renamed ClickType to ContainerInput) so the server sees an
ordinary inventory action. Auto Shield raises on the tick a hit lands rather
than predicting the swing: a shield that comes up before the attacker moves is
a tell, one that comes up on the hit is just fast.

No Hurt Camera was clearing hurtTime after the frame that had already drawn the
lurch, so every hit still showed one. It now zeroes damageTiltStrength, the
option the renderer consults while drawing, so there is nothing to see at all.

The aimbot was a lerp, which is fastest the instant it acquires and then crawls
— the opposite of how a hand moves, and the reason it read as a bot. It is now
a critically damped spring with a capped turn rate, so a turn accelerates,
carries and settles, and no acquisition is ever instant. A little noise on the
aim point keeps it from sitting perfectly still on a moving target.

Also: watermark off by default, and the unload watchdog no longer gives up
after one sighting of the marker — if the marker appeared while the game was
not drawing, the request went unheard and the copy was stranded for good.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

The menu was styled like a modern app: rounded panels, a pastel accent, soft
padding, and a paragraph of explanation under every module. Rebuilt in the idiom
these clients have used for fifteen years — Minecraft's own chat palette, hard
square borders, 15px rows, no switch graphics (an enabled module is simply lit),
values written across the slider they belong to, and no prose at all. Every
string is drawn twice, offset, the way the game draws its own text: the absence
of that shadow is the clearest sign of something bolted on from outside.

Binding moved to right-click on a module, which is where it belongs and frees
the row of its chip.

Made it shippable while I was in there. Everything the client reads or writes
now lives beside the DLL rather than at a hardcoded C:\lodestone, the font is
embedded with a file beside the DLL still taking precedence, and the loader
carries the client inside it: build.rs embeds the DLL, and the loader writes it
out under a fresh name before injecting. An explicit path argument still wins,
so the dev loop is unchanged.

The earlier conclusion that embedding the font broke loading was wrong — that
was the shell quoting bug in deploy.sh, and the test that seemed to confirm it
was marshalling ANSI into LoadLibraryW.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

No Java crash report, no JVM fatal log, no Windows fault event — and the game
log shows a public server rather than a single-player world. That pattern is a
hang, not a crash, and the cause is that the scans were written for a quiet
world.

A single-player world holds a handful of entities and a few chests. A public
server near spawn holds thousands of each, and every one costs several JNI
calls per frame — entity ESP even reads a name string per entity per frame. The
base scan was the worst of it: it walked every block entity in 289 chunks once
a second, which near a chest room is a multi-hundred-millisecond stall on the
render thread, every second.

So everything now has a ceiling: entity targets are capped and sorted nearest
first so the cap keeps what matters; block entities cap both what is kept and
what is examined, because looking for shulkers on a server that has none
otherwise walks the lot; the drawing caps boxes independently; and the ore sweep
budget is halved, since each position is a Java allocation and three calls.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Auto Dodge treats the two threats differently, because they are different
problems. An arrow is already in flight on a known path, so the answer is
geometry: solve for the time of closest approach, and if it passes within about
a player's width, step across the path on the side you are already drifting
towards — sooner means a smaller step, so urgency scales the commitment. A
hostile mob follows you instead, so the answer is distance, weighted by inverse
square so the one breathing on you outweighs the one across the room.

Both produce a direction to want. The last step is the one a naive "run away"
skips: try that heading, then progressively wider deviations either side, and
take the first that is actually walkable — head clear, and something to land on
rather than a ledge. blocksMotion is the game's own passability test, so tall
grass reads as passable and a fence does not. A one-block step is a hop rather
than a stall.

Freecam now hides the HUD. 26.2 moved it out of Gui into its own Hud class, so
the flag F1 sets is Hud.isHidden; the old Options.hideGui is gone, which is the
same restructuring that moved Minecraft.screen onto Gui.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The rubber-banding was not bad luck, it was three specific vanilla checks:

- A server counts ticks where your vertical delta is >= -0.03125 while you are
  not allowed to fly, and disconnects at eighty of them. Flight now dips below
  that threshold on a timer, which puts the counter back to zero, so the kick
  never arrives.
- handleMovePlayer re-simulates the move you claim, with collision, and pulls
  you back when the result differs. Teleport steps that pass through a block do
  exactly that, so steps are capped and a "stay within server limits" switch
  holds velocity and step size to what is accepted.
- Nothing at all is checked if nothing is sent. LocalPlayer.sendPosition only
  builds a packet when the position differs from xLast/yLast/zLast or
  positionReminder reaches 20, so writing the current position into those every
  frame suppresses movement packets entirely. Freecam is now genuinely free
  rather than a fight with the server, and Blink falls out of the same trick.

Added Bhop, which is just vanilla's own sprint-jump bonus and therefore nothing
for a server to disagree with.

X-Ray takes a block selection: thirteen groups, each with its own colour,
deepslate variants folded in.

Base finder reads block entities out of the loaded chunks instead of sweeping
blocks — shulker boxes, ender chests, beacons, brewing stands, enchanting
tables — covering the whole loaded area in one pass, with a coordinate list.
Container ESP moved onto the same mechanism and is much faster for it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Kill aura was a nearest-target loop on a timer, which in modern Minecraft
lands twenty hits for a fraction of the damage of one. It now waits on the
attack-cooldown bar (Player.getAttackStrengthScale), picks targets by
nearest/weakest/smallest-turn, asks the game whether it can actually see the
target (hasLineOfSight) instead of ignoring the through-walls switch, and
rotates for the swing.

Criticals were backwards: the hop was applied with the swing, so every hit
landed while rising and none of them were critical. It now hops, holds the
swing, and lands it on the way down.

Frame-rate dependence fixed throughout: physics runs per tick, so velocity
modules act on a tick boundary (Entity.tickCount) and velocity speed sets an
absolute speed instead of scaling each frame, which compounded into a
slingshot. Aimbot smoothing is time-based, so the turn takes the same time at
30 fps as at 300.

ESP finished: X-Ray and container highlighting. Blocks have no list to walk, so
the volume is swept a slice per frame with a fixed budget and the completed
pass swapped in; block identity is System.identityHashCode on the singleton
Block, one int compare rather than a chain of reference tests.

Also: auto respawn.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The project gains a second half. The external explorer stays (and is how every
name below was verified against the running game), but the cheat menu now runs
inside Minecraft:

- inject a DLL, hook glfwSwapBuffers, draw egui in the game's own GL context
- drive the game through JNI rather than raw memory, so writes go through the
  GC's barriers and methods can be called directly
- five draggable windows: Combat, Movement, ESP, Visuals, Misc
- client-side only: nothing depends on owning the server

Modules wired to the game: fly (vanilla/smooth/glide/teleport), speed
(abilities/velocity), no-fall, jetpack, auto-sprint, noclip, step, high jump,
jesus, spider, freecam; kill aura, aimbot (camera/silent, smoothed), trigger
bot, reach, auto clicker with jitter, anti-knockback, criticals; entity ESP with
boxes, tracers, nametags and health bars; fullbright, custom FOV, no hurt
camera, no weather, no view bob; hide-from-capture.

Per-module keybinds, a panic key, and settings saved to disk.

GL state the game leaves behind has to be neutralised before drawing and put
back after: a sampler object on unit 0 renders everything black, and a stale
GL_UNPACK_ROW_LENGTH scrambles the font atlas.

Unload unhooks and goes inert rather than unmapping the module, which crashed
the game while the window still pointed at our window procedure.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>