Hi, I'm dlunch 🍊

I explore how things work, build tools, and share what I learn along the way.

About Me

A brief introduction

I'm a hacker at heart — someone who can't leave a piece of software alone when it works but I don't yet understand why. Whether it's reverse engineering old binaries, dissecting an undocumented file format, or piecing together how a long-dead runtime actually behaves, I find the process of figuring things out more interesting than most polished end results.

Most of what I build comes out of that habit. If I run into a problem worth solving twice, it usually ends up as a small tool, a CLI utility, or a longer-running project like WIE. I lean toward systems-level work — emulators, parsers, virtual machines — but I'll reach for whatever fits the job: Rust for performance-sensitive code, C++ when I'm interfacing with legacy ecosystems, TypeScript for anything that lives in the browser, and Python or shell for quick one-offs.

Open source is where most of this work lives. I contribute back when I can, ship my own projects publicly by default, and try to write things up on the blog so the next person hitting the same wall doesn't have to start from scratch.

These days I spend most of my hobby time on emulation, WebAssembly tooling, and the long tail of legacy platforms that no longer have anyone maintaining them officially. There's something satisfying about taking software that was effectively dead and putting it back into a state where you can run it, study it, or build on it again.

Rust

C++

Java

TypeScript

Python

WebAssembly

Docker

Linux

Git

Reversing

What I Work On

Recurring threads in my projects

🕹️ Emulation & Preservation

Platforms from the late 90s and 2000s — feature-phone runtimes like WIPI, early Java ME stacks, niche embedded systems — are quietly slipping out of reach. The hardware ages, the runtimes lose vendor support, and a lot of software written for them ends up effectively unrunnable. Writing emulators is one of the few practical ways to keep this software alive: not just nostalgically, but in a form where you can still execute it, debug it, study it, and learn from how it was actually built.

🔬 Reverse Engineering

When source code isn't available and the documentation is incomplete or wrong, reading the binary is often the only way forward. I spend a fair amount of time in disassemblers, decompilers, and debuggers — sometimes to figure out an undocumented API surface for an emulator, sometimes just because I'm curious how a particular piece of shipped software actually behaves under the hood. The output is usually a parser, a working reimplementation, or a write-up explaining what I found.

🌐 The Browser as a Runtime

WebAssembly has quietly changed what you can ship to users without asking them to install anything. WIE runs entirely in the browser through Rust compiled to WASM — no native binary, no platform-specific build, just a URL. I keep finding new uses for the same approach: tools that used to need a download now live behind a link, and the friction for users to actually try something drops to nearly zero.

🛠️ Small Tools & Utilities

Not everything has to be a large project. A lot of what I build is small — a CLI that automates something I do once a week, a script that turns a manual workflow into a one-liner, a browser extension that fixes a specific annoyance. These rarely show up on the front page, but they're where most of the day-to-day learning actually happens.

Projects

Projects I've built and maintain

📱

WIE (WIPI Emulator)

An emulator for WIPI — the Wireless Internet Platform for Interoperability, the mobile application stack mandated on Korean feature phones in the mid-2000s. A whole generation of mobile games and apps were built on it before the platform was deprecated, and most of that software has been effectively unrunnable for years.

WIE reimplements the runtime in Rust and compiles to WebAssembly so it runs entirely in a web page — no installation, no native dependencies. The project covers the bytecode execution layer, the WIPI API surface, and the device-specific behaviors that real handsets used to provide.

WebAssembly Rust Emulator Reverse Engineering

Technical overview Try WIE

📖

Tech Blog

A personal tech blog where I write up the things I figure out: reverse engineering walkthroughs, emulator implementation notes, language and runtime internals, and the occasional debugging story. It doubles as my own reference — I end up re-reading old posts whenever I run into a similar problem again.

Posts tend to be longer-form and focused on the how and why rather than quick tips. If you're interested in the same kinds of low-level work I describe here, the blog is where most of it actually gets documented.

Reverse Engineering Emulation Systems

Visit Blog

Writing

Long-form notes on the projects above

Project Write-up

What I Value

Values I hold dear as a hacker

🔍

Curiosity

Always asking "how does this work?" and diving deep to find out.

📚

Sharing

Documenting what I learn so others can benefit from the journey.

⚡

Efficiency

Writing clean code that performs well and is easy to maintain.

🤝

Open Source

Contributing to and learning from the open source community.

Get In Touch

Have a question, want to collaborate, or just want to say hi? Feel free to reach out!