I was a Research Scientist at Meta AI London, and I am currently in a gap in Malaysia. I work on video diffusion models, generative rendering, talking avatars, and world models — teaching machines to observe, imagine, and simulate visual reality. The longer-term hope is to make worlds as easy to build as they are to imagine — so anyone can freely express the ones in their head, not only engineers.
I received my Ph.D. in Computer Science from the University of Surrey, supervised by Prof. Tao Xiang and Prof. Yi-Zhe Song, and worked closely with Dr. Xiatian (Eddy) Zhu.
I completed my Bachelor's degree in Computer Science (Artificial Intelligence) at the University of Malaya, where I was a lab member of CISIP under Prof. Chan Chee Seng.
Contact: kamwoh [at] gmail.com
Kaleido and Rays as Pixels generate the world from one camera path — but a shared world has many players, and each one sees only part of it. A world model built on egocentric streams alone drifts: revisited places change, and the players disagree about each other. OverSeer renders each player's view together with a few fixed auxiliary cameras. The cameras never move, so they anchor the shared world — places stay where they were when a player returns, and what one player does is seen by the others. A δ-VAE codes each fixed camera as one reference frame plus a small residual for what moved (108 tokens per latent frame instead of 864), so an extra camera is cheap. Tested on Minecraft, Doom, and real multi-camera capture.
Kaleido learned to generate novel views given unseen camera poses — but can we also recover the camera trajectory from a video? The key challenge is that camera parameters live in a completely different space from pixels. Plücker embeddings are 6-channel — incompatible with pretrained 3-channel video VAEs, meaning you'd need to finetune just to fit the input format. Rays as Pixels solves this with raxels: each camera is "unfolded" into a 3-channel image where every pixel stores its ray origin + direction, so camera poses look just like RGB frames and go straight through the same VAE. Now both can be co-denoised together, and a single model handles pose estimation, trajectory-controlled generation, and joint video-camera synthesis.
Applied structured spatial generation to a new modality. VecGlypher fine-tunes multimodal LLMs to directly emit SVG path commands — no raster intermediate — via a two-stage curriculum (syntax mastery, then style refinement), producing editable vector glyphs from text or image exemplars. If LLMs can reason about 2D geometry as text, the leap to 3D meshes is just one more dimension — today's models may already be closer to generating 3D worlds than we think.
Moved beyond per-object NeRF distillation toward a visual world model. Kaleido is a sequence-to-sequence transformer that directly synthesises novel views — no explicit 3D representations, no per-scene optimisation — pre-trained on video, learning to imagine how the world looks from any viewpoint. Along the way, picked up large-scale Blender rendering and 3D modeling — the undergrad game dev itch never really went away.
Returned to the 3D world that fascinated me since my undergrad game engine days — this time through neural rendering. Restudied classical rendering, NeRF, and implicit neural representations, then built Chirpy3D: fine-tuning multi-view diffusion models with LoRA, learning a continuous part latent space, and distilling part-controlled views into NeRF — generating fine-grained 3D objects from unposed 2D images alone.
ConceptHash showed that parts can be encoded separately — but can we also generate by parts? PartCraft answers yes: entropy-based attention losses steer cross-attention so each part token controls its own spatial region, enabling compositional image generation from part-level descriptions.
ConceptHash made hash codes interpretable — each sub-code attends to a discoverable visual part, turning hash bits into semantic concepts. The first sign that compact representations could capture meaningful structure, not just similarity.
The orthogonal binary codes used in watermarking map directly to hashing — both need compact codes with maximum Hamming separation. DPN introduced central similarity with orthogonal class centres; OrthoHash distilled it to a single cosine objective; SDC solved similarity collapse via Wasserstein-calibrated distributions; and FIRe unified benchmarking across the field.
Extended ownership protection from model weights to model outputs. IPR-GAN embeds both white-box signatures in GAN weights and black-box watermarks in generated images, enabling dual verification without sacrificing visual quality.
First major publication — studied how to protect DNN intellectual property. DeepIPR embeds learnable "passport" layers into normalization parameters — the model only produces correct outputs with the right passport, defeating ambiguity attacks without degrading performance.
After training models to recognise and detect objects, wanted to understand what they actually learn. Studied CNN interpretability — visualising internal representations and asking how networks arrive at their decisions. Published first workshop paper at AAAI-19.
Moved from recognition to detection — trained YOLO and SSD models to detect and localise cars. First taste of spatial reasoning: not just what is in the image, but where.
Two parallel obsessions as an undergrad: training CNNs (car plate OCR with Caffe, back when deep learning meant writing prototxt files by hand) and building games (a Java-based game engine, an asteroid game with simple game AI, and hours studying how rendering and game engines work). No papers, no grand vision — just a curious student who wanted to make things that see and things you can play.
Claude as the world model for a robot arm. Type an instruction, and Claude plans the task in its head and shows the plan as a 3D video. Then a MuJoCo arm runs the plan, Claude compares the result with what it imagined, and it re-plans until the task is done. Works with 18 arms, from the Franka Panda to the UR5e, through the Claude Code CLI.
A programmable world model on Godot. Whole games are plain JSON, run by a small fixed interpreter with seven primitives (Entity, Tag, Rule, Trigger, Effect, Query, Relation). Describe a world in words, Claude compiles it to JSON, and it runs — no per-game engine code. It also works as a testbed for RL and world-model training.
Learn Japanese while you play retro games. A PS1 emulator runs in the browser with an AI companion beside it: press Explain and Claude reads the screen, giving each line with its reading, romaji, translations and a short grammar note, plus an optional translation overlay on the game. Every word you meet goes into a personal word list. Built with Claude Code.
What agents and skills really are, and why natural language is the next abstraction layer in programming — written for engineers trying to make sense of the AI era without wading through official docs.
A meta first post: how a static GitHub Pages site gets indexable blog posts without a backend.
# Claude Code Personal Site
Build a personal academic/portfolio website styled like the Claude Code terminal UI.
## Prompt
> Build me a single-page personal website with a Claude Code terminal aesthetic.
> Use plain HTML + CSS + JS (no frameworks). It should include:
>
> 1. **Loading animation**: A terminal-style loader with braille spinners
> (⣋⠙⠹...), typed command text, task checklist with
> checkmarks, then fade into the main site.
>
> 2. **Dark terminal theme**: Dark navy background (#111827), monospace fonts,
> amber accents (#d97706), indigo links (#818cf8), green highlights (#4ade80),
> cyan badges (#22d3ee). Sticky frosted-glass nav bar.
>
> 3. **Profile section**: Grid layout — avatar + links on left, terminal-block
> bio card on right (with header bar like a code editor tab).
>
> 4. **Research journey timeline**: Vertical line with gradient, colored nodes
> (green=new, cyan=highlight), connector labels between items showing how
> each phase led to the next.
>
> 5. **Compact publication list**: 4-column grid rows
> (venue | name+tag | blurb | links). Color-coded venues — cyan for top
> venues, amber for awards. Pulsing green "New" badges.
>
> 6. **Staggered reveal**: Content fades in with translateY after loader
> completes, with incremental transition-delays.
>
> Host on GitHub Pages with a `.nojekyll` file.
## Key CSS Variables
```css
--bg: #111827; --accent: #d97706;
--bg-surface: #1a1f2e; --link: #818cf8;
--bg-card: #1f2937; --green: #4ade80;
--border: #2d3748; --cyan: #22d3ee;
--text: #e0ddd5; --purple: #c084fc;
```
## File Structure
```
index.html ← entire site in one file
assets/css/style.css ← all styles
assets/js/main.js ← loader animation + smooth scroll
.nojekyll ← skip Jekyll on GitHub Pages
```