@@ -0,0 +1,47 @@
+# 通过 GitHub OIDC「可信发布」把包发到 npm —— 全程不需要任何长效 token。
+#
+# 前置（仅此一次，由仓库拥有者在 npm 网页完成，不传 token）：
+#   1. 登录 npmjs.com → 进入包 moxwebgpu → Settings → Trusted Publishers
+#   2. Add Publisher：
+#        - Publisher: GitHub Actions
+#        - Repository: codecloud-dev/moxwebgpu
+#        - Workflow name: publish.yml
+#        - Environment: （留空）
+#   3. 保存。
+# 配置好后，本流程在推送 `v*` tag 时自动 `pnpm publish --provenance`，
+# npm 会用 GitHub 临时签发的 OIDC 令牌完成发布（带 provenance 溯源）。
+# 若未配置就推了 tag：本流程会失败（无害），去网页配置后「Re-run」该次运行即可。
+
+name: Publish to npm (OIDC)
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  id-token: write   # 供 npm OIDC 签发临时令牌
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+
+      - name: Install
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm build
+
+      - name: Publish (provenance, no token)
+        run: pnpm publish --provenance --no-git-checks --access public
@@ -157,9 +157,9 @@ WebGPU 的 compute pipeline 能力极强,但裸用它做一次向量加法,你
 
 ## 安装
 
-> ⚠️ **npm / CDN 尚未发布**:`moxwebgpu` 目前还没有发布到 npm,下方「方式一(CDN)」「方式二(npm)」的 `unpkg` 与 `npm install` **暂不可用**(在线会 404)。请先走「方式三:从源码构建」,或直接在浏览器体验[在线演示](#浏览器演示)。发布后本节会更新。
+> ✅ **已发布到 npm**:`moxwebgpu@1.0.0` 已可在 npm 安装,CDN 走 unpkg 即可。本节的「方式一」「方式二」现已可用;发布通过 GitHub OIDC 可信发布完成,无需任何长效 token(见仓库 `.github/workflows/publish.yml`)。
 
-### 方式一:浏览器 `<script>`(零构建,即将发布)
+### 方式一:浏览器 `<script>`(零构建)
 
 ```html
 <script src="https://unpkg.com/moxwebgpu/dist/moxwebgpu.browser.js"></script>
@@ -171,7 +171,7 @@ WebGPU 的 compute pipeline 能力极强,但裸用它做一次向量加法,你
 
 IIFE 产物暴露全局 `MoxWebGPU`,内含 `mox`、`MoxContext`、`Tensor`、`Kernel` 等全部导出。
 
-### 方式二:npm(Node / 打包器,即将发布)
+### 方式二:npm(Node / 打包器)
 
 ```bash
 npm install moxwebgpu
@@ -312,6 +312,43 @@ t.destroy();      // 单个张量释放(通常不需要,池会自动回收中间
 
 ---
 
+### 10. 自动微分（反向模式 / 训练）
+
+moxwebgpu 1.0 起内置**反向模式自动微分**,直接叠加在现有惰性计算图上——`OpDef` 只是纯元数据 + codegen,每个算子附带一个 `backward`,反向图天然复用同一套算子,只有当你读取梯度时才上 GPU。
+
+```ts
+import { mox } from 'moxwebgpu';
+
+const gpu = await mox.init();
+const x = gpu.tensor([1, 2, 3, 4]).withGrad();   // 标记可微叶子
+const loss = x.mul(x).sum();                       // L = Σ x²
+
+loss.backward();                                   // 反向传播
+console.log(await x.grad.toArray());               // [2, 4, 6, 8] = dL/dx
+```
+
+三个要点:
+
+- **`.withGrad()`**:标记该叶子张量需要梯度(其余叶子默认不计)。
+- **`.backward()`**:从标量 loss 出发,逆拓扑序传播,把梯度填进每个 `requiresGrad` 叶子的 **`.grad`**。整个过程只建惰性图,**不碰 GPU**,直到你 `await x.grad.toArray()`。
+- **广播正确**:二元算子的梯度会用 `sumTo` 自动归约回较小操作数的形状;`sum/mean/softmax` 的梯度用 `expand` 复制回去。
+
+```ts
+// 一个最小线性层的前向 + 反向
+const W = gpu.tensor([[0.1, 0.2], [0.3, 0.4]]).withGrad();
+const inp = gpu.tensor([1, 1]);
+const pred = W.matmul(inp);          // [2]
+const loss = pred.mul(pred).sum();   // Σ pred²
+loss.backward();
+console.log(await W.grad.toArray());  // dL/dW,形状与 W 一致
+```
+
+**已支持反向的算子**:加/减/乘/除(含标量、含广播)、neg/abs/exp/log/sqrt/square/relu/sigmoid/tanh、matmul、sum/mean(全局与任意轴)、softmax(沿末轴,数值稳定)。
+
+> 路线图中 layernorm / embedding / conv1d、pass 融合、Web Worker 运行属于 **1.0.x 后续规划**,本版未做——给后续更新留空间。
+
+---
+
 ## 统一 API 参考
 
 ### `mox.init(options?)` → `Promise<MoxContext>`
@@ -603,11 +640,11 @@ moxwebgpu/
 
 - [x] **v0.1** —— 三层架构、30+ 算子、27 个真实 GPU e2e、液态玻璃演示
 - [x] **v0.2** —— 任意轴归约(任意 rank/负轴)、整型归约修复、调度器 temp 回收加固
-- [ ] 自动微分(反向图叠加在现有 lazy graph 上)
-- [ ] 更多 NN 算子:layernorm / embedding / conv1d
-- [ ] 相邻逐元素算子的 pass 融合(进一步压 dispatch 次数)
-- [ ] Web Worker / OffscreenCanvas 内运行
-- [ ] npm 首次发布(即将发布)
+- [x] **v1.0** —— 反向模式自动微分(叠加在现有 lazy graph 上)、matmul/softmax/sum/mean 反向、OIDC 免 token 发布到 npm
+- [ ] 更多 NN 算子:layernorm / embedding / conv1d(规划中,1.0.x)
+- [ ] 相邻逐元素算子的 pass 融合(进一步压 dispatch 次数,规划中)
+- [ ] Web Worker / OffscreenCanvas 内运行(规划中)
+- [x] npm 首次发布
 - [x] 文档站上线
 
 > 有想要的功能或方向,欢迎提 Issue 一起讨论。
@@ -626,7 +663,7 @@ A:99% 是 WGSL 编译失败(静默 no-op)。moxwebgpu 已把编译错误打印
 A:它们是「模型中心」:面向推理预置模型。moxwebgpu 是「算子中心」:给你 NumPy 式的原始计算能力 + 逃生舱,恰好可以作为它们没有的那层「通用 GPGPU 地基」。
 
 **Q:支持训练(反向传播)吗?**  
-A:暂不支持,自动微分在路线图第一位(现有 lazy graph 天然适合叠加反向图)。
+A:支持。1.0.0 起内置反向模式自动微分:对叶子张量调 `.withGrad()`,正向建图后调 `.backward()`,梯度即填到 `.grad`(惰性,需要时才上 GPU)。详见[自动微分](#10-自动微分反向模式--训练)。
 
 **Q:为什么我的机器跑 `pnpm test:gpu` 也能过?我没有 N 卡。**  
 A:因为 SwiftShader——Chrome 自带的纯软件 Vulkan 实现。moxwebgpu 的 GPU 测试配方**不要求真显卡**,CI 上也一样。
 
@@ -1,7 +1,7 @@
 {
   "name": "moxwebgpu",
-  "version": "0.2.0",
-  "description": "⚡ A WebGPU compute (GPGPU) framework — typed tensors, raw kernels and a lazy compute graph, in one tiny package.",
+  "version": "1.0.0",
+  "description": "⚡ A WebGPU compute (GPGPU) framework — typed tensors, raw kernels and a lazy compute graph, with reverse-mode autodiff, in one tiny package.",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -15,8 +15,13 @@
     "./browser": "./dist/moxwebgpu.browser.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsup",
     "test": "vitest run --config vitest.config.ts",
 
@@ -0,0 +1,108 @@
+/**
+ * Reverse-mode automatic differentiation.
+ *
+ * The gradient graph is built lazily on top of the existing lazy DAG: every
+ * `BackwardFn` returns new lazy Tensors via the normal op set, so no GPU work
+ * happens until a gradient is materialized with `.toArray()` / `.toBuffer()`.
+ *
+ * `backward(loss)` fills `.grad` on every leaf Tensor whose `requiresGrad` is
+ * true. The loss is treated as a scalar (seed = 1); pass a pre-reduced scalar
+ * loss for the usual "dL/dparams" semantics.
+ */
+
+import { Tensor } from '../tensor/tensor.js';
+import type { MoxContext } from '../core/context.js';
+import type { LazyNode } from './lazy.js';
+import { numElements } from '../core/dtype.js';
+
+/** Reverse topological order (parents before children); does not mutate state. */
+function reverseTopo(root: LazyNode): LazyNode[] {
+  const order: LazyNode[] = [];
+  const seen = new Set<LazyNode>();
+  const visit = (n: LazyNode): void => {
+    if (seen.has(n)) return;
+    seen.add(n);
+    for (const inp of n.inputs) {
+      if (inp.kind !== 'leaf') visit(inp);
+    }
+    order.push(n);
+  };
+  visit(root);
+  return order;
+}
+
+/** A lazy ones-tensor shaped like `t` (no GPU upload until materialized). */
+function onesLike(t: Tensor): Tensor {
+  return t.toFloat().mul(0).add(1);
+}
+
+/**
+ * Reduce `t` to `shape` by summing out broadcasted / leading dimensions.
+ * Used to push a gradient back to a smaller broadcast operand's shape.
+ */
+export function sumTo(t: Tensor, shape: number[]): Tensor {
+  let cur = t;
+  let curShape = cur.shape;
+  while (curShape.length > shape.length) {
+    cur = cur.sum(0);
+    curShape = cur.shape;
+  }
+  const outShape: number[] = [];
+  for (let d = 0; d < shape.length; d++) {
+    if (curShape[d] !== shape[d]) {
+      cur = cur.sum(d);
+      curShape = cur.shape;
+      outShape.push(1);
+    } else {
+      outShape.push(curShape[d]);
+    }
+  }
+  return cur.reshape(...outShape);
+}
+
+function wrap(node: LazyNode, ctx: MoxContext): Tensor {
+  return new Tensor(ctx, node.shape, node.dtype, node, null);
+}
+
+export function backward(loss: Tensor): void {
+  const root = loss.node;
+  if (!root) return; // leaf loss: nothing to differentiate
+
+  const order = reverseTopo(root);
+  const gradOf = new Map<object, Tensor>();
+  gradOf.set(root, onesLike(loss));
+
+  for (let i = order.length - 1; i >= 0; i--) {
+    const node = order[i];
+    const g = gradOf.get(node);
+    if (!g) continue;
+
+    const inputs: Tensor[] = node.inputs.map((inp) => {
+      if (inp.kind === 'leaf') return inp.tensor as Tensor;
+      return wrap(inp as LazyNode, loss.ctx);
+    });
+    const output = wrap(node, loss.ctx);
+
+    const fn = node.op.backward;
+    const grads: (Tensor | null)[] = fn ? fn(inputs, output, g, node.attrs) : inputs.map(() => null);
+
+    for (let j = 0; j < node.inputs.length; j++) {
+      const gi = grads[j];
+      if (!gi) continue;
+      let target: object;
+      if (node.inputs[j].kind === 'leaf') {
+        target = (node.inputs[j] as { kind: 'leaf'; tensor: Tensor }).tensor;
+      } else {
+        target = node.inputs[j] as LazyNode;
+      }
+      const prev = gradOf.get(target);
+      gradOf.set(target, prev ? prev.add(gi) : gi);
+    }
+  }
+
+  for (const [key, g] of gradOf) {
+    if (key instanceof Tensor && key.requiresGrad) {
+      key.grad = g;
+    }
+  }
+}
@@ -9,6 +9,23 @@
 
 import type { DType } from '../core/dtype.js';
 import type { GpuDataBuffer } from '../core/buffer.js';
+import type { Tensor } from '../tensor/tensor.js';
+
+/**
+ * Reverse-mode gradient of an op.
+ *  - `inputs`  : the original input Tensors (leaves or node-backed), in order
+ *  - `output`  : a Tensor view of this node's output
+ *  - `gradOutput`: upstream gradient w.r.t. this node's output
+ *  - returns one gradient Tensor (or null) per input, matching input order.
+ * Gradients are themselves lazy tensors, so the whole backward graph reuses
+ * the existing op set and only touches the GPU when materialized.
+ */
+export type BackwardFn = (
+  inputs: Tensor[],
+  output: Tensor,
+  gradOutput: Tensor,
+  attrs: any,
+) => (Tensor | null)[];
 
 /**
  * One GPU compute pass inside an op's execution plan.
@@ -58,6 +75,8 @@ export interface OpDef {
   outDtype?: (inputDtypes: DType[], attrs: any) => DType;
   /** Build the GPU execution plan for this node. */
   build: (inputShapes: number[][], inputDtypes: DType[], attrs: any) => OpPlan;
+  /** Optional reverse-mode gradient (see BackwardFn). Absent = no gradient. */
+  backward?: BackwardFn;
 }
 
 /** A downstream reference: either another lazy node or a leaf tensor. */
 
@@ -22,19 +22,25 @@ export {
 
 // ---- tensor ----
 export { Tensor, type TensorLike, type TensorOptions } from './tensor/tensor.js';
-export type { OpDef, KernelStep, LazyNode, OpPlan, BindingSpec } from './graph/lazy.js';
+export type { OpDef, KernelStep, LazyNode, OpPlan, BindingSpec, BackwardFn } from './graph/lazy.js';
 export { createNode, topoSort } from './graph/lazy.js';
 export { Scheduler } from './graph/scheduler.js';
 export { PipelineCache } from './graph/pipelineCache.js';
 
+// ---- autograd ----
+export { backward, sumTo } from './graph/autograd.js';
+
 // ---- codegen (for building custom ops) ----
 export * from './tensor/codegen.js';
 
 // ---- version ----
-export const MOXWEBGPU_VERSION = '0.2.0';
+export const MOXWEBGPU_VERSION = '1.0.0';
 
 import { Tensor } from './tensor/tensor.js';
 import { installTensorOps } from './tensor/ops/index.js';
+import { installBackward } from './tensor/ops/backward.js';
 
 // Install the unified chainable op API (add/matmul/sum/softmax/...) once.
 installTensorOps(Tensor.prototype);
+// Attach reverse-mode gradients to the built-in ops.
+installBackward();