The Indian Computing Ecosystem: Own the Everyday, Rent the Extraordinary

How Dholera, RISC-V, 22nm FD-SOI, open hardware, Ubuntu and Indian data centres could combine to create a three-tier computing ecosystem — without India ever needing to win the race to the smallest transistor.

Note on the scenario: This article deliberately separates what exists today from what could be built over the next several years. Tata Electronics currently describes the Dholera fab as a planned 300mm facility with 50,000 wafers per month of capacity for analogue and logic products in the 28nm–110nm range. Tata has also described access to a broader PSMC technology portfolio including 28nm, 40nm, 55nm, 90nm and 110nm. The 22nm FD-SOI stage discussed later is therefore a future scenario, not a current Dholera commitment.

The question is no longer whether India can build a computer

Imagine looking back from 2032.

India has a domestic semiconductor industry. Dholera is producing chips. Indian companies design RISC-V processors and specialised accelerators. Linux runs on domestically designed silicon. Indian universities routinely tape out chips. Data centres across the country offer rented AI and high-performance computing capacity.

And there is something else that would have seemed improbable a decade earlier.

Millions of Indians are using computers whose most important silicon was designed and manufactured within an Indian-led ecosystem.

They are not necessarily the fastest computers in the world.

They do not need to be.

They are fast enough.

They are efficient.

They are inexpensive enough.

They run familiar software.

They are upgradeable.

And when their users occasionally need vastly more computing power, they connect to Indian data centres and rent it.

That is the idea behind what I would call the Indian Computing Ecosystem.

It is not an attempt to build an Indian equivalent of Apple, NVIDIA, Qualcomm, Microsoft and TSMC simultaneously.

It is something more pragmatic.

Build a domestic computing platform that is good enough for the majority, open enough to evolve, large enough to attract developers, and connected enough to outsource the workloads that genuinely require leading-edge computing.

And surprisingly, the foundation for such a strategy may not require India to manufacture the world's smallest transistor.

It may require something closer to a well-designed 22nm-class system.

The first principle: stop confusing transistor size with user experience

Much of the semiconductor industry is described as a race:

7nm.

5nm.

3nm.

2nm.

1.4nm.

And eventually whatever comes after that.

For semiconductor engineers, these advances are enormously important.

For the average user, however, the transistor node is almost irrelevant.

A user experiences:

• how quickly an application opens;
• how responsive the interface feels;
• how smoothly video plays;
• how long the battery lasts;
• how quickly a webpage renders;
• how well multitasking works;
• how quickly a photograph is processed;
• how good the AI assistant feels;
• how quickly the computer wakes from sleep;
• how quietly it operates.

None of those experiences is determined by transistor size alone.

Architecture matters.

Cache design matters.

Memory bandwidth matters.

Storage matters.

Software matters.

Compilers matter.

GPU architecture matters.

Dedicated video engines matter.

Neural accelerators matter.

Power management matters.

And perhaps most importantly, hardware and software have to be designed together.

This is where the Indian opportunity becomes interesting.

The Dholera starting point

The Dholera semiconductor fab being developed by Tata Electronics in partnership with Taiwan's Powerchip Semiconductor Manufacturing Corporation, or PSMC, is the physical anchor for this discussion.

Tata currently describes the facility as a 300mm fab with planned monthly capacity of 50,000 wafers, serving analogue and logic applications in the 28nm–110nm range. Tata says the chips are intended for markets including automotive, computing, communications, AI, IoT and data storage.

Tata's more recent description of its technology partnerships says PSMC provides access to a technology portfolio including 28nm, 40nm, 55nm, 90nm and 110nm.

This is important because it immediately changes the question India should be asking.

It does not have to begin by asking:

“How do we manufacture a 1.4nm processor?”

It can ask:

“What useful computers can we build with the processes we have?”

That is a much more productive question.

Generation One: build the computer before trying to build the perfect computer

Suppose the first commercially useful domestic logic platform available to Indian designers is around the 40nm-class level.

That should not be regarded as a failure.

It should be regarded as Generation One.

The first objective should be to create a functional, modular computer around domestic silicon.

Not an ultrabook.

Not a MacBook killer.

Not a flagship gaming machine.

A development computer.

A machine that can boot Linux, browse the web, run office applications, compile software, play video, connect to networks and serve as a platform on which thousands of engineers and students can develop the next generation of Indian silicon.

This is where the philosophy of MNT Reform becomes particularly relevant.

MNT has designed its Reform systems around modularity. Its processor is implemented as a replaceable System-on-Module connected to the motherboard through a 200-pin connector. MNT has produced multiple compatible processor modules and explicitly documents the hardware so that others can design replacement modules.

That is almost exactly the architecture India needs for an experimental domestic computing platform.

The laptop becomes a carrier for evolving silicon

Consider the traditional laptop.

Its CPU is soldered to the motherboard.

The memory is soldered or tightly integrated.

The GPU is integrated into the SoC.

When the processor generation changes, the entire computer usually changes.

The modular approach reverses that relationship.

The computer becomes the stable platform.

The compute module becomes the evolving component.

                 MODULAR INDIAN COMPUTER

       ┌─────────────────────────────────────┐
       │ Display                             │
       │ Keyboard                            │
       │ Battery                             │
       │ USB                                 │
       │ Audio                               │
       │ Storage                             │
       │ Networking                          │
       │ Power management                    │
       │                                     │
       │       ┌───────────────────┐         │
       │       │  COMPUTE MODULE   │         │
       │       │                   │         │
       │       │ RISC-V CPU        │         │
       │       │ GPU               │         │
       │       │ NPU               │         │
       │       │ Memory controller │         │
       │       │ Security          │         │
       │       └───────────────────┘         │
       │                                     │
       └─────────────────────────────────────┘

Generation One goes into the machine.

Generation Two replaces it.

Generation Three replaces it again.

The keyboard doesn't need to change.

The screen doesn't need to change.

The chassis doesn't need to change.

The storage doesn't necessarily need to change.

The software ecosystem largely survives.

The silicon improves.

That is a fundamentally different way of designing a computing ecosystem.

Why MNT Reform is such an important precedent

MNT's experience demonstrates that this isn't merely a theoretical architecture.

The company has already created multiple processor modules for Reform systems, including the RKX7 FPGA module. Its architecture allows different modules to contain very different SoCs or an FPGA while sharing a common motherboard.

The RKX7 is particularly relevant because it allowed an FPGA-based RISC-V system to become a real laptop computer rather than remaining an isolated laboratory development board.

That is an important distinction.

An FPGA development board tells an engineer whether the design works.

A laptop tells thousands of users whether the system works.

Those are very different tests.

The first Dholera computer should therefore be a learning machine

Imagine a first-generation Indian compute module based on an open RISC-V processor such as SHAKTI or CVA6, combined with open or licensable peripherals and accelerators.

A reasonable engineering target could look something like this:

Component	Generation One target
Process	40nm-class, subject to actual Dholera/PSMC availability
CPU	RISC-V, approximately 1GHz target
Memory	4–8GB baseline; higher-capacity modules where practical
Memory technology	DDR3/DDR4-class, depending on available PHY/controller technology
GPU	Modest integrated or adjacent accelerator
NPU	Basic edge-AI accelerator
Storage	128GB or more, preferably modular
Operating system	Linux/Ubuntu
Form factor	Thicker, repairable, modular laptop

None of these numbers should be treated as a guaranteed consequence of a 40nm process.

A 40nm process does not automatically produce a 1GHz CPU, just as a 22nm process does not automatically produce a modern laptop processor.

Clock frequency depends on architecture, libraries, SRAM, physical implementation, voltage, thermal design and timing closure.

The point is to establish a credible target for a first-generation platform.

The first generation does not need to be competitive

This is perhaps the most important economic insight.

The first domestic computer does not have to beat Intel.

It does not have to beat AMD.

It does not have to beat Apple.

It does not have to beat Qualcomm.

It certainly does not need to beat NVIDIA.

It needs to teach India how to build the entire system.

That means discovering:

• which RISC-V core is easiest to productise;
• which memory architecture works;
• how to integrate the GPU;
• how to integrate the NPU;
• how to bring up Linux;
• how to write and upstream drivers;
• how to handle power management;
• how to debug PCIe;
• how to build reliable storage interfaces;
• how to qualify the package;
• how to manufacture thousands of modules;
• how to support customers.

That knowledge is the real product of Generation One.

Generation Two: 28nm changes the equation

Now imagine that the ecosystem has spent several years learning.

The second compute module is designed around a 28nm-class process.

The CPU gets more capable.

The cache gets larger.

The memory subsystem improves.

The GPU becomes more useful.

The NPU becomes a serious local AI engine.

Video encode/decode becomes hardware accelerated.

Power management improves.

The software stack is already mature.

Most importantly, the new module plugs into essentially the same computer.

This is where the original “development laptop” starts turning into a genuine mainstream computer.

The software investment compounds

Imagine spending three years getting the first generation of the platform to work properly.

By then, engineers have fixed:

• boot firmware;
• Linux kernel support;
• memory initialisation;
• USB;
• PCIe;
• NVMe;
• Ethernet;
• display;
• audio;
• GPU drivers;
• power management;
• suspend and resume;
• firmware update mechanisms;
• security infrastructure.

The second-generation CPU does not have to reinvent all of this.

The software stack moves forward with the hardware.

This is where RISC-V's use of standard profiles becomes particularly important.

Canonical has adopted RVA23 as the baseline for modern Ubuntu RISC-V support, creating a common hardware/software foundation intended to reduce fragmentation between different RISC-V implementations.

That is precisely what a multi-generation Indian hardware ecosystem would need.

We should not build one Indian CPU

This is another important conclusion.

India does not need to declare one RISC-V processor to be the Indian processor.

That would recreate the very centralisation that open hardware is supposed to avoid.

Instead, India could establish a common platform specification.

Something like:

• RISC-V application profile;
• standard memory model;
• standard boot architecture;
• standard interrupt mechanisms;
• standard PCIe/NVMe interfaces;
• standard security requirements;
• standard graphics interfaces;
• standard NPU runtime interfaces;
• standard Linux support requirements.

Then multiple CPU designs could compete.

SHAKTI could compete with CVA6.

A future Indian out-of-order CPU could compete with both.

A startup could develop its own core.

A foreign company could participate.

The software platform would remain relatively stable.

The platform survives the processor.

That is where an “Indian Computing Platform” becomes possible

Think of it as a certification rather than a single chip.

Indian Computing Platform — hypothetical specification

• ISA: RISC-V
• Baseline: RVA23 or an appropriate future profile
• OS: Linux/Ubuntu
• Security: open or independently auditable Root of Trust
• Storage: NVMe/SATA/standard removable interfaces
• Networking: standard Ethernet and wireless modules
• Graphics: standard Linux graphics stack
• AI: standardised accelerator APIs
• Firmware: open, documented interfaces wherever possible

The objective would not be to dictate the CPU.

The objective would be to dictate the contract between hardware and software.

RISC-V profiles are particularly important because common profiles provide a predictable baseline that software can target across different processor implementations while still allowing hardware vendors to innovate.

That is exactly the balance India would need:

standardise enough to preserve compatibility; remain open enough to preserve innovation.

Generation Three: the 22nm FD-SOI possibility

This is where the story becomes much more interesting.

Suppose that after the first generations of Dholera manufacturing and Indian design experience, India establishes a partnership with an experienced FD-SOI foundry ecosystem — potentially involving GlobalFoundries technology, licensing, process-development collaboration or another appropriate technology-transfer structure.

Again, this is a scenario, not a current announcement.

The important point is that India would no longer be approaching such a technology from a standing start.

It would have experience with:

• domestic wafer manufacturing;
• process bring-up;
• PDKs;
• standard cells;
• SRAM;
• physical design;
• RISC-V silicon;
• accelerator integration;
• packaging;
• Linux enablement;
• real-world products.

That accumulated experience would make a future technology transition considerably more meaningful than simply saying “let's now build 22nm.”

Why 22nm FD-SOI is attractive

GlobalFoundries' 22FDX is a particularly interesting reference point.

22FDX is a 22nm fully depleted silicon-on-insulator technology designed around performance, power and integration rather than simply chasing maximum transistor density. GlobalFoundries has positioned the platform for applications including IoT, mobile, RF, automotive and edge AI.

That history matters.

It demonstrates that a 22nm-class FD-SOI technology can be commercially relevant at enormous scale.

It is not a theoretical laboratory process.

It is also interesting because FD-SOI provides designers with body-bias techniques that can be used to trade performance and power dynamically.

That makes it an intriguing technology for computers where efficiency matters as much as peak performance.

The 22nm computer should not try to be a 1.4nm computer

This is the central argument of the entire ecosystem.

Suppose a 22nm FD-SOI Indian SoC is substantially slower than the leading processor available from Apple, AMD, Intel or Qualcomm.

That does not automatically make it a bad computer.

Imagine instead that it provides:

• 8 or more capable RISC-V cores;
• vector processing;
• a competent GPU;
• a dedicated NPU;
• hardware video encode/decode;
• strong memory bandwidth;
• fast NVMe storage;
• 16–32GB of memory;
• excellent power management;
• well-optimised Linux drivers;
• native applications.

For web browsing, office work, software development, education, video consumption, communications and ordinary AI-assisted workloads, the user may perceive the computer as fast.

The transistor node disappears from the user's consciousness.

They experience responsiveness.

That is the real target.

“Own the everyday. Rent the extraordinary.”

This leads to what may be the most useful phrase for the entire concept:

Own the everyday. Rent the extraordinary.

The mainstream Indian computer does not need to perform every imaginable workload locally.

It needs to perform the overwhelming majority of everyday tasks locally and efficiently.

When the user needs extraordinary computing power, that power can be rented from the cloud.

This produces a three-tier computing architecture.

Tier	Technology	Purpose
Tier 1	Domestic 22nm-class SoC	Mainstream personal computing
Tier 2	Leading-edge foreign/advanced silicon	Premium local computing
Tier 3	Indian data centres using advanced global compute	Extreme and elastic workloads

These three tiers do not have to compete.

They complement each other.

Tier One: the Indian mainstream machine

This is the market that could become enormous.

The target could be a laptop costing perhaps ₹40,000–₹70,000 in today's purchasing-power terms, depending on memory, display and other components.

It would not necessarily have the fastest CPU.

It would not necessarily have the fastest GPU.

But it could have something more important:

a very high performance-to-cost ratio for ordinary workloads.

The machine might be slightly thicker than the latest ultrabook.

It might have replaceable modules.

It might have an unusually accessible service design.

And it could have a key feature almost completely absent from modern consumer laptops:

the ability to upgrade the computer by replacing the compute module.

The government can provide the anchor market

Here we move from technology into policy.

Suppose India eventually establishes a procurement rule requiring a substantial share of the hardware value of government and government-aided computing equipment to come from Indian-designed or Indian-manufactured components.

This is a hypothetical policy proposal, not an existing mandate.

Suppose further that the resulting addressable institutional base is approximately 20 million users.

The precise number should be treated as a scenario rather than a current official count. Government employment statistics are fragmented across the Union, states, public institutions and government-aided bodies.

But 20 million is useful as a planning assumption.

At 20 million machines:

20 million × ₹50,000 = ₹1 trillion.

That is approximately ₹1 lakh crore of hardware demand over a procurement cycle.

Even if replacement occurred over five years, that represents an average market of roughly four million systems per year.

That is not a niche.

It is an ecosystem anchor.

The government doesn't need to manufacture everything

This is another crucial distinction.

A “domestic hardware” requirement should not mean that every transistor, DRAM chip, display panel and Wi-Fi radio has to be manufactured in India.

That would be counterproductive.

A realistic rule could measure domestic contribution across the system.

A qualifying computer might contain:

• Indian-designed CPU/SoC;
• Indian motherboard;
• Indian power-management electronics;
• Indian security hardware;
• Indian firmware;
• domestically manufactured semiconductor content;
• Indian assembly and testing.

It could still use imported:

• DRAM;
• NAND;
• display panels;
• wireless modules;
• batteries;
• specialised PHYs.

This is how a real industrial ecosystem develops.

Localise the strategic bottlenecks first.

The 20-million-device base becomes more powerful through household exposure

A government deployment of 20 million computers does not necessarily mean 20 million people are the only people who interact with them.

These machines enter homes.

Children use them.

Spouses use them.

Students encounter them.

Relatives encounter them.

Developers encounter them.

Schools and training institutions begin supporting them.

It is therefore reasonable to imagine a future institutional deployment producing an ecosystem exposure of perhaps 80–100 million people or more, depending on household size, secondary users and educational spillovers.

That is not a forecast.

It is a scenario illustrating the network effect.

The important point is that 20 million machines can create a much larger software market.

And software follows the users

Once tens of millions of people are using a common architecture, developers have a reason to support it.

Today, a developer might ask:

“Why should I optimise my application for Indian RISC-V hardware?”

In a 100-million-user ecosystem, the question changes to:

“How do I make my application run exceptionally well on Indian RISC-V hardware?”

That is how platforms become self-reinforcing.

The installed base creates the developer market.

The developer market creates better applications.

Better applications increase adoption.

More adoption increases hardware volumes.

Higher volumes lower costs.

Lower costs increase adoption again.

That is the flywheel India needs.

The role of Ubuntu — or the hypothetical “Canonical India” layer

This is where the software strategy becomes particularly interesting.

There is no current Canonical initiative called “Canonical India” of the kind imagined in this article.

The phrase is best understood as a shorthand for a hypothetical strategic partnership between Canonical, Indian semiconductor companies, OEMs, developers and government institutions.

But the technical foundations already exist.

Canonical has supported RISC-V in Ubuntu since 2021 and has adopted RVA23 as the baseline for modern Ubuntu RISC-V support. Canonical's stated objective is to make RISC-V practical, scalable and production-ready for silicon vendors, OEMs, ODMs and developers.

This is precisely the kind of software foundation the Indian platform would need.

India should not try to write an operating system from scratch.

It should take advantage of the enormous Linux ecosystem and contribute upstream where Indian hardware needs support.

The operating system should be common even when the CPU changes

Imagine:

Generation One: SHAKTI-based computer.

Generation Two: CVA6-based computer.

Generation Three: a new Indian out-of-order RISC-V processor.

If all three implement an appropriate common RISC-V profile and platform specification, the same Ubuntu ecosystem can continue across generations.

That is incredibly valuable.

The operating system becomes the stable layer.

The CPU becomes replaceable.

The GPU becomes replaceable.

The NPU becomes replaceable.

The compute module becomes a component rather than the identity of the computer.

RISC-V profiles are particularly valuable here because they provide a common feature baseline that software can target across different implementations while still allowing hardware vendors to innovate.

Native applications: the argument is stronger than “Android is virtualised”

There is an important technical correction here.

Android is not simply a Java virtual machine interpreting every application instruction at runtime. Modern Android uses the Android Runtime, or ART, with ahead-of-time and just-in-time compilation, and Android applications can also use native C/C++ code.

The stronger argument for an Indian Ubuntu/RISC-V ecosystem is different.

It is the possibility of having a relatively direct software path from:

application → native libraries → Linux → RISC-V → hardware accelerators.

Developers could build directly for the platform.

Compilers could target the processor.

Libraries could target the vector engine.

AI frameworks could target the NPU.

Graphics libraries could target the GPU.

Video frameworks could target dedicated codecs.

And the entire stack could be tuned together.

RISC-V also permits hardware-specific extensions, allowing specialised processors to expose additional capabilities without abandoning the broader architecture.

That is the real opportunity.

The smartphone becomes the second major battlefield

Once the laptop platform exists, the same philosophy can move into mobile devices.

A future Indian mobile SoC could combine:

• RISC-V CPU cores;
• vector processing;
• GPU;
• NPU;
• ISP;
• video engines;
• security;
• display processing;
• memory controllers.

The difficult component is likely to remain cellular connectivity and some of the high-speed analogue/PHY infrastructure.

India does not need to solve every component simultaneously.

It can localise the processor and compute architecture first while continuing to use licensed or imported specialist IP where necessary.

That is not a failure of sovereignty.

It is rational engineering.

The smartphone does not need to contain the world's fastest processor either

A 22nm-class mobile SoC could potentially be perfectly adequate for:

• messaging;
• web browsing;
• photography;
• video;
• social applications;
• navigation;
• office applications;
• local AI assistance;
• education;
• communications.

The workloads that require massive compute can move elsewhere.

This creates a natural connection between the device and the data centre.

Tier Two: the premium foreign machine

Nothing in this model requires India to eliminate foreign hardware.

Quite the opposite.

There will always be users who want the fastest machine available.

A professional video editor may want the latest high-end GPU.

A game developer may want a cutting-edge graphics processor.

A researcher may want enormous local memory.

An AI engineer may want multiple high-end accelerators.

A workstation user may need maximum CPU performance.

Those users can buy:

• Apple;
• AMD;
• Intel;
• NVIDIA;
• Qualcomm;
• Lenovo;
• Dell;
• ASUS;
• HP;
• and other global products.

The domestic platform does not have to defeat them.

It simply needs to dominate — or become highly competitive in — the enormous middle.

That is a far more achievable ambition.

Tier Three: compute as a utility

Now comes the data-centre layer.

Suppose India develops a large domestic ecosystem of AI and high-performance computing facilities.

The precise processors and process nodes used by those facilities will evolve rapidly, so there is little value in predicting exactly which node will dominate a decade from now.

The strategic idea is simpler:

Indian users should be able to rent advanced computing from Indian infrastructure.

A user with a modest domestic laptop could connect to:

• GPU clusters;
• AI accelerators;
• high-memory servers;
• rendering infrastructure;
• scientific-computing clusters;
• large language models;
• specialised enterprise compute.

The device becomes the local intelligence and interface.

The data centre becomes the elastic horsepower.

This is where the economics become attractive

Imagine a user who occasionally needs a machine worth ₹300,000.

They might need it for only a few hours a week.

Why should they own it?

They could instead own a ₹50,000–₹70,000 mainstream domestic computer and rent high-performance compute when required.

The same principle already operates in cloud computing.

The difference is that the local device remains powerful enough to provide an excellent everyday experience.

It isn't merely a thin client.

It is a genuine computer.

Own the everyday. Rent the extraordinary.

The cloud also creates an escape hatch for the 22nm platform

This is important because otherwise critics will quite reasonably ask:

“What happens when 22nm is no longer competitive?”

The answer is:

It doesn't have to be competitive with everything.

The 22nm computer handles the local workload.

The premium user buys leading-edge hardware.

The rest use cloud compute when necessary.

That means the domestic platform can remain economically viable even as the global semiconductor industry continues to advance.

India therefore doesn't have to win the transistor race

This is perhaps the most provocative proposition in the entire article.

India does not necessarily need to manufacture the smallest transistor in the world to create a sovereign computing ecosystem.

It needs to control enough of the stack.

It needs:

• domestic semiconductor manufacturing;
• domestic processor design;
• domestic accelerator expertise;
• domestic system design;
• domestic packaging and testing;
• domestic software engineering;
• domestic cloud infrastructure;
• access to global leading-edge technology where appropriate.

That is sovereignty through optionality, not isolation.

The Netherlands and ASML matter here

This is also why India's semiconductor strategy should not be framed as autarky.

India needs global partners.

Tata Electronics and ASML have announced a strategic partnership under which ASML will support the establishment and ramp-up of the Dholera fab with lithography tools, training, supply-chain development and R&D infrastructure.

This is exactly the kind of international collaboration an Indian computing ecosystem should encourage.

India doesn't need to reinvent lithography.

It needs to become exceptionally good at using lithography.

India-Netherlands collaboration could become part of the design loop

The emerging India-Netherlands semiconductor relationship makes this even more interesting.

The two countries have outlined semiconductor collaboration involving the Dutch semiconductor ecosystem, India's Semiconductor Mission, European universities and Indian technical institutes, with industry participation from companies including NXP, ASML and Tata.

That means the ecosystem can connect:

Indian universities → Dutch semiconductor expertise → ASML → Tata → Dholera → Indian startups → Indian products.

This is precisely the kind of network required to move from semiconductor assembly and fabrication into genuine design capability.

The open-silicon stack becomes the design commons

Now return to the open-hardware projects discussed in the earlier article.

They begin to make sense as components of the larger ecosystem.

Layer	Possible open starting points	Role
ISA	RISC-V	Common processor architecture
CPU	SHAKTI, CVA6, BlackParrot, VexRiscv	General-purpose compute
High-performance CPU	XiangShan, BOOM, future Indian designs	Advanced local compute
Vector	Ara/PULP ecosystem	SIMD and AI workloads
GPU	Vortex and related projects	Parallel compute/graphics research
NPU	Coral NPU, NVDLA, Gemmini	AI acceleration
ISP	Infinite-ISP	Camera processing
Video	Fudan OpenASIC	Video encode/decode
Storage	IITM NVMe/OpenSSD ecosystem	Storage controllers
Security	OpenTitan	Root of Trust
SoC infrastructure	LiteX and related cores	Integration and peripherals
Physical design	OpenROAD/OpenLane	RTL-to-GDS development
Operating system	Linux/Ubuntu	Software platform

The important change in perspective is this:

These projects aren't the product.

They are ingredients.

The product is the integrated platform.

The missing middle is system integration

This is where the earlier discussion about MNT Reform becomes crucial.

There are plenty of open CPU projects.

There are open GPUs.

There are open NPUs.

There are open ISPs.

There are open storage controllers.

There are open security architectures.

But putting all of them together is a separate engineering discipline.

The real chain is:

Open ISA
   ↓
CPU
   ↓
SoC integration
   ↓
Memory
   ↓
GPU / NPU / ISP / Video
   ↓
Security
   ↓
PCIe / USB / Ethernet / NVMe
   ↓
Firmware
   ↓
Linux
   ↓
Drivers
   ↓
Physical design
   ↓
Tapeout
   ↓
Dholera
   ↓
Package
   ↓
Compute module
   ↓
Laptop / desktop / phone
   ↓
Real users

That is the actual project.

Why the first laptop should be deliberately modular

A conventional semiconductor company might design the SoC, design the motherboard, solder everything together and launch the product.

That creates a giant single point of failure.

If the CPU is wrong, the product is wrong.

If the memory controller is wrong, the product is wrong.

If the GPU driver is poor, the product is poor.

The modular approach allows the problems to be isolated.

The motherboard can mature separately.

The compute module can mature separately.

The operating system can mature separately.

The storage can mature separately.

And when the silicon changes, the rest of the platform survives.

MNT's Reform architecture is a practical demonstration of this philosophy: the company's processor modules share a common motherboard interface, while different modules can contain very different SoCs or an FPGA.

Generation Four could finally become the ultrabook

This is where the roadmap comes full circle.

The first machine might be thick.

The second might be a conventional laptop.

The third might be genuinely competitive.

The fourth could be thin and light.

And by then, the industry would have accumulated years of experience.

	Generation One	Generation Two	Generation Three
Process	40nm-class*	28nm-class	22nm-class FD-SOI*
CPU	~1GHz target	Higher performance	Advanced RISC-V/OoO
Memory	4–8GB DDR3/DDR4	8–16GB DDR4-class	16–32GB DDR5-class*
GPU	Basic	Useful	Competitive mainstream
NPU	Experimental	Practical edge AI	Integrated AI engine
Storage	128GB+	256GB+	512GB–1TB+
Form factor	Development laptop	Normal laptop	Thin/light

*Illustrative engineering scenario, not a committed Dholera technology roadmap.

The important thing is that the generations are not independent.

They are cumulative.

The first generation creates the engineers who build the second

This is the real advantage.

Suppose 5,000 engineers work on Generation One.

They learn the process.

They learn the PDK.

They learn physical design.

They learn packaging.

They learn Linux.

They learn drivers.

They learn power management.

They learn what breaks in real computers.

Then those engineers move to Generation Two.

Some create startups.

Some join universities.

Some join Tata.

Some join Indian semiconductor design houses.

Some work on data centres.

The ecosystem becomes larger than the original project.

That is how semiconductor capability compounds.

The government should therefore fund the learning curve, not just the finished product

This is where public policy can be unusually powerful.

Instead of funding one “Indian processor” and declaring victory, government programmes could fund:

• open IP development;
• verification;
• MPW shuttle runs;
• university tapeouts;
• PDK access;
• shared EDA infrastructure;
• open reference boards;
• RISC-V software development;
• Linux upstreaming;
• compiler optimisation;
• accelerator software;
• packaging research;
• system-level reference designs.

The government could effectively create a national semiconductor learning loop.

Every tapeout teaches something.

Every failed tapeout teaches something.

Every laptop sold generates another layer of feedback.

Every software bug becomes an engineering lesson.

Every generation gets better.

The 20-million-user government market can make that learning loop commercial

This is the crucial transition from government-funded research to industry.

If the government becomes an anchor customer, companies can justify building products around the platform.

A laptop manufacturer knows there is a market.

A semiconductor company knows there is a market.

A software company knows there is a market.

A developer knows there is a market.

A cloud provider knows there is a market.

The ecosystem begins to reinforce itself.

There should still be a premium foreign market

And this is where the proposal becomes much more realistic than nationalist technology programmes often are.

India should not ban high-end foreign computers.

It should not prevent Indian consumers from buying the best technology available.

If someone wants the world's fastest workstation, let them buy it.

If someone wants an expensive gaming laptop, let them buy it.

If a professional needs a specialised accelerator that India does not manufacture, let them import it.

The objective is not isolation.

The objective is to make sure that India has a domestic alternative in the mainstream market.

And the premium market can actually help the domestic ecosystem

Foreign companies would continue competing in India.

That competition would push the domestic ecosystem to improve.

Indian companies could learn from global products.

Premium users would have choices.

Domestic developers could benchmark against the world's best.

And when Indian silicon became good enough, it could compete internationally.

This is much healthier than trying to protect a domestic product from competition indefinitely.

Data centres complete the pyramid

The final layer is the data centre.

At the bottom is the mass-market domestic computer.

In the middle is the premium workstation.

At the top is elastic cloud computing.

That gives us:

                  INDIAN COMPUTING ECOSYSTEM

                     ┌───────────────┐
                     │ DATA CENTRES  │
                     │               │
                     │ AI / HPC      │
                     │ Advanced CPUs │
                     │ GPUs / NPU    │
                     │               │
                     └───────┬───────┘
                             │
                       Cloud services
                             │
        ┌────────────────────┴────────────────────┐
        │                                         │
┌───────▼────────┐                         ┌──────▼───────┐
│ PREMIUM LOCAL  │                         │ MAINSTREAM   │
│ COMPUTING      │                         │ DOMESTIC     │
│                │                         │ COMPUTING    │
│ Leading-edge   │                         │              │
│ foreign silicon│                         │ 22nm-class   │
│                │                         │ RISC-V       │
└────────────────┘                         └──────────────┘

The user can move between all three.

The mainstream machine handles everyday tasks.

The premium machine handles demanding local workloads.

The cloud handles extraordinary workloads.

There is no requirement that one device do everything.

This could also change the economics of AI

AI is often presented as a reason every device needs an enormous accelerator.

That isn't necessarily true.

A domestic NPU can handle:

• speech recognition;
• image enhancement;
• background noise reduction;
• translation;
• small language models;
• document classification;
• local summarisation;
• camera processing;
• privacy-sensitive inference.

Large models can remain in the cloud.

This creates a useful division:

Local AI for privacy, latency and cost.

Cloud AI for scale.

A 22nm SoC with a well-designed NPU could therefore remain highly relevant even while the largest AI models run on much more advanced hardware elsewhere.

The same philosophy applies to graphics

An Indian mainstream GPU does not need to compete with the world's most powerful gaming GPUs.

It needs to provide:

• smooth desktop graphics;
• video playback;
• hardware composition;
• light 3D;
• accelerated browsers;
• developer graphics;
• basic gaming.

Users who require professional rendering or high-end gaming can move to premium hardware or cloud GPU services.

That is a rational allocation of silicon.

The real competitive advantage becomes optimisation

This is where the 22nm thesis becomes strongest.

If India controls the CPU design, NPU design, operating system integration and application optimisation, it can compensate for some of the process disadvantage.

A workload that would normally require a powerful CPU can be moved to the NPU.

A video workload can be handled by dedicated hardware.

A vector workload can use vector extensions.

A graphics workload can use the GPU.

A repetitive workload can use a custom accelerator.

The CPU doesn't have to do everything.

The system does the work.

This is why the open-silicon strategy is more than a licensing strategy

It is tempting to think the attraction of open hardware is simply avoiding royalties.

That is too small a view.

The bigger advantage is control over architecture.

If an Indian company owns or can legally modify the CPU architecture, it can change the processor.

If it controls the NPU, it can change the accelerator.

If it controls the compiler, it can optimise the software.

If it controls the OS integration, it can tune the system.

If it controls the manufacturing relationship, it can optimise the design for the process.

That is where the economic value lies.

Dholera then becomes more than a fab

The ultimate strategic objective should not be to make Dholera a factory that manufactures chips designed elsewhere.

That would still be valuable.

But the larger prize is:

design → manufacture → package → deploy → learn → redesign.

That loop should happen increasingly within the Indian ecosystem.

Tata's existing partnerships point in this direction, with collaboration spanning process technology, PDK development, IP creation, design-technology co-optimisation, manufacturing equipment, training and R&D.

That is exactly the infrastructure required for a design-manufacturing feedback loop.

India-Netherlands collaboration could become part of the design loop

The emerging India-Netherlands semiconductor relationship makes this even more interesting.

The two countries have outlined semiconductor collaboration involving the Dutch semiconductor ecosystem, India's Semiconductor Mission, European universities and Indian technical institutes, with industry participation from companies including NXP, ASML and Tata.

That means the ecosystem can connect:

Indian universities → Dutch semiconductor expertise → ASML → Tata → Dholera → Indian startups → Indian products.

This is precisely the kind of network required to move from semiconductor assembly and fabrication into genuine design capability.

The long-term objective should be optionality

By the early 2030s, India does not need to say:

“We manufacture everything ourselves.”

That is neither realistic nor desirable.

It should be able to say:

“We have options.”

We can design our own CPU.

We can modify our own CPU.

We can manufacture selected chips domestically.

We can package them domestically.

We can run our own software.

We can build our own cloud.

We can buy leading-edge foreign hardware when it makes sense.

We can switch architectures when necessary.

We can develop alternatives when supply chains are disrupted.

That is technological sovereignty.

And this is where the 22nm idea becomes surprisingly powerful

A 22nm device does not need to beat a 1.4nm device.

It needs to be:

• cheap enough;
• efficient enough;
• fast enough;
• well supported;
• available at scale;
• upgradeable;
• secure;
• open enough to evolve.

If it can satisfy those conditions, it can become the foundation of a massive computing ecosystem.

The premium 1.4nm-class system can exist alongside it.

The data centre can sit above both.

The user can move between them without even thinking about transistor technology.

The Indian Computing Ecosystem is therefore not one chip

It is a hierarchy.

Layer	Indian strategic objective
Open IP	Create reusable CPU, GPU, NPU, ISP, security and peripheral building blocks
Domestic silicon	Turn those blocks into manufacturable SoCs
Dholera	Provide a domestic manufacturing anchor
Modular computers	Provide real-world platforms for successive generations of silicon
Ubuntu/Linux	Provide a common software foundation
Government demand	Create an anchor market
Mass market	Create scale and developer demand
Premium market	Provide access to leading-edge foreign technology
Data centres	Provide elastic high-performance computing
Global partnerships	Keep India connected to leading technology ecosystems

The most important product might therefore be the platform

It is tempting to ask:

“Which Indian CPU will win?”

That may be the wrong question.

The better question is:

“Can India create a computing platform in which multiple CPUs, accelerators and generations of silicon can compete while the software and system ecosystem remains stable?”

If the answer becomes yes, then no single processor has to win.

Several can coexist.

Some will be embedded.

Some will be mobile.

Some will be laptop processors.

Some will be servers.

Some will be AI accelerators.

Some will fail.

Others will succeed.

The ecosystem survives all of them.

The ultimate roadmap

The entire strategy can be reduced to a surprisingly simple progression.

Stage One: use the currently accessible PSMC/Dholera process technology to build a modest domestic SoC.

Stage Two: put it into a modular, MNT Reform-style computer.

Stage Three: give those computers to developers, universities, government institutions and early adopters.

Stage Four: use real-world experience to improve the CPU, GPU, NPU, memory subsystem and software.

Stage Five: move to the next Dholera process generation.

Stage Six: repeat the process.

Stage Seven: collaborate internationally on more advanced technologies, potentially including FD-SOI if economically and technically appropriate.

Stage Eight: build a mature 22nm-class mainstream platform.

Stage Nine: deploy it across tens of millions of institutional and consumer systems.

Stage Ten: connect those devices to an Indian cloud/data-centre ecosystem for workloads that exceed local capability.

And eventually:

local device + domestic software + domestic manufacturing + domestic cloud.

The 2030 computer may therefore look very different from the 2026 computer

Not necessarily because the CPU is the fastest.

But because the architecture of computing has changed.

A mainstream Indian laptop could have a domestically designed RISC-V processor fabricated on a mature process.

It could have a powerful NPU that makes local AI feel instantaneous.

It could have an efficient GPU and dedicated video engines.

It could run Ubuntu.

Its applications could be compiled natively for RISC-V.

Its compute module could be replaced when a new generation arrives.

Its user could subscribe to a high-performance Indian cloud when needed.

And the same broad architecture could extend from laptops to desktops, workstations, education systems, government terminals and eventually smartphones.

The result would not be the world's most advanced computer.

It might be something more important:

a computer platform that India controls enough of to keep improving.

Conclusion: India does not have to win the transistor race

There is a seductive idea in technology policy that sovereignty means having the smallest transistor.

It does not.

Technological sovereignty is the ability to make meaningful choices.

India does not need every laptop to contain the world's most advanced processor.

It needs a domestic platform capable of serving the majority of users.

It needs a premium market where the best global hardware remains available.

It needs data centres capable of providing extraordinary computing power when local machines are insufficient.

And it needs the ability to move between those layers without losing control of the underlying ecosystem.

That is why the 22nm FD-SOI idea is interesting.

Not because 22nm is somehow equivalent to 1.4nm.

It isn't.

But because a mature, power-efficient 22nm-class platform may be good enough for an enormous fraction of everyday computing if the architecture, accelerators, memory system and software are designed intelligently.

India could then reserve the most expensive leading-edge computing for the workloads that actually need it.

The mainstream user would own an efficient domestic computer.

The professional could buy an advanced foreign workstation.

The researcher could rent a massive Indian AI cluster.

The student could develop on the same open platform used by the government.

The startup could design an accelerator and eventually put it into silicon.

The university could tape out a processor.

The fab could manufacture it.

The cloud could run it.

And the next generation could improve upon it.

That is the ecosystem.

And perhaps the most important part is that it begins not with a 1.4nm fab, but with something much more achievable:

a modular computer, an open processor, a domestic manufacturing process and enough users to make the entire system economically worthwhile.

The first machine may be thick.

The first processor may be slow.

The first GPU may be modest.

The first NPU may be experimental.

The first version of Ubuntu may have rough edges.

None of that matters.

Because the objective is not to build the perfect Indian computer in one generation.

It is to build a computer that can become better every time the silicon gets better.

And if India can create a 20-million-device institutional anchor, turn that into tens of millions of additional users, attract developers around a stable RISC-V/Linux platform, and connect the whole system to a domestic high-performance cloud, the country would have achieved something far more consequential than a home-grown laptop.

It would have created a national computing platform.

One in which:

the everyday is owned,

the extraordinary is rented,

the silicon keeps evolving,

and the ecosystem never has to start from zero again.

That may ultimately be the more realistic definition of Indian technological sovereignty.