Atomic Precision. Software from '01.
Semiconductor equipment is a marvel of human engineering. The software running it isn't.
A semiconductor fab is one of the most sophisticated environments humans have ever built.
The tools inside can pattern features smaller than a virus. They operate at tolerances measured in atoms and a single machine can cost more than a commercial aircraft. The physics required to make them work took decades of the best engineering minds on earth to figure out.
But when an engineer needs to operate one, they open a virtual machine running software that looks like Windows XP.
That line is less of an exaggeration than it sounds. SEMI itself noted in 2022 that semiconductor equipment can remain in service for up to forty years, that a single fab may contain more than twenty different operating system versions, and that Windows XP continued to be installed on new semiconductor equipment even after Microsoft ended patch support in 2014. In most industries, that would sound like technical debt. In semiconductors, it’s just the installed base.
The gap between the physical sophistication of semiconductor equipment and the software used to run it is one of the most absurd disconnects in modern industry. We can manufacture chips at 2-nanometer-class process nodes. We cannot reliably give every engineer a clean, unified dashboard showing what all their tools are doing at the same time.
Every piece of equipment in a fab talks just enough to keep production moving, but rarely enough to make the factory feel like one coherent software system. The industry has standards (SECS/GEM, GEM300, EDA/Interface A), but those standards grew out of a world where the priority was control, state reporting, and uptime, not modern analytics or clean product design. The result is a factory full of machines that can pattern atoms but often expose their data through vendor-specific interfaces, aging control software, and fragmented tool histories.
A single production line generates continuous streams of data from thousands of sensors monitoring temperature, vibration, pressure, gas flow, plasma behavior, wafer movement, and process parameters across dozens of tools. Some of that data is captured, some of it is analyzed, some of it disappears into vendor systems, local logs, recipe files, maintenance notes, spreadsheets, or the heads of the engineers who know which weird alarm actually matters.
This is not because semiconductor engineers are bad at software. It is because the incentives were never built around software as a product.
Equipment companies are hardware companies. The machine is the product. Software is often treated as the interface to the machine, not as the central operating layer of the factory. Customers choose tools based on yield, throughput, process performance, defectivity, service support, and integration into existing flows. They do not buy a plasma etcher because the user interface is elegant, so the interface never had to become elegant.
The caution is understandable. In a fab, change is risk. A patch is not just a patch if it can interrupt yield, invalidate a configuration, break a recipe, or take down a tool that costs hundreds of millions of dollars. Production equipment is qualified, protected, and expected to run for decades. Once something works, the instinct is to freeze it in place.
Over time, that caution hardened into a software philosophy: keep systems separate, keep interfaces proprietary, keep working software untouched, and avoid disturbing anything that might affect the process. The result is not the absence of software. It is software everywhere, but buried in tool controllers, vendor stacks, MES systems, APC layers, FDC systems, historians, Excel files, and custom internal scripts that only a few people understand.
Semiconductors did not fail to adopt software. They adopted software in the most semiconductor way possible: cautiously, locally, vendor-by-vendor, tool-by-tool, and then froze it in place for decades because downtime is more terrifying than bad UX.
Cybersecurity exposed the cost of that bargain.
SEMI published its first cybersecurity standard for semiconductor manufacturing equipment, SEMI E187, in January 2022. The most strategically critical manufacturing sector in the world got its first equipment cybersecurity baseline only recently. The WannaCry ransomware attack that exploited legacy Windows vulnerabilities happened in 2017. TSMC suffered a major virus incident in 2018 after infected software was installed on a new tool and spread when the tool was connected to the company’s network.
The lesson was not that fabs had no security. The lesson was that old software, long equipment lifecycles, and highly networked production environments create a dangerous combination. The very thing that makes fabs reliable (not changing things casually) can also make them brittle.
Now the industry is trying to move in the other direction. Synopsys recently marketed a new analytics platform as the industry’s first full-stack big data solution spanning design, manufacturing, and test. That is an important development, but it’s also revealing. If bringing fragmented design, fab, and test data into one analytics layer can still be positioned as a breakthrough, it tells you just how much of the problem has been sitting in plain sight.
The strangest thing about semiconductors is that the industry already understands complexity better than almost anyone. It knows how to control contamination at the particle level and how to move wafers through thousands of process steps. But the software layer still often feels like an archaeological site: one generation of systems stacked on top of another, all too important to replace and too fragile to touch.
That may have been acceptable when semiconductor manufacturing was an obscure industrial niche. It is harder to defend now that chips sit at the center of AI, defense, energy, transportation, and national strategy.
The hardware got a generational upgrade. The software did not get the memo.