Arkwright: Why we named the stack after a wig-maker

Richard Arkwright.

Richard Arkwright was a barber who made wigs for a living, and then he invented the factory.

We named our backend core stack after him: the Arkwright Engine. Yes, him: the wig-maker with the loan and the river, the man whose Cromford Mill is the ancestor of every centralised factory on Earth. Naming the stack after the patron saint of the system we intend to obsolete is exactly the sort of irony this company runs on. I mean, we are called Antonym, after all. (He was also from Lancashire, and no Yorkshireman has ever passed up an opportunity to put a Lancastrian to work.)

The name is literal: an Autonomous Runtime Kernel, with the suffix -wright surfacing its role as a digital builder or craftsman of physical atoms. A wheelwright makes wheels. A shipwright makes ships. A playwright, oddly, makes plays. Ours makes matter.

Father of industrial operating systems

Richard Arkwright did not build a machine. He built the world’s first physical operating system. Before him, manufacturing was a fragmented, domestic pursuit, a slow pulse of manual labour scattered across independent cottages. By harnessing water power to drive his spinning frame and, crucially, by inventing the factory system itself, he introduced the concept of synchronised production. He proved that when you unify power, precision machinery and a structured workforce under a single roof, you transcend human limitation. This was the Great Pivot: the moment making things stopped being an artisanal craft and started becoming a scalable, autonomous science standardised into a protocol.

Without this fundamental shift in the architecture of production, the 19th century’s greatest triumphs would have remained impossible blueprints. Arkwright’s factory system provided the conceptual and economic substrate for everything that followed, from the precision lathes of Henry Maudslay to the locomotive engines of George Stephenson and the massive steel mills of the Bessemer process. He established the logic of the integrated system, a lineage that leads directly from his water-powered spindles to the autonomous, digitised cells of today. To name our stack after him is to recognise that every leap in hardware, be it a steam engine or orbital infrastructure, relies entirely on a revolutionary reimagining of the act of making itself.

In the 18th century, Arkwright’s science was industrial logic. Before him, manufacturing was an art. It lived in the hands and intuition of a spinner.

Arkwright was the first to extract that intuition and encode it into a physical system. Before him, if a spinner got sick, the knowledge of how to make that specific yarn left the room. His breakthrough was standardisation. He broke down the complex, artisanal act of spinning into a series of discrete, mechanical steps, and by doing so he created a protocol: a set of instructions that could be performed by unskilled workers, or operatives, and powered by a machine. This made production scalable, because you no longer needed to find 100 master craftsmen. You just needed one Arkwright System.

A barber with a waterproof dye

Richard Arkwright was born in Preston in 1732, the youngest of seven surviving children, in a family that could not afford to send him to school. A cousin taught him to read. He spent his first career as a barber and wig-maker in Bolton, where his notable invention was a waterproof dye for periwigs. This is my favourite fact about him. The father of the factory system started out solving a problem for wigs.

Lancashire in the 1760s had a problem of its own. Thirty years earlier, John Kay’s flying shuttle had roughly doubled the speed of a weaver. The spinners, working by hand in cottages, could not keep up. Weavers sat idle waiting for yarn. Yarn was the bottleneck of the most important industry in the country, and anyone who could tinker was tinkering.

Arkwright had no engineering training, but he saw the bottleneck clearly enough to pay other people to fix it. He worked with a clockmaker, also called John Kay, on the machine that became the water frame: a spinning machine that produced yarn strong enough for warp threads, which hand-spinning struggled to do consistently.

He patented the water frame in 1769. The first one was turned by horses. Two hosiers, Jedediah Strutt and Samuel Need, put up the money for a mill, and it was only when he set the frames in the Derwent valley at Cromford in 1771 and let water drive them that the thing people now call the Industrial Revolution actually had somewhere to live. The power came from Bonsall Brook and the Cromford Sough, a lead-mine drain that ran at a constant 52°F and never froze, and by 1772 the mill worked day and night on two twelve-hour shifts.

The water frame · Cromford Mill · 1769–1771

Cromford Mill in the Derwent valley, Derbyshire, and Arkwright’s water frame.

The first autonomous logic. We think of autonomy as AI and robotics, but Arkwright’s water frame was arguably the first industrial expression of autonomous production.

Input: raw cotton. Engine: the water frame, driven by gravity and water. Output: standardised yarn.

Once configured, the machine executed continuously without the constant correction of a human hand. This was the birth of unattended production, and it shifted the human role from the maker to the operator.

Historians often argue that Arkwright’s greatest invention was not the mill at Cromford, but the factory system itself: the idea that production could be synchronised, repeatable, and encoded into a physical operating model. Lombe’s silk mill in Derby got there fifty years earlier, but Lombe built a building. Arkwright built a system other people could copy.

By proving that machine-led production could scale, Arkwright created the demand for everything that followed: larger power systems such as Boulton & Watt, precision tooling such as the Maudslay lathe, and eventually industrial standards such as Whitworth threads.

Arkwright did not invent the steam engine or the lathe. He invented the customer for them.

His deeper breakthrough was not mechanisation. It was abstraction. The spinning frame proved that output quality could become dependent on system design rather than operator skill. For the first time, identical outputs could be produced independent of fatigue, mood or local craft variation. Repeatability became infrastructure. Arkwright translated sweat and skill into gears and logic.

He proved that the soul of manufacturing does not reside in the artisan’s hand, but in the architecture of the system itself. By encoding human craft into mechanical logic, he transitioned production from bespoke isolation into scalable industrial certainty. Had he not broken that artisanal barrier, we would still be living in a Bespoke World, where every screw, every gear and every circuit board would be a unique, unrepeatable object, making modern tech economically and physically impossible.

The man who smuggled a factory in his head

Once it worked, the only question left was who else would be allowed to have it. Britain understood exactly what it had. Parliament made it illegal to export textile machinery, and illegal for the skilled mechanics who understood it to emigrate. The Arkwright system was treated as a national asset worth criminalising to protect: industrial sovereignty, two and a half centuries before anyone used the phrase.

It did not hold. Samuel Slater had been apprenticed at fourteen to Jedediah Strutt, Arkwright’s own partner, and spent years inside the system learning how every frame, gear and shift fitted together. In 1789, at twenty-one, he left England posing as a farm labourer. He carried no drawings, no machines and no papers. He carried the architecture in his head. In Rhode Island he rebuilt it from memory, and by 1793 his mill was running in Pawtucket. The American industrial revolution started from a memory.

In 1789 the most valuable industrial architecture on Earth crossed the Atlantic inside one man’s memory. Today it travels as code.

That changes what capability means. Nations still compete over where things can be made, and still treat the factory as the thing to own. When intent is portable and execution is deterministic, capability stops being a building a country owns and becomes something it can hold, move and deploy: compiled, verified and run wherever it is needed, on its own terms.

Then the loom learned to read

Once spinning was solved, the bottleneck flipped. Mills like Cromford produced more yarn than hand-weavers could use. In 1785, the same year Arkwright lost his patent, a clergyman named Edmund Cartwright patented the power loom. The two machines spent the next half-century chasing each other up the productivity curve.

Then, in 1804, the loom learned to read.

Joseph Marie Jacquard fitted a loom with a chain of punched cards. Each card told the machine which threads to lift. Change the cards and you changed the cloth, without rebuilding the loom. For the first time, the pattern was separated from the mechanism. The instructions were portable. The design lived in the cards, and the machine executed them.

That is programmable manufacturing, and it arrived roughly a century and a half before programmable computing. Babbage borrowed the cards for his Analytical Engine. Ada Lovelace, describing it in 1843, wrote that the Engine “weaves algebraical patterns just as the Jacquard loom weaves flowers and leaves.” Hollerith borrowed the cards for tabulation; from tabulation came IBM, and from IBM came most of the rest.

The entire computing industry is descended from a device for making cloth. Manufacturing invented programmability, handed it to computing, and did not keep a copy.

In 1839 a Jacquard loom in Lyon wove a portrait of the man himself in silk. It took around 24,000 punched cards. The result was so fine that viewers mistook it for an engraving, and Babbage owned a copy that he liked to show to visitors. The most complex image of its age was not painted. It was compiled.

That is the quiet consequence of separating pattern from mechanism. Once the pattern is a program, an intricate result costs the machine no more than a simple one. Complexity becomes free.

A barber built the factory. A clergyman built the power loom. A weaver’s son made the loom programmable. A former apprentice carried the whole system across an ocean. None of them came from the establishment of their day, and none of them was trying to build a better machine. Each of them saw the system. Industrial revolutions are rarely started by the industry they revolutionise.

Loom and Arkwright

The Industrial Revolution ran on two machines chasing each other. Arkwright’s spinning frame created a glut of yarn. Cartwright’s power loom answered it in 1785. Then Jacquard’s loom separated pattern from mechanism in 1804. We named our two halves after both: Arkwright after the frame, and Loom after the loom, which is also an acronym, Logic for Optimising Objectives into Matter. Loom decides what. Arkwright decides where and how, and then does it.

Loom is the upstream compiler. It is the studio where intent is authored, and the intent arrives at an offensively high level: what the thing is for, how many are needed and how often, what each one can cost, and the performance it has to hold. Loom does everything else, compiling that intent into geometry. The result is not a drawing of a guess but geometry that carries the reasons it looks the way it does. This is Jacquard’s insight two centuries on: the pattern is the valuable thing, and the pattern should be portable.

And because the pattern is a program, complexity becomes free. Geometry no one would dare draw by hand becomes ordinary. Loom is built for the portrait, not the plain cloth.

Arkwright is the runtime underneath. It takes what Loom produces, decides which node in the network should make it, compiles it for that node, runs it there and returns proof of what physically happened. This is Cromford’s insight two centuries on: output should be a property of the system, not of whoever is on shift.

In compiler terms, Loom is the front end and Arkwright is the back end. Source goes in at the top. Matter comes out at the bottom, with a receipt.

Historically, spinning came before weaving, because you need thread before you can make cloth. We put the loom first. In 1771 the scarce resource was thread. Today the scarce resource is intent a machine can understand, while idle capacity sits everywhere with nothing to tell it what to do. The bottleneck has flipped again.

Together they close a loop that has been open since 1804. Intent becomes geometry. Geometry becomes matter. Matter comes back with proof.

From Cromford to compute

Every step since has been the same move at a higher level of abstraction: take something that lives in a person, encode it into a system, and let the system carry it.

	Shift	What changed
1771	Arkwright system	The first factory structured as a synchronised runtime for physical production. Throughput decoupled from artisan variance.
1785	The power loom	The bottleneck flips from spinning to weaving. The two machines start chasing each other up the curve.
1790s	Mechanised precision	Standardised tooling and repeatable tolerances. Production freed from the inconsistency of human craft.
1804	The Jacquard loom	Pattern separated from mechanism. Instructions become portable. Manufacturing becomes programmable.
1800s	Interchangeable parts	Blanc, Hall, Whitworth. Components encoded to specification, the precursor to modular systems architecture.
1850–1900	Mass industrialisation	Railways, steel, energy infrastructure. Industrial logic scales to civilisational scope.
1910s–30s	Scientific management	Taylor and Ford. System theory enters production, and the factory becomes programmable by design.
1950s–60s	Compute systems	The first programmable manufacturing controls. Physical production begins its convergence with computational logic.
1970s–90s	Automation	PLCs, CNC, distributed control systems. Manufacturing processes gain autonomy at the machine level.
2000s	Distributed networks	Global supply chain optimisation. Production fragments across geographies and starts demanding topology-aware coordination.
Now	Atomic Compute	Protocol-driven production. Factories as nodes, manufacturing as compute, production as code.

250 years, one idea, repeatedly: move the knowledge out of the person and into the architecture.

What we took, and what we are retiring

We took the half he got right. Production is a system rather than a performance. Output should be a property of the architecture, not of who happens to be on shift. A configured machine should run unattended.

We are retiring the other half, which is the roof.

Arkwright’s answer to “where does the system live” was one building, next to one fixed water supply, with everybody inside it. That answer was correct in 1771, because water does not travel and neither did information. It has been quietly wrong for about forty years, and the industry has spent those forty years building bigger versions of it anyway.

Our Arkwright is the opposite shape. The runtime kernel, the edge hypervisor, the compiler engine and the scheduler run on standardised nodes rather than inside a single mill, and the point is that any node of a class behaves like any other: the same instructions, the same result, in a different postcode. Same intent, same outcome, anywhere on Earth (and beyond). Manufacturing intent stays portable until the network decides where execution should happen. FactoryOS sits above it, Atomic Compute is the capacity underneath, and the proof comes back from execution rather than from paperwork. Loom sits upstream, turning what you need into what should exist.

Antonym represents the ultimate evolution of that lineage: translating physical, tacit, tribal know-how into deterministic code that runs autonomously on compliant nodes in the network, anytime, anywhere on Earth.

Why now

In 1771 Cromford was a small building in a Derbyshire valley, run by a former barber, financed by two stocking-makers, staffed by a couple of hundred people and built around a machine many sensible people considered a novelty. It did not look like the most important building in the world. It looked like a mill.

Strutt and Need, the clockmaker, and the first operators who learned the system were early exactly once. So were the people who heard about it in 1785 and decided to wait. Nine years earlier, Matthew Boulton had shown James Boswell round his Soho works and told him, “I sell here, sir, what all the world desires to have: power.” Those who bet on power early became the industrial aristocracy of the next century. Those who waited bought it from them.

The machines the next century needs do not yet have names: reactors, robots, spacecraft and categories of hardware nobody has drawn yet. They cannot arrive through a design stack waiting on factories and factories waiting on design, through analogue tools and analogue factories still running on the logic of 1771. That is the absurd tax on invention every hardware team now pays, and it is a catch-22. Design cannot become fully computational while manufacturing stays analogue, because computed geometry has nowhere to land. Manufacturing cannot become computational infrastructure while design keeps handing it hand-drawn parts, because there is nothing worth computing. Computed geometry is worthless without a factory that can compile it. A computational factory is idle without geometry worth compiling. Each side waits for the other, so neither moves.

This has happened before. In the 1760s the weaver waited on the spinner. After Cromford the spinner waited on the weaver. For fifty years, spinning and weaving took turns waiting on each other before the leapfrogging settled. Design and manufacturing are now in the same deadlock, except neither can move first. Design waits on manufacturing, and manufacturing waits on design.

The only way out is to move both at once, as one system. That is why Loom and Arkwright are designed as one system: so the chase ends rather than restarts. With them, imagination is the input and matter is the output, at machine speed.

After the factory

On the other side of the deadlock, hardware iterates at the speed of software: the tenth version of a machine follows the first as easily as a new build follows a commit. A new machine goes from intent to physical form wherever it is needed, in a city, a shipyard, a field hospital or a launch site, on the nearest qualified node. Know-how compounds instead of retiring, and every execution makes the next one faster and more certain.

And the categories of hardware nobody has named yet finally get their chance to exist. The reactors, robots and spacecraft of the next century, and the machines that will make them look primitive, stop being limited by the difficulty of making them and start being limited only by physics and imagination.

250 years later

Arkwright took the knowledge out of the spinner’s hands and put it into the mill. Jacquard took the pattern out of the weaver’s head and put it onto a card. For 250 years, every revolution in making things has made the same move: take what lives in a person, encode it into a system, and let the system carry it.

Loom weaves intent into geometry.

Arkwright compiles geometry into atoms.

Richard Arkwright mechanised production.

Antonym Industries is computationalising it - the entire semantic distance between imagination and matter.