Forty percent to eight percent in a single year. That’s Bernstein Research’s read on Nvidia’s slice of China’s AI chip market, dropping from roughly 40% in 2025 to around 8% in 2026, while Huawei climbs from a near-tie at 40% up to about 50%.
I build bots for a living. Agents, retrieval pipelines, the occasional fine-tune that eats a weekend. So my first reaction to a number like that wasn’t about stock prices. It was about the dozens of places in my own code where I’ve quietly assumed a particular vendor’s runtime would always be there.
What actually changed
The headline story is policy. U.S. export restrictions pushed China to accelerate building a self-sufficient semiconductor industry, and the results are showing up faster than most people expected. Bernstein’s projection isn’t a slow erosion, it’s a cliff.
But the part that matters to builders is the technical claim underneath it. Huawei’s Ascend chips are now considered roughly comparable to Nvidia’s H200. Not a toy, not a government-mandated downgrade that teams tolerate out of obligation. Comparable silicon.
And then there’s DeepSeek. The company migrated off Nvidia’s CUDA ecosystem to Huawei’s CANN framework, and debuted its V4 model on the Huawei Ascend platform on April 24, 2026. Jensen Huang has publicly acknowledged Nvidia’s AI chip share in China falling toward zero.
Analysts are calling Huawei’s chip progress “another DeepSeek moment,” and I think that framing is right for a reason that has nothing to do with chips. The original DeepSeek moment was a reminder that the assumed cost and tooling floor for frontier work was softer than everyone believed. This is the same lesson applied one layer down the stack.
The part that should make you check your own code
CUDA’s dominance was never purely about speed. It was about the fifteen years of accumulated libraries, kernels, forum answers, Docker images, and muscle memory sitting on top of it. That accumulated weight is what made switching feel irrational.
A team migrating a frontier-scale model off that ecosystem and shipping on the other side changes the calculation. Not because CANN is better, but because it demonstrates the migration is survivable at the hardest difficulty setting. If DeepSeek can move a flagship model, your inference service can probably move too.
Which raises an uncomfortable question for those of us who write the glue code. How much of your stack would break if the accelerator underneath it changed next quarter?
In my experience, the answer is usually “more than you’d guess, and in dumb places.” A few patterns I’ve had to clean up in my own projects:
- Hardcoded device strings. Scattered
cuda:0references across training scripts, eval harnesses, and utility files. Centralize device selection into one config-driven function and you’ve removed most of the pain. - Vendor-specific kernels in the hot path. Custom attention implementations and quantization kernels that only compile against one toolchain. Keep a slower portable fallback path, even if you never plan to use it. The day you need it, you’ll need it fast.
- Base images baked into deployment. Dockerfiles starting from a vendor-specific runtime image, with system-level dependencies layered on assumptions about that runtime. Separate your application layer from your accelerator layer.
- Benchmarks that only exist in your head. If you can’t re-run your latency and throughput numbers on new hardware with one command, you can’t evaluate alternatives. You’ll just stay where you are by default.
Portability as a design habit
I’m not arguing anyone outside China should rush to Ascend hardware. Most readers of this site can’t buy it and don’t need it. The useful takeaway is about posture, not procurement.
For years, the right engineering bet was to go all-in on one ecosystem, because fragmentation cost more than lock-in. A market where one vendor’s share can go from 40% to 8% in twelve months, in the world’s largest single AI market, is a market where that bet carries more risk than it used to. Supply, pricing, and availability all get less predictable when the competitive picture moves this fast.
The practical version of this for bot builders is boring and cheap. Abstract your model-serving layer behind an interface. Treat the accelerator as a swappable dependency, the way you’d treat a database driver. Run your eval suite against at least one backend you don’t normally use, even if it’s just CPU, so you know the seams hold. Write down which parts of your pipeline are genuinely vendor-locked, so the decision is explicit rather than accidental.
Where I land on it
Bernstein’s numbers are a projection, and projections miss. Huawei hitting 50% isn’t a certainty, and Nvidia isn’t short on options elsewhere.
What’s already happened, though, is harder to argue with. A major model shipped on a non-CUDA framework, on silicon described as roughly H200-class, and the market responded by re-pricing an incumbent’s position in an entire country. The moat was deep. It turned out to be crossable.
That’s the signal I’d act on. Build like the hardware underneath you is temporary, because for a lot of teams it just became exactly that.
🕒 Published: