TileLang Natively Supports Ascend 950: A Technical Breakdown of Open-Source Operator Development

What TileLang's Native Ascend 950 Support Really Means

TileLang's main repository now officially supports generating operator code for the Ascend 950 — a development worth watching for anyone tracking the domestic AI chip ecosystem. Writing high-performance operators on Ascend hardware has historically demanded deep low-level knowledge and tedious hand-tuned optimizations. TileLang takes a different approach: expressing computation logic and data movement in Python-style syntax, then mapping that to Ascend hardware capabilities through a compilation toolchain.

This means developers can describe an operator at a relatively high level of abstraction without having to handle every low-level detail from scratch. For teams looking to deploy custom operators on the Ascend 950, this lowers the barrier to entry and makes operator iteration and debugging significantly more intuitive.

How Python-Style Code Runs on Ascend Hardware

A core question worth addressing: how does code that looks like Python actually leverage Ascend hardware capabilities? The answer lies in the compilation toolchain underneath. TileLang code is compiled and transformed into low-level Ascend-targeted code — every computation expression and data movement operation the developer writes gets translated into a hardware-executable form during this process.

The full workflow breaks down into roughly three steps: express computation logic and data movement arrangements in TileLang, compile through the toolchain to generate Ascend 950–targeted code, then run it on hardware to check results and benchmark performance. This "write high-level, run low-level" model is key to how TileLang maintains a consistent development experience across multiple hardware backends.

Opening the Generated Code to See What Happened

The best way to understand a compiled DSL (Domain-Specific Language) is to open the code it generates and see what your operations actually turned into. By comparing source code against generated output, developers gain a clearer picture of how data is moved on-chip and how computation is scheduled — which pays dividends when reading someone else's operator implementation or refactoring your own.

This "observability" is especially valuable for performance tuning: when you know which low-level instructions correspond to a given line of high-level code, you can optimize with much greater precision.

---

Ascend NPUs (such as the 910B, 910C, and the latest 950) differ significantly from NVIDIA GPUs in hardware architecture. Their core compute units are called the Cube Core (handling matrix multiplication) and Vector Core (handling element-wise operations), while on-chip memory is organized across multiple tiers: L0A/L0B/L0C, L1, and Unified Buffer. Data movement between these tiers must be explicitly orchestrated via dedicated DMA instructions (e.g., copy_gm_to_l1, copy_l1_to_l0a). This is the primary reason hand-writing Ascend operators — typically using Huawei's TBE/TIK programming framework — carries such a steep learning curve: developers must manually manage memory hierarchy and instruction pipelining. TileLang's compilation toolchain takes on this tedious mapping work, automatically translating high-level computation descriptions into the corresponding TBE primitives or AscendC code while handling data movement timing and synchronization.

A DSL (Domain-Specific Language) is a programming language designed for a specific application domain. Compared to general-purpose languages like C++ or Python, a DSL makes certain trade-offs in expressiveness, but offers more concise, problem-native syntax within its target domain. TileLang is a compiled DSL: programs written in its Python-like syntax are not interpreted directly, but instead pass through frontend parsing, intermediate representation optimization, and backend code generation phases before producing hardware-executable low-level code. Similar in spirit to Triton in the CUDA ecosystem, or TVM/TIR in AI compilers, TileLang aims to strike a balance between developer productivity and the ability to generate high-performance code. Understanding the structure of generated code helps developers indirectly control low-level behavior — by adjusting their high-level code — in cases where the compiler hasn't fully optimized.

Supporting Development Resources and Operator Libraries

A set of supporting resources is already available for Ascend development with TileLang:

• TileLang main repo and TileKernels: The framework itself and operator implementations — a solid starting point for understanding the architecture and coding patterns.
• Ascend-targeted operator library: Contains operator implementations and tests for Ascend hardware. A good reference if you need working code to learn from.
• LearningHub development courses: Systematic TileLang tutorials with worked examples walking through each step — what to write and why — well-suited for hands-on learning.
• AI-assisted development tools: A TileLang development assistant that can help generate operators and write tests, further boosting productivity.

These resources cover the full spectrum — from "learning by example" to "building it yourself" to "letting AI help you write it" — making them accessible to developers at different stages.

Starting with Examples to Build Understanding

For beginners, diving into concrete examples from the operator library is often more effective than reading documentation from top to bottom. Observing how a specific operator expresses computation, arranges data movement, and structures its tests — then trying to modify parameters or logic and validating on hardware — tends to be the most efficient learning path.

Why This Matters

TileLang's native support for the Ascend 950 represents a meaningful reinforcement of the domestic AI chip ecosystem at the developer tooling layer. High-performance operator development has long been one of the bottlenecks for hardware ecosystems — great hardware needs accessible programming abstractions and a mature toolchain before a broader community of developers can meaningfully engage with it.

By covering multiple hardware backends with a unified high-level syntax, TileLang allows Ascend to leverage community knowledge and existing ecosystem experience rather than building entirely from scratch. For developers, this is an opportunity to get started with Ascend operator development using a familiar Python-style workflow. If you're interested, the main repo, operator library, and development courses are all available — pick an operator you care about and give it a try.

---

An operator is a fundamental unit of computation in deep learning frameworks — think matrix multiplication (GEMM), attention mechanisms, activation functions, and so on. Custom operator development becomes necessary when a framework's standard operators can't meet the demands of new model architectures, or when standard implementations deliver insufficient performance on specific hardware. In the CUDA ecosystem, tools like Triton have dramatically lowered this barrier, enabling researchers and engineers to write high-performance GPU operators without mastering CUDA assembly. The Ascend ecosystem previously lacked comparable tooling, keeping the barrier high for hand-written TIK/AscendC operators and limiting the pace of community-driven operator innovation. TileLang's support for Ascend 950 meaningfully fills this gap — making it possible to rapidly prototype new operator ideas and benchmark their performance on Ascend hardware.