Research window: The past 24 hours (2026-09-17 07:00 ~ 2026-09-18 07:00, Beijing time). The previous issue was a trial run, with a window of 09-16 19:23 ~ 09-17 19:23, which overlaps with this window during the daytime of 09-17; for the overlapping portion, this issue only provides status notes and follow-up progress, focusing on what was newly opened and newly merged within the window. Sources: GitHub (full verification of push times across 28 repositories in the tile-ai organization; 9 repositories had pushes within the window; item-by-item review of newly opened PRs and defect tickets in the main repo during the window, including the RNG defect split, the GEMM type whitelist, and the CuTeDSL-side FP4 fix; item-by-item verification of branches, commits, and backport branches for TileOPs, TileOPs-nightly, tilelang-hygon, tilelang-ascend, tilelang-metax, and tilelang-musa), Google News RSS multi-language queries (via proxy), Hacker News, arXiv, and media coverage (NeoTeo’s reporting on DeepSeek kernel automation and TileKernels)

Index for This Issue

  • Today’s Highlights: TileOPs batched matrix multiplication switches to a shared GEMM template, delivering up to 1.44x speedup on H200 (09-17)
  • I. Core Project Progress
    • 1.1 Three RNG defects in the main repo split and fixed: default random sequence, void result binding, and no error on missing initialization (09-17)
    • 1.2 Unsupported GEMM type combinations are intercepted early, no longer falling through to nvcc’s type assertions (09-17)
    • 1.3 CuTeDSL backend FP4 conversion and storage fix; DeepSeek V4 activation quantization still stuck at the FP8 stage (09-17)
    • 1.4 API documentation and instruction-level variants for tiled quantized GEMM go live (09-17)
    • 1.5 Status notes on items already reported in the previous issue (09-17)
  • II. Multi-Backend Adaptation (Ascend / MetaX / Hygon / Moore Threads)
    • 2.1 Ascend: all 1,925 daily regression items pass, operator coverage continues to advance (09-17/09-18)
    • 2.2 Hygon: MLS address rebasing and asynchronous pipelining formally merged and backported to the release branch (09-17)
    • 2.3 MetaX: asynchronous copy GEMM enters the repository and then shifts to branch maintenance (09-17)
    • 2.4 Moore Threads: the backport branch carries MUSA 5.3.0 documentation; the main branch has been static since 09-11 (09-17)
  • III. Ecosystem and Adopters
    • 3.1 TileOPs manifestization: composite operators, resources, and nullable outputs enter the manifest (09-17)
    • 3.2 TileOPs documentation site follows up on unified dispatch and the new compilation boundary (09-17)
    • 3.3 Nightly benchmarks and correctness snapshots: 1 of 1,039 benchmark items fails, all 1,117 correctness items pass (09-17)
    • 3.4 Media: DeepSeek engineer predicts AI-written kernels will match his own work in 6 to 12 months (09-16/09-17)
    • 3.5 Adopter repositories quiet within the window: no pushes from TileKernels, FlashQLA, or TileRT
  • IV. Community, Tutorials, and Events
    • 4.1 Documentation site and API pages regenerated by bot (09-17)
    • 4.2 No additions on the academic and community side: zero hits on arXiv and Hacker News within the window (09-17)
    • 4.3 Release cadence: the latest tag in the main repo remains v0.1.14, with no TileOPs release (09-02)
  • V. Trend Observations
    • 5.1 The main repo’s focus shifts from “adding capabilities” to “turning silent errors into compile-time failures”
    • 5.2 CuTeDSL shows its first coupling breakage with upstream CUTLASS DSL version evolution
    • 5.3 Diverging cadence among domestic backends: Ascend iterates at high frequency, Hygon wraps up, MetaX and Moore Threads shift to maintenance
    • 5.4 TileOPs speeds up on one side while establishing contracts, evolving toward a contract-bearing operator layer
    • 5.5 Gaps and risk points in this window

Today’s Highlight: TileOPs BMM switches to shared GEMM template, up to 1.44x speedup on H200

Date: 2026-09-17　Source: TileOPs #2148 Batched matrix multiplication (BMM) switches to shared GEMM template

The heaviest change in this window lands in the operator library rather than the language itself: TileOPs replaces the kernel of its batched matrix multiplication forward operator (BmmFwdOp, comparable to torch.bmm) with the batched form of the shared GEMM template (GemmTemplate(BATCHED) and the batched kernels derived from it). The change was submitted by michaelwithu and merged by maintainer lcy-seso, across 6 commits.

The measured data given by the author in the PR (environment: NVIDIA H200, CUDA 13.2, PyTorch 2.13.0, TileLang 0.1.12) shows the gains are concentrated in medium-to-large shapes:

Shape (B,M,N,K) Type Old (ms) New (ms) vs. Old vs. torch-cublas New throughput
(8, 2048, 2048, 2048) bfloat16 0.2905 0.2023 1.437x 1.007x 679.6 TFLOPS
(4, 4096, 4096, 4096) bfloat16 1.0413 0.7451 1.398x 1.034x 737.9 TFLOPS
(128, 512, 512, 2048) bfloat16 0.2942 0.2110 1.394x 1.021x 651.3 TFLOPS
(8, 1024, 1024, 1024) float16 0.0410 0.0304 1.351x 1.021x 566.0 TFLOPS
(16, 512, 512, 512) float16 0.0132 0.0118 1.110x 1.008x 362.3 TFLOPS
(64, 128, 2048, 128) float16 0.0228 0.0199 1.146x 1.063x 216.1 TFLOPS
(32, 256, 256, 256) bfloat16 0.0064 0.0065 0.985x 1.108x 166.1 TFLOPS

Three takeaways: first, the new version does not fall behind torch-cublas in any of the 15 cases (1.007x to 1.185x), and small shapes (8×128×128×128, 32×256×256×256, 64×128×128×2048) are essentially at parity; second, the only regression is (32, 256, 256, 256) bfloat16 at 0.985x, a boundary case where template overhead is not yet amortized on small shapes; third, unifying batching onto a shared template means common foundations such as attention and multi-head structures are maintained in one place, so future batched-operator optimizations need not be copied one by one.

Merged alongside the speedup are 5 accompanying fixes, all written in the spirit of “let errors surface at construction time or measurement time”: MoE workspace validation made construction-time safe, the BMM template counting tiles by what is actually launched, H200 device detection with device-name case normalization, and attention kernel grid filled according to the device at hand. Such accompanying changes show that once a shared template is reused by multiple operators, the robustness of device detection and resource counting becomes a new common concern.

I. Core Project Progress

Window Overview: Of the 28 repositories in the tile-ai organization, 9 had pushes during the window, but the last commit on the main repo’s default branch is still the branch parameter type mapping fix from 09-17 09:57 — in other words, no new merges landed in the main repo during the latter half of the window (after 09-17 20:00 Beijing time), with activity concentrated in “review of already-opened PRs and defect splitting.” During the window, the main repo opened 6 new PRs and 1 defect ticket, all of which remain unmerged.

1.1 Main Repo RNG Three Defects Split and Fixed: Default Random Sequence, void Result Binding, Missing Initialization Not Reported (09-17)

Date: 2026-09-17　Source: #3242 Default sequence derived from full launch dimensions / #3243 Reject binding void results / #3244 Uninitialized access changed to explicit diagnostic

Three defects in the CUDA-side random number interface were split into three independent PRs (submitted by the same author; the predecessor #3239 was closed and replaced by the split). All three are silent issues of the “compiles fine by type, wrong by semantics” variety:

First, when no sequence number is specified, random state initialization derived the default sequence using only the x dimension within the thread block and the x dimension of the grid, so in thread blocks of two or more dimensions, threads differing only in y/z coordinates shared the same random subsequence, producing byte-identical random numbers. The fix derives the default sequence by folding all launched dimensions into it in row-major order, while preserving the historical value for the one-dimensional case (#3242, with 4 new tests covering 2D thread blocks, 2D grids, 1D compatibility, and comparison against an explicit sequence number).

Second, random initialization is itself a pure side-effect intrinsic, but the frontend recorded it as “having a return value,” so binding the result as documented would generate void state = ;, turning a semantic error into an nvcc “incomplete type” compile error. The fix rejects binding a valueless expression in the frontend and reports both the variable name and the offending expression (#3243).

Third, calling random numbers directly in a function that was never initialized generates an empty curand call, which likewise surfaces as an nvcc syntax error. The fix records “whether initialized” and “whether the random stream is consumed” in a function-level pre-scan, reporting a TileLang-native error if either is missing; the author explicitly notes that the check is function-level rather than control-flow-sensitive — initialization inside a runtime branch still counts as initialized, avoiding a slide into definite-assignment analysis (#3244).

Read together, these three reveal a systemic class of problem the main repo is addressing: missing frontend diagnostics let semantic errors surface in obscure forms inside the underlying compiler.

1.2 Unsupported GEMM Type Combinations Intercepted Upfront, No Longer Falling Through to nvcc Type Assertions (09-17)

Date: 2026-09-17　Source: tilelang #3245 Reject unsupported GEMM type combinations before CUDA code generation

Some matrix multiply operand type combinations (e.g., bfloat16 times bfloat16 with float16 output) were previously accepted by the frontend and only failed at the nvcc stage with an opaque static assertion. This PR establishes an explicit type whitelist for the Ampere/Ada-generation mma.sync path, validating at both the frontend entry point and in C++ instruction selection, so unsupported combinations are rejected before code generation with a clear message; supported combinations and non-Ampere targets are unaffected, with 1 negative and 3 positive regression tests. This is the second thread in this issue of the main repo “moving silent errors forward into explicit failures.”

1.3 CuTeDSL Backend FP4 Conversion and Storage Fix; DeepSeek V4 Activation Quantization Still Stuck at the FP8 Stage (09-17)

Date: 2026-09-17　Source: Defect ticket #3240 / Fix #3241

The most noteworthy risk item in the window appears in the CuTeDSL backend (the backend built on CUTLASS DSL primitives rather than CUDA code generation). The defect ticket records that the activation quantization kernel in the DeepSeek V4 example does not work on this backend. The root cause is version coupling — the conversion helper still uses outdated vector extract and insert operations, while nvidia-cutlass-dsl 4.7 has renamed both, causing all FP4 type conversions to throw MLIR attribute errors; the same chain also has an FP8 target type mismatch.

After the fix PR switches FP4 conversion to the new MLIR interface, the FP4 activation quantization path compiles and passes when this backend is specified, and the FP8 target type mismatch is fixed as well; but the combined case still fails — the FP8 stage hits an independent libNVVM compilation failure, so that case cannot yet be removed from the known-failure list. The ticket also records a finding worth noting: the actual way this backend is enabled (specifying the target via an environment variable) is only read in the repository by the example test fixture and two pipeline fragments, while the library itself does not read this variable, indicating that test coverage for this path was assembled bypassing the library layer.

It should also be noted that this section corresponds to actual activity on 09-17 (concentrated in the morning and evening), overlapping with the previous issue’s time window; it is called out separately here because it advanced from “defect recorded” to “defect half-fixed, remainder clearly delimited.”

1.4 Blockwise Quantized GEMM API Docs and Instruction-Level Variants Go Live (09-17)

Date: 2026-09-17　Source: tilelang.github.io commit Update docs

The documentation site was regenerated by a bot (387 files), pushing the blockwise quantized GEMM merged into the main repo in the previous issue onto the public API pages: under the CUDA dialect, a full signature description of blockwise quantized GEMM was added (scale factors as first-class inputs, completion barriers required on SM100, cluster dimension configuration required for dual-CTA mode, SM120 taking the synchronous fragment-accumulation path), along with three newly listed instruction-level explicit variants — Hopper’s wgmma explicit async version, Blackwell’s tcgen05 explicit async version, and the corresponding blockwise quantized versions of both, plus a scale layout construction entry point. The docs also hard-code the behavioral contract as “unsupported combinations fail to compile rather than dropping scale factors.” This aligns with the orientation of 1.2: adding capability while writing failure modes into the documentation.

1.5 Status Notes on Items Reported in the Previous Issue (09-17)

The following items were reported in the previous issue and saw no semantic changes during the window; only their current status is recorded: main repo blockwise quantized GEMM and its backend selector (#3237), performance recovery for atomic vector width planned by destination address (#3238), batch parameter type mapping completion (#3229); TileOPs’ MoE index small-router expert path (#2141) and kernel selection, build dispatch refactor (#2146); Ascend-side NSA forward and variable-length operators, dynamic quantization and RMSNorm fusion examples; MetaX asynchronous copy GEMM (#156) and its test fix (#157). The above dozen-plus items constitute the backlog for this window and are not expanded upon again in this issue.

II. Multi-Backend Adaptation (Ascend / MetaX / Hygon / Moore Threads)

Window Overview: All four domestic and third-party backends saw activity within the window, but of differing nature — Ascend maintained the highest activity level with “high-frequency operator coverage + daily regression,” Hygon completed a relatively large backend change merge and backport, while MetaX and Moore Threads have shifted focus to release branches and documentation maintenance.

2.1 Ascend: Daily Regression Passes All 1925 Tests, Operator Coverage Advances (09-17/09-18)

Date: 2026-09-18　Source: tilelang-ascend daily test report #1811

The Ascend adaptation repo’s daily scheduled test reported at 05:46 (Beijing time) on 09-18: all 1925 tests passed, 0 failures, with attachments retained for 30 days. This is the only cross-day data point in this window, serving as evidence that “Ascend-side regression remains all-green after the upstream main repo continuously merged new operators.” The repo had 4 commits in the window (NSA forward, NSA forward variable-length, dynamic quantization example, RMSNorm dynamic quantization fusion example), all landing on the morning of 09-17 and already covered in the previous issue; no new commits appeared in the latter half of the window.

2.2 Hygon: MLS Address Rebasing and Async Pipeline Formally Merged, Backported to Release Branch (09-17)

Date: 2026-09-17　Source: tilelang-hygon #10 Rebase buffer storage and take over async copy pipeline

A Hygon-side change was formally merged into the main branch in this window (19 files, +540/-31), covering two things: first, address rebasing for multi-level storage (MLS), adding buffer operation rebase annotations and corresponding attribute mappings so that backend code generation can rebase buffer storage addresses by block index, while also speeding up layout inference on these paths; second, delegating the commit and wait of parallel copies with async preferences to the software pipeline planner. The change also passed format checks. After merging, the repo backported the same change to the v0.1.12 release branch at 20:25 (Beijing time) on 09-17, additionally bringing in a fix for matmul layout under 3D slice scopes; the newly created development branch feat/hcu-mls-rebase-device-flags also has one more commit for pipeline management and format cleanup. Hygon remains the heaviest in backend code changes among the four.

2.3 MetaX: Async Copy GEMM Merged, Now in Branch Maintenance (09-17)

Date: 2026-09-17　Source: tilelang-metax branch list

MetaX saw no new main-branch commits in the window; the latest landing point remains the MACA async copy matmul support and its test fix merged on the morning of 09-17 (already covered in the previous issue). Current activity is concentrated on release branches and test maintenance, making it the smallest in change volume among the four.

2.4 Moore Threads: Backport Branch Carries MUSA 5.3.0 Documentation, Main Branch Static Since 09-11 (09-17)

Date: 2026-09-17　Source: tilelang-musa branch list

The Moore Threads adaptation repo’s main branch last saw a commit on 09-11; pushes within the window landed on the release backport branch, containing the MUSA 5.3.0 documentation commit frozen on the morning of 09-17 (already covered in the previous issue). The branch list shows its maintenance approach is “one upstream minor version corresponds to one suffixed backport branch,” currently sitting on the v0.1.12 line and not yet following the main repo’s v0.1.14.

III. Ecosystem and Adopters

3.1 TileOPs manifest-ification: composite operators, resources, and nullable outputs enter the manifest (09-17)

Date: 2026-09-17　Source: TileOPs #2147 Expressing composite operators via manifest

TileOPs submitted its largest change of this window (34 files, +2552/-370, not yet merged). It lets the operator manifest describe the internal structure, resources, and nullable outputs of composite operators, while consolidating previously scattered duplicate derivation logic. The author’s problem list is telling of the project’s maturity bottleneck: the manifest previously could only describe the external contract of public operators, leaving six already-implemented composite operators with nowhere to declare themselves as composite; one fused expert operator declared two temporary buffers as ordinary signature inputs, effectively giving the workspace “result-dependent value” semantics; the shared expert operator had no manifest entry, its benchmark carried its own compute and byte-count calculations, and its class name violated the established naming convention; and fixed output positions returning null previously could not be expressed. None of these are performance issues—they are interface contract issues. Viewed alongside today’s highlight on batched matmul template reuse, TileOPs is advancing both the performance and contract tracks simultaneously.

3.2 TileOPs docs site follows up on unified dispatch and new compilation boundaries (09-17)

Date: 2026-09-17　Source: TileOPs.github.io #51 Follow up on unified kernel dispatch

The docs site synced the operator dispatch refactor merged in the previous issue: the new signature of the kernel acquisition entry point (taking keys and build method as explicit parameters), the boundaries of PyTorch custom operator registration and fake implementation registration, and the compilation boundary syntax generated from operator spec tuples. Both Chinese and English docs were modified in the same batch, and the author recorded in the verification section the execution of the interface page check script, docs site build, and full test suite. Documentation following up the same day after upstream operator changes shows that TileOPs’ documentation pipeline is automated enough to track refactors.

3.3 Nightly benchmark and correctness snapshot: 1 of 1039 benchmarks failed, all 1117 correctness tests passed (09-17)

Date: 2026-09-17　Source: TileOPs-nightly snapshot commit / snapshot record file

TileOPs’ nightly pipeline generated a snapshot in this window for the “batched matmul templating” commit (the merge result of today’s highlight), containing benchmark results, correctness results, and environment metadata. The metadata pins down everything needed for reproducibility: the exact commit hash, container image recorded by digest, GPU model and power cap, SM clock settings, and full dependency versions (in this record, Cube version 13.2, PyTorch 2.13.0, TileLang 0.1.11 plus the build identifier for that commit). Readings from the two result sets:

  • Correctness: all 1117 tests passed, 2 skipped, taking about 219 seconds;
  • Benchmark: 1 of 1039 cases failed; the failing case is the GQA prefill paged kernel under the softcap 50 configuration, and the error comes from a function signature mismatch in the reference baseline implementation (missing one parameter), not from a TileOPs kernel error—this kind of failure precisely illustrates the need for “the reference side to also enter regression.”

The standout in the benchmark is the sparse attention decoding class of operators: under mainstream batch configurations, TileOPs achieves 1.86 ms and 313.98 TFLOPS, versus 19.88 ms and 30.79 TFLOPS for the reference implementation, with the other two references (fused attention implementation at 5.61 ms, compiled PyTorch at 16.64 ms) also behind; the long-context low top-k variant achieves 0.50 ms and 291.55 TFLOPS versus 20.36 ms for the reference; multi-head latent attention decoding at 4k context (half precision) achieves 0.0385 ms versus 0.3147 ms for the reference.

Two caveats are needed: these numbers appear only in a single nightly pipeline run record and are not a cross-sectional evaluation; and the reference implementation for the sparse attention item is a naive implementation (30.79 TFLOPS), not directly comparable to production-grade indexed attention.

3.4 Media: DeepSeek engineer predicts AI-written kernels could match his work in 6 to 12 months (09-16/09-17)

Date: 2026-09-17　Source: NeoTeo: DeepSeek engineer forecasts AI-written GPU kernels could match his work

This is the only topical media report retrieved in the window. The article records the public judgment of DeepSeek engineer Shengyu Liu: over about a year, AI’s role in kernel work advanced from reading documentation and code and fixing defects to reading low-level graphics assembly, analyzing instruction stalls, and optimizing operators; he predicts that within 6 to 12 months AI-written kernels could reach or exceed his own level, with the human role shifting to defining goals, interpreting profiling results, and judging output. The article also surveys the TileLang ecosystem as background: TileKernels is a kernel library written purely in TileLang, covering gating, mixture-of-experts routing, quantization, transpose, and two types of connection operators, with environment requirements of two generations of Hopper/Blackwell-class GPUs, Python 3.10+, PyTorch 2.10+, TileLang 0.1.9+, and CUDA 13.1+; it also cites NVIDIA’s earlier verifier-loop experiment generating attention kernels with a reasoning model (100% first-level numerical correctness, 96% second-level, about 15 minutes per loop) as a comparison for “already working under limited conditions.”

On positioning, it must be made clear: this is predictive reporting plus ecosystem overview, containing no changes to TileLang itself and constituting no independent verification of the above capabilities; the reason for inclusion is that it is the only public material in this window discussing TileLang in the context of industry talent structure, and it is directly relevant to the narrative of the adopter (TileKernels).

3.5 Adopter repositories quiet in the window: no pushes from TileKernels, FlashQLA, or TileRT

In the window, DeepSeek’s TileKernels (last push 04-23), Alibaba Qwen’s FlashQLA (08-26), and TileRT (08-13), also under the tile-ai organization, had no commits. TileRT has now gone five consecutive weeks without updates. The static state on the adopter side does not constitute a risk signal in this window, but it means today’s activity comes entirely from the upstream language and operator library side.

IV. Community, Tutorials, and Events

4.1 Docs site and API pages regenerated by bot (09-17)

Date: 2026-09-17　Source: tilelang.github.io commit list

The main repository’s docs site was regenerated by bot from upstream code that day (387 files), with visible content changes concentrated in matmul-related API pages (see 1.4). This chain of “upstream merge, docs site follows up the same day” operated normally in this window, with no disconnect between docs and code.

4.2 No additions on the academic and community side: zero hits on arXiv and Hacker News in the window (09-17)

In this window, an arXiv search for TileLang returned no new papers; the most recent is a performance modeling paper (TileSight) from 2026-07-24, which is background material; Hacker News had no topical discussion hits in the past five days. There was no tutorial, tutorial-style repository, or event announcement content on the community side in the window, so this issue has no incremental entries.

4.3 Release cadence: main repo’s latest tag remains v0.1.14, no TileOPs release (09-02)

The main repository’s latest tag remains v0.1.14 (released 09-02), with no new tags in the window; TileOPs still has no release records or tags, and its external state is carried by the docs site and nightly snapshots.

V. Trend Observations

5.1 Main repo’s focus shifts from “adding capabilities” to “turning silent errors into compile-time failures”

Of the 6 new PRs opened in the main repo this window, 5 belong to the same family: wrong default RNG sequence, binding void results, missing initialization not reported, type combinations that don’t satisfy constraints but blow up in the underlying compiler, and outdated interfaces for sub-byte floating-point conversion. The common thread is that these previously compiled and produced results, but the results were wrong or the error messages pointed to unrelated layers. Combined with the dispatch refactor turning “silent degradation on backends lacking capability” into a compile failure, it can be judged that the main repo’s current priority is to build error boundaries at the language layer rather than continuing to expand the operator surface.

5.2 First appearance of CuTeDSL and the coupling damage from upstream CUTLASS DSL version evolution

The CuTeDSL backend in this window first exposed the problem of being broken by upstream version renames, and even after the fix, the FP8 stage still gets stuck on libNVVM. This points to a structural risk: backends built on third-party DSLs have their stability dependent on the stability of upstream interfaces, and such backends currently lack a library-level readable way to enable them and regular regression coverage. For adopters relying on this pathway (especially teams focused on DeepSeek-family quantized operators), the progress in this window is worth tracking.

5.3 Diverging cadence among domestic backends: Ascend iterating at high frequency, Hygon consolidating, MetaX and Moore Threads shifting to maintenance

The differences among the four are especially clear in this window: Ascend maintains momentum with 1925 daily regressions plus operator completion; Hygon completed a relatively large change involving code generation and pipelining and immediately back-ported it to the release branch, which is “merge plus consolidation”; MetaX shifted to testing and branch maintenance after landing asynchronous copy GEMM; Moore Threads’ back-port branch is stuck at the v0.1.12 line and has not yet followed up to main repo v0.1.14. From this, the overall cadence of domestic adaptation remains healthy, but the gap among vendors in how far they can track the latest upstream language capabilities has already opened up.

5.4 TileOPs speeds up while establishing contracts, evolving toward a contract-bearing operator layer

Today’s highlight on batched matmul speedup (up to 1.44x, not falling behind the official library) and the manifest-ification changes (composite operators, resource semantics, nullable outputs) advanced on the same day, plus the nightly pipeline leaving a reproducible snapshot for each commit (commit hash, image digest, clock settings), TileOPs’ positioning is shifting from “a batch of operator implementations” to “a batch of contract-bearing, reproducibly compared operators.” This is good for downstream inference engine integration: clear contracts reduce integration cost more than operator count does.

5.5 Gaps and risk points in this window

On gaps: the main repo’s default branch had no new merges in the latter half of the window; adopter repositories (TileKernels, FlashQLA, TileRT) were all static; zero hits on the academic and community side; no new releases. On risks, there are two: first, the FP8 stage of DeepSeek V4 activation quantization on CuTeDSL is still not working, and the combined case remains on the known-failure list; second, all 6 main repo PRs opened in this window remain unmerged, with the three RNG defects and the type whitelist still in the review queue, making the timing of fixes uncertain—these three points are what the next issue should focus on verifying.

Appendix: Sources and Verification Notes

Source Verification Table

Source Verification Result
GitHub organization push check Full check of push times across 28 repos in the tile-ai organization; 9 repos had pushes within the window: main repo, operator library and its site and nightly data repo, Ascend, MetaX, Hygon, Moore Threads, docs site
Main repo commit details 2 commits in the default branch within the window (both already reported in the previous issue), last commit at 09-17 09:57; 6 new PRs and 1 bug report opened within the window, none merged
TileOPs 3 merges within the window (2 of which were already reported in the previous issue), 1 new PR opened; the nightly data repo generated a snapshot for the latest commit
TileOPs-nightly 1 push to the snapshots branch within the window; 1 of 1039 benchmarks failed (reference implementation signature issue), all 1117 correctness items passed
tilelang-ascend 4 commits within the window (already reported in the previous issue) plus 1 daily test report (all 1925 items passed)
tilelang-hygon 1 merge to the main branch, 2 to the backport branch, 1 to the dev branch; changes include address rebasing and async pipeline takeover
tilelang-metax 2 commits in the default branch within the window (already reported in the previous issue), no new commits
tilelang-musa No commits in the default branch within the window; pushes landed on the v0.1.12 backport branch; last commit to the main branch was 09-11
tilelang-mlir-ascend / TileFoundry / DeepStack / tilescale No pushes within the window; most recent were 09-16 / 09-15 / 09-15 / 08-25 respectively
TileRT No pushes within the window; most recent was 2026-08-13, five consecutive weeks without updates
Adopter repos TileKernels / FlashQLA No pushes within the window; most recent were 2026-04-23 / 2026-08-26 respectively
Google News RSS (multiple queries in Chinese and English) After combined queries of topic terms, component names, and team terms, only 1 usable hit within the window (NeoTeo report); the rest were same-name noise and stock market articles, which were excluded
Hacker News Zero hits for topic terms over the past five days; all hits were same-name entries
arXiv No new papers within the window; the most recent was a performance modeling paper from 2026-07-24
Docs site and tags Docs site regenerated the same day (387 files); the latest tag on the main repo remains v0.1.14 (09-02), TileOPs has no tags or releases

Full Source List