Dr. Safeer
Ali Mirani

Nazar

2026 · WebGPU · Industrial anomaly detection

Nazar reimplements PatchCore (Roth et al., CVPR 2022) and reproduces the published benchmark across all 15 MVTec AD categories: 98.80 mean image AUROC against the paper's 98.93 at the same 10 percent bank, and 98.87 on the bank it actually ships, which is five times smaller again. It never sees a defect in training. A factory has thousands of good parts and almost no faulty ones, so the only honest thing to learn is what good looks like. A hand-written WGSL compute shader runs the exact nearest-neighbour search on your GPU, and the page checks its own result against the offline PyTorch score while you watch. Built for the decision rather than the leaderboard: a measured few-shot curve, a cost explorer that trades missed defects against a stopped line, and a failure panel that counts what no threshold catches.

Now a Larkode product.

Yaad

2026 · WebGPU · On-device inspection

Nazar's sibling, and the question a factory asks next: can the person standing at the machine set the inspector up himself, from good parts only, with nobody from the ML team in the room. Hold a good part in front of the camera and turn it in your hand; the browser turns each frame into 784 patches of what normal looks like and keeps them as its memory. Show it a damaged one and the patches unlike that memory light up. No training run, and nothing uploaded. A MobileNetV3-Large backbone, hand-written as WGSL compute shaders, runs the backbone forward pass on an iPhone 15 Pro Max in 8 to 11 ms per frame (about 110 fps). Going phone-sized costs 0.69 points of mean AUROC against Nazar's WideResNet50-2 and shrinks the bank ten times; four categories lose nothing at all, capsule loses 4.07, and the whole table is on the page.

Now a Larkode product.

Governor

2026 · WebGPU · Control systems

Drive a PI controller on a simulated model of a two-tank water rig, live in the browser, and watch feedback command what the identification data cannot predict. The rig is identified from measured lab data; 256 GPU-simulated copies of the model run in a hand-written WGSL compute shader, one thread each. Open loop they disagree by about 0.16 V; close the loop and integral feedback lands them all on the target, collapsing the disagreement to about 0.006 V, roughly twenty-five times tighter. Honest by construction: the identified model only ties a linear baseline (0.593 vs 0.588 V test error), so it is a believable twin not an accurate one, and the uncertainty band is labelled a bootstrap family spread. The first control-systems piece in the set.

Now a Larkode product.

Inkwell

2026 · WebGPU · In-browser ML

Draw a digit and a real neural network classifies it as you draw, shown as the small network from 3Blue1Brown's series: a 784-16-16-10 perceptron with every neuron and weighted connection on screen. Three WGSL compute dispatches produce the activations and they are read back to light the neurons you see. A plain JavaScript copy of the same network checks the GPU on every stroke, and where the two disagree the page says so on screen and shows the JavaScript answer instead of quietly showing a wrong one. Trained from scratch on real MNIST, 95.8% test accuracy out of about 13,000 parameters, with the optimiser written by hand in numpy and no machine-learning or graphics library anywhere in it. Flat, or orbitable in 3D with the weights readable on hover. Educational rather than state of the art: deliberately the small, legible network where every weight is visible.

Now a Larkode Lab demo.

NeuroConstellation Desktop

2023 — 2026

A Unity and HLSL renderer for the activity of full-scale hippocampal CA1 circuits, up to 5.28 million human neurons, at frame rates you can still interact with. Six visualisation modes run alongside analyses that would normally happen afterwards: firing-rate maps, recruitment maps and spike-history trails are computed on the GPU while the simulation plays, rather than exported and processed later. Each of them is validated against a Python NumPy and SciPy reference pipeline, because a shader that is fast and quietly wrong is worse than no shader at all. It came first; the browser build is a port of it and the two headset builds stream from it. The activity it renders comes from NEST simulations run on CINECA's Galileo100 cluster.

HoloNeV, HoloLens 2

2024 — 2026

A HoloLens 2 has roughly the compute of a phone, so a scene that runs on a workstation cannot simply be handed to it. HoloNeV splits the work: the workstation renders and the headset displays, over holographic remoting, which is what lets a dense mouse CA1 circuit stay dense in mixed reality. Interaction is by hand rather than controller, through Microsoft's MRTK, with a proxy container paradigm built for the case that breaks the standard gestures. You cannot grab a million points, so you grab a stand-in that owns them and move that instead. The result is a circuit you walk around in your own room. Manuscript in preparation.

Immersive VR, Varjo XR-4

2025 — 2026

Where HoloNeV puts the circuit in your room, this puts you inside it. Human hippocampal CA1 activity rendered stereoscopically in a Varjo XR-4, with Ultraleap tracking bare hands, so a structure that is normally a figure in a paper becomes something you can walk around and reach into. Which dataset loads is configurable rather than compiled in, and the gestures are gated on the tracker's own confidence: a half-seen hand does nothing instead of throwing the scene across the room, which sounds like a detail until it happens in front of a visitor. Six degrees of freedom throughout. The single-draw-call rendering underneath it is written up separately.

NeuroConstellation Web

2026

The same six visualisation modes as the desktop build, translated shader by shader from HLSL to WGSL and moved into the browser. No install, no plugin, and no server doing the work: millions of neurons are stepped and drawn on whatever GPU the visitor already has, in any browser with WebGPU. The point is reach rather than novelty. A collaborator on another continent, a reviewer, or a committee member can open a link and see exactly what the lab sees, which is a different proposition from asking them to install Unity and obtain the datasets first. Manuscript in preparation. Deployed privately, with access on request.

Seismic Earth

2026 · WebGPU · Real-time 3D

A globe built directly against the raw WebGPU API, with every magnitude 5.0 and above of the last five years on it, fetched live from the USGS. About 9,000 real events, coloured by depth and scaled by magnitude, drawn as spikes in a single instanced call so the whole planet costs one draw. There is no three.js underneath, no map SDK and no build step: the WGSL shaders, the matrix maths and the arcball camera are all written out, which was the point of building it rather than assembling it. Time-lapse playback runs the five years forward, place search puts you over a city, and the whole thing is keyboard navigable and screen-reader labelled rather than mouse-only.

Now a Larkode Lab demo.

Emotion Atlas

2026 · WebGPU · In-browser ML

all-MiniLM-L6-v2, a real sentence-transformer, runs in the browser tab on WebGPU and embeds the full 16,000-tweet emotion split into 384 dimensions. The model runs through transformers.js; the PCA, the k-nearest-neighbour search and the renderer are hand-written. The cloud is projected to 3D by power iteration with Gram-Schmidt deflation and drawn as an instanced WGSL point system you can fly through. Type a sentence of your own and it is embedded live on the same GPU, placed by the same basis, and joined to its true cosine nearest neighbours with a k-nearest-neighbour emotion prediction. The projection is honest about itself: what you see in 3D is a lossy view of 384 dimensions, and the neighbours are computed in the full space rather than in the picture. No three.js, no backend, no build step.

Now a Larkode Lab demo.

CortexCast

2026 · WebGPU · EEG / BCI

Real 64-channel motor-imagery EEG from PhysioNet, replayed in the browser while a decoder watches the motor cortex and calls which hand the subject was imagining. A hand-written FFT drives mu (8-12 Hz) and beta (13-30 Hz) band power, a WGSL scalp topographic map renders onto a real 3D head mesh, and event-related desynchronisation over the C3 and C4 motor cortex calls which hand, scoring itself against the true cue as it goes. It is right about 60 to 66 percent of the time against a 50 percent baseline. That is a physiological contrast measured on the replayed recording, not a trained or cross-validated classifier, and the page leads with that rather than with the number. The same EEG and BCI analysis I run in MATLAB and MNE, rebuilt to run for anyone with a browser.

Now a Larkode Lab demo.

Windfield

2026 · WebGPU · GPU compute

About a million particles, and up to 4.2 million if you push it, ride one real hour of NOAA GFS 10 m wind across a world map, entirely in the browser on WebGPU. A hand-written WGSL compute shader samples the wind field under every particle and advects it across a world map, leaving glowing motion trails coloured by speed. Because the field is a single steady forecast snapshot rather than an animation, every trail is a true streamline of that hour and not a decorative swirl. The particle count is yours to push until your GPU complains. The forecast timestamp stays on screen, so you always know which hour you are looking at.

Now a Larkode Lab demo.

Orrery

2026 · WebGPU · HPC + astronomy

A raw WebGPU flythrough of the real Milky Way. Every point is an actual star measured by ESA's Gaia mission: a random sample of 1,013,200 stars with full 6D position and velocity. Their orbits were integrated on the CINECA Galileo100 supercomputer, a 34-task SLURM array using gala and astropy, compressed to about 112 bytes per star, and reconstructed live on the GPU, so you can scrub the Sun's neighbourhood across 500 million years in either direction and click any star to draw its own orbit. A compute pass evaluates every orbit, an HDR pass draws additive star sprites, and GPU picking finds the star under the cursor. Hand-written WGSL and no rendering libraries. Ensemble motion is trustworthy and any single star half a billion years out is an estimate, so the reconstruction error is on screen: a median of 17 parsecs at 500 million years, with 4.85 percent of orbits flagged as poor fits.

Now a Larkode Lab demo.

Sabzaar

2026 · Geospatial · Neighbourhood-scale pilot

Larkana loses shade every summer as old trees come down. Sabzaar maps the city's tree canopy and its summer heat from public satellite data, and shows which parts are hottest and shortest of shade. It is a pilot that works at neighbourhood scale: the canopy layer comes from Meta and WRI's canopy height model, checked against ESA WorldCover, and ground temperature comes from Landsat thermal. At that scale it cannot tell a tree from a house, so it does not mark individual trees or exact planting spots. Every highlighted area is a candidate to walk before planting, not a decision, and the planting guidance is kept apart from the measurements because it is judgement rather than data.

Now a Larkode product.

Shajro

2025-2026 · Full-stack · Next.js + Supabase

A private, invite-only family tree built for one family, and specifically for non-technical relatives adding people from their phones, in Sindhi and Urdu. Every addition or edit is a change request that a family moderator reviews before it enters the tree, with a full audit log. Names transliterate to Sindhi automatically, kinship is computed from the actual family graph rather than guessed, and the family owns its data through one-click GEDCOM 7 export. Row-Level Security enforces privacy and roles in the database itself rather than in the application. The real tree is never public, so the demo runs the same code over a fictional family, with no database access and no account needed.

Now a Larkode product.

Sindhi Braille

2026 · Language technology · Accessibility

Standard Sindhi Braille was ratified by a Sindhi Language Authority committee in 2016 and is taught in schools across Sindh, but until this project it existed only on paper: no software could produce a line of it. This is the first digital implementation of the code, built in partnership with Riaz Hussain Memon. A translator works in both directions and in both grades, a six-key braille writer lets you type it directly, and liblouis tables let screen readers and embossers use it. It reproduces all 78 worked examples in the standard guide and 99.93% of 23,674 words from the committee's publications, and the liblouis tables pass 109 of 109 tests.

Now a Larkode product.

CA1 Connectome Explorer

2026 · WebGPU

A connectome at single-cell resolution is a graph with millions of nodes, and the usual way to look at one is to render pictures of it on a server and send those down. This does the opposite: the whole graph goes to the visitor and their own GPU walks it. Two species load as separate instances, mouse at about 288,000 neurons and human at 5.28 million. You can filter by cell type, follow guided tours through the wiring, isolate the structural rich-club, and play recorded spiking activity back over the structure that produced it. Nothing is computed on a server, which is also what makes it cheap enough to leave running.

CA1 Connectome Analysis

2026 · Network neuroscience

The analysis the explorer exists to make legible. Full-scale single-cell CA1 connectomes for human and mouse, measured on the same footing rather than compared across papers that used different methods, which makes it one of the first matched cross-species comparisons at this resolution. The headline result is a rich-club of GABAergic neurogliaform cells conserved between the two species: a small, densely interconnected core of interneurons doing structural work out of all proportion to its size. How far function can be predicted from structure is reported through a variance decomposition that accounts for collinearity between the graph measures, because those measures are far from independent and naive attribution overstates every one of them.

CA1 Morphology Viewers

2026 · WebGPU

Every neuron in the scaffold models is a point with a position and a type, which is enough to simulate and nowhere near enough to recognise. These viewers give each cell type its shape back: a representative published reconstruction from NeuroMorpho.org, shown on its own so the morphology can actually be read, and then placed at the real soma coordinates of every cell of that type and rendered as a whole population. The result is a forest of dendrites at brain scale instead of a cloud of dots, and it makes visible how differently each layer is occupied. One reconstruction stands in for every cell of its type, so the population is right and no individual cell is. Rendered on the GPU in the browser, with no server involved.

EEG Data Analysis

Ongoing

EEG arrives buried in the subject's own blinks, jaw movement and mains hum, so most of the work is the part before any analysis begins. These pipelines handle it in MATLAB end to end: artefact rejection, source reconstruction to move from sensors on the scalp to estimated activity inside the brain, and spectral decomposition into the frequency bands the literature is written in. On top of that sits machine-learning classification of brain state, trained on the reconstructed features rather than the raw traces. Built alongside the simulation work rather than instead of it, so that modelled activity and recorded activity can eventually be held to the same measures.

Brain Co-Simulation

Ongoing · EBRAINS-Italy

The brain is modelled at incompatible scales: detailed multi-compartment cells on one side, point-neuron networks on another, mean-field populations above both, each with its own simulator and its own idea of time. Co-simulation is the work of making two of them run together and exchange state without either being reduced to the other's assumptions. This is that plumbing, in collaboration with EBRAINS-Italy, and it is the least glamorous and most reusable part of the doctorate: a scaffold model is only worth simulating if the thing simulating it can talk to the thing modelling the region next door.

Emotion Detection from Text

2017 — 2019 · Master's Thesis

The master's thesis, at UESTC's NLP lab, and the first appearance of a habit that runs through everything since: build the same thing three ways and let the comparison be the result. Fine-grained emotion classification, past the usual positive and negative into distinctions like fear against anger and joy against anticipation, where the label set is unbalanced and the confusions are the interesting part. Recurrent, convolutional and transformer models were each implemented and measured on the same data and the same split. Work from 2019, kept here because never trusting a single architecture's number is the same discipline the recent projects run on.

Sindh University Larkana Web Portal

2016 · Bachelor's Project

The final-year project, and the first thing built here that other people had to use whether they liked it or not. The department adopted it as the actual Sindh University Larkana campus portal rather than marking it and filing it away, which meant it inherited real users: staff posting notices, students hunting for results, and everyone between them finding the edge cases that never show up in a demo. PHP, SQL and hand-written CSS, in 2016. It took first prize in the departmental software exhibition, but the more useful lesson was that shipping to people who did not choose your software is a different discipline from building it.