The Ghost in the Code: The Machine Whisperer Has No Face

Fabrice Bellard wrote the code that carries the world's video, spins up its clouds, and speaks to its cell towers. He does not give interviews. For nearly forty years he has been in conversation with one thing only, a machine, in a quiet room, with no one else invited. This is a portrait of that conversation, assembled from everyone left standing outside the door.

Digits of pi, fragments of C, and the space where the man should be.

On the last night of 2009, while the rest of the planet was counting backward from ten, a desktop computer in France finished counting forward. It had been running for 131 days, one consumer machine humming the same note, hnnnnnnnnnnnn, from late summer into the dead of winter. When it stopped, it held 2.7 trillion digits of pi. A world record. The previous one had needed a supercomputer. This one was set by a PC that would not have looked out of place under a teenager's desk.

The digits of pi, each one rendered as a rod whose color and height encode its value. Bellard computed nearly 2.7 trillion of them on a desktop.

The man who owned that PC did not hold a press conference. He posted a short note on a website that has no logo, no photographs, and a design that looks untouched since the last century. It thanked nobody. Then, as far as anyone can tell, he went back to work.

His name is Fabrice Bellard. If you have watched a video on the internet today, you have used his code. If you have spun up a virtual machine, tested an app in an emulator, or stood beneath a certain kind of cellular tower, you have used his code. A rover on Mars compressed the video of its own landing with his code. He has never sat for the kind of long, confessional interview the industry hands to men who have built one tenth of what he has built.

He would not sit for this one either. Nobody expected him to.

There is an old way of writing about a man who will not talk to you. You go to the people who carry his work, who fight over it, who inherited it and cannot put it down, and after a while the shape of the absent man appears in the way everything around him has been bent. You do not need to see the planet. You can see it in the paths of its moons.

Bellard's moons are mailing lists and commit logs, maintainers who inherited his cathedrals and spent decades keeping the roofs on, and John Carmack, the man who wrote Doom, saying out loud what the field had been muttering for twenty-five years:

"I admire Fabrice Bellard. He is almost certainly a better overall programmer than I am."

That is the industry's most famous engineer conceding the crown to a man most of the industry cannot pick out of a lineup. So we went to the moons.

But understand what the moons are circling. At the center there is not a personality. There is a room. Nobody has described it, but every piece of software he has ever released is the transcript of the same conversation: one man, one machine, and nobody else. The machine speaks in cycles and bytes and the flat refusal of a full floppy. He answers in code. Efficiency is not his style. It is the grammar of the conversation. Every wasted byte is a word the machine will not forgive, and every human interruption, every committee, every interviewer, is noise on the line.

I. The Website

Start at bellard.org.

You type it in and you brace for the modern web, the cookie banner, the hero image, the parallax scroll, the sans-serif reassurances about mission and vision and changing the world, and instead you get... a list. A plain list of links on a white page. Black text. Blue links. It looks like something a graduate student would have put up in 1997 and forgotten about, and in a sense that is exactly what it is, except that the graduate student never stopped.

Look at the list. It is not a résumé. It is an inventory of the load-bearing walls of the twenty-first century.

FFmpeg. QEMU. Tiny C Compiler. QuickJS. JSLinux. BPG. A formula for the digits of pi. A world record for pi. An LTE and 5G base station. A neural-network compressor that won a benchmark. An audio codec that squeezes a song into five and a half kilobits per second, a bandwidth that a dial-up modem of the mid-1980s could not have delivered. A REST server for running large language models on your own machine. Each link goes to a page as plain as the first. Each page describes, in flat, declarative, faintly amused prose, a piece of software that would be the crowning achievement of an ordinary career.

There is no About Me. There is no photograph on the home page. There is, in fact, no usable photograph of him anywhere. The one image on Wikimedia Commons that was labeled with his name turned out, on inspection, to be a photograph of the mathematician Simon Plouffe, misfiled for more than a decade, and was quietly recategorized. The most complete fan-maintained page about him notes that there are no in-focus images of Fabrice Bellard on the internet. In the age of the selfie, the man who wrote the software that carries the world's video has arranged to be, visually, a blur. A commenter on Hacker News, in a thread about one of his releases, once ticked off the absences the modern software world considers mandatory: no libraries, no continuous integration, no issue tracker, no landing page, no dashboard. Just code, and a paragraph explaining what it does, and a tarball.

It is a little thrilling and a little sickening. The same commenter put his finger on the nausea. Most of the apparatus of modern software engineering, he wrote, is "a cost that only benefits for managing collaboration between teams. The smaller the team the less stuff you need." And here is a man who has skipped all of it and simply built the thing.

That austerity is the first clue. The website is the man. There is nothing on it that does not need to be there, and everything that is there works. It is what a conversation looks like when only one side of it is allowed to leave the room. You get the answers. You never hear the questions.

II. The Ghost in the Codec

Go to the beginning of video on the internet, which is to say December 20, 2000.

On that day, a developer using the name Gérard Lantau pushed the first commits of a new project. It was a mask. In the year 2000 the world of digital video was a minefield of patents, its mathematics owned, licensed, and litigated, its codecs locked in black boxes guarded by lawyers. To write a free implementation of those codecs was to paint a target on your chest. So, one presumes, the man who did it wore a false name.

The project was called FFmpeg. The "mpeg" was a nod to the standards body that governed video. The "FF" stood for fast forward. And behind Gérard Lantau, as everyone in the community would eventually learn, was a twenty-eight-year-old Frenchman named Fabrice Bellard.

FFmpeg: the fast-forward wordmark that now sits, unseen, behind nearly every video on the internet.

He looked at the chaos of digital media, the dozens of container formats and hundreds of codecs and the incompatible, patent-shackled, vendor-locked mess of it all, and he built a universal translator. He drew a clean line between the codec layer, libavcodec, and the format layer, libavformat, and connected them with a pipeline that could swallow almost anything and spit it out as anything else. Then he wrote the codecs. Not wrapped, not borrowed. Written. Largely from scratch, largely alone, for peak performance, in C.

Picture the terms of it. A codec is a negotiation with a machine over what can be thrown away. The machine says: this frame costs this many cycles, this many bytes. He answers: not that many. And back and forth, night after night, until the machine stops objecting. There was no one else in the room. Gérard Lantau was not just a shield against lawyers. It was a door, closed.

When a video is uploaded to YouTube, FFmpeg transcodes it into a dozen resolutions. When a movie streams on Netflix, when a clip loops on TikTok, when a file plays in VLC, when a broadcaster pushes a signal to a satellite, when a rover on Mars squeezes the footage of its own touchdown for the long trip home, FFmpeg is down there in the dark doing the work.

NASA's Perseverance rover at the rock nicknamed Rochette, September 2021. The video of its descent and landing was compressed on board with FFmpeg. Image: NASA/JPL-Caltech/MSSS.

And then he left.

By 2003, Bellard had drifted away from the daily grind of FFmpeg. By 2004 the project belonged to a developer named Michael Niedermayer and a cadre of volunteers, and he had walked. This is the signature, the thing every moon describes in the same stunned tone. He builds the skyscraper alone. He hands over the keys. He does not look back.

The people who inherited the keys will tell you what it is like to live inside a Bellard building. It is fast. It is brilliantly conceived. And it is, in places, nearly impossible to read. Bellard is a three-time winner of the International Obfuscated C Code Contest, and that mindset, the ability to hold an intricate architecture whole in one skull, bleeds into the serious work. The early code was so tightly wound around its own logic that untangling a piece of it often bred more bugs than it killed.

The community took on the same temperament. A 2001 LinuxWorld review of the neighboring MPlayer project, whose developers soon became FFmpeg's, found them relishing "nothing more than belittling their users"; a later retrospective boiled that down to software by Marquis de Sade. In 2011 the fights over leadership went nuclear and a faction forked the project as Libav. For years there were two FFmpegs hurling code at each other, until Libav was quietly declared dead around 2020.

Every word of that war was human noise. Bellard was not in it. He had left the room the moment other voices came into it. Through all of it, the original kept running. Kostya Shishkov, a former FFmpeg developer who wrote a long, sardonic history of the project, shrugs that it has reached "too big to die" status. The phrase is meant as a put-down. It reads like a prayer.

Only the first two are his. The rest were poured by his heirs onto his foundation.

He builds a monolith and hands it to a hundred people, who need twenty years to maintain the plumbing of what one man built in four. That is not a story about software. That is a story about gravity.

III. Magnétophone

Where does a mind like that come from? The material is thin, because he has never sat still long enough to be asked, but it is there.

He was born in Grenoble in 1972, in the shadow of the Alps, and grew up in Montpellier. The family story, told to two student biographers in 2009 with the affection of a legend, is that his first spoken word was not maman or papa. It was magnétophone. Tape recorder.

It is tempting to read too much into a family story. Try to resist it, and notice that you cannot. Before the boy could say mother, he could name a machine that listens, plays back exactly what it was given, and adds nothing.

Magnétophone. The first word, by family legend, that the boy from Grenoble ever spoke.

By nine he was programming a Texas Instruments TI-59. It was a scientific calculator, a slab of beige plastic with a ten-digit red display and a language that was Turing-complete in the strictest, most punishing sense: no letters, no words, no mercy. Memory so scarce it was measured in keystrokes: 960 program steps, a hundred data registers, and not a byte more. You had to know exactly what the hardware could and could not do, down to the register, down to the step. You had to think like the machine.

Notice what the TI-59 did not offer. It did not flatter. It did not interrupt. It gave a wrong answer or a right one, in red digits, instantly, and then it waited. To a certain kind of mind it is the first honest conversation of a lifetime, and everything afterward is a search for more of it.

The Texas Instruments TI-59, with its magnetic program card and red LED display. Bellard was programming one at nine.

That calculator is the seed. A childhood spent bargaining with a machine that had almost nothing to give forged a philosophy that runs through everything he would ever write: a relentless, almost moral pursuit of hardware efficiency, an absolute mastery of the lowest layers, a horror of waste.

At seventeen, a student at the Lycée Joffre in Montpellier, he ran into a mundane problem. His computer, an Amstrad PC1512, had no hard disk at all, only two floppy drives holding 360 kilobytes apiece. A normal teenager deletes some files. A slightly unusual teenager saves up for a hard disk. Bellard studied the existing compression algorithms, the LZSS family, and then he sat down and rewrote one from the ground up in raw 8086 machine code. The result was LZEXE, the first executable compressor for the PC that anyone actually used. A program shrunk by it still ran, decompressing itself on the fly. Microsoft had shipped a cruder tool of the same idea, EXEPACK, with its linker since 1985, and Bellard borrowed its self-extraction trick, but it was LZEXE that spread across the early PC world, passed around on bulletin boards and floppies, shrinking the shareware of an entire generation. He had solved his floppy problem. He had also, incidentally, made a category of software famous.

Look at the shape of it, because the shape will repeat for thirty-five years. The machine states a constraint. The floppy is full. He does not argue with the constraint, and he does not buy his way around it. He goes down. Past the language, past the compiler, down to the bare 8086 instructions, to the place where the machine actually lives, and there, in its own words, he persuades it. The machine says no. He goes down.

An Amstrad PC1512, the machine whose 360-kilobyte floppies drove a seventeen-year-old to write LZEXE in raw 8086 code.

Then came the machine that makes French engineers: the École Polytechnique, the most prestigious of the grandes écoles, a school founded during the Revolution, run as a military academy, whose students still parade in uniform on Bastille Day. He entered in 1993, placing 76th among some six thousand candidates, and went on to Télécom Paris in 1996. The French system does not romanticize dropouts. It grinds its engineers through a curriculum of savage theoretical rigor, and what came out the other end was a man who thinks of computer science as a classical discipline, closer to physics than to product. Two student interviewers who reached him in 2009 came away with his view of what matters in the field: the study of how computers work and how to use them efficiently through languages, and the mathematical theory of computation itself. Not frameworks. Not markets. Not users. The machine, and the math.

Polytechniciens in bicorne and grand uniform at the Bastille Day parade. The school that forged Bellard still marches.

This is why there is no Bellard Inc. with a rooftop garden and a valuation. Silicon Valley builds companies. Bellard builds proofs. The right image is not a hacker but a surgeon, and not for the prestige of it but for the stillness. He does not hack. He operates.

IV. The Machine Inside the Machine

If FFmpeg is the eye and ear of the internet, what he did next became its skeleton.

In 2003 he released QEMU. Quick Emulator. Two words, one of them a joke.

QEMU. Run single-handedly through version 0.7.1, it became the device model beneath KVM and Xen. Logo by Benoît Canet.

Before QEMU, the idea of running a complete, unmodified operating system inside another one, ARM code on an Intel chip, belonged to expensive enterprise products and to academic interpreters so slow they were toys. Bellard wanted something free, generic, and fast. He ran it single-handedly through version 0.7.1 in 2005, the only committer, merging other people's patches by hand. Then he wrote a paper for the USENIX conference, "QEMU, a Fast and Portable Dynamic Translator."

It is worth slowing down for the paper, because this is where the mind is most visible.

When QEMU meets a piece of guest code, say an ARM instruction meant for a phone, it does not interpret it line by line. Instead it translates the code on the fly into the language of the host machine, the actual chip under the desk. The trick, in every version of the engine, is abstraction of a very particular, very Bellard kind.

The paper describes the first version. Each guest instruction was broken into micro-operations, and each micro-operation was written as a tiny C function, compiled ahead of time by GCC. A tool he called dyngen then harvested the machine code GCC had produced and stitched the pieces together at runtime, so that QEMU got a code generator for every host architecture without anyone having to write one. It was audacious and fragile, since it leaned on the internals of a compiler he did not control. In 2008 Bellard replaced it with the Tiny Code Generator, TCG, which had begun life as a generic backend for a C compiler of his own and was pared down for the job. TCG shatters guest instructions into TCG ops, a universal in-between language that belongs to no processor on earth, then converts those ops into native code for whatever host it happens to be running on.

Then the optimizations, layered like plate armor. Translated code is grouped into Translation Blocks, chunks bounded by jumps. When a block of guest code runs for the first time, the translator converts it and stashes the result in a cache. The cache is keyed not just on where the code lives but on the state of the virtual CPU, so that if the privilege level and the mode bits have not changed, the cached translation is reused instantly and the expensive translation step is skipped. And then the flourish: direct block chaining. Normally, when a translated block ends, the emulator has to climb back up to a central dispatch loop to figure out where to go next, and the climb costs time. QEMU does not climb. It patches the end of one executed block to jump straight into the beginning of the next, so that the guest code runs through the host like water through a pipe.

Look at what direct block chaining removes. It removes the trip home. Bellard cannot stand that moment. It is the technical form of an interruption, and his whole career can be read as a war against interruption: against the dispatcher, against the extra compiler pass, against the dependency, against the meeting. Here he had two machines talking through him, a guest and a host that had never been designed to understand each other, and his job was to make the conversation so fluent that neither one ever had to pause and look up.

QEMU became the device model beneath KVM, the Linux kernel's virtualization layer, and beneath Xen. And KVM and Xen became the beating heart of the open-source cloud, the hypervisors under OpenStack, Proxmox, and a thousand hosting companies. When one of those companies lights up a rack of virtual computers that do not physically exist, the device model that gives them their disks and network cards descends from an emulator one Frenchman wrote in 2003. And QEMU itself became the reference machine for nearly every kernel and embedded developer on earth, the computer you boot before the real one exists.

Racks in a dark server room. The device model beneath KVM and Xen, the hypervisors of the open-source cloud, descends from an emulator written in 2003.

Once again he built the cathedral. Once again he left.

The aftermath, as with FFmpeg, was handled by a small army. Bellard's own accelerator, KQEMU, still emulated kernel-mode code by default, and the KVM developers, moving faster than upstream would take their patches, forked the project into qemu-kvm and went their own way. It fell to maintainers like Anthony Liguori at IBM, and to engineers at Red Hat and Linaro, to steer the ship, heal the fork, and rebuild the project around maintainer subtrees rather than one man's absolute authority. QEMU has grown far past anything he wrote, but the pipe he laid in 2003 is still the pipe.

Consider what the men at IBM and Red Hat were doing. They were building a bureaucracy of committees and subtrees and review to maintain something created without any of it. He is the reason the bureaucracy exists, and he is the proof that it was never strictly necessary. Say it the way the moons never would: a bureaucracy is what a conversation with a machine turns into when you let people join it.

V. The Aesthetics of Constraint

There is a thing that happens to a programmer the first time they open one of Bellard's source files, and the closest analogy is opening a watch and finding no gears.

Modern software is a sprawl. A serious application spans thousands of files, dozens of dependencies, a build system that itself needs a build system. Nobody can hold a whole system in their head, the argument goes, so we chop it into pieces small enough to fit.

Bellard does not chop. He writes in pristine C, and he condenses enormous functional architectures into a handful of files, and sometimes into one. It is a portrait of how he thinks. He holds the whole system in his head, so he sees no reason to pay the tax of modularity. Keeping the code unified spares him the overhead of a build system and produces compilation speeds that border on instantaneous. One file, one voice, one machine on the other end. You split code into modules so that other people can work on it. He is not writing for other people.

The purest expression of this is the Tiny C Compiler. In 2001, Bellard won the Obfuscated C Code Contest with OTCC, a C compiler that could compile itself, whose entire source code came to 2,048 bytes by the contest's counting rules, about three kilobytes on disk. Smaller than this paragraph. He then grew OTCC into TCC, a complete, functioning C compiler for x86 and ARM so small it fits on a 1.44-megabyte floppy disk with room to spare.

1.44 megabytes. Enough room for a complete C compiler, if the compiler is TCC.

TCC is fast because it breaks the rules. A conventional compiler builds an abstract syntax tree and then makes pass after pass over it. TCC does none of that. It generates machine code in a single pass, compiling each statement on its own, managing registers and the stack in a straight line. The result is a compiler that compiles, assembles, and links roughly nine times faster than GCC, the industry standard, in Bellard's own benchmark of the day.

To prove the point, he built TCCBOOT. It is a boot loader that reads the source code of a pared-down Linux 2.4 kernel from disk, compiles it into memory, and boots the operating system. Bare metal to a running Linux, from source, in under fifteen seconds on a 2004 Pentium 4. It proved the compiler.

Fifteen seconds is the machine's reply. He asked the question in a few thousand lines of C, and the machine answered, and it answered fast, because he had removed everything that normally stands between the question and the answer. That is what speed means to him. Not throughput. Proximity.

Then, eighteen years later, the encore.

In July 2019, alongside a collaborator named Charlie Gordon, Bellard released QuickJS. JavaScript is the most widely deployed programming language on earth, and the engines that run it, Google's V8 chief among them, are colossal: millions of lines of C++, gigantic memory footprints, teams of hundreds. QuickJS is a complete engine for the modern ECMAScript standard, and it is a few C files. Zero external dependencies. It compiles to a binary of a few hundred kilobytes. It runs the full standard test suite in about two minutes on a single core.

The choices are pure Bellard. Values are small tagged structs, with an optional NaN-boxing mode on 32-bit builds, a trick that hides the type tag inside the unused bits of a floating-point number. Memory is managed with deterministic reference counting plus a cycle collector. There is a command-line compiler, qjsc, that takes JavaScript source and produces a standalone executable. There is a page on the website, plain as ever, that explains all of it.

When QuickJS landed on Hacker News, the thread ran long into the night. Engineers opened the source and found the core interpreter in a single file of roughly a megabyte and a half, and found it, to their evident surprise, readable. The comments have the tone of pilgrims who have walked a long way to see a relic and found the relic has a pulse.

It is not admiration. It is grief. It is a whole profession looking at a single man's work and quietly asking itself what it has been doing with its time. What it has been doing is talking to each other. The thread itself is the proof: hundreds of people discussing, at length, a file that one person wrote in silence.

JavaScript on a screen. QuickJS runs essentially the entire modern language standard from a few C files with no dependencies.

VI. The Number

And now the number, where the pattern becomes obsession.

In 1997, Bellard was twenty-four and a student at Télécom Paris, and he found a new formula for pi.

Two years earlier, a formula discovered by Bailey, Borwein, and Plouffe had stunned the mathematical world. The BBP formula let you compute the nth hexadecimal digit of pi without computing any of the digits before it, an act that had seemed for centuries like reaching into a river and pulling out the ten-thousandth drop. Bellard took it apart and derived a variant that was about 43 percent faster. Forty-three percent, in a field where a two percent improvement is a career. Bellard's formula became the workhorse of the PiHex distributed computing project, which used it to compute the quadrillionth bit of pi, and it became the standard method by which supercomputer teams verify the last digits of their monster calculations.

Most people would have stopped there, thrilled to have their name on a formula. Bellard, twelve years later, went for the record itself.

By 2009 the race for total decimal digits of pi belonged exclusively to supercomputers. The record was held by a machine in Japan, the T2K supercomputer at Tsukuba, which had chewed through nearly 2.6 trillion digits in 29 hours on 640 nodes and more than two thousand processors, with a budget that no individual could contemplate. Bellard's plan was to beat it with a desktop PC.

He did not have the memory. The answer alone was more than a terabyte long, the working set of the computation ran to six times that, and he had six gigabytes of RAM, about a hundred and seventy times too little. So he traded. He wrote his own arbitrary-precision arithmetic to keep the numbers on a stack of five ordinary hard disks and to keep the disk traffic to a minimum, evaluated the Chudnovsky series by binary splitting with a set of mathematical tricks to cut the constant factor, and paid for the whole arrangement in time. Then he pointed a single quad-core consumer processor at the problem, a Core i7, and he let it run.

It ran for 131 days. One hundred and thirty-one days of a machine humming in a room, and this is the longest single conversation of his that we know of. From late summer into the dead of winter he could not see the answer. He could see only the machine working: the disk lights, the fan, the slow accrual of intermediate terms. He had phrased the question with exquisite care, and now he had to trust the machine to carry it, and the machine had to trust that he had not made a mistake in the asking, because if he had, 131 days were gone and there would be no one to blame. Nobody else was in it. Nobody else could be. The computation of the binary digits took 103 of those days. The rest went to checking them with a separate formula and converting them to decimal, the checking done on a borrowed network of nine office PCs over a long weekend. On December 31, 2009, it stopped. Two trillion, six hundred ninety-nine billion, nine hundred ninety-nine million, nine hundred ninety thousand decimal digits of pi. A new world record, set by a machine that cost less than a used car.

Here is the Bellard signature, visible in the record the way a brushstroke is visible in a painting. He did not win by force. He won by understanding the problem so completely that he could reshape it to fit the hardware he had. He took a problem that demanded a data center and folded it, like a map, until it fit in a desktop.

The record stood until August 2010, when a pair of researchers took it back with five trillion digits, and Bellard, so far as anyone can tell, did not lose a moment's sleep. He had not been chasing the number. He had been chasing the folding.

VII. The Trick in the Browser, the Tower in the Box

Every few years Bellard performs a certain kind of demonstration. He picks a thing everyone knows to be impossible. He does it. He posts the link. Then the arguments begin about whether it is real.

In May 2011, the link was JSLinux. It was a complete PC emulator, a 32-bit x86 processor with its interrupt controller and its timer and its serial port, written entirely in JavaScript, running entirely in a web browser, booting a real Linux kernel to a real shell prompt. You clicked the link, and the browser became a computer inside a computer, and kernel messages flew by and there was a prompt, blinking.

The first reaction of many engineers was doubt. One blogger felt obliged to test it and report that it was "a real x86 emulator written in JavaScript and running Linux, not a fake Linux terminal." It was not a fake. It was a forecast. JSLinux proved that browsers had become capable of acting as true virtual machines, and in doing so it predicted the whole subsequent decade: WebAssembly, the migration of desktop-class applications into the tab.

There is a purer reading, and it is the one his life suggests. A browser is the loudest room on the internet, all advertising and tracking and autoplay and chatter. He walked into it and built a quiet room inside it: a black screen, a blinking prompt, a machine waiting to be spoken to. He took the noisiest thing on earth and made it into the place he is most at home.

A Linux kernel booting inside QEMU. In 2011 Bellard did the same thing inside a browser tab, in pure JavaScript, and people had to check that it was real.

The following year, in 2012, the ghost did something almost unimaginable for a ghost. He went into business.

He co-founded a company called Amarisoft with a partner, Franck Spinelli, and took the title of chief technology officer. The cellular industry is among the most hardware-bound and proprietary on earth. A cell tower's base station is a rack of dedicated, expensive, purpose-built electronics. Upgrading a network from one generation to the next has historically meant ripping out steel and replacing it with new steel.

Bellard wrote a 4G LTE base station in software. Under him it grew into a 5G NR one. The entire physical layer and protocol stack, the real-time signal processing that turns electromagnetic waves into packets, all of it in software, in real time, on the same kind of hardware that runs a spreadsheet, with a low-cost software-defined radio bolted to the front end to handle the antenna. The cost and complexity of standing up a cellular network fell dramatically. The same PC and the same radio could be turned from a 4G base station into a 5G one by changing the software. Today its code runs in test labs, in private networks, and in the harnesses phone makers use to prove their handsets before they ship.

It is the same thing at a new scale. He had extended the conversation past the machine, to the air itself. Radio does not speak in bytes. It speaks in phase and frequency and interference, in microseconds, and it does not wait for you. He wrote software fast enough to answer it in real time on a general-purpose chip, which the telecommunications industry had spent decades building special hardware to avoid. The same man who once persuaded a full floppy was now persuading the electromagnetic spectrum, and using the same grammar to do it.

A bare software-defined radio board. Bolt one of these to an ordinary PC running Amarisoft's code and you have a cellular base station.

Consider what this means in the orbit. The orbit had grown used to Bellard building things for free and giving them away. And then he built one of the most technically brutal pieces of software in telecommunications and, for once, kept it. Even the exception proves the rule: no Silicon Valley, no war chest, no keynote. He wrote the base station and quietly became the technical heart of a company that most of the world has never heard of, because the world does not read the names on the equipment in its telephone labs.

The tower is steel and antennas. Increasingly, the base station behind it is just software.

VIII. Compression, Again

Bellard's subject is compression. He has been trying to make the world smaller since he was seventeen and out of room on a floppy.

It is also, if you take the theme of his life seriously, the purest form of what he does. Compression is the art of removing noise from a signal without losing the signal. Everything a compressor throws away, it throws away because it was not carrying information. That is what he does to a codec, a compiler, a website, and his own public existence. Compression is not one of his subjects. It is the subject, and the rest are instances.

In 2014 he made a run at the most entrenched format on the internet. JPEG had been the standard for photographs since 1992, and it was decades behind the state of the art. Bellard took the intra-frame coding from the HEVC video standard, the piece that compresses a single frame, and wrapped it into an image format he called BPG, Better Portable Graphics. Dramatically smaller files at the same quality, or dramatically better quality at the same size. It did not win. HEVC was entangled in patents, and the patent problem strangled BPG in the crib. But the shape of the idea, a still image format built from a video codec's keyframes, was so obviously right that the industry followed it: AVIF, the patent-free format built from the AV1 video codec that now ships in every major browser, is the same idea with a different codec inside. He lost the battle. The idea won the war.

Then the industry caught artificial-intelligence fever, and Bellard waited, as he always does when a field becomes a stampede. He watched the giants pour gigawatts into data centers the size of towns, and he asked the Bellard question, which is always the same question: what is the efficient version of this?

The answers arrived, as always, as plain links on a plain page. TextSynth Server, a REST API for running large language models locally, for text completion, translation, classification. And then, inevitably, he turned the new tools on his oldest obsession. In January 2021 his neural-network compressor, NNCP, took first place on the Large Text Compression Benchmark, the contest to squeeze a gigabyte of Wikipedia as small as it will go. It held the top for years. In 2023 he released ts_zip, a text compressor that uses a language model to predict the next token and an arithmetic coder to write down only the surprise. And in 2024 TSAC, an audio codec that compresses mono sound to 5.5 kilobits per second at a sample rate of 44.1 kilohertz while keeping it listenable. Five and a half kilobits. A modem from 1985 could not have kept up with it.

The through-line from a seventeen-year-old rewriting LZSS in 8086 assembly on an Amstrad to a fifty-one-year-old bending a neural network into a compressor is so straight it looks drawn with a ruler. He has been asking one question for nearly four decades. How small can this be? The tools changed. The question did not. Neither did the room.

IX. The Moons Speak

Assemble the orbit and listen to it. Then notice that every voice you are hearing comes from outside the room.

Listen to the FFmpeg maintainers, two decades deep in a codebase they did not write, who talk about the founding code the way a cathedral's caretakers talk about the masons: nobody alive could have built this, and nobody can quite figure out how it stands.

Listen to the QEMU engineers at IBM and Red Hat, building committees to steward a thing that was born without one.

Listen to the Hacker News threads at two in the morning, where people who write software for a living open the QuickJS source and go quiet, and then, after a while, start typing that the whole core is a single file, and that it is, of all things, readable.

Listen to the supercomputer teams who verify their pi records using his formula, checking their monster machines against the arithmetic of a man with a desktop.

Listen to the phone makers who test their handsets against a cell tower that lives in a PC.

And listen to Carmack. John Carmack, who wrote the engines that made 3D gaming exist, who has never been accused of false modesty in his life, saying: he is almost certainly a better overall programmer than I am. He is not being polite. He is describing a different species. He is telling you that the thing you thought was the ceiling was a floor.

There is a comment in one of the threads that the orbit keeps returning to. A developer was trying to distill the whole body of work into a philosophy, and what he came up with was almost embarrassingly simple:

Things should be good. They are not so good. I can learn to make them better. And then, more broadly: You can just do things.

It lands like a slap because the modern software industry is built on the opposite premise. The industry runs on learned helplessness. Developers rely on abstractions they did not write and do not understand. They conclude, reasonably, that fixing anything fundamental is the province of massive teams and enormous budgets. The very idea of the "10x engineer" is argued over as a toxic myth.

And there, on a plain white page, is the counter-argument. Not an argument. An existence proof.

He does not build apps that chase user whims. He identifies a deep, mathematical, architectural bottleneck in the machinery of the world. He withdraws. He writes a complete program, grounded in real computer science, with minimal dependencies, in immaculate C. He posts it. Then the trillion-dollar empires of the earth build themselves on top of it, and he asks for nothing.

Not a share of YouTube. Not a board seat at Amazon. Not a keynote, a podcast, a foundation with his name on the door. He simply notices that the infrastructure of the world is inefficient, and he rewrites it, and he moves on to the next thing.

The moons are loud. That is what moons are for. Listen through them, past the mailing lists and the forks and the record books and the famous man's tribute, and there is one sound underneath all of it. It is a fan in a room at night. And under that, at a frequency you cannot pick up from here, a man and a machine, talking.

X. The Silence

Most famous men have a silence that stops things. Bellard's silence moves the other way. It does not seize the machine. It is the machine. Nothing that does not need to be there. He does not need to be there. The code is there. And it dawns on you, late, that the silence was never the absence of a conversation. It is the sound of one in progress, with someone else. He has been talking the entire time. It was just never to us.

Tonight, somewhere, a teenager will upload a video, and it will be transcoded in the dark by a codec library begun under a false name in the year 2000. A phone will be certified on a tower that is a PC. A supercomputer team will check a record against a formula found by a twenty-four-year-old in 1997. A file will be made smaller. None of them will know his name. That is not a tragedy. It is the design. We are living inside the architecture of one man's mind, and the man is not home.

So where is he? What is he whispering to the machine now?

He will not say. But the plain white page was last touched in March 2026, and its newest links all point one way. His language-model server now ships with quantization of his own design that packs a seventy-billion-parameter model from 141 gigabytes into 39, and his benchmarks are not for the racks the giants buy by the hectare. They are for a used RTX 3090 and, tellingly, for a six-core CPU with no graphics card at all. Beneath it sits his own tensor library, in C, with no dependencies. Read that the way you would read the LZEXE story, or the pi record. The industry has decided that intelligence lives in data centers, behind memory that costs more per gigabyte than gold. The machine on the desk has a handful of cores and a stick of ordinary RAM. That is the constraint. That is the 360-kilobyte floppy, the six gigabytes against a terabyte of pi.

This is a bet, not a report. But if you had to wager on the next impossible thing to appear on that page, wager on this: a serious model at conversational speed on a computer no one would call serious, with no GPU and no exotic memory, folded to fit the way he folded the number. Because the machine said no, and he has never once in forty years let that be the last word.

He is at the desk. It is late, or it is early; the machine does not know the difference and has never asked. The fans are humming. Hnnnnnnnnnn. No one else is in the room, and no one else was ever meant to be. The machine states a constraint. He goes down to meet it. He is folding the next impossible thing until it fits.

Sources

Bellard did not participate in this profile. It draws on:

• Bellard's own project pages at bellard.org, including his technical notes and FAQ on the 2009 pi computation and his LZEXE, TCC, TCCBOOT, QuickJS, JSLinux, LTE, BPG, NNCP, ts_zip, ts_sms, TSAC, LibNC, and TextSynth Server pages, as of the site's March 9, 2026 update.
• Fabrice Bellard, "QEMU, a Fast and Portable Dynamic Translator," USENIX Annual Technical Conference, FREENIX track, 2005.
• The QEMU project's documentation, changelog, and source history; LWN's history of the KVM and Xen forks.
• The FFmpeg project's history and documentation, and Kostya Shishkov's "FFhistory" series at codecs.multimedia.cx, winter 2022 to 2023.
• Joe Barr, "MPlayer: The project from hell," LinuxWorld, December 2001, and Reynaldo Verdejo's 2015 retrospective "FFmpeg: A Retrospective."
• Gocke and Pizzolato, "Fabrice Bellard," student biography based on their 2009 interview.
• Maki et al., "The Mars 2020 Engineering Cameras and Microphone on the Perseverance Rover," Space Science Reviews, 2020.
• Daisuke Takahashi's 2009 T2K Tsukuba pi record page, and numberworld.org on the August 2010 record by Shigeru Kondo and Alexander Yee.
• Matt Mahoney's Large Text Compression Benchmark.
• John Carmack's post of June 2026 and the Hacker News discussions of it and of Bellard's releases, including the comments quoted here.
• Amarisoft's company and product pages.
• Wikipedia entries for Fabrice Bellard (English and French), FFmpeg, QEMU, the Tiny C Compiler, QuickJS, Bellard's formula, Better Portable Graphics, and the TI-59.

Image credits

All images are free-licensed or public domain and were resized to fit within 1600 pixels on the long axis.

• Hero image: original illustration rendered for this article from the digits of pi and fragments of C; no photograph of Bellard was available.
• Pi digits visualization: fdecomite, via Flickr and Wikimedia Commons, CC BY 2.0.
• FFmpeg logo: public domain wordmark, vectorized by Vulphere after Hervé Flores, via Wikimedia Commons. FFmpeg may be a trademark of its project.
• Perseverance selfie at Rochette: NASA/JPL-Caltech/MSSS, public domain.
• Akai reel-to-reel tape recorder: Sameer Verma, via Flickr and Wikimedia Commons, CC BY-SA 2.0.
• TI-59 programmable calculator: Pittigrilli, Wikimedia Commons, CC BY-SA 4.0.
• Amstrad PC1512: Marcin Wichary, via Flickr and Wikimedia Commons, CC BY 2.0.
• École Polytechnique at the 14 July parade: École polytechnique / J. Barande, via Flickr and Wikimedia Commons, CC BY-SA 2.0.
• QEMU logo: Benoît Canet, CC BY 3.0, via Wikimedia Commons.
• Server racks: NOIRLab/NSF/AURA/T. Slovinský, CC BY 4.0, via Wikimedia Commons.
• 3.5-inch floppy disk: VSchagow, CC BY-SA 4.0, via Wikimedia Commons.
• Code on a monitor: Markus Spiske, CC0, via Unsplash and Wikimedia Commons.
• Linux booting under QEMU: Scientus, public domain, via Wikimedia Commons.
• HackRF One software-defined radio board: wdwd, CC BY-SA 4.0, via Wikimedia Commons.
• Cell tower: Justin Smith, CC BY-SA 2.5, via Wikimedia Commons.