diff --git a/docs/start/framework/react/build-from-scratch.md b/docs/start/framework/react/build-from-scratch.md
index f3090d7f30..689997015b 100644
--- a/docs/start/framework/react/build-from-scratch.md
+++ b/docs/start/framework/react/build-from-scratch.md
@@ -49,33 +49,39 @@ We highly recommend using TypeScript with TanStack Start. Create a `tsconfig.jso
 
 ## Install Dependencies
 
-TanStack Start is powered by [Vite](https://vite.dev/) and [TanStack Router](https://tanstack.com/router) and requires them as dependencies.
+TanStack Start is powered by [TanStack Router](https://tanstack.com/router) and supports [Vite](https://vite.dev/) or [Rsbuild](https://rsbuild.dev/) as the bundler.
 
-To install them, run:
+To install Start and Router, run:
 
 ```shell
 npm i @tanstack/react-start @tanstack/react-router
 ```
 
-We also need vite as a devDependency:
+You'll also need React:
 
 ```shell
-npm i -D vite
+npm i react react-dom
 ```
 
-You'll also need React:
+Install the bundler and React integration you want to use:
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```shell
-npm i react react-dom
+npm i -D vite @vitejs/plugin-react
 ```
 
-As well as React's Vite plugin:
+# Rsbuild
 
 ```shell
-npm i -D @vitejs/plugin-react
+npm i -D @rsbuild/core @rsbuild/plugin-react
 ```
 
-Alternatively, you can also use `@vitejs/plugin-react-swc`.
+<!-- ::end:tabs -->
+
+If you use Vite, you can also use `@vitejs/plugin-react-swc` instead of `@vitejs/plugin-react`.
 
 and some TypeScript:
 
@@ -85,7 +91,11 @@ npm i -D typescript @types/react @types/react-dom @types/node
 
 ## Update Configuration Files
 
-We'll then update our `package.json` to use Vite's CLI and set `"type": "module"`:
+We'll then update our `package.json` to use your bundler's CLI and set `"type": "module"`:
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```json
 {
@@ -98,10 +108,28 @@ We'll then update our `package.json` to use Vite's CLI and set `"type": "module"
 }
 ```
 
-Then configure TanStack Start's Vite plugin in `vite.config.ts`:
+# Rsbuild
+
+```json
+{
+  // ...
+  "type": "module",
+  "scripts": {
+    "dev": "rsbuild dev",
+    "build": "rsbuild build"
+  }
+}
+```
+
+<!-- ::end:tabs -->
+
+Then configure TanStack Start's bundler plugin:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import viteReact from '@vitejs/plugin-react'
@@ -121,6 +149,23 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  server: {
+    port: 3000,
+  },
+  plugins: [pluginReact(), tanstackStart()],
+})
+```
+
+<!-- ::end:tabs -->
+
 ## Add the Basic Templating
 
 There are 2 required files for TanStack Start usage:
@@ -137,7 +182,7 @@ Once configuration is done, we'll have a file tree that looks like the following
 │   │   └── `__root.tsx`
 │   ├── `router.tsx`
 │   ├── `routeTree.gen.ts`
-├── `vite.config.ts`
+├── `vite.config.ts` or `rsbuild.config.ts`
 ├── `package.json`
 └── `tsconfig.json`
 ```
@@ -171,7 +216,6 @@ Finally, we need to create the root of our application. This is the entry point
 
 ```tsx
 // src/routes/__root.tsx
-/// <reference types="vite/client" />
 import type { ReactNode } from 'react'
 import {
   Outlet,
diff --git a/docs/start/framework/react/comparison.md b/docs/start/framework/react/comparison.md
index b28667acce..cc5c8073b9 100644
--- a/docs/start/framework/react/comparison.md
+++ b/docs/start/framework/react/comparison.md
@@ -54,14 +54,14 @@ Feature/Capability Key:
 | Devtools                                                          | ✅                                               | 🛑                                            | 🟠 (3rd party)                             |
 | CLI Tooling                                                       | ✅                                               | ✅                                            | ✅                                         |
 | Dev Server Startup Speed                                          | ✅ (Fast)                                        | 🛑 (Slow)                                     | ✅ (Fast)                                  |
-| HMR Speed                                                         | ✅ (Fast, Vite)                                  | 🛑 (Slow, Webpack/Turbopack)                  | ✅ (Fast, Vite)                            |
+| HMR Speed                                                         | ✅ (Fast, Vite or Rsbuild)                       | 🛑 (Slow, Webpack/Turbopack)                  | ✅ (Fast, Vite)                            |
 | Dev Navigation Speed                                              | ✅                                               | 🟡                                            | ✅                                         |
 | Dev Resource Usage (CPU/RAM)                                      | ✅ (Lightweight)                                 | 🛑 (Heavy)                                    | ✅ (Lightweight)                           |
 | TypeScript Support                                                | ✅                                               | ✅                                            | ✅                                         |
 | Type-First Architecture                                           | ✅                                               | 🛑                                            | 🛑                                         |
 | --                                                                | --                                               | --                                            | --                                         |
 | **Deployment & Hosting**                                          | --                                               | --                                            | --                                         |
-| Deployment Flexibility                                            | ✅ (Any Vite-compatible host)                    | 🟡 (Optimized for Vercel, possible elsewhere) | ✅ (Multiple adapters)                     |
+| Deployment Flexibility                                            | ✅ (Vite and Rsbuild builds)                     | 🟡 (Optimized for Vercel, possible elsewhere) | ✅ (Multiple adapters)                     |
 | Edge Runtime Support                                              | ✅                                               | ✅                                            | ✅                                         |
 | Serverless Support                                                | ✅                                               | ✅                                            | ✅                                         |
 | Node.js Support                                                   | ✅                                               | ✅                                            | ✅                                         |
@@ -84,7 +84,7 @@ Feature/Capability Key:
 **Philosophy**: Maximum developer freedom with best-in-class type safety.
 
 - **Router-First**: Built on TanStack Router (see [full routing comparison][router-comparison])
-- **Deployment Agnostic**: Built on Vite, deploy anywhere without vendor lock-in
+- **Deployment Agnostic**: Built on Vite and Rsbuild integrations, deploy without vendor lock-in
 - **Composable Middleware**: Middleware system works at both the request level AND individual server function level (both client & server)
 - **Selective SSR**: Fine-grained control over SSR behavior per route (full SSR, data-only, or client-only)
 - **Developer Control**: Explicit, composable patterns over convention-based magic
@@ -115,7 +115,7 @@ Feature/Capability Key:
 ### Choose TanStack Start if you:
 
 - Want the absolute best type safety for routing (see [Router Comparison][router-comparison])
-- Need deployment flexibility without vendor lock-in (works with any Vite-compatible host)
+- Need deployment flexibility without vendor lock-in (works with Vite and Rsbuild builds)
 - Prefer composable, explicit patterns over convention
 - Want fine-grained control over SSR behavior (selective SSR per route)
 - Need composable middleware that works at both request and server function levels
@@ -247,7 +247,7 @@ const authMiddleware = createMiddleware({ type: 'function' })
 
 ### Deployment Flexibility
 
-**TanStack Start** leverages Vite's ecosystem:
+**TanStack Start** leverages modern bundler ecosystems:
 
 - Deploy to Cloudflare Workers, Netlify, Vercel, Railway, Fly.io, AWS, etc.
 - Use Nitro for universal deployment support
@@ -276,7 +276,7 @@ TanStack Start's RSC implementation takes a client-led composition approach: ser
 
 All three frameworks are capable of achieving excellent production performance and top Lighthouse scores. The differences come down to optimization strategies:
 
-- **TanStack Start**: Vite's optimized builds, SWR caching reduces server load, lightweight runtime
+- **TanStack Start**: Optimized bundler builds, SWR caching reduces server load, lightweight runtime
 - **Next.js**: Automatic code splitting, image optimization, and built-in performance features
 - **React Router**: Web standards-based caching and optimization
 
diff --git a/docs/start/framework/react/guide/cdn-asset-urls.md b/docs/start/framework/react/guide/cdn-asset-urls.md
index df43906198..28c9c8c030 100644
--- a/docs/start/framework/react/guide/cdn-asset-urls.md
+++ b/docs/start/framework/react/guide/cdn-asset-urls.md
@@ -317,16 +317,21 @@ Warmup has no effect in development mode or when `cache: false`.
 
 > **Note:** In development mode (`TSS_DEV_SERVER`), caching is always skipped regardless of the `cache` setting, so you always get fresh manifests.
 
-## Use Relative Vite Asset Paths for Client Navigation
+## Keep Client Navigation Chunks on the CDN
 
 `transformAssets` rewrites the URLs in the SSR HTML: script preload hints, stylesheet links, and the client entry script. This means the browser's initial page load can fetch those assets from the CDN.
 
-When users navigate client-side, TanStack Router lazy-loads route chunks using `import()` calls with paths baked in by the bundler. With Vite's default `base: '/'`, those paths are absolute, such as `/assets/about-abc123.js`, and resolve against the app server origin instead of the CDN.
+When users navigate client-side, TanStack Router lazy-loads route chunks using `import()` calls with paths baked in by the bundler. Configure your bundler so those async chunk URLs resolve relative to the client entry script that `transformAssets` rewrites to the CDN.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+With Vite's default `base: '/'`, lazy route chunk paths are absolute, such as `/assets/about-abc123.js`, and resolve against the app server origin instead of the CDN.
 
 For Vite builds, set `base: ''` so Vite generates relative import paths for client-side chunks.
 
-```ts
-// vite.config.ts
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 
 export default defineConfig({
@@ -346,6 +351,25 @@ Using an empty string rather than `'./'` is important. Both produce relative cli
 
 Use `base: ''` whenever you use `transformAssets` with Vite and want initial-load assets and client-navigation chunks served from the same CDN.
 
+# Rsbuild
+
+For Rsbuild builds, set `output.assetPrefix` to `'auto'` so Rspack derives async chunk URLs from the loaded client entry script.
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+
+export default defineConfig({
+  output: {
+    assetPrefix: 'auto',
+  },
+  // ... plugins, etc.
+})
+```
+
+With `assetPrefix: 'auto'`, the client entry script can be loaded from the CDN by `transformAssets`, and async route chunks resolve relative to that entry script during client-side navigation.
+
+<!-- ::end:tabs -->
+
 ## What This Does Not Rewrite
 
 `transformAssets` rewrites Start manifest-managed assets and, when CSS URL templates are enabled, URLs inside CSS that Start inlines into the HTML.
@@ -368,7 +392,7 @@ If this stylesheet must use a CDN URL, use a bundler-level option or build-time
 `transformAssets` also does not rewrite asset URLs imported directly in your components:
 
 ```tsx
-// This import resolves to a URL at build time by Vite.
+// This import resolves to a URL at build time by your bundler.
 import logo from './logo.svg'
 
 function Header() {
@@ -376,10 +400,15 @@ function Header() {
 }
 ```
 
-For these asset imports in Vite builds, use Vite's `experimental.renderBuiltUrl` in your `vite.config.ts`.
+For these asset imports, use the URL controls provided by your bundler.
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+For Vite builds, use Vite's `experimental.renderBuiltUrl` in your `vite.config.ts`.
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 
 export default defineConfig({
@@ -394,3 +423,19 @@ export default defineConfig({
   },
 })
 ```
+
+# Rsbuild
+
+For Rsbuild builds where the CDN origin is known at build time, use `output.assetPrefix` in your `rsbuild.config.ts`.
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+
+export default defineConfig({
+  output: {
+    assetPrefix: 'https://cdn.example.com/',
+  },
+})
+```
+
+<!-- ::end:tabs -->
diff --git a/docs/start/framework/react/guide/css-styling.md b/docs/start/framework/react/guide/css-styling.md
index 1a92ecad10..e44b5fb29c 100644
--- a/docs/start/framework/react/guide/css-styling.md
+++ b/docs/start/framework/react/guide/css-styling.md
@@ -125,8 +125,11 @@ CSS inlining embeds Start manifest-managed route CSS directly into the server-re
 
 Enable it with `server.build.inlineCss` in the Start plugin options. Passing `true` is shorthand for `{ enabled: true, transformAssets: false }`.
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
@@ -143,6 +146,27 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      server: {
+        build: {
+          inlineCss: true,
+        },
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 This option only affects production builds. Development mode keeps using Start's normal development CSS handling.
 
 CSS inlining applies to CSS discovered from side-effect imports and CSS modules, because those stylesheets are Start manifest assets. It does not inline CSS imported with `?url` and returned from `head().links`, because those links are dynamic route head output rather than manifest-managed stylesheet assets.
diff --git a/docs/start/framework/react/guide/environment-variables.md b/docs/start/framework/react/guide/environment-variables.md
index 944f3965e5..c5ee8b57bc 100644
--- a/docs/start/framework/react/guide/environment-variables.md
+++ b/docs/start/framework/react/guide/environment-variables.md
@@ -9,7 +9,11 @@ Learn how to securely configure and use environment variables in your TanStack S
 
 ## Quick Start
 
-TanStack Start automatically loads `.env` files and makes variables available in both server and client contexts with proper security boundaries.
+TanStack Start automatically loads `.env` files and makes variables available in both server and client contexts with proper security boundaries. Server code can read unprefixed variables from `process.env`; client code can only read variables exposed by your bundler's public prefix.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```bash
 # .env
@@ -30,6 +34,29 @@ export function AppHeader() {
 }
 ```
 
+# Rsbuild
+
+```bash
+# .env
+DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
+PUBLIC_APP_NAME=My TanStack Start App
+```
+
+```typescript
+// Server function - can access any environment variable
+const getUser = createServerFn().handler(async () => {
+  const db = await connect(process.env.DATABASE_URL) // ✅ Server-only
+  return db.user.findFirst()
+})
+
+// Client component - only PUBLIC_ prefixed variables by default
+export function AppHeader() {
+  return <h1>{import.meta.env.PUBLIC_APP_NAME}</h1> // ✅ Client-safe
+}
+```
+
+<!-- ::end:tabs -->
+
 ## Environment Variable Contexts
 
 ### Server-Side Context (Server Functions & API Routes)
@@ -59,7 +86,13 @@ const authenticateUser = createServerFn()
 
 ### Client-Side Context (Components & Client Code)
 
-Client code can only access variables with the `VITE_` prefix:
+Client code can only access variables with your bundler's public prefix.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+Vite exposes variables with the `VITE_` prefix:
 
 ```typescript
 // Client configuration
@@ -87,6 +120,38 @@ export function FeatureGatedComponent() {
 }
 ```
 
+# Rsbuild
+
+Rsbuild exposes variables with the `PUBLIC_` prefix by default:
+
+```typescript
+// Client configuration
+export function ApiProvider({ children }: { children: React.ReactNode }) {
+  const apiUrl = import.meta.env.PUBLIC_API_URL // ✅ Public
+  const apiKey = import.meta.env.PUBLIC_KEY // ✅ Public
+
+  // This would be undefined (security feature):
+  // const secret = import.meta.env.DATABASE_URL // ❌ Undefined
+
+  return (
+    <ApiContext.Provider value={{ apiUrl, apiKey }}>
+      {children}
+    </ApiContext.Provider>
+  )
+}
+
+// Feature flags
+export function FeatureGatedComponent() {
+  const enableNewFeature = import.meta.env.PUBLIC_ENABLE_NEW_FEATURE === 'true'
+
+  if (!enableNewFeature) return null
+
+  return <NewFeature />
+}
+```
+
+<!-- ::end:tabs -->
+
 ## Environment File Setup
 
 ### File Hierarchy (Loaded in Order)
@@ -105,10 +170,13 @@ TanStack Start automatically loads environment files in this order:
 **.env** (committed to repository):
 
 ```bash
-# Public configuration
+# Public configuration (Vite uses VITE_; Rsbuild uses PUBLIC_ by default)
 VITE_APP_NAME=My TanStack Start App
 VITE_API_URL=https://api.example.com
 VITE_SENTRY_DSN=https://...
+PUBLIC_APP_NAME=My TanStack Start App
+PUBLIC_API_URL=https://api.example.com
+PUBLIC_SENTRY_DSN=https://...
 
 # Server configuration templates
 DATABASE_URL=postgresql://localhost:5432/myapp_dev
@@ -129,6 +197,7 @@ JWT_SECRET=your-local-secret
 ```bash
 # Production overrides
 VITE_API_URL=https://api.myapp.com
+PUBLIC_API_URL=https://api.myapp.com
 DATABASE_POOL_SIZE=20
 ```
 
@@ -240,6 +309,10 @@ export function Dashboard() {
 
 Create `src/env.d.ts` to add type safety:
 
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
 ```typescript
 /// <reference types="vite/client" />
 
@@ -274,6 +347,44 @@ declare global {
 export {}
 ```
 
+# Rsbuild
+
+```typescript
+/// <reference types="@rsbuild/core/types" />
+
+interface ImportMetaEnv {
+  // Client-side environment variables
+  readonly PUBLIC_APP_NAME: string
+  readonly PUBLIC_API_URL: string
+  readonly PUBLIC_AUTH0_DOMAIN: string
+  readonly PUBLIC_AUTH0_CLIENT_ID: string
+  readonly PUBLIC_SENTRY_DSN?: string
+  readonly PUBLIC_ENABLE_NEW_DASHBOARD?: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+
+// Server-side environment variables
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      readonly DATABASE_URL: string
+      readonly REDIS_URL: string
+      readonly JWT_SECRET: string
+      readonly AUTH0_CLIENT_SECRET: string
+      readonly STRIPE_SECRET_KEY: string
+      readonly NODE_ENV: 'development' | 'production' | 'test'
+    }
+  }
+}
+
+export {}
+```
+
+<!-- ::end:tabs -->
+
 ### Runtime Validation
 
 Use Zod for runtime validation of environment variables:
@@ -337,10 +448,13 @@ DATABASE_URL=postgresql://...
 JWT_SECRET=super-secret-key
 STRIPE_SECRET_KEY=sk_live_...
 
-# ✅ Client-safe (VITE_ prefix)
+# ✅ Client-safe (Vite uses VITE_; Rsbuild uses PUBLIC_ by default)
 VITE_APP_NAME=My App
 VITE_API_URL=https://api.example.com
 VITE_SENTRY_DSN=https://...
+PUBLIC_APP_NAME=My App
+PUBLIC_API_URL=https://api.example.com
+PUBLIC_SENTRY_DSN=https://...
 ```
 
 ### 3. Validate Required Variables
@@ -349,7 +463,7 @@ VITE_SENTRY_DSN=https://...
 // src/config/validation.ts
 const requiredServerEnv = ['DATABASE_URL', 'JWT_SECRET'] as const
 
-const requiredClientEnv = ['VITE_APP_NAME', 'VITE_API_URL'] as const
+const requiredClientEnv = ['VITE_APP_NAME', 'VITE_API_URL'] as const // Use PUBLIC_ names for Rsbuild
 
 // Validate on server startup
 for (const key of requiredServerEnv) {
@@ -368,8 +482,8 @@ for (const key of requiredClientEnv) {
 
 ## Production Checklist
 
-- [ ] All sensitive variables are server-only (no `VITE_` prefix)
-- [ ] Client variables use `VITE_` prefix
+- [ ] All sensitive variables are server-only (no `VITE_` or `PUBLIC_` prefix)
+- [ ] Client variables use your bundler's public prefix (`VITE_` for Vite, `PUBLIC_` for Rsbuild)
 - [ ] `.env.local` is in `.gitignore`
 - [ ] Production environment variables are configured on hosting platform
 - [ ] Required environment variables are validated at startup
@@ -385,7 +499,7 @@ for (const key of requiredClientEnv) {
 
 **Solutions**:
 
-1. **Add correct prefix**: Use `VITE_` prefix (e.g. `VITE_MY_VARIABLE`)
+1. **Add correct prefix**: Use your bundler's public prefix (e.g. `VITE_MY_VARIABLE` for Vite or `PUBLIC_MY_VARIABLE` for Rsbuild)
 2. **Restart development server** after adding new variables
 3. **Check file location**: `.env` file must be in project root
 4. **Verify bundler configuration**: Ensure variables are properly injected
@@ -408,7 +522,7 @@ VITE_API_KEY=abc123 npm run build
 
 ### Runtime Client Environment Variables in Production
 
-**Problem**: If `VITE_` variables are replaced at bundle time only, how to make runtime variables available on the client?
+**Problem**: If public client variables are replaced at bundle time only, how to make runtime variables available on the client?
 
 **Solutions**:
 
@@ -416,7 +530,7 @@ Pass variables from the server down to the client:
 
 ```tsx
 const getRuntimeVar = createServerFn({ method: 'GET' }).handler(() => {
-  return process.env.MY_RUNTIME_VAR // notice `process.env` on the server, and no `VITE_` prefix
+  return process.env.MY_RUNTIME_VAR // notice `process.env` on the server, and no public prefix
 })
 
 export const Route = createFileRoute('/')({
@@ -445,13 +559,14 @@ function RouteComponent() {
 
 ### TypeScript Errors
 
-**Problem**: `Property 'VITE_MY_VAR' does not exist on type 'ImportMetaEnv'`
+**Problem**: `Property 'VITE_MY_VAR' does not exist on type 'ImportMetaEnv'` or `Property 'PUBLIC_MY_VAR' does not exist on type 'ImportMetaEnv'`
 
 **Solution**: Add to `src/env.d.ts`:
 
 ```typescript
 interface ImportMetaEnv {
   readonly VITE_MY_VAR: string
+  readonly PUBLIC_MY_VAR: string
 }
 ```
 
@@ -461,7 +576,7 @@ interface ImportMetaEnv {
 
 **Solutions**:
 
-1. Remove `VITE_` prefix from sensitive variables
+1. Remove `VITE_` or `PUBLIC_` prefix from sensitive variables
 2. Move sensitive operations to server functions
 3. Use build tools to verify no secrets in client bundle
 
@@ -497,8 +612,11 @@ With static replacement enabled (the default), the bundler sees `"production" ==
 
 The replacement is controlled by the `server.build.staticNodeEnv` option:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import viteReact from '@vitejs/plugin-react'
@@ -518,10 +636,34 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    pluginReact(),
+    tanstackStart({
+      server: {
+        build: {
+          // Replace process.env.NODE_ENV at build time (default: true)
+          staticNodeEnv: true,
+        },
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 The replacement value is determined in this order:
 
 1. `process.env.NODE_ENV` at build time (if set)
-2. Vite's `mode` (e.g., from `--mode staging`)
+2. The bundler's `mode` (e.g., from `--mode staging`)
 3. `"production"` (fallback)
 
 ### When to Disable Static Replacement
@@ -554,3 +696,4 @@ Common reasons to disable:
 - [Server Functions](./server-functions.md) - Learn more about server-side code
 - [Hosting](./hosting.md) - Platform-specific environment variable configuration
 - [Vite Environment Variables](https://vitejs.dev/guide/env-and-mode.html) - Official Vite documentation
+- [Rsbuild Environment Variables](https://rsbuild.dev/guide/advanced/env-vars) - Official Rsbuild documentation
diff --git a/docs/start/framework/react/guide/hosting.md b/docs/start/framework/react/guide/hosting.md
index 26e2e0db66..23fdd63226 100644
--- a/docs/start/framework/react/guide/hosting.md
+++ b/docs/start/framework/react/guide/hosting.md
@@ -3,7 +3,7 @@ id: hosting
 title: Hosting
 ---
 
-Hosting is the process of deploying your application to the internet so that users can access it. This is a critical part of any web development project, ensuring your application is available to the world. TanStack Start is built on Vite, a powerful dev/build platform that allows us to make it possible to deploy your application to any hosting provider.
+Hosting is the process of deploying your application to the internet so that users can access it. This is a critical part of any web development project, ensuring your application is available to the world. TanStack Start supports Vite and Rsbuild, giving you flexible build outputs for different hosting providers and runtimes.
 
 ## What should I use?
 
@@ -36,6 +36,7 @@ Once you've chosen a deployment target, you can follow the deployment guidelines
 </a>
 
 When deploying to Cloudflare Workers, you'll need to complete a few extra steps before your users can start using your app.
+The official Cloudflare Workers setup currently uses Vite through `@cloudflare/vite-plugin`.
 
 1. Install `@cloudflare/vite-plugin` and `wrangler`
 
@@ -124,7 +125,7 @@ A full TanStack Start example for Cloudflare Workers is available [here](https:/
   </picture>
 </a>
 
-Install and add the [`@netlify/vite-plugin-tanstack-start`](https://www.npmjs.com/package/@netlify/vite-plugin-tanstack-start) plugin, which configures your build for Netlify deployment and provides full Netlify production platform emulation in local dev:
+The official Netlify setup currently uses Vite through [`@netlify/vite-plugin-tanstack-start`](https://www.npmjs.com/package/@netlify/vite-plugin-tanstack-start), which configures your build for Netlify deployment and provides full Netlify production platform emulation in local dev:
 
 ```bash
 npm install --save-dev @netlify/vite-plugin-tanstack-start
@@ -264,6 +265,12 @@ Deploy your application to Vercel using their one-click deployment process, and
 
 ### Node.js / Docker
 
+Use the Node.js deployment shape that matches your build tool.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
 Follow the [`Nitro`](#nitro) deployment instructions. Use the `node` command to start your application from the server from the build output files.
 
 Ensure `build` and `start` npm scripts are present in your `package.json` file:
@@ -273,6 +280,33 @@ Ensure `build` and `start` npm scripts are present in your `package.json` file:
     "start": "node .output/server/index.mjs"
 ```
 
+# Rsbuild
+
+An Rsbuild production build emits client assets in `dist/client` and a server bundle in `dist/server/index.js`. The server bundle exports a fetch-style Start server entry:
+
+```ts
+type ServerEntry = {
+  fetch(request: Request): Response | Promise<Response>
+}
+```
+
+To run it on Node.js, serve `dist/client` as static assets and forward all other requests to the server entry's `fetch` handler. `srvx` is one way to do that:
+
+```sh
+npm install srvx
+```
+
+```json
+    "build": "rsbuild build",
+    "start": "srvx --prod -s dist/client dist/server/index.js"
+```
+
+Express or any other custom Node.js server works too, as long as it serves the client assets and calls the server entry's `fetch` handler for dynamic requests.
+
+If your server entry is emitted as `dist/server/server.js`, use that path instead of `dist/server/index.js`.
+
+<!-- ::end:tabs -->
+
 Then you can run the following command to build your application:
 
 ```sh
@@ -296,7 +330,7 @@ Make sure that your `react` and `react-dom` packages are set to version 19.0.0 o
 bun install react@19 react-dom@19
 ```
 
-Follow the [`Nitro`](#nitro) deployment instructions.
+For Vite builds, follow the [`Nitro`](#nitro) deployment instructions.
 Depending on how you invoke the build, you might need to set the `'bun'` preset in the Nitro configuration:
 
 ```ts
diff --git a/docs/start/framework/react/guide/import-protection.md b/docs/start/framework/react/guide/import-protection.md
index 677b26fac8..8bf47c729a 100644
--- a/docs/start/framework/react/guide/import-protection.md
+++ b/docs/start/framework/react/guide/import-protection.md
@@ -95,8 +95,11 @@ Mock mode is useful during development because it lets you keep working even whe
 
 You can override the defaults:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
@@ -112,6 +115,26 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      importProtection: {
+        // Always error, even in dev
+        behavior: 'error',
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 Or set different behaviors per mode:
 
 ```ts
@@ -127,8 +150,11 @@ importProtection: {
 
 You can add your own deny rules on top of the defaults. Rules are specified per environment using glob patterns (via [picomatch](https://github.com/micromatch/picomatch)) or regular expressions.
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
@@ -152,6 +178,34 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      importProtection: {
+        client: {
+          // Block specific npm packages from the client bundle
+          specifiers: ['@prisma/client', 'bcrypt'],
+          // Block files in a custom directory
+          files: ['**/db/**'],
+        },
+        server: {
+          // Block browser-only libraries from the server
+          specifiers: ['localforage'],
+        },
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 ### Checking third-party packages
 
 By default, resolved files inside `node_modules` are excluded from resolved-target deny checks (file-pattern and marker checks). This avoids false positives from packages that happen to use `.client.` or `.server.` in their distribution filenames. If you want to re-enable checking for a specific environment, set `excludeFiles` to an empty array:
diff --git a/docs/start/framework/react/guide/isr.md b/docs/start/framework/react/guide/isr.md
index ad1e322130..5704af1a11 100644
--- a/docs/start/framework/react/guide/isr.md
+++ b/docs/start/framework/react/guide/isr.md
@@ -22,8 +22,11 @@ The core concept is simple:
 
 The most common ISR pattern uses the `Cache-Control` header with `max-age` and `s-maxage` directives:
 
-```tsx
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import { defineConfig } from 'vite'
 
@@ -39,6 +42,28 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    pluginReact(),
+    tanstackStart({
+      prerender: {
+        routes: ['/blog', '/blog/posts/*'],
+        crawlLinks: true,
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 ```tsx
 // routes/blog/posts/$postId.tsx
 import { createFileRoute } from '@tanstack/react-router'
@@ -386,8 +411,11 @@ const cacheMonitoringMiddleware = createMiddleware().server(
 
 Prerender at build time for instant first load, then use ISR for updates:
 
-```tsx
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import { defineConfig } from 'vite'
 
@@ -403,6 +431,28 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    pluginReact(),
+    tanstackStart({
+      prerender: {
+        routes: ['/blog', '/blog/posts/*'],
+        crawlLinks: true,
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 ## Debugging ISR
 
 ### Check Cache Headers
diff --git a/docs/start/framework/react/guide/llmo.md b/docs/start/framework/react/guide/llmo.md
index 25007890fa..8c18252aee 100644
--- a/docs/start/framework/react/guide/llmo.md
+++ b/docs/start/framework/react/guide/llmo.md
@@ -281,7 +281,7 @@ function DocumentationPage() {
 
       <section>
         <h2>Configuration</h2>
-        <p>Configure your app in vite.config.ts...</p>
+        <p>Configure your app in your bundler config...</p>
       </section>
     </article>
   )
diff --git a/docs/start/framework/react/guide/path-aliases.md b/docs/start/framework/react/guide/path-aliases.md
index 98092beb2d..791b8a5d0a 100644
--- a/docs/start/framework/react/guide/path-aliases.md
+++ b/docs/start/framework/react/guide/path-aliases.md
@@ -20,7 +20,11 @@ By default, TanStack Start does not include path aliases. However, you can easil
 
 In this example, we've defined the path alias `~/*` that maps to the `./src/*` directory. This means that you can now import files from the `src` directory using the `~` prefix.
 
-After updating your `tsconfig.json` file, you'll need to make changes to `vite.config.ts` to ensure that Vite resolves the path aliases correctly.
+After updating your `tsconfig.json` file, configure your bundler so it resolves the same path aliases.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ## Vite 8
 
@@ -63,6 +67,25 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+Rsbuild reads the `paths` field from `tsconfig.json` by default. No extra config is needed when your aliases live in the root `tsconfig.json`.
+
+If you use a custom tsconfig file, point Rsbuild at it with `source.tsconfigPath`:
+
+```ts
+// rsbuild.config.ts
+import { defineConfig } from '@rsbuild/core'
+
+export default defineConfig({
+  source: {
+    tsconfigPath: './tsconfig.custom.json',
+  },
+})
+```
+
+<!-- ::end:tabs -->
+
 Once this configuration has completed, you'll now be able to import files using the path alias like so:
 
 ```ts
diff --git a/docs/start/framework/react/guide/seo.md b/docs/start/framework/react/guide/seo.md
index a4f580d446..53c7ce381a 100644
--- a/docs/start/framework/react/guide/seo.md
+++ b/docs/start/framework/react/guide/seo.md
@@ -179,8 +179,12 @@ See the [Selective SSR guide](./selective-ssr) for more details.
 
 For content that doesn't change frequently, static prerendering generates HTML at build time for optimal performance:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
+import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
 export default defineConfig({
@@ -195,6 +199,26 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      prerender: {
+        enabled: true,
+        crawlLinks: true,
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 Prerendered pages load faster and are easily crawlable. See the [Static Prerendering guide](./static-prerendering) for configuration options.
 
 ## Sitemaps
@@ -203,8 +227,12 @@ Prerendered pages load faster and are easily crawlable. See the [Static Prerende
 
 TanStack Start can automatically generate a sitemap when you enable prerendering with link crawling:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
+import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
 export default defineConfig({
@@ -223,6 +251,30 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      prerender: {
+        enabled: true,
+        crawlLinks: true, // Discovers all linkable pages
+      },
+      sitemap: {
+        enabled: true,
+        host: 'https://myapp.com',
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 The sitemap is generated at build time by crawling all discoverable pages from your routes. This is the recommended approach for static or mostly-static sites.
 
 ### Static Sitemap
diff --git a/docs/start/framework/react/guide/server-components.md b/docs/start/framework/react/guide/server-components.md
index b11b067216..e6b3488aa9 100644
--- a/docs/start/framework/react/guide/server-components.md
+++ b/docs/start/framework/react/guide/server-components.md
@@ -12,7 +12,11 @@ Server Components let you render React components on the server and stream them
 
 **Server Components are not enabled by default.** Complete these three steps first:
 
-### 1. Install the Vite RSC Plugin
+### 1. Install Bundler-Specific RSC Dependencies
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```bash
 npm install -D @vitejs/plugin-rsc
@@ -24,11 +28,25 @@ yarn add -D @vitejs/plugin-rsc
 bun add -D @vitejs/plugin-rsc
 ```
 
-### 2. Configure Vite
+# Rsbuild
 
-Update your `vite.config.ts` to enable RSC in the TanStack Start plugin and add the Vite RSC plugin:
+Rsbuild does not need a separate RSC plugin. Make sure your Rsbuild React dependencies are installed:
 
-```tsx
+```bash
+npm install -D @rsbuild/core @rsbuild/plugin-react
+```
+
+<!-- ::end:tabs -->
+
+### 2. Configure Your Bundler
+
+Update your bundler config to enable RSC in the TanStack Start plugin:
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import viteReact from '@vitejs/plugin-react'
@@ -47,7 +65,28 @@ export default defineConfig({
 })
 ```
 
-**Requirements:** React 19+, Vite 7+
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    pluginReact({ splitChunks: false }),
+    tanstackStart({
+      rsc: {
+        enabled: true,
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
+**Requirements:** React 19+, Vite 7+ or Rsbuild 2+
 
 ## Quick Start
 
diff --git a/docs/start/framework/react/guide/server-functions.md b/docs/start/framework/react/guide/server-functions.md
index fb521b8c8e..c86e9ec2e4 100644
--- a/docs/start/framework/react/guide/server-functions.md
+++ b/docs/start/framework/react/guide/server-functions.md
@@ -420,7 +420,7 @@ If two server functions end up with the same ID (including when using a custom g
 
 Customization:
 
-You can customize function ID generation for the production build by providing a `generateFunctionId` function when configuring the TanStack Start Vite plugin.
+You can customize function ID generation for the production build by providing a `generateFunctionId` function when configuring the TanStack Start bundler plugin.
 
 Prefer deterministic inputs (filename + functionName) so IDs remain stable between builds.
 
@@ -428,10 +428,12 @@ Please note that this customization is **experimental** and subject to change.
 
 Example:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
 export default defineConfig({
@@ -439,22 +441,41 @@ export default defineConfig({
     tanstackStart({
       serverFns: {
         generateFunctionId: ({ filename, functionName }) => {
-          // Return a custom ID string
           return crypto
             .createHash('sha1')
             .update(`${filename}--${functionName}`)
             .digest('hex')
+        },
+      },
+    }),
+  ],
+})
+```
+
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
 
-          // If you return undefined, the default is used
-          // return undefined
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      serverFns: {
+        generateFunctionId: ({ filename, functionName }) => {
+          return crypto
+            .createHash('sha1')
+            .update(`${filename}--${functionName}`)
+            .digest('hex')
         },
       },
     }),
-    react(),
   ],
 })
 ```
 
+<!-- ::end:tabs -->
+
 ---
 
 > **Note**: Server functions use a compilation process that extracts server code from client bundles while maintaining seamless calling patterns. On the client, calls become `fetch` requests to the server.
diff --git a/docs/start/framework/react/guide/spa-mode.md b/docs/start/framework/react/guide/spa-mode.md
index 8921465553..a29d97a71e 100644
--- a/docs/start/framework/react/guide/spa-mode.md
+++ b/docs/start/framework/react/guide/spa-mode.md
@@ -38,8 +38,25 @@ After enabling the SPA mode, running a Start build will have an additional prere
 
 To configure SPA mode, there are a few options you can add to your Start plugin's options:
 
-```tsx
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      spa: {
+        enabled: true,
+      },
+    }),
+  ],
+})
+```
+
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
 export default defineConfig({
   plugins: [
     tanstackStart({
@@ -51,6 +68,8 @@ export default defineConfig({
 })
 ```
 
+<!-- ::end:tabs -->
+
 ## Use Necessary Redirects
 
 Deploying a purely client-side SPA to a host or CDN often requires the use of redirects to ensure that urls are properly rewritten to the SPA shell. The goal of any deployment should include these priorities in this order:
@@ -90,8 +109,25 @@ The default pathname used to generate the SPA shell is `/`. We call this the **s
 > [!NOTE]
 > It's recommended to keep the default value of `/` as the shell mask path.
 
-```tsx
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      spa: {
+        maskPath: '/app',
+      },
+    }),
+  ],
+})
+```
+
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
 export default defineConfig({
   plugins: [
     tanstackStart({
@@ -103,6 +139,8 @@ export default defineConfig({
 })
 ```
 
+<!-- ::end:tabs -->
+
 ## Prerendering Options
 
 The prerender option is used to configure the prerendering behavior of the SPA shell, and accepts the same prerender options as found in our prerendering guide.
@@ -117,8 +155,29 @@ This means that by default, the shell will not be crawled for links to follow fo
 
 You can always override these options by providing your own prerender options:
 
-```tsx
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
+export default defineConfig({
+  plugins: [
+    tanstackStart({
+      spa: {
+        prerender: {
+          outputPath: '/custom-shell',
+          crawlLinks: true,
+          retryCount: 3,
+        },
+      },
+    }),
+  ],
+})
+```
+
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
 export default defineConfig({
   plugins: [
     tanstackStart({
@@ -134,6 +193,8 @@ export default defineConfig({
 })
 ```
 
+<!-- ::end:tabs -->
+
 ## Customized rendering in SPA mode
 
 Customizing the HTML output of the SPA shell can be useful if you want to:
diff --git a/docs/start/framework/react/guide/static-prerendering.md b/docs/start/framework/react/guide/static-prerendering.md
index dfaac8fcef..c4b12a67ae 100644
--- a/docs/start/framework/react/guide/static-prerendering.md
+++ b/docs/start/framework/react/guide/static-prerendering.md
@@ -7,11 +7,14 @@ Static prerendering is the process of generating static HTML files for your appl
 
 ## Prerendering
 
-TanStack Start can prerender your application to static HTML files, which can then be served to users without having to generate them on the fly. To prerender your application, you can add the `prerender` option to your tanstackStart configuration in `vite.config.ts` file:
+TanStack Start can prerender your application to static HTML files, which can then be served to users without having to generate them on the fly. To prerender your application, you can add the `prerender` option to your `tanstackStart` configuration:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
 
+# Vite
+
+```ts title="vite.config.ts"
+import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import viteReact from '@vitejs/plugin-react'
 
@@ -69,6 +72,69 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    pluginReact(),
+    tanstackStart({
+      prerender: {
+        // Switch to true to enable prerendering
+        enabled: false,
+
+        // Disable if you need pages to be at `/page.html` instead of `/page/index.html`
+        autoSubfolderIndex: true,
+
+        // If disabled, only the root path or the paths defined in the pages config will be prerendered
+        autoStaticPathsDiscovery: true,
+
+        // How many prerender jobs to run at once
+        concurrency: 14,
+
+        // Whether to extract links from the HTML and prerender them also
+        crawlLinks: true,
+
+        // Filter function takes the page object and returns whether it should prerender
+        filter: ({ path }) => !path.startsWith('/do-not-render-me'),
+
+        // Number of times to retry a failed prerender job
+        retryCount: 2,
+
+        // Delay between retries in milliseconds
+        retryDelay: 1000,
+
+        // Maximum number of redirects to follow during prerendering
+        maxRedirects: 5,
+
+        // Fail if an error occurs during prerendering
+        failOnError: true,
+
+        // Callback when page is successfully rendered
+        onSuccess: ({ page }) => {
+          console.log(`Rendered ${page.path}!`)
+        },
+      },
+      // Optional configuration for specific pages
+      // Note: When autoStaticPathsDiscovery is enabled (default), discovered static
+      // routes will be merged with the pages specified below
+      pages: [
+        {
+          path: '/my-page',
+          prerender: { enabled: true, outputPath: '/my-page/index.html' },
+        },
+      ],
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 ## Automatic Static Route Discovery
 
 All static paths will be automatically discovered and seamlessly merged with the specified `pages` config
diff --git a/docs/start/framework/react/guide/tailwind-integration.md b/docs/start/framework/react/guide/tailwind-integration.md
index 25f18f5b62..62fb3fd6e9 100644
--- a/docs/start/framework/react/guide/tailwind-integration.md
+++ b/docs/start/framework/react/guide/tailwind-integration.md
@@ -9,22 +9,37 @@ This guide will help you use Tailwind CSS in your TanStack Start project.
 
 ## Tailwind CSS Version 4 (Latest)
 
-The latest version of Tailwind CSS is 4. And it has some configuration changes that majorly differ from Tailwind CSS Version 3. It's **easier and recommended** to set up Tailwind CSS Version 4 in a TanStack Start project, as TanStack Start uses Vite as its build tool.
+The latest version of Tailwind CSS is 4. And it has some configuration changes that majorly differ from Tailwind CSS Version 3. It's **easier and recommended** to set up Tailwind CSS Version 4 in a TanStack Start project with either Vite or Rsbuild.
 
 ### Install Tailwind CSS
 
-Install Tailwind CSS and it's Vite plugin.
+Install Tailwind CSS and the integration for your bundler.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```shell
 npm install tailwindcss @tailwindcss/vite
 ```
 
-### Configure The Vite Plugin
+# Rsbuild
+
+```shell
+npm install tailwindcss @tailwindcss/postcss postcss
+```
+
+<!-- ::end:tabs -->
 
-Add the `@tailwindcss/vite` plugin to your Vite configuration.
+### Configure Tailwind CSS
 
-```ts
-// vite.config.ts
+Add Tailwind CSS to your bundler configuration.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import tsConfigPaths from 'vite-tsconfig-paths'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
@@ -39,6 +54,31 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  server: {
+    port: 3000,
+  },
+  plugins: [pluginReact(), tanstackStart()],
+})
+```
+
+```js title="postcss.config.mjs"
+export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+}
+```
+
+<!-- ::end:tabs -->
+
 ### Import Tailwind in your CSS file
 
 You need to create a CSS file to configure Tailwind CSS instead of the configuration file in version 4. You can do this by creating a `src/styles/app.css` file or name it whatever you want.
@@ -50,7 +90,13 @@ You need to create a CSS file to configure Tailwind CSS instead of the configura
 
 ## Import the CSS file in your `__root.tsx` file
 
-Import the CSS file in your `__root.tsx` file with the `?url` query and make sure to add the **triple slash** directive to the top of the file.
+Import the CSS file in your `__root.tsx` file.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+Use the `?url` query and make sure to add the **triple slash** directive to the top of the file.
 
 ```tsx
 // src/routes/__root.tsx
@@ -71,6 +117,28 @@ export const Route = createRootRoute({
 })
 ```
 
+# Rsbuild
+
+Use a side-effect import so Start can discover the generated stylesheet as a route asset.
+
+```tsx
+// src/routes/__root.tsx
+import { createRootRoute } from '@tanstack/react-router'
+import '../styles/app.css'
+
+export const Route = createRootRoute({
+  head: () => ({
+    meta: [
+      // your meta tags and site config
+    ],
+    // other head config
+  }),
+  component: RootComponent,
+})
+```
+
+<!-- ::end:tabs -->
+
 ## Use Tailwind CSS anywhere in your project
 
 You can now use Tailwind CSS anywhere in your project.
diff --git a/docs/start/framework/react/migrate-from-next-js.md b/docs/start/framework/react/migrate-from-next-js.md
index 3517360743..81a678e246 100644
--- a/docs/start/framework/react/migrate-from-next-js.md
+++ b/docs/start/framework/react/migrate-from-next-js.md
@@ -52,23 +52,49 @@ rm postcss.config.* next.config.*
 
 ### 2. Install Required Dependencies
 
-TanStack Start leverages Tanstack Router, [Vite](https://vite.dev), and a vite deployment plugin e.g. [nitro](https://nitro.build/).
+TanStack Start leverages TanStack Router and supports [Vite](https://vite.dev) or [Rsbuild](https://rsbuild.dev/) as the bundler. The Vite setup below includes [Nitro](https://nitro.build/) as a deployment plugin.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```sh
 npm i @tanstack/react-router @tanstack/react-start nitro vite @vitejs/plugin-react
 ```
 
-For Tailwind CSS:
+# Rsbuild
+
+```sh
+npm i @tanstack/react-router @tanstack/react-start @rsbuild/core @rsbuild/plugin-react
+```
+
+<!-- ::end:tabs -->
+
+For Tailwind CSS, install the bundler integration you want to use:
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```sh
 npm i -D @tailwindcss/vite tailwindcss
 ```
 
+# Rsbuild
+
+```sh
+npm i -D @tailwindcss/postcss tailwindcss
+```
+
+<!-- ::end:tabs -->
+
 ### 3. Update Project Configuration
 
 Now that you've installed the necessary dependencies, update your project configuration files to work with TanStack Start.
 
-- `package.json`
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```json
 {
@@ -81,10 +107,25 @@ Now that you've installed the necessary dependencies, update your project config
 }
 ```
 
-- `vite.config.ts`
+# Rsbuild
 
-```ts
-// vite.config.ts
+```json
+{
+  "type": "module",
+  "scripts": {
+    "dev": "rsbuild dev",
+    "build": "rsbuild build"
+  }
+}
+```
+
+<!-- ::end:tabs -->
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import viteReact from '@vitejs/plugin-react'
@@ -114,6 +155,40 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginReact } from '@rsbuild/plugin-react'
+import { tanstackStart } from '@tanstack/react-start/plugin/rsbuild'
+
+export default defineConfig({
+  server: {
+    port: 3000,
+  },
+  plugins: [
+    pluginReact(),
+    tanstackStart({
+      srcDirectory: 'src', // This is the default
+      router: {
+        // Specifies the directory TanStack Router uses for your routes.
+        routesDirectory: 'app', // Defaults to "routes", relative to srcDirectory
+      },
+    }),
+  ],
+})
+```
+
+```js title="postcss.config.mjs"
+export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+}
+```
+
+<!-- ::end:tabs -->
+
 By default, `routesDirectory` is set to `routes`. To maintain consistency with Next.js App Router conventions, you can set it to `app` instead.
 
 ### 4. Adapt the Root Layout
diff --git a/docs/start/framework/react/overview.md b/docs/start/framework/react/overview.md
index 539e1335c1..b0b11c6580 100644
--- a/docs/start/framework/react/overview.md
+++ b/docs/start/framework/react/overview.md
@@ -8,14 +8,14 @@ title: TanStack Start Overview
 > **This does not mean it is bug-free or without issues, which is why we invite you to try it out and provide feedback!**
 > The road to v1 will likely be a quick one, so don't wait too long to try it out!
 
-TanStack Start is a full-stack React framework powered by TanStack Router. It provides a full-document SSR, streaming, server functions, bundling, and more. Thanks to [Vite](https://vite.dev/), it's ready to develop and deploy to any hosting provider or runtime you want!
+TanStack Start is a full-stack React framework powered by TanStack Router. It provides a full-document SSR, streaming, server functions, bundling, and more. With [Vite](https://vite.dev/) and [Rsbuild](https://rsbuild.dev/) support, it's ready to develop and deploy to the hosting provider or runtime you want.
 
 ## Dependencies
 
 TanStack Start is built on two key technologies:
 
 - **[TanStack Router](https://tanstack.com/router)**: A type-safe router for building web applications with advanced features like nested routing, search params, and data loading
-- **[Vite](https://vite.dev/)**: A modern build tool that provides fast development with hot module replacement and optimized production builds
+- **[Vite](https://vite.dev/) or [Rsbuild](https://rsbuild.dev/)**: Modern bundlers that provide fast development with hot module replacement and optimized production builds
 
 ## Should I use TanStack Start or just TanStack Router?
 
@@ -27,7 +27,7 @@ TanStack Start is built on two key technologies:
 - **Server Functions** - Type-safe RPCs between client and server
 - **Middleware & Context** - Powerful request/response handling and data injection
 - **Full-Stack Bundling** - Optimized builds for both client and server code
-- **Universal Deployment** - Deploy to any Vite-compatible hosting provider
+- **Universal Deployment** - Deploy to hosting providers and runtimes with Vite or Rsbuild builds
 - **End-to-End Type Safety** - Full TypeScript support across the entire stack
 
 That said, if you **know with certainty** that you will not need any of the above features, then you may want to consider using TanStack Router alone, which is still a powerful and type-safe SPA routing upgrade over other routers and frameworks.
diff --git a/docs/start/framework/react/start-vs-nextjs.md b/docs/start/framework/react/start-vs-nextjs.md
index 99f9144454..27b814725f 100644
--- a/docs/start/framework/react/start-vs-nextjs.md
+++ b/docs/start/framework/react/start-vs-nextjs.md
@@ -68,13 +68,13 @@ Both frameworks handle the fundamentals - code splitting, caching, SSR, static o
 
 ### The Build Pipeline
 
-**Next.js** uses a custom build system (historically Webpack, now Turbopack). It's tightly integrated with their architecture, which enables optimizations but limits flexibility. Turbopack has improved dev speed, but it's still no match for Vite.
+**Next.js** uses a custom build system (historically Webpack, now Turbopack). It's tightly integrated with their architecture, which enables optimizations but limits flexibility. Turbopack has improved dev speed, but it's still no match for Vite or Rsbuild.
 
-**TanStack Start** is built on Vite. This means:
+**TanStack Start** supports Vite and Rsbuild. This means:
 
 - Faster dev server startup
 - Faster HMR
-- Access to the entire Vite plugin ecosystem
+- Access to modern plugin ecosystems
 - Standard tooling that transfers to other projects
 
 ### The Runtime
@@ -253,7 +253,7 @@ With RSC support, the question isn't "what does Start lack?" - it's: **"Why give
 
 **Caching model** - Explicit SWR primitives you already understand if you've used TanStack Query. No implicit layers to debug.
 
-**Dev experience** - Vite's speed is real. Instant startup, fast HMR, lower resource usage. This compounds over a workday - and even more so when AI agents are iterating on your code in tight loops.
+**Dev experience** - Vite and Rsbuild are fast. Instant startup, fast HMR, lower resource usage. This compounds over a workday - and even more so when AI agents are iterating on your code in tight loops.
 
 **Deployment as a feature** - Start treats deployment flexibility as a first-class feature. Cloudflare, Netlify, AWS, Fly, Railway, your own servers - they're all equally supported. Your app works the same everywhere because it's built on standards, not platform-specific optimizations. This means you can:
 
@@ -275,7 +275,7 @@ With RSC support, the question isn't "what does Start lack?" - it's: **"Why give
 | **Type safety**      | End-to-end, compile-time             | TypeScript support with boundary gaps |
 | **Server functions** | Typed, validated, middleware support | Untyped boundary, no middleware       |
 | **Caching**          | Explicit SWR primitives              | Multi-layer implicit caching          |
-| **Build tool**       | Vite                                 | Turbopack/Webpack                     |
+| **Build tool**       | Vite or Rsbuild                      | Turbopack/Webpack                     |
 | **Deployment**       | Equal support everywhere             | Optimized for Vercel                  |
 | **Routing**          | Best-in-class type safety            | File-based, basic types               |
 | **RSC**              | Supported                            | Supported                             |
diff --git a/docs/start/framework/react/tutorial/fetching-external-api.md b/docs/start/framework/react/tutorial/fetching-external-api.md
index 486a5f86fc..8bdb048c88 100644
--- a/docs/start/framework/react/tutorial/fetching-external-api.md
+++ b/docs/start/framework/react/tutorial/fetching-external-api.md
@@ -61,7 +61,7 @@ At this point, the project structure should look like this:
 │   ├── routeTree.gen.ts                  # Generated route tree
 │   └── styles.css                        # Global styles
 ├── public/                               # Static assets
-├── vite.config.ts                         # TanStack Start configuration
+├── vite.config.ts or rsbuild.config.ts    # TanStack Start configuration
 ├── package.json                          # Project dependencies
 └── tsconfig.json                         # TypeScript configuration
 
diff --git a/docs/start/framework/react/tutorial/reading-writing-file.md b/docs/start/framework/react/tutorial/reading-writing-file.md
index 3149be04c9..0b579bae95 100644
--- a/docs/start/framework/react/tutorial/reading-writing-file.md
+++ b/docs/start/framework/react/tutorial/reading-writing-file.md
@@ -74,7 +74,7 @@ At this point, the project structure should look like this -
 │   ├── routeTree.gen.ts                  # Generated route tree
 │   └── styles.css                        # Global styles
 ├── public/                               # Static assets
-├── vite.config.ts                        # TanStack Start configuration
+├── vite.config.ts or rsbuild.config.ts   # TanStack Start configuration
 ├── package.json                          # Project dependencies
 └── tsconfig.json                         # TypeScript configuration
 ```
diff --git a/docs/start/framework/solid/build-from-scratch.md b/docs/start/framework/solid/build-from-scratch.md
index b7e71afab6..3a0e7a0f09 100644
--- a/docs/start/framework/solid/build-from-scratch.md
+++ b/docs/start/framework/solid/build-from-scratch.md
@@ -48,20 +48,38 @@ We highly recommend using TypeScript with TanStack Start. Create a `tsconfig.jso
 
 ## Install Dependencies
 
-TanStack Start is powered by [Vite](https://vite.dev/) and [TanStack Router](https://tanstack.com/router) and requires them as dependencies.
+TanStack Start is powered by [TanStack Router](https://tanstack.com/router) and supports [Vite](https://vite.dev/) or [Rsbuild](https://rsbuild.dev/) as the bundler.
 
-To install them, run:
+To install Start and Router, run:
 
 ```shell
-npm i @tanstack/solid-start @tanstack/solid-router vite
+npm i @tanstack/solid-start @tanstack/solid-router
 ```
 
 You'll also need SolidJS:
 
 ```shell
-npm i solid-js vite-plugin-solid
+npm i solid-js
 ```
 
+Install the bundler and Solid integration you want to use:
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```shell
+npm i -D vite vite-plugin-solid
+```
+
+# Rsbuild
+
+```shell
+npm i -D @rsbuild/core @rsbuild/plugin-babel @rsbuild/plugin-solid
+```
+
+<!-- ::end:tabs -->
+
 and some TypeScript:
 
 ```shell
@@ -70,7 +88,11 @@ npm i -D typescript @types/node
 
 ## Update Configuration Files
 
-We'll then update our `package.json` to use Vite's CLI and set `"type": "module"`:
+We'll then update our `package.json` to use your bundler's CLI and set `"type": "module"`:
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```json
 {
@@ -83,10 +105,28 @@ We'll then update our `package.json` to use Vite's CLI and set `"type": "module"
 }
 ```
 
-Then configure TanStack Start's Vite plugin in `vite.config.ts`:
+# Rsbuild
 
-```ts
-// vite.config.ts
+```json
+{
+  // ...
+  "type": "module",
+  "scripts": {
+    "dev": "rsbuild dev",
+    "build": "rsbuild build"
+  }
+}
+```
+
+<!-- ::end:tabs -->
+
+Then configure TanStack Start's bundler plugin:
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
 import viteSolid from 'vite-plugin-solid'
@@ -106,6 +146,30 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginBabel } from '@rsbuild/plugin-babel'
+import { pluginSolid } from '@rsbuild/plugin-solid'
+import { tanstackStart } from '@tanstack/solid-start/plugin/rsbuild'
+
+export default defineConfig({
+  server: {
+    port: 3000,
+  },
+  plugins: [
+    pluginBabel({
+      include: /\.(?:jsx|tsx)$/,
+    }),
+    pluginSolid(),
+    tanstackStart(),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 ## Add the Basic Templating
 
 There are 2 required files for TanStack Start usage:
@@ -122,7 +186,7 @@ Once configuration is done, we'll have a file tree that looks like the following
 │   │   └── `__root.tsx`
 │   ├── `router.tsx`
 │   ├── `routeTree.gen.ts`
-├── `vite.config.ts`
+├── `vite.config.ts` or `rsbuild.config.ts`
 ├── `package.json`
 └── `tsconfig.json`
 ```
@@ -156,7 +220,6 @@ Finally, we need to create the root of our application. This is the entry point
 
 ```tsx
 // src/routes/__root.tsx
-/// <reference types="vite/client" />
 import * as Solid from 'solid-js'
 import {
   Outlet,
diff --git a/docs/start/framework/solid/guide/environment-variables.md b/docs/start/framework/solid/guide/environment-variables.md
index 401a78ec35..a945ba73cd 100644
--- a/docs/start/framework/solid/guide/environment-variables.md
+++ b/docs/start/framework/solid/guide/environment-variables.md
@@ -7,7 +7,11 @@ Learn how to securely configure and use environment variables in your TanStack S
 
 ## Quick Start
 
-TanStack Start automatically loads `.env` files and makes variables available in both server and client contexts with proper security boundaries.
+TanStack Start automatically loads `.env` files and makes variables available in both server and client contexts with proper security boundaries. Server code can read unprefixed variables from `process.env`; client code can only read variables exposed by your bundler's public prefix.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```bash
 # .env
@@ -28,6 +32,29 @@ export function AppHeader() {
 }
 ```
 
+# Rsbuild
+
+```bash
+# .env
+DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
+PUBLIC_APP_NAME=My TanStack Start App
+```
+
+```typescript
+// Server function - can access any environment variable
+const getUser = createServerFn().handler(async () => {
+  const db = await connect(process.env.DATABASE_URL) // ✅ Server-only
+  return db.user.findFirst()
+})
+
+// Client component - only PUBLIC_ prefixed variables by default
+export function AppHeader() {
+  return <h1>{import.meta.env.PUBLIC_APP_NAME}</h1> // ✅ Client-safe
+}
+```
+
+<!-- ::end:tabs -->
+
 ## Environment Variable Contexts
 
 ### Server-Side Context (Server Functions & API Routes)
@@ -57,7 +84,13 @@ const authenticateUser = createServerFn()
 
 ### Client-Side Context (Components & Client Code)
 
-Client code can only access variables with the `VITE_` prefix:
+Client code can only access variables with your bundler's public prefix.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+Vite exposes variables with the `VITE_` prefix:
 
 ```typescript
 // Client configuration
@@ -85,6 +118,38 @@ export function FeatureGatedComponent() {
 }
 ```
 
+# Rsbuild
+
+Rsbuild exposes variables with the `PUBLIC_` prefix by default:
+
+```typescript
+// Client configuration
+export function ApiProvider(props) {
+  const apiUrl = import.meta.env.PUBLIC_API_URL // ✅ Public
+  const apiKey = import.meta.env.PUBLIC_KEY // ✅ Public
+
+  // This would be undefined (security feature):
+  // const secret = import.meta.env.DATABASE_URL // ❌ Undefined
+
+  return (
+    <ApiContext.Provider value={{ apiUrl, apiKey }}>
+      {props.children}
+    </ApiContext.Provider>
+  )
+}
+
+// Feature flags
+export function FeatureGatedComponent() {
+  const enableNewFeature = import.meta.env.PUBLIC_ENABLE_NEW_FEATURE === 'true'
+
+  if (!enableNewFeature) return null
+
+  return <NewFeature />
+}
+```
+
+<!-- ::end:tabs -->
+
 ## Environment File Setup
 
 ### File Hierarchy (Loaded in Order)
@@ -103,10 +168,13 @@ TanStack Start automatically loads environment files in this order:
 **.env** (committed to repository):
 
 ```bash
-# Public configuration
+# Public configuration (Vite uses VITE_; Rsbuild uses PUBLIC_ by default)
 VITE_APP_NAME=My TanStack Start App
 VITE_API_URL=https://api.example.com
 VITE_SENTRY_DSN=https://...
+PUBLIC_APP_NAME=My TanStack Start App
+PUBLIC_API_URL=https://api.example.com
+PUBLIC_SENTRY_DSN=https://...
 
 # Server configuration templates
 DATABASE_URL=postgresql://localhost:5432/myapp_dev
@@ -127,6 +195,7 @@ JWT_SECRET=your-local-secret
 ```bash
 # Production overrides
 VITE_API_URL=https://api.myapp.com
+PUBLIC_API_URL=https://api.myapp.com
 DATABASE_POOL_SIZE=20
 ```
 
@@ -238,6 +307,10 @@ export function Dashboard() {
 
 Create `src/env.d.ts` to add type safety:
 
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
 ```typescript
 /// <reference types="vite/client" />
 
@@ -272,6 +345,44 @@ declare global {
 export {}
 ```
 
+# Rsbuild
+
+```typescript
+/// <reference types="@rsbuild/core/types" />
+
+interface ImportMetaEnv {
+  // Client-side environment variables
+  readonly PUBLIC_APP_NAME: string
+  readonly PUBLIC_API_URL: string
+  readonly PUBLIC_AUTH0_DOMAIN: string
+  readonly PUBLIC_AUTH0_CLIENT_ID: string
+  readonly PUBLIC_SENTRY_DSN?: string
+  readonly PUBLIC_ENABLE_NEW_DASHBOARD?: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+
+// Server-side environment variables
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      readonly DATABASE_URL: string
+      readonly REDIS_URL: string
+      readonly JWT_SECRET: string
+      readonly AUTH0_CLIENT_SECRET: string
+      readonly STRIPE_SECRET_KEY: string
+      readonly NODE_ENV: 'development' | 'production' | 'test'
+    }
+  }
+}
+
+export {}
+```
+
+<!-- ::end:tabs -->
+
 ### Runtime Validation
 
 Use Zod for runtime validation of environment variables:
@@ -327,10 +438,13 @@ DATABASE_URL=postgresql://...
 JWT_SECRET=super-secret-key
 STRIPE_SECRET_KEY=sk_live_...
 
-# ✅ Client-safe (VITE_ prefix)
+# ✅ Client-safe (Vite uses VITE_; Rsbuild uses PUBLIC_ by default)
 VITE_APP_NAME=My App
 VITE_API_URL=https://api.example.com
 VITE_SENTRY_DSN=https://...
+PUBLIC_APP_NAME=My App
+PUBLIC_API_URL=https://api.example.com
+PUBLIC_SENTRY_DSN=https://...
 ```
 
 ### 3. Validate Required Variables
@@ -339,7 +453,7 @@ VITE_SENTRY_DSN=https://...
 // src/config/validation.ts
 const requiredServerEnv = ['DATABASE_URL', 'JWT_SECRET'] as const
 
-const requiredClientEnv = ['VITE_APP_NAME', 'VITE_API_URL'] as const
+const requiredClientEnv = ['VITE_APP_NAME', 'VITE_API_URL'] as const // Use PUBLIC_ names for Rsbuild
 
 // Validate on server startup
 for (const key of requiredServerEnv) {
@@ -358,8 +472,8 @@ for (const key of requiredClientEnv) {
 
 ## Production Checklist
 
-- [ ] All sensitive variables are server-only (no `VITE_` prefix)
-- [ ] Client variables use `VITE_` prefix
+- [ ] All sensitive variables are server-only (no `VITE_` or `PUBLIC_` prefix)
+- [ ] Client variables use your bundler's public prefix (`VITE_` for Vite, `PUBLIC_` for Rsbuild)
 - [ ] `.env.local` is in `.gitignore`
 - [ ] Production environment variables are configured on hosting platform
 - [ ] Required environment variables are validated at startup
@@ -375,7 +489,7 @@ for (const key of requiredClientEnv) {
 
 **Solutions**:
 
-1. **Add correct prefix**: Use `VITE_` prefix (e.g. `VITE_MY_VARIABLE`)
+1. **Add correct prefix**: Use your bundler's public prefix (e.g. `VITE_MY_VARIABLE` for Vite or `PUBLIC_MY_VARIABLE` for Rsbuild)
 2. **Restart development server** after adding new variables
 3. **Check file location**: `.env` file must be in project root
 4. **Verify bundler configuration**: Ensure variables are properly injected
@@ -398,7 +512,7 @@ VITE_API_KEY=abc123 npm run build
 
 ### Runtime Client Environment Variables in Production
 
-**Problem**: If `VITE_` variables are replaced at bundle time only, how to make runtime variables available on the client?
+**Problem**: If public client variables are replaced at bundle time only, how to make runtime variables available on the client?
 
 **Solutions**:
 
@@ -406,7 +520,7 @@ Pass variables from the server down to the client:
 
 ```tsx
 const getRuntimeVar = createServerFn({ method: 'GET' }).handler(() => {
-  return process.env.MY_RUNTIME_VAR // notice `process.env` on the server, and no `VITE_` prefix
+  return process.env.MY_RUNTIME_VAR // notice `process.env` on the server, and no public prefix
 })
 
 export const Route = createFileRoute('/')({
@@ -435,13 +549,14 @@ function RouteComponent() {
 
 ### TypeScript Errors
 
-**Problem**: `Property 'VITE_MY_VAR' does not exist on type 'ImportMetaEnv'`
+**Problem**: `Property 'VITE_MY_VAR' does not exist on type 'ImportMetaEnv'` or `Property 'PUBLIC_MY_VAR' does not exist on type 'ImportMetaEnv'`
 
 **Solution**: Add to `src/env.d.ts`:
 
 ```typescript
 interface ImportMetaEnv {
   readonly VITE_MY_VAR: string
+  readonly PUBLIC_MY_VAR: string
 }
 ```
 
@@ -451,7 +566,7 @@ interface ImportMetaEnv {
 
 **Solutions**:
 
-1. Remove `VITE_` prefix from sensitive variables
+1. Remove `VITE_` or `PUBLIC_` prefix from sensitive variables
 2. Move sensitive operations to server functions
 3. Use build tools to verify no secrets in client bundle
 
@@ -487,8 +602,11 @@ With static replacement enabled (the default), the bundler sees `"production" ==
 
 The replacement is controlled by the `server.build.staticNodeEnv` option:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
 
@@ -506,10 +624,38 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginBabel } from '@rsbuild/plugin-babel'
+import { pluginSolid } from '@rsbuild/plugin-solid'
+import { tanstackStart } from '@tanstack/solid-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    pluginBabel({
+      include: /\.(?:jsx|tsx)$/,
+    }),
+    pluginSolid(),
+    tanstackStart({
+      server: {
+        build: {
+          // Replace process.env.NODE_ENV at build time (default: true)
+          staticNodeEnv: true,
+        },
+      },
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 The replacement value is determined in this order:
 
 1. `process.env.NODE_ENV` at build time (if set)
-2. Vite's `mode` (e.g., from `--mode staging`)
+2. The bundler's `mode` (e.g., from `--mode staging`)
 3. `"production"` (fallback)
 
 ### When to Disable Static Replacement
@@ -540,3 +686,4 @@ Common reasons to disable:
 - [Server Functions](./server-functions.md) - Learn more about server-side code
 - [Hosting](./hosting.md) - Platform-specific environment variable configuration
 - [Vite Environment Variables](https://vitejs.dev/guide/env-and-mode.html) - Official Vite documentation
+- [Rsbuild Environment Variables](https://rsbuild.dev/guide/advanced/env-vars) - Official Rsbuild documentation
diff --git a/docs/start/framework/solid/guide/error-boundaries.md b/docs/start/framework/solid/guide/error-boundaries.md
index bec1690ad5..8c07185c2d 100644
--- a/docs/start/framework/solid/guide/error-boundaries.md
+++ b/docs/start/framework/solid/guide/error-boundaries.md
@@ -1,52 +1,8 @@
 ---
-id: error-boundaries
-$title: Error Boundaries
+ref: docs/start/framework/react/guide/error-boundaries.md
+replace:
+  {
+    '@tanstack/react-router': '@tanstack/solid-router',
+    'React Start': 'Solid Start',
+  }
 ---
-
-## Error Boundaries (Solid Start)
-
-TanStack Start (Solid) uses TanStack Router's route-level error boundaries.
-
-- Set a default for all routes via the router
-- Override per-route with `errorComponent`
-
-### Configure a default
-
-```tsx
-// src/router.tsx
-import { createRouter, ErrorComponent } from '@tanstack/solid-router'
-import { routeTree } from './routeTree.gen'
-
-export function getRouter() {
-  const router = createRouter({
-    routeTree,
-    defaultErrorComponent: ({ error, reset }) => (
-      <ErrorComponent error={error} />
-    ),
-  })
-  return router
-}
-```
-
-### Per-route override
-
-```tsx
-// src/routes/posts.$postId.tsx
-import { createFileRoute, ErrorComponent } from '@tanstack/solid-router'
-import type { ErrorComponentProps } from '@tanstack/solid-router'
-
-function PostError(props: ErrorComponentProps) {
-  return <ErrorComponent error={props.error} />
-}
-
-export const Route = createFileRoute('/posts/$postId')({
-  component: PostComponent,
-  errorComponent: PostError,
-})
-```
-
-Notes:
-
-- `ErrorComponent` is a simple built-in UI you can replace.
-- Call `reset()` to retry rendering the route after fixing state.
-- Use `beforeLoad`/`loader` to throw errors that will be caught.
diff --git a/docs/start/framework/solid/guide/hosting.md b/docs/start/framework/solid/guide/hosting.md
index 8c7fcd6068..23f1d35cf4 100644
--- a/docs/start/framework/solid/guide/hosting.md
+++ b/docs/start/framework/solid/guide/hosting.md
@@ -1,438 +1,16 @@
 ---
-id: hosting
-title: Hosting
----
-
-Hosting is the process of deploying your application to the internet so that users can access it. This is a critical part of any web development project, ensuring your application is available to the world. TanStack Start is built on Vite, a powerful dev/build platform that allows us to make it possible to deploy your application to any hosting provider.
-
-## What should I use?
-
-TanStack Start is **designed to work with any hosting provider**, so if you already have a hosting provider in mind, you can deploy your application there using the full-stack APIs provided by TanStack Start.
-
-However, since hosting is one of the most crucial aspects of your application's performance, reliability, and scalability, we recommend using one of our **Official Hosting Partners**: [Cloudflare](https://www.cloudflare.com?utm_source=tanstack), [Netlify](https://www.netlify.com?utm_source=tanstack), or [Railway](https://railway.com?utm_source=tanstack).
-
-## Deployment
-
-Once you've chosen a deployment target, you can follow the deployment guidelines below to deploy your TanStack Start application to the hosting provider of your choice:
-
-- [`cloudflare-workers`](#cloudflare-workers--official-partner): Deploy to Cloudflare Workers
-- [`netlify`](#netlify--official-partner): Deploy to Netlify
-- [`railway`](#railway--official-partner): Deploy to Railway
-- [`nitro`](#nitro): Deploy using Nitro
-- [`vercel`](#vercel): Deploy to Vercel
-- [`node-server`](#nodejs--docker): Deploy to a Node.js server
-- [`bun`](#bun): Deploy to a Bun server
-- [`appwrite-sites`](#appwrite-sites): Deploy to Appwrite Sites
-- ... and more to come!
-
-### Cloudflare Workers ⭐ _Official Partner_
-
-<a href="https://www.cloudflare.com?utm_source=tanstack" alt="Cloudflare Logo">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/cloudflare-white.svg" width="280">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/cloudflare-black.svg" width="280">
-    <img alt="Cloudflare logo" src="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/cloudflare-black.svg" width="280">
-  </picture>
-</a>
-
-### Cloudflare Workers
-
-When deploying to Cloudflare Workers, you'll need to complete a few extra steps before your users can start using your app.
-
-1. Install `@cloudflare/vite-plugin`
-
-```bash
-pnpm install @cloudflare/vite-plugin -D
-```
-
-2. Update `vite.config.ts`
-
-Add the cloudflare plugin to your `vite.config.ts` file.
-
-```ts
-// vite.config.ts
-import { defineConfig } from 'vite'
-import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
-import { cloudflare } from '@cloudflare/vite-plugin'
-import viteSolid from 'vite-plugin-solid'
-
-export default defineConfig({
-  plugins: [
-    cloudflare({ viteEnvironment: { name: 'ssr' } }),
-    tanstackStart(),
-    viteSolid({ ssr: true }),
-  ],
-})
-```
-
-3. Install `wrangler`
-
-```bash
-pnpm add wrangler -D
-```
-
-4. Add a `wrangler.json` config file
-
-```json
-{
-  "$schema": "node_modules/wrangler/config-schema.json",
-  "name": "tanstack-start-app",
-  "compatibility_date": "2025-09-02",
-  "compatibility_flags": ["nodejs_compat"],
-  "main": "@tanstack/solid-start/server-entry",
-  "vars": {
-    "MY_VAR": "Hello from Cloudflare"
-  }
-}
-```
-
-5. Modify package.json script
-
-```json
-{
-  "scripts": {
-    "dev": "vite dev",
-    "build": "vite build && tsc --noEmit",
-    "start": "node .output/server/index.mjs",
-    // ============ 👇 add this line ============
-    "deploy": "npm run build && wrangler deploy"
+ref: docs/start/framework/react/guide/hosting.md
+replace:
+  {
+    '@tanstack/react-start': '@tanstack/solid-start',
+    '@vitejs/plugin-react': 'vite-plugin-solid',
+    'viteReact()': 'viteSolid({ ssr: true })',
+    'viteReact': 'viteSolid',
+    'examples/react/start-basic-cloudflare': 'examples/solid/start-basic-cloudflare',
+    'examples/react/start-bun': 'examples/solid/start-bun',
+    'React 19': 'Solid 1.x',
+    'React 18': 'an older Solid version',
+    '`react` and `react-dom` packages are set to version 19.0.0 or higher': '`solid-js` package is set to a supported version',
+    'bun install react@19 react-dom@19': 'bun install solid-js@latest',
   }
-}
-```
-
-6. Deploy
-
-```bash
-pnpm run deploy
-```
-
-Deploy your application to Cloudflare Workers using their one-click deployment process, and you're ready to go!
-
-### Netlify ⭐ _Official Partner_
-
-<a href="https://www.netlify.com?utm_source=tanstack" alt="Netlify Logo">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/netlify-dark.svg" width="280">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/netlify-light.svg" width="280">
-    <img alt="Netlify logo" src="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/netlify-light.svg" width="280">
-  </picture>
-</a>
-
-Install and add the [`@netlify/vite-plugin-tanstack-start`](https://www.npmjs.com/package/@netlify/vite-plugin-tanstack-start) plugin, which configures your build for Netlify deployment and provides full Netlify production platform emulation in local dev:
-
-```bash
-npm install --save-dev @netlify/vite-plugin-tanstack-start
-# or...
-pnpm add --save-dev @netlify/vite-plugin-tanstack-start
-# or yarn, bun, etc.
-```
-
-```ts
-// vite.config.ts
-import { defineConfig } from 'vite'
-import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
-import netlify from '@netlify/vite-plugin-tanstack-start' // ← add this
-import viteSolid from 'vite-plugin-solid'
-
-export default defineConfig({
-  plugins: [
-    tanstackStart(),
-    netlify(), // ← add this (anywhere in the array is fine)
-    viteSolid({ ssr: true }),
-  ],
-})
-```
-
-Finally, use [Netlify CLI](https://developers.netlify.com/cli/) to deploy your app:
-
-```bash
-npx netlify deploy
-```
-
-If this is a new Netlify project, you'll be prompted to initialize it and build settings will be automatically configured for you.
-
-For more detailed documentation, check out the full [TanStack Start on Netlify
-docs](https://docs.netlify.com/build/frameworks/framework-setup-guides/tanstack-start/).
-
-#### Manual configuration
-
-Alternatively, if you prefer manual configuration, you can add a `netlify.toml` file to your project root:
-
-```toml
-[build]
-  command = "vite build"
-  publish = "dist/client"
-[dev]
-  command = "vite dev"
-  port = 3000
-```
-
-Or you can set the above settings directly [in the Netlify
-app](https://docs.netlify.com/build/configure-builds/overview/#build-settings).
-
-#### Other deployment methods
-
-Netlify also supports other deployment methods, such as [continuous deployment from a git repo
-hosted on GitHub, GitLab, or
-others](https://docs.netlify.com/start/quickstarts/deploy-from-repository/), [starting from a
-template](https://docs.netlify.com/start/quickstarts/deploy-from-template/), [deploying or
-importing from an AI code generation
-tool](https://docs.netlify.com/start/quickstarts/deploy-from-ai-code-generation-tool/), and
-[more](https://docs.netlify.com/deploy/create-deploys/).
-
-### Railway ⭐ _Official Partner_
-
-<a href="https://railway.com?utm_source=tanstack" alt="Railway Logo">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/railway-dark.svg" width="280">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/railway-light.svg" width="280">
-    <img alt="Railway logo" src="https://raw.githubusercontent.com/tanstack/tanstack.com/main/src/images/railway-light.svg" width="280">
-  </picture>
-</a>
-
-Railway provides instant deployments with zero configuration. Follow the [`Nitro`](#nitro) deployment instructions, then deploy to Railway:
-
-1. Push your code to a GitHub repository
-
-2. Connect your repository to Railway at [railway.com](https://railway.com?utm_source=tanstack)
-
-3. Railway will automatically detect your build settings and deploy your application
-
-Railway automatically provides:
-
-- **Automatic deployments** on every push to your repository
-- **Built-in databases** (Postgres, MySQL, Redis, MongoDB)
-- **Preview environments** for pull requests
-- **Automatic HTTPS** and custom domains
-
-For more details, see [Railway's documentation](https://docs.railway.com).
-
-### Nitro
-
-[Nitro](https://nitro.build/) is an agnostic layer that allows you to deploy TanStack Start applications to [a wide range of hostings](https://nitro.build/deploy).
-
-**⚠️ The [`nitro/vite`](https://nitro.build/) plugin natively integrates with Vite Environments API as the underlying build tool for TanStack Start. It is still under active development and receives regular updates. Please report any issues you encounter with reproduction so they can be investigated.**
-
-1. Install `nitro`:
-
-```bash
-npm install nitro
-```
-
-2. Add the `nitro/vite` plugin to your `vite.config.ts` file:
-
-```tsx
-import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
-import { defineConfig } from 'vite'
-import { nitro } from 'nitro/vite'
-import viteSolid from 'vite-plugin-solid'
-
-export default defineConfig({
-  plugins: [tanstackStart(), nitro(), viteSolid({ ssr: true })],
-  nitro: {},
-})
-```
-
-#### Performance Tip: FastResponse
-
-If you're deploying to Node.js with Nitro (which uses [srvx](https://srvx.h3.dev/) under the hood), you can get a ~5% throughput improvement by replacing the global `Response` constructor with srvx's optimized `FastResponse`.
-
-First, install srvx:
-
-```bash
-pnpm install srvx
-```
-
-Then add this to your server entry point (`src/server.ts`):
-
-```ts
-import { FastResponse } from 'srvx'
-globalThis.Response = FastResponse
-```
-
-This works because srvx's `FastResponse` includes an optimized `_toNodeResponse()` path that avoids the overhead of the standard Web `Response` to Node.js conversion. This optimization only applies to Node.js deployments using Nitro/h3/srvx.
-
-### Vercel
-
-Follow the [`Nitro`](#nitro) deployment instructions.
-Deploy your application to Vercel using their one-click deployment process, and you're ready to go!
-
-### Node.js / Docker
-
-Follow the [`Nitro`](#nitro) deployment instructions. Use the `node` command to start your application from the server from the build output files.
-
-Ensure `build` and `start` npm scripts are present in your `package.json` file:
-
-```json
-    "build": "vite build",
-    "start": "node .output/server/index.mjs"
-```
-
-Then you can run the following command to build your application:
-
-```sh
-npm run build
-```
-
-You can start your application by running:
-
-```sh
-npm run start
-```
-
-### Bun
-
-Follow the [`Nitro`](#nitro) deployment instructions.
-Depending on how you invoke the build, you might need to set the `'bun'` preset in the Nitro configuration:
-
-```ts
-// vite.config.ts
-import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
-import { defineConfig } from 'vite'
-import viteSolid from 'vite-plugin-solid'
-import { nitro } from 'nitro/vite'
-
-export default defineConfig({
-  plugins: [
-    tanstackStart(),
-    nitro({ preset: 'bun' })
-    viteSolid({ssr: true}),
-  ],
-})
-```
-
-#### Production Server with Bun
-
-Alternatively, you can use a custom server implementation that leverages Bun's native APIs.
-
-We provide a reference implementation that demonstrates one approach to building a production-ready Bun server. This example uses Bun-native functions for optimal performance and includes features like intelligent asset preloading and memory management.
-
-**This is a starting point - feel free to adapt it to your needs or simplify it for your use case.**
-
-**What this example demonstrates:**
-
-- Serving static assets using Bun's native file handling
-- Hybrid loading strategy (preload small files, serve large files on-demand)
-- Optional features like ETag support and Gzip compression
-- Production-ready caching headers
-
-**Quick Setup:**
-
-1. Copy the [`server.ts`](https://github.com/tanstack/router/blob/main/examples/react/start-bun/server.ts) file from the example repository to your project root (or use it as inspiration for your own implementation)
-
-2. Build your application:
-
-   ```sh
-   bun run build
-   ```
-
-3. Start the server:
-
-   ```sh
-   bun run server.ts
-   ```
-
-**Configuration (Optional):**
-
-The reference server implementation includes several optional configuration options via environment variables. You can use these as-is, modify them, or remove features you don't need:
-
-```sh
-# Basic usage - just works out of the box
-bun run server.ts
-
-# Common configurations
-PORT=8080 bun run server.ts  # Custom port
-ASSET_PRELOAD_VERBOSE_LOGGING=true bun run server.ts  # See what's happening
-```
-
-**Available Environment Variables:**
-
-| Variable                         | Description                                        | Default                                                                       |
-| -------------------------------- | -------------------------------------------------- | ----------------------------------------------------------------------------- |
-| `PORT`                           | Server port                                        | `3000`                                                                        |
-| `ASSET_PRELOAD_MAX_SIZE`         | Maximum file size to preload into memory (bytes)   | `5242880` (5MB)                                                               |
-| `ASSET_PRELOAD_INCLUDE_PATTERNS` | Comma-separated glob patterns for files to include | All files                                                                     |
-| `ASSET_PRELOAD_EXCLUDE_PATTERNS` | Comma-separated glob patterns for files to exclude | None                                                                          |
-| `ASSET_PRELOAD_VERBOSE_LOGGING`  | Enable detailed logging                            | `false`                                                                       |
-| `ASSET_PRELOAD_ENABLE_ETAG`      | Enable ETag generation                             | `true`                                                                        |
-| `ASSET_PRELOAD_ENABLE_GZIP`      | Enable Gzip compression                            | `true`                                                                        |
-| `ASSET_PRELOAD_GZIP_MIN_SIZE`    | Minimum file size for Gzip (bytes)                 | `1024` (1KB)                                                                  |
-| `ASSET_PRELOAD_GZIP_MIME_TYPES`  | MIME types eligible for Gzip                       | `text/,application/javascript,application/json,application/xml,image/svg+xml` |
-
-<details>
-<summary>Advanced configuration examples</summary>
-
-```sh
-# Optimize for minimal memory usage
-ASSET_PRELOAD_MAX_SIZE=1048576 bun run server.ts
-
-# Preload only critical assets
-ASSET_PRELOAD_INCLUDE_PATTERNS="*.js,*.css" \
-ASSET_PRELOAD_EXCLUDE_PATTERNS="*.map,vendor-*" \
-bun run server.ts
-
-# Disable optional features
-ASSET_PRELOAD_ENABLE_ETAG=false \
-ASSET_PRELOAD_ENABLE_GZIP=false \
-bun run server.ts
-
-# Custom Gzip configuration
-ASSET_PRELOAD_GZIP_MIN_SIZE=2048 \
-ASSET_PRELOAD_GZIP_MIME_TYPES="text/,application/javascript,application/json" \
-bun run server.ts
-```
-
-</details>
-
-**Example Output:**
-
-```txt
-📦 Loading static assets from ./dist/client...
-   Max preload size: 5.00 MB
-
-📁 Preloaded into memory:
-   /assets/index-a1b2c3d4.js           45.23 kB │ gzip:  15.83 kB
-   /assets/index-e5f6g7h8.css           12.45 kB │ gzip:   4.36 kB
-
-💾 Served on-demand:
-   /assets/vendor-i9j0k1l2.js          245.67 kB │ gzip:  86.98 kB
-
-✅ Preloaded 2 files (57.68 KB) into memory
-🚀 Server running at http://localhost:3000
-```
-
-For a complete working example, check out the [TanStack Start + Bun example](https://github.com/TanStack/router/tree/main/examples/react/start-bun) in this repository.
-
-### Appwrite Sites
-
-When deploying to [Appwrite Sites](https://appwrite.io/products/sites), you'll need to complete a few steps:
-
-1. **Create a TanStack Start app** (or use an existing one)
-
-```bash
-npx @tanstack/cli@latest create --framework solid
-```
-
-2. **Push your project to a GitHub repository**
-
-Create a [GitHub repository](https://github.com/new) and push your code.
-
-3. **Create an Appwrite project**
-
-Head to [Appwrite Cloud](https://cloud.appwrite.io) and sign up if you haven't already, then create your first project.
-
-4. **Deploy your site**
-
-In your Appwrite project, navigate to the **Sites** page from the sidebar. Click on the **Create site**, select **Connect a repository**, connect your GitHub account and select your repository.
-
-1. Select the **production branch** and **root directory**
-2. Verify **TanStack Start** is selected as the framework
-3. Confirm the build settings:
-   - **Install command:** `npm install`
-   - **Build command:** `npm run build`
-   - **Output directory:** `./dist` (if you're using Nitro v2 or v3, this should be `./.output`)
-
-4. Add any required **environment variables**
-5. Click **Deploy**
-
-After successful deployment, click the **Visit site** button to see your deployed application.
+---
diff --git a/docs/start/framework/solid/guide/llmo.md b/docs/start/framework/solid/guide/llmo.md
index 770f32e8d7..09ee301810 100644
--- a/docs/start/framework/solid/guide/llmo.md
+++ b/docs/start/framework/solid/guide/llmo.md
@@ -1,364 +1,8 @@
 ---
-id: llmo
-title: LLM Optimization (LLMO)
+ref: docs/start/framework/react/guide/llmo.md
+replace:
+  {
+    '@tanstack/react-router': '@tanstack/solid-router',
+    '/framework/react/': '/framework/solid/',
+  }
 ---
-
-> [!NOTE]
-> Looking for traditional search engine optimization? See the [SEO guide](./seo).
-
-## What is LLMO?
-
-**LLM Optimization (LLMO)**, also known as **AI Optimization (AIO)** or **Generative Engine Optimization (GEO)**, is the practice of structuring your content and data so that AI systems—like ChatGPT, Claude, Perplexity, and other LLM-powered tools—can accurately understand, cite, and recommend your content.
-
-While traditional SEO focuses on ranking in search engine results pages, LLMO focuses on being accurately represented in AI-generated responses. As more users get information through AI assistants rather than traditional search, this is becoming increasingly important.
-
-## How LLMO Differs from SEO
-
-| Aspect             | SEO                         | LLMO                                 |
-| ------------------ | --------------------------- | ------------------------------------ |
-| **Goal**           | Rank in search results      | Be cited/recommended by AI           |
-| **Audience**       | Search engine crawlers      | LLM training & retrieval systems     |
-| **Key signals**    | Links, keywords, page speed | Structured data, clarity, authority  |
-| **Content format** | Optimized for snippets      | Optimized for extraction & synthesis |
-
-The good news: many LLMO best practices overlap with SEO. Clear structure, authoritative content, and good metadata help both.
-
-## What TanStack Start Provides
-
-TanStack Start's features that support LLMO:
-
-- **Server-Side Rendering** - Ensures AI crawlers see fully rendered content
-- **Structured Data** - JSON-LD support for machine-readable content
-- **Document Head Management** - Meta tags that AI systems can parse
-- **Server Routes** - Create machine-readable endpoints (APIs, feeds)
-
-## Structured Data for AI
-
-Structured data using schema.org vocabulary helps AI systems understand your content's meaning and context. This is perhaps the most important LLMO technique.
-
-### Article Schema
-
-```tsx
-// src/routes/posts/$postId.tsx
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/posts/$postId')({
-  loader: async ({ params }) => {
-    const post = await fetchPost(params.postId)
-    return { post }
-  },
-  head: ({ loaderData }) => ({
-    meta: [{ title: loaderData.post.title }],
-    scripts: [
-      {
-        type: 'application/ld+json',
-        children: JSON.stringify({
-          '@context': 'https://schema.org',
-          '@type': 'Article',
-          headline: loaderData.post.title,
-          description: loaderData.post.excerpt,
-          image: loaderData.post.coverImage,
-          author: {
-            '@type': 'Person',
-            name: loaderData.post.author.name,
-            url: loaderData.post.author.url,
-          },
-          publisher: {
-            '@type': 'Organization',
-            name: 'My Company',
-            logo: {
-              '@type': 'ImageObject',
-              url: 'https://myapp.com/logo.png',
-            },
-          },
-          datePublished: loaderData.post.publishedAt,
-          dateModified: loaderData.post.updatedAt,
-        }),
-      },
-    ],
-  }),
-  component: PostPage,
-})
-```
-
-### Product Schema
-
-For e-commerce, product schema helps AI assistants provide accurate product information:
-
-```tsx
-export const Route = createFileRoute('/products/$productId')({
-  loader: async ({ params }) => {
-    const product = await fetchProduct(params.productId)
-    return { product }
-  },
-  head: ({ loaderData }) => ({
-    meta: [{ title: loaderData.product.name }],
-    scripts: [
-      {
-        type: 'application/ld+json',
-        children: JSON.stringify({
-          '@context': 'https://schema.org',
-          '@type': 'Product',
-          name: loaderData.product.name,
-          description: loaderData.product.description,
-          image: loaderData.product.images,
-          brand: {
-            '@type': 'Brand',
-            name: loaderData.product.brand,
-          },
-          offers: {
-            '@type': 'Offer',
-            price: loaderData.product.price,
-            priceCurrency: 'USD',
-            availability: loaderData.product.inStock
-              ? 'https://schema.org/InStock'
-              : 'https://schema.org/OutOfStock',
-          },
-          aggregateRating: loaderData.product.rating
-            ? {
-                '@type': 'AggregateRating',
-                ratingValue: loaderData.product.rating,
-                reviewCount: loaderData.product.reviewCount,
-              }
-            : undefined,
-        }),
-      },
-    ],
-  }),
-  component: ProductPage,
-})
-```
-
-### Organization and Website Schema
-
-Add organization schema to your root route for site-wide context:
-
-```tsx
-// src/routes/__root.tsx
-export const Route = createRootRoute({
-  head: () => ({
-    meta: [
-      { charSet: 'utf-8' },
-      { name: 'viewport', content: 'width=device-width, initial-scale=1' },
-    ],
-    scripts: [
-      {
-        type: 'application/ld+json',
-        children: JSON.stringify({
-          '@context': 'https://schema.org',
-          '@type': 'WebSite',
-          name: 'My App',
-          url: 'https://myapp.com',
-          publisher: {
-            '@type': 'Organization',
-            name: 'My Company',
-            url: 'https://myapp.com',
-            logo: 'https://myapp.com/logo.png',
-            sameAs: [
-              'https://twitter.com/mycompany',
-              'https://github.com/mycompany',
-            ],
-          },
-        }),
-      },
-    ],
-  }),
-  component: RootComponent,
-})
-```
-
-### FAQ Schema
-
-FAQ schema is particularly effective for LLMO—AI systems often extract Q&A pairs:
-
-```tsx
-export const Route = createFileRoute('/faq')({
-  loader: async () => {
-    const faqs = await fetchFAQs()
-    return { faqs }
-  },
-  head: ({ loaderData }) => ({
-    meta: [{ title: 'Frequently Asked Questions' }],
-    scripts: [
-      {
-        type: 'application/ld+json',
-        children: JSON.stringify({
-          '@context': 'https://schema.org',
-          '@type': 'FAQPage',
-          mainEntity: loaderData.faqs.map((faq) => ({
-            '@type': 'Question',
-            name: faq.question,
-            acceptedAnswer: {
-              '@type': 'Answer',
-              text: faq.answer,
-            },
-          })),
-        }),
-      },
-    ],
-  }),
-  component: FAQPage,
-})
-```
-
-## Machine-Readable Endpoints
-
-Create API endpoints that AI systems and developers can consume directly:
-
-```ts
-// src/routes/api/products.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/api/products')({
-  server: {
-    handlers: {
-      GET: async ({ request }) => {
-        const url = new URL(request.url)
-        const category = url.searchParams.get('category')
-
-        const products = await fetchProducts({ category })
-
-        return Response.json({
-          '@context': 'https://schema.org',
-          '@type': 'ItemList',
-          itemListElement: products.map((product, index) => ({
-            '@type': 'ListItem',
-            position: index + 1,
-            item: {
-              '@type': 'Product',
-              name: product.name,
-              description: product.description,
-              url: `https://myapp.com/products/${product.id}`,
-            },
-          })),
-        })
-      },
-    },
-  },
-})
-```
-
-## Content Best Practices
-
-Beyond technical implementation, content structure matters for LLMO:
-
-### Clear, Factual Statements
-
-AI systems extract factual claims. Make your key information explicit:
-
-```tsx
-// Good: Clear, extractable facts
-function ProductDetails(props) {
-  return (
-    <article>
-      <h1>{props.product.name}</h1>
-      <p>
-        {props.product.name} is a {props.product.category} made by{' '}
-        {props.product.brand}. It costs ${props.product.price} and is available
-        in {props.product.colors.join(', ')}.
-      </p>
-    </article>
-  )
-}
-```
-
-### Hierarchical Structure
-
-Use proper heading hierarchy—AI systems use this to understand content organization:
-
-```tsx
-function DocumentationPage() {
-  return (
-    <article>
-      <h1>Getting Started with TanStack Start</h1>
-
-      <section>
-        <h2>Installation</h2>
-        <p>Install TanStack Start using npm...</p>
-
-        <h3>Prerequisites</h3>
-        <p>You'll need Node.js 18 or later...</p>
-      </section>
-
-      <section>
-        <h2>Configuration</h2>
-        <p>Configure your app in vite.config.ts...</p>
-      </section>
-    </article>
-  )
-}
-```
-
-### Authoritative Attribution
-
-Include author information and sources—AI systems consider authority signals:
-
-```tsx
-export const Route = createFileRoute('/posts/$postId')({
-  head: ({ loaderData }) => ({
-    meta: [
-      { title: loaderData.post.title },
-      { name: 'author', content: loaderData.post.author.name },
-      {
-        property: 'article:author',
-        content: loaderData.post.author.profileUrl,
-      },
-      {
-        property: 'article:published_time',
-        content: loaderData.post.publishedAt,
-      },
-    ],
-  }),
-  component: PostPage,
-})
-```
-
-## llms.txt
-
-Some sites are adopting a `llms.txt` file (similar to `robots.txt`) to provide guidance to AI systems:
-
-```ts
-// src/routes/llms[.]txt.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/llms.txt')({
-  server: {
-    handlers: {
-      GET: async () => {
-        const content = `# My App
-
-> My App is a platform for building modern web applications.
-
-## Documentation
-- Getting Started: https://myapp.com/docs/getting-started
-- API Reference: https://myapp.com/docs/api
-
-## Key Facts
-- Built with TanStack Start
-- Supports React and Solid
-- Full TypeScript support
-
-## Contact
-- Website: https://myapp.com
-- GitHub: https://github.com/mycompany/myapp
-`
-
-        return new Response(content, {
-          headers: {
-            'Content-Type': 'text/plain',
-          },
-        })
-      },
-    },
-  },
-})
-```
-
-## Monitoring AI Citations
-
-Unlike traditional SEO with established analytics, LLMO monitoring is still evolving. Consider:
-
-- **Test with AI assistants** - Ask ChatGPT, Claude, and Perplexity about your product/content
-- **Monitor brand mentions** - Track how AI systems describe your offerings
-- **Validate structured data** - Use [Google's Rich Results Test](https://search.google.com/test/rich-results) and [Schema.org Validator](https://validator.schema.org/)
-- **Check AI search engines** - Monitor presence in Perplexity, Bing Chat, and Google AI Overviews
diff --git a/docs/start/framework/solid/guide/seo.md b/docs/start/framework/solid/guide/seo.md
index 617c492182..abc1a356be 100644
--- a/docs/start/framework/solid/guide/seo.md
+++ b/docs/start/framework/solid/guide/seo.md
@@ -1,368 +1,9 @@
 ---
-id: seo
-title: SEO
+ref: docs/start/framework/react/guide/seo.md
+replace:
+  {
+    '@tanstack/react-router': '@tanstack/solid-router',
+    '@tanstack/react-start': '@tanstack/solid-start',
+    '/framework/react/': '/framework/solid/',
+  }
 ---
-
-> [!NOTE]
-> Looking to optimize for AI assistants and LLMs? See the [LLM Optimization (LLMO) guide](./llmo).
-
-## What is SEO, really?
-
-SEO (Search Engine Optimization) is often misunderstood as simply "showing up on Google" or a checkbox that a library can magically provide. In reality, SEO is a broad discipline focused on delivering valuable content that people need and making it easy for them to find.
-
-**Technical SEO** is a subset of SEO that developers interact with most directly. It involves using tools and APIs that satisfy the technical requirements of search engines, crawlers, rankers, and even LLMs. When someone says a framework has "good SEO support," they typically mean it provides the tools to make this process straightforward.
-
-TanStack Start provides comprehensive technical SEO capabilities, but you still need to put in the work to use them effectively.
-
-## What TanStack Start Provides
-
-TanStack Start gives you the building blocks for technical SEO:
-
-- **Server-Side Rendering (SSR)** - Ensures crawlers receive fully rendered HTML
-- **Static Prerendering** - Pre-generates pages for optimal performance and crawlability
-- **Document Head Management** - Full control over meta tags, titles, and structured data
-- **Performance** - Fast load times through code-splitting, streaming, and optimal bundling
-
-## Document Head Management
-
-The `head` property on routes is your primary tool for SEO. It allows you to set page titles, meta descriptions, Open Graph tags, and more.
-
-### Basic Meta Tags
-
-```tsx
-// src/routes/index.tsx
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/')({
-  head: () => ({
-    meta: [
-      { title: 'My App - Home' },
-      {
-        name: 'description',
-        content: 'Welcome to My App, a platform for...',
-      },
-    ],
-  }),
-  component: HomePage,
-})
-```
-
-### Dynamic Meta Tags
-
-Use loader data to generate dynamic meta tags for content pages:
-
-```tsx
-// src/routes/posts/$postId.tsx
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/posts/$postId')({
-  loader: async ({ params }) => {
-    const post = await fetchPost(params.postId)
-    return { post }
-  },
-  head: ({ loaderData }) => ({
-    meta: [
-      { title: loaderData.post.title },
-      { name: 'description', content: loaderData.post.excerpt },
-    ],
-  }),
-  component: PostPage,
-})
-```
-
-### Open Graph and Social Sharing
-
-Open Graph tags control how your pages appear when shared on social media:
-
-```tsx
-export const Route = createFileRoute('/posts/$postId')({
-  loader: async ({ params }) => {
-    const post = await fetchPost(params.postId)
-    return { post }
-  },
-  head: ({ loaderData }) => ({
-    meta: [
-      { title: loaderData.post.title },
-      { name: 'description', content: loaderData.post.excerpt },
-      // Open Graph
-      { property: 'og:title', content: loaderData.post.title },
-      { property: 'og:description', content: loaderData.post.excerpt },
-      { property: 'og:image', content: loaderData.post.coverImage },
-      { property: 'og:type', content: 'article' },
-      // Twitter Card
-      { name: 'twitter:card', content: 'summary_large_image' },
-      { name: 'twitter:title', content: loaderData.post.title },
-      { name: 'twitter:description', content: loaderData.post.excerpt },
-      { name: 'twitter:image', content: loaderData.post.coverImage },
-    ],
-  }),
-  component: PostPage,
-})
-```
-
-### Canonical URLs
-
-Canonical URLs help prevent duplicate content issues:
-
-```tsx
-export const Route = createFileRoute('/posts/$postId')({
-  head: ({ params }) => ({
-    links: [
-      {
-        rel: 'canonical',
-        href: `https://myapp.com/posts/${params.postId}`,
-      },
-    ],
-  }),
-  component: PostPage,
-})
-```
-
-## Structured Data (JSON-LD)
-
-Structured data helps search engines understand your content and can enable rich results in search:
-
-```tsx
-export const Route = createFileRoute('/posts/$postId')({
-  loader: async ({ params }) => {
-    const post = await fetchPost(params.postId)
-    return { post }
-  },
-  head: ({ loaderData }) => ({
-    meta: [{ title: loaderData.post.title }],
-    scripts: [
-      {
-        type: 'application/ld+json',
-        children: JSON.stringify({
-          '@context': 'https://schema.org',
-          '@type': 'Article',
-          headline: loaderData.post.title,
-          description: loaderData.post.excerpt,
-          image: loaderData.post.coverImage,
-          author: {
-            '@type': 'Person',
-            name: loaderData.post.author.name,
-          },
-          datePublished: loaderData.post.publishedAt,
-        }),
-      },
-    ],
-  }),
-  component: PostPage,
-})
-```
-
-## Server-Side Rendering
-
-SSR is enabled by default in TanStack Start. This ensures that search engine crawlers receive fully rendered HTML content, which is critical for SEO.
-
-```tsx
-// SSR is automatic - your pages are rendered on the server
-export const Route = createFileRoute('/about')({
-  component: AboutPage,
-})
-```
-
-For routes that don't need SSR, you can disable it selectively. However, be aware this may impact SEO for those pages:
-
-```tsx
-// Only disable SSR for pages that don't need SEO
-export const Route = createFileRoute('/dashboard')({
-  ssr: false, // Dashboard doesn't need to be indexed
-  component: DashboardPage,
-})
-```
-
-See the [Selective SSR guide](./selective-ssr) for more details.
-
-## Static Prerendering
-
-For content that doesn't change frequently, static prerendering generates HTML at build time for optimal performance:
-
-```ts
-// vite.config.ts
-import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
-
-export default defineConfig({
-  plugins: [
-    tanstackStart({
-      prerender: {
-        enabled: true,
-        crawlLinks: true,
-      },
-    }),
-  ],
-})
-```
-
-Prerendered pages load faster and are easily crawlable. See the [Static Prerendering guide](./static-prerendering) for configuration options.
-
-## Sitemaps
-
-### Built-in Sitemap Generation
-
-TanStack Start can automatically generate a sitemap when you enable prerendering with link crawling:
-
-```ts
-// vite.config.ts
-import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
-
-export default defineConfig({
-  plugins: [
-    tanstackStart({
-      prerender: {
-        enabled: true,
-        crawlLinks: true, // Discovers all linkable pages
-      },
-      sitemap: {
-        enabled: true,
-        host: 'https://myapp.com',
-      },
-    }),
-  ],
-})
-```
-
-The sitemap is generated at build time by crawling all discoverable pages from your routes. This is the recommended approach for static or mostly-static sites.
-
-### Static Sitemap
-
-For simple sites, you can also place a static `sitemap.xml` file in your `public` directory:
-
-```xml
-<!-- public/sitemap.xml -->
-<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  <url>
-    <loc>https://myapp.com/</loc>
-    <changefreq>daily</changefreq>
-    <priority>1.0</priority>
-  </url>
-  <url>
-    <loc>https://myapp.com/about</loc>
-    <changefreq>monthly</changefreq>
-  </url>
-</urlset>
-```
-
-This approach works well when your site structure is known and doesn't change often.
-
-### Dynamic Sitemap
-
-For sites with dynamic content that can't be discovered at build time, you can create a dynamic sitemap using a [server route](./server-routes). Consider caching this at your CDN for performance:
-
-```ts
-// src/routes/sitemap[.]xml.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/sitemap.xml')({
-  server: {
-    handlers: {
-      GET: async () => {
-        const posts = await fetchAllPosts()
-
-        const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  <url>
-    <loc>https://myapp.com/</loc>
-    <changefreq>daily</changefreq>
-    <priority>1.0</priority>
-  </url>
-  ${posts
-    .map(
-      (post) => `
-  <url>
-    <loc>https://myapp.com/posts/${post.id}</loc>
-    <lastmod>${post.updatedAt}</lastmod>
-    <changefreq>weekly</changefreq>
-  </url>`,
-    )
-    .join('')}
-</urlset>`
-
-        return new Response(sitemap, {
-          headers: {
-            'Content-Type': 'application/xml',
-          },
-        })
-      },
-    },
-  },
-})
-```
-
-## robots.txt
-
-### Static robots.txt
-
-The simplest approach is to place a static `robots.txt` file in your `public` directory:
-
-```txt
-// public/robots.txt
-User-agent: *
-Allow: /
-
-Sitemap: https://myapp.com/sitemap.xml
-```
-
-This file will be served automatically at `/robots.txt`. This is the most common approach for most sites.
-
-### Dynamic robots.txt
-
-For more complex scenarios (e.g., different rules per environment), you can create a robots.txt file using a [server route](./server-routes):
-
-```ts
-// src/routes/robots[.]txt.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/robots.txt')({
-  server: {
-    handlers: {
-      GET: async () => {
-        const robots = `User-agent: *
-Allow: /
-
-Sitemap: https://myapp.com/sitemap.xml`
-
-        return new Response(robots, {
-          headers: {
-            'Content-Type': 'text/plain',
-          },
-        })
-      },
-    },
-  },
-})
-```
-
-## Best Practices
-
-### Performance Matters
-
-Page speed is a ranking factor. TanStack Start helps with:
-
-- **Automatic code-splitting** - Only load the JavaScript needed for each page
-- **Streaming SSR** - Start sending HTML to the browser immediately
-- **Preloading** - Prefetch routes before users navigate to them
-
-### Content is King
-
-Technical SEO is just one piece of the puzzle. The most important factors are:
-
-- **Quality content** - Create content that provides value to users
-- **Clear site structure** - Organize your routes logically
-- **Descriptive URLs** - Use meaningful path segments (`/posts/my-great-article` vs `/posts/123`)
-- **Internal linking** - Help users and crawlers discover your content
-
-### Test Your Implementation
-
-Use these tools to verify your SEO implementation:
-
-- [Google Search Console](https://search.google.com/search-console) - Monitor indexing and search performance
-- [Google Rich Results Test](https://search.google.com/test/rich-results) - Validate structured data
-- [Open Graph Debugger](https://developers.facebook.com/tools/debug/) - Preview social sharing cards
-- Browser DevTools - Inspect rendered HTML and meta tags
-
-### Track Your Rankings
-
-To monitor your SEO performance over time, we recommend [Nozzle.io](https://nozzle.io?utm_source=tanstack). Nozzle provides enterprise-grade rank tracking that lets you monitor unlimited keywords, track SERP features, and analyze your visibility against competitors. Unlike traditional rank trackers, Nozzle stores the entire SERP for every query, giving you complete data to understand how your pages perform in search results.
diff --git a/docs/start/framework/solid/guide/server-routes.md b/docs/start/framework/solid/guide/server-routes.md
index 543eed07ea..c1d3ca2fbb 100644
--- a/docs/start/framework/solid/guide/server-routes.md
+++ b/docs/start/framework/solid/guide/server-routes.md
@@ -1,441 +1,10 @@
 ---
-id: server-routes
-title: Server Routes
+ref: docs/start/framework/react/guide/server-routes.md
+replace:
+  {
+    '@tanstack/react-router': '@tanstack/solid-router',
+    '@tanstack/react-start': '@tanstack/solid-start',
+    '/framework/react/': '/framework/solid/',
+    'useState': 'createSignal',
+  }
 ---
-
-Server routes are a powerful feature of TanStack Start that allow you to create server-side endpoints in your application and are useful for handling raw HTTP requests, form submissions, user authentication, and much more.
-
-Server routes can be defined in your `./src/routes` directory of your project **right alongside your TanStack Router routes** and are automatically handled by the TanStack Start server.
-
-Here's what a simple server route looks like:
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      GET: async ({ request }) => {
-        return new Response('Hello, World!')
-      },
-    },
-  },
-})
-```
-
-## Server Routes and App Routes
-
-Because server routes can be defined in the same directory as your app routes, you can even use the same file for both!
-
-```tsx
-// routes/hello.tsx
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      POST: async ({ request }) => {
-        const body = await request.json()
-        return new Response(JSON.stringify({ message: `Hello, ${body.name}!` }))
-      },
-    },
-  },
-  component: HelloComponent,
-})
-
-function HelloComponent() {
-  const [reply, setReply] = createSignal('')
-
-  return (
-    <div>
-      <button
-        onClick={() => {
-          fetch('/hello', {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ name: 'Tanner' }),
-          })
-            .then((res) => res.json())
-            .then((data) => setReply(data.message))
-        }}
-      >
-        Say Hello
-      </button>
-    </div>
-  )
-}
-```
-
-## File Route Conventions
-
-Server routes in TanStack Start follow the same file-based routing conventions as TanStack Router. This means that each file in your `routes` directory with a `server` property in the `createFileRoute` call will be treated as an API route. Here are a few examples:
-
-- `/routes/users.ts` will create an API route at `/users`
-- `/routes/users.index.ts` will **also** create an API route at `/users` (but will error if duplicate methods are defined)
-- `/routes/users/$id.ts` will create an API route at `/users/$id`
-- `/routes/users/$id/posts.ts` will create an API route at `/users/$id/posts`
-- `/routes/users.$id.posts.ts` will create an API route at `/users/$id/posts`
-- `/routes/api/file/$.ts` will create an API route at `/api/file/$`
-- `/routes/my-script[.]js.ts` will create an API route at `/my-script.js`
-
-## Unique Route Paths
-
-Each route can only have a single handler file associated with it. So, if you have a file named `routes/users.ts` which'd equal the request path of `/users`, you cannot have other files that'd also resolve to the same route. For example, the following files would all resolve to the same route and would error:
-
-- `/routes/users.index.ts`
-- `/routes/users.ts`
-- `/routes/users/index.ts`
-
-## Escaped Matching
-
-Just as with normal routes, server routes can match on escaped characters. For example, a file named `routes/users[.]json.ts` will create an API route at `/users.json`.
-
-## Pathless Layout Routes and Break-out Routes
-
-Because of the unified routing system, pathless layout routes and break-out routes are supported for similar functionality around server route middleware.
-
-- Pathless layout routes can be used to add middleware to a group of routes
-- Break-out routes can be used to "break out" of parent middleware
-
-## Nested Directories vs File-names
-
-In the examples above, you may have noticed that the file naming conventions are flexible and allow you to mix and match directories and file names. This is intentional and allows you to organize your Server routes in a way that makes sense for your application. You can read more about this in the [TanStack Router File-based Routing Guide](/router/latest/docs/framework/solid/routing/file-based-routing#s-or-s).
-
-## Handling Server Route Requests
-
-Server route requests are handled by Start automatically by default or by Start's `createStartHandler` in your custom `src/server.ts` entry point file.
-
-The start handler is responsible for matching an incoming request to a server route and executing the appropriate middleware and handler.
-
-If you need to customize the server handler, you can do so by creating a custom handler and then passing the event to the start handler. See [The Server Entry Point](./server-entry-point).
-
-## Defining a Server Route
-
-Server routes are created by adding a `server` property to your `createFileRoute` call. The `server` property contains:
-
-- `handlers` - Either an object mapping HTTP methods to handler functions, or a function that receives `createHandlers` for more advanced use cases
-- `middleware` - Optional route-level middleware array that applies to all handlers
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      GET: async ({ request }) => {
-        return new Response('Hello, World! from ' + request.url)
-      },
-    },
-  },
-})
-```
-
-## Defining Server Route Handlers
-
-You can define handlers in two ways:
-
-- **Simple handlers**: Provide handler functions directly in a handlers object
-- **Handlers with middleware**: Use the `createHandlers` function to define handlers with middleware
-
-### Simple handlers
-
-For simple use cases, you can provide handler functions directly in a handlers object.
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      GET: async ({ request }) => {
-        return new Response('Hello, World! from ' + request.url)
-      },
-    },
-  },
-})
-```
-
-### Adding middleware to specific handlers
-
-For more complex use cases, you can add middleware to specific handlers. This requires using the `createHandlers` function:
-
-```tsx
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: ({ createHandlers }) =>
-      createHandlers({
-        GET: {
-          middleware: [loggerMiddleware],
-          handler: async ({ request }) => {
-            return new Response('Hello, World! from ' + request.url)
-          },
-        },
-      }),
-  },
-})
-```
-
-### Adding middleware to all handlers
-
-You can also add middleware that applies to all handlers in a route by using the `middleware` property at the server level:
-
-```tsx
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    middleware: [authMiddleware, loggerMiddleware], // Applies to all handlers
-    handlers: {
-      GET: async ({ request }) => {
-        return new Response('Hello, World! from ' + request.url)
-      },
-      POST: async ({ request }) => {
-        const body = await request.json()
-        return new Response(`Hello, ${body.name}!`)
-      },
-    },
-  },
-})
-```
-
-### Combining route-level and handler-specific middleware
-
-You can combine both approaches - route-level middleware will run first, followed by handler-specific middleware:
-
-```tsx
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    middleware: [authMiddleware], // Runs first for all handlers
-    handlers: ({ createHandlers }) =>
-      createHandlers({
-        GET: async ({ request }) => {
-          return new Response('Hello, World!')
-        },
-        POST: {
-          middleware: [validationMiddleware], // Runs after authMiddleware, only for POST
-          handler: async ({ request }) => {
-            const body = await request.json()
-            return new Response(`Hello, ${body.name}!`)
-          },
-        },
-      }),
-  },
-})
-```
-
-## Handler Context
-
-Each HTTP method handler receives an object with the following properties:
-
-- `request`: The incoming request object. You can read more about the `Request` object in the [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Request).
-- `params`: An object containing the dynamic path parameters of the route. For example, if the route path is `/users/$id`, and the request is made to `/users/123`, then `params` will be `{ id: '123' }`. We'll cover dynamic path parameters and wildcard parameters later in this guide.
-- `context`: An object containing the context of the request. This is useful for passing data between middleware.
-
-Once you've processed the request, you can return a `Response` object or `Promise<Response>` or even use any of the helpers from `@tanstack/solid-start` to manipulate the response.
-
-## Dynamic Path Params
-
-Server routes support dynamic path parameters in the same way as TanStack Router. For example, a file named `routes/users/$id.ts` will create an API route at `/users/$id` that accepts a dynamic `id` parameter.
-
-```ts
-// routes/users/$id.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/users/$id')({
-  server: {
-    handlers: {
-      GET: async ({ params }) => {
-        const { id } = params
-        return new Response(`User ID: ${id}`)
-      },
-    },
-  },
-})
-
-// Visit /users/123 to see the response
-// User ID: 123
-```
-
-You can also have multiple dynamic path parameters in a single route. For example, a file named `routes/users/$id/posts/$postId.ts` will create an API route at `/users/$id/posts/$postId` that accepts two dynamic parameters.
-
-```ts
-// routes/users/$id/posts/$postId.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/users/$id/posts/$postId')({
-  server: {
-    handlers: {
-      GET: async ({ params }) => {
-        const { id, postId } = params
-        return new Response(`User ID: ${id}, Post ID: ${postId}`)
-      },
-    },
-  },
-})
-
-// Visit /users/123/posts/456 to see the response
-// User ID: 123, Post ID: 456
-```
-
-## Wildcard/Splat Param
-
-Server routes also support wildcard parameters at the end of the path, which are denoted by a `$` followed by nothing. For example, a file named `routes/file/$.ts` will create an API route at `/file/$` that accepts a wildcard parameter.
-
-```ts
-// routes/file/$.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/file/$')({
-  server: {
-    handlers: {
-      GET: async ({ params }) => {
-        const { _splat } = params
-        return new Response(`File: ${_splat}`)
-      },
-    },
-  },
-})
-
-// Visit /file/hello.txt to see the response
-// File: hello.txt
-```
-
-## Handling requests with a body
-
-To handle POST requests, you can add a `POST` handler to the route object. The handler will receive the request object as the first argument, and you can access the request body using the `request.json()` method.
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      POST: async ({ request }) => {
-        const body = await request.json()
-        return new Response(`Hello, ${body.name}!`)
-      },
-    },
-  },
-})
-
-// Send a POST request to /hello with a JSON body like { "name": "Tanner" }
-// Hello, Tanner!
-```
-
-This also applies to other HTTP methods like `PUT`, `PATCH`, and `DELETE`. You can add handlers for these methods in the route object and access the request body using the appropriate method.
-
-It's important to remember that the `request.json()` method returns a `Promise` that resolves to the parsed JSON body of the request. You need to `await` the result to access the body.
-
-This is a common pattern for handling POST requests in Server routes/ You can also use other methods like `request.text()` or `request.formData()` to access the body of the request.
-
-## Responding with JSON
-
-When returning JSON using a Response object, this is a common pattern:
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      GET: async ({ request }) => {
-        return new Response(JSON.stringify({ message: 'Hello, World!' }), {
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        })
-      },
-    },
-  },
-})
-
-// Visit /hello to see the response
-// {"message":"Hello, World!"}
-```
-
-## Using the `Response.json` helper function
-
-Or you can use the [`Response.json`](https://developer.mozilla.org/en-US/docs/Web/API/Response/json_static) helper function to automatically set the `Content-Type` header to `application/json` and serialize the JSON object for you.
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      GET: async ({ request }) => {
-        return Response.json({ message: 'Hello, World!' })
-      },
-    },
-  },
-})
-
-// Visit /hello to see the response
-// {"message":"Hello, World!"}
-```
-
-## Responding with a status code
-
-You can set the status code of the response by passing it as a property of the second argument to the `Response` constructor
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      GET: async ({ request, params }) => {
-        const user = await findUser(params.id)
-        if (!user) {
-          return new Response('User not found', {
-            status: 404,
-          })
-        }
-        return Response.json(user)
-      },
-    },
-  },
-})
-```
-
-In this example, we're returning a `404` status code if the user is not found. You can set any valid HTTP status code using this method.
-
-## Setting headers in the response
-
-Sometimes you may need to set headers in the response. You can do this by passing an object as the second argument to the `Response` constructor.
-
-```ts
-// routes/hello.ts
-import { createFileRoute } from '@tanstack/solid-router'
-export const Route = createFileRoute('/hello')({
-  server: {
-    handlers: {
-      GET: async ({ request }) => {
-        return new Response('Hello, World!', {
-          headers: {
-            'Content-Type': 'text/plain',
-          },
-        })
-      },
-    },
-  },
-})
-// Visit /hello to see the response
-// Hello, World!
-```
diff --git a/docs/start/framework/solid/guide/static-prerendering.md b/docs/start/framework/solid/guide/static-prerendering.md
index 5a98af5e6c..d530813896 100644
--- a/docs/start/framework/solid/guide/static-prerendering.md
+++ b/docs/start/framework/solid/guide/static-prerendering.md
@@ -7,11 +7,14 @@ Static prerendering is the process of generating static HTML files for your appl
 
 ## Prerendering
 
-TanStack Start can prerender your application to static HTML files, which can then be served to users without having to generate them on the fly. To prerender your application, you can add the `prerender` option to your tanstackStart configuration in `vite.config.ts` file:
+TanStack Start can prerender your application to static HTML files, which can then be served to users without having to generate them on the fly. To prerender your application, you can add the `prerender` option to your `tanstackStart` configuration:
 
-```ts
-// vite.config.ts
+<!-- ::start:tabs variant="bundler" -->
 
+# Vite
+
+```ts title="vite.config.ts"
+import { defineConfig } from 'vite'
 import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
 import viteSolid from 'vite-plugin-solid'
 
@@ -69,6 +72,73 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginBabel } from '@rsbuild/plugin-babel'
+import { pluginSolid } from '@rsbuild/plugin-solid'
+import { tanstackStart } from '@tanstack/solid-start/plugin/rsbuild'
+
+export default defineConfig({
+  plugins: [
+    pluginBabel({
+      include: /\.(?:jsx|tsx)$/,
+    }),
+    pluginSolid(),
+    tanstackStart({
+      prerender: {
+        // Enable prerendering
+        enabled: true,
+
+        // Enable if you need pages to be at `/page/index.html` instead of `/page.html`
+        autoSubfolderIndex: true,
+
+        // If disabled, only the root path or the paths defined in the pages config will be prerendered
+        autoStaticPathsDiscovery: true,
+
+        // How many prerender jobs to run at once
+        concurrency: 14,
+
+        // Whether to extract links from the HTML and prerender them also
+        crawlLinks: true,
+
+        // Filter function takes the page object and returns whether it should prerender
+        filter: ({ path }) => !path.startsWith('/do-not-render-me'),
+
+        // Number of times to retry a failed prerender job
+        retryCount: 2,
+
+        // Delay between retries in milliseconds
+        retryDelay: 1000,
+
+        // Maximum number of redirects to follow during prerendering
+        maxRedirects: 5,
+
+        // Fail if an error occurs during prerendering
+        failOnError: true,
+
+        // Callback when page is successfully rendered
+        onSuccess: ({ page }) => {
+          console.log(`Rendered ${page.path}!`)
+        },
+      },
+      // Optional configuration for specific pages
+      // Note: When autoStaticPathsDiscovery is enabled (default), discovered static
+      // routes will be merged with the pages specified below
+      pages: [
+        {
+          path: '/my-page',
+          prerender: { enabled: true, outputPath: '/my-page/index.html' },
+        },
+      ],
+    }),
+  ],
+})
+```
+
+<!-- ::end:tabs -->
+
 ## Automatic Static Route Discovery
 
 All static paths will be automatically discovered and seamlessly merged with the specified `pages` config
diff --git a/docs/start/framework/solid/guide/tailwind-integration.md b/docs/start/framework/solid/guide/tailwind-integration.md
index c805f049a7..54b88c4f88 100644
--- a/docs/start/framework/solid/guide/tailwind-integration.md
+++ b/docs/start/framework/solid/guide/tailwind-integration.md
@@ -9,22 +9,37 @@ This guide will help you use Tailwind CSS in your TanStack Start project.
 
 ## Tailwind CSS Version 4 (Latest)
 
-The latest version of Tailwind CSS is 4. And it has some configuration changes that majorly differ from Tailwind CSS Version 3. It's **easier and recommended** to set up Tailwind CSS Version 4 in a TanStack Start project, as TanStack Start uses Vite as its build tool.
+The latest version of Tailwind CSS is 4. And it has some configuration changes that majorly differ from Tailwind CSS Version 3. It's **easier and recommended** to set up Tailwind CSS Version 4 in a TanStack Start project with either Vite or Rsbuild.
 
 ### Install Tailwind CSS
 
-Install Tailwind CSS and it's Vite plugin.
+Install Tailwind CSS and the integration for your bundler.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
 
 ```shell
 npm install tailwindcss @tailwindcss/vite
 ```
 
-### Configure The Vite Plugin
+# Rsbuild
+
+```shell
+npm install tailwindcss @tailwindcss/postcss postcss
+```
+
+<!-- ::end:tabs -->
 
-Add the `@tailwindcss/vite` plugin to your Vite configuration.
+### Configure Tailwind CSS
 
-```ts
-// vite.config.ts
+Add Tailwind CSS to your bundler configuration.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+```ts title="vite.config.ts"
 import { defineConfig } from 'vite'
 import tsConfigPaths from 'vite-tsconfig-paths'
 import { tanstackStart } from '@tanstack/solid-start/plugin/vite'
@@ -44,6 +59,38 @@ export default defineConfig({
 })
 ```
 
+# Rsbuild
+
+```ts title="rsbuild.config.ts"
+import { defineConfig } from '@rsbuild/core'
+import { pluginBabel } from '@rsbuild/plugin-babel'
+import { pluginSolid } from '@rsbuild/plugin-solid'
+import { tanstackStart } from '@tanstack/solid-start/plugin/rsbuild'
+
+export default defineConfig({
+  server: {
+    port: 3000,
+  },
+  plugins: [
+    pluginBabel({
+      include: /\.(?:jsx|tsx)$/,
+    }),
+    pluginSolid(),
+    tanstackStart(),
+  ],
+})
+```
+
+```js title="postcss.config.mjs"
+export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+}
+```
+
+<!-- ::end:tabs -->
+
 ### Import Tailwind in your CSS file
 
 You need to create a CSS file to configure Tailwind CSS instead of the configuration file in version 4. You can do this by creating a `src/styles/app.css` file or name it whatever you want.
@@ -55,7 +102,13 @@ You need to create a CSS file to configure Tailwind CSS instead of the configura
 
 ## Import the CSS file in your `__root.tsx` file
 
-Import the CSS file in your `__root.tsx` file with the `?url` query and make sure to add the **triple slash** directive to the top of the file.
+Import the CSS file in your `__root.tsx` file.
+
+<!-- ::start:tabs variant="bundler" -->
+
+# Vite
+
+Use the `?url` query and make sure to add the **triple slash** directive to the top of the file.
 
 ```tsx
 // src/routes/__root.tsx
@@ -76,6 +129,28 @@ export const Route = createRootRoute({
 })
 ```
 
+# Rsbuild
+
+Use a side-effect import so Start can discover the generated stylesheet as a route asset.
+
+```tsx
+// src/routes/__root.tsx
+import { createRootRoute } from '@tanstack/solid-router'
+import '../styles/app.css'
+
+export const Route = createRootRoute({
+  head: () => ({
+    meta: [
+      // your meta tags and site config
+    ],
+    // other head config
+  }),
+  component: RootComponent,
+})
+```
+
+<!-- ::end:tabs -->
+
 ## Use Tailwind CSS anywhere in your project
 
 You can now use Tailwind CSS anywhere in your project.
diff --git a/docs/start/framework/solid/tutorial/fetching-external-api.md b/docs/start/framework/solid/tutorial/fetching-external-api.md
index c32a081399..ad776ae174 100644
--- a/docs/start/framework/solid/tutorial/fetching-external-api.md
+++ b/docs/start/framework/solid/tutorial/fetching-external-api.md
@@ -1,314 +1,12 @@
 ---
-id: fetching-external-api
-title: Calling an external API using TanStack Start
+ref: docs/start/framework/react/tutorial/fetching-external-api.md
+replace:
+  {
+    '@tanstack/react-router': '@tanstack/solid-router',
+    '@tanstack/react-start': '@tanstack/solid-start',
+    '/framework/react/': '/framework/solid/',
+    'className': 'class',
+    'React': 'Solid',
+    'react': 'solid',
+  }
 ---
-
-This guide demonstrates how to integrate external API calls into your TanStack Start application using route loaders. We will use TMDB API to fetch popular movies using TanStack Start and understand how to fetch data in a TanStack Start app.
-
-The complete code for this tutorial is available on [GitHub](https://github.com/shrutikapoor08/tanstack-start-movies).
-
-## What You'll Learn
-
-1. Setting up external API integration with TanStack Start
-1. Implementing route loaders for server-side data fetching
-1. Building responsive UI components with fetched data
-1. Handling loading states and error management
-
-## Prerequisites
-
-- Basic knowledge of Solid and TypeScript
-- Node.js (v18+) and `pnpm` installed on your machine
-- A TMDB API key (free at [themoviedb.org](https://www.themoviedb.org))
-
-## Nice to know
-
-- [TanStack Router](/router/latest/docs/framework/solid/routing/routing-concepts)
-
-## Setting up a TanStack Start Project
-
-First, let's create a new TanStack Start project:
-
-```bash
-pnpx create-start-app movie-discovery
-cd movie-discovery
-```
-
-When this script runs, it will ask you a few setup questions. You can either pick choices that work for you or just press enter to accept the defaults.
-
-Optionally, you can pass in a `--add-on` flag to get options such as Shadcn, Clerk, Convex, TanStack Query, etc.
-
-Once setup is complete, install dependencies and start the development server:
-
-```bash
-pnpm i
-pnpm dev
-```
-
-## Understanding the Project Structure
-
-At this point, the project structure should look like this:
-
-```text
-/movie-discovery
-├── src/
-│   ├── routes/
-│   │   ├── __root.tsx                    # Root layout
-│   │   ├── index.tsx                     # Home page
-│   │   └── fetch-movies.tsx              # Movie fetching route
-│   ├── types/
-│   │   └── movie.ts                      # Movie type definitions
-│   ├── router.tsx                        # Router configuration
-│   ├── routeTree.gen.ts                  # Generated route tree
-│   └── styles.css                        # Global styles
-├── public/                               # Static assets
-├── vite.config.ts                         # TanStack Start configuration
-├── package.json                          # Project dependencies
-└── tsconfig.json                         # TypeScript configuration
-
-```
-
-Once your project is set up, you can access your app at `localhost:3000`. You should see the default TanStack Start welcome page.
-
-## Step 1: Setup a `.env` file with TMDB_AUTH_TOKEN
-
-To fetch movies from the TMDB API, you need an authentication token. You can get this for free at themoviedb.org.
-
-First, let's set up environment variables for our API key. Create a `.env` file in your project root:
-
-```bash
-touch .env
-
-```
-
-Add your TMDB API token to this file:
-
-```dotenv
-TMDB_AUTH_TOKEN=your_bearer_token_here
-```
-
-_Important_: Make sure to add `.env` to your `.gitignore` file to keep your API keys secure.
-
-## Step 2: Defining Data Types
-
-Let's create TypeScript interfaces for our movie data. Create a new file at `src/types/movie.ts`:
-
-```ts
-// src/types/movie.ts
-export interface Movie {
-  id: number
-  title: string
-  overview: string
-  poster_path: string | null
-  backdrop_path: string | null
-  release_date: string
-  vote_average: number
-  popularity: number
-}
-
-export interface TMDBResponse {
-  page: number
-  results: Movie[]
-  total_pages: number
-  total_results: number
-}
-```
-
-## Step 3: Creating the Route with API Fetch Function
-
-To call the TMDB API, we're going to create a server function that fetches data on the server. This approach keeps our API credentials secure by never exposing them to the client.
-Let's create our route that fetches data from the TMDB API. Create a new file at `src/routes/fetch-movies.tsx`:
-
-```typescript
-// src/routes/fetch-movies.tsx
-import { createFileRoute } from '@tanstack/solid-router'
-import type { Movie, TMDBResponse } from '../types/movie'
-import { createServerFn } from '@tanstack/solid-start'
-
-const API_URL =
-  'https://api.themoviedb.org/3/discover/movie?include_adult=false&include_video=false&language=en-US&page=1&sort_by=popularity.desc'
-
-const fetchPopularMovies = createServerFn().handler(
-  async (): Promise<TMDBResponse> => {
-    const response = await fetch(API_URL, {
-      headers: {
-        accept: 'application/json',
-        Authorization: `Bearer ${process.env.TMDB_AUTH_TOKEN}`,
-      },
-    })
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch movies: ${response.statusText}`)
-    }
-
-    return response.json()
-  },
-)
-
-export const Route = createFileRoute('/fetch-movies')({
-  component: MoviesPage,
-  loader: async (): Promise<{ movies: Movie[]; error: string | null }> => {
-    try {
-      const moviesData = await fetchPopularMovies()
-      return { movies: moviesData.results, error: null }
-    } catch (error) {
-      console.error('Error fetching movies:', error)
-      return { movies: [], error: 'Failed to load movies' }
-    }
-  },
-})
-```
-
-_What's happening here:_
-
-- `createServerFn()` creates a server-only function that runs exclusively on the server, ensuring our `TMDB_AUTH_TOKEN` environment variable never gets exposed to the client. The server function makes an authenticated request to the TMDB API and returns the parsed JSON response.
-- The route loader runs on the server when a user visits /fetch-movies, calling our server function before the page renders
-- Error handling ensures the component always receives valid data structure - either the movies or an empty array with an error message
-- This pattern provides server-side rendering, automatic type safety, and secure API credential handling out of the box.
-
-## Step 4: Building the Movie Components
-
-Now let's create the components that will display our movie data. Add these components to the same `fetch-movies.tsx` file:
-
-```tsx
-// MovieCard component
-const MovieCard = ({ movie }: { movie: Movie }) => {
-  return (
-    <div
-      class="bg-white/10 border border-white/20 rounded-lg overflow-hidden backdrop-blur-sm shadow-md hover:shadow-xl transition-all duration-300 hover:scale-105"
-      aria-label={`Movie: ${movie.title}`}
-      role="group"
-    >
-      {movie.poster_path && (
-        <img
-          src={`https://image.tmdb.org/t/p/w500${movie.poster_path}`}
-          alt={movie.title}
-          class="w-full h-64 object-cover"
-        />
-      )}
-      <div class="p-4">
-        <MovieDetails movie={movie} />
-      </div>
-    </div>
-  )
-}
-
-// MovieDetails component
-const MovieDetails = ({ movie }: { movie: Movie }) => {
-  return (
-    <>
-      <h3 class="text-lg font-semibold mb-2 line-clamp-2">{movie.title}</h3>
-      <p class="text-sm text-gray-300 mb-3 line-clamp-3 h-10">
-        {movie.overview}
-      </p>
-      <div class="flex justify-between items-center text-xs text-gray-400">
-        <span>{movie.release_date}</span>
-        <span class="flex items-center">
-          ⭐️ {movie.vote_average.toFixed(1)}
-        </span>
-      </div>
-    </>
-  )
-}
-```
-
-## Step 5: Creating the MoviesPage Component
-
-Finally, let's create the main component that consumes the loader data:
-
-```tsx
-// MoviesPage component
-const MoviesPage = () => {
-  const { movies, error } = Route.useLoaderData()
-
-  return (
-    <div
-      class="flex items-center justify-center min-h-screen p-4 text-white"
-      style={{
-        backgroundColor: '#000',
-        backgroundImage:
-          'radial-gradient(ellipse 60% 60% at 0% 100%, #444 0%, #222 60%, #000 100%)',
-      }}
-      role="main"
-      aria-label="Popular Movies Section"
-    >
-      <div class="w-full max-w-6xl p-8 rounded-xl backdrop-blur-md bg-black/50 shadow-xl border-8 border-black/10">
-        <h1 class="text-3xl mb-6 font-bold text-center">Popular Movies</h1>
-
-        {error && (
-          <div
-            class="text-red-400 text-center mb-4 p-4 bg-red-900/20 rounded-lg"
-            role="alert"
-          >
-            {error}
-          </div>
-        )}
-
-        {movies.length > 0 ? (
-          <div
-            class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6"
-            aria-label="Movie List"
-          >
-            {movies.slice(0, 12).map((movie) => (
-              <MovieCard key={movie.id} movie={movie} />
-            ))}
-          </div>
-        ) : (
-          !error && (
-            <div class="text-center text-gray-400" role="status">
-              Loading movies...
-            </div>
-          )
-        )}
-      </div>
-    </div>
-  )
-}
-```
-
-### Understanding How It All Works Together
-
-```mermaid
-sequenceDiagram
-    autonumber
-    actor U as User
-    participant R as Router (TanStack Start)
-    participant L as Route Loader (/fetch-movies)
-    participant A as External API (TMDB)
-    participant V as MoviesPage (UI)
-
-    U->>R: Navigate to /fetch-movies
-    R->>L: Invoke loader (server-side)
-    L->>A: GET /movie/popular\nAuthorization: Bearer <TOKEN>
-    A-->>L: JSON TMDBResponse
-    alt response.ok
-        L-->>R: { movies, error: null }
-        R->>V: Render SSR with movies
-        V-->>U: HTML with movie grid
-    else non-ok / error
-        L-->>R: { movies: [], error: "Failed to load movies" }
-        R->>V: Render SSR with error alert
-        V-->>U: HTML with error state
-    end
-
-    note over L,V: Loader validates response.ok,\nreturns data or error for initial render
-```
-
-Let's break down how the different parts of our application work together:
-
-1. Route loader: When a user visits `/fetch-movies`, the loader function runs on the server
-2. API call: The loader calls `fetchPopularMovies()` which makes an HTTP request to TMDB
-3. Server-Side rendering: The data is fetched on the server reducing the load on the client side
-4. Component rendering: The `MoviesPage` component receives the data via `Route.useLoaderData()`
-5. Rendering UI: The movie cards are rendered with the fetched data
-
-## Step 6: Testing Your Application
-
-Now you can test your application by visiting [http://localhost:3000/fetch-movies](http://localhost:3000/fetch-movies). If everything is set up correctly, you should see a grid of popular movies with their posters, titles, and ratings. Your app should look like this:
-
-![Netflix style movie setup](https://res.cloudinary.com/dubc3wnbv/image/upload/v1756512946/Screenshot_2025-08-29_at_5.14.26_PM_iiex7o.png)
-
-## Conclusion
-
-You've successfully built a movie discovery app that integrates with an external API using TanStack Start. This tutorial demonstrated how to use route loaders for server-side data fetching and building UI components with external data.
-
-While fetching data at build time in TanStack Start is perfect for static content like blog posts or product pages, it's not ideal for interactive apps. If you need features like real-time updates, caching, or infinite scrolling, you'll want to use [TanStack Query](/query/latest) on the client side instead. TanStack Query makes it easy to handle dynamic data with built-in caching, background updates, and smooth user interactions. By using TanStack Start for static content and TanStack Query for interactive features, you get fast loading pages plus all the modern functionality users expect.
diff --git a/docs/start/framework/solid/tutorial/reading-writing-file.md b/docs/start/framework/solid/tutorial/reading-writing-file.md
index a6526fffa5..0dd171a787 100644
--- a/docs/start/framework/solid/tutorial/reading-writing-file.md
+++ b/docs/start/framework/solid/tutorial/reading-writing-file.md
@@ -74,7 +74,7 @@ At this point, the project structure should look like this -
 │   ├── routeTree.gen.ts                  # Generated route tree
 │   └── styles.css                        # Global styles
 ├── public/                               # Static assets
-├── vite.config.ts                        # TanStack Start configuration
+├── vite.config.ts or rsbuild.config.ts   # TanStack Start configuration
 ├── package.json                          # Project dependencies
 └── tsconfig.json                         # TypeScript configuration
 ```
