There is a ceiling that every civilization eventually encounters if it tries to rebuild modern technology without semiconductors.
It is a surprisingly high ceiling.
A sufficiently capable society can produce wood products, pottery, glass, bricks, cement, steel, copper wire, electric motors, generators, pumps, machine tools, agricultural machinery, bicycles, vehicles, refrigeration, lighting and a remarkable range of industrial equipment without ever manufacturing a modern integrated circuit.
It could even build a sophisticated mechanical-electrical civilization.
Relays can perform logic. Electric motors can provide mechanical power. Generators can produce electricity. Analog circuits can perform measurement and control. Mechanical governors can regulate engines. Machine tools can produce increasingly precise machines. A community with enough accumulated knowledge could recreate a substantial industrial base.
But eventually it would hit a wall.
The problem would no longer be whether it could make a washing machine, a lathe or a refrigerator.
The problem would be whether it could recreate the information-processing system that modern civilization depends upon.
The Ceiling of a Mechanical-Electrical Civilization
Imagine a civilization that has successfully reconstructed everything up to the point just before semiconductors.
It has electricity.
It has copper.
It has steel.
It has motors and generators.
It has machine tools.
It has factories.
It has telephones and perhaps even relatively sophisticated analog electronics.
It can manufacture thousands of physical objects.
Yet it cannot easily reproduce the world we now take for granted.
There is no modern smartphone.
There is no modern laptop.
There is no modern office computer.
There is no cloud computing.
There is no modern internet infrastructure.
There is no practical digital video ecosystem.
There is no modern computer gaming industry.
There is no modern artificial intelligence.
There is no inexpensive mass digital communication.
There is no modern CNC ecosystem at anything approaching today's scale.
And perhaps most importantly, there is no inexpensive machine capable of manipulating information at enormous speed.
This is the ceiling.
A civilization without semiconductors can have an impressive physical industrial base, but it cannot easily reproduce the information civilization that sits on top of that physical base.
This distinction matters enormously for a modern interpretation of the Global Village Construction Set.
The Original GVCS Question Was About Machines
The original idea behind a Global Village Construction Set is compelling: identify the machines and technologies necessary to build a resilient community, and make their designs openly available.
But our previous discussion suggested that the deeper question is not:
“Which machines should a village possess?”
It is:
“What chain of capabilities allows a community to rebuild and progressively advance its technological civilization?”
That changes everything.
Clay leads to pottery.
Charcoal leads to high-temperature metallurgy.
Iron leads to tools.
Tools lead to machine tools.
Machine tools lead to factories.
Factories lead to more sophisticated machines.
And eventually, the chain must lead somewhere beyond mechanical engineering.
It must lead to semiconductors.
Because otherwise the capability tree stops just before the digital age.
The Semiconductor Must Become a GVCS Capability
We can therefore imagine a semiconductor technology occupying the same conceptual position in the GVCS as a lathe or a forge.
Not because a semiconductor fabrication facility is a convenient village machine.
It obviously isn't.
Rather, because the knowledge required to manufacture integrated circuits represents one of the highest-level capabilities that a civilization must eventually recover if it wants to recreate modern computing.
For the purposes of this thought experiment, let us choose 130 nm.
Not 3 nm.
Not 2 nm.
Not even 28 nm.
130 nm.
Why?
Because the objective here is not maximum performance.
The objective is recoverability.
We want a semiconductor process sufficiently old and comparatively approachable that its manufacturing knowledge can become an open technological asset, while still being powerful enough to manufacture useful general-purpose computers.
There is already evidence that parts of this idea are technically plausible. The SKY130 ecosystem has made a 180–130 nm-class process design environment broadly accessible through an open PDK. The SKY130 documentation describes a mature 180/130 nm hybrid process with five metal layers, local interconnect and several device options.
But our hypothetical GVCS process would go considerably further.
The objective would be to document the semiconductor manufacturing chain itself.
From:
- silicon feedstock
- wafer preparation
- chemicals
- gases
- photoresists
- deposition
- etching
- doping
- oxidation
- metallization
- cleaning
- photolithography
- masks
- process control
- metrology
- packaging
- testing
- failure analysis
all the way to a functioning integrated circuit.
In other words:
The 130 nm semiconductor process becomes a machine in the GVCS.
Not a machine made of steel sitting in a workshop, but a documented industrial capability that can reproduce the machines of the digital age.
But a Semiconductor Process Is Not Enough
Here is where the idea becomes much more interesting.
Suppose we successfully create the completely open 130 nm semiconductor process.
We manufacture transistors.
We manufacture logic gates.
We manufacture memory.
We manufacture a processor.
We package it.
We put it onto a circuit board.
We turn it on.
What happens?
Nothing particularly useful.
The computer needs software.
And this exposes another weakness in the conventional definition of technological independence.
A civilization can preserve the recipe for manufacturing a processor and still lose the ability to use it effectively if the software ecosystem required to operate that processor disappears.
The semiconductor therefore cannot be treated as an isolated capability.
It needs a corresponding open software civilization.
The Indian Open Consortium Becomes Part of the Solution
This is where our earlier idea of an Indian Open Consortium becomes much more ambitious.
The consortium should not merely attempt to produce Indian replacements for individual commercial applications.
It should not be defined simply as an organization that builds an Indian word processor, Indian cloud software or Indian collaboration platform.
Those things may be useful.
But they are only the visible surface.
The deeper responsibility should be:
Maintain an open software stack capable of supporting India's technological civilization from the lowest practical open-computing platform upward.
That means the consortium would maintain two parallel software worlds.
The Modern Track
The first track would target contemporary hardware:
- modern RISC-V processors
- GPUs
- NPUs
- laptops
- smartphones
- servers
- high-speed networking
- modern storage
- AI systems
- modern desktop applications
This is the software ecosystem required to compete in the present.
The Civilization Backup Track
The second track would be radically different.
It would target the deliberately modest 130 nm computer.
Its objective would not be to run the latest bloated software.
Its objective would be to preserve the functions of digital civilization.
A low-computing machine should still be able to:
- write and edit documents
- create spreadsheets
- draw diagrams
- write and compile programs
- read technical documentation
- operate databases
- run simulations
- communicate over networks
- serve web pages
- access local information repositories
- perform engineering calculations
- design PCBs
- perform basic CAD
- design integrated circuits
- run EDA software
- maintain source-code repositories
- operate local educational systems
- preserve and reproduce digital knowledge
The goal is not to make a 130 nm computer feel like a 2026 workstation.
The goal is to make sure that a 130 nm computer is enough.
The 130 nm Computer Should Be the Digital Seed
This is where the analogy with the Svalbard Global Seed Vault becomes useful.
The Svalbard Global Seed Vault exists to safeguard crop diversity for the future. As of 2026, it holds more than 1.4 million seed samples and has storage capacity for up to 4.5 million samples.
But imagine applying the same philosophy to technological civilization.
Instead of preserving seeds that can eventually produce crops, we preserve the knowledge and tools that can eventually produce computers, networks, engineering systems and new technology.
Call it the:
Digital Seed Vault
The Digital Seed Vault would not simply be a hard drive containing source code.
That would be far too fragile.
It would contain a complete dependency chain.
DIGITAL SEED VAULT
Fundamental knowledge
↓
Mathematics and algorithms
↓
Programming languages
↓
Compiler + assembler + linker
↓
Bootloader
↓
Operating system
↓
Hardware drivers
↓
Filesystems
↓
Networking
↓
Development tools
↓
Applications
↓
EDA tools
↓
Chip designs
↓
Next-generation chip designs
↓
Better computer
The important part is that every layer must have a path to the layer below it.
If the compiler requires a proprietary cloud service, the chain is broken.
If the operating system depends on a proprietary bootloader, the chain is broken.
If the source code can no longer be compiled using the preserved tools, the chain is broken.
If the documentation exists only on a website that disappeared, the chain is broken.
If the chip design exists but the EDA tools required to modify it are unavailable, the chain is broken.
The Digital Seed Vault therefore needs to preserve not merely software, but software reproduction capability.
The Computer Must Be Able to Rebuild the Software
This is perhaps the most important design principle.
A civilization backup should not contain only finished applications.
It should contain the tools necessary to recreate those applications.
For example:
Text editor
↓
Source code
↓
Compiler
↓
Executable
↓
Operating system
↓
Computer
And then the loop should continue:
Computer
↓
Compiler
↓
Software
↓
EDA
↓
Chip design
↓
New processor
↓
Better computer
That is the difference between a software archive and a technological seed.
An archive remembers what civilization once had.
A seed contains enough information to grow something again.
Why RISC-V Fits the Idea
A processor architecture also needs to be part of this open chain.
This is one reason an open instruction-set architecture such as RISC-V is particularly interesting for this thought experiment.
RISC-V is an open standard ISA rather than a single proprietary processor design. Its specifications define a base instruction set with optional extensions, allowing implementations ranging from relatively simple cores to much more sophisticated processors.
This distinction is important.
RISC-V does not automatically give us an open 130 nm CPU.
We would still need an actual processor implementation, verification, physical design, SRAM, peripherals, fabrication and packaging.
But an open ISA provides a stable interface between hardware and software.
That is extremely valuable for a civilization that wants to preserve its computing capability across multiple generations of hardware.
The same operating-system and compiler ecosystem could potentially survive as the underlying processor evolves.
The Low-Computing Software Stack
The Indian Open Consortium could therefore define a formal Low-Computing Stack.
Think of it as a minimum software civilization.
| Layer | Purpose |
|---|---|
| Firmware | Boot and hardware initialization |
| Bootloader | Start the operating system |
| Kernel | Memory, processes, storage and hardware management |
| Drivers | Display, storage, USB, network, audio and peripherals |
| Core utilities | Shell, filesystem tools, text processing and administration |
| Compiler toolchain | Build software from source |
| Editor | Write and modify source code and documents |
| Office | Documents, spreadsheets and presentations |
| Graphics | Images, diagrams and basic publishing |
| Database | Structured information storage |
| Networking | Local and wider-area communication |
| Browser | Access standards-based information systems |
| CAD/EDA | Design machines, electronics and chips |
| Documentation | Offline technical knowledge repository |
None of these programs need to look spectacular.
They need to be dependable.
They need to be understandable.
They need to be maintainable.
And above all, they need to remain buildable.
Low Computing Is Not the Same as Bad Computing
This is an important distinction.
A modern application might consume gigabytes of storage and hundreds of megabytes or even gigabytes of RAM simply because abundant computing resources have become available.
That doesn't mean the underlying task actually requires those resources.
Writing a letter does not require a multi-core processor.
A spreadsheet does not inherently require gigabytes of RAM.
A text editor does not require an AI accelerator.
A diagram does not require a cloud account.
A local database does not require a data center.
A technical manual does not require a subscription service.
Much of modern software's resource consumption comes from layers of convenience, abstraction, graphical complexity, frameworks, background services and network dependencies that have accumulated over decades.
The Low-Computing Stack would deliberately ask a different question:
What is the minimum computing required to perform this useful task reliably?
That is a very different optimization target.
The Software Should Be Designed for the Hardware
This is where the semiconductor and software projects need to be developed together.
If the reference processor has limited cache, the operating system should account for it.
If memory bandwidth is limited, applications should avoid unnecessary memory movement.
If storage is slow, software should minimize random access.
If graphics hardware is primitive, interfaces should not assume modern GPU acceleration.
If the CPU has no sophisticated vector or AI extensions, the software should still work.
In other words:
Do not take today's software and attempt to squeeze it into tomorrow's 130 nm computer.
Build software specifically for the computer that civilization knows how to manufacture.
The 130 nm Computer Does Not Have to Be a Pentium III
It would be tempting to define the target as “build a Pentium III equivalent.”
That is useful as a mental reference, but it should not become the engineering specification.
The goal is not to reproduce Intel's architecture or recreate a 700 MHz Pentium III.
The goal is to reproduce the class of capabilities that made computers of that era so useful.
A successful GVCS-130 machine might therefore be capable of:
- desktop document editing
- spreadsheets
- programming
- basic web access
- email and messaging
- digital publishing
- image manipulation
- basic audio and video
- retro gaming
- engineering calculations
- CAD
- PCB design
- chip design
- industrial control
- local servers
- education
- technical documentation
That would already represent an enormous technological capability.
And more importantly, it would provide a platform on which the next generation could be designed.
The Computer Becomes a Machine Tool for Knowledge
Our previous GVCS article placed the machine tool near the centre of the technological capability tree.
The open computer now needs to be placed beside it.
A lathe transforms material.
A milling machine transforms material.
A furnace transforms material.
A computer transforms information.
And increasingly, information is what allows us to transform material more effectively.
A computer can design the next machine.
It can calculate the strength of the machine.
It can simulate the machine.
It can generate manufacturing drawings.
It can control a CNC machine.
It can design the PCB.
It can design the integrated circuit.
It can compile the software controlling the factory.
This creates a feedback loop:
Physical capability
↓
Machine tools
↓
Semiconductors
↓
Computer
↓
Software
↓
Engineering
↓
Better machine tools
↓
Better semiconductors
↓
Better computer
The computer is therefore not merely another consumer product.
It is part of the machinery that allows civilization to improve itself.
The Indian Open Consortium Could Maintain the Digital Seed
This gives our earlier Indian Open Consortium concept a second, deeper mission.
Alongside maintaining critical open-source infrastructure used by Indian industry, government, education and businesses, the consortium could maintain a Digital Civilization Repository.
It would contain at least four categories of material.
1. Software
- operating systems
- compilers
- development tools
- office applications
- databases
- networking software
- CAD and EDA
- educational software
2. Hardware
- CPU designs
- MCU designs
- GPU designs
- NPU designs
- memory controllers
- USB controllers
- Ethernet controllers
- storage controllers
- display controllers
- peripheral interfaces
3. Manufacturing
- semiconductor process documentation
- PDKs
- mask information
- equipment documentation
- chemical specifications
- metrology procedures
- packaging
- testing
- PCB manufacturing
- component specifications
4. Knowledge
- textbooks
- engineering manuals
- scientific references
- mathematical references
- machine drawings
- repair manuals
- manufacturing procedures
- agricultural knowledge
- medical and public-health references
- historical technical archives
The result would be something much more ambitious than an open-source software repository.
It would be a technological memory of civilization.
The Repository Must Be Able to Survive the Internet
This is another important difference.
A conventional software project assumes that the internet will continue to exist.
A civilization backup cannot make that assumption.
The information should therefore be reproducible in offline form.
A physical installation might contain:
DIGITAL SEED VAULT
Multiple storage copies
+
Printed critical documentation
+
Offline source-code archive
+
Offline package repository
+
Offline compiler toolchains
+
Offline educational library
+
Hardware designs
+
Semiconductor process documentation
+
EDA tools
+
PDKs
+
Test data
+
Build instructions
Multiple copies could exist at geographically separated institutions.
The point would not be secrecy.
The point would be redundancy.
The same philosophy that says humanity should not store all of its agricultural genetic diversity in one location should also apply to critical technological knowledge.
From GVCS-130 to GVCS-90
Once the 130 nm platform exists, the project should not stop there.
The 130 nm computer would be the first digital rung.
The next rung could be 90 nm.
Then 65 nm.
Then 45 nm.
Then 28 nm.
And eventually perhaps much more advanced processes.
GVCS-130 │ ▼ GVCS-90 │ ▼ GVCS-65 │ ▼ GVCS-45 │ ▼ GVCS-28 │ ▼ GVCS-14 │ ▼ Future open processes
These should not be interpreted as guaranteed performance equivalents to commercial processors at those nodes.
Process geometry alone does not determine CPU performance. Architecture, transistor budget, memory, cache, frequency, interconnect, packaging and software all matter.
Instead, each generation should represent a new open manufacturing capability and a corresponding expansion of the software ecosystem.
Each generation should make it easier to design the next one.
This Is Where Dholera Becomes Interesting
The idea also connects directly to India's emerging semiconductor ambitions.
If India eventually develops a significant semiconductor manufacturing ecosystem, the obvious objective is to produce commercially competitive chips.
That is necessary.
But there is another opportunity.
Some portion of that ecosystem could also be dedicated to open reference technologies.
A deliberately open mature-node process could become the foundation for universities, startups, government laboratories and independent engineers.
An open processor could be fabricated on it.
An open computer could be built around that processor.
The Indian Open Consortium could maintain the software stack.
The software could run the engineering tools.
The engineering tools could design the next chips.
And the next generation of chips could eventually be produced on more advanced Indian processes.
That would create something remarkable:
A hardware-software ecosystem capable of improving itself.
The Open Semiconductor Is Only Half the Story
This also reveals why simply declaring a semiconductor process “open” is not enough.
An open PDK is extremely valuable, but it is only one layer of the stack.
For example, the existing SKY130 ecosystem demonstrates the usefulness of opening process-design information. The associated ecosystem includes process documentation, libraries and design resources, while separate repositories contain raw process data.
Open chip-design tools such as OpenROAD are another important piece: the project describes its flow as taking synthesizable RTL through physical implementation toward manufacturable GDSII.
But the complete civilization stack requires all of these layers to connect:
OPEN PROCESS
↓
OPEN PDK
↓
OPEN EDA
↓
OPEN CPU
↓
OPEN SoC
↓
OPEN COMPUTER
↓
OPEN OS
↓
OPEN APPLICATIONS
↓
OPEN KNOWLEDGE
↓
OPEN MANUFACTURING
↓
NEXT-GENERATION COMPUTER
That is the actual objective.
A Civilization Should Preserve the Ladder, Not Just the Summit
Modern civilization tends to think from the top down.
We look at a smartphone, a GPU, an AI accelerator or a 2 nm processor and ask how to preserve it.
But that may be the wrong question.
If civilization suffered a sufficiently severe technological disruption, preserving a modern smartphone design would not be enough.
We might not have the fabs capable of manufacturing it.
We might not have the chemicals.
We might not have the equipment.
We might not have the packaging infrastructure.
We might not have the software tools.
We might not even have computers capable of running the tools needed to recreate the design.
The more useful thing to preserve is therefore the ladder.
Perhaps:
Hand tools ↓ Machine tools ↓ Electrical machinery ↓ Basic electronics ↓ Transistors ↓ 130 nm ICs ↓ 130 nm computer ↓ 90 nm computer ↓ 65 nm computer ↓ 45 nm computer ↓ 28 nm computer ↓ Advanced computing
At every stage, the civilization should possess enough knowledge to reach the next stage.
The Ultimate GVCS Metric
This suggests a new metric for the Global Village Construction Set.
Instead of asking:
“How many machines have we built?”
we should ask:
“How many future capabilities can this capability unlock?”
A pottery kiln is valuable because it produces ceramics.
Ceramics enable crucibles.
Crucibles enable metallurgy.
Metallurgy enables machine tools.
Machine tools enable semiconductor equipment.
Semiconductors enable computers.
Computers enable advanced engineering.
Advanced engineering enables better semiconductor equipment.
And so the loop closes.
The greatest GVCS machines are therefore not necessarily the largest or most impressive machines.
They are the machines that unlock the largest number of future capabilities.
The Digital Seed Vault Is Not About Doomsday
It is tempting to interpret an idea like this purely as a disaster-preparation exercise.
That would miss the larger point.
Preparing for technological discontinuity also creates useful technology for ordinary times.
An open 130 nm process is useful for education.
It is useful for research.
It is useful for universities.
It is useful for industrial control.
It is useful for low-cost embedded systems.
An efficient low-computing software ecosystem is useful for developing countries, schools, old computers, offline systems and resource-constrained environments.
Open engineering documentation is useful even when civilization is functioning perfectly.
Open EDA is useful to researchers and startups.
Open processors are useful to engineers.
Offline knowledge repositories are useful in places with unreliable connectivity.
In other words, resilience and normal technological development can reinforce each other.
The Real Goal Is Not to Stay at 130 nm
This is perhaps the most important clarification.
The Digital Seed Vault should not become an argument that 130 nm is “good enough” forever.
It isn't.
Modern civilization will continue moving toward more advanced semiconductor technologies because smaller processes can enable greater performance, efficiency and integration when combined with suitable architecture and manufacturing.
The point of 130 nm is different.
It is a floor.
A technological floor from which civilization can rebuild.
If we can preserve the ability to manufacture a 130 nm-class integrated circuit, build a general-purpose computer from it, compile software on that computer, design new hardware with it and preserve the knowledge needed to improve the process, then we have preserved something far more valuable than an old processor.
We have preserved a path back into the digital age.
The Digital Civilization Loop
Perhaps this is ultimately what our revised GVCS should look like:
NATURAL RESOURCES
↓
BASIC MATERIALS
↓
MACHINE TOOLS
↓
INDUSTRIAL PROCESSES
↓
ELECTRONICS
↓
OPEN 130 nm SEMICONDUCTOR
↓
OPEN COMPUTER
↓
LOW-COMPUTING OS
↓
OPEN APPLICATIONS
↓
ENGINEERING SOFTWARE
↓
OPEN EDA / CAD
↓
NEXT-GENERATION HARDWARE
↓
MORE ADVANCED PROCESS
↓
BETTER COMPUTER
│
└───────────────┐
↓
IMPROVED INDUSTRY
↓
IMPROVED GVCS
This is no longer merely a collection of machines.
It is a civilization recovery system.
From Seed Vault to Civilization Vault
The Svalbard Global Seed Vault preserves biological possibilities.
A Digital Seed Vault would preserve technological possibilities.
One protects the diversity required to grow food.
The other would protect the knowledge required to grow technology.
Neither guarantees that civilization will survive every possible catastrophe.
But both follow the same profound principle:
Do not assume that the future will always have access to everything the present takes for granted.
Preserve the starting points.
Preserve the instructions.
Preserve the diversity.
Preserve the tools.
And, most importantly, preserve the ability to reproduce them.
Conclusion: Preserve the Ladder
The ultimate purpose of the Global Village Construction Set may therefore not be to build a village that can live independently of the modern world.
That is too small an ambition.
Nor is it to recreate every modern product.
That is too large and probably impossible as a single project.
The deeper objective is to preserve the capability ladder of civilization.
Wood should lead to tools.
Tools should lead to machines.
Machines should lead to industry.
Industry should lead to electronics.
Electronics should lead to semiconductors.
Semiconductors should lead to computers.
Computers should lead to software.
Software should lead to engineering.
Engineering should lead to better machines and better semiconductors.
And the cycle should continue.
The 130 nm computer is therefore not the destination.
It is the first digital seed.
If a future generation ever needs to rebuild the information civilization from a much lower technological base, it should not have to rediscover computing from scratch.
It should be able to open the vault.
Find the semiconductor process.
Find the processor.
Find the compiler.
Find the operating system.
Find the engineering tools.
Build the computer.
And then begin climbing again.
That is what a truly global village construction set should ultimately preserve: not merely the machines of civilization, but the ability of civilization to rebuild its own machines.
