This is an automated email from the ASF dual-hosted git repository.
tqchen pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tvm-tirx.git
The following commit(s) were added to refs/heads/main by this push:
new 7c19669ce [DOCS] Concise README, native Rust layout note, and
.asf.yaml homepage (#161)
7c19669ce is described below
commit 7c19669ce1b5161fc112429fbf7cb76102da29f1
Author: Tianqi Chen <[email protected]>
AuthorDate: Mon Nov 2 10:18:37 2026 -0500
[DOCS] Concise README, native Rust layout note, and .asf.yaml homepage
(#161)
Replace the title-only README with a concise overview of TVM TIRx: links
to the documentation and Quick Start, a one-sentence introduction, the
feature list, and links to the main documentation sections. The ASF
license header is kept.
In the Rust guide (Objects and Managed References), note that `AddObj`
has the same memory layout as its C++ counterpart, so `add.a` is a
direct field read, as efficient as in C++.
Update `.asf.yaml`: the GitHub homepage now points to
https://tvm.apache.org/tirx and the description reads "Open ML Compiler
Foundation for the Agentic Era".
---
.asf.yaml | 4 ++--
README.md | 23 ++++++++++++++++++++++-
docs/ir_guides/working_with_ir_in_rust.rst | 2 ++
3 files changed, 26 insertions(+), 3 deletions(-)
diff --git a/.asf.yaml b/.asf.yaml
index 7d542d90a..c0e67f6e3 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -16,8 +16,8 @@
# under the License.
github:
- description: "Open ML Compiler Foundation"
- homepage: https://tvm.apache.org/
+ description: "Open ML Compiler Foundation for the Agentic Era"
+ homepage: https://tvm.apache.org/tirx
labels:
- compiler
- tirx
diff --git a/README.md b/README.md
index 719439f64..04f2fdaf5 100644
--- a/README.md
+++ b/README.md
@@ -15,4 +15,25 @@
<!--- specific language governing permissions and limitations -->
<!--- under the License. -->
-# TVM TIRx
+# TVM TIRx: Open ML Compiler Foundation for the Agentic Era
+
+📚 [Documentation](https://tvm.apache.org/tirx/) | 🚀 [Quick
Start](https://tvm.apache.org/tirx/get_started/quick_start.html)
+
+Apache TVM TIRx is a minimal, open ML compiler foundation for the agentic era.
+
+## Features
+
+- **Minimal, stable core IR** - a small, stable set of core AST nodes,
designed for common needs and for extension.
+- **Predictable utilities** - TVM-FFI bridge generation, symbolic integer
analysis, structural traversal and mapping, and minimal code generation for
CUDA and host LLVM.
+- **Dynamic extension by design** - all compiler APIs are open, so developers
and agents can iterate quickly on extensions in separate packages that link to
TIRx dynamically, without rebuilding one monolithic bundle.
+- **First-class cross-language support** - Python, C++, and native Rust.
Prototype an analysis or extension in Python, then bake it into Rust or C++;
extensions work across all supported languages.
+- **Built on stable toolchains** - a minimal layer for ML compilation needs
that connects to stable compiler toolchains and leverages their backend
capabilities when possible.
+
+## Documentation
+
+Check out the [documentation site](https://tvm.apache.org/tirx/) for the full
documentation, including:
+
+- [Quick Start](https://tvm.apache.org/tirx/get_started/quick_start.html)
+- [IR Guides](https://tvm.apache.org/tirx/ir_guides/overview.html)
+- [Programming
Guides](https://tvm.apache.org/tirx/programming_guides/index.html)
+- [Extending
TIRx](https://tvm.apache.org/tirx/advanced/extending_ir_in_rust.html)
diff --git a/docs/ir_guides/working_with_ir_in_rust.rst
b/docs/ir_guides/working_with_ir_in_rust.rst
index fbba2c262..4f6bcc3d8 100644
--- a/docs/ir_guides/working_with_ir_in_rust.rst
+++ b/docs/ir_guides/working_with_ir_in_rust.rst
@@ -207,6 +207,8 @@ This is the newtype pattern. Simplified from the crate, the
pair is:
Rust has no inheritance; instead, ``#[repr(C)]`` puts the parent's object,
``ExprObj``, first in ``AddObj``, so every addition is also an expression.
``Add`` implements ``Deref`` to ``AddObj``, which is why ``add.a`` works.
+``AddObj`` has the same memory layout as its C++ counterpart, so
+``add.a`` is a direct field read, as efficient as in C++.
**Nodes are immutable.** As with data behind an ``Arc``, a managed
reference gives read access only; to change a node, we build a new one.
