The Percepta team published the article *Constructing an LLM-Computer*: a system that analytically compiles a WebAssembly virtual machine into the weights of a standard autoregressive transformer. The network itself executes the program—C code, after being compiled to WASM, is fed as tokens and executed step-by-step, without training and without an interpreter outside the model. The weights occupy approximately 1.5 MB, the demo works directly in the browser, and the full code is open on GitHub. This is a rare case where the idea of a “transformer as a computer” is formulated not as rhetoric, but as a verifiable engineering mechanism.

image
image
image

What Happened

On March 25, 2026, the Percepta team published the article *Constructing an LLM-Computer*, a follow-up to the post *Can LLMs Be Computers?* from March 11, 2026. The work describes a pipeline that analytically compiles a WebAssembly virtual machine into the weights of a standard autoregressive transformer: for this purpose, an abstract machine ALM (Append-only Lookup Machine) and the CALM language were defined, and the distribution of operations across layers is solved via Mixed-Integer Linear Programming (MILP). Any C code compiled to WASM is fed to the model as tokens and executed by the transformer itself, without training and without an external interpreter. The weights of the resulting model occupy approximately 1.5 MB, a demo with ready-made examples (hello, addition, fibonacci, collatz, sudoku) works directly in the browser, and the full code is open in the Percepta-Core/transformer-vm repository on GitHub.

Context

The post *Can LLMs Be Computers?* from March 11, 2026, posed the question of whether a transformer can be a computer, and the new article answers it not with arguments, but with a ready-made engineering mechanism with an open artifact. The key difference from common debates about whether LLMs can do math is that execution is claimed to be exact integer arithmetic and obtained by construction of the weights: the program is embedded into the weights by a compiler, and gradient training is not involved. Verifying such a claim reduces to reproducing the compilation pipeline, rather than measuring accuracy on tests, which is methodologically stronger than common benchmarks. The result itself relates to the expressiveness of the architecture, where attention and feed-forward serve as carriers of the lookup mechanics of the abstract machine ALM, rather than to the capabilities of trained models, so it cannot be transferred to ordinary pre-trained LLMs. The choice of WebAssembly as the target virtual machine is methodologically sound: it is a unified frontend for arbitrary C code with a ready-made ecosystem of tools, but it also highlights the nature of the result—we are looking at a planned distribution of computations across layers, not an emergent capability of the model. The compactness of the artifact allows for cheap bitwise verification of the weights and reproduction of the entire pipeline, which is rare for loud claims in this field.

Why This Matters for the Industry

For the AI industry, this is a specific mechanism, not a promise, and it offers builders several entry points immediately. First—a working open pipeline that compiles programs from C to WASM and then into transformer weights: based on it, interactive educational products, computation visualizers, and developer tools can already be built. Second—areas where execution accuracy and verifiability are important, primarily verifiable computations and neurosymbolic accelerators, where deterministic “microprograms in weights” could work on specialized hardware. Third—interpretability: the MILP planner, which automatically distributes operations across layers, is itself a non-trivial tool for studying which computational primitives a transformer implements natively and which layers encode which operations. At the same time, the impact on current LLMs, their training, and benchmarks is zero, and production value is not confirmed: this is not a replacement for a standard WASM runtime and not an inference engine, and for startups today it is a window for cheap experiments and capturing tooling niches, not a ready-made product. In the coming months, independent code and weight checks, reproduction reports, and the possible transformation of the compiler into a research arsenal utility are logical; if compiling programs into weights scales, it may lead to a niche of verifiable computations; if not, the work will remain an impressive demonstration of expressiveness.

Why This Matters for Users

To see the mechanism in action, a browser is enough: in the demo, you can load one of the ready-made C programs—hello, addition, fibonacci, collatz, or sudoku—compile it to WASM, and track how the transformer with custom weights executes it step by step. The system can be downloaded and run locally, and a fork for a custom interface is estimated to take days of work, not months, so the repository is convenient as a basis for educational projects, hackathons, and prototypes. The ready-made demo can be easily embedded as an interactive element in a course, article, or workshop—it is a way to visually show how a neural network executes a familiar program. For the everyday user of common LLM services, there is no direct benefit here and now: the value of the system is research and educational.

What Is Still Unknown / Limitations

The evidence base is currently limited to two Percepta blog posts and the authors' own demo: the provided materials show no signs of external peer review or independent reproduction, so the claim of exact execution remains the authors' word until verified by a third party. The actual characteristics of the system are also unknown: latency in forward passes per instruction, the maximum size of executable programs, robustness to quantization, and the limits of the MILP planner—primarily how compilation time grows with code length and whether the pipeline scales to longer programs and a larger number of layers. The title of the post from which the material was taken mentions another work repeating the approach “almost 1-to-1,” but its details and comparison are not present in the materials.

Sources

Author

Look at AI, editorial team