DeepSeek Open-Sources Six Core Components: Laying the Foundation for Domestic AI Chips

An Open-Source Release More Important Than Launching a New Model

At 10:01 AM on September 30th, just before China's National Day holiday, DeepSeek^Ad did something that barely made the trending charts — yet may be more significant than releasing any new model. In one shot, it open-sourced six core infrastructure components targeting Huawei's Ascend platform: TileLang, DeepGEMM, DeepEP, FlashMLA, TileKernels, and DeepSelect.

In plain terms: DeepSeek built a complete set of the "pots and pans" it uses to train large models — this time on domestic chips — and gave the whole thing away for free.

This deserves its own spotlight because it's the first time a leading Chinese AI company has fully open-sourced the complete low-level software stack for running production-grade training on domestic hardware. This isn't a slide deck or a demo. These are components that were battle-tested in the training of DeepSeek V4. It turns the question mark over "can domestic chips train top-tier LLMs" into a period.

The Bottleneck Was Never the Chip

To appreciate the weight of this release, you first need to clear up a common misconception: the bottleneck for domestic AI chips has never been the hardware itself — it's always been the software ecosystem.

At its core, AI model training is massive-scale computation running on GPU chips. NVIDIA GPUs dominate this space. But hardware doesn't do anything on its own — you need software to tell it how to compute. That "how to compute" layer is what we call the foundational software stack.

NVIDIA's real advantage isn't just cutting-edge silicon. It's CUDA, launched back in 2006, and the nearly 20 years of ecosystem NVIDIA built around it: TensorRT, companion libraries, documentation, tooling, and a global developer community. The result: any AI developer on NVIDIA hardware has to write CUDA. Switching to a different chip is like asking a Java developer with a decade of experience to rewrite everything in assembly — the migration cost alone is enough to stop most people cold.

Domestic GPUs have been competitive on raw specs for a few years now, but everyone in the industry agrees the ecosystem gap is enormous. What DeepSeek just did is start filling that gap.

It's worth adding that NVIDIA's CUDA moat goes beyond tooling. It's embedded in the talent pool and the accumulated codebase of the field. Reproductions of research papers, core operators in open-source frameworks like PyTorch and TensorFlow — virtually all of it defaults to CUDA. This means that even if a domestic chip's theoretical performance matches NVIDIA's, developers face a "code debt" problem when migrating: not only do they have to rewrite operators, they have to re-verify numerical precision and re-tune performance from scratch. Any step that goes wrong makes training results non-reproducible. Huawei's AscendC programming framework was an important step, but without a production-validated upper-layer software stack like the one DeepSeek just released, the adoption barrier has remained high.

What Each of the Six Components Does

These six components map one-to-one to DeepSeek's previously open-sourced components for NVIDIA's platform — there was already a version for NVIDIA, and now Ascend has its own.

Breaking Them Down

• TileLang: Corresponds to CUDA. Write high-performance operators with clean, simple code instead of low-level boilerplate.
• DeepGEMM: Corresponds to cuBLAS. Handles the core of all AI computation — matrix multiplication — as fast as possible.
• DeepEP: Corresponds to NCCL. Manages communication across hundreds of chips without bottlenecks.
• FlashMLA: Corresponds to FlashAttention. Makes processing very long sequences faster and more memory-efficient.
• TileKernels: Corresponds to CUTLASS. Handles the standard data movement and processing routines.
• DeepSelect: Corresponds to pipelines like DALI. Rapidly selects the relevant data from massive datasets.

One point worth emphasizing: TileLang is not theoretical. To quote DeepSeek directly, it already powers most of the operator implementations used in training the DeepSeek V4 series. In other words, this is production-validated.

From Manual to Automatic: Why TileLang Matters

If you've never written an operator, here's all you need to understand TileLang: CUDA is a manual transmission; TileLang is an automatic.

If you've worked with databases, the analogy is intuitive. When you write SQL, you just write SELECT ... FROM ... JOIN ... WHERE. You don't worry about which table gets scanned first, whether the query planner uses an index, or whether it picks a hash join — the query optimizer handles all of that. Writing CUDA, by contrast, is like writing the execution plan yourself. Every step must be manually arranged, and one wrong move either tanks performance or produces incorrect results. TileLang brings you back to the "write SQL" level of abstraction.

The GPU's Layered Execution Model

GPUs execute CUDA programs through a hierarchy: Grid → Block → Thread. Think of it like a warehouse. A Thread is a single worker handling one small task (scanning one item). A Block is a team of hundreds of workers who can communicate with each other (shared memory). A Grid is the entire warehouse operation, made up of countless teams working in parallel to complete a massive job.

This Grid-Block-Thread hierarchy maps directly to real hardware resources. Each Block's shared memory (Shared Memory in CUDA terms) is more than ten times faster than global video memory (VRAM), but it's tiny — typically only a few dozen KB. The essence of a high-performance operator is precisely orchestrating data movement: pulling data from slow global memory into fast shared memory, computing, and writing back — while keeping all threads busy throughout. If the timing or synchronization points are off, you either get a severe performance hit or silently wrong results. This is the root cause of why hand-written CUDA is so error-prone and expensive to debug, and it's exactly what TileLang automates.

Matrix Multiplication as an Example

To accelerate matrix multiplication, a standard technique is "tiling" — breaking large matrices into small blocks, loading them one at a time into the GPU's fast cache to compute.

In traditional CUDA (manual transmission), the programmer manually controls how threads walk through the data, how data is moved, and when synchronization happens. You define the small tile in shared memory yourself, loop through the large matrix, move data point by point, and carefully hand-write synchronization instructions. Index arithmetic is everywhere, and one miscalculation breaks everything; a missed or misplaced sync instruction causes a data race that produces garbage output and is nearly impossible to debug.

In TileLang (automatic transmission), matrices and tiles are first-class objects. You simply describe how you want to tile the data, and TileLang handles the movement and synchronization automatically — no complex pointer arithmetic, just Python-like slice syntax for data operations. Most critically, there are no manual sync instructions: TileLang understands that you're doing tiled computation and inserts synchronization in exactly the right places when compiling to machine code. The code is dramatically shorter and far easier to read.

CUDA is like an old manual truck — you work the clutch and shift gears yourself, and if your technique is off the engine stalls (crashes) or miscalculates. TileLang is like a modern electric vehicle with autopilot — you set the destination (tile size), press the accelerator, and let it drive. Migration cost drops from "rewrite everything" to "change a few lines."

Three Industry-Level Shockwaves

Stepping back from DeepSeek itself, this release sends at least three shockwaves through the broader industry.

Shockwave One: The software gap for domestic chips is substantively closed. For the first time, Ascend now has a production-grade software stack in the most demanding use case — large model training — that is on par with the CUDA ecosystem. This will significantly accelerate the pace at which other domestic chip vendors follow suit.

Shockwave Two: Smaller AI companies gain real freedom in chip selection. Before this, a startup doing AI basically had one path: raise money, buy NVIDIA, burn cash. Now there's a genuine alternative: Ascend plus DeepSeek's open-source stack. Even if used only for inference clusters or fine-tuning vertical models, the cost structure changes meaningfully.

Shockwave Three: The "warring states era" of AI low-level languages begins. TileLang, Triton, Mojo, AscendC, CUDA — the AI low-level language landscape is about to get very crowded. Engineers who can write high-performance operators and tune for domestic chips are already extremely rare. When demand spikes, this group will see a new wave of opportunity.

From a broader geopolitical lens, this open-source release also carries strategic significance. Since the U.S. imposed advanced GPU export controls on China in 2022, NVIDIA's A100, H100, and similar high-end chips have been unable to legally enter the Chinese market. Domestic AI companies have had no choice but to turn to Ascend, Cambricon, and other local alternatives. Yet the "chips without software" problem has been the primary barrier to adoption — customers buy the hardware but can't run mainstream models on it, leaving large amounts of compute sitting idle. DeepSeek's release effectively provides a "universal adapter" for the entire domestic chip ecosystem, with the potential to activate already-deployed but underutilized compute. For the return on investment in national compute infrastructure, this is a meaningful improvement.

For Non-Trainers: The Opportunity Is in the Last Mile

Most readers are Java, Go, or front-end engineers working on internet or enterprise applications. You don't train models, so you might feel locked out of the model-layer upside. But the upside of "making AI actually work inside enterprises" is still very much yours to capture.

Short term (3–6 months): Your tech stack won't change because of this. But spend half a day pulling down the TileLang repo, take a look, run it if you can. Build the cognitive foundation early.

Medium term (6–18 months): AI costs will fall significantly, and the scope of projects you can take on will expand. The old pattern for adding AI capabilities — smart summarization, Q&A, document understanding — was to call an OpenAI, ERNIE, or Tongyi API, pay per token, and let data leave your internal network. The emerging pattern will be: privately deploy an open-source LLM, run it on a domestic compute cluster (Ascend + DeepSeek open-source stack).

Long term (1–3 years): It's time to recalibrate your skill bets. Don't go all-in on CUDA alone — cross-hardware languages like TileLang are worth the investment. Pay attention to the Ascend, Cambricon, and Moore Threads ecosystems. Most importantly: AI engineering capability is scarcer than model training capability. For the vast majority of enterprise teams, knowing how to use AI beats knowing how to train it. Domain knowledge combined with AI deployment skills is the highest-value combination.

The "last mile" of getting domestic compute into enterprise internal networks — the part that makes AI genuinely useful inside business systems — is exactly where application-layer engineers thrive.

Conclusion

What was open-sourced this time isn't a model — it's "the layer that makes everything usable": six production-grade components, each corresponding one-to-one with their NVIDIA counterparts. The bottleneck for domestic chips was never the hardware; it was migration cost. TileLang turns "writing execution plans by hand" back into "writing SQL," compressing migration cost from a full rewrite to a few line changes. For engineers who don't train models, the opportunity isn't in writing operators — it's in the last mile.