Reporting period: Monday, November 9, 2026 through Friday, November 13, 2026 — 5 working days.


Part 1 · Brief

This section is the week’s curated highlights, kept under 800 words by default (767 words this issue); full entries, itemized lists, and sources are archived in Part 2.

Two main threads hand off simultaneously this week: one is releases, the other is the coverage of the vector path.

  • ruyi 0.54.0 officially released: Landed on 11-10, forty-seven days and seventy-one commits after 0.53.0; the core is the collection and matching of ELF ABI compatibility, and the visible change turns “can it install” into a pre-install determination — ruyi list shows host compatibility, ruyi install warns when installing an incompatible package, and ruyi admin check-abi aids troubleshooting.
  • triton-riscv cuts its first formal release tag: release/20261108-6895885 shipped on 11-09; the previous eighteen tags were all nightly, and installation now prefers wheels; #110 on 11-10 enables the AMD GPU backend by default on RISC-V hosts, validated on real hardware with SG2044 paired with an RX 7900 XTX.
  • buddy-mlir merges thirteen commits in one week: i1 masks, libm-only math functions, bf16, all reduction kinds, rank-0 fill, and integer matmul are wired into VIR category by category; FlagGems passing count on SG2044 goes 3980 → 4006, and across 1811 kernels linalg.fill goes 393 → 0 and linalg.matmul 2 → 0.
  • VLEN 1024 becomes a shared pressure point: Three fixes land in the same week — load-time validation (#1032, mismatched VLEN triggers a direct _exit(1)), reduction lane loss (#1051, CI all green while all 25 reductions fail on the K3 board), and strip-mined remainder handling (#1050).
  • openRuyi packaging runs at full tilt but the monthly release doesn’t move: Single-day peak of thirty-six commits, forty packages following KDE Plasma 6.8.2, the kernel reaching 7.3.4 and 6.18.63, glibc bumped to 2.44; the public monthly release remains at 2026.09.

This week’s assessment: What got fixed this week is “can it be delivered” rather than features — all four repos spent the same week patching the release chain and the install path; the defects are almost all “no error, just wrong results,” and verification cost has reached the scale of exhaustive input enumeration; packaging is moving while the monthly versioned release is stuck.


Part 2 · Archive

Below is the full text for the week, with structure and conventions consistent with previous weekly reports; every judgment in the brief can find its itemized basis and sources here.

Source material: 5 issues of this publication’s daily RuyiAI update reports (2026-11-09 to 2026-11-13, each window covering 04:30 of the prior day to 04:30 of the current day, with Monday covering the past 3 days including the weekend); plus a 168-hour repository check across four organizations — RuyiAI-Stack, ruyisdk, buddy-compiler, and openRuyi-Project (check coverage through the morning of 11-14), dual-source cross-checks against the RuyiSDK developer community and the openRuyi distribution news page, three-page snapshots of the official RuyiAI homepage along with the blog and documentation index, and targeted searches of Google News and arXiv.

Editorial note: Two main threads hand off simultaneously this week: one is releases, the other is the coverage of the vector path. On the release side, ruyi 0.54.0 landed as a formal release on 11-10, forty-seven days after the previous version; triton-riscv cut the first release/ tag in the repository’s history on 11-09, and on 11-10 enabled the AMD GPU backend by default on RISC-V hosts; Ruyi Imager 1.1.0 was released the same day, and biweekly progress issue 080 closed out this batch of “triple releases” as the external messaging. On the compiler side, buddy-mlir merged thirteen commits in one week, wiring i1 masks, libm-only math functions, bf16, all reduction kinds, rank-0 fill, and integer matmul into the VIR vector path category by category; the FlagGems suite’s passing count on SG2044 rose from 3980 to 4006, and the residual linalg.fill and linalg.matmul among 1811 kernels both dropped to zero. Advancing alongside coverage is safety: three VLEN-related changes all point to the same class of failure — no error, just wrong results. The gap remains in the same place: openRuyi’s monthly release is still at 2026.09, with no new version in October or November to date.

I. Weekly Highlights

  • ruyi 0.54.0 officially released: ELF ABI compatibility moves from “package scanning” to “pre-install determination”: The stable release shipped on 11-10 at 21:15 (Beijing time), forty-seven days after the previous 0.53.0 on 09-24; seventy-one commits and seventy-four files relative to 0.53.0. The bulk is the collection and matching of ELF ABI compatibility information—collection is split by architecture: x86-64 records the ISA feature level, AArch64 records BTI and PAC, RISC-V records the ISA string (including parsing of versioned single-letter extensions, filtering ld.so.cache entries by host floating-point ABI, and stack alignment requirements). User-visible changes land in three commands: ruyi list shows host compatibility in the notes, ruyi install warns when installing an incompatible package, and ruyi admin check-abi is available for troubleshooting; the data plane goes through repository-side ABI sidecars, and a bad sidecar is discarded as “no ABI information” rather than failing the whole install. There is also a fetch-path fix in #509: non-2xx HTTP responses now report errors faithfully, failed first downloads are discarded, and stalled transfers get a timeout. Sources: ruyi 0.54.0, 0.53.0…0.54.0 comparison, PR #507

  • triton-riscv cuts its first official release tag; install path moves from source to wheel: release/20261108-6895885 was published on 11-09 at 06:59; all eighteen previous tags carried the nightly/ prefix, and the repo had never had a release/ tier. The release ships two wheels, x86_64 (manylinux_2_27 and 2_28) and riscv64 (manylinux_2_39), uniformly cp312-abi3, with version string triton-3.9.0; the tag points at the 11-06 merge commit “add codegen library for AMD,” and the three commits from that day all landed after the tag and are not in this package. PRs #105 and #107 the same day switch the README install section from source-first to wheel-first, and change the quick start from “print ok: True” to compiling a kernel for riscv64-unknown-linux-gnu, keeping the object file, and grepping the disassembly for the backend-generated vsetivli, vle32.v, vfadd.vv, vse32.v. Sources: release/20261108-6895885, PR #105, PR #107

  • triton-riscv enables the AMD GPU backend by default on RISC-V hosts, validated on real hardware with SG2044 + RX 7900 XTX: #110 merged on 11-10 at 17:51 and does three things: builds and packages the riscv64 AMD codegen library with the existing Buddy LLVM SDK; fixes the ambiguity on riscv64 when choosing between the CPU and GPU drivers, with the rule being to prefer an available GPU; and removes the driver-layer check that made the choice ambiguous. Validation was done on real hardware—SG2044 with an RX 7900 XTX, torch and ROCm from the openRuyi software repository—and it also tested whether the backend falls back to CPU automatically when the GPU device is hidden. This confirms that a RISC-V host really does dispatch kernels to the AMD card rather than falling back to the CPU. The README gains an AMD GPU section: when ROCm is present the backend activates itself via torch.version.hip, and the wheel does not bundle the ROCm runtime. Source: PR #110

  • buddy-mlir merges thirteen PRs in a week, filling in VIR operator coverage in batches: from VLEN semantics in #1032 and #1037, to end-to-end YOLOv8 in #1041 and #1042, to tail and reduction fixes in #1050 and #1051, and finally seven PRs #1052 through #1058 merged back-to-back between 11-12 08:12 and 14:44. The verifiable numbers are concentrated on the test side: the Triton-RISCV FlagGems suite’s 4045 items on SG2044 (VLEN 128) went from 3980 to 4006 passing, with the 26 fixed items being test_erf and test_gelu; residual linalg.fill across 1811 kernels dropped from 393 to 0 and linalg.matmul from 2 to 0; and the one issue that blocked 179 of 325 Triton-RISCV test files on i1 memref under the pure VIR pipeline was also eliminated. Sources: PR #1052, PR #1053, PR #1057, PR #1058

  • VLEN is the week’s most concentrated pressure point: load-time validation, reduction lane loss, and strip-mined tails all move at once: #1032 elevates the “build for exact VLEN” constraint from a build-script comment to a runtime enforcement—runtime/rvv/BuddyRvvVlen.c is linked into the model library as a constructor, reads vlenb at load time, and if it does not match the exact VLEN used at build time, prints a message and calls _exit(1) (_exit rather than exit, because running destructors while the loader holds its lock would deadlock); the triggering case is concrete: a DeepSeek-R1 rax built for prefill_ime on K3 lands on an X100 core (VLEN 256) and produces wrong results when /proc/set_ai_thread has not been executed. #1051 fixes reductions: ElideSingleElementReduction treated vector<[1]xT> as a single-element vector, so the other vscale−1 lanes vanished, and all 25 reduction tests on the K3’s A100 core returned wrong values (amax over 512 values gave 1.853 instead of 4.101), while the CI VLEN 256 runner kept passing. #1050 fixes tails: a strip-mined vir.set_vl previously dumped all remaining lanes into a scalar tail loop, and on K3 the hottest loop in the f32 YOLOv8 pose head (5% of total model time) was a scalar dot product, with scalar floating-point instructions accounting for 39% of perf’s 150k samples. Sources: PR #1032, PR #1051, PR #1050

  • openRuyi packaging at full tilt: one release each on both kernel lines, KDE Plasma 6.8.2 with forty packages following the same day, single-day peak of thirty-six commits: The rolling kernel linux went from 7.3.3 (11-08) to 7.3.4 (11-11), and the long-term line linux-lts from 6.18.62 to 6.18.63, each with a patchset and config refresh; glibc moved to 2.44 and ran the full test suite on x86_64, while rpm-config-openruyi gained x86_64 architecture macros and tune configuration, part of the build system filling in the host side. The desktop stack saw the week’s largest single batch on 11-09: KDE Plasma 6.8.2 upgraded wholesale, with forty packages following the same day, from kwin and plasma-workspace to breeze, discover, powerdevil, and supporting pieces such as libplasma and libkscreen, with the Wayland stack advancing in step (wayland 1.26.0, wayland-protocols 1.50, wlroots 0.20.2). 11-11’s thirty-six commits were the densest day of the past week: eight OpenTelemetry packages moved to 1.45.2 plus two new packages, and all four Python auth packages (pyjwt, oauthlib, joserfc, authlib) carried security-fix markers. Sources: linux 7.3.4 and the openRuyi commit list, plasma-workspace commit, glibc upgrade commit

  • The firmware and device update chain closes the loop within a week: Ruyi Firmware reaches beyond a single chip vendor, and fwupd’s three pieces come together: Ruyi Firmware shipped two releases back-to-back on 11-07 and 11-08; 20261107 extends support from SpacemiT K3 to the SiFive HiFive Unmatched—adding SPI boot, JTAG recovery, NVMe and USB boot, and persistent UEFI variables for that board, with PXE and HTTP ISO boot controls added to Platform Settings; 20261108 changes only the K3 line, switching USB Fastboot to the shared EDK2 implementation and reporting the firmware version via fastboot getvar version-bootloader. On the openRuyi side the firmware update chain is completed in three places: 11-11 brings in fwupd itself plus the OpenCL trio (opencl-headers, opencl-icd-loader, clinfo), and 11-12 adds the gcab package and an OVMF RiscVVirt FMP capsule patch, forming a complete path of “device firmware published as cab—parsed and delivered in-system by fwupd—written by UEFI as a capsule.” The ruyi branch of ruyifirmware also has a “fu740: Support recovery with OpenOCD 0.12” commit. Sources: Ruyi Firmware 20261107, Ruyi Firmware 20261108, gcab commit, OVMF capsule patch

  • Biweekly progress issue 080 goes up on the forum, settling accounts on four upstream lines at once: Posted to the RuyiSDK community forum on 11-11 at 17:53, six days after the in-repo draft of 11-05. The compiler side is the most concrete: three RISC-V GCC backend optimizations entered the GCC development trunk on 10-27 (r17-5638, r17-5639, r17-5640), covering Zba shift-add and integer div/rem combination recognition, Zbs eliminating redundant masks via bclr shift-index semantics, and Zbkb fixing the packh cost model and match priority, all three with regression tests; on the LLVM side, six RISC-V P-extension and GlobalISel PRs merged upstream (#235306, #235245, #234450, #237815, #238214, #234484). RuyiSDK’s own LLVM branch adds preliminary RV32/RV64 matrix extension support per the Ztt spec and intrinsics document v0.6 (#169). On the runtime side, the RISC-V port of OpenJDK’s JEP 544 (AOT static compilation) passed functional tests and merged into the trunk (#32311); V8’s review list shows “Allow vlen=1024” (CL8585179), pointing at the same hardware fact as this issue’s two K3 fixes in buddy-mlir. Sources: Issue 080 (community forum), Issue 080 article commit

  • The other half of the release story: monthly releases untouched for a month, site and intelligence repo both silent: The latest two posts on the openRuyi distro news page are both from 10-19, the monthly release entry is still stuck at 2026.09 from 09-30, and the repo’s tags are still at 2026.09-experimental; by the one-release-per-month cadence from 05 through 09, the October and November releases had still not appeared as of this week, while the packaging repo kept up several to thirty-plus commits a day. The official homepage’s index, blog, and docs pages showed no hash changes all week, the blog still has two posts and the docs index twenty-three chapters, and this week’s batch of VIR changes has no corresponding article on the site; the ruyiai-daily intelligence repo’s last commit is still 11-08, with five issues from 11-09 to 11-13 not generated. Two actions from the evening before publication through the early hours of the day are also noted here: the nightly build 2026-11-13-72176d5 was produced on 11-14 at 00:25; and on 11-14 at 15:19, #117 (explicit targets switched to opt -O3, +zvfbfmin added to the default llc features), listed as open in the 11-13 daily, was merged into the mainline. Sources: openRuyi news page, ruyiai-daily commit list, PR #117


II. RuyiAI Stack Progress (PyTorch / Triton / TileLang RISC-V Adaptation)

2.1 triton-riscv: From “Eighteen Nightly Tags” to the First Official Release

Date: 2026-11-06 to 2026-11-14 Source: Official release tag, PR #105 README switched to wheel-first

This repo completed three steps this week: establishing the release tier (the first release/ tag), switching the install path from source to wheel, and taking the heterogeneous backend from “compiles” to “runs on real hardware.” The three steps depend on each other in sequence—without a reproducible wheel tag, GPU backend validation could only stop at source builds; and AMD backend validation in turn exposed several issues in the release chain that only appear on the self-hosted riscv64 runner.

2.1.1 The Tag Itself Is the Entire Content of the Release Action

Date: 2026-11-06, 11-09 Source: release/20261108-6895885, PR #101

release/20261108-6895885 points to commit 6895885, the merge commit of the 11-06 “add missing riscv64 codegen library for AMD” (#102), the same point as nightly nightly/20261106-6895885. The three commits that day (#105, #106, #107) all landed after the tag and did not make it into this package—meaning the first official release actually packages last weekend’s code state.

Two supporting changes to the release chain had already landed earlier in the window: #101 fixed two release-chain issues exposed after #100 (the release workflow now uses the same checkout action version as CI, and scripts/release.sh adds a backend registration step so that wheels produced by release carry the same plugin registration info as wheels built by CI); #102 makes setup.sh build the AMD codegen library locally and place it at the agreed path when it detects it is missing, with env.sh pointing TRITON_AMD_CODEGEN_PATH at it. The nightly additionally adds a unique version suffix .dev<date>, because previously every build shared Triton’s own version number and the package index would reject duplicate versions.

2.1.2 Install Path Switched to Wheel-First, Quick Start Now Looks at Disassembly

Date: 2026-11-09 Source: PR #105, PR #107

#105 rewrote the README install section: first the wheel path and the package index hosting it, then the required LLVM archive and the variable pointing to it; the source path is compressed into make setup (create .venv, clone the pinned Triton, download the pinned LLVM and buddy build), and the previous “create virtualenv, install dependencies, fifteen environment-script variables” instructions are condensed into a short note. #107 then made a correction: the package index does not yet have triton and buddy tools, so the address given for the binary install in the README would fail; it was changed to point at the two projects’ respective GitHub releases and install wheels from disk. The same commit also fixed a lit crash under Python 3.14—Triton uses which to find lit in PATH, and the copy of lit in the LLVM tree calls main at module level; Python 3.14 defaults to the forkserver start method on Linux, which crashes on re-import; the fix is to put the build interpreter’s bin directory first in PATH.

2.2 triton-riscv’s Heterogeneous Path: RISC-V Host Driving AMD Cards

Date: 2026-11-10 Source: PR #110 enable GPU backend by default, README

After #110 merged, this repo’s positioning expanded from “running Triton only on the vector units of RISC-V CPUs” to “driving heterogeneous accelerators from a RISC-V host.” Of the three changes, the build side builds and packages the riscv64 AMD codegen library using the existing Buddy LLVM SDK; the driver side fixes the ambiguity when choosing between CPU and GPU, with the rule being to prefer an available GPU (a net deletion of four lines in that file); the documentation side adds an AMD GPU section to the README, explaining that the backend activates itself via torch.version.hip when ROCm is present, that the wheel does not bundle the ROCm runtime, and that forcing a fallback to CPU uses TRITON_DEFAULT_BACKEND=triton_shared.

Real-hardware validation is what gives this change its weight: SG2044 with an RX 7900 XTX, with torch and ROCm from openRuyi’s software repository, plus a test of automatic fallback when the GPU device is hidden. At a time when no mainstream AI accelerator card ships a RISC-V host driver, supporting AMD cards first is the most realistic step—ROCm’s RISC-V-side work is already maintained in the openRuyi repo, and the same group of people is pushing both.

The timing gap is worth noting: the nightly nightly/2026-11-10-209274f published at 10:22 that day predates this merge, so that package does not yet include the GPU backend.

2.3 Release Chain and Artifacts: Three CI Fixes, Wheels 40% Lighter, Explicit Targets Switched to -O3

Date: 2026-11-11 to 11-12 Source: PR #113 shared git auth, PR #116 wheel slimming, PR #117 -O3 and +zvfbfmin

All three merges on 11-11 were in the release chain; none changed compiler functionality. #113 extracted the “one-off global git config” that CI and release.sh each duplicated into a shared scripts/_git-auth.sh: anonymous git traffic on the self-hosted riscv64 runner cannot obtain authentication, so when upstream FetchContent pulls googletest it returns 401 and hangs at the username prompt with no tty. #111 fixes the release script itself; #112 is documentation, removing the torch install command no longer needed on the CPU path after #110, and adding to the AMD section that “torch must be installed, and it must be a build that can use the AMD GPU.” All three were by the same author, concentrated between 17:59 and 21:11.

The two open changes on 11-12 both target the artifacts themselves. #116 noted that the LLVM and buddy tools packed into the wheel previously used --strip-unneeded, leaving debug sections intact: triton-shared-opt alone carried nine .debug sections and was 407 MB; switching to --strip-all reduced it to 118 MB, and the total payload of the seven tools dropped from about 970 MB to about 576 MB, roughly 60% of the original size. #117 changes the optimization level of the cross-compilation path: when an explicit RISC-V target triple is given, the build previously skipped the LLVM middle end and llc used the default optimization level, so loops that MLIR left in scalar form remained scalar in the object file; the change runs opt -O3 and llc -O3 first for such builds, while the native path without a triple (llc -O0) and the IME path are untouched. The same commit also adds +zvfbfmin to the default llc features—otherwise scalable bf16 aborts directly in llc, and buddy-mlir’s #1054 assumes the extension is present by default, so the two must stay in sync. These two were still open in the 11-13 report, and #117 merged to main at 15:19 on 11-14.

2.4 pytorch: riscv Branch Adds CI Criteria, main Continues Upstream Sync

Date: 2026-11-13 Source: PR #56 riscv64 CI criteria, riscv branch commit list

#56 merged at 00:25 on 11-13, changing only one file, .github/workflows/ci-riscv64.yml (16 lines added, 7 removed). The trigger was that on community CI, PytorchCi’s 39th build showed “build succeeded, CI job failed, parent job still recorded as passed,” one case of which was failed being 0 and pass also being 0 in the statistics. The change adds two criteria: a non-zero Jenkins return code fails the step directly; and PASSED being 0 in the statistics also counts as failure, with only PASSED greater than 0 and FAILED equal to 0 counting as a pass. For a branch that runs nightly packages every day, this is more worth noting than a feature change—if the green mark allows zero test cases to pass, regressions become invisible.

The previous batch of commits was the SyncBots integration at 23:23 on 11-10 (#51 local riscv64 image, #44 float and complex fixes for bytes_to_scalar, #50 masking torchinductor’s opinfo cases, #42 ULP tolerance for linear cross entropy). When re-checking on a 168-hour basis, note: this fork’s default branch is riscv, and the repo-level Atom feed reflects upstream sync commits on main (over a hundred this week, all by PyTorch MergeBot, with zero matches when filtered by the keywords riscv, rvv, XuanTie, rv64); actual activity on the riscv branch is as described in the previous paragraph.

2.5 tilelang-riscv and llvm-project: Zero Commits All Week

Date: 2026-11-09 to 11-13 (status) Source: tilelang-riscv commit list, llvm-project commit list

tilelang-riscv’s main branch head commit is stuck at 11-03 06:13 UTC, llvm-project’s main is stuck at 11-02 14:48, and the riscv branch is still stuck at the 11-04 BOSCAME commit; both repos had no commits and no releases all week. All of the RuyiAI stack’s incremental progress this week came from triton-riscv and buddy-mlir.


III. RuyiSDK Toolchain and Distributions

3.1 ruyi 0.54.0: Turning “Can It Be Installed” into a Computable Fact

Date: 2026-11-10 Source: ruyi 0.54.0, PR #507 ELF ABI compatibility

The feature surface of 0.54.0 is exactly the full content of the 11-02 pre-release 0.54.0-beta.20261102; the official release adds only one version-number commit over the pre-release, totaling seventy-one commits and seventy-four files since 0.53.0. The core is ELF ABI compatibility: whether a precompiled binary can run on a target device depends on a set of facts scattered across the ELF file header—which dynamic libraries it needs, which symbol versions it requests from those libraries, and architecture-specific capability requirements. Previously nothing in the software source recorded these; ruyi now scans them out, stores them, and compares them before installation.

The RISC-V path is the most labor-intensive to collect, because its extensions are concatenated as versioned strings: this period’s commits include parsing versioned single-letter extensions, filtering ld.so.cache entries by host floating-point ABI, and factoring in stack alignment requirements. Host-side probing for x86-64 and AArch64 is also implemented; host libraries are resolved by the requested soname, and an unresolvable soname reports “undetermined” rather than a hard failure—this three-state design separates “cannot install” from “don’t know.” The data plane goes through the repository-side ABI sidecar, resolved by distfile name; rescan-package-abi and plugin artifacts gain strip-components to handle archives with leading directories; the sidecar has a size cap, and a bad sidecar is discarded as “no ABI information.”

3.2 Ruyi Imager: 1.1.0 Released, Followed by a Nearly Thousand-Line Local Image Identification Commit

Date: 2026-11-10, 11-13 Source: Ruyi Imager 1.1.0, local image identification commit

1.1.0 was released on 11-10 at 15:46, with four items in the release notes, all from the same new contributor: a download action added to the image selection step (the standalone image pre-download button mentioned in the biweekly progress), CLI output following the console character set while JSON remains UTF-8, double-click confirmation in the selection dialog, and the dialog requiring an explicit selection before continuing. The biweekly progress also records one item not in the release notes: added SpacemiT K3 flashing support; the two are not contradictory—K3 support may be provided on the image manifest side rather than the code side, so this item should be read against both accounts.

On 11-13 at 02:22, a commit with 978 lines added and 78 deleted landed, titled “identify and prepare local images using catalog metadata.” The change spans GUI and SDK: MainWindow gains an entry point, Chinese and English i18n each get new strings, and the SDK side adds ImageCatalogService, LocalImageMatcher, LocalImageMatch, DistfileIntegrity, and coordination with RuyiDistfileDownloader, plus a JavaFX smoke test. Judging from the file composition, this matches existing local image files against catalog entries by metadata and performs integrity verification on downloads—the flashing tool previously relied more on users picking the right file themselves.

3.3 packages-index and the Board Support Matrix

Date: 2026-11-11 (issue 080 scope) Source: Biweekly progress issue 080, packages-index commit list

Neither the package manager nor the package index repository had commits this week; the official version remains 0.54.0, and the biweekly progress already states the next version is due at the end of November. Index-side progress is recorded in issue 080: packages-index added GNU toolchain adaptation for SpacemiT K1/K3 and supplemented ABI compatibility information for some packages; the board support matrix added Chinese and English reports for Milk-V Jupiter2 with Bianbu 4.0.1 and SpacemiT K3 Pico-ITX with Bianbu 4.0.8 LXQt, and updated the VisionFive 2 Lite Ubuntu 24.04.5 report; the examples repository added Chinese examples for HiFive Premier P550 Dhrystone and the SiFive Kernel Library, a llama-server deployment example for Jupiter2, and extended the K3 ROS 2 course entry to chapters 11 through 15 (scan matching, SLAM, and localization).

3.4 openRuyi Packaging: Dual Kernel Lines, glibc 2.44, and KDE Plasma 6.8.2

Date: 2026-11-08 to 11-12 Source: openRuyi commit list, KDE Plasma 6.8.2, glibc 2.44

The two kernel lines each advanced one step this week: the rolling line linux went from 7.3.3 to 7.3.4, and the long-term line linux-lts from 6.18.62 to 6.18.63, each step refreshing the patchset and config. Kernel version bumps in openRuyi usually come with a config re-check—RISC-V platform peripheral, power management, and filesystem options are maintained inside %ifarch riscv64 conditional blocks, so the config refresh is more noteworthy than the version number itself; 11-12 also had two wrap-up commits changing only the patchset and config (2 lines each).

The host-side catch-up is equally evident: glibc was bumped to 2.44 and the full test suite run on x86_64, and rpm-config-openruyi gained x86_64 architecture macros and tune configuration. For a distribution targeting riscv64 exclusively, these two together mean the build system is catching up on the host side—cross-building, running tests on x86 machines, and native bootstrapping on x86 all require rpm to recognize this architecture.

The desktop stack is the largest batch this week: on 11-09 KDE Plasma 6.8.2 was upgraded wholesale, with forty packages following the same day, from kwin, plasma-workspace, and plasma-desktop to breeze, discover, powerdevil, kinfocenter, and kscreenlocker, then to libraries like libplasma, libksysguard, and libkscreen, as well as supporting pieces such as layer-shell-qt, kwayland6, kpipewire, and knighttime. Wayland-related items advanced together in the same window: wayland 1.26.0, wayland-protocols 1.50, plasma-wayland-protocols 1.23.0, and wlroots 0.20.2. For a RISC-V distribution, a wholesale desktop stack upgrade is one of the scenarios most likely to expose architecture problems, and such batches usually don’t come out all green on the first try.

3.5 Security and Toolchain: Seven Python Commits, Eight OpenTelemetry Packages, llvm23 23.1.5

Date: 2026-11-09 to 11-12 Source: openRuyi commit list

Among the batch of commits on 11-09, seven are marked as security fixes: urllib3 bumped to 2.8.0 (fixing three CVEs), tornado to 6.6 (three CVEs and two GHSAs), pymongo to 4.19.0 (four CVEs), dnspython to 2.9.1, websockets to 17.4, trio to 0.35.0, and aioquic to 1.7.2 (six GHSAs). What these share is the networking and async stack—HTTP clients, DNS, WebSocket, QUIC, async runtimes; they are not desktop components, yet they determine whether containers, CI, and cloud-native toolchains can run securely on riscv64.

Among the thirty-six commits on 11-11 alone, the largest cluster is OpenTelemetry: eight packages bumped to 1.45.2 (exporter-otlp and its three sub-packages grpc/http/proto-common, proto, api, sdk), semantic-conventions to 0.66b2, plus two new packages, exporter-otlp-common and exporter-http-transport; the observability stack previously had only a few scattered packages, and this fills it out to cover common OTLP combinations. The second cluster is four Python authentication packages, all marked with security fixes: pyjwt 2.15.1, oauthlib 4.0.1, joserfc 1.8.0, and authlib 1.9.3.

On the toolchain side, llvm23 was bumped to 23.1.5, and it and the daily snapshot package clang-wrap each follow their own track—the latter tracks up to 20261111, the third consecutive day following upstream snapshots, meaning the compiler downstream receives changes every week; these two packages are the foundation of the self-hosting compilation chain on RISC-V and also the source of the LLVM archive that triton-riscv depends on at build time. One more commit deserves separate mention: the Python bindings of the llvm22, llvm23, and llvm24 packages now use textual substitution to point clang’s bindings at a versioned libclang—in a distribution where multiple LLVM versions coexist, if the bindings point at an unversioned name, installing a second version will overwrite the first.

3.6 Devices and Peripherals: Three OpenCL Packages, the fwupd Chain, qemu-rustsbi

Date: 2026-11-11 to 11-12 Source: gcab package addition, OVMF FMP capsule patch, fu740 recovery flow

On 11-11 three OpenCL packages were added: opencl-headers, opencl-icd-loader, and clinfo. For RISC-V desktops and AI acceleration this is a long-missing piece—triton-riscv drives AMD cards via ROCm on RISC-V hosts, and ROCm and OpenCL share the ICD loading mechanism, so third-party implementations can only be plugged in once icd-loader is in place. The same batch also added fwupd, giving device firmware updates a standard entry point; 11-12 added two more pieces: the gcab package (fwupd’s tool for handling cab-format firmware archives) and OVMF’s 2000-OvmfPkg-RiscVVirt-Use-FMP-Capsule-as-cab-payload-for.patch (making the RiscVVirt platform use FMP capsule as the cab payload).

On the Rust side, five dependencies were added at once plus qemu-rustsbi: rust-memchr 2.7.6 and rust-libc 0.2.185 are new, rust-hashbrown was bumped to 0.17.1, plus rustc-literal-escaper 0.0.7 and clap-verbosity-flag 3. The appearance of qemu-rustsbi indicates that the RustSBI RISC-V firmware line has entered the QEMU rehearsal stage in the packaging repository. The ruyi branch of ruyifirmware also has a “fu740: Support recovery with OpenOCD 0.12” commit—the recovery flow is one of the hardest parts of a firmware repository to get right; when the OpenOCD version changes, the scripts and configuration must change with it.

3.7 Release Governance: the release Specification Repository, ruyi-deck, and the Missing Monthly Version

Date: 2026-11-09 to 11-13 Source: release specification repository, ruyi-deck, openRuyi distribution news page

openRuyi-Project created the release repository on 11-04, and on 11-09 the same person pushed eight consecutive commits turning the management rules for distribution requirements into documentation: requirement numbering rules, writing principles, scope division (computation and verification), issue priorities, plus bilingual Chinese-English issue templates and per-item standard documents. This repository holds no code, only rules—for a distribution released monthly, pinning down “what counts as a requirement, how it is numbered, and how priority is set” is the prerequisite for turning judgments scattered across issues and meetings into a reviewable process; on 11-10 another commit unified the writing style of requirement entries and stack naming, since naming drift is harder to clean up than code errors in a cross-institutional project.

On 11-11 the ruyi-deck repository was added, described as “The Operations Deck for openRuyi Repositories and Releases,” licensed MulanPSL-2.0, with only a single Init repo commit in the window and a README containing just one title line. The name and positioning indicate it is meant to be an operations console for repositories and releases—a monthly version must be released across the packaging, image, and firmware repositories, and what’s missing is exactly such a unified entry point; the repository has no code yet, so this issue records only its existence.

The gap remains in releasing itself: the two latest posts on the news page are both from 10-19, the monthly version entry is still 2026.09 from 09-30, and the tag remains at 2026.09-experimental. Rolling packaging and monthly finalization are two separate lines by nature, but the externally visible “version” has not been updated for a month.


IV. Vector Extensions and Operator Optimization

4.1 The three vector repos remain silent; all vector-side progress is in VIR

Date: 2026-11-09 to 11-13 (status) Source: FBGEMM, VecIntrinBench, IntrinTrans

The three repos VecIntrinBench, IntrinTrans, and FBGEMM saw zero commits all week, with head commits stalled at 02-13, 06-25, and 07-13 respectively—silence that has now persisted for months. This does not mean there is no vector-side progress: this week’s vector changes all occurred at the VIR layer of buddy-mlir, and they fall into two categories—one determining “whether something can enter a vector loop” (coverage), the other determining “whether the vector loop is fully utilized” (performance). Investment is concentrated in the compiler rather than in measurement tooling, and this division of labor has remained unchanged since September.

4.2 i1 masks read/written byte-wise (#1052)

Date: 2026-11-12 Source: PR #1052

When the memref element type is i1, scalable vectors were previously rejected outright (with the message a memref of i1 needs fixed vectors), because a memref occupies one byte per element while an i1 vector occupies one lane per bit—only fixed-length vectors have a per-lane lowering. Triton’s load/store masks happen to be exactly i1 memrefs: when going through the pure VIR pipeline with scalable vectors, 179 of the 325 Triton-RISCV test files got stuck on this error, making this the most broadly impactful of the week’s seven patches.

The fix is to read/write byte-wise: contiguous accesses use llvm.load/store of i8 vectors, while non-contiguous strip-mined regions use vp.strided.load/store with all lanes enabled; incidentally, i1 lanes are now sized as one byte—previously a region whose first dynamic vector was i1 was counted as 1 bit, which under VLEN 256 would yield a size like vector<[512]xi1>, i.e. sixteen register groups.

4.3 Per-lane expansion of libm-only math functions (#1053)

Date: 2026-11-12 Source: PR #1053

Math functions that LLVM refuses to lower on scalable vectors (erf, erfc, cbrt, powf, atan2, acosh, etc.) are now expanded per lane: for vector<[N]xT>, each of the N times vscale lanes is extracted one by one, the scalar function is called, and the result is inserted back. The trigger was that convert-math-to-libm handled scalable vectors the same as fixed-length vectors, computing only the first N and silently zeroing the rest—a scalable erf under VLEN 128 (vscale 2) had half its lanes wrong. The effect shows directly in the test surface: on the FlagGems suite of 4045 items on SG2044 (VLEN 128), the number passing rose from 3980 to 4006; the 26 fixed items are test_erf and test_gelu, with no new failures.

4.4 The two bf16 paths and exhaustive verification (#1054)

Date: 2026-11-12 Source: PR #1054

RVV places bf16 in vector registers only with Zvfbfmin; without that extension, LLVM refuses to lower even a single load. The change adds an rvv-mattr parameter to the lowering, defaulting to assuming Zvfbfmin is present (Buddy’s several RVV targets—K3’s X100 and A100, and SG2044—all have it); when -zvfbfmin is given explicitly, it instead treats values as integer bits, reading/writing bf16 vectors as i16, using integer operations for extf and truncf (truncf rounding to nearest-even), and routing absf and negf through the sign bit.

The verification method is the heaviest part of the week: truncf covers all 2^32 f32 values, while extf, absf, negf, and extf-mulf-truncf cover all 2^16 bf16 values, compared bit-for-bit against the Zvfbfmin path on both the SG2044 and K3 cores, with identical results. This level of verification cost shows that bf16 is being treated as a shipping path rather than an “optimization for when there’s time.”

4.5 fast-math flags and all reduction kinds (#1055, #1056)

Date: 2026-11-12 Source: PR #1055, PR #1056

#1055 fixes fast-math flags being dropped in the strip-mined lowering: an arith.mulf plus arith.addf carrying contract was rebuilt as plain fmul and fadd, which LLVM would not fuse. Now the flags propagate with the same-kind operators into the vector loop and the tail, so f32 multiply-add can emit vfmacc, and bf16 under +zvfbfwma emits vfwmaccbf16; the author compared the fmaf expansion bit-for-bit over 4M lanes on K3’s X100 and A100, with matching results. This is the only one of the seven patches that directly changes instruction selection.

#1056 expands vir.reduce from recognizing only floating-point add and maxnum to all kinds of vector.reduction: add, mul, minsi, minui, maxsi, maxui, and, or, xor, minnumf, maxnumf, minimumf, maximumf, with integers supported as well, and a verifier checking that kind and element type match. Previously Triton’s integer sum, min/max, product, and all/any (along with the argmin, argmax, count_nonzero, bitonic sort, and radix sort that depend on them) all remained in loops. The change adds 570 lines across 9 files.

4.6 Wrapping up residual paths: rank-0 fill and integer matmul (#1057, #1058)

Date: 2026-11-12 Source: PR #1057, PR #1058

#1057 lowers linalg.fill on rank-0 memrefs (mostly reduction accumulators) to a single memref.store, reducing residual linalg.fill in the 1811 FlagGems kernels from 393 to 0. #1058 enables integer matmul to lower as well: when A and B are the same integer type and no wider than C, sign- or zero-extend first and then multiply-add (without fma); on RVV, int8 matmul yields vsext.vf2 plus vwmacc.vx, and unsigned yields vzext.vf2 plus vwmaccu.vx; the same patch also fixes an assertion failure in dynamic-shape matmul—M and K were originally taken inside the vir.set_vl region and erased while still in use by a later pass. After the change, no linalg.matmul remains among the 1811 kernels.

Together, the two patches provide a verifiable coverage metric: not a benchmark score, but “how many linalg or scalar paths remain.”


V. Buddy Compiler Updates

5.1 The First Half of VLEN Exactness: #1032 and #1037

Date: 2026-11-08 Source: PR #1032, PR #1037

The problem #1032 addresses is a class of failure that fails the wrong way: no error, just wrong results. A RISC-V model built for an exact VLEN has vector code that is valid only for that one VLEN—llc is explicitly told the VLEN (+zvlNb and -riscv-v-vector-bits-max), and the scalable vectors in decode attention are sized accordingly. On a different VLEN, the model does not crash; it simply produces wrong results.

The fix moves validation forward to load time: runtime/rvv/BuddyRvvVlen.c is linked into the model library as a constructor; as soon as the library is loaded it reads vlenb, and if it does not match the exact VLEN used at build time, it prints a message and terminates the process with _exit(1). Using _exit rather than exit is deliberate—running destructors while the loader holds its lock would deadlock. A follow-up change after review moved the check from “judging by build variables” to “judging by the final llc options”: previously a native build could specify the VLEN via the model’s own LLC_ATTRS, and if BUDDY_RISCV_VLEN disagreed with it, the checked value would not match the actual code; moreover, the check was only linked into the third stage, missing Qwen3-VL’s vision and decode shims as well as the layered-linking paths. Now the build script extracts the exact VLEN from the final llc options (reading the same place as VIR lowering), and conflicting options fail outright at configure time. Testing is the other half of this change: test_buddy_rvv_vlen.py builds the model library for each VLEN from 128 to 65536; only the host’s own can load, and all others exit with code 1. The docs were updated in step, with the two DeepSeek-R1 deployment notes for A210 and K3 spelling out the boundary between “which builds are exact-VLEN” and “which are generic RVV”—A210’s kernels are fixed-length vectors with no VIR, so it is a generic build; K3’s prefill_ime requires 1024, so it is exact-VLEN.

#1037 fixes an error in the other direction: -lower-vir-to-vector, when neither rvv-vlen is given nor scalable vectors are enabled, sizes fixed-length vectors by the host register width, but its host detection covers only x86 (AVX2, AVX-512) and SVE; a RISC-V host with the V extension always falls through to the generic default (128 bits, 16 registers). The consequence showed up in tests: since #1030, the kernels pipeline lowers VIR by host when no llc options are given, and the riscv64 CI host is VLEN 256 but was treated as 128-bit, so the squared q and k norms were split into vector<32xf32> partial sums, differing in order from the bit-for-bit comparison against the vector kernels, and vir decode qk_norm ... same bits evaluated to false. The author first added a change that pinned rvv-vlen=1024 use-scalable=false in tests only, then reverted it—that would have created a second place to set VLEN outside the llc options, conflicting with the direction of #1032. The final fix detects a RISC-V host in the lowering stage (reading host CPU features and hwprobe) and sizes by the real VLEN.

5.2 f32 YOLOv8 Runs End-to-End Through VIR (#1041)

Date: 2026-11-09 (merged 11-10 01:07) Source: PR #1041, merge commit 18c66ec

#1041 takes the f32 YOLOv8 graph end-to-end through VIR: first Linalg-to-VIR lowering, then VIR-to-vector-dialect lowering. Previously this pass had no convolution pattern, and three other operator classes in the graph failed outright—one change adds both the convolution and those three. The scale: fourteen files, 1,646 lines added, 115 removed, thirteen commits.

Both convolution families are covered: 2D NHWC with HWCF and 2D NHWC with FHWC. Vectorization is along the output channel F; for each (kh, kw, c) the input element is broadcast into one vir.fma per output pixel, so every vector access is contiguous and there is no cross-lane reduction—reductions need horizontal instructions and a subsequent reduction tree, which is costly at narrow VLEN; the price is that the FHWC filter must first be copied in parallel into an HWCF buffer, trading one extra transfer for contiguous access in the inner loop.

The three previously failing operator classes are filled in as well: rank-0 inputs (memref<f32> fed directly into linalg.generic reports invalid reassociation at memref.expand_shape; changed to load once and broadcast), linalg.reduce preserving the last dimension (e.g. DFL softmax’s 1x16x4x2100, dimensions=[1], addf combined with maximumf), and named ops reading linalg.index (e.g. linalg.map iota in upsample). The on-device numbers are clear: on K3, f32 YOLOv8 pose’s raw output changes by at most 6e-5, and the gap to PyTorch remains within 6e-4 (bus) and 8e-4 (zidane), unchanged from before; the detect model’s detections are unchanged and speed does not drop; f32 and IME dynamic library outputs are byte-for-byte identical to before.

5.3 YOLOv8 Enters rax: Detection and Pose on the K3 Matrix Engine (#1042)

Date: 2026-11-10 Source: PR #1042

#1042 wires Ultralytics YOLOv8 into buddy-cli’s rax format: yolov8n detection (eighty COCO classes) and yolov8n-pose (seventeen keypoints), both with 320x320 input. The f32 model goes through VIR lowering; if the spec says ime: true, it runs on the SpacemiT K3 matrix engine instead.

The two fixes added during review are more informative than the model itself. First, weight validation: the manifest carries params_size, and the runner requires the weight file to match it; previously a short weight file let the model read past the buffer. The runner is also required to accept only rax packages, because when the library and weights are supplied separately the pose model would be run with the detection model’s parameters. Second, TCM copies: the TCM copy of IME weights is cached by weight address, so new weights read into a freed buffer would hit the stale copy; now the kernel-side invalidation function is called after every weight load. The spec keeps both params_size and ime_params_size, so the f32 version can still be built with ime: false—one graph, two backend paths, one comparable baseline.

5.4 The AME/BOSCAME Line: The Review Queue After SPM

Date: 2026-11-08 to 11-12 Source: PR #1038, PR #1035, triton-riscv PR #104

After #1033 merged at the end of last week (BOSCAME backend gains SPM optimization; 209 files, over 46,000 lines added), three more are still under review on the AME line this week: adding descriptor offsets to AME tile addressing, a new Linalg-to-XTAME matmul-family lowering, and XtameBench (a benchmark evaluating AME matmul lowering by instruction count); plus #1035, a llama-bench-style RAX model benchmark. Taken together, AME is moving from “it runs” to “it’s correct and comparable.”

triton-riscv’s #104 echoes this line: merged 11-12 17:40, it wires the BOSCAME FPGA SPM path into triton-riscv (AOT contract export, lit and integration tests, kernel, launch and makefile under examples/BOSCAMEFPGA), and the first line of buddy-hash.txt pins the buddy-mlir commit that landed SPM, keeping the example and compiler versions in sync.

5.5 Nightly Cadence: Six-Day Gap Filled, Packages Cut Before the Day’s Merges

Date: 2026-11-11 to 11-14 Source: buddy-mlir Release list, PR #1059

The nightly had been stuck at 0.1.4.dev20261105. 0.1.4.dev20261111 shipped on 11-11, closing the six-day gap; 0.1.4.dev20261112 shipped at 10:33 on 11-12, and by merge time it could only include that day’s first change, #1052, with the six after it waiting for the next package; then 2026-11-13-72176d5 shipped at 00:25 on 11-14. The official release is still BUDDY MLIR 0.1.3 from 10-31.

The two open PRs point the same way: #1059 changes whole-block copies from memrefCopy to vector reads and writes, reducing the last few non-vector paths; #1049 handles set_vl grouping into four registers when the vectors exceed eight register groups. Downstream has already pinned the nightly into dependencies—triton-riscv’s #115 writes 0.1.4.dev20261112, and #117 adds +zvfbfmin to the default llc features; the two are the two ends of the same thing as upstream #1054: the compiler assumes by default that the hardware has the extension, and the runtime’s llc option string must keep up, or scalable bf16 aborts at kernel compile time. This “default assumption—parameter sync” coupling is exactly what fork-style downstreams most easily miss.


VI. Community, Events, and Official Website

6.1 Biweekly Progress Issue 080 Published to Forum

Date: 2026-11-11 Source: Issue 080 (Community Forum), Issue 080 draft

Issue 080 was posted to the RuyiSDK community forum on 11-11 at 17:53, six days after the in-repo draft of 11-05. This issue closes out the “triple tool release”: package manager 0.54.0, Ruyi Imager 1.1.0, and VS Code extension 0.1.7 are all named together. Note the framing: 0.54.0 and Imager 1.1.0 are official releases within this week’s window, but the extension’s 0.1.7 is actually the 09-28 version, with 0.1.8-beta.1 (10-30) already out since; per the draft’s framing it is carried over, and should not be treated as a new version.

The testing framing is also given in this issue: 0.54.0-beta.20261102 and extension v0.1.7 were judged to meet the exit criteria; on the toolchain side, CI is not yet run on Python 3.15 pending pygit2 adaptation to Python 3.15 — the only explicit deferral this issue; the next version is set for late November. Compiler-side content is covered in “This Week’s Highlights,” with one item worth noting separately: RISE-CI has connected container services with GitHub Actions, added multilib build-scenario checks, and plans to integrate LLM-based evaluation of CI errors; performance benchmarking is moving toward SPEC CPU 2026, starting with environment and resource assessment, and a memory shortfall has been identified for running the full SPECspeed 2026 on K3.

6.2 Forum: Three Posts on 11-11, Routine Hot-Topic Post on 11-12

Date: 2026-11-11, 11-12 Source: RuyiSDK Community Latest Topics, 11-12 hot-topic post

The forum added four new topics this week. 11-11 saw three posts: Issue 080 at 17:53, a repost at 12:29, and a “2026-11-11 Open-Source Tech Hot News Roundup” at 11:50. The repost’s title claims Alibaba plans to spin off T-Head for an independent Hong Kong listing; it is a repost and unverified. The roundup post is the daily routine industry-news aggregation. Another similar hot-topic post appeared on 11-12; biweekly progress remains at Issue 080 with Issue 081 not yet out; the Ruyi Imager beta-test thread received one reply on 11-11, part of ongoing Q&A. The forum’s substantive content remains concentrated on the biweekly-progress thread.

6.3 Front Page of China Science Daily: Institutional Background of the Ruyi Community and the Kernel Same-Source Initiative

Date: 2026-11-10 Source: China Science Daily report

On 11-10, the front page of China Science Daily ran a ten-year retrospective on the Institute of Software’s RISC-V foundational software team. Several verifiable facts are worth recording: the Ruyi community was founded in November 2024; as of the end of 2025, code contributed by industry partners such as Alibaba and ZTE under the “RISC-V kernel same-source” initiative exceeded half of the total; and the RVA23 releases published by openEuler and openKylin all adopt the results of this same-source kernel work. The article also mentions that the software migration tool follows a “neuro-symbolic fusion” path (program analysis and formal verification as the foundation, LLMs for efficiency, and engineers’ experience distilled into rules and a knowledge base to set boundaries), already deployed in communities such as openEuler; and that a master’s student added a RISC-V backend and vector instruction optimizations to OpenCV, merged into the official mainline.

The “open-source AI compiler project for RISC-V” mentioned in the article is buddy-mlir, whose VIR commits largely come from this team. This report provides the organizational background of this stack: the Ruyi community, the kernel same-source work, the compiler, and the migration tool all come from the same team; the changes scattered across different repos in the daily briefs are, at the institutional level, one and the same line.

6.4 Official Website: Three Pages Unchanged, Two Blog Posts, Twenty-Three Documentation Chapters

Date: 2026-11-09 to 11-13 (status) Source: RuyiAI official website, blog page

The hashes of the index, blog, and docs pages on www.ruyiai.org were identical all week to the previous inspection. The blog still has two posts (Triton’s RISC-V adaptation, PyTorch RISC-V CI practices), and the documentation index has twenty-three chapters. This week’s batch of VIR changes and the triton-riscv GPU backend and release-chain changes have no corresponding articles on the site — on a weekly basis, the official site’s update cadence is clearly slower than the code repos, which can be recorded as a “content-side gap.”

6.5 ruyiai-daily Gap of Five Days

Date: 2026-11-13 (status) Source: ruyiai-daily commit list

The last commit in the daily-intelligence repo RuyiAI-Stack/ruyiai-daily remains 11-08 06:21 (Beijing time); five issues from 11-09 to 11-13 were not generated. The repo previously produced one issue per day; this is the longest gap since this publication began using daily-brief materials, and for those who rely on it for secondary distribution, only this publication’s daily briefs are available this week.

6.6 External News and arXiv: Zero Hits All Week

Date: 2026-11-09 to 11-13 (status) Source: Google News, arXiv RISC-V search

Targeted queries in six groups — RuyiAI, RuyiSDK, Ruyi community, Ruyi RISC-V, openRuyi, buddy-mlir, triton riscv — in both Chinese and English returned zero hits all week, surfacing only old articles from months ago; the latest arXiv RISC-V vector search result stops at an 11-09 MCU delegated-protection paper, with no new papers in the window. General RISC-V crawls returned mostly teaching-oriented pipeline implementations and personal CPU repos, unrelated to the Ruyi community. The openRuyi distribution news page still shows the two posts from 2026-10 as latest, with the 2026.11 monthly release not yet published. The only substantive output from this channel this week is the China Science Daily report in 6.3.


VII. Trend Observations

7.1 Release chain before features: this week’s work was “can we ship a package at all”

Among the merges into triton-riscv this week, only #110 (AMD backend) is a feature; the rest — #101, #102, #105, #107, #111, #112, #113 — are all on the release chain: registering the backend into the wheel, local builds of the AMD codegen library, wheel-first in the README, lit lookup order, git auth extraction, and the torch prerequisite for the AMD section. Add #116’s wheel slimming and #117’s -O3, and this repo’s output for the week can be summed up as “making the install path reproducible, downloadable, and verifiable.”

This is not an isolated phenomenon: the main content of ruyi 0.54.0 is likewise “check whether it can be installed before installing,” pytorch’s #56 plugs “zero test cases passing also counts as green,” and buddy-mlir’s nightly fills a six-day packaging gap. Four repos doing the same kind of work in the same week shows that this stack has moved from “proving it runs” to “proving it can be delivered.”

7.2 Coverage before performance: the 393→0, 2→0, 179→0 framing

Of buddy-mlir’s seven patches this week, only #1055 directly changes instruction selection; the other six bring forms previously left in loops into the vector path: i1 masks, libm-only math functions, bf16, reduction kinds, rank-0 fill, and integer matmul. The right yardstick for this kind of change is “how many linalg or scalar paths remain,” not benchmarks — 393 down to 0, 2 down to 0, 179 failing files to zero, all under this framing.

Contrast this with the previous day’s #1050, which narrows the strip-mined remainder. The division of labor across the two days is clear: first let the vector loop fill its lanes (performance), then let every operator enter the vector loop (coverage). Reversing the order wastes effort — a full-width loop with only the same few operators inside it.

7.3 VLEN 1024 becomes a shared pressure point for compiler and runtime

Three changes this week point directly at VLEN 1024: load-time validation (#1032), reduction lane loss (#1051), and the strip-mined remainder (#1050). What they share is the same hardware fact recurring at every layer — K3’s prefill_ime must be 1024, 16 f32 on the A100 core is one full vector, and a shape like vector<[1]xT> simply cannot be reached at VLEN 128/256.

The same signal appeared upstream in the same week: V8’s review list shows “Allow vlen=1024” (CL8585179). This shows that long vectors are no longer just a local configuration for one board, but are beginning to enter the general paths of runtimes and browsers. The risk follows — CI’s riscv64 runner is VLEN 256 while shipping hardware is 1024, so the two are inherently misaligned in test coverage; a defect like #1051, “all green in CI, all wrong on the board,” is exactly the product of that misalignment.

7.4 The verification cost of silent wrong values has reached the scale of exhaustive inputs

#1054 ran all 2^32 f32 values through truncf and all 2^16 bf16 values through conversions and sign operations; #1055 compared the fmaf expansion bit by bit across 4M lanes; #1041’s acceptance criterion was “byte-for-byte identical to before the change”; #1051’s acceptance criterion was 25 reduction tests going from wrong to right. The four use different verification methods, but all answer the same question: is the result correct, not is it fast.

The reason is clear: the defects fixed this week are almost all “no error, just wrong results” — a model built for an exact VLEN silently misbehaves on different hardware, scalable erf has half its lanes zeroed, reductions keep only lane 0, and mask-based size computation yields sixteen register groups. Crashes are easy to spot; wrong values are not. When verification cost rises to the scale of exhaustive inputs, it means this stack now treats foundational operators like bf16 and reductions to shipping standards.

7.5 Rolling packaging decouples from monthly releases

The openRuyi packaging repo saw its highest commit density in recent memory this week (a single-day peak of thirty-six commits, with KDE, security, toolchain, and device-facing work all advancing in parallel), while the externally visible monthly release remains at 2026.09. The two are not contradictory: rolling packaging and monthly releases are two separate tracks; daily updates show the engineering is moving, and the missing release shows the release process or verification cycle is stuck.

Worth noting are the two new governance repos this week: the release spec repo writes requirement numbering and priority into process, and ruyi-deck is positioned as an “operations console for repos and releases.” Neither produces code, yet both point at the same gap — a monthly release must ship across the packaging repo, images, and firmware, and what is missing is not commits but the step that converges commits into a releasable version.

7.6 “Can it be installed” becomes a computable fact for the first time

ruyi 0.54.0 turns ELF ABI compatibility into a three-state determination (compatible, incompatible, undetermined) and exposes it in three places: list, install, and admin check-abi. The significance is not the feature itself but turning “can this package run on my machine” from a judgment call into data that can be queried, compared, and troubleshot.

This matters especially for RISC-V: the same prebuilt binary behaves differently on hosts with different extension combinations and different floating-point ABIs, and in the past the only option was trial and error. The three-state design also leaves room for “undetermined,” avoiding treating the unknown as incompatible — that distinction determines whether the tool is usable in real environments. The next thing to watch is sidecar coverage: which packages have ABI information added and which still have “no information.” The packages-index mentioned in issue 080 adding ABI compatibility information for some packages is a continuation of this line.


Appendix: Sources and Verification Notes

Sources: Five issues of the RuyiAI daily report from 2026-11-09 to 2026-11-13, each covering the window from 04:30 the previous day to 04:30 that day (11-09 covers the past three days, 11-07 to 11-09). The weekly report introduces no new facts beyond the dailies, with two period-boundary additions: the buddy-mlir nightly at 11-14 00:25 and triton-riscv #117 merged at 11-14 15:19, both timestamped in the body.

Verification scope: 168-hour repo verification across four organizations — RuyiAI-Stack, ruyisdk, buddy-compiler, openRuyi-Project (covering 11-07 08:00 to 11-14 08:00 UTC); commit-by-commit review of the main openRuyi repo; dual-source verification via the RuyiSDK developer community (forum, biweekly progress) and the openRuyi distro news page; snapshots of the RuyiAI official homepage index, blog, and docs pages plus the blog and documentation indexes; six targeted Google News queries and an arXiv RISC-V search.

Notes on methodology: First, the pytorch repo’s default branch is riscv; the repo-level Atom feed reflects upstream sync commits on main, and this week’s hundred-plus commits were all PyTorch MergeBot syncs with zero after filtering by RISC-V keywords, so the body only credits actual activity on the riscv branch. Second, Ruyi Imager 1.1.0’s K3 flashing support appears only in the biweekly progress, not in the Release notes, so the body gives both framings. Third, the VS Code extension 0.1.7 named in issue 080 is in fact the 09-28 version, and the body notes it should not be treated as a new version this week. Fourth, this week’s six external news queries and arXiv search returned zero hits; the only substantive report was the front-page piece in China Science Daily on 11-10, listed separately.

Source Verification Table

Source Verification result
RuyiAI-Stack key repos triton-riscv: one merge (#110), one tagged release (release/20261108-6895885), five nightlies, three release-chain merges (#111, #112, #113), and three open PRs (#116, #117, #109); pytorch riscv branch: one merge (#56) and a batch of SyncBots syncs; tilelang-riscv and llvm-project: zero commits
ruyisdk org ruyi 0.54.0 officially released, zero follow-up commits in the window; ruyi-imager 1.1.0 released plus one 978-line commit; packages-index: zero commits (K1/K3 toolchain adaptation recorded in issue 080)
buddy-compiler buddy-mlir: thirteen merges (#1032, #1037, #1041, #1042, #1050 to #1058) and three nightlies; two open PRs (#1059, #1049); official release still 0.1.3
openRuyi-Project Packaging repo: over a hundred commits this week (one version each on the two kernel lines, glibc 2.44, forty packages for KDE Plasma 6.8.2, eight OpenTelemetry packages, three OpenCL packages, the fwupd chain, llvm23 23.1.5); ruyifirmware: five commits (including the 20261107 and 20261108 releases and the fu740 recovery flow); release spec repo: eight commits; ruyi-deck initialized
RuyiSDK forum 11-11: three posts (issue 080, a repost, and a hot-topics roundup); 11-12: the routine hot-topics post; biweekly progress still at issue 080, issue 081 not yet out
RuyiAI official homepage index, blog, and docs pages unchanged all week; 2 blog posts, 23 documentation chapters
ruyiai-daily Stopped at 11-08; the five issues from 11-09 to 11-13 were not generated
openRuyi distro news page Latest is still the two posts from 2026-10; the 2026.11 monthly release has not shipped
Google News Six targeted Chinese and English queries returned zero hits all week
arXiv No new papers in the window; latest stops at 11-09

Full Source List