Forem: Lukas Hammer

Level Up Your Linux Game: My Journey Through OverTheWire’s Bandit & Natas

Lukas Hammer — Mon, 09 Feb 2026 13:03:39 +0000

If you’ve ever wanted to feel like a hacker in a 90s movie—minus the glowing green rain and the frantic "I'm in"—wargames are the place to start. Specifically, OverTheWire.

I recently dove into their challenges to sharpen my technical skills, and it’s been a wild ride of "Aha!" moments and "Wait, what?" frustrations. This post is just the beginning; I’ll be updating this blog with every other OverTheWire wargame level as I complete them, but for now, let’s look at my experience with the first two: Bandit and Natas.

1. Bandit: The Gold Standard for Linux Newbies

Bandit is the entry-level wargame, and honestly, it is a masterclass in learning by doing.

The Vibe

It starts simple—find a password in a file called readme. But soon, you’re hunting for hidden files, filtering strings with grep, and learning how to navigate a terminal like a pro.

The "Fun" Factor

It is incredibly satisfying. Because the game forces you to figure things out yourself, every level you beat feels like a genuine win. It’s tricky, but it feels fair.

The Flow

For the most part, Bandit is perfectly paced. I almost always knew exactly what to do after reading through the documentation for the suggested commands. It strikes that rare balance of being challenging without being confusing.

The GitHub Twist

The shift toward using Git and GitHub toward the end is a very cool touch. However, this was the one area that felt a bit random. Unlike the previous levels, the guidance here felt a bit thin, making the tasks feel slightly disconnected from the steady climb of the earlier stages.

Verdict: Essential for anyone who wants to stop being afraid of the command line.

2. Natas: Entering the Web Wilderness

Once you’ve conquered the terminal, Natas introduces you to Serverside Web Security. This is where the training wheels come off—and the bike might feel like it's missing a wheel.

The Learning Curve

Unlike Bandit, which guides you through documentation, Natas can feel a bit "random" if you don’t have prior web knowledge. Without that background:

You're Directionless: You have no idea what the goal is or where to start looking for the vulnerability.
Search Paralysis: You don't even know what terms to Google. It’s hard to find an answer when you don't even know what the problem is called.

Verdict: A great challenge for aspiring security buffs, but you definitely need a baseline of web development knowledge before diving in.

What’s Next?

Wargames are easily one of the most addictive ways to learn tech. They strip away the boring lectures and replace them with a puzzle-solving rush. While the jump to Natas is steep, the solid foundation built in Bandit makes it all worth it.

Stay tuned, because as I fight my way through Krypton, Leviathan, and the rest, I'll be adding my thoughts and progress right here.

Pro Tip: In Bandit, actually read the man pages (manuals) for the suggested commands. They usually hold the "key" to the password!

Building My First Emulator: A CHIP-8 Journey in Rust

Lukas Hammer — Sun, 08 Feb 2026 15:08:26 +0000

Building My First Emulator: A CHIP-8 Journey in Rust

When I decided to build a CHIP-8 emulator, I had no idea how much I'd learn along the way. This was my first time creating an emulator and my first big Rust project—quite the combination! But looking back now, with both a desktop and web version running, I couldn't be more proud of what I've accomplished.

Why CHIP-8?

CHIP-8 is the perfect starting point for emulator development. It's simple enough to be approachable but complex enough to teach you real emulation concepts. With only 35 opcodes, 4KB of memory, and a 64x32 monochrome display, it's manageable yet challenging.

Plus, I wanted to really dive into Rust. What better way to learn than building something complex?

The Core: Platform-Agnostic Interpreter

I started by building the core CHIP-8 interpreter—the brain of the emulator. This handles:

CPU emulation with 16 8-bit registers
4KB of RAM
A 16-level stack
Two 60Hz timers (delay and sound)
The full instruction set

Writing this in Rust taught me so much about ownership and borrowing. The compiler kept me honest, catching bugs before they became problems. Every error message was a learning opportunity.

The beauty of separating the core logic? I could reuse it for both desktop and web versions later!

Desktop Version: SDL2 Window to the Past

For the desktop frontend, I used SDL2 to handle graphics, input, and window management. This was my first time working with SDL2, and it was surprisingly straightforward.

The desktop version lets you:

Load ROM files from your filesystem
Play games with keyboard input (mapped to CHIP-8's 16-key hexadecimal keypad)
See the classic 64x32 display scaled up to a comfortable size

Web Version: WebAssembly Magic

This is where things got really exciting. I wanted people to play my emulator without installing anything, so I dove into WebAssembly.

Using wasm-pack, I compiled my Rust code to WebAssembly and created a browser-based version. The same core interpreter, now running in your browser with near-native performance!

The web version taught me:

How to bridge Rust and JavaScript
Working with the browser's canvas API
Handling user input in web contexts
Deploying WebAssembly applications

Seeing my Rust code run in a browser for the first time was genuinely magical.

Challenges Along the Way

Not everything went smoothly (does it ever?):

The wasm32 Target Mystery: I initially installed Rust via Homebrew, which didn't include the WebAssembly target. Switching to Rustup and adding wasm32-unknown-unknown solved it, but it was a confusing detour.

LSP Configuration Headaches: Getting my Neovim setup to work with both Rust and JavaScript auto-formatting took some trial and error. But now my workflow is smooth!

Opcode Implementation: Some instructions were straightforward, but others (looking at you, display drawing with XOR) required careful testing with multiple ROMs to get right.

What I Learned

This project taught me far more than just Rust syntax:

Systems Programming: Understanding how CPUs work, memory management, and instruction cycles
Cross-Platform Development: Building for both native desktop and web from a single codebase
Project Structure: Organizing code into modules (chip8_core, desktop, wasm, website)
Debugging: Using test ROMs to verify my implementation
Modern Web Tech: WebAssembly isn't just hype—it's genuinely powerful

Try It Yourself!

You can play the emulator right now at minipliy.net/chip8 or check out the source code on GitHub.

Final Thoughts

If you're learning Rust or curious about emulator development, I highly recommend starting with CHIP-8. It's challenging enough to push your skills but achievable enough to finish. And seeing those retro games come to life through code you wrote? Absolutely worth it.

Big thanks to aquova's CHIP-8 tutorial for guidance along the way!

Want to build your own emulator? Start with CHIP-8, embrace the compiler errors, and enjoy the journey. You'll learn more than you expect.

Made with Love and Rust

My Rust Learning Journey: Challenges, Projects, and Growth

Lukas Hammer — Sat, 06 Sep 2025 14:14:37 +0000

I've been spending a lot of time with "The Rust Programming Language" lately, and honestly, it’s been a game-changer. I’ve been working through the exercises in the 2023 edition to get a real feel for how the language works.

Rust isn't exactly easy—the ownership system and the compiler can be pretty demanding—but that’s what makes it so rewarding. I’ve been practicing the core concepts like borrowing, using collections, and handling errors properly. One project I really enjoyed was building a Median and Mode Finder. It was a great way to practice parsing input and managing data, especially when handling multiple modes at once.

Each chapter helps me feel more confident in my code. The book does a fantastic job of giving you just enough guidance while still letting you solve problems on your own. If you’re thinking about learning Rust, I’d highly recommend starting there; it's an incredible resource. I’m excited to keep building and see where this goes next.

Also check out all of the projects on GitHub.