← The Charlot Lab · Thermodynamic Physical AI · Research

Take a grid. Every cell holds one label out of a small set: stone, ore, air, water. Write down an energy that only ever looks at pairs of touching cells, giving a low number to pairs that belong together and a high number to pairs that do not. That single function defines a probability for every possible arrangement of the whole grid, with low-energy arrangements more likely, and a temperature controlling how strongly that preference is felt.

To draw an arrangement from that probability, visit one cell, look only at its neighbours, and pick a new label with probability proportional to how well it fits them. Repeat. That is Gibbs sampling, and it is the whole method. At high temperature the grid stays disordered; lower the temperature and regions of agreement grow. Add a term that makes heavy labels prefer to be low, and the grid will stratify on its own, with no one having drawn a layer.

Two more ideas complete the picture. Clamping a cell means fixing its label and letting everything else arrange itself around that constraint. That one mechanism does three jobs here: it is how a mined tunnel stays open, how a codec's known pixels constrain the unknown ones, and how a designer states an intention. And a seed plus the rules is enough to reproduce an entire world, which is why a session in the game below travels as a few dozen bytes.

Stuart Geman and Donald Geman introduced Gibbs sampling in 1984 for image restoration, describing it as a highly parallel relaxation algorithm. Texture came a year earlier: Cross and Jain fitted Markov random fields to real textures in 1983, and found that microtextures fitted well while regular and inhomogeneous ones did not. The approach reached its high point with FRAME in 1998, which matched filter statistics and used a Gibbs sampler to draw the images.

In 1999 Efros and Leung gave two reasons for moving on, and the difference between them matters more than anything else on this page. The first is about cost:

"Gibbs sampling is notoriously slow and in fact it is not possible to assess when it has converged."

The second is about whether sampling helps at all. They ran a Gibbs sampler on top of their own much simpler greedy result to see if it improved:

"our trials have shown that Gibbs sampling produced very little improvement for most textures. This lack of improvement indicates that the heuristic indeed provides a good approximation to the desired conditional pdf."

Everything after that keeps the energy and discards the sampler. Wei and Levoy searched deterministically and ran two orders of magnitude faster. Image quilting found a minimum-cost seam by dynamic programming. Graphcut Textures took the same energy on the same sparse graph and solved for the most likely arrangement instead of drawing one, which min-cut does exactly. Lefebvre and Hoppe reached real time on the GPU with no temperature anywhere in the method. PatchMatch, which became Content-Aware Fill, searches rather than samples.

Speed is the reason that has changed. The other one has not, and it is a statement about the quality of the answer rather than the time taken: running a slow method faster arrives at the same conclusion sooner. Any claim this topic makes has to face the second quotation, not the first.

The first version cleared each stage's marks when the stage ended. That sounds right (an earlier mark is something that was true once, not a promise about the finished world) and the resulting pictures looked like history. They were not. Once a mark stops being held, the cell is free to relax back to whatever the physics prefers, and it does.

The measurement is a coupling experiment and it is easy to state. Build a world twice from the same seed and the same random numbers, changing one thing: whether stage one lays its marks at all. Any disagreement between the two finished worlds is stage one and nothing else. It was 0.000%, in the flat receiver and the solid one, at every settling budget from 100 sweeps to 1400. Every stage but the last was doing nothing at all.

That number needed a control before it meant anything, and the first control failed: with stage one marking an ore bed low down, the two worlds differed by 0.75% immediately after stage one, because gravity puts ore low down anyway. The experiment had been run inside a region where the variable does not matter. Marking sand high up instead (sand has the strongest downward pull of the six materials, so the world argues with it) moved the control to 10–21%, and the erasure held at 0.000% regardless.

The fix is one line and no new bytes: a mark keeps holding after its own stage ends, and a later mark at the same place simply overrides it, which is what drawing over something means. Stage one now survives at full strength (10.5% against a 10.6% control, 20.5% against 21.6%) in both receivers, at every budget. An intermediate fix, letting a stage settle without first melting what it was handed, worked in the solid receiver and not in the flat one; a rule that depends on the receiver's lattice is not a rule the message can rely on, so it was not the fix.

The conformance suite records the correction precisely. Eight of its eleven worlds have one stage, and their fingerprints did not move by a single bit; only the two multi-stage worlds changed. A fix that moves exactly the vectors it should move, and no others, is a fix worth believing.

Everything so far had one receiver, and one receiver can only ever agree with itself. So the same bytes now also build a 64³ solid: same seed, same eighteen numbers, same grain, same stages, same marks. What travels is a description of a world, and a description should be realizable in whatever the receiver happens to have.

It did not survive contact. A mark says where on the plan; it said nothing about how far down, because a flat sender never needed to. Given a third axis there is more than one lawful reading, and two of them build visibly different worlds from identical bytes, a river that stands up as a wall of water through the full depth, and a river that cuts a trench in the surface. Both honour every byte. Both hold 100% of what was asked. That is not a receiver making a mistake; it is a message that does not determine its world.

So the language gained a word: one byte an object, an anchor and a band, measured in eighths of the world so it means the same thing at any resolution, the choice already made for position and radius. The flat receiver has no depth axis and ignores the byte, and that is the test the addition has to pass: the same world written in the old format and the new one lands on the identical fingerprint. A format may add a word. It may not quietly change what the words already there meant.

The two defects had been hiding each other. With every stage but the last erased, the depth of an earlier mark could not matter, so the two readings of the message agreed and the gap looked closed. Fixing the history made the ambiguity visible; fixing the ambiguity made the history worth having.

Grain says what temperature to settle to. Nothing said how long to settle for, and every receiver here had fourteen hundred sweeps written into it as a constant that never travelled. Whether that constant matters is a measurable question: realize one message at several budgets and see what moves.

Cell by cell a great deal moves, and that turns out to be the wrong number to read. Disagreement is higher inside the window where this model equilibrates than outside it, which is the right way round and worth sitting with: a chain that has equilibrated keeps drawing fresh independent samples, while a frozen one stays near wherever it got to. So cell-by-cell difference cannot tell another draw of the same world from a different world. What the world is made of can — and to read that safely you need to know how much it moves when nothing changes but the seed, which over five seeds is between a sixth and a half of a point. Every figure below is several times that.

One row fails, and it is the flat receiver's own default: 512² at grain 1.62. Its composition is still moving with the sweep count, so that receiver was handing over worlds whose material make-up depended on a number the message never carried. Everywhere else the message fixes the distribution even where it does not fix the individual world, a real promise, and a weaker one than had been claimed.

So the budget became a word: one byte a stage, counted against the width of the field rather than in raw sweeps. Information travels about a cell per sweep, so a fixed count means different amounts of settling at different sizes, and the same message realized larger would have been a differently-settled world instead of the same world in more detail. The solid receiver reads the same byte and spends a hundred and seventy-six sweeps on its 64³ block rather than fourteen hundred, which is both eight times cheaper and closer to where its own measured mixing curve says the model settles.

The conformance suite carries two messages that differ in exactly two bytes (the budget of each stage, twenty-two against forty-four) and they are required to land on different fingerprints. A word that changes nothing is not a word, and a word nobody transmits is a receiver's private opinion. All eleven earlier vectors came back bit-identical. Both marks still hold at 100% at every budget, which is what carrying the clamps bought: the promise is the part that does not move.

The strokes are fractions of the field rather than pixels in it, so the intent says where the ore is relative to the world and not which cells it occupies. Realizing it at four times the width costs nothing on the wire and gives sixteen times the world, with the constraints landing in the same places and holding just as exactly. The comparison this invites is not with an image file but with a typeface, which also describes shapes rather than storing them and is rendered at whatever size is asked for.

That was an argument from how the format is written, so it was worth measuring rather than asserting. Two fields at different sizes cannot be compared cell by cell, which leaves the composition as the only statistic that can test it, a good sign it is the right one. Across a four-fold range it holds: realized flat at 256 and at 1024 against 512, what the world is made of moves by about a third of a percentage point, and in the solid receiver at 96 and 128 against 64, by about one. It stops holding below that. A 32-cube comes out a genuinely different world, three and a third points adrift, and that is a limit of the size rather than of the settling: it stays at 3.3 points across a sixteen-fold range of budgets. There is a floor under "any size you like", and it sits between 32 and 64.

So a single amplification figure is the wrong summary. The intent is bounded and the world is not, and any particular number in that column is just the size someone happened to ask for.

The message is a version byte, four bytes of seed, eighteen numbers that are the world's physics, and then the things that must be true of it. The eighteen are the interesting part: six say how common each material is, six how each answers gravity, six which pairs like to touch. Between them they decide whether a world has strata, veins, oceans or none of these, and the first six are where a sentence like "ore is rare" gets said. Before they were on the wire a link described a placement inside somebody else's world; now it describes the world. One more byte says how coarse it should be, which is the temperature the settling stops at, and the instrument reports whether that setting is inside the window where this model actually settles or past it, using the measurements further down this page. Past about 1.1 what you get is whatever the annealing froze rather than a settled world, and it says so instead of quietly handing you one.

The constraints come in two shapes, because a river is not a row of unrelated dots. A dot costs five bytes and says a thing is here. A path costs two bytes and three for each bend, and says a thing runs from here to there: one object that can be moved and edited as one, and cheaper than the dots it replaces once there are more than a few of them. Clicking leaves a dot and dragging leaves a path, which is the only interface decision in the whole instrument.

Two things had to be fixed before the claim was true. The first is old news to anyone who has built a codec and was news here: the sender was building its world from the positions it had, while the receiver built one from the positions that fit on the wire. A stroke placed at 0.234 travels as 958 parts in 4095 and arrives at 0.23394, which lands on different cells and grows a different world. Both sides were internally consistent and both ledgers agreed exactly. The rule is that the encoder must run the decoder, so the intent is now rounded to what the wire can carry the moment it is drawn. The same mistake was then made a second time when the physics joined the message, and caught the same way: the numbers were rounded for the wire while the world was still being built from the unrounded ones.

The second was arithmetic. The shader language permits several units of error in an exponential and allows an implementation to reorder a sum, so two devices that both follow the rules may disagree about one draw, and one disagreement is enough to grow a different world. This instrument now has no floating point on that path at all: the temperature is folded into the couplings before they are uploaded, the energies are integer sums, the exponential is a table, and the choice is an integer comparison. It costs about a fifth of the speed, and the table stops being an approximation of the model and becomes the model, which is what makes agreement possible rather than likely.

Verified across five machines and three generations of graphics hardware (two M3 Ultras, two M4 Maxes and a second M5 Max) each returning every fingerprint unchanged, and each reporting a real graphics adapter rather than a software fallback, which is the check that makes the result mean anything. That establishes the arithmetic survives a change of silicon. It does not establish a change of vendor, because all five speak to the same graphics layer underneath.

It has since run somewhere that is not that graphics layer at all. The browser ships a software implementation of the same standard, and asking for it through the ordinary API puts the identical suite on a different code generator, a different intermediate representation and a processor instead of a graphics card. Thirteen out of thirteen, bit-identical. This is what an all-integer accept path is for, and it was the first evidence it holds anywhere else.

The remaining objection to that pair of runs was that one browser was translating the shader language both times, so a fault in the translator would be invisible to both. That is now answered. The suite has been driven through a second browser built on an entirely independent engine, whose compiler for the shader language shares no code with the first, on a real graphics adapter rather than a software one. Thirteen out of thirteen again, to the same fingerprints.

What that establishes: the arithmetic survives two independent compilers for the shader language, three code generators, and execution on both a graphics processor and an ordinary one. What it still does not establish is a second hardware vendor. Every run above is Apple silicon or software, so the driver and the physical arithmetic units have never changed. That is the one axis left, it needs a machine this work does not have, and the suite is one page and installs nothing if you have one.

Worth adding that the same mistake was made a second time when the physics joined the message: the numbers were being rounded for the wire while the world was still built from the unrounded ones, so sender and receiver disagreed again. It was caught only because the end-to-end test exists, and the ledgers on both sides read identically while the worlds did not.

The suite above builds five worlds from five fixed intents and fingerprints each one: nothing painted, a single stroke, a typical intent, a crowded one, and the typical intent realized larger. Between them they cover an empty constraint set, one constraint, many, and a change of lattice size. The reference values were measured here. Opening the page anywhere else takes half a minute and produces a short report, and a mismatch is worth more than a match, because it would name the operation that is not as portable as its specification promises.

Five machines have now run it and all nine worlds came back identical on every one, across three generations of graphics hardware. That is a real result and a partial one: the same vendor and the same graphics layer throughout. What is still wanted, in the order it would settle the question, is a Windows machine with an NVIDIA card, which changes vendor, graphics backend and shader language at once; then a phone, because mobile parts are where integer behaviour is most likely to surprise and because a link is the kind of thing people open on a phone; then a different browser, whose shader translator is written by different people and so tests the arithmetic rather than one company's compiler.

The prediction was stated before any of this ran, so that it could be wrong: every device would match. Five have, which is encouraging and not yet conclusive. Everything left on that path is exactly specified, and integer addition is associative, so a compiler may reorder it without changing the answer. That is what a fifth of the speed was spent on. One thing was nearly missed while building the test and would have failed it: the table of exponentials was being computed with the language's own exponential function, which the specification describes as approximated rather than exact, so two engines could have built different tables and grown different worlds from identical arithmetic. It is now built from an integer constant, which every engine agrees on.

When Morse code was introduced, people already had speech, letters, printing and painting, and all of them were incomparably richer. Two symbols cannot carry tone, or a face, or a paragraph of prose. Judged against what already existed it was a poor way to communicate, and every such judgement was correct and beside the point, because none of the older forms could cross a continent in a second. The thing that made it work was the constraint: two symbols is what a wire can carry.

The sharpest result below has the same shape. Used as a code rather than a sampler, the same fitted model is five times smaller and loses nothing, which reads as a defeat until you notice that a coder has to be given the picture first. This one is not given a picture. Asking which is the better compressor answers a question only one of them was built for.

The property that has no counterpart elsewhere is the one measured above. A few bytes of intent become a whole field, the constraints are honoured exactly, and the same intent with a different seed gives a different world that honours them just as exactly. Nothing that compresses can report that number, because a compressor is handed the world. The limitation that makes this possible is the same one that makes it fast: interactions reach only as far as the neighbouring cell, which is why it runs at ten billion updates a second and why it travels as a seed.

So the retractions below stand, and they are not the subject. They are what it costs to know where the edges are. The subject is the thing on the other side of them.

FRAME is remembered for taking about a day to make one texture. Its authors give the arithmetic behind that figure, and it is a product of two nested loops: fifty rounds of adjusting the model's parameters, with four sweeps of the sampler between each round. The sampler is doing double duty, serving as both the thing that draws the picture and the thing that estimates the gradient for the next parameter update. Drawing a picture from parameters already known is the four-sweep slice. The factor of fifty belongs to fitting the parameters.

So a sampler ten billion times faster addresses the inner loop and leaves the outer one where it was. Fitting an energy function to content requires an expectation that has no closed form and is itself estimated by sampling, and the difficulty there is bias rather than throughput. The same authors named the way out in the same paper, pointing at pseudo-likelihood as a way to fit without sampling at all, and then said they would not pursue it. That invitation has been open since 1998.

This matters for everything downstream. A codec has to get its couplings from somewhere, and if they are fitted per image then they are part of the message and belong in the bitrate. A generator has to get them from an exemplar or from a designer. The instruments on this page sidestep the question entirely by using couplings written by hand, which is a legitimate choice and also a small one: it is the reason they can be fast, and the reason they cannot yet be pointed at arbitrary content.

A chain run for a fixed number of sweeps with no convergence test computes a reproducible deterministic function of its seed, its budget, its starting distribution, its clamps and its couplings. That is a real and useful thing, and it is what these instruments do. What it is not is a draw from the distribution the energy function defines, and the difference is not a technicality: the output's statistics depend on the budget, so couplings fitted at one sweep count do not transfer to a decoder running a different one.

The most striking thing found while checking this is that FRAME's authors described their own fixed-budget loop as being very much like simulated annealing rather than as equilibrium sampling, in 1998. Two of those authors are on the papers that, twenty-one years later, characterised what a non-convergent chain actually estimates. The field understood its own position throughout, and the honest framing was available the whole time rather than being something this topic had to invent.

There is a second failure this could have had, and it does not. An energy function fitted by a short chain has no valid long-run behaviour: run such a model far past the budget it was fitted under and it drifts into a few oversaturated states, which several groups first recorded as a curiosity before it was recognised as a symptom. The worlds here use couplings written by hand, so there is a genuine distribution for the chain to reach and no reason to expect that drift. Tested rather than assumed: running to 1200 sweeps, six and a half times the measured mixing time, moves energy per site by 0.35%, against a fluctuation of a tenth of that per sweep. The field is stable. This is the one place where declining to fit anything is a real advantage rather than a limitation, and it is worth separating from the codec, which does fit.

One trap is worth stating because it is easy to fall into. If the couplings are refitted at each setting, then output quality holding steady as the budget grows is the expected signature of non-convergence rather than evidence against it. Any budget or density sweep has to hold the couplings fixed. The sweeps on this page do: the worlds use hand-written couplings, and the codec fits once per source and reuses that fit across every scaffold density.

A note on how these behave. Each field settles to equilibrium and then stops. A settled field is not resampled to draw it, because another sweep would produce a different draw from the same distribution: every cell would change, and none of the change would carry information. Sweeps resume only where the field has genuinely been disturbed.

The original method was to raise the sweeps done per frame until the frame rate fell away from the display's refresh, then multiply frames per second by sweeps per frame. The reasoning was that if the frame rate is dropping, the sampler must be the thing holding it back. That reasoning is wrong, because submitting work to a GPU does not wait for it: the loop enqueues a frame's worth of sweeps and returns immediately, so the frame counter keeps ticking while the queue behind it grows.

Measured directly, the loop fired ninety-one times in three seconds while the queue it had filled took six and a half seconds to empty. At the exact shape the original figure came from, 4096 sweeps in one submission, waiting for the work to finish takes 421 milliseconds. The original arithmetic implied ten. The frame rate was a measurement of the submitting loop, not of the device.

The fix is one line: wait for the queue to drain before dividing. Both instruments on this page now do that, so neither can report the inflated figure again. What the corrected number says about the method is that it is limited by how often work can be launched rather than by arithmetic. Each sweep needs two passes, one for each colour of the lattice, and the second cannot start until the first has finished, so a 64³ field spends most of its time waiting to start rather than computing.

Correcting the number made it worth optimising, and the first attempt was wrong in an instructive way. If launching work were the cost, the fix would be to do more per launch, so the field was cut into chunks that could each take many steps behind one launch. That is exact, and it came out slower: one group of threads per chunk left eight times fewer threads running at once, which cost more than the launches saved. What actually helped was smaller. The lattice is updated in two passes, and each pass was starting every site and immediately abandoning half of them, so half the machine idled. Starting only the sites that will be updated is worth 1.79×. A second change was worth another 2.5×: the six candidate weights were being held in an array indexed by a loop counter, which cannot stay in registers and quietly becomes memory traffic. Naming them fixes it. Because the randomness is tied to a site's position rather than to which thread handles it, both changes produce the same world cell for cell, and the instruments here run the faster version.

The consequence reaches further than the number. At the corrected rate, equilibrating one 64³ region takes under 3 ms, so about six regions fit in a frame rather than the ninety-two that were claimed. The original projection, made before any of this was measured, had said about one. That projection was right, and the measurement that appeared to overturn it by two orders of magnitude was the thing that was wrong. The claim that re-thermalising a region is comfortably free at frame rate is withdrawn along with the number.

The two columns are the same chemistry run through the same kernel, differing only in how many neighbours a site has. That alone moves the ordering transition: at β=0.80 the three-dimensional field is nearly critical and needs 186 sweeps, while the two-dimensional one is comfortably disordered and needs 15. The slow band arrives later in two dimensions because fewer neighbours pull on each site, which is the direction the physics predicts and a check worth doing. Mixing time belongs to the model, not to the sampler, so it has to be measured once per model.

The cost of a correct sample is cheap in the disordered phase, rises steeply as the field begins to order, exceeds the measurement window through the transition, and falls again once the field is firmly ordered. This is critical slowing down, and it is the specific reason a single fixed sweep budget cannot be quoted as a converged sample across temperatures. No temperature above β=0.5 clears the 70 sweeps this work previously used, in either model.

What this does and does not cost the topic. The worlds are unchanged: they are structured, stratified, reproducible from a seed, and they are what an energy function produces under a stated budget. What cannot be claimed is that they are draws from the equilibrium distribution at the temperatures where they look best. The instruments now take their settle budget from this table and say which of the two they are showing.

On both contents where the sampler was already failing, the same couplings used as a code are smaller than the sampler's message and lose nothing at all. There is no operating point to tune and no metric argument to have: one method is exact and cheaper. For structured content the compression application is finished, and what the model is good for there is coding rather than generating.

The second column of that table carries a finding of its own. The coder's rate moves across a twenty-four-fold range with the content, from 337 bytes to 8188, because it spends bits exactly where the picture is surprising. The sampler's rate does not move at all: 1683 bytes for every input, because a fixed lattice of clamped sites costs the same whatever is in the image. A method whose rate is independent of its content is not compressing in the sense the word is normally used, and that is visible here without appealing to any quality measure.

Where the sampler is genuinely smaller, on texture and on generated worlds, it is four to five times cheaper than exact coding while getting about a quarter of the sites wrong. Whether that trade is worth anything is precisely the question no metric on this page can currently answer, which is why it is an experiment below rather than a claim here.

The left column falls off a cliff between the first two rows and never recovers. The right column loses eight points of agreement while the message shrinks by a further factor of sixteen. Reading only one of these columns would support almost any conclusion. The couplings were fitted once per source and held fixed across every row, which matters: if they were refitted at each density the sweep would be uninterpretable, because quality holding steady under a changing budget is what non-convergence looks like.

A third content sits between them, and the table above hides it. A photographic texture, run through the same sweep, goes from 71% down to 35% agreement. That is neither the cliff nor the curve but something in between, so what the two columns really sample is the ends of a range rather than two kinds of thing. Describing content as either local-statistic or structured is a simplification, and the interesting work is in the middle.

One reservation, and it is the most exposed claim on this page. Class agreement counts sites that match, one by one, which makes it the categorical relative of PSNR. Zujovic and colleagues measured how point-by-point scores behave on exactly this kind of comparison, retrieving a different crop of the same texture: PSNR ranked the correct match first 4% of the time, against 96% for a score built from texture statistics. A metric that is appropriate on the structured column and close to useless on the texture column could produce a difference in shape between the two on its own. Until this is re-measured with a texture-aware score on both arms, the contrast above is a result about the measurement as much as about the content, and it is listed as an experiment below rather than as a conclusion.

One mechanism by which the metric could have produced the difference has been ruled out. If the reconstruction were the right texture in slightly the wrong place, a strict site-by-site count would punish it and a tolerant one would not. Allowing every sixteen-pixel block to find its best match within four pixels recovers at most six points, and recovers a similar amount on all three contents. The structured scene still collapses from 100% to 9% across the same sweep where the generated world moves from 78% to 75%. Spatial misalignment is therefore not what separates them. That is one mechanism excluded rather than the question settled: a resampled texture differs from its source by more than a shift, which is why the experiment below asks for a metric built on texture statistics rather than for a more forgiving version of counting.

• The throughput figure is from one machine and one vendor: an Apple M5 Max with a 40-core GPU, and it is now about three orders of magnitude below purpose-built FPGA machines rather than one. What remains interesting about it is where it runs, not how large it is, and the reading is that a browser tab is a convenient place to do this rather than a fast one.
• Convergence is now measured rather than assumed, and the measurement went against the work: the earlier 70-sweep figure was the visual plateau, and the mixing time at the temperature these worlds run at is 186 sweeps. Through the ordering transition it exceeds the 240-sweep window entirely. The instruments state which regime they are in.
• There is floating-point arithmetic on the accept path, including an exponential. The WGSL specification allows an implementation several units in the last place of error on that function, and separately permits reassociating and fusing operations. Two conformant implementations may therefore compute different values from identical inputs, take different branches, and produce different worlds from the same seed. Reproducing a world from a seed is established on one device and driver and not across them, and for a codec that is not a nicety, since a decoder that cannot reproduce what the encoder drew does not decode. An integer accept path is the only sound fix.
• The couplings in the codec are fitted from the content being sent. Those fitted values are part of the message, and any compression ratio quoted without them is incomplete.
• Energy is now measured rather than assumed: 9.65 nJ per site-update on the GPU rail, from on-chip power counters read without elevated privileges, divided by the update rate from the same run. It is a rail measurement rather than a wall measurement, so it excludes the rest of the machine, and it is one device on one day.
• The update schedule is not new. Colouring a graph so that conditionally independent sites can be resampled together is standard, published for parallel Gibbs in 2011 and resting on parallel-scheduling results from the 1980s, and it is what current probabilistic-computing hardware does as a matter of course. What belongs to this work is the port to a browser and the measurements, not the algorithm.

• Re-measure the scaffold sweep with a texture-aware score on both arms. The cliff-against-curve contrast is currently measured in per-site agreement, a point-by-point score, and point-by-point scores are known to be near-blind to texture similarity. If the contrast survives a texture-aware metric it is a property of the content; if it does not, it was a property of the ruler. This is the cheapest way to settle the page’s most exposed claim.
• Build the two controls that any future codec number needs: the null that costs nothing, and a decoder that minimises squared error at identical rate, clamps and temperature. Without the second, no appeal to perceptual metrics is available, because the most such an appeal can be worth is about three decibels.
• Efros and Leung found that sampling added almost nothing on top of a good greedy result. Does that still hold when the sampler is ten billion times faster, or was the finding about the estimator rather than the budget? This is the question the whole topic rests on.
• Which content has the tail? The codec wins on one class of image and loses on another. A two-point spread is not a distribution, and the useful result is the boundary rather than either end.
• How large is the gap between greedy per-block rate-distortion optimisation in a modern video encoder and a joint optimum over the same choices? If it is small, an encoder built on sampling has nothing to win.
• AV1 already transmits film-grain parameters and resynthesises the grain at the receiver. Games have shipped seed-plus-rules reproduction to a far larger audience. How far does that contract generalise, and what breaks it first?
• At what energy per sample does dedicated hardware earn its place against a GPU that is already this fast and comes with a complete toolchain? The throughput result makes this case harder to argue, not easier.

Onsager's closed form, exact-Boltzmann total-variation distance, enumerated ground states and Gaussian elimination all sit in the test suite as referees, so the sampler is checked against answers that are known independently of it. Every claim carries a grade, measured or verified or projected, and the grade travels with the claim.

The library ↗Thermodynamic Physical AI →How we measure energy (PAI-280) →

The standard teaching texts on Monte Carlo describe starting one run from a random configuration and another from a uniform one, plotting energy per site after every sweep, and reading equilibration off the point where the two agree. They describe it for q-state Potts models by name, in the same vocabulary this topic uses, and they present it as routine rather than as a result. It is the diagnostic on this page, and none of it is ours.

What is worth noticing is the gap. One field recorded an obstacle serious enough to change its direction for twenty years, while a field one shelf over treated the same question as a first-week exercise. The sentence about convergence is quoted here as evidence for what the graphics community understood at the time, and it should also be read as evidence about how narrowly a literature can be searched. This work repeated the error in the other direction: the diagnostic was built from first principles before anyone checked whether it had a name.

The useful correction is that the answer to the 1999 objection was never going to come from making the sampler faster. It comes from borrowing a measurement that already existed. That leaves the second objection, the one about whether sampling improves on a good greedy result, standing exactly where it was.

It loses everywhere it was tried, in sweeps and again in wall time, and adding clamped sites makes it worse rather than better. Watching what the clusters do says why. Early on the field is disordered, clusters are tiny, and two thirds of all sites move in a sweep. As the field does its work the clusters merge, until one of them holds forty-four per cent of the lattice, and by then fewer than one site in ten moves at all.

The cure works by exploiting a symmetry this model does not have. Flipping a large region wholesale is cheap only when the energy does not care which way it flips. Here the energy cares a great deal: heavy things prefer to be low, and that preference is the entire reason a world made this way has ground under it and sky above. The large cluster is exactly the stratified region, and moving it means moving the stratification, which the field immediately refuses. The better the model works as a world, the less the acceleration has to offer.

That is worth stating as a trade rather than a defeat. A field-shaped world and cluster acceleration are alternatives, not companions, and anyone reaching for the second should expect to give up the first. The measurement took an afternoon and it closes a line of enquiry that could otherwise have absorbed a great deal more.

The convergence diagnostic is the textbook equilibration check, described above. It is also weaker than what already exists: coupling from the past runs two extremal chains and, when they meet, returns an exact draw from the target distribution rather than evidence that one is nearby. Where that applies it does not merely diagnose the problem this page spent a day measuring, it removes it.

Comparing against a decoder that does nothing is standard too. Repeating the previous frame is a recognised control in video prediction, reported precisely because it beats sophisticated methods whenever motion is small, which is exactly how it beat the codec here. Video coding has had a mandatory harness of common test conditions for years, and an image-processing journal has published every article as text plus reviewed source plus a demo the reader can run since 2009.

And using a generative model as a code rather than as a generator, which produced the sharpest result on this page, is a stated equivalence with its own literature: any predictive model plus an arithmetic coder is a compressor whose ideal length is the model's own surprise. It was applied to language models under that name two years ago. The finding here is real and the framing is borrowed.

What is left is smaller and worth saying plainly. These instruments are a teaching artifact and a set of measurements for one model family on hardware people have. That is a legitimate thing to publish and it is not a discovery. The temptation, on finding every component occupied, is to define a narrower conjunction until the gap reappears. A vacancy produced that way is a definition rather than a finding, and the move is to cite the people who got there first and spend the effort on the questions that are still open.

Published lattice simulations reach 1.8 × 10¹² spin-updates per second for a two-state model on a single current datacentre GPU, and 9.5 × 10¹¹ for a three-state model at four bits per spin. Against the three-state figure this work is about fifty-six times slower, on a laptop rather than a datacentre part, and that is the fair way to state it.

Two details in those runs matter more than the ratio. They carry no external field and no clamped sites, and both of those are the whole point of the operation here: a field is what makes the world stratify, and clamping is what makes a tunnel stay open and a codec's scaffold mean anything. And the speed comes largely from packing many spins into one machine word and updating them with bitwise operations, which requires the couplings to take a small set of integer values. The couplings here are arbitrary real numbers, so that technique is not available without changing the model. The gap is therefore partly a measure of how much the conditioning costs, and saying so is more useful than the ratio.

None of the corrections came from a number that was meaningless. Each came from a number that was accurate about a quantity next door to the one being claimed. Frames per second was a faithful measurement of how fast work could be submitted, and it was quoted as how fast work was done. Seventy sweeps was a faithful measurement of when the picture stops visibly changing, and it was quoted as when the field forgets where it started. A ratio of thirty-three was a faithful count of bytes, and it was quoted as compression, which also requires a statement about quality. Class agreement of 84% was a faithful count of matching sites on a page of text, and almost all of those sites were background.

This is a more uncomfortable failure than being wrong, because each figure survives every check that asks whether it is real. It was produced by working code, it reproduced, and it moved in the right direction when the underlying thing changed. What none of them carried was the sentence saying which quantity had been measured, and that sentence is the whole difference between a measurement and a claim.

Five checks caught all of it, and they are cheap enough that there is no good reason to skip them. Ask what the answer is when the method does nothing at all, because a method that cannot beat doing nothing has not been shown to do anything. Ask whether the work finished, rather than whether it was started. Ask whether the chain has forgotten where it began, which for a model on a sparse graph is a measurement rather than an article of faith. Ask whether the same model would do better used a different way, which for a generative model usually means using it to code rather than to guess. And attach to every number the conditions under which it was taken, because a number without them will eventually be read as a claim about something it never measured.

The plainest way to state what came out of the work is that a game engine and a codec were the goal, and neither is what was built. What was built is an apparatus for telling whether a method like this is real, and the evidence that it works is that it kept returning answers nobody wanted. That is a smaller claim than the one the topic started with and a more durable one, and it is the part worth giving away.

1. 1983 · Cross & Jain. Markov random field texture models. IEEE TPAMI. The first fit of MRFs to real textures; microtextures worked, regular and inhomogeneous ones did not.
2. 1984 · Geman & Geman. Stochastic relaxation, Gibbs distributions, and the Bayesian restoration of images. IEEE TPAMI 6(6). Where the sampler comes from.
3. 1987 · Marroquin, Mitter & Poggio. Probabilistic solution of ill-posed problems in computational vision. Introduces the MPM estimator and argues it beats MAP for restoration.
4. 1995 · Bader, JáJá & Chellappa. Scalable data parallel algorithms for texture synthesis using Gibbs random fields. IEEE TIP 4(10). Massively parallel Gibbs on a lattice, used for both synthesis and compression.
5. 1998 · Zhu, Wu & Mumford. Filters, random fields and maximum entropy (FRAME). IJCV. The high-water mark of sampled texture.
6. 1999 · Efros & Leung. Texture synthesis by non-parametric sampling. ICCV. States both reasons the field moved on.
7. 2000 · Wei & Levoy. Fast texture synthesis using tree-structured vector quantization. SIGGRAPH. Keeps the MRF model, replaces the sampler with a deterministic search.
8. 2001 · Efros & Freeman. Image quilting for texture synthesis and transfer. SIGGRAPH. Minimum-cost path by dynamic programming.
9. 2003 · Kwatra et al.. Graphcut textures. SIGGRAPH. Same energy, same sparse graph, argmin instead of a sample.
10. 2005 · Lefebvre & Hoppe. Parallel controllable texture synthesis. SIGGRAPH. Real-time on the GPU and explicitly deterministic; variation comes from jittered exemplar coordinates rather than a temperature.
11. 2008 · Jalali & Weissman. Rate-distortion via Markov chain Monte Carlo. Sampling as the compression primitive, with an optimality result for stationary ergodic sources.
12. 2009 · Barnes et al.. PatchMatch. Randomized search over a correspondence field, converging to a fixed point. Ships as Content-Aware Fill.
13. 2004 · Berg. Introduction to Markov chain Monte Carlo simulations and their statistical analysis. Describes ordered and disordered starts for q-state Potts models, and reading equilibration off the point where their energies agree, as ordinary practice.
14. 1996 · Propp & Wilson. Exact sampling with coupled Markov chains. Coupling from the past: run two extremal chains and, when they meet, the common state is an exact draw rather than an approximation. Strictly stronger than the diagnostic on this page, where it applies.
15. 2016 · Theis, van den Oord & Bethge. A note on the evaluation of generative models. Log-likelihood, sample quality and Parzen estimates are largely independent in high dimensions, so a generative model has to be evaluated against the application it is for.
16. 2017 · Villegas et al.. Decomposing motion and content for natural video sequence prediction. Documents the copy-last-frame control, which scores highly wherever motion is small; the same control is what beats the codec here.
17. 2021 · Vehtari, Gelman, Simpson, Carpenter & Bürkner. Rank-normalization, folding and localization: an improved R-hat. Documents where the standard multi-chain convergence statistic fails and what to use instead.
18. 2024 · Delétang et al.. Language modeling is compression. Any predictive model plus an arithmetic coder is a compressor whose ideal code length is the model's own surprise. The framing behind the code-versus-sample result above.
19. 2025 · Various. Massive-scale lattice Monte Carlo on current datacentre GPUs: 1.8 × 10¹² spin-updates/s for two-state and 9.5 × 10¹¹ for a three-state model on a single device, with no external field and no clamping.
20. 2005 · Carreira-Perpiñán & Hinton. On contrastive divergence learning. AISTATS. Its fixed points are not maximum-likelihood fixed points, and the bias is largest near the boundaries of the simplex, which is where hard clamps and low temperature put you.
21. 2011 · Gonzalez, Low, Gretton & Guestrin. Parallel Gibbs sampling: from colored fields to thin junction trees. AISTATS. The chromatic schedule this work uses, published, and itself built on parallel-scheduling results from the 1980s.
22. 2013 · Zujovic, Pappas & Neuhoff. Structural texture similarity metrics for image analysis and retrieval. IEEE TIP 22(7). Measures how badly point-by-point scores do on texture: PSNR retrieves the right match 4% of the time where a statistics-based score reaches 96%.
23. 2018 · Blau & Michaeli. The perception-distortion tradeoff. Perfect perceptual quality costs at most a factor of two in squared error, which is 3.01 dB. The ceiling on any "the metric is unfair" argument.
24. 2019 · Nijkamp, Hill, Zhu & Wu. On learning non-convergent short-run MCMC toward energy-based models. What a fixed-budget chain actually estimates, which is not the energy you think you fitted.
25. 2020 · Nijkamp, Hill, Han, Zhu & Wu. On the anatomy of MCMC-based maximum likelihood learning of energy-based models. AAAI. Names the convergent and non-convergent regimes and gives diagnostics for telling them apart. Two of its authors wrote FRAME.
26. 2020 · Ding, Ma, Wang & Simoncelli. Image quality assessment: unifying structure and texture similarity (DISTS). Built specifically to tolerate texture resampling, which is the failure mode the codec here runs into.
27. 2022 · Aadit et al.. Massively parallel probabilistic computing with sparse Ising machines. Nature Electronics. Measured update rates on FPGA hardware that the browser figure on this page sits well below.
28. 2015 · Versteegen, Gimel'farb & Riddle. Texture modelling with nested high-order MRFs. Records that Gibbs sampling from these models adds unwanted high-frequency noise, and that the Markov blankets had grown to 50–100 pixels.

The specification →← All topicsThe energy-first turn →