I care about systems and how we represent them — the layers, abstractions, and interfaces that shape what computers can do.

• Computer systems and architecture
• Memory, locality, and accelerators
• Representation and abstraction design
• System interfaces and boundaries
• Spatial computing
• Visual and interaction design, especially in earlier projects

▶ Play

A voxel world made from real-world terrain and places, to explore and build on, using Overture Maps and GEDTM30 elevation.

The eye decides how finely it is drawn: the view is divided into cells that each cover the same angular area around the eye, and blocks become coarser with distance to match. A pixel's ray, a walker's step and an edit all ask the same question — what fills this cube of space, at this level of detail — and one function, compiled for both the CPU and the GPU, answers it.

A Rust kernel holds the world and draws it with WebGPU, as WebAssembly in the browser and natively on iOS and Android; the React Native shell decides nothing about the world. It runs on xpute.

This is also where I'm leaning on AI-assisted implementation the most, while focusing my own design work on the system architecture, representations, and boundaries.

A runtime for running one program inside another. The host owns the platform and the guest computes; they share one memory, with one call into the guest and one number back saying when it wants to run again.

┌─ host ── TypeScript ───┐                        ┌─ guest ──────────────────┐
│ owns the clock, the    │                        │ computes, and owns       │
│ memory, the I/O        │ ═ interrupt(quota) ═▶  │ nothing                  │
│                        │                        │                          │
│                        │  ◀═══ wake_ms ═══════  │                          │
└───────────┬────────────┘                        └────────────┬─────────────┘
            │                                                  │
            └──────────────────────────┬───────────────────────┘
                                       ▼
           ┌─ the core memory ───────────────────────────────────┐
           │ everything else crosses here, and nothing else does │
           └─────────────────────────────────────────────────────┘

Each call is a turn with a time budget. Messages, file requests and GPU calls are written into the shared memory during the turn, and the host carries them out after it returns. The host is TypeScript; guests in Rust and C++ are checked against the same contract by the same conformance tests.

An undergraduate research project extending SCALE-Sim with PREMA (HPCA 2020), a preemption-aware multi-task scheduling algorithm for neural accelerators.

The implementation adds task scheduling, runtime prediction, checkpoint/resume, and mid-layer preemption to the simulator.

A from-scratch, user-level ELF64 loader, demand pager, and cooperative thread runtime for x86-64 Linux.

Written as a programming test for admission to a KAIST research lab, with no starter implementation. It builds process startup state manually, implements SIGSEGV-driven demand paging and cooperative user-level scheduling, and transfers control directly into loaded binaries.

▶ Gameplay video

A keyboard rhythm game inspired by DJMAX, originally written in Flash and later revived and ported from ActionScript 2 to ActionScript 3.

Along with the game itself, it includes a note editor and configuration tooling.

▶ Play

My first long-running software project, started in middle school.

A widget-based desktop launcher built with Flash/ActionScript 2 — widgets snap to a grid across multiple pages, each with its own settings, inside a shared launcher UI.

It began as a quicker way to search the web and gradually grew into a small personal software environment.