Nerotek01
I build, break, and harden software. My focus is Minecraft development, distributed systems, and offensive security.
Forged in anger. Sharpened by betrayal.
Nerotek01 wasn't born — it was carved out of a grudge. Five years ago I was a quiet kid building Minecraft plugins for communities that promised loyalty and paid in contempt. Servers I poured months into were stolen. Credit was erased. The people I trusted turned out to be the same people who left the backdoors open on purpose.
I stopped trusting. I started reading. Every leaked source, every deobfuscated jar, every CVE writeup, every reversing challenge I could find. The anger didn't go away — it became a craft. I learned to read code the way an attacker reads it: not for what it does, but for what it lets you do. Once you see systems that way, you can't unsee it.
Now I build things that don't break, and I break things that other people build. The two halves feed each other. Every plugin I write is a plugin I know how to exploit. Every audit I run teaches me a new way to defend the next one. The grudge never settled — I just pointed it at the work. Build it like you'll break it. Break it like you built it.
What I carry into the work.
Not exhaustive — just the tools I reach for first. I learn from source code and writeups, not tutorials. The offensive side is where I spend most of my curiosity now.
Minecraft Dev
CorePlugins, server arch, anti-cheat, performance.
TypeScript / JS
LanguageNode, React, Next.js, Bun, runtime internals.
Java / Kotlin
LanguageJVM internals, bytecode, Paper/Bukkit APIs.
Reverse Engineering
OffensiveGhidra, IDA, javap, deobfuscation, RCE chains.
Exploit Development
OffensiveMemory corruption, ROP, JVM deserialization, PoCs.
Pentest / Audit
OffensiveBlack-box, white-box, threat modeling, recon.
Packet & Protocol
OffensiveNetty pipelines, MITM, custom protocol fuzzing.
SQL · NoSQL
DataSchema design, injection, query optimization.
Systems Design
InfraSharded backends, 1k+ concurrent, failover.
Distributed Sys
InfraProxy meshes, state replication, consensus.
Realtime / WS
InfraSocket.io, Netty, custom binary protocols.
Bash · Rust · Go
LanguageCLI tools, automation, low-level utilities.
Where the grudge started.
This is where I learned that code is never just code — it's a contract, and contracts get broken. I started young, building plugins for small servers, and watched those servers get stolen, leaked, hijacked. The lesson stuck: every system you build will eventually be attacked by someone who understands it better than you do. So I became that someone.
Plugin Development
Bukkit · Spigot · Paper · Folia — custom mechanics, anti-cheat, performance tuning.
Server Architecture
BungeeCord · Velocity · multi-proxy sharding for 1k+ concurrent players.
Realtime Systems
Netty pipelines, packet-level optimizations, custom protocol bridges.
World Engines
Chunk streaming, custom generators, anvil-level data manipulation.
Craft
Every plugin is built like a hand tool — with intent, with purpose, with character.
Scale
From 10 to 10,000 concurrent players — the difference is architecture, not code.
Secure
Every input is a potential threat. Every packet might be an attack. Always.
The other half of the work.
Breaking things is the fastest way to learn how they actually work. I spend as much time reading other people's code with hostile intent as I spend writing my own. Not to cause harm — to understand. The PoCs stay private. The lessons go into everything I build.
Reverse Engineering
Static and dynamic analysis of JVM bytecode, native binaries, and obfuscated plugins. Ghidra, IDA, javap, custom deobfuscation pipelines.
Exploit Development
Memory corruption, ROP chains, JVM deserialization gadgets, logic flaws. Every PoC is a lesson; every lesson is a defense.
Protocol & Packet
Custom Netty pipelines, MITM on game protocols, packet-level fuzzing, replay attacks, state-machine breaking.
Audit & Hardening
Black-box and white-box audits, threat modeling, CSP design, sandboxing. The flip side of breaking — making it not break.
every system I can break, I can also defend. the rest is just a question of time.
Slow code is a bug.
Most performance problems are inherited, not designed. I trace them down to the allocation, the syscall, the lock contention — then I kill them. Real numbers, real flame graphs, no cargo-cult optimization.
Profiling First
Async-profiler, async-profiler, async-profiler. Never optimize without a flame graph in hand.
Memory Discipline
Object pools, allocation hotspots, GC tuning. A server that GCs less serves more.
Packet-Level
Custom Netty pipelines, zero-copy, batched flushes. The kernel is not your friend.
Measure, Don't Guess
JMH, jmh, jmh. Microbenchmarks lie less than intuition. Always cold + warm runs.
if you can't measure it, you can't make it faster.
If you have something worth breaking.
I take select work — Minecraft architecture, security audits, exploit development for authorized targets. If you're building something that needs a build-break-harden mindset, I'm listening.