Showing posts with label RISC-V. Show all posts
Showing posts with label RISC-V. Show all posts

Thursday, September 17, 2026

Build the Plinth Before the Statue: Why India Needs an Open Technology Consortium Now

India is building the foundations of a semiconductor industry. It is developing RISC-V capabilities, investing in electronics manufacturing and creating a growing deep-tech ecosystem. But a chip does not become a product simply because it comes out of a fab. Between silicon and the finished product lies an enormous layer of software, tools, drivers, APIs, standards and engineering knowledge. India should start building that layer now.

The Semiconductor Clock Is Not the Only Clock That Matters

India's semiconductor story is beginning to move from policy announcements toward physical infrastructure.

The Tata Electronics semiconductor fab in Gujarat, being established in partnership with Taiwan's Powerchip Semiconductor Manufacturing Corporation (PSMC), has an approved investment of ₹91,526 crore and planned production capacity of approximately 50,000 wafer starts per month. India's semiconductor programme is also supporting OSAT facilities and a growing semiconductor-design ecosystem.

But there is another clock running in parallel.

The software clock.

A semiconductor fab can eventually produce chips. A design company can eventually produce a RISC-V processor. An NPU company can eventually produce an accelerator.

But when those chips arrive, someone has to make them useful.

Someone needs to make them boot.

Someone needs to write the drivers.

Someone needs to make Linux or an RTOS understand the hardware.

Someone needs to make the compiler generate good code.

Someone needs to make the GPU work.

Someone needs to make the NPU accessible to AI frameworks.

Someone needs to make cameras, displays, storage, Wi-Fi, Bluetooth, USB, sensors and power management work.

Someone needs to build the SDK.

Someone needs to test it.

Someone needs to document it.

Someone needs to maintain it five years later.

The time to begin doing that work is before the hardware arrives.

India should not wait for its semiconductor ecosystem to become mature before building the software ecosystem that makes that semiconductor ecosystem useful.

It should build the software ecosystem while the hardware ecosystem is still learning.

The Missing Institution

India already has companies, universities, semiconductor programmes, startups, open-source developers and individual RISC-V initiatives.

What is missing is a large institution whose primary purpose is to connect these efforts at the common infrastructure layer.

Call it, for now, the Indian Open Technology Consortium.

The name is less important than the function.

Its mission should be simple:

Build and maintain the open software, APIs, tools, reference implementations, testing infrastructure and standards required to make modern hardware easy to develop products on.

There is an important distinction in that sentence.

The consortium should not primarily make end-user products.

It should make the tools used to make end-user products.

Build the Plinth, Not Every Statue

Imagine a giant statue.

The statue is what everyone notices. It is the smartphone, automobile, robot, television, refrigerator, industrial machine or computer.

But underneath the statue is the plinth.

The plinth doesn't determine what the statue looks like. It gives the statue a stable foundation.

This is the role the consortium should play.

It should build the plinth.

A smartphone company can build its smartphone.

An automobile company can build its vehicle.

An appliance company can build its refrigerator.

A robotics startup can build its robot.

A semiconductor company can build its processor.

The consortium should make it easier for all of them to build.

That means standardising and maintaining the common layers that do not need to be reinvented by every company.

What Is the Common Layer?

Consider a smart washing machine.

The manufacturer may have proprietary algorithms for determining washing cycles, water consumption, detergent use, vibration and load characteristics.

Those are legitimate areas of differentiation.

But the machine also needs:

  • sensor interfaces
  • motor interfaces
  • networking
  • security
  • firmware updates
  • diagnostics
  • power management
  • storage
  • Bluetooth or Wi-Fi
  • device management

Why should every washing-machine company independently reinvent all of that?

Now consider a smart TV.

It needs:

  • GPU support
  • video decoding
  • audio
  • display drivers
  • HDMI
  • USB
  • networking
  • storage
  • security
  • OTA updates

Again, much of this is plumbing.

The same pattern appears in cars, smart watches, robot vacuums, industrial IoT devices, cameras, medical devices and smartphones.

The opportunity is to make the plumbing reusable.

Standardise the Interface, Not the Innovation

This is perhaps the most important design principle for the consortium.

It should not attempt to standardise the product.

It should standardise the interfaces between the components.

Imagine three different NPU manufacturers.

They have completely different internal architectures.

That is fine.

The application should be able to communicate with them through a common software interface.

                    AI APPLICATION
                          |
                    Common NPU API
                          |
                    AI Runtime
                          |
          +---------------+---------------+
          |               |               |
        NPU A           NPU B           NPU C
          |               |               |
       Vendor A        Vendor B        Vendor C

The same principle can apply to GPUs, cameras, displays, sensors, audio systems, storage, security engines and other hardware.

The consortium's job is not to tell semiconductor companies how to design their chips.

Its job is to ensure that software developers have a predictable way to use those chips.

That is how competition underneath an open interface becomes possible.

RISC-V Makes This Particularly Important

RISC-V is an open standard instruction-set architecture rather than a single processor design. RISC-V International describes its role as maintaining the open standard and related specifications, while implementations and software are developed by the wider ecosystem. The organisation explicitly describes interoperability and shared standards as mechanisms that allow different vendors to compete while building on a common foundation.

That distinction is critical.

RISC-V gives hardware designers freedom.

But freedom at the instruction-set level is only the beginning.

A commercially successful computing ecosystem still needs:

  • compilers
  • debuggers
  • bootloaders
  • operating systems
  • device drivers
  • graphics
  • AI runtimes
  • multimedia
  • security
  • networking
  • development tools
  • documentation
  • testing

This is why RISC-V should not be viewed simply as a processor project.

It is an ecosystem project.

Where Should the Consortium Start?

It should not start by designing a new operating system.

It should not start by building a new smartphone.

It should not start by designing another processor.

It should start with something much less glamorous.

Existing hardware.

There are already RISC-V development boards, SoCs, processors and accelerator projects available to developers.

The first task should be to map the ecosystem.

Which boards are available?

Which chips are supported?

Which peripherals work?

Which drivers are missing?

Which Linux subsystems require improvement?

Which RTOS implementations need support?

Where are the documentation gaps?

Which GPUs have usable open drivers?

Which NPUs have usable runtimes?

Which development boards are painful to bring up?

Which interfaces appear repeatedly across different chips?

That produces a list of actual engineering problems.

And those problems become the consortium's first projects.

Start With the Boring 80 Percent

The first engineering teams could concentrate on common interfaces:

  • GPIO
  • I²C
  • SPI
  • UART
  • PWM
  • ADC and DAC
  • USB
  • Ethernet
  • Wi-Fi
  • Bluetooth
  • SD and eMMC
  • NVMe
  • display interfaces
  • touchscreens
  • camera interfaces
  • audio
  • sensors
  • motor controllers
  • power-management ICs
  • watchdogs
  • real-time clocks
  • secure elements
  • hardware cryptography

These things are not glamorous.

That is precisely why they are valuable.

If five different RISC-V boards require the same kind of support, improving that support once can benefit all five.

If fifty future products can use the same API, the return on that engineering effort becomes enormous.

Then Move Up the Stack

Once the low-level foundation becomes stronger, the consortium can move upward:

LEVEL 1
Drivers / firmware / BSP
        |
LEVEL 2
Hardware abstraction
        |
LEVEL 3
Common APIs
        |
LEVEL 4
SDKs and developer tools
        |
LEVEL 5
Reference platforms
        |
LEVEL 6
Industry platforms
        |
LEVEL 7
Commercial products

The consortium should primarily operate through Levels 1–5.

Industry should dominate Levels 6 and 7.

That boundary is important.

If the consortium begins building commercial end-user products, it starts competing with the very companies it is supposed to enable.

Its purpose is to make those companies stronger.

The Steam Lesson

There is a useful analogy in the gaming world.

Valve's work around Steam on Linux demonstrates what can happen when a company invests heavily in the layers required to make a fragmented technical environment practical for mainstream users.

Proton/Wine, SDL, controller support, graphics compatibility, anti-cheat work, hardware integration and the wider Linux gaming ecosystem did not all originate as a single Valve-owned technology stack.

The important contribution was sustained engineering, integration, investment and upstream collaboration.

Valve didn't need to replace Linux.

It helped make Linux substantially more useful for a particular class of applications.

That is the lesson worth borrowing.

The Indian consortium should not attempt to replace the global open-source ecosystem.

It should make the global open-source ecosystem work exceptionally well with the hardware and industries India is trying to develop.

Do not fork the world. Strengthen the world.

India's First Objective Should Be Hardware Enablement

Imagine an Indian semiconductor company releases a new RISC-V SoC.

Today, the company may have to answer dozens of questions before an OEM can seriously consider it:

  • Does Linux boot?
  • Are the drivers upstream?
  • Does the GPU work?
  • Does the NPU have an SDK?
  • Can common AI frameworks use it?
  • Does video decoding work?
  • Does suspend/resume work?
  • How good is power management?
  • Does Wi-Fi work?
  • How do we perform secure OTA updates?
  • Where is the documentation?
  • Who maintains the software five years from now?

The consortium could turn a large part of that list into a platform service.

The semiconductor company could say:

"This chip is supported by the Open Technology Platform."

That changes the conversation.

The Consortium Becomes a Test Laboratory for Silicon

The organisation could establish shared hardware laboratories.

New chips could be tested against common workloads.

Measurements could include:

  • boot time
  • power consumption
  • thermal behaviour
  • memory bandwidth
  • GPU performance
  • NPU performance
  • video playback
  • browser performance
  • storage
  • networking
  • sleep and wake
  • security
  • driver maturity
  • application compatibility

This creates an unusually valuable feedback loop.

Software engineers learn what the silicon actually needs.

Silicon engineers learn what real software actually demands.

Future chips can then be designed with that knowledge.

It is a learning machine connecting software and hardware.

The Consortium Should Be Industry-Funded

The most sustainable model is unlikely to be a conventional government software programme.

The government can be an important enabler, but the consortium should ideally have substantial industry funding.

Potential members could include:

  • semiconductor companies
  • automobile manufacturers
  • electronics manufacturers
  • appliance manufacturers
  • telecommunications companies
  • cloud companies
  • IT companies
  • startups
  • universities
  • research institutions
  • multinational companies with significant engineering operations in India

The government could support the ecosystem through appropriate incentives, research programmes, infrastructure, procurement and university partnerships.

But the foundation should not become a government-owned software company.

A simple division of responsibility would be:

  • Government: create favourable conditions.
  • Industry: provide funding and engineering participation.
  • Universities: provide research and talent.
  • Foundation: provide infrastructure and stewardship.
  • Engineers: build and maintain the technology.
  • Open communities: retain technical authority.

Talent Before Headcount

One of the biggest mistakes would be to define the organisation's success by how many programmers it employs.

FLOSS requires a particular temperament.

Some engineers love the work of maintaining infrastructure for years.

They enjoy debugging obscure problems.

They enjoy reading specifications.

They enjoy reviewing patches.

They are willing to respond to upstream feedback.

They care about documentation and compatibility.

They enjoy understanding systems from silicon to application.

Those people are extraordinarily valuable.

The consortium should find them.

It should not try to force every software engineer into that role.

Start with talent and motivation, not headcount.

Perhaps the first engineering organisation has 100 people.

Perhaps later it becomes 500.

Perhaps eventually it becomes several thousand.

The growth should follow the work.

The Open Technology Academy

There should, however, be a deliberate path for new people to enter this ecosystem.

This is where a training and learning vertical becomes extremely valuable.

But it should not look like a conventional training institute.

It should be an Open Technology Academy.

Its purpose would be to turn interested engineers into contributors, developers, maintainers and eventually systems architects.

And the most important principle should be:

Don't teach people FLOSS. Put them inside FLOSS.

Learning by Contribution

Instead of spending months simply watching courses, an apprentice might receive a RISC-V development board.

The first assignment could be:

Make it boot.

Then:

Find something that doesn't work.

Then:

Debug it.

Then:

Fix it.

Then:

Submit the patch upstream.

Then:

Respond to the review.

Then:

Get it merged.

At that point the person hasn't merely completed a course.

They have become an open-source contributor.

A possible progression could be:

Explorer
   |
Contributor
   |
Developer
   |
Maintainer
   |
Senior Maintainer
   |
Technical Architect

Not everyone needs to reach the top.

Someone may discover that they love documentation.

Another may become an exceptional kernel developer.

Another may specialise in compiler technology.

Another may discover a talent for hardware validation.

Another may become a security engineer.

The Academy should help people discover where they belong.

Talent Should Select Itself

This also solves the problem of identifying people with the necessary drive.

Do not try to identify every future maintainer during recruitment.

Give interested people access to real projects.

Let contribution reveal the talent.

Perhaps 1,000 people enter an introductory programme.

Perhaps 300 become regular contributors.

Perhaps 100 become serious developers.

Perhaps 30 become excellent maintainers.

Perhaps five eventually become world-class subsystem experts.

That is not failure.

That is how a technical culture develops.

AI Makes Systems Engineering More Important

The emergence of increasingly capable AI coding tools makes this model even more interesting.

AI can increasingly help generate code, tests, documentation and debugging hypotheses.

But someone still needs to understand whether the resulting system is correct.

Does the driver break another subsystem?

Does the compiler produce incorrect machine code?

Does the firmware introduce a security vulnerability?

Does the NPU runtime actually exploit the hardware?

Does the power-management implementation work across different boards?

Can the software still be maintained five years later?

These are systems questions.

The consortium should therefore cultivate people who understand the complete chain:

silicon → firmware → kernel → driver → compiler → runtime → application.

That is a particularly valuable form of engineering knowledge.

India Should Not Keep the Consortium Indian

The institution may be founded and substantially funded in India.

But the technology should be globally open.

An engineer in Bengaluru should be able to work with an engineer in Munich.

A university in Chennai should be able to collaborate with a research group in Helsinki.

An Indian startup should be able to work with a European automotive company.

An engineer living in the United States, Japan, Brazil or Africa should be able to contribute to a project simply because they have something valuable to contribute.

Indian-origin engineers around the world could become an important source of talent, mentorship and leadership.

But nationality or ethnicity should not be a requirement for participation.

Indian-founded does not have to mean Indian-only.

Open by Default, Trusted by Design

This global openness must, however, coexist with serious security and compliance practices.

Not every project has the same risk.

A public compiler project and a secure automotive testing laboratory should not necessarily have identical access rules.

The consortium should therefore use a tiered participation model.

Open Community

Anyone can:

  • read the code
  • use the software
  • report bugs
  • submit patches
  • write documentation
  • participate in public projects

Technical Membership

Participating companies, universities and individuals can join working groups and contribute engineering resources under defined governance rules.

Strategic Membership

Trusted organisations can receive access to shared testing infrastructure, pre-production hardware, joint development programmes and industry working groups.

Restricted Projects

Projects involving particularly sensitive semiconductor designs, automotive systems, critical infrastructure, security technology or other controlled technologies can have additional access requirements.

The principle should be:

Open by default. Restricted where justified. Transparent about why.

Trust Should Be an Engineering Requirement

If India wants this consortium to become a major partner for Europe and other advanced technology ecosystems, trust cannot be an afterthought.

The consortium should establish a formal technology-trust framework covering areas such as:

  • ownership transparency
  • beneficial ownership
  • conflict-of-interest rules
  • export-control compliance
  • research-security procedures
  • secure development practices
  • software provenance
  • dependency tracking
  • vulnerability disclosure
  • access control
  • protection of sensitive hardware
  • auditable governance
  • transparent funding

The objective should not be to create arbitrary political exclusions.

It should be to create a predictable, auditable system in which partners understand the rules before they participate.

That is particularly important for cooperation with European organisations.

The EU and India are already deepening cooperation in semiconductors, high-performance computing, AI, quantum technologies and 6G through the EU–India Trade and Technology Council. The July 2026 TTC meeting also launched an EU–India deep-tech startup partnership and agreed to strengthen strategic value chains. This creates a natural environment in which a well-governed open technology institution could eventually become a useful India–Europe engineering bridge.

Europe Should Be a Partner, Not Just a Customer

Europe has substantial strengths in automotive systems, industrial automation, robotics, embedded technology, semiconductor equipment, power electronics and industrial software.

India has enormous engineering capacity, a large technology market, a growing semiconductor ecosystem and a large pool of software developers.

An open consortium could sit between these ecosystems.

Indian engineers could contribute maintainers.

European companies could contribute industrial requirements.

Universities could contribute research.

Semiconductor companies could contribute hardware.

Startups could turn the resulting infrastructure into products.

The output would remain open wherever the project licences and governance permit.

A driver written in India could eventually support equipment made in Europe.

A European robotics requirement could lead to an open API maintained by engineers in India.

A RISC-V development tool improved in Bengaluru could be used by developers everywhere.

That is what a genuinely global FLOSS ecosystem looks like.

Become a Serious Upstream Participant

The consortium should also participate deeply in the organisations that already maintain the world's open technology infrastructure.

That could include appropriate membership and engineering participation in organisations and communities around:

  • RISC-V
  • Linux
  • LLVM
  • Apache
  • Eclipse
  • OpenSSF
  • Mesa
  • Zephyr
  • other relevant FLOSS communities

But membership should not be about collecting logos.

Membership should mean contribution.

Money is useful.

Engineers are more useful.

Code is more useful.

Maintainers are more useful.

Testing infrastructure is more useful.

Upstream contributions are more useful.

RISC-V International's current development-partner model is an interesting example of this philosophy: participating organisations commit engineering resources and defined technical deliverables rather than merely being passive members.

India should adopt that mentality broadly.

Don't just join the global commons.

Become one of the people maintaining it.

Four Pillars

The consortium can therefore be organised around four major pillars.

1. Engineering & Maintenance

  • Linux
  • RISC-V
  • firmware
  • drivers
  • compilers
  • graphics
  • AI runtimes
  • security
  • embedded systems
  • testing

2. Open Technology Academy

  • apprenticeships
  • hardware labs
  • mentorship
  • upstream contribution
  • maintainer development
  • systems engineering

3. Industry & Ecosystem

  • semiconductors
  • automotive
  • consumer electronics
  • appliances
  • robotics
  • IoT
  • industrial systems
  • startups

4. Standards & Interoperability

  • APIs
  • reference architectures
  • compatibility specifications
  • certification
  • hardware profiles
  • security requirements
  • interoperability testing

These four pillars reinforce one another.

Industry provides real problems.

The engineers solve them.

The Academy creates new engineers.

The standards teams turn repeated solutions into reusable interfaces.

The FLOSS community improves everything.

The Five-Year Flywheel

The initial roadmap could be remarkably simple.

Year 1 — Discover

Inventory existing RISC-V hardware and identify the most common gaps.

Year 2 — Enable

Fix drivers, firmware, toolchains, documentation, testing and hardware support.

Year 3 — Standardise

Turn recurring solutions into common APIs, SDKs and reference platforms.

Year 4 — Industrialise

Build automotive, appliance, robotics, consumer-electronics and IoT working groups.

Year 5 — Export

Turn the Indian engineering base into a global contributor to open technology infrastructure.

The important thing is that the work can begin immediately.

It does not require waiting for a future Indian processor.

And Then the Silicon Arrives

When new Indian semiconductor products eventually become available, they should not enter an empty ecosystem.

They should enter an ecosystem that already knows how to support them.

                  INDIAN SILICON
                       |
                 RISC-V / SoC
                       |
                 Common BSP
                       |
              Linux / RTOS
                       |
              Drivers / HAL
                       |
             GPU / NPU / VPU
                       |
                 Common APIs
                       |
                    SDK
                       |
             Testing / Certification
                       |
                   STARTUPS
                       |
                    PRODUCTS
                       |
                    USERS

This is the entire reason to begin now.

The semiconductor industry has long development cycles.

Software can move faster.

India can use that difference in timescale to its advantage.

Don't Wait for the Perfect Chip

There is a dangerous temptation to say:

"Once India has a world-class processor, then we will build the ecosystem around it."

That is backwards.

The ecosystem should already exist when the processor arrives.

Developers should already know the tools.

Drivers should already have a place to live upstream.

Testing infrastructure should already exist.

SDKs should already be available.

AI frameworks should already have integration pathways.

Companies should already understand how to build products on open hardware.

Universities should already be teaching the relevant skills.

European and other international partners should already know the organisation.

The first commercial Indian chips should therefore become another supported platform rather than an entirely new software emergency.

The Real Product of the Consortium

At first glance, it might seem that the consortium's product is software.

That is only partly true.

Its deeper product is capability.

The capability to take a new processor and make it useful.

The capability to take a new NPU and integrate it with AI frameworks.

The capability to take a new GPU and bring it into the graphics stack.

The capability to take a new sensor and make it available through standard interfaces.

The capability to take a development board and turn it into a product platform.

The capability to train engineers who understand the entire stack.

The capability to maintain software for decades.

The capability to participate in global standards rather than merely consuming them.

That is technological sovereignty in a much more useful sense.

India Does Not Need to Build Everything

There is an important philosophical point here.

Technology sovereignty does not require India to manufacture every component, write every piece of software or create an Indian copy of every global product.

It means developing enough capability that India can understand, integrate, maintain, modify and improve the technologies on which its economy depends.

Open technology is particularly powerful for this purpose.

India can contribute to the global commons while simultaneously developing domestic capability.

A Linux contribution is both global software infrastructure and Indian engineering experience.

A RISC-V toolchain improvement is both global infrastructure and Indian semiconductor enablement.

A new NPU runtime is both a FLOSS contribution and a potential foundation for Indian AI hardware.

A compatibility test suite can be used by Indian manufacturers and foreign manufacturers alike.

Everyone benefits.

The Bigger Vision

Perhaps the most important thing is what this consortium should not become.

It should not become another government IT project.

It should not become a collection of proprietary products.

It should not become an Indian fork of the entire open-source world.

It should not become a jobs programme whose success is measured by headcount.

It should not become a standards bureaucracy detached from real hardware.

It should not build products that compete with the companies it is supposed to enable.

Instead:

Find the talent.

Give them real hardware.

Fix the plumbing.

Upstream the improvements.

Turn repeated solutions into APIs.

Build the tools.

Train through contribution.

Create trusted governance.

Work with Europe and the wider world.

Let startups and manufacturers build the products.

Build the Plinth Before the Statue

India's semiconductor journey will eventually produce silicon.

But silicon alone does not create an ecosystem.

The ecosystem emerges when hardware, software, developers, standards, manufacturers and users can work together.

That requires infrastructure.

Much of that infrastructure can be open.

Much of it can be shared.

Much of it can be built before the final products exist.

And much of it can be built today.

India does not need to wait for the perfect chip.

It can start with the chips and boards already available.

It can start with the missing drivers.

It can start with the broken documentation.

It can start with the APIs nobody has standardised yet.

It can start with the engineers who already have the drive to maintain difficult software.

It can start small and let success attract talent, companies and international partners.

Eventually, Indian-origin engineers around the world can participate.

European companies can become partners.

Universities can become training grounds.

Startups can become users of the infrastructure.

Semiconductor companies can become hardware partners.

And the resulting software can remain part of the global FLOSS commons.

The philosophy can be reduced to five principles:

  1. Build the tools, not every product.
  2. Standardise the interfaces, not the innovation.
  3. Train through contribution, not certificates.
  4. Be open by default and trusted by design.
  5. Build in India, contribute to the world.

The semiconductor fab may eventually produce the silicon.

But the software consortium can make sure that when that silicon arrives, someone already knows what to do with it.

That is the real opportunity.

Don't wait for the statue.

Build the plinth.

And make the plinth open enough that the world can build on it.

Friday, September 11, 2026

The Indian Computing Ecosystem: Own the Everyday, Rent the Extraordinary (Compressed)

Editor's Note: This is the compressed long-form edition of the original essay (https://thesovereignpulse.blogspot.com/2026/09/the-indian-computing-ecosystem-own.html) — shorter, but preserving the core argument and strategic framework behind India's emerging computing ecosystem.

India does not need to win the global transistor race to build computing sovereignty. It needs to own enough of the stack, enough of the market and enough of the learning curve.

The question is no longer whether India can build a computer

For decades, the obvious measure of computing progress has been the semiconductor process node.

7nm beats 14nm. 3nm beats 7nm. Eventually 2nm will beat 3nm, and some future process will beat that.

But national computing capability is not the same thing as transistor density.

A country can import the world's most advanced processors and still remain dependent on everyone else's architecture, software, intellectual property, manufacturing and supply chains.

Conversely, a country can build an ecosystem around mature silicon that is remarkably capable because the hardware, software and applications are designed together.

This is where India's semiconductor ambitions become much more interesting.

The Dholera semiconductor fab being developed by Tata Electronics, in partnership with PSMC, is planned as a 300mm foundry with technologies in the 28nm to 110nm range. Tata has also announced access to PSMC technologies including 28nm, 40nm, 55nm, 90nm and 110nm, while its 2026 partnership with ASML brings lithography expertise, equipment and ecosystem development into the picture. :contentReference[oaicite:1]{index=1}

That is not the end of India's computing journey.

It could be the beginning.

Stop confusing transistor size with user experience

The most important principle is simple:

A 22nm computer does not have to behave like a 22nm computer.

If the processor architecture is efficient, the operating system is optimised, the GPU and NPU handle the workloads they are designed for, memory is well matched to the system and applications are compiled specifically for the platform, a mature process can produce a very usable machine.

Users ultimately experience responsiveness, battery life, application performance and reliability.

They do not experience the transistor gate directly.

This creates a strategic opportunity.

India does not have to reproduce the entire global semiconductor hierarchy immediately. It can begin by owning the parts of computing that are economically and strategically important.

Generation One: build the computer before building the perfect computer

The first Indian processor does not need to be the fastest processor in the world.

It needs to exist.

A sensible first generation could be a modular laptop or desktop-class system built around a 40nm-class or similar mature process, with a RISC-V CPU, modest GPU or NPU acceleration, conventional memory and standard storage.

The objective would not be benchmark leadership.

The objective would be learning.

India needs engineers who understand the entire chain:

ISA → CPU → SoC → memory → accelerators → security → I/O → firmware → Linux → drivers → physical design → tapeout → packaging → product.

That knowledge cannot be acquired simply by importing finished chips.

The laptop should become a carrier for evolving silicon

This is where modular computing becomes particularly powerful.

Consider the philosophy behind systems such as MNT Reform: the motherboard, display, keyboard, storage and chassis can remain useful while the computing module evolves.

India could adopt the same principle.

+--------------------------------------------------+
|              Indian Modular Computer             |
+--------------------------------------------------+
| Display | Keyboard | Storage | Power | I/O       |
+--------------------------------------------------+
|              Standard Carrier Board              |
+--------------------------------------------------+
|       Replaceable Indian Compute Module          |
|     CPU + GPU/NPU + Memory + Security + I/O      |
+--------------------------------------------------+

The first compute module might be relatively modest.

The second could be faster.

The third could move to a smaller process.

The laptop does not have to become obsolete every time the processor improves.

That changes the economics of semiconductor development. Instead of treating every chip generation as a completely new ecosystem, India can build a platform on which successive generations of silicon are deployed.

The open-silicon advantage

India also does not have to start from an empty page.

The global open-hardware ecosystem already contains many of the building blocks.

RISC-V provides the open instruction-set architecture. Projects such as IIT Madras's SHAKTI demonstrate that India can build production-oriented RISC-V processors and SoCs. Other open projects cover CPUs, vector processors, GPUs, NPUs, image processing, storage controllers, security and SoC infrastructure.

Examples include SHAKTI, CVA6, BlackParrot, VexRiscv, Ara, Vortex, Coral NPU, NVDLA, Gemmini, Infinite-ISP, OpenTitan, LiteX and a growing collection of open ASIC design tools.

The significance is not that India should simply copy these projects.

The significance is that the starting point for Indian silicon can increasingly be a global design commons.

The missing piece is system integration.

Someone still has to turn all these components into a reliable product.

That is precisely where an Indian ecosystem can create enormous value.

Generation Two: optimisation becomes the weapon

Once the first generation exists, the objective changes.

The second generation does not need to reinvent everything. It can improve the CPU, memory subsystem, interconnect, accelerator blocks, power management and software stack.

A move toward 28nm-class silicon could provide substantially more room for integration.

Instead of building a generic processor and hoping the market finds a use for it, India could design processors around specific workloads:

  • government productivity
  • education
  • office computing
  • local AI inference
  • industrial automation
  • automotive systems
  • communications
  • edge computing
  • storage and networking

The competitive advantage would increasingly become optimisation.

That is a much more realistic target than attempting to defeat the world's leading semiconductor companies at every workload simultaneously.

Generation Three: the 22nm possibility

Further down the road, a 22nm-class platform becomes particularly interesting.

Technologies such as GlobalFoundries' 22FDX demonstrate that 22nm FD-SOI can combine relatively mature manufacturing with low-voltage operation, body biasing and integration of digital, analogue and RF capabilities.

For India, however, 22nm FD-SOI should be viewed as a future possibility rather than an assumption about Dholera's current process roadmap.

Moving to FD-SOI would require the appropriate substrates, process technology, PDKs, standard-cell libraries, SRAM, analogue IP, design tools, manufacturing expertise and qualification.

But if that capability eventually becomes available, it could provide an interesting middle ground.

The objective would not be to make a fake 1.4nm processor.

The objective would be to make a very good 22nm computer.

Own the everyday. Rent the extraordinary.

This leads to the larger economic strategy.

India does not need every citizen to own the world's fastest computer.

It needs a domestic computing platform capable of handling the overwhelming majority of everyday workloads.

Think of the ecosystem as three layers:

Tier Purpose Silicon Strategy
Everyday Government, education, business, home Indian-designed and increasingly Indian-manufactured
Premium Gaming, professional workloads, enthusiasts Open to the best global hardware
Extreme AI training, HPC, scientific computing Accessed primarily through data centres and cloud infrastructure

This is not technological isolation.

It is sovereignty through optionality.

An Indian citizen should be able to buy an Indian computer because it is good enough, affordable and supported—not because every foreign alternative has been banned.

If someone wants a premium NVIDIA GPU, Apple processor or other leading-edge system, that market can remain open.

If a research institution needs enormous AI compute, it can rent it from a data centre using whatever advanced global silicon is economically appropriate.

The important thing is that the entire country does not need to depend on imported leading-edge silicon for ordinary computing.

The government can provide the anchor market

One of the biggest problems in semiconductor development is the chicken-and-egg problem.

Chip companies need customers before they can scale.

Customers hesitate to adopt immature domestic chips before the ecosystem is proven.

Government procurement can break that loop.

Imagine, as a policy scenario rather than a current mandate, that government departments and government-supported institutions committed to using a substantial proportion of domestically designed computing hardware.

A 20-million-device planning scenario would already be transformative.

At an illustrative ₹50,000 per machine, that represents ₹1 trillion, or ₹1 lakh crore, of hardware demand over a replacement cycle.

The real value, however, would be larger than the initial purchase.

Every government laptop becomes a test platform.

Every deployment creates software feedback.

Every failure teaches an engineer something.

Every successful deployment creates confidence for the private sector.

And the users take the technology home.

A government employee using an Indian computer at work is one user. A family exposed to that machine can represent several more potential users.

The government therefore does not have to manufacture everything.

It can create the initial market that allows domestic manufacturers and software developers to learn at scale.

Software is where the ecosystem compounds

Hardware sovereignty without software sovereignty would leave India only partially independent.

This is why the operating system matters.

Ubuntu and the wider Linux ecosystem already provide an enormous foundation for RISC-V computing. Over time, India could build a stronger national platform layer on top of Linux—possibly through a dedicated initiative or commercial ecosystem.

Call the hypothetical concept Canonical India.

The point would not be to create another Linux distribution merely for branding.

The point would be to coordinate the hardware and software stack:

  • RISC-V support
  • CPU-specific optimisation
  • GPU and NPU drivers
  • power management
  • security
  • developer tools
  • package repositories
  • enterprise support
  • long-term updates

And the argument should not be that Android is simply a "virtualised" operating system. Android's ART runtime uses both ahead-of-time and just-in-time compilation, and Android supports native code through the NDK.

The stronger argument is that a native Linux/RISC-V platform gives India greater freedom to optimise the entire stack—from compiler to CPU to accelerator to application.

That is a much more powerful proposition.

The smartphone is the harder battlefield

Mobile computing would eventually become an obvious target.

A 22nm-class Indian mobile platform would not need to outperform the latest flagship processor.

It would need to deliver excellent everyday performance at a competitive cost.

Office applications, messaging, web browsing, media playback, education, payments and local AI inference do not necessarily require the world's smallest transistor.

The difficult part would be the ecosystem around the processor.

Cellular modems, RF, graphics, camera pipelines, display interfaces, power management and certification are all substantial engineering challenges.

Some of these technologies could remain globally sourced while the central compute platform becomes progressively more Indian.

Again, the principle is optionality rather than isolation.

Data centres complete the pyramid

The same ecosystem can support a completely different class of computing at the top.

                 EXTREME COMPUTE
             AI / HPC / SCIENCE
          Advanced Global Silicon
                    ▲
                    │
                 CLOUD
                    ▲
                    │
        INDIAN EVERYDAY COMPUTING
       Laptops / Desktops / Phones
            Domestic Platform

The ordinary device does not have to perform every computation locally.

A modest Indian laptop can run normal workloads while sending demanding AI, simulation or rendering tasks to a domestic data centre.

Those data centres can use whatever processors make economic sense—including advanced foreign silicon.

This is the key insight.

India does not need to own every transistor. It needs to own the ability to choose where computation happens.

Why ASML and the Netherlands matter

Semiconductor sovereignty cannot mean pretending the global semiconductor industry does not exist.

It means building strategic relationships with it.

The Tata Electronics-ASML partnership is significant in precisely this context. ASML is supporting the Dholera fab with lithography technology, training, supply-chain development and R&D infrastructure. :contentReference[oaicite:2]{index=2}

India can therefore learn from the world's semiconductor ecosystem while simultaneously building its own capabilities.

The long-term objective should be a design loop:

global technology → Indian engineering → Indian design → Indian manufacturing → Indian products → Indian users → engineering feedback → better Indian technology.

Over time, the proportion of that loop controlled domestically can increase.

The first generation creates the engineers who build the second

This may ultimately be the most important point.

The first Indian computer is not merely a product.

It is an engineering school.

The engineers who build the first RISC-V SoC learn things that cannot be learned from PowerPoint presentations.

They learn timing closure.

They learn memory controllers.

They learn power budgets.

They learn packaging.

They learn what breaks after tapeout.

They learn how Linux behaves on their silicon.

They learn what customers actually need.

Then they build the second generation.

And the third generation is built by engineers who grew up inside the second.

That is how ecosystems become self-reinforcing.

The ultimate roadmap

Stage Objective
1 Open RISC-V development platforms
2 First Indian SoCs and learning silicon
3 Modular domestic computer platforms
4 Commercial 40nm-class systems
5 28nm-class higher-performance platforms
6 Integrated CPU, GPU and NPU ecosystems
7 Potential 22nm-class advanced domestic silicon
8 Thin-and-light mainstream computers
9 Indian mobile and edge-computing platforms
10 Advanced domestic data-centre accelerators

None of these stages needs to happen overnight.

The point is to make sure that every stage creates the capabilities required for the next.

Dholera should become more than a fab

The real opportunity is therefore much larger than manufacturing wafers.

Dholera could become the physical anchor of an Indian computing ecosystem—but only if the surrounding ecosystem grows with it.

That means semiconductor design.

It means RISC-V processors.

It means accelerators.

It means open-source hardware.

It means EDA and physical-design expertise.

It means packaging.

It means firmware and drivers.

It means Linux.

It means laptops, desktops, phones, servers and embedded systems.

And above all, it means users.

Conclusion: India does not have to win the transistor race

The conventional semiconductor race asks a simple question:

Who can manufacture the smallest transistor?

India should ask a different question:

How much of the computing experience can we control?

If India can build open processors, domestic SoCs, accelerators, operating systems, developer tools, computers and eventually mobile platforms, then a mature process node becomes much more powerful than its number suggests.

A 22nm machine optimised across the hardware and software stack can be an excellent everyday computer.

A premium user can still buy the world's fastest foreign machine.

A researcher can still rent extreme compute from a data centre.

And the domestic ecosystem can continue improving underneath all three.

That is the real meaning of “Own the Everyday, Rent the Extraordinary.”

India does not need to isolate itself from the global semiconductor industry.

It needs to become capable of participating in it from a position of strength.

The ultimate objective is not one Indian chip.

It is an Indian computing ecosystem.

Own the everyday. Rent the extraordinary. Keep the silicon evolving. And never start from zero again.