A shareware text editor, a 30-hour binge, and a five-year war with Apple

Tim Sweeney’s older brother Steve, sixteen years his senior, had gone west to work for a tech company and bought one of the first IBM PCs. At about eleven, Sweeney spent a summer in California, learned BASIC in a few days, and was, as he tells Lex Fridman, “hooked from that point onward.” He still remembers every early program more clearly than people’s names. The first game, on an Apple II, was text-mode only: asterisks drifting left to right, a parenthesis on the right like a baseball mitt. It took a couple of hours.

He built databases, a Pascal-like language and a full compiler because he did not know where you went to buy one, and bulletin-board software that had to handle data, a user interface, and several callers at once. Every town had hundreds of those boards, each with its own sysop and personality. Between ages ten and twenty he estimates 10,000 to 15,000 hours of code, all of it before he shipped anything to strangers. The hours, he insists, are not the point. What mattered was moving from project to project, learning what he knew and what he lacked, until that stock of hobby knowledge became the first Unreal Engine.

He studied mechanical engineering at the University of Maryland, a party school in some departments that “worked the engineers to death.” Vector calculus, matrices, physics, stress and strain — none of it announced how an engineer would actually use it. Writing Unreal’s 3D math, he had a *Karate Kid* moment: paint the fence, wax the car, and suddenly the pieces were a 3D engine. Years later he flipped through an old textbook ticking off chapters he had used, until eigenvalues, which he did not recognize. Those, he notes, were the breakthrough behind Google Search: dump the web’s links into a giant matrix, find the dominant eigenvector, and you have a ranking.

University, in his view, is not for the diploma. Grades are the school’s bookkeeping; what you can actually do is what startups hire. He also mourns a disappearing American childhood. His mother fed him breakfast, the neighbors’ mothers did the same, and the instruction was “be back by dark.” Kids explored woods, built go-karts, and salvaged electronics into fake spacecraft panels. Some wasted the time on television. Some built real projects. He worries that a more sheltered, structured culture is squeezing that free interval out of the country.

Sweeney’s real ambition, he says, has always been to program cool things; coding is more fun than anything else. Two games formed him: Atari 2600 *Adventure*, a dot on the screen picking up swords and invading castles, and the text adventure *Zork*, which had no graphics and still built an elaborate picture in the mind. Playing them taught him to move a character, parse “go north” and “pick up sword,” and — this is the principle that stuck — separate the tools that build a world from the game that runs it. Until Fortnite, he mostly played to reverse-engineer. When Wolfenstein 3D and Doom arrived he studied them pixel by pixel, nudging the mouse to see what changed. It was, he says, puzzle-solving at grand scale.

Epic Games began in 1991 with ZZT, and ZZT did not begin as a game. Sweeney had just moved from Apple II to an IBM PC and needed a text editor, so he wrote one. One night the finished editor looked boring, so he turned the cursor into a smiley face and gave characters in the document gameplay jobs: walls, killers, things that flew. About twenty or thirty object types felt like enough for a compelling game and few enough that players would not lose track. He invited neighbors of every age, sat them down, and forced himself not to explain. The notes from those sessions — what they stuck on, enjoyed, or found dull — were user-experience research before the field had the name.

He uploaded the first episode to local bulletin boards as shareware, asked for $30 for the two sequels, and printed his parents’ mailing address. Checks arrived within days: three or four orders a day, about $100, which felt like wealth to a twenty-year-old. A month later the orders were international. Money, he says, was always a tool for funding cool work; the shock was that a kid on a local board was doing business with the world. Software could spread in a way a mechanical device never could. He also shipped the editor and a little scripting language with the game. Thirty years later, adults still stop him at industry events to say they grew up in ZZT. That dual mission — entertainment and tools, shared so other people can build — is, he argues, why Epic survived every downturn: when games were dry, the engine funded the company, and the other way around.

Advice for indies, from that 1990s mindset: do not try to beat Electronic Arts or Activision at their own genre. Shareware was Epic’s unfair angle, a free first episode that later looked like free-to-play. Minimize the friction of getting in. Compete where nobody else is standing; *Minecraft*, *Roblox*, and Fortnite Creative all repeated the pattern of a game that becomes a platform. The one-shot leap from idea to global hit is, he thinks, much less likely than a multi-step climb. It was not lonely. Neighborhood kids laughing at the screen, and later letters from parents, were the thing that made him go all-in. Capital was a few thousand dollars of computers bought by mowing lawns.

By the early 1990s Epic was matchmaking young talent across oceans: Cliff Bleszinski, a California high-schooler, with Dutch demo coder Arjan Brussee and musician Robert Allen, shipping 2D shareware such as *Jazz Jackrabbit* while the kids were still in school. Wolfenstein 3D, running at 30 frames per second, made the company realize the future was 3D. Doom, which followed shockingly fast, was the real blow. Sweeney was depressed. The wizardry was so complete he gave up programming for about six months. Carmack had not made one leap; he had made a dozen at once, interlocking so you could not pick them apart.

The thaw was Michael Abrash. The veteran graphics programmer published a book and magazine articles with assembly for texture mapping, and Sweeney thought: *oh, I can do that*. Several people at Epic independently started writing 3D code. They pulled the best 2D people into a 3D team that had never shipped a 3D game. Sweeney volunteered for the editor. James Schmalz, who had written *Epic Pinball* in college — $30,000 a month in royalties, 30,000 lines of assembly — was supposed to write the engine. He sent the pile of assembly over. Sweeney looked at it and decided to write the engine himself. Schmalz moved to models and animation; Bleszinski became customer number one for the editor.

At the peak of *Unreal*, about twenty people were on the project, a huge team for the time, stretching Epic’s finances to the breaking point. Development lasted three and a half years on a game they always thought was six months from shipping, most of them working 70 to 80 hour weeks, so buried in the current problem they did not know what the next one would be. Sweeney was sure they could solve the technical and art problems; money was the constant fear. Mark Rein ran the business, maxing out credit cards to keep revenue coming. The team compiled several times a day. Iteration speed, Sweeney says, is the critical variable in games: a weekly build loses to a daily one by a huge margin by the end of a project.

He had grown up on Pascal, moved to C for *Jill of the Jungle*, started Unreal on 16-bit Windows, then spent most of the project in C++ on 32-bit protected mode. C++ simplified a complicated pile of code and, for all its manual pain, still solves problems at scale. For maximum output he stopped being cheap about hardware: a 24-inch CRT that weighed about a hundred pounds, 1920 by 1200 in 1996, then a $7,000 Dell with a Pentium Pro, a gigabyte of RAM, and a 200 MHz CPU that tripled compile speed. On a 90 MHz Pentium he had gotten software texture mapping down to six CPU cycles, eleven instructions, per pixel — a lost art, he says, now that out-of-order chips make instruction-by-instruction control impossible. The art still lives on GPUs and ASICs. Nanite, years later, would be that kind of multi-year, high-to-low optimization again.

Unreal Engine went further than Quake in one respect that artists felt immediately: constructive solid geometry in a real-time editor. Additive-only worlds are tedious; a door means a dozen pieces of frame and wall, all aligned. Subtracting a door from a wall is the natural operation. Sweeney had believed it was possible for a long time. When he finally sat down, a 30-hour session closed the special cases. The next day he handed James Schmalz a demo: a giant torus, another interlocking torus, a cylinder subtracted, a complex composite in three operations. Schmalz accused him of cheating. It was, Sweeney thinks, probably the first real-time CSG anyone had shipped.

He has a theory about the binge. Brains have more horsepower than you can reach by asking what line to type next. After long enough, sleep deprivation damages short-term memory, so you lose easy recall of the code you just wrote and the rest of the mind is free to work other problems. The foundation was the binary space partitioning tree, a structure from graphics researcher Bruce Naylor that Carmack had used to great effect in Doom. With a BSP tree, Sweeney thought, CSG could be efficient. He broke geometry combinations into about fourteen cases, most of them simple. Coplanar polygons — same plane, same direction or opposite, keep or kill — were the hard remainder, solved by deduction and some trial and error. Writing software that is 99 percent correct is easy. The last one percent is where the devil lives.

Lighting is the same joke: the laws of physics are known, so doing it right is easy and doing it fast is the whole field. Brute-force photon tracing is millions or billions of times too slow. A six-cycle texture mapper could not afford thirty more cycles of lighting per pixel. Carmack’s answer in Quake was lightmapping: compute a lighting value every foot of wall, then interpolate, like wallpaper. Unreal added colored lights. Because the expensive work ran per foot, not per pixel, they had hundreds of cycles to spend on torch flicker, water caustics, pulsing and blinking, and a compositor for an arbitrary number of sources. A real-time shadow ray-tracer ran at half a frame per second. Sweeney ran around in it, firing light projectiles, thinking computers would be fast enough someday. The practical trick: precompute shadows for a still light, keep the lighting dynamic, and flickering torches with shadows become possible. Artists found drop-downs of new options every day and did combinations he had never imagined.

Volumetric fog began with a screenshot from a Finnish graphics-hardware startup: a foggy room, lights glowing in the mist with distance falloff, like street lamps on a foggy night. Sweeney assumed they had real-time volumetric fog and gave himself another 30 hours. Light falls with the inverse square of distance, Newton’s law; the fog interaction is a line integral along the ray from eye to surface, accumulating illuminated mist. He had studied that in mechanical engineering without knowing why. The integral of the transformed one-over-r-squared is the arctangent of r. Per pixel it would have been hundreds of cycles, so they computed fog every square meter, like a light map, and handed it to artists. Decades later he told an engineer from that company the screenshot had inspired him. The engineer said they had cheated: it was a 3D Studio Max render. What Sweeney admires in Carmack is the same refusal to keep old code. Legendary results were the seventh or eighth try. When performance, quality, or capability is truly load-bearing, iterate until it is right. Do not settle for the first solution that works.

Nobody thirty years ago, Sweeney says, expected the hardware curve they actually got: something like 100,000 times more CPU performance from cores, clocks, and parallelism. In aviation, that would be a trip to neighboring stars. Graphics is more extreme still — about ten million times more usable GPU performance than a Pentium 90. Rendering has kept up. Almost every Unreal generation replaced most of the renderer. Unreal Engine 1 was software, with late Voodoo 1 support. Engine 2 rode early GPU acceleration. DirectX 9 and programmable shaders were a godsend: GPU pixel code about a hundred times faster than the Pentium 90 work of a few years earlier. Andrew Scheidecker built Unreal Engine 3 around real-time pixel shading, dynamic shadows, and a multithreaded renderer for early dual-core chips. Engine 4 piled on artist options. Engine 5’s leap was Nanite micro-polygon geometry and Lumen global illumination, which Sweeney thinks bridged “game-ish” graphics to photorealism for artists who wanted it.

Other subsystems have barely moved since the 1998 ship. The file manager has been optimized without being rethought. Networking — how clients and servers negotiate game state — is still an evolution of what Sweeney wrote, and it shows: spectator bugs in Fortnite where some parameters do not update are the lossy nature of that model. The heaviest historical burden is single-threaded game simulation. On a 16-core CPU, gameplay uses one core. Multithreading is orders of magnitude harder, and they would not put that foot-gun in the hands of partners or the community. The limitation hurts more every year. Unreal Engine 6, he says, is the generation that will put those core limits on a foundation the modern world deserves.

Art tools now make scenes with billions of polygons. You cannot draw billions per frame. The aim is an image indistinguishable from full-detail geometry, at real-time cost. Nyquist sampling says that to reconstruct a signal you never need more than twice the samples you will display; two triangles per pixel should look like thousands, and fewer than two starts to show. GPU triangle rasterizers are built for fairly large triangles. Ten pixels is efficient; one pixel is not. Brian Karis’s breakthrough in Nanite was an entire pipeline that skips the rasterizer, goes to pixels, and decides what a pixel should be via ray-geometry tests in a pixel shader. Close-up detail needs tiny triangles; the hardware that draws big ones is the wrong tool. The other enemy is popping — a visible jump when triangle density changes, as if the screen were shaken. Nanite’s trade-off was to push those transitions down until they exist statistically and a person does not perceive them.

Fridman cues up Epic’s GDC 2024 work for *Marvel 1943*: Nazi-occupied France in winter, snow, and dirt so detailed it looks like infinite resolution. Sweeney’s first credit is not Epic. The heroes of that image are the artists and technical artists; the reason they showed it is that it went “way, way beyond” what the team thought the systems could do. Lumen, Daniel Wright’s decade of lighting work, was once a controversial claim: enough levels of calculation, from building-scale shadows down to dirt, can make global illumination work everywhere without visible boundaries. The fine ice-and-dirt contact shadows are screen-space — computed from pixels, not world coordinates — because that is the only way to run them fast enough in a pixel shader. Sweeney’s first reaction was that it was clever and would not work. It does, as an approximation the eye accepts. A novice building the same scene would not get this result. Making that quality easier and more automatic is, he says, still ahead.

First-generation engines lit what a light hit and left the rest black. Real light bounces: a red wall throws red onto a white floor. The complete solution was written down in the 1950s; Lumen’s trick is to compute bounces from kilometers down to millimeters and integrate the levels so they look seamless. Place lights in a Nanite scene, Sweeney says, and it just works. Reflections, layered dirt and snow, fog an artist added rather than a simulation, a burning trash can whose smoke occludes light and no longer “looked like a video game” — all of it is real-time, on about 20 teraflops where a 90 MHz Pentium was 90 megaflops. He is careful to say the particle system and physics are the foundation, and artist sophistication is a very large part of why this fire finally looks like a fire.

Humans are the hardest object in computer graphics because evolution gave us dedicated machinery for faces. A caveman meeting a stranger had to decide, instantly, friend or killer. People notice imperfections, especially the ones that come from graphics limits. MetaHumans is a decade-plus effort led by Vlad Mastilovic, who joined with the 3Lateral team. Capture means a sphere of dozens of cameras, a few hours on the person, then thousands of hours of processing: not only the shape of a face but the full range of muscle, sinew, and fat. The more interesting goal is thousands of faces across cultures, continents, ages, and types, so the system can reconstruct a face it has never seen — even from an iPhone photo — by combining known human detail rather than inventing it on the device.

Hair is easy in physics and a billion times too slow to render strand by strand. Skin is not a solid. Light travels through it; subsurface scattering is a huge part of why a painted mannequin never looks human. Get any one of dozens of systems wrong, Sweeney says, and the eye goes straight there, onto the wrong side of the uncanny valley. Architecture that is slightly off is forgiven. A face that is slightly off is jarring. MetaHuman Creator exposes parameters for a unique face; MetaHuman Animator retargets iPhone-class capture onto a different head shape, a translation that is “really sophisticated and non-obvious.” Direct copy from actor to character would look completely wrong. This is year thirty of a project that may take fifty to reach full photorealism and control. They have given artists a productivity and quality multiplier. They do not consider the problem solved.

Outside games, Unreal Engine has become a film tool. Fridman notes that the short *Wars is Over*, made with the engine, won an Oscar. Hollywood’s big shift, Sweeney says, is off green screen and onto LED volumes driven in real time. Old composites give themselves away because lighting on the actors is wrong. In front of LED panels the performer is lit by the virtual scene and can see the set, so acting and lighting both improve. Cost is the limit in every one of these businesses; anything that makes the job easier is power.

He thinks the industry is overly optimistic about AI video. Still images can be stunning; video has consistency problems going from place to place, and he does not think those will just be patched. AI has nothing like an understanding of the whole scene, the plot arc, or the surrounding world. Game engines already have that representation. The future he wants is not human creatives made obsolete. It is AI as a multiplier — closer to Fridman’s VR interview with Mark Zuckerberg, where captured faces were rendered in 3D and then patched by an AI enhancer for missing subtleties. Epic’s Quixel team scanned tens of thousands of real objects; Fab has the library. What it lacks is the ability to mint arbitrary new trees from that knowledge, to spec.

Two world models are colliding. The scene graph is a precise list of every object and its data, reproducible from any camera, the same if you play it ten times. It is expensive and manual. The other model is what AI “thinks”: vast knowledge in a mushy, human-incomprehensible form, queryable by prompt, almost impossible to art-direct. Change the prompt slightly and the image can become something else entirely. Connect them — let AI help build the scene, and let the scene graph be visible to the AI as a list of objects and properties — and you might get stable scenes, higher productivity, and art direction that sticks. Job fear is real, he says, but it rhymes with synthesizers that were once barred from music awards and Photoshop that was once “not art.” Alienation comes from a prompt that will give you an entire work and then refuse to turn one object green. That feels like a competitor. Nuanced control would feel like another Photoshop tool.

On code, he is cooler. AI is good at emitting things a million GitHub repos already do. It is notoriously bad at something new and hard. The more code you ask for, the more you get a heap that “sort of works.” Getting the last 1 percent to 100 percent with AI may be harder than writing it. Anyone serious should try assistants on hard problems, not demos. Boilerplate itself, he adds, is a failure of languages and modules: ask an AI for a sort and you now have another possibly buggy sort beside a million others. Better to have one written, tested, optimized, and shared. As for simulating reality, non-human scenes — a jungle, a city, the lighting — may be only a few years from shocking closeness. Humans, dialogue, and intent are a much higher bar, and that will dominate the next decade. Ten years ago he said that even infinite compute could not simulate people, because nobody had the algorithms. That is no longer quite true: generative text already does a pretty good job of a person at the level of words. He is not saying it is a good idea. He thinks the arc is heading there at a shocking rate, in our lifetimes, certainly in less than twenty years. Epic does not aspire to worlds people refuse to leave. Fun between work and the rest of life is the job. Fridman argues that a simulated human who can suffer should be illegal. Sweeney’s reply is that game developers have generally been good-spirited — the worst popular example is robbing a bank in GTA, clearly fiction — and that harder questions will have to be answered as humans get more real.

Sweeney’s metaverse is not a stock ticker. It is multiplayer social play in a 3D world with your actual friends. Fortnite Battle Royale captures that essence, especially after Sony agreed that every platform could play and voice-chat together. Rec Room in VR is another flavor. Six to eight hundred million people a month already play games of that kind. VR is optional hardware; NFTs are just one way to mark value. Interoperability is the requirement, and it can live in a blockchain, a database, or a standards body. Railroads were standardized centuries ago.

Fortnite itself began humbly. In 2011, finishing a *Gears of War*, Epic gave the whole company a week to form teams and build something in Unreal. One team made the first Fortnite: build forts by day, defend against zombies by night, more elaborate the longer you lasted. Building was always fun; the rest pivoted for years, including a move from a more realistic look to the current Pixar-like style. The same artists who had done *Gears* could work stylized, and a long-lived mainstream game, they thought, should not feel like pixel-hunting a *Call of Duty* scope in the dark. It drifted through a Destiny-like light MMO and a tower-defense persistence mode that shipped in early 2017 as Save the World: a moderate success, budget recouped, slightly ahead.

Then the battle-royale genre exploded. PUBG was out; Epic people were playing it and saying it would be cool with Fortnite building. About thirty people were put in a war room. Four weeks later, Battle Royale shipped. Seven years of content was already there; the gameplay and systems were not. Epic went from about 300 employees to thousands, from on the order of $100 million in revenue to billions, and became, for a time, the center of the gaming world. Fortnite now makes billions a year, the majority of Epic’s revenue beside Unreal licensing, *Rocket League*, *Fall Guys*, and Fab. The company has spent more than it makes — for a stretch more than a billion a year extra, then painful layoffs, now several hundred million extra, affordable because of cash and investment. They can start a project that will not pay for three, four, five years.

The technical miracle was older than the mode. Since 2012 Epic had been building scalable backends for accounts, login, and multiplayer. In a year of intense work the online team took concurrent users from about 40,000 to 15 million. Architecture is microservices: game servers running 100-player sessions, many account-server instances on a shared database, hundreds of services talking to one another. Scaling is finding bottlenecks and giving each hop horizontal room and redundancy. Epic reached 15 million concurrent users without buying server hardware. One week Brazil ran out of machines on a heavy weekend; the next, heavier week, the machines were there. Someone at Amazon, Sweeney says, had drop-shipped millions of dollars of servers just in time. There are a lot of unsung heroes in that story, many of whom Epic has never heard of.

Sweeney starts the economics lecture where Fridman least expects: “the present of gaming and why it sucks.” Fortnite has on the order of 100 million monthly actives, your friends, a hundred thousand islands, and a seamless hop from experience to experience. Want Roblox? Quit Fortnite, launch another app, another friend list, another username, relearn the stick. Cosmetics you bought in Fortnite vanish. *Call of Duty*, *World of Warcraft*, *League of Legends* are the same isolation. Consoles tried to fix it with platform-wide friends, but a PlayStation friend is invisible on Xbox. Two orthogonal fiefdoms — platforms and games — were not built in malice. They are a historical accident. People cannot move, with friends and stuff, from game to game.

The fix is federation. Recognize players by name with an @ prefix so Xbox, Epic, and Steam identities can live in one space. Unifying social graphs is the first layer. Unifying economies is harder. A World of Warcraft sword should not work in Fortnite; gameplay items are local. Cosmetics that do not affect outcomes are a different story. Most major multiplayer games have them. Bundle the similar ones, Sweeney guesses, and about 70 percent could interoperate: the same outfit in Fortnite, Roblox, maybe *Call of Duty*, maybe a hundred or two hundred other titles. Fortnite already does this internally with cars: first into a world car, and it takes your cosmetic.

The creator-economy trick was to split engagement from cash. Battle Royale and user modes are why people play; they are not pay-to-win and they do not make money directly. The item shop makes the money, and it only exists because of that play. Spend is then shared by engagement: if you played 40 percent Battle Royale and 60 percent user modes, the profit on what you spent is split among the creators in those places. That is how Fortnite’s creator economy reached $400 million and kept growing. The next step is a standards body that defines a portable outfit — dimensions, capabilities, what it may and may not do — so games respect one another’s purchases and share revenue across ecosystems. *Only Up*, a climbing mode everyone loved, showed the inverse: people did not buy skins, because the only other player you see is a rear end above you. You can measure the correlation between a mode and spending.

Low-level interchange already works. PNG and MP3 for the web; Pixar’s USD for a scene graph that Unreal, Unity, and Blender can share; glTF for textures and geometry. A Fortnite character’s static look, body, animations, poses, and emote sounds can live in those files. The biggest missing piece, Sweeney says, is the programming language at the center of a standardized metaverse. The web has HTML for a static 2D layout and JavaScript to make it move. The metaverse needs something more powerful, safer, and more scalable, because a webpage is one company’s bundle until the next release, and a metaverse is code and content from millions of people that might form one seamless world. A high-detail Fortnite update is about 60 gigabytes, a sliver of the creative economy. In a decade, with standards, you might have exabytes. Battle Royale is not the last genre; Doom made deathmatch possible, and battle royale itself needed hardware that did not exist twenty years earlier. What is still missing is the ability to compose work from thousands of authors in one continuous space — a car from one person, weapons from twenty, a landscape from thousands — without writing impractical code. That is what Verse is for.

Verse is a language for large-scale simulation: not only a Fortnite island, but modules that millions of programmers can share in one environment. Some games will stay at 100 players; Sweeney bets there are thousand-, million-, and tens-of-million-player experiences still undiscovered. Fortnite has already drawn 15 million concurrent users, chopped into 100-player servers — a limit, he says, not a design. A concert where tens of millions participate together and see the crowd would be cooler. Ten million people will not need ten million full-detail avatars on your screen; Nyquist again. Networking is the harder half. Hard problems are the job.

He wants simple and powerful at once, citing Niklaus Wirth: power from a small set of features that compose, not from a pile of special cases. A 1956 meeting that produced ALGOL, almost forgotten, fixed how functions, variables, and recursion work; the C family inherited it. A few things they got wrong, Verse tries to fix. In an ordinary language an expression yields one value. In a functional-logic language it can yield zero, one, or many: fail, succeed, or a set you iterate. An `if` is not a boolean you throw away; the condition succeeds and binds values the `then` branch can use, or it fails. A `for` can look like a SQL query. Epic C++ programmers spend months writing “C++ in Verse syntax,” worse than either language; then the code gets tighter. First-time Fortnite programmers take the model as intuition and write loops and conditions more advanced than a lot of internal code.

A live metaverse never shuts down, and modules update constantly, so a new version must be provably backward compatible — a type-checking problem. A function that returned integers can later return natural numbers; it cannot start returning rationals. Java and C# once had strict rules of that kind and then abandoned them. The deeper 1930s insight is that a carefully designed type system can express theorems: this function returns a sorted array of the same integers, and the author must prove it. Types are theorems; certain values are proofs. Lean and Coq already check mathematical proofs so you cannot lie. Verse’s aim is to be the first mainstream language that adopts that approach in a way friendly enough that you do not have to write proofs yourself. If the compiler accepts the program, it should work. Humans will still err; you can still catch more at compile time. A bug in users’ hands costs hundreds of times more than a bug on your machine. Curry–Howard, which Sweeney sent Fridman down a rabbit hole to read, says that what you can prove in logic you can prove in a type system with the right features — on the order of seven laws. Naming and indentation are subjective; Guido van Rossum’s Python whitespace is taste. A type system that cannot express proofs is, in Sweeney’s view, simply worse, and computing’s job is to go back and fix what was done wrong before the croft crushes the system. A lot of last year’s horrible vulnerabilities, he suspects, were buffer overruns in C.

The generation’s biggest technical problem is taming concurrency so an ordinary programmer gets it by writing ordinary code. Five Unreal generations refused to scale gameplay across threads by hand; it was too much of a foot-gun for Epic and every licensee. Microservices work for Amazon’s orders. They will not work for millions of hobbyists who cannot foresee every parallel dependency. The usable foundation is 1980s work made real in the Haskell paper “Composable Memory Transactions.” A transaction is a block that must run as if single-threaded: an object update, once per frame, 60 times a second. A 100-player Fortnite match already has tens of thousands of those per frame, which is why the cap is 100 — maybe 140 if you melt a server, not thousands or billions. Programmers write ordinary reads and writes. The runtime runs many updates speculatively, buffers writes locally, commits the ones with no read-write overlap, and retries the rest. Update 10,000 objects, find 9,000 conflict-free, apply them in any order, throw away the other thousand and run them again. Pain that would have sat on a million people moves onto a few language designers. Verse is shipping modest, backward-compatible slices inside Unreal Editor for Fortnite, with major APIs every few months; licensees who already have full C++ will not get it until the essential surface is there. Unreal Engine 6 is a few years out, perhaps a preview in two or three, aiming at one build that can ship as a Fortnite island, a standalone game, or both, still inside an open item economy. Indie success, he tells Fridman about Gavin Eisenbeisz’s *Choo-Choo Charles* (Blueprints, no C++), is productivity: a content marketplace so a small team does not model every tree.

Sweeney’s first computer was a Wozniak-designed Apple II Plus, then an IBM PC. The machine came up at a language prompt; you had to do work *not* to write a program. Anyone could put software on a floppy, share it, sell it, without a tech company’s permission. IBM, then the dominant computer firm on earth, shipped an open PC. That era of unmatched technical growth, he says, is burned into him. Later the big firms realized they could block developers from shipping and from dealing with customers directly. You paid for the phone; it is yours. There is no reason Apple should stop you installing from a webpage, or writing your own app without a developer account. There is no reason it should add a 30 percent “junk fee” to commerce you already paid the device for, applied to some goods and not others. The competitive engine still runs on Windows and the open web. On mobile it does not. He would bet Steam for iPhone would be a better store than Apple’s, and that Apple would then have to build a better one.

The side effect is a storefront that offends gamer taste. Console best-sellers tend to be high-effort, high-value games. iPhone charts, almost always, are “ridiculously greedy” whale titles full of pay-to-win and loot boxes, legalized gambling driven by manipulation. Fun-based games struggle. Operating an online game is already expensive; handing Apple 30 percent — more than most game companies’ profit — forces prices up. It is an inflationary tax on digital goods. That is only the first bite. Before Fortnite was pulled from iOS, a search for “Fortnite” put a competing game first. Steam does not do that. Buying search might mean about 45 percent; social user acquisition another 20. Something like 70 percent of revenue, he says, can go to junk fees. What is left funds abusive designs that do not look like games to ordinary players.

Why only Epic? Every company is terrified of Apple, because Apple can destroy the business. Fortnite was the biggest game in the world when the fight started, and most players were on PC and console, so losing iOS was survivable. Spotify, Facebook, the rest of the top ten mobile apps, he thinks, could not live through a ban. Apple’s handling of Epic was not only litigation; it was a message to every developer: fight and we will try to ruin you. Soft power is quieter. Approve updates fast, or slow them a couple of weeks, and you change a company’s ability to compete. Apple has a long history of cat-and-mouse with developers out of favor, slowing major tech companies for weeks or months under the radar because nobody will say it publicly. That is enough to deter almost any public company.

He is in the fight because he thinks a billion-user, real-time 3D social economy — most major games as peers, dealing with customers directly — cannot exist until Apple and Google’s gatekeeping is lifted. Fees are only one layer. Apple forbids iOS browsers from implementing web standards better than Apple’s, and starves web APIs of storage and 3D so web apps cannot compete with native. Treat the metaverse the same way and the rule becomes: Apple’s engine only, Unreal disallowed, commerce forced through Apple. In Europe, even under the DMA, a store “must only be a store.” He uses the Soviet term: defense in depth. Each barrier is fatal; knock one down and the others still kill the scheme. Apple let Epic Games Store onto iOS in the EU in a form so difficult, he says, that it has no chance until regulators impose harsh penalties. Fridman, who likes Apple, says Apple is wrong here and that competition would sharpen its own store. Sweeney wants the Apple of the Apple II manual: ROM source in the book, a hardware schematic, an open ecosystem. “That’s the awesome Apple.” The current one, he says, is on the wrong side of history.

Epic Games Store launched at 12 percent against Steam’s 30. Sweeney does not dodge the two main complaints. The launcher is clunky; they need to improve it. He wishes they had put quality-of-life above merchandising features partners wanted — multiple editions, deluxe upgrades — and admits several refactors have still disappointed users. Experience is not uniform: near a CDN, with a small library, it can feel fine; the people for whom it is slow are the ones who post. They do not want every Steam feature. Partners generally did not want Epic-hosted forums. They do want convenience that matches Steam, especially as games go multi-platform and a person has four identities across Steam, Discord, PlayStation, and Xbox. Epic Online Services gives cross-platform friends, chat, and identity to any developer for free. Metcalfe’s law, he says, is the number-one trend in gaming: a game is quadratically more valuable when it connects more of your real-world friends. Sony had blocked cross-play; after a harsh series of talks in 2018 it opened PlayStation, then deepened the partnership — *God of War* in Fortnite, Unreal at Sony Pictures, Sony Music. Sony’s share versus Xbox grew after that. A better Apple, he says, would have answered his email to senior management with a conversation. Instead it is a five-year war, against what he hopes is the early part of a 15-plus-year partnership with Sony.

Exclusives he defends on principle. Apple forcing its payment stack is coercive. Paying a developer for exclusive supply is competition. Epic never forced anyone; it offered money, marketing, incentives, and spent, he says, over a billion dollars net beyond game revenue to get titles. *Borderlands* did as well on Epic as Gearbox thinks it would have on Steam. Some smaller games reached fewer customers and went to Steam when the window ended. The opening exhibit in the Epic-Google trial was a thought experiment: a new store that has everything the old store has, at the same price. Nobody switches. Epic could not compete on price because developers feared Steam featuring and console anger. So it competed on supply. Google, when Fortnite left Play Store, ran Project HUG — Hold developers Close — paying the top 30 publishers hundreds of millions not to do exclusive deals with competitors. A jury found the practices illegal. The all-in cost of operating Google Play, Epic’s data says, is about 6 percent of revenue. Apple is leaner still. Markup from 6 to 30 is what only a monopoly can do.

The future of the industry, he thinks, keeps getting lost behind drama: the constant is fun. Recent failures did not deliver it, or not competitively with other fun in people’s lives. Talent has concentrated at places like Epic and Riot and in big tech. Play is shifting toward games you play with real-world friends, not random strangers and not, for the most part, solitary campaigns. Groups settle on a game they will accept together even if it is nobody’s first pick. That is Metcalfe again, and it is why Fortnite hit an all-time high of 110 million monthly actives, with Roblox bigger than ever. A great single-player — he cites *Black Myth: Wukong* — often plays as a vacation, then people come back. You cannot spend $300 million on that kind of game; at $40 million you can make money. Biggest games reinvest faster, a winner-take-more loop. Aside from his own, the games that impress him are the ones that feel like a living world: *Zelda: Breath of the Wild*, *Skyrim*, *Red Dead Redemption*, whose rivers a high-school classmate trained in ecology called hydrologically sound. He last designed a game in 1992 and is not a designer. The best genre, he thinks, has not been invented. Rockstar taking years on GTA 6 is the Unreal lesson again: when you push quality past what has been done, you cannot schedule the new problems each fix reveals. A bad game is bad forever. A late good game is eventually good. Fortnite seasons only become judgeable in the last month, so the last mile is a sprint, and some lessons only arrive live.

What gives him hope is a split in the digital age. Social networks, people typing at each other, engagement that promotes negativity, feel like a step backward, a shaky foundation. Full-squad Fortnite with strangers, sometimes in “battlefield Spanish” as far as Mexico City, has been excellent and endearing. Humans talking to humans, together in a real or virtual space, is a naturally empathetic medium. Angry text is a self-reinforcing negative. Fridman agrees that Discord around a game can be toxic and that the same people in a room almost always get along. Make the digital space immersive enough to feel the other person, and the empathy shows. Sweeney’s closing job description is modest: make people’s lives better by entertaining them, as a diversion, not as an alternate to reality.