The loop. A scheduled workflow wakes tools/dream.py at 02:30 IST. The script pulls my recent public GitHub events, classifies commits and repo names into research threads, and measures cadence — how many pushes, which threads dominate, what hour of the night the commits landed. That becomes a small state vector, shown as chips along the bottom of the panel so you can see the evidence the dream was conditioned on. A model then performs one rollout from that state, and the result is typeset into the SVG above and committed.

Why nightly and committed, rather than generated per visitor. The obvious design is a serverless endpoint that runs inference on every page view. It doesn't work: GitHub proxies every README image through Camo and caches it hard, so the endpoint serves one request and Camo serves everyone else a stale copy. You'd pay per cache-miss, expose a public inference endpoint, and risk Camo timing out mid-render. A committed artefact loads instantly, costs about thirty calls a month, and keeps the key in GitHub Secrets.

The log is the point. Every rollout is a commit, so dreams/log.json accumulates an archaeological record — what the repo was thinking in March, which threads were hot, which nights ran long. That history is more interesting than an ephemeral greeting, and it's reviewable: anything the model says can be read, reverted, or argued with.

It degrades, it doesn't break. With no API key the script composes the rollout deterministically from the same state vector. The panel always renders; only the prose gets less surprising.

A world model compresses observations into a latent whose dynamics are learnable. The RSSM splits that latent in two: a deterministic path $h_t$ carrying memory, and a stochastic path $z_t$ carrying uncertainty.

Training maximises the ELBO shown in the panel above — reconstruct the observation, predict the reward, and pay a KL price for every bit of surprise smuggled into the latent. Once the dynamics are learned you never touch the environment again: you roll out inside the model and train on imagined trajectories, bootstrapped with a $\lambda$-return.

The part that's genuinely hard: $\beta$ on that KL term is the whole argument. Too low and the model memorises pixels instead of learning consequence. Too high and the posterior collapses onto the prior — the model stops dreaming, and every rollout returns the same beige future.

Why model-based at all: model-free RL pays for every gradient step in real environment interactions. A world model converts sample complexity into compute complexity — and compute is the thing I know how to make cheaper in hardware. That sentence is the whole reason this profile has both halves.

Message passing in its general form — aggregate from the neighbourhood, update, repeat, with $\bigoplus$ any permutation-invariant aggregator:

Swap that aggregator for attention and you get a GAT; normalise it spectrally and you get a GCN. They are the same idea wearing different clothes, which is also why transformers keep showing up in this literature.

Why I care: a gate-level netlist, a placement, a routing congestion map and a dataflow graph are all graphs. Every EDA problem that currently costs hours of heuristic search is a graph learning problem nobody has finished attacking.

An agent that calls tools is doing sequential decision-making where actions have cost, not just consequence. The honest objective includes the bill:

where $c(a)$ is latency, tokens, API spend, or blast radius. Drop that term and you get an agent that solves the task by brute-force calling everything it can reach. Add tree search with a learned value on top and you are doing planning, not prompting.

Where I've shipped this: the agentic RISC-V verification platform — twelve agents, most running with no EDA toolchain, where every tool call has a real cost. And Anvil, a quantization agent whose surrogate-guided planner matched a 60-evaluation greedy search in ~9 on-device evals. Both make you take $c(a)$ seriously.

Uniform affine quantization maps a float to an integer grid through a scale $s$ and zero-point $z$, then clips. Rounding has zero gradient almost everywhere, so training leans on the straight-through estimator — pretend the quantizer is the identity inside the clipping range:

At the binary extreme, weights collapse to a sign and one scale per filter:

which turns a multiply-accumulate into XNOR + popcount — and that is a sentence about hardware, not about machine learning.

The constraint that decides everything — arithmetic intensity against the roofline:

Most "slow" models are not compute-bound. They are memory-bound, and quantization is a bandwidth optimization that happens to look like a numerics one.

A state on $n$ qubits lives in $\mathbb{C}^{2^n}$, which is the entire promise and the entire problem. Variational algorithms hedge: a shallow parameterised circuit on the device, a classical optimiser outside it. The panel above is the whole method — the variational principle guarantees $E(\boldsymbol\theta)$ never undershoots the ground state, and the Hamiltonian decomposes into Pauli strings you can actually measure.

Gradients come from the parameter-shift rule — exact, not finite-difference, which is the detail that makes it trainable at all:

The honest caveat: barren plateaus. For a random deep ansatz on $n$ qubits, gradient variance decays as $\mathcal{O}(2^{-n})$ — the landscape flattens exponentially and the optimiser has nothing to descend. Structured ansätze and local cost functions are the live area, and I'm reading rather than claiming here.

Why it sits next to the silicon work: both are about extracting useful computation from a physical substrate that does not care about your abstractions. Coherence times and setup time are the same genre of constraint.

Setup closure — the clock period has to cover the whole combinational path:

Hold closure — the failure mode that survives simulation and kills silicon, because it is frequency-independent:

You cannot slow the clock to fix a hold violation. That asymmetry is why hold buffers exist and why CTS matters more than it looks.

Power splits into switching, $\alpha C_L V_{DD}^2 f$, and leakage, $V_{DD} I_\text{leak}$. The quadratic on $V_{DD}$ is the single most exploitable fact in low-power design — and the reason DVFS beats almost any microarchitectural trick you can name.

Amdahl, for accelerator scoping — the sentence that kills bad accelerator proposals early:

If your kernel is 60% of runtime, an infinitely fast accelerator buys you 2.5×. Profile before you build.

Concretely: at ADRIN (ISRO) I designed a custom HLS-based datapath to deploy MobileViTv2 — a vision transformer — on the AMD Versal ACAP VCK-190. Transformers on edge silicon are an exercise in memory hierarchy, not in FLOPs. The attention block is the bandwidth problem; everything else is arithmetic you can schedule.

Random stimulus hitting $n$ distinct coverage bins is the coupon-collector problem. The expected number of runs to hit all of them:

For $n = 1000$ bins that is roughly 7,500 runs — and the tail is worse than the mean suggests. This is the quantitative argument for directed tests on the hard corners: you do not random-walk into a 1-in-$10^6$ state, you go there deliberately.

The complementary argument, for formal: model checking does not sample the state space, it quantifies over it. Where a property is small and the state space is bounded, a proof beats $7{,}500$ simulations and finishes sooner.

My working rule: lint and CDC first because they're free. cocotb for iteration speed while the design is still moving. UVM once the interfaces stabilise and you need real reuse. SVA everywhere, because an assertion that fires next to the bug is worth a hundred waveforms. Formal on the control logic where the state space is small enough to be exhausted.

Python testbenches are not a toy. They give you the whole scientific stack next to your DUT: numpy for reference models, pytest for structure, CI that actually runs on every push. The tradeoff is simulation speed at the boundary — which matters less than people assume for anything below full-chip.

I maintain cocotb-v2-migration-helper for exactly this reason: the v1 → v2 API break is mechanical enough to automate and tedious enough that people put it off, and testbench debt compounds faster than design debt.

Lithography sets the floor. The panel above carries the Rayleigh criterion: EUV at $\lambda = 13.5\,\text{nm}$ with $\mathrm{NA} = 0.33$ reaches roughly 13 nm half-pitch in one exposure. Below that you multi-pattern — LELE, SADP, SAQP, each adding cost, mask count and overlay error — or move to High-NA and accept a smaller field. Note the square on NA in the depth-of-focus term: every gain in resolution costs focus budget quadratically. There is no free tightening.

Yield decides whether any of it matters. Murphy's model, for a die of area $A$ and defect density $D_0$:

Yield falls off superlinearly with die area. That one fact is why chiplets exist, why big dies are disproportionately expensive, and why "just make the accelerator bigger" is an economic proposal before it is an architectural one.

Devices, as they've actually moved: planar → FinFET → gate-all-around nanosheet, each transition a geometric answer to the gate losing control of a shrinking channel.

Why an RTL person should know this: wire delay does not scale like gate delay. Past a certain node interconnect dominates — so floorplan is a microarchitectural decision, not a backend one, and locality in your dataflow is worth more than gate count.

Colour tokens — one ramp from substrate to signal, with a violet axis reserved for anything quantum or probabilistic. substrate #030811 → die #071226 → well #0C1D3E → trace #1B3566, accented by signal #38BDF8 and signal-alt #22D3EE, text in ink #C8E0F8 and ink-dim #7FA6D4, probabilistic domains in quantum #A78BFA / #C084FC.

Type scale — three families, three jobs. Segoe UI for headings, JetBrains Mono for anything machine-adjacent, a math serif for equations. Section headers at 30px / 700 / +10 letter-spacing; annotations at 9–11px mono with lowered opacity, so they read as marginalia rather than content.

Motion, deliberately restrained — every animation is a 3–9 second loop with no easing spikes, so nothing competes for attention. Travelling pulses along circuit rails, a slow scan across banners, coverage bars that fill once and freeze, a Bloch vector that precesses. Motion signals aliveness, not urgency.

Layout — a fixed 1400px design width, 16–18px radii, 60px gutters, and a 10%-opacity dot grid on every panel so the page reads as one continuous surface rather than a stack of unrelated images.

Accessibility — every graphic carries alt text, nothing critical is colour-only, body contrast clears 7:1, and the page degrades to readable structured markdown if images fail.

Built from source, not by hand — every banner, divider and diagram is generated by parameterised Python in tools/, so the geometry is computed rather than eyeballed. Equations are typeset to SVG with MathJax and served light/dark through <picture>, because GitHub mangles double-dollar math inside collapsible blocks — it strips backslashes and eats underscore pairs as italics. The TeX source lives in tools/equations.json and in every image's alt. GitHub Actions regenerate the contribution graph nightly, and the dream with it.