I build AI systems
and the 3D worlds
they run in.

A bengkel is a workshop — the room where the tools are kept and the work is done. This one is the front door to seven of them, and the rail down its side is a pipeline in the order the work happens: find it, make it, clean it up, dress it, check it, move it, ship it. It carries no engine of its own — the bundle holds a studio page, a tool list and one Swift file, and runs each tool from where that tool already lives on disk, so a change to any of them is live the next time it starts. pasar searches Sketchfab, Poly Haven and Texturelabs from one box, reimplementing none of them: the three command-line tools already on the machine are loaded as modules and their functions called, so there is one description of how to talk to Sketchfab rather than two that drift. The licence is on every card before the download, anything that cannot be sold is flagged, and every file arrives with a note of its source, author and licence beside it — six months later that note is the only thing that still knows. jaring asks the one question every other remesher gets wrong: not “how many faces do you want”, which nobody knows, but how wide one quad should be in centimetres, which is a thing you can picture. The face count follows from the model’s own surface area and is shown as the slider moves; one press then welds, remeshes, unwraps, bakes a normal map off the original and builds LODs through a headless Blender, and a downloaded paladin came back from 12,332 to 2,632 triangles — same size, same place, still recognisably a paladin. It refuses four failures that raise nothing. A glTF has no shared vertices, so a model that has been through one arrives as loose triangles that merely touch and is never closed — a sphere exported and re-imported comes back with 32,512 non-manifold edges — and without welding first, the quad remesher is never once given a surface it can work on. Blender’s Quadriflow then lies twice: it cancels rather than raising, and on a mesh it could not handle it reports success and hands back shards at a different size, which every other check passes. So the result is measured against what went in — a remesh of a thing is the same size as the thing — and anything else is done again another way. A bake is never wired to read the image it is writing; each LOD gets its own file, because three inside one are not alternatives but three copies standing inside one another; and when a result comes out heavier than it went in, it says so rather than reporting “−2% lighter”. periksa is the last look before a model goes into a game, and it reads the file rather than opening it — a .glb carries its own table of contents, so the size, the origin, the weight and the UVs are all answerable in milliseconds instead of the thirty seconds a Blender launch costs, which is the difference between a thing you run on every model and a thing you run when you already suspect something. It refuses to grade: a 400,000 triangle model is right for a cinematic and hopeless for a crowd, so it asks what the thing is for and the same model passes as a hero and fails as scenery, with every finding carrying what it found, why it matters and what to do. hantar is the last mile into one of the twelve game projects, and the only tool that writes outside the workshop — so it writes nowhere else, and the guard is in the server rather than the page. It invents no layout: for each game it finds where that project already keeps its models and how those files are already spelled, so the same typed name becomes walker_walk.glb in one project and walker-walk.glb in another, because a tool that imposes its own convention on twelve existing projects makes work rather than saving it. It stands the model on the floor, scales it to a real height, and exports for Godot or for Unreal, which counts in centimetres. The three were checked against each other rather than one at a time: periksa said a model’s origin was not on the ground, hantar moved it and sized it, and periksa then passed it. A tool’s server starts the first time you open that tool and stops when the window closes; not at launch, because one of them keeps a headless Blender running. The servers never speak to each other: a window.bengkel object is injected into every page and everything crosses through the native side, and because each tool checks whether that object exists and carries on exactly as before when it does not, all seven still run perfectly well alone. What the tools share — the token and origin guards, the model library, the way to call Blender, the look — lives in one place, so a fifth tool is a page and about a hundred lines.

Type “a tall blue knight with a sword” and watch Blender build it in the browser, part by part, as it is being made — then press one button for a skeleton and type “walk slowly” to make it move. A knight is not a blue person: each kind of character has a kit of named pieces — breastplate, pauldrons, gauntlets, belt, tassets, greaves, boots, helmet, crest — and they go on one at a time, in that order, each fitted to the body underneath and tied to the bone it moves with, so the pauldron turns with the shoulder without anything extra. Three more things keep it from looking like stacked boxes. Every part is a lofted stack of cross-sections rather than a primitive — a torso wide at the shoulders, narrowing at the waist and widening again at the hips; an arm as a shoulder ring, a bicep swell, an elbow and a wrist — because a box with its corners filed off is still a box. Those sections are measured: the eight-head canon for the vertical landmarks, anthropometry for the widths (biacromial breadth is 0.234 of height, so the skeletal shoulder is narrower than the finished figure and the deltoids make up the difference), breed standards for the dog, real dimensions for the chicken. And the app pulls photographs of whatever you asked for alongside the viewport so you can judge one against the other. Then a sculpt pass voxel-remeshes the soft parts into one continuous skin, so the seam where an arm meets a shoulder stops being a seam, while crates and machines stay crisp on purpose. Every part is then given a surface by what it is made of — metal on armour, wood on a crate, cloth on a robe — multiplied over its colour rather than replacing it, from a free texture library read through its own licence first. Name a palette — one of ten built-in moods, or any of the thousands on Lospec — and the whole model is snapped onto it in Oklab, by an ordered assignment that keeps every colour distinct and the shading the right way up. The one-press rig survives that: vertex weights are painted on before the remesh and transferred back after, so the skeleton is still placed from the recipe rather than guessed at a cloud of triangles. Nineteen moves, each written separately for people, four-legged animals, birds and objects; motion capture clips can be dropped in and retargeted. System Python driving one long-running headless Blender, three.js in the page, 779 checks against the real thing.

Drag an STL into the browser and get a printing price. The page parses the triangle mesh itself — no server, no upload — works out solid volume, shell and infill, converts that to grams and hours, then prices it against filament cost, machine rate and margin.

A WhatsApp-style web app that drives an AI coding agent running on my Mac at home. Each chat on the phone is a real terminal session over a private Tailscale network. Node with built-in modules only — no dependencies, no framework.

A Blender add-on that batch-exports a scene to Unreal with the naming, unit scale, pivots and collision meshes Unreal expects. Four export modes, FBX and glTF. Its tests run Blender headless and re-import the FBX to measure that the pivot, rotation and scale survived the round trip.

A learning platform for a tuition centre: students open materials and track progress, parents see attendance and fees, the centre sees enrolment and revenue. Built as a working demo to answer a client brief rather than claim past work.

A hands-free AI assistant for the drive to work. Open a page on the phone, tap once, and it listens, answers aloud and listens again. It knows my project notes, can save new facts to a vector store, and searches the web.

A first-person football game where you are the referee, on foot, for a full 11-a-side match the engine simulates for real. Look down and see your own boots; decide with a whistle and your pointing arm; show the card to the player you are looking at. Every tackle, offside position and ball over the line is recorded as it happens and judged against the IFAB Laws of the Game, and an assessor marks you out of ten with replays from your own eyes. Both captains meet you for the toss before a ball is kicked; players who disagree come and tell you so, and waving them away is marked as carefully as the decision itself. A career climbs from a village rec with club linesmen to a floodlit final with VAR, and the report ends with a map of the pitch showing where you were standing for every call you made, and what you could see from there. Every training drill is checked both ways — the right call must pass, doing nothing must fail.

A Fibbage-style bluffing party game for 3–10 players, dressed as a 1970s television quiz show. Each round shows a strange-but-true fact with the key word blanked out; everyone writes a convincing fake, the fakes are shuffled in with the truth, and you score for finding the real answer and for how many people your lie caught. Two ways to play: pass one device around the room, or put the board on a TV and let phones join with a four-letter code. A Phaser effects layer sits over the HTML — TRUTH and LIE stamps, score rings, a drum roll and a sax sting on the reveal — while the writing and picking stay ordinary DOM, because a text box is the one thing a game engine does worse than a browser.

A Japanese class that runs in a browser tab and refuses to move on until you have said the phrase out loud. The teacher speaks first through a Japanese voice already installed in macOS, then the microphone opens, Chrome turns what you said into Japanese text, and the app marks it against what it asked for. Every lesson drills its phrases and then makes you use them in a scene where the teacher plays the other person. Built because Luqman wanted to learn by speaking rather than by tapping — and built to cost nothing: no API key, no account, no server, 47 passing checks on the marking alone.

A Roblox game where you learn Luau by writing it. There is no joystick — your code is the controller, and typing move() walks the robot one tile. Eight rooms are ordered so each introduces exactly one new idea, other players solve the same room beside you with their robots visible, and every solve is checked on the server rather than taken on trust. It exists because 4.38 million visits to a single-player lesson reader prove the demand and prove that nobody stays. 339 headless checks; the interpreter, the rooms, the robot, the tap-to-build palette and saved progress are all in.

Gudang — “warehouse” — is the receiving bay every 3D asset passes through on its way into a game. Drop in a Sketchfab download, a Meshy generation or a raw .blend, and headless Blender inspects it: triangle count, real-world scale, topology, UVs, textures and rig, reported as JSON and then judged in plain language per target engine. It read 75 real files in 73 seconds, and immediately earned itself — it found that 16 of 32 Sketchfab downloads were at the wrong scale while 0 of 33 Meshy files were. Two of its own first verdicts were wrong and were corrected, which is recorded rather than hidden.

A scaled-down copy of a managed security provider’s two portals — a client portal showing a firm’s devices and security posture, and an internal operations portal — built in Retool on PostgreSQL with JavaScript transformers and REST APIs. It exists for one reason: to apply for a Junior Application Developer role by building the exact thing the job description asks for, with fictional data, rather than describing it on a CV.

A Blender add-on that takes a sculpt to a game-ready asset in one press. Blender’s own Quadriflow Remesh gives you quads and then stops — no UVs, no baked normal map, no LODs, one object at a time, and it asks for a face count nobody can guess. Retopo Kit keeps that remesher as its engine and supplies everything around it: a quad size asked for in centimetres instead of faces, an automatic unwrap sized for the texture you are about to bake into, a normal bake whose ray distance is worked out from the model itself, LODs named the way Unreal expects, and a batch mode for a whole folder.

An original isometric action RPG in the Diablo and Path of Exile mould, and the longest-form thing here — six roles, an act structure and a loot loop, rather than a single clever rule. You arrive on the Ashen Road with your name taken from you, walk into Emberhollow because its hearth is the only light left in the valley, recover three ward embers from shrine guardians in the Gloamwood, and put down the Bellkeeper beneath the Sundered Chapel. Thirteen skill slots are bound from the first keypress and all thirteen do something: six earned abilities per role on top of the basic attack and the class ability, thirty–six in all. Around them sit a twenty–four slot backpack with rarities and random affixes, twelve equipment slots, a smith who buys, sells and tempers, a mastery choice at every level, and waystone travel that opens as you clear each ward. Every asset in it is original, and the repository contains the pipeline that made each one — the world geometry is generated in code, the shaders and texture atlases were painted for this game, all 33 sounds were synthesised from mathematics by a build script rather than downloaded, and the twelve characters are concept sheets generated to a written art direction, reconstructed into rigged meshes and installed by a tool in tools/ that prices every step and refuses to spend twice. The six heroes and the three enemies are shaded by a character shader that rebuilds a full material out of one baked texture, because the meshes arrive with no metallic, roughness or normal map at all. It is also the first project built by two AI agents working the same repository at once, one taking equipment and economy while the other took audio and the ability system, which turned out to be as much the point as the game. 407 checks across twelve headless suites.

A top–down shooter under a fixed Diablo camera, and an exercise in making an animation set that does not exist. Movement and aim are separate — the keys drive him around the world, the mouse decides which way he faces — so he spends most of his time walking in a direction he is not looking in, and a single forward cycle is nowhere near enough. The character came off Sketchfab with seven animations on it and none of them covered jumping, strafing, backpedalling or firing, so those were built out of the poses of the clips that did exist: the backpedal plays the legs in reverse against a forward–playing torso, the strafe yaws the hips sixty–eight degrees and counter–yaws the spine back over three joints, and the jump comes from pushing a stand–to–squat blend past both of its ends, so the legs go straighter than standing and the knees fold deeper than the squat without either pose being drawn by hand. Three faults in that set — a crouch that was really a forward hunch, a second attempt that folded him double, a recoil too small to see — raised no error at all and were found only by rendering contact sheets and looking at them. The firing animation plays on the spine and arms alone, filtered from the skeleton’s own track names at load, so he keeps running while he shoots.

A photography game, set in one kampung yard on a bright morning. A client sends a brief — three pictures, each with one specific thing they want — and the camera you are handed is a real one: aperture, shutter speed and ISO run through the standard photographic formulas, Godot’s physical camera turns them into the rendered picture, and the same formulas mark the result. Open the aperture and the background falls away, but the frame fills with light; speed the shutter up to stop the hen mid–step and the light drains out again; buy it back with ISO and the picture goes grainy. That trade is the game. The photograph itself is built by rendering the exposure up to eight times and averaging the frames, so a slow shutter genuinely smears what was moving, and every mark on the report carries the number it came from — “the cat at 2.8 m; sharp from 2.7 m to 2.9 m” — and says which dial to turn next time. Around it sit a main menu, a photo album that keeps every accepted picture, an illustrated guide to the camera and a fighting–game–style control list that lights up the key you just pressed. 192 checks hold it in place, including one that renders the yard and insists a real camera’s settings expose it correctly.

Battleships, fought from the bridge of a battleship. There is no chart on a screen: you stand in the Littorio’s wheelhouse with your own fleet in company, lay that fleet out on a lit plotting table, call a target on the same table, and take the shot through a director sight that gives you a bearing to lay the guns on. The guns come round onto it: the hull is a bought model with her turrets welded solid, so both forward turrets are cut out of its merged meshes at load time and hung on nodes that can train, at the six degrees a second the real ones managed. If the round finds something the camera goes to it — the vessel you hit, taking that shell at the point along her hull where you actually hit her — and afterwards she stays on your horizon, burning. When they fire back, you are standing on the ship they are shooting at. The wheelhouse you stand in — deck, bulkheads, deckhead, window band, wheel, telegraphs and all — is built in code, because a hull model meant to be seen from half a mile away does not survive being stood in.

One-thumb mamak stacking game. Food swings from a hook; one tap drops it. Land it and the tower grows, the camera rises, the swing speeds up. Miss and the order collapses — real physics, so it never falls the same way twice.

A drawing party game played on one passed-around phone, tablet or laptop. Write a phrase, the next player draws it, the next guesses the drawing — then the whole chain is revealed to the room. Plain HTML with no server, so drawing and typing stay instant, and a Phaser layer over the top for confetti, bursts and real sound that sleeps while you draw. A headless-Chrome test plays a full game with real touch input at phone, tablet and desktop sizes, and checks the effects never block a tap.

Wave-based FPS zombie game, built as my final year project at UTeM. Unreal Engine 5 with Blender assets — level design, enemies and gameplay programming.

A 1v1 street-food stall competition set in a Malaysian hawker centre. All 3D assets and game design, built in Blender and Unreal Engine.

A village elder against local supernatural entities — Malaysian folklore as a game setting. 3D assets and game design in Blender and Unreal Engine.

A VR game in Unreal Engine 5.1, built by a friend for a programme teaching students the fundamentals of VR development. I helped with the 3D. It is localised throughout: local fruit, the Petaling Street arch and a paddy field level.

Stylised chibi character model, sculpted and shaded in Blender.

Facial rig study in Blender — building controls for expression and lip movement on a character head.

Environment and prop modelling for a ghost-hunting scene, built in Blender.

3D reconstruction of the VR lab at FTMK, UTeM — the room, its equipment and layout modelled in Blender.

Interior architectural visualisation of a classroom hub, modelled and rendered in SketchUp.

Architectural visualisation of a college interior — space planning and materials in SketchUp.