← 返回 Siami 首頁

Linear 為什麼這麼快?完整技術拆解:IndexedDB 本地資料庫、樂觀更新與毫秒級渲染

▲ 189 💬 110
Linear 為什麼這麼快?完整技術拆解:IndexedDB 本地資料庫、樂觀更新與毫秒級渲染

Dennis Brotzky · May 3, 2026

Linear 為什麼這麼快?完整技術拆解

在 Linear 裡更新一張 issue 只要幾毫秒。傳統 CRUD app 做同樣的事要 300ms。他們是怎麼做到的?其實沒有什麼神奇的銀彈。事實是,這個產品從一開始就蓋在對的基礎上,之後再用無數個小決策逐步打磨出來。本文的目標是帶你走過那些讓 Linear 感覺那麼快的技巧,幫助你也能套用到自己的專案上。

本文涵蓋範圍

  • 瀏覽器內的資料庫
  • 讓首次載入感覺瞬間完成
  • 同步引擎
  • 為速度而生的設計
  • 動畫

快速聲明:我從來沒在 Linear 上班,也從來沒看過他們的 code。我分享的一切來自個人經驗、研究他們的產品、讀他們的部落格、以及看他們的 conference talk。我單純熱愛打造 web app,也從 Linear 還在 beta 開始就是用戶。另外,本文主視覺圖片來自 Meg Wayne 為 Linear 拍攝的影片——他為 Linear 做的作品真的非常驚人。

瀏覽器內的資料庫

大部分 web app 都跑在同樣的迴圈裡:使用者點擊、瀏覽器發出 HTTP 請求、伺服器查資料庫後回傳、瀏覽器重繪。最終結果就是轉圈圈、skeleton 載入畫面、或 UI 凍結幾百毫秒——整個 app 都在等網路。

Linear 反轉了這個傳統關係。UI 實際讀取的資料庫在瀏覽器裡、在 IndexedDB 中。Mutation 先在本地套用,再非同步推到伺服器,然後伺服器透過 WebSocket 把差量廣播給其他 client。

我認為這是 Linear 性能最關鍵的一塊。當你的目標是打造快速的 web app,你最大的瓶頸就是網路。client 跟 server 之間任何資料傳輸都要花費數百毫秒。最佳解法是徹底消除網路請求——這正是 Linear 在做的事。

我會一直重複這句話:打造驚人 web app 的祕密是把所有網路請求藏在使用者看不到的地方。你愈能避免載入狀態,就愈快。

下面是一個範例,說明 Linear 的請求有多簡單:

// 傳統 web app 更新伺服器
async function updateIssue({ issue }) {
  showSpinner();
  const response = await fetch(`/api/issues/${issue.id}`, {
    method: "PATCH",
    body: JSON.stringify({ title: issue.title }),
  });
  const updated = await response.json();
  setIssue(updated)
  hideSpinner();
}

// vs Linear
issue.title = "Faster app launch";
issue.save();

第一行 issue.title = "Faster app launch" 更新了一個 in-memory datastore(Linear 用的是 MobX observable)。第二行 issue.save() 把一筆交易排進佇列,由他們的同步引擎批次送到伺服器。重點是 UI 是同步從本地 in-memory 的更新重新渲染的。沒有 spinner,因為根本沒有要等的東西——資料在背景同步。這就是把瀏覽器當作每位使用者專屬資料庫的魔法。

Linear 共同創辦人 Tuomas 在 2024 年的 conference 上說:「我寫的第一行程式碼就是同步引擎,這在新創公司裡其實很不常見。」從第一天起,Linear 就很清楚要走這條路,以及要付出什麼代價。

我知道大部分人不會為了讓 app 變快就自己刻一套同步引擎,也不需要。對大多數情境來說,像 Tanstack Query 或 SWR 這類函式庫,靠著樂觀更新就能逼近 Linear 的效果。大部分 web app 感覺慢,是因為 UI 在等每個網路請求完成才更新狀態。對多數使用情境來說,網路請求其實會成功,所以你就該利用這點,樂觀地先更新狀態:

// 用 SWR 做樂觀 mutation
mutate(
  `/api/issues/${issue.id}`,
  { ...issue, title: "Faster app launch" },
  false
);

// vs Linear
issue.title = "Faster app launch";
issue.save();

核心概念很簡單:UI 的反應速度不該依賴網路延遲。使用者對「快」的感知來自介面反應多快,不是伺服器回得多快。

樂觀請求是最高槓桿的改善之一:

  • 消除多餘的 spinner
  • 立即更新狀態
  • 在背景驗證
  • 失敗才 rollback

Linear 的整套基礎就是建立在這個原則上,也因此 app 用起來像原生 app 一樣快。

一窺 Linear 的技術堆疊

Linear 用的是你能找到最簡單的技術堆疊:React、TypeScript、MobX、PostgreSQL、CDN。沒有 edge 資料庫、沒有 React Server Components、也沒有任何花俏的框架。

Frontend
  React + react-dom               (UI runtime)
  MobX                            (observable graph, granular re-renders)
  TypeScript                      (single language end-to-end)
  Rolldown-Vite + plugin-react-oxc(mid-2025; previously Rollup; previously Parcel)
  ProseMirror + y-prosemirror     (rich text editor; Yjs CRDT for live collab)
  Radix UI primitives             (popovers, menus, focus traps)
  Emotion + StyleX                (Emotion runtime + StyleX compiled to atomic CSS)
  Comlink                         (Worker RPC)
  idb                             (IndexedDB wrapper backing the local-first store)
  graphql-request                 (GraphQL transport to the sync server)
  Sentry                          (error monitoring)
  Inter Variable                  (single woff2, font-display: swap)

Backend
  Node.js + TypeScript            (single language for all server code)
  PostgreSQL on Cloud SQL         (issues table partitioned 300 ways)
  Memorystore Redis               (event bus + cache + sync cursors)
  turbopuffer                     (similar-issue detection, vector db)
  Kubernetes on GCP               (one workload per concern)
  Cloudflare Workers              (multi-region edge proxy)

Other clients
  Desktop: Electron               (same web JS, native chrome)
  Mobile:  Swift (iOS) + Kotlin   (a separate full reimplementation)

Marketing
  Next.js                         (static)
  styled-components
  Inline SVG sprite

對我來說最醒目的一點是他們堅持純 client-side rendering 的決定。CSR 常因為初次載入慢而挨罵,但只要架構跟設計正確,它可以感覺是瞬間的。

我也很喜歡它帶來的簡潔。把 app 完全 client-side 化,創造出乾淨得多的心智模型,也拿掉了 server-rendered app 帶來的複雜性。你不用一直糾結「我現在是在 server 還是 client」、「window 物件能不能用」、「我有沒有設對的 cache header」。簡單本身就是一種美,它強加的限制反而是力量。

那 Linear 是怎麼讓 client-side rendered app 感覺瞬間的呢?

讓首次載入感覺瞬間完成

有一件事我特別執著:首次載入。Linear 顯然也是。對生產力工具來說,使用者能「真的開始工作」前要等的那段時間,是最重要的細節之一。沒人想等多秒才看到一個新分頁打開。

首先你必須理解初次載入慢在哪。對 client-side app 來說,你要請求 index.html,然後它會請求所有 JS 跟 CSS,跑一輪認證,最後打幾個 API 請求才把 app 顯示出來。

Linear 的 bundler 演化史:Parcel → Rollup → Vite → Rolldown

讓 app 感覺快的第一步,在 runtime 之前就發生了——它從 build time 開始。記住,網路是瓶頸,所以把要送出的 JS 跟 CSS 壓到最少,是快速載入時間的關鍵。

就我所能查到的,Linear 已經重寫了四次 build pipeline:Parcel → Rollup → Vite → Rolldown。每次遷移都為了同一個目標:減少 JS 跟 CSS 的體積、並改善開發者體驗。

從他們自己部落格發的數字看:

  • 送出的程式碼少 50%
  • 壓縮後再小 30%
  • 冷快取頁面載入快 10~30%
  • 啟動 issue 頁面的 first-paint 下降 59%(Safari)
  • 記憶體用量下降 70~80%

這些主要來自幾個方向:只支援現代瀏覽器、更好的 dead-code elimination、激進的 code splitting。放棄舊瀏覽器支援是最大贏家(沒有 polyfill、沒有 ES5 transpile、沒有 nomodule fallback),但 dead-code 跟 chunking 的功夫也同樣關鍵。

即使做了這麼多優化,Linear 還是會送出相當大量的程式碼:大約 21MB 的 minified JavaScript。差別在於它被激進地切分成幾百個 route-level 的 chunk,按需載入:

// vite.config.ts(依觀察到的 chunk 圖重建)
export default defineConfig({
  plugins: [react()],
  build: {
    target: "esnext",            // 不支援舊語法、沒有 polyfill
    cssMinify: "lightningcss",
    modulePreload: { polyfill: false },
    rollupOptions: {
      output: {
        // 每個 > ~3KB 的 npm 套件切一個 chunk。
        // cache 失效變成 per-library,而不是 per-app-revision。
        manualChunks(id) {
          if (id.includes("node_modules")) {
            const pkg = id.match(/node_modules\/([^/]+)/)?.[1];
            if (pkg) return `vendor-${pkg}`;
          }
        },
      },
    },
  },
});

教訓不是要選哪個 bundler,而是拋棄舊瀏覽器、走向原生 ESM、瘋狂做 code splitting 的重要性。每一小步都不大,但疊起來之後,Linear 的 first-load JavaScript 砍了大約一半、build 時間降了一個數量級。

所以,讓初次載入時間變快的第一個祕密就是:縮減渲染給使用者看的東西所需的 JS 跟 CSS 體積。

初次載入後的預載

一旦你把 JS 切到盡可能小的 chunk,就可以開始在背景做事了。

但等等,切成幾百個 chunk 會帶來新問題:每個 chunk 會 import 其他 chunk,而瀏覽器要解析 entry script 才知道它們是什麼。沒人幫忙的話,載入時序會變成瀑布:抓 entry → 解析它 → 抓它的 imports → 解析它們 → 抓它們的 imports。每多一層就多一次網路 round-trip,這是你最想避免的。

Linear 的做法是:在任何 JS 跑起來之前,瀏覽器就看到完整清單,把請求全部平行發出去。等 entry script 跑到第一個 import 的時候,那些 chunk 早就在 cache 裡了。

這是他們 index.html <head /> 裡的樣子:

<script type=module crossorigin
  src="https://static.linear.app/client/assets/html.2_JBQs3Q.js"></script>
<link rel=modulepreload crossorigin
  href="https://static.linear.app/client/assets/vendor-mobx.Crhy2qQc.js">
<link rel=modulepreload crossorigin
  href="https://static.linear.app/client/assets/SyncWebSocket.Djw6l_Op.js">
<link rel=modulepreload crossorigin
  href="https://static.linear.app/client/assets/DatabaseManager.DKssGAN8.js">
<!-- ...還有很多 -->

每個 preload 的 crossorigin 屬性都跟 entry script 的 crossorigin 對齊,這樣瀏覽器會重用 cache 裡的那次抓取,不會把 preload 跟 import 當成兩個不同資源。跟字型 preload 同一招,只是套用到所有 critical path 上的 chunk。

冷載入的時序從序列瀑布塌縮成一個平行的批次。網路該做的工還是要做,但一次做完。這個技巧的精妙之處在於,使用者第一次打開登入頁的這段時間,你就能在背景做完所有事。幾秒內,整個 app 已經在 cache 裡,之後打開就是瞬間。

理解人們會怎麼用你的 app 極其重要。一旦有了這個理解,你就可以開始利用它——像 Linear 一樣在背景預載 script。

用 service worker 達到更快的速度與離線能力

剩下的 Linear——使用者還沒造訪過的 view 的 route-level chunk——會被 service worker 在背景快取。worker 把一份 precache manifest 燒進原始碼:大約 1,200 個雜湊後的資源,涵蓋 route chunk、圖示、字型,並在首次載入後 lazy 抓下來。在登入畫面打開的幾秒內,整個 app 就坐在 cache 裡了。

這帶來兩個好處。後續的導航完全跳過網路——service worker 直接從它的 cache 回答,連 HTTP cache 都不經過。而且網路不通的時候 app 還能繼續用。搭配 local-first 的同步引擎(已經把使用者資料放在 IndexedDB 裡),Linear 在離線時完全可用。你可以讀 issue、開新 issue、改標題跟描述、改狀態。所有操作都排在 local transaction store,連線回來時一次送出。

Modulepreload 處理 app 立刻需要的東西,平行抓取,讓瀏覽器永遠不會被序列 import chain 擋住。Service worker 處理 app 接下來會用到的東西。

所以,要讓載入變快,Linear 的步驟是:儘量刪掉程式碼 → 切成小塊 → 在背景預先 cache。同樣的,這一切的目標都是讓網路請求愈快愈好——最好完全消滅。

Vendor bundle 構成

我覺得有趣的是,Linear 用的每個套件都有自己的 chunk,獨立快取。傳統的 vendor.js 任何相依套件一升級,整個依賴圖就失效。Linear 的切分把 vendor 快取從單一大檔變成細粒度。升級單一相依套件只會讓那一個 chunk 失效,其他全部留在 cache。

這聽起來像顯而易見的事,卻也是確保快速載入時間的另一個細節。

載入巨大的字型檔

字型載入是很多 app 搞砸的環節之一。失敗的徵兆都很明顯:有半秒看不到字、字型切換時版面位移、預載跟實際請求沒對到所以重抓兩次。Linear 的設定避開了這三個:

<!-- in <head> of index.html -->
<link rel="preload"
      href="https://static.linear.app/fonts/InterVariable.woff2?v=4.1"
      as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preconnect" href="https://static.linear.app" crossorigin>
@font-face {
  font-family: "Inter Variable";
  font-weight: 100 900;
  font-display: swap;
  src: url(https://static.linear.app/fonts/InterVariable.woff2?v=4.1)
       format("woff2");
}
/* Italic 跟 Berkeley Mono 也是同樣模式,各一個 woff2。 */

可變字型(Variable font) 用單一 woff2 涵蓋 100–900 的整個 weight 範圍,省掉每個 weight 都要發請求的成本。font-display: swap 立刻用 fallback 渲染,等到 Inter 載入完才換過去。最容易漏掉的小細節:preload tag 上的 crossorigin="anonymous"。少了它,瀏覽器先預載一次字型,CSS 後面引用時又再抓一次,因為兩個請求的 CORS 模式不同。preload 加上 crossorigin 後,瀏覽器會重用 cache 裡的那次。

這些看起來都簡單,但我永遠驚訝於有多少 app 把字型載入搞錯。Linear 是把每個細節都想透、確保字型載入又快又準的絕佳範例。

Inlined app shell

讓首次載入感覺快的另一個關鍵技巧:在 <head/> 裡 inline 剛好足夠的 CSS 來繪製 loading 狀態,不抓任何外部 stylesheet。記住,網路是瓶頸,也是你為了讓 app 感覺快必須一直對抗的對手。在這個 case,Linear 直接 inline 顯示 app shell 所需的 critical CSS,消滅了一個網路請求。

<style>
  :root {
    --bg-color: #f5f5f5;
    --bg-base-color: #fcfcfd;
    --bg-border-color: #e0e0e0;
    --sidebar-width: 244px;
  }
  html { background: var(--bg-color); height: 100%; }
  body { font-family: "Inter Variable", Arial, Helvetica, sans-serif; }

  #appBorders {
    border: 1px solid var(--bg-border-color);
    background: var(--bg-base-color);
    margin: 8px 8px 8px var(--sidebar-width);
    border-radius: 12px;
  }

  #logo { transform: translateZ(0); }

  @keyframes logoBackgroundPulse {
    0%   { opacity: 0; transform: scale(0.8); }
    70%  { opacity: 1; }
    100% { opacity: 0; transform: scale(1.0); }
  }
</style>
<script>performance.mark("appStart");</script>

除了 CSS 之外,還有一堆 inline 的 JavaScript 是初次體驗所必需的:

<script>
// Electron context — 讓 CSS 能根據 native chrome 分支判斷。
if (navigator.userAgent.includes("Electron") && navigator.userAgent.includes("Linear")) document.documentElement.classList.add("electron");

// 沒有 local store → 沒有 workspace 資料 → 渲染登入頁。
if (localStorage.getItem("ApplicationStore") === null) document.documentElement.classList.add("logged-out");

// 在 paint 之前還原上次的 shell 設定(sidebar 底色、寬度、深色模式)。
const c = JSON.parse(localStorage.getItem("splashScreenConfig") || "{}");
if (c.bgSidebarColor) document.documentElement.style.setProperty("--bg-sidebar-color", c.bgSidebarColor);
if (c.sidebarWidth) document.documentElement.style.setProperty("--sidebar-width", c.sidebarWidth + "px");
if (c.darkMode) document.documentElement.classList.add("dark");

// 在桌面 app 開連結時把 sidebar 縮到極細。
if (JSON.parse(localStorage.getItem("userSettings") || "{}").openLinksInDesktop) document.documentElement.style.setProperty("--sidebar-width", "8px");

</script>

在任何 bundle 解析之前,index.html 裡的 JavaScript 讀取 localStorage.splashScreenConfig、合併 sessionStorage 上的覆寫,然後直接把使用者記得的 shell 設定套用到 document.documentElement.style:sidebar 背景色、底色、邊框色、sidebar 寬度、agent toolbar 高度。它偵測色彩偏好與 Electron 環境。它檢查 localStorage.ApplicationStore 存不存在,如果沒有,就加上一個 logged-out class 切換成登入頁 layout。

等第一批 JavaScript bundle 從網路回來時,loading 畫面早已根據使用者是否登入,正確地上了色、設了尺寸、擺了位置。

這給人一種「app 在你按下 Enter 那一刻就準備好了」的感覺。要做到這件事沒有比把 initial app shell 直接塞進 index.html 回應更快的辦法了。

先渲染,再認證

認證是另一個大部分 app 會把性能預算花光的環節。傳統流程:抓 HTML、載入 bundle、驗 session、抓使用者、抓 workspace,然後才渲染。一到三秒後使用者才看到東西。

Linear 用對待 mutation 的方式對待認證:先假設一切順利,再在背景驗證。這大概是我最喜歡的架構一塊,因為它讓 app 在載入後幾乎能立刻渲染完整體驗。

大部分 CRUD app 把真正的 session 放在 HttpOnly cookie,再加一個 JS 可讀的 cookie 或 /me 請求,讓前端在啟動時能判斷使用者是否登入。Linear 走更簡單的路:不維護平行的 auth 訊號,inline boot script 只檢查 localStorage.ApplicationStore 存不存在:

if (localStorage.getItem("ApplicationStore") === null) {
  document.documentElement.classList.add("logged-out");
}

如果有,代表這位使用者之前在這個瀏覽器用過 Linear,這也代表他的 workspace 早就躺在 IndexedDB 裡了——呼應前面「資料庫在瀏覽器」的章節。如果沒有,那也沒什麼好渲染的,shell 就切到登入 layout,由登入流程接手。

Linear 的初始流程不是「你有沒有有效的 session」,而是「我們有沒有東西可以給你看」。真正的 session token 放在 cookie。bundle 不耍小聰明,就只是先渲染手邊的東西,把下一個請求(WebSocket 握手、sync delta、任何 HTTP 呼叫)當成真正會失敗的地方——如果 session 過期了就在那邊收到 401,然後 client 導去登入頁。

整個模式跟架構其餘部分一致:client 信任本地的東西,server 是正確性的唯一來源,兩邊非同步對帳。就像 mutation 一樣。就像他們的同步引擎一樣。

這大概是我最喜歡的 Linear 細節之一,希望更多 app 也學著這樣做。對認證,先假設一切順利、不行再退回。如果有資料可以顯示,那就顯示它!並善用瀏覽器的 datastore 立刻渲染。

同步引擎

Linear 為什麼快,大部分原因都來自同一個決定:伺服器是 sync target,不是 UI 的真理來源。他們同步引擎的內部早被徹底反向工程過了,Tuomas 也在多場 talk 中談過架構。我不重述。我想做的是點出真正產生速度的三個支柱,因為速度是它們組合起來的結果,不是任何單一項的特性。

1. 資料早就在那裡

App 啟動時,它不是從伺服器抓 workspace,而是從 IndexedDB 把資料注水到 in-memory 的 MobX 物件池,UI 的每個查詢都先打這個池。沒有「載入 issue 中」這種狀態,因為 issue 早就在使用者電腦上了。

我覺得有趣的是,隨著規模擴大,他們在同步引擎裡用跟 JS bundle 一樣的 chunking 原理切分資料。不是一次全抓:兩張最重的表——Issue 跟 Comment——按需 lazy-hydrate。這是資料層級的 code splitting,也是引擎能 scale 的原因:啟動成本跟 workspace 結構走,不是跟 workspace 大小走。一萬張 issue 的 workspace 開起來跟一百張的一樣快。

點進一個 project,issue 就在那。篩選負責人,索引已經建好。沒有要抓的東西,因為沒有缺的東西——它要不是立即從你的瀏覽器載入、要不就是短暫之後從某個 codesplit 的 lazy chunk 出來。

2. Mutation 不等網路

當你改一張 issue 的狀態,三件事幾乎同時發生:MobX observable 更新,UI 反映變動;mutation 寫進 IndexedDB 裡一條 durable 的交易佇列;它被排進送往伺服器的佇列。網路還沒被動到。

使用者從來不用等著看到自己的變更。重試、rollback、跨重啟的持久性,全在背景。如果伺服器拒絕,observable 退回,UI 會短暫閃一下,但實務上幾乎不會發生,因為大多數無效的 mutation 在交易建立前就被擋下了。

我一直在講:網路是敵人,你必須竭盡所能避開它。Linear 的流程從 local mutation 開始,把伺服器當成確認步驟,不是許可步驟。

3. 一個差量,一個 cell

當伺服器確認一筆 mutation(你的或別人的),這個改動會以一個描述變動內容的小型 JSON envelope 形式回來。client 套用它的方式是寫進對應的 MobX observable。

因為 Linear 裡每張 model 的每個屬性都是各自的 observable,而每個讀取它的 component 都用 observer() 包起來,MobX 知道哪些 component 依賴哪些欄位。一個只更新某張 issue 某個欄位的改動,只會重渲染讀取那個欄位的 component。不是父層的列表、不是 sidebar,就是一個 cell。50 張 issue 的更新就是 50 次 cell re-render,不是整個列表 re-render。這就是為什麼在十個人同時編輯的繁忙 workspace 裡,UI 還能保持滑順:接收更新的成本跟「改動了什麼」走,不是跟「畫面上有什麼」走。

我曾經做過即時串流股票資料跟財報的 app,原子的、個別 component 的更新正是讓 app 感覺高效能的關鍵。你要盡可能避免連鎖更新,Linear 做的就是這件事。

為什麼這三件事要綁在一起

任何一個拿掉,app 就會開始感覺慢。沒有樂觀寫入的本地資料庫,存檔時還是會轉圈。沒有細粒度 observable 的樂觀寫入,每次更新還是會卡頓。沒有本地資料庫的細粒度 observable,初次載入還是得等。Linear 的速度不是任何單一層的特性,是整個系統的特性。

Bundler 跟 loader shell 讓 app 在 first paint 感覺快。同步引擎讓你在開始用之後持續感覺快。

為速度而生的設計

速度不只是工程問題,也是設計問題。一套完美的同步引擎還是會輸給遲鈍的輸入模型:如果最快的動作路徑需要滑鼠、三層選單、再加一次點擊,使用者就會為這些步驟付出代價——不管底層引擎跑多快。

Linear 速度的另一個基石是他們把鍵盤當作主要的導航跟完成工作工具。每個常用動作都有快捷鍵。Command palette 一個按鍵就到。右鍵選單是客製刻的。這些沒有一個是意外,而是從第一天起的深思熟慮。

每個動作都有快捷鍵

單鍵編輯當前 issue。兩鍵組合做導航。修飾鍵做全域動作。

聽創辦人聊 Linear 早期的故事,可以很清楚知道快捷鍵從一開始就是基礎。同步引擎的一部分設計目的,就是任何動作任何時候都做得到。這種設計跟工程的搭配,感覺一直延續到現在的每個功能。

如果仔細看他們的 UI,你會發現快捷鍵標示無所不在。最常用的用單字元,因為最常被用。而且每個動作都能用滑鼠完成,以免把新手嚇跑。

Command palette 永遠一個按鍵之遙

⌘ k 打開 command palette,讓使用者搜尋 Linear 裡幾乎所有動作:issue、project、label、狀態變更、導航、開 issue、設定、切換主題。這個 command 之所以快到不可思議,是因為它搜的是本地的 MobX 物件池,不是伺服器。記住,避開網路。

架構上的回報是:整個 app 都能從同一個面板觸達。導航是搜尋、開 issue 是搜尋、改狀態是 scope 過的搜尋。更棒的是,這個 command 是 context-aware 的,會根據你正在做的事情調整。這是教使用者任何 view 的關鍵動作跟快捷鍵的好方法。一個原始機制,到處都用,跑在已經在記憶體裡的資料上。

一個快的 app 需要令人讚嘆的工程跟設計。你可以做出完美的同步引擎、零瑕疵的渲染 pipeline,只要設計錯了,最後的成品還是感覺慢。工程速度讓單一互動變快。設計速度讓每個互動的路徑變短。

對一個整天都在用的工具來說,「按個快捷鍵」跟「用滑鼠花兩秒」之間的差距,會在每個動作累積。把快捷鍵跟全域 command palette 結合,你就得到一個用起來快得不可思議的 app。

動畫

到目前為止做的所有事,還是可能因為糟糕的動畫被搞砸。團隊耗費巨大心力讓 app 的每個部分都快。初始載入、更新、資料庫查詢,全都做了。把毫秒數一點一點刮掉,讓使用者從來不用等。然後,在最後一步,有人加了一個 500ms 的 height 動畫到某個元素上。

你能動的屬性其實只有少數幾個

瀏覽器對屬性變更有三個層級的處理成本,從低到高分別是渲染 pipeline 的不同階段。合成層級(composited) 的屬性(transform、opacity)把工作交給 GPU,跟 main thread 獨立跑。觸發繪製(paint)的屬性(color、background-color、border-color、fill)跳過 layout 但還是重畫像素。觸發 layout 的屬性(width、height、top、left、margin、padding)會強迫瀏覽器重算頁面上後續每個元素的位置。永遠不要動這些。我說的是永遠。

/* Linear 怎麼做 */
.row:hover {
  background-color: var(--color-bg-hover);
  transition: background-color 0.12s;
}
.icon-arrow {
  transform: translateX(0);
  transition: transform 0.15s;
}

/* 如果你不知道的話,可能會寫成這樣 */
.row:hover {
  margin-left: 2px;       /* 對下面每個 row 都觸發 layout */
  transition: all 0.2s;   /* 而且你現在在動 margin */
}

margin-left 那個版本,會在每一幀、整整 200ms 的 transition 期間,為被 hover 那一列下方的每一列重算 layout。在一個長 issue list 上,這就是「滑順」跟「卡頓」的差別。

如果你把 Linear app 裡所有會動畫化的屬性都看過一輪,它們只侷限在少數幾個:大多是合成層級的屬性(transform 跟 opacity),偶爾才是 background-color 跟 border-color 這類。

知道什麼時候該忍住

我認為,跟「只動合成層級屬性」幾乎一樣重要的是知道什麼時候根本不該動畫。動畫做過頭很容易。但在每天都要用的工具裡,你在行銷網站上會愛上的那些動畫,開始變成礙事的東西。就算是一個小小的 hover 延遲,放錯位置,就會變成使用者唯一會注意到的東西。

Linear 這點做得很好。Command palette 我會說稍慢了一點,但這幾年我已經變成一個嘮叨老頭。

他們很多動畫有效,是因為它們會回到自己的起點。狀態 popover 從狀態 pill 縮放展開。Agent panel 從它的 toggle 滑出。動畫在做「空間定位」的工作,告訴使用者新元素是從哪裡來的,而不是從虛無淡入當作裝飾。

持續時間保持短而俐落

/* 從 Linear 的 stylesheet 抽出的變數 */

--speed-highlightFadeIn: 0s;
--speed-highlightFadeOut: .15s;
--speed-quickTransition: .1s;
--speed-regularTransition: .25s;
--speed-slowTransition: .35s;

大部分設計系統的預設值都設得比應該的還長。Material 的標準 duration 是 200ms,iOS 的 spring 接近 350ms。預設偏短是讓 app 感覺快最簡單的方法之一,而 Linear 的預設值遠低於業界常態。

Linear 更進一步,對進場跟退場用不對稱的時間。Hover highlight、popover、agent panel 在你召喚它們時瞬間出現,關閉時用 150ms 淡出。

順帶一提,Linear 的一位 Design Engineer Emil Kowalski 做了一個非常棒的動畫課程 animations.dev。如果你覺得前面幾節有意思,值得去看看。他深入探討動畫原則,有很多例子跟實務教學。

Linear 為什麼這麼快——總結

還有更多細節我能寫,Linear 之所以感覺快,是因為它做對了。事實是沒有一件單獨的事能讓 app 高效能。它是數百個做對的決定累積起來的結果。

我喜歡 Linear 做法的地方是它大部分有多簡單。沒有 Next、沒有 Tanstack、沒有花俏的框架。他們很早就決定什麼架構最能服務使用者,然後一直堅持下去。結果是一個 client-side rendered app,比 server-rendered 的還要快(而且沒有那種複雜度)!

整體的形狀大致是這樣的:

  • 伺服器是 sync target,不是真理來源。
  • 資料庫住在瀏覽器裡。
  • Mutation 先在本地套用,在背景對帳。
  • 首次載入用更少的程式碼、切成更多小塊,service worker 在使用者還在登入頁時預先 cache 剩下的部分。
  • Auth 根據狀態先假設,之後再驗證。
  • 同步引擎從 IndexedDB 注水到 per-property 的 MobX observables,所以 50 張 issue 的更新是 50 次 cell re-render,不是列表 re-render。
  • 輸入模型是 keyboard-first。每個常用動作都有快捷鍵,加上全域 command palette。
  • 動畫留在 GPU 上,duration 落在 100ms 的因果閾值以下,永遠不動觸發 layout 的屬性。

難的部分不是實作。難的是在 codebase 成熟、擴張、撞上新限制的那幾年裡,堅持把工做對的紀律。

如果你還沒用過,推薦你打開 Linear 親自體驗看看。

希望你學到了一兩件事!寫這篇、深入研究讓 Linear 成為現在這樣的細節,是很開心的過程。我就是熱愛打造世界上最棒的 web app,也喜歡看別人怎麼做到的。如果你有任何回饋、建議、或者想聊聊,歡迎在 X 上找我。


本文改編自 Dennis Brotzky 2026 年 5 月 3 日發表的《How’s Linear so fast? A technical breakdown》,原文以 CC BY-NC-SA 4.0 授權釋出,感謝原作者的精彩拆解。

網友熱門留言 (8)

#1 HoyaSaxa ▲ 95
我在公司用 Linear,老實說我可能屬於少數派,但我對它的 UX 真的很苦手。我也不覺得它快。技術上來說頁面確實載入得還算快,但有一半的時間我會看到畫面上的數字在更新,卻沒有任何視覺指示告訴我資料其實還在載入中。
#2 syspec ▲ 87
整篇部落格基本上就是在講:在客戶端做 mutation、假設它成功了、然後丟到背景存檔。
#3 ricardobeat ▲ 62
我以前一直聽到 Linear 很快,但實際每天用過之後,我的熱情消失了。搜尋很慢、UI 經常卡卡的(雖然看起來漂亮)、Pulse 連在小型團隊都是一片雜訊,我常常找不到我需要的東西,最後只好把全部都加到最愛。早期的 Trello 才是史上最佳專案追蹤體驗。
#4 throwaway7783 ▲ 54
寫一個最終一致的資料庫很難,對 Linear 的使用情境來說或許可以接受,但不知道我的更新有沒有送到伺服器(也就是我的團隊那邊)才是大問題。同步延遲在我之前待過的專案裡造成過無數的災難,所以我一律走同步解。這些花俏的東西只有真的需要時才用。我寧可把伺服器優化到極快,讓使用者「承擔」網路延遲。
#5 jacobgold ▲ 41
這類本地優先的同步 web app 真的很有趣也實用,但我覺得前提有點問題。「Linear 更新一張 issue 只要幾毫秒,傳統 CRUD app 要 300ms。」這是因為光速沒辦法被解決——大型 RTT 在 HTTP client 跟 server 之間就是會卡。但你可以找到瓶頸並繞過它。
#6 Keyframe ▲ 38
挺有趣的。說實話我從來不覺得 Linear 「快」。它跟大部分 web app 一樣卡,但跟 JIRA 比當然是光速。Linear 確實很棒,是經歷 JIRA 折磨後的一場及時雨。至於樂觀更新跟「快」——也許我們應該先來聊聊 Gmail?
#7 simjnd ▲ 32
去年有個人反向工程了 Linear 的同步引擎,連說明文件一起開源在 GitHub。https://github.com/wzhudev/reverse-linear-sync-engine
#8 cuechan ▲ 28
300ms 看起來有點多。就算把整個 HTTP 請求加回應都算進去,這時間長度還是不可思議地久。