update(docs): Updated README.

Author: lcy-seso

README.md

@@ -11,44 +11,34 @@
   </p>
 </div>
 
-TileRT is an experimental project that explores core compiler techniques designed to serve large language models in ultra-low-latency scenarios. Unlike existing inference systems built for high-throughput batch processing, TileRT focuses on delivering extreme responsiveness—critical for applications such as high-frequency trading, interactive AI, real-time decision-making, long-running agents, and AI coding, where users care more about the latency of a few requests or even a single request.
+## News
 
-The goal of the TileRT project is to push the latency boundaries of LLMs without compromising model size or quality—for example, enabling models with hundreds of billions of parameters to run at millisecond-level TPOT.
+- **\[2025/12\]** ⚡ **v0.1.1 released** — end-to-end token generation speed significantly reduced (~35%) on a single node with 8× NVIDIA B200, improving from ~170 to ~230 tokens/s under ultra-low-latency settings.
+- **\[2025/11\]** 🚀 TileRT initial release for DeepSeek-V3.2-Exp, designed for **ultra-low-latency** inference (available on [PyPI](https://pypi.org/project/tilert) and [HuggingFace](https://huggingface.co/Tile-AI/DeepSeek-V3.2-Exp-TileRT)).
+
+## About
+
+TileRT is an experimental project exploring core compiler techniques for serving large language models (LLMs) in **ultra-low-latency** scenarios. Its goal is to push the latency limits of LLMs without compromising model size or quality—for example, enabling models with hundreds of billions of parameters to achieve millisecond-level **time per output token (TPOT)**.
 
 <p align="center">
 <img src="assets/generate.gif" alt="TileRT Benchmark"><br>
 Fig. Sequence generation using SGLang (left), vLLM (middle), and TileRT (right) with the DeepSeek-V3.2-Exp model.
 </p>
 
-TileRT addresses these challenges with a new tile-level runtime engine. It uses a compiler-driven approach to decompose LLM operators into fine-grained tile-level tasks, and a tile-level runtime that reschedules compute, I/O, and communication across multiple devices in a highly overlapped manner. This allows TileRT to minimize idle time and maximize hardware utilization. These compiler techniques will be incorporated into TileLang and TileScale.
-
-We evaluated TileRT’s preliminary performance using the DeepSeek-V3.2-Exp model (without lossy optimizations such as quantization or distillation) with a batch size of 1 on 8× NVIDIA B200 GPUs. As shown in the benchmark below, TileRT significantly outperforms existing inference systems:
+We evaluated TileRT’s preliminary performance using the **DeepSeek-V3.2-Exp** model (without lossy optimizations such as quantization or distillation) with a batch size of 1 on 8× NVIDIA B200 GPUs. As shown in the benchmark below, TileRT demonstrates substantial improvements over existing inference systems.
 
 <p align="center">
 <img src="assets/perf.png" alt="TileRT Benchmark" width="400"><br>
 Fig. Evaluation setup: batch size: 1, input seqlen/output seqlen: 1K/1K, SGLang-0.5.5, vLLM-0.11.0, CUDA-12.9
 </p>
 
-TileRT is a continuously evolving project. Our ongoing plans include pursuing more aggressive optimizations, supporting various batch sizes, more model families and more hardware, and establishing a new foundation for low-latency AI inference. Stay tuned for updates!
-
-- [Installation](#installation)
-  - [Prerequisites](#prerequisites)
-    - [**Hardware**](#hardware)
-    - [**Operating System**](#operating-system)
-    - [**Python**](#python)
-    - [**PyTorch Build**](#pytorch-build)
-  - [Python Package Installation](#python-package-installation)
-    - [Docker Installation](#docker-installation)
-- [Getting Started](#getting-started)
-  - [Download Pre-Converted Weights from HuggingFace](#download-pre-converted-weights-from-huggingface)
-    - [Option 1: Using `huggingface-cli` (recommended)](#option-1-using-huggingface-cli-recommended)
-    - [Option 2: Using Git + Git LFS](#option-2-using-git--git-lfs)
-  - [Running the Generation Example](#running-the-generation-example)
-- [Status & Future Work](#status--future-work)
+Unlike traditional inference systems optimized for high-throughput batch processing, TileRT prioritizes **responsiveness**, which is critical for applications such as high-frequency trading, interactive AI, real-time decision-making, long-running agents, and AI-assisted coding, where the latency of individual requests matters most.
 
-## Installation
+To achieve this, TileRT introduces a **tile-level runtime engine**. Leveraging a compiler-driven approach, LLM operators are decomposed into fine-grained tile-level tasks, while the runtime dynamically reschedules computation, I/O, and communication across multiple devices in a highly overlapped manner. This design minimizes idle time and improves hardware utilization.
+
+The project is actively evolving, and the underlying compiler techniques will be gradually shared with the community as they are integrated into **TileLang** and **TileScale**.
 
-### Prerequisites
+## Installation
 
 Before installing the TileRT wheel package, please ensure your environment meets the following requirements: