Lint

English | 繁體中文

---

English

A macOS menu-bar AI writing assistant. Press a global hotkey to capture the selected text, send it to an LLM, compare the suggestion in a floating panel, then replace or copy it.

Install

Get the latest Lint-<version>-macOS-arm64.dmg from GitHub Releases. Official releases are signed with a Developer ID certificate and notarized by Apple. They need macOS 14+ on an Apple Silicon Mac.

1. Open the DMG and drag Lint into Applications.
2. Launch Lint from Applications. Lint's icon (a pen nib with a check mark) appears in the menu bar and the Set Up Local AI window opens.
3. It reports the Local AI runtime as ready, because llama.cpp is already inside Lint. The AI model is the one thing still missing: Lint shows its size (about 5.2 GB for the default Gemma 4 E4B) and where it is stored, and starts downloading only after you click Download and Install. It shows progress, verifies the download, then starts the local server.
4. Allow Lint under System Settings → Privacy & Security → Accessibility (the setup window guides you and updates when it is on).
5. Optional: verify the download with shasum -a 256 -c Lint-<version>-macOS-arm64.dmg.sha256, run in the folder that holds both files.

Hotkeys

Hotkey	Action
⌥⌘K	Compact suggestion bubble
⌥⌘L	Full two-column panel

Hotkeys can be rebound in Settings.

Live check — watching the focused field and preparing a suggestion while you type — is on by default. Turn it off in Settings → General.

Permissions

System Settings → Privacy & Security → Accessibility → enable Lint. Accessibility can read text in the app you are using, including the focused field. Lint reads the text you select, the field ⌥⌘K checks, and, while live check is on (the default), the field you are typing in.

Without permission the app still works, but falls back to simulated ⌘C / ⌘V through the clipboard. Run the signed dist/Lint.app; a bare binary does not reliably show up in the Accessibility list. If the system treats a rebuilt app as new, grant the permission again. Use a stable code-signing identity (e.g. Apple Development) to avoid this.

While replacing text, macOS may ask whether Lint may control "System Events". Allow it: Lint uses it only to bring your previous app back to the front, which makes Replace reliable in browsers and Electron apps.

What Lint can read, and how to report a vulnerability, is in SECURITY.md.

Install details

Preview builds

Preview builds: the Pre-release entries on the Releases page (Lint-<version>-macOS-arm64-preview.dmg) are unsigned previews from before the first notarized release; install the latest notarized release instead. If you do open a preview, macOS blocks it the first time: go to System Settings → Privacy & Security and click Open Anyway, or run xattr -dr com.apple.quarantine /Applications/Lint.app. Allow Accessibility again after installing each new preview.

What is inside the app and what is downloaded:

• Bundled in the official DMG: a pinned llama.cpp runtime (llama-server and its libraries, MIT-licensed, build b11046; its license notices are in the app). It is signed and notarized together with Lint, so nothing executable is downloaded after you install. Runtime updates arrive with Lint updates.
• Downloaded after you agree: the GGUF model. It is not in the DMG. It is checked against a pinned SHA-256 and stored under ~/Library/Application Support/Lint/Models; you can remove it in Settings → Model. Apart from this download, the default setup uses the network only to check GitHub for Lint updates (see Updates).
• Not needed: Homebrew, Python, CMake, Ollama, or a llama.cpp of your own.

Developer / source install (no Homebrew)

git clone https://github.com/davislinyd/Lint.git && cd Lint    # or download the ZIP from GitHub and unzip it
./Scripts/install.sh

Needs macOS 14+ and Apple's Command Line Tools (xcode-select --install; the script tells you if they are missing). Homebrew is not required. The script downloads the pinned llama.cpp runtime over HTTPS and verifies its SHA-256, builds Lint in release mode, installs it to ~/Applications/Lint.app (no sudo; ./Scripts/install.sh --system installs to /Applications), and opens it. The same in-app setup then continues with the model download. ./Scripts/install.sh --dry-run only checks the prerequisites.

A source build is signed with your Apple Development identity if you have one, otherwise ad-hoc. It is not the notarized release, and macOS may ask you to allow Accessibility again after a rebuild.

Advanced: your own backend

Settings → Model → Advanced lets you point Lint at another llama-server (a Homebrew or self-built one), or at a Hugging Face model that llama-server downloads itself (-hf). You can also choose an OpenAI-compatible endpoint (Ollama, LM Studio, custom) as the model source. None of this is needed for the default setup.

Requirements

• macOS 14+
• To build from source: Apple's Command Line Tools with a Swift 6.1+ toolchain (Xcode also works)
• An LLM backend: by default nothing extra, since Lint bundles llama.cpp and downloads its own model. Alternatively Apple Intelligence (macOS 26 or later) or an OpenAI-compatible endpoint (default http://127.0.0.1:8000/v1, e.g. llama-server, Ollama, LM Studio)

Run

# Optional: store the API key in Keychain (reads the gitignored .env.local)
# .env.local content: LINT_API_KEY=...
chmod +x Scripts/*.sh
./Scripts/seed-keychain.sh
./Scripts/run-dev.sh

Lint's icon (a pen nib with a check mark) appears in the menu bar. Packaging fetches the pinned llama.cpp runtime on first use (Scripts/fetch-llama-runtime.sh, hash-verified, cached under .build/); to try a development build without touching your real models, set LINT_APP_SUPPORT_DIR to another folder.

How it reads text

• Live check: while you type, Lint watches the focused field (English-leaning text) and prepares a suggestion in the background, so ⌥⌘K shows it right away. With a local model, it is also warmed up as soon as you start typing.
• Any app: native apps are read through Accessibility. For Chromium / Electron apps (browsers, Slack, SeaTalk, ChatGPT, …) Lint switches on their accessibility tree automatically.
• Fallback: if a field exposes no text, ⌥⌘K selects the field (⌘A), copies it, then restores the clipboard and the caret.
• Fullscreen: the bubble opens on the Space you are working in, including fullscreen apps.

Settings

• Model source: Automatic, Apple Intelligence, local llama.cpp (managed by Lint) or an OpenAI-compatible endpoint (Ollama / LM Studio / custom). OpenAI, Anthropic and Google Gemini are listed but greyed out until they have been tested, and the ChatGPT (Plus / Pro login) source is turned off.
• AI engine: Automatic, Apple Intelligence or Lint Local AI. Apple Intelligence uses the on-device model built into macOS 26 or later (no separate download; Lint uses only the on-device model, never Private Cloud Compute). Automatic uses it when it is available and otherwise Lint's local AI if that is already set up; it never starts a download on its own. Existing settings are kept on upgrade. See docs/APPLE-INTELLIGENCE.md for how it was evaluated against Gemma.
• API keys are stored in Keychain (service app.lint.assistant)
• Default endpoint: http://127.0.0.1:8000/v1
• Ollama: http://127.0.0.1:11434/v1; LM Studio: http://127.0.0.1:1234/v1
• Local llama.cpp: pick it as the source in Settings → Model. The same page shows the bundled runtime, the model (download / remove / show in Finder) and the server (start / stop / restart, port); Advanced holds the runtime source (automatic or a custom llama-server), the model source and extra arguments. The server only listens on 127.0.0.1 and only answers Lint: it is started with a key that Lint makes each time it starts and never shows. Other apps use the model through Lint's API port instead (see below).
• Menu bar: the first row of Lint's menu shows the local model's state (not loaded, loading, running, idle, restarting or failed; the dot on the icon shows it too). It opens a list to switch models: one that Lint manages, or Apple Intelligence when this Mac has it. A model that is not downloaded yet shows its size and asks first; it then downloads with its progress in that row, and starts when it is in. The same list starts, stops, restarts or rechecks the local server. Further down, the menu shows the CPU and memory Lint and its local model use, counted as Activity Monitor does and updated every second while the menu is open; the model's weights are a mapped file outside that memory, so the size of its model file is listed while it is loaded.
• Interface language (Settings → General): Follow System, English, Traditional Chinese, Simplified Chinese, Japanese, Korean, Vietnamese, Indonesian, Thai or Portuguese (Brazil). It applies after Lint restarts.
• Translation language (Settings → General): the language the Translate mode and the reference translation under a suggestion use, Traditional Chinese by default, from the same list (English excepted). Lint only translates from English into it; the change applies at once.

Updates

Lint checks GitHub Releases for a newer official release: every week by default (Settings → General → Updates: every launch, day, week or month), and whenever you choose Check for Updates… in the menu bar menu.

• Ask before installing (the default): Lint shows the new version, and Download and Install installs it.
• Install automatically: Lint installs it once the suggestion window is closed, then restarts.
• Only check: Lint only tells you about it.

A check only asks the GitHub API for the latest release; none of your text is sent. Before anything is replaced, the downloaded DMG has to match the published SHA-256, and the app inside it has to be Lint (app.lint.assistant) signed with Lint's Developer ID and Hardened Runtime. The new copy is swapped in after Lint quits, and only at /Applications/Lint.app or ~/Applications/Lint.app. A copy anywhere else, or one not signed with Lint's Developer ID (such as a source build), can check for updates but is not replaced.

Local AI notes

• Not set up yet: until Lint's local AI has its model and Lint may read text (Accessibility), opening Settings or pressing ⌥⌘K or ⌥⌘L opens the setup window instead, never a connection error. Its Use Another Model Source… link opens Settings, for example to use an OpenAI-compatible endpoint; Apple Intelligence and other model sources never lead back to it. The menu-bar item Set Up Local AI… reopens the setup window at any time; Later on the first-run screen only stops it from opening by itself at launch.
• Downloads are safe to interrupt: cancel, lose the connection or even quit Lint, and the partial file stays under ~/Library/Application Support/Lint/Downloads; downloading again continues from where it stopped. A file that fails its size, GGUF-header or SHA-256 check is deleted and never used, and the model only appears under Models/ once every file has passed, in one step.
• Disk space: before downloading, Lint checks for about 1.2× what is still missing and tells you how much it needs and how much the Mac has.
• Slow first start: loading a 4–5 GB model can take minutes on a Mac that is short of memory. Lint waits up to 10 minutes and, if the server is still loading, leaves it running instead of starting over. If it fails, Settings → Model → Details shows the last lines it printed.
• One piece on disk: a download writes the model as it arrives, which scatters it across the disk. Once llama-server has loaded a managed model for the first time, Lint rewrites each file once in the background in a single pass, checked against its SHA-256 and only when there is room for a second copy; nothing waits for it, and a failure leaves the file as it was. The server keeps the copy it loaded, so the gain starts with the next load (after an idle release, a restart or the next launch): on a 16 GB M1 Pro, loading Gemma 4 E4B from disk went from about 14 s to 4 s.
• Models: Gemma 4 E4B (default, about 5.2 GB), Qwen3 4B (optional, 2.5 GB) and Gemma 4 12B (optional, 7 GB) can be picked in Settings → Model. Gemma 4 12B is marked as a memory risk: on a 16 GB Mac it can make the system very slow or unresponsive. Switching never deletes a model; one you already have is never downloaded again. An upgrade keeps the model you have installed; an install that only had 12B stored as the old default and never downloaded it moves to E4B.
• Tuning and idle release: Lint passes each managed model its own llama-server arguments (context 8192, q8_0 KV cache, --reasoning off for Gemma 4). Every model also gets --lazy-mode on: Gemma 4 E4B's per-layer embeddings (2.15 GiB of its 4.8) are read a row per token instead of loaded, so about 2 GB less stays in memory, which also makes a load faster on a Mac short of memory; models without such tensors are unaffected. llama-server's prompt cache in memory is capped at 128 MiB: its default could grow to 8 GiB, was kept while the model slept, and grew by about 80 MB with every proofread of a longer text, none of it used again. The advanced field starts empty and only overrides the options it names. After 5 minutes without a suggestion (Settings → Model → Memory) llama-server releases the model's memory and reloads it on the next request, which takes a few seconds. A stored copy of an old built-in default argument string is cleared on upgrade; anything you typed is kept.

Use the local model from other apps (optional, off by default)

Settings → Model → Other Apps lets scripts, other apps, browser extensions and your own web pages on this Mac call Lint's local model through an OpenAI-compatible API, while Lint keeps priority. Scripts and apps need only a key; extensions and web pages also need to be let in, as below.

• Address and keys: http://127.0.0.1:8001/v1 (the API port can be changed), with one of the keys listed there, sent as Authorization: Bearer <key> or X-Api-Key: <key>. Only connections from this Mac are accepted; Host must be 127.0.0.1 or localhost.
• One key per app: Add API Key makes a new key under a name you choose (the app or page you give it to), and Revoke… stops one key at once, so only the apps that use it lose access; a request already under way finishes. Every key is kept in the Keychain and can be shown or copied at any time. The key from Lint 0.16.0 is kept and listed as Default. The diagnostic log notes which key a request used by the first characters of its ID, never its name or value.
• Routes: POST /v1/chat/completions, POST /v1/completions, GET /v1/models and GET /health. Nothing else of llama-server's (such as /props or /slots) is reachable.
• Lint comes first: the model answers one request at a time. When Lint needs it (a suggestion, a translation, warming up while you type), the request from another app is interrupted at once; if it had not sent anything back yet, Lint sends it again when it is done, so the app only waits longer. A streamed answer that was already under way ends with an error (preempted_by_lint). While Lint is using the model, and for 3 seconds after, or while you type, other requests wait (at most 8 waiting, up to 2 minutes each); beyond that they get 503 with Retry-After.
• Browser extensions: Allow browser extensions to use the API (off) lets extensions in Chrome, Brave, Edge, Firefox and Safari in (chrome-extension://, moz-extension://, safari-web-extension://), with a key; extensions can see the pages you browse, so give a key only to ones you trust.
• Your own web pages: a page can use the API only if its address is in Allowed websites: by default pages on this Mac (http://localhost, http://127.0.0.1, https://localhost, any port). For a page on your local network or your own domain, add its http or https address, such as http://192.168.1.5:3000, or https://*.example.com for every subdomain of example.com (not example.com itself). Other websites cannot get in, and neither can a local file (, which sends ). A page needs a key too. Checked on 2026-10-24 and 2026-10-25: Chrome and Brave let an allowed website reach the API port, and Chrome an page served on the local network; Safari does not let any page connect to an address on this Mac (its mixed-content rule), so in Safari no page can use it.

curl http://127.0.0.1:8001/v1/chat/completions \
  -H "Authorization: Bearer $LINT_API_KEY" -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Hello"}]}'

Writing modes

Proofreading and polishing, translation and a custom prompt. Proofreading takes one of five tones: Preserve Tone corrects errors and leaves your wording alone; Idiomatic (the default) also rewrites English that is correct but not what a native speaker would say, and rebuilds a sentence that is put together wrong (a subject said twice, clauses out of order), while keeping your voice: a question stays a question, contractions or full forms stay as written, slang and emoji stay, and no greeting, hedge or stock phrase is added; Formal, Casual and Concise rewrite it in that style. Translation takes Preserve Tone, Formal, Casual or Concise. Each mode remembers its own tone, and the custom prompt uses none. For example, “Kindly revert back to me at the earliest.” becomes “Please get back to me as soon as possible.” in Idiomatic. Idiomatic, Formal, Casual and Concise also take Chinese or another language: they work out what the text means and write it the way a native English speaker would, always in English, so 「抱歉，這個需求我們這季排不進去，下季再評估看看。」 becomes “Sorry, we can't fit this request into this quarter. Let's reassess it next quarter.” Settings → General decides whether text that mixes English with Chinese or another language in its own script (Japanese, Korean, Thai and so on) is written all in English (the default) or keeps that language and has only its English edited; a language in Latin letters mixed with English, such as Vietnamese or Indonesian, is always written in English. An Idiomatic answer that changes your voice is retried once; one that still only sounds a little different is shown with a note, and one that brings in too many words of its own keeps the original. Words in another language inside English text, such as a Korean file or product name, stay as written. When a result is the text as it is, Lint says so, and after Preserve Tone it offers to try Idiomatic. Read the result before replacing the original: the small local model sometimes rewords text that was already natural, and a style can drift from the original. Apple Intelligence sometimes replies to Chinese text instead of rewriting it, so under Automatic, English written from Chinese or another language uses Lint's local model whenever it is set up. Preserve Tone edits English only: a text without any English, or in another language written in Latin letters, is not sent to the model, and translation goes from English into the translation language.

Memory and dreaming (optional, off by default)

With Settings → Memory turned on, Lint notices writing habits you correct (a word you misspell, an article you drop), writes them down as short rules and uses them from the next suggestion on. While it is off, Lint behaves exactly as before. The few memories that fit what you are writing (at most five short lines) are added to the end of the prompt sent to your model; with a local model that stays on your Mac.

• Everything stays on your Mac, in ~/Library/Application Support/Lint/LintLearning.sqlite (readable only by you). The settings page calls this Memory; the file name stays LintLearning.sqlite.
• Only abstracted rules are kept: a word, a short phrase or a template sentence, never the text around it. Numbers, addresses, paths, acronyms and capitalised names are left out. Lint cannot recognise Chinese names or names typed in lowercase, so a name you corrected can still end up in a memory; you can read and delete every memory under Settings → Memory → Manage Memories.
• What you did with a suggestion (replace, copy, rewrite) is logged as keyed hashes, not text; the key is in the Keychain.
• Observation mode (Settings → Memory, off by default): after a suggestion, Lint keeps reading that field until the text is sent (the field empties), the field goes away or 10 minutes pass without a change, and notes whether a suggestion was used, looked at and left, or never opened. The text is only compared in RAM. The file gets a count per app (under its bundle ID) that fades with time and, for a suggestion you looked at and did not use, an event of keyed hashes. From the text that was sent it learns what to leave alone: a word you put back after Replace becomes a memory to keep that word, used from the next suggestion on; a change you looked at and sent without becomes one once that has happened twice, and only for plain proofreading (Preserve Tone and Idiomatic), since another tone rewrites on purpose. An article or a preposition you left as it was only counts against the memory that asks for that fix. Text typed after the stretch that was checked, and its last word, are not judged. It also counts four ways of writing where a suggestion would have changed them: contractions you keep, full forms you keep, a message without a period at its end, and a lowercase start. Once one of them was seen at least 8 times lately and kept 80% of the time, dreaming writes it into one memory of your style, which tells the model to leave it as it is; it is dropped again when you keep it less than 60% of the time. This counts under Preserve Tone and Idiomatic only, and you can reword, pin, disable or delete that memory like any other (deleted, it is not written again). Dreaming also adjusts Lint per app. An app in which 30 sessions lately ended without a suggestion being used, and none with one, goes quiet: nothing is prepared there on its own any more, ⌥⌘K still checks, and using it there ends the quiet. An app in which one tone was the tone of at least 3 used suggestions lately, and of 80% of them, gets that tone for its automatic suggestions; the menu keeps showing the tone you chose, the bubble names the tone it used, and choosing a tone by hand ends it. Settings → Memory lists these adjustments, each with a Remove button, and shows the recent adoption rate. Details are in SECURITY.md.

Test

swift test

Downloading a model is never done by the tests. LINT_LIVE_DOWNLOAD=1 swift test --filter LiveModelDownloadTests additionally downloads a 1.2 MB public file from Hugging Face to check redirects and resume against the real service.

License

MIT. The bundled llama.cpp runtime is MIT-licensed as well; its license files are inside the app (Contents/Resources/LlamaRuntime/<arch>/licenses, also reachable from Settings → About).

---

繁體中文

macOS 選單列 AI 寫作助手：全域快捷鍵擷取選取文字，送到 LLM，在浮動面板對比後覆蓋或複製。

安裝

到 GitHub Releases 下載最新的 Lint-<版本>-macOS-arm64.dmg。正式版以 Developer ID 憑證簽署並通過 Apple 公證，需要 macOS 14+ 與 Apple Silicon Mac。

1. 開啟 DMG，把 Lint 拖進 Applications。
2. 從「應用程式」開啟 Lint，選單列會出現 Lint 的圖示（筆尖加一個勾），並開啟「設定本機 AI」視窗。
3. 視窗會顯示本機 AI 執行環境已就緒，因為 llama.cpp 已經在 Lint 裡面。還缺的只有 AI 模型：Lint 會列出大小（預設的 Gemma 4 E4B 約 5.2 GB）與存放位置，按下下載並安裝之後才開始下載，並顯示進度、驗證檔案，再啟動本機服務。
4. 到 系統設定 → 隱私權與安全性 → 輔助功能，勾選 Lint（設定視窗會引導，開啟後自動更新）。
5. 選用：在放有 DMG 與 .sha256 的資料夾執行 shasum -a 256 -c Lint-<版本>-macOS-arm64.dmg.sha256 驗證下載。

快捷鍵

快捷鍵	行為
⌥⌘K	迷你建議浮窗
⌥⌘L	雙欄全面板

快捷鍵可在設定中重新綁定。

即時檢查（打字時監看焦點欄位並在背景準備建議）預設開啟，可在「設定 → 一般」關閉。

權限

系統設定 → 隱私權與安全性 → 輔助功能 → 勾選 Lint。輔助功能可以讀取你正在使用的 App 裡的文字，包含焦點欄位。Lint 會讀你選取的文字、⌥⌘K 檢查的欄位，以及即時檢查開著時（預設開）你正在輸入的欄位。

未授權時仍可運作，但改走模擬 ⌘C／⌘V 的剪貼簿備援。必須執行簽名過的 dist/Lint.app，裸 binary 不會穩定出現在輔助功能列表。重新組包後若系統視為新 App，需再勾選一次；使用固定的程式碼簽署憑證（如 Apple Development）可避免。

取代文字時，macOS 可能會詢問是否允許 Lint 控制「系統事件」。請允許：Lint 只用它把你原本使用的 App 帶回最前面，這樣在瀏覽器與 Electron App 裡取代才會穩定。

Lint 能讀到什麼，以及如何回報漏洞，寫在 SECURITY.md。

安裝補充

預覽版

預覽版： Releases 頁上標示為 Pre-release 的項目（Lint-<版本>-macOS-arm64-preview.dmg）是第一個公證版發佈之前的未簽章預覽版；請改裝最新的公證版。如果還是要開預覽版，第一次開啟時 macOS 會擋下：到 系統設定 → 隱私權與安全性 按「仍要打開」，或執行 xattr -dr com.apple.quarantine /Applications/Lint.app。每安裝一個新的預覽版，輔助功能都要重新允許。

App 裡有什麼、之後才下載什麼：

• **官方 DMG 內建：**固定版本的 llama.cpp 執行環境（llama-server 與其函式庫，MIT 授權，build b11046；授權文件在 App 內）。它和 Lint 一起簽署並公證，所以安裝之後不會再下載任何可執行檔。執行環境隨 Lint 更新一起更新。
• **同意後才下載：**GGUF 模型。它不在 DMG 裡，下載後會以固定的 SHA-256 驗證，存放在 ~/Library/Application Support/Lint/Models，可在「設定 → 模型」移除。除了這次下載，預設設定只會用網路到 GitHub 檢查 Lint 的更新（見〈更新〉）。
• **不需要：**Homebrew、Python、CMake、Ollama，或自行安裝的 llama.cpp。

開發者／從原始碼安裝（不需要 Homebrew）

git clone https://github.com/davislinyd/Lint.git && cd Lint    # 或從 GitHub 下載 ZIP 並解壓縮
./Scripts/install.sh

需要 macOS 14+ 與 Apple 的 Command Line Tools（xcode-select --install，缺少時腳本會告訴你）。不需要 Homebrew。腳本會以 HTTPS 下載固定版本的 llama.cpp 執行環境並驗證 SHA-256、以 release 模式建置 Lint、安裝到 ~/Applications/Lint.app（不需要 sudo；./Scripts/install.sh --system 則安裝到 /Applications），然後開啟它。接著由 App 內的同一套設定畫面繼續下載模型。./Scripts/install.sh --dry-run 只檢查前置條件。

原始碼建置會用你的 Apple Development 憑證簽署，沒有的話用 ad-hoc。它不是公證過的正式版，重新建置後 macOS 可能要求再次允許輔助功能。

進階：使用自己的後端

「設定 → 模型 → 進階」可以改用另一個 llama-server（Homebrew 或自行編譯的版本），或改用由 llama-server 自己下載的 Hugging Face 模型（-hf）。也可以把 OpenAI 相容端點（Ollama、LM Studio、自訂）當作模型來源。預設設定完全用不到這些。

需求

• macOS 14+
• 從原始碼建置：Apple 的 Command Line Tools，含 Swift 6.1+ 工具鏈（裝 Xcode 也可以）
• LLM 後端：預設不需要額外安裝，Lint 內建 llama.cpp 並自行下載模型。也可以改用 Apple Intelligence（macOS 26 以上）或 OpenAI 相容 API（預設 http://127.0.0.1:8000/v1，例如 llama-server、Ollama、LM Studio）

啟動

# 可選：把 API Key 寫進 Keychain（讀取 gitignored 的 .env.local）
# .env.local 內容：LINT_API_KEY=...
chmod +x Scripts/*.sh
./Scripts/seed-keychain.sh
./Scripts/run-dev.sh

選單列會出現 Lint 的圖示（筆尖加一個勾）。組包時第一次會下載固定版本的 llama.cpp 執行環境（Scripts/fetch-llama-runtime.sh，驗證雜湊後快取在 .build/）；想試用開發版又不動到真正的模型，可把 LINT_APP_SUPPORT_DIR 設成別的資料夾。

如何讀取文字

• 即時檢查： 打字時 Lint 會監看目前輸入框（以英文為主的文字），在背景先準備好建議，按 ⌥⌘K 即可立刻顯示；使用本機模型時，開始打字就會先暖機。
• 任何 App： 原生 App 透過輔助功能讀取；Chromium／Electron 系 App（瀏覽器、Slack、SeaTalk、ChatGPT 等）由 Lint 自動開啟其輔助功能樹。
• 後備： 輸入框讀不到文字時，⌥⌘K 會全選（⌘A）並複製，再還原剪貼簿與游標位置。
• 全螢幕： 浮窗會出現在你正在使用的 Space，包含全螢幕 App。

設定

• 模型來源：自動、Apple Intelligence、本機 llama.cpp（由 Lint 管理），或 OpenAI 相容端點（Ollama / LM Studio / 自訂）。OpenAI、Anthropic、Google Gemini 會列出，但在測試過之前是灰色、不能選；ChatGPT（Plus／Pro 登入）來源已關閉。
• AI 引擎：自動、Apple Intelligence 或 Lint 本機 AI。Apple Intelligence 使用 macOS 26 以上內建的裝置端模型（不必另外下載；Lint 只用裝置端模型，從不使用 Private Cloud Compute）。「自動」在 Apple Intelligence 可用時使用它，否則使用已經設定好的 Lint 本機 AI；它不會自己開始下載。升級時保留原有設定。與 Gemma 的比較見 docs/APPLE-INTELLIGENCE.md。
• API Key 存在 Keychain（service app.lint.assistant）
• 預設 Endpoint：http://127.0.0.1:8000/v1
• Ollama：http://127.0.0.1:11434/v1；LM Studio：http://127.0.0.1:1234/v1
• 本機 llama.cpp：在「設定 → 模型」選擇該來源。同一頁會顯示內建的執行環境、模型（下載／移除／在 Finder 顯示）與服務（啟動／停止／重啟、埠）；「進階」有執行環境來源（自動或自訂 llama-server）、模型來源與額外參數。服務只監聽 127.0.0.1，而且只回應 Lint：啟動時帶著 Lint 每次開啟時產生、從不顯示的金鑰。其他 app 改用 Lint 的 API 埠（見下文）。
• 選單列：Lint 選單的第一行顯示本機模型的狀態（未載入、載入中、運作中、閒置中、重啟中或失敗，圖示上的小圓點也會顯示）。展開它可以切換模型：由 Lint 管理的本機模型，或這台 Mac 可以用的 Apple Intelligence。還沒下載的模型會先列出大小並詢問，同意後才下載，進度就顯示在這一行，下載完成後自動啟動。同一個清單也能啟動、停止、重新啟動或重新檢查本機服務。選單下方會顯示 Lint 與本機模型使用的 CPU 和記憶體，算法與活動監視器相同，選單開著時每秒更新；模型權重是對映的檔案，不在這個記憶體數字裡，所以模型載入時會另外列出模型檔的大小。
• 介面語言（「設定 → 一般」）：跟隨系統、English、繁體中文、简体中文、日本語、한국어、Tiếng Việt、Bahasa Indonesia、ไทย 或 Português (Brasil)。重新啟動 Lint 後套用。
• 翻譯語言（「設定 → 一般」）：「翻譯」模式與建議下方的參考譯文使用的語言，預設繁體中文，可選的語言同上（英文除外）。Lint 只把英文翻成這個語言，變更立即生效。
• 診斷（「設定 → 診斷」，或選單列選單的 「診斷記錄…」）：記錄 Lint 做了什麼、結果如何（擷取、取代、模型請求、本機服務、錯誤），不含你的文字。記錄存在 ~/Library/Logs/Lint/，最多兩個各 1 MB 的檔案。**「拷貝」**會把 Lint 版本與這台 Mac 的資訊附在最近 1000 行前面，方便回報問題。見 SECURITY.md。

更新

Lint 會到 GitHub Releases 檢查有沒有較新的正式版：預設每週一次（「設定 → 一般 → 更新」可選每次啟動、每天、每週或每月），在選單列選單按**「檢查更新…」**也會立即檢查。

• 手動更新（預設）：Lint 顯示新版本，按**「下載並安裝」**才安裝。
• 自動更新：建議視窗關閉後就安裝，並重新啟動 Lint。
• 只檢查：只告訴你有新版本。

檢查時只向 GitHub API 查詢最新的正式版，不會送出你的任何文字。換上新版之前，下載的 DMG 必須符合公布的 SHA-256，裡面的 App 必須是 Lint（app.lint.assistant），並以 Lint 的 Developer ID 簽署、啟用 Hardened Runtime。新版在 Lint 結束後才換上，而且只會取代 /Applications/Lint.app 或 ~/Applications/Lint.app。放在其他位置、或不是以 Lint 的 Developer ID 簽署的 Lint（例如從原始碼建置的版本），可以檢查更新，但不會被取代。

本機 AI 補充說明

• **尚未設定：**在本機 AI 裝好模型、且 Lint 獲准讀取文字（輔助功能）之前，打開設定或按 ⌥⌘K、⌥⌘L 都會改開設定視窗，不會出現連線錯誤。視窗裡的「使用其他模型來源…」會打開設定，例如改用 OpenAI 相容端點；使用 Apple Intelligence 或其他模型來源時不會被導回。選單列的「設定本機 AI…」可隨時重新開啟設定視窗；首次畫面按「稍後」只是不在啟動時自動彈出。
• **下載可以安全中斷：**取消、斷線甚至結束 Lint，已下載的部分都會留在 ~/Library/Application Support/Lint/Downloads，再次下載會從中斷處接續。大小、GGUF 標頭或 SHA-256 任一項驗證失敗的檔案會被刪除、絕不使用；所有檔案都通過之後，模型才會一次出現在 Models/。
• **磁碟空間：**下載前會檢查是否有「還缺的部分 ×1.2」的可用空間，並告訴你需要多少、這台 Mac 有多少。
• **第一次啟動較慢：**在記憶體吃緊的 Mac 上，載入 4–5 GB 的模型可能要數分鐘。Lint 最多等 10 分鐘，若伺服器仍在載入，會讓它繼續跑而不是重來。失敗時，「設定 → 模型 → 詳細資訊」會顯示它最後印出的幾行。
• **連續存放：**下載時模型是邊收邊寫，檔案會散落在磁碟各處。llama-server 第一次載入由 Lint 管理的模型之後，Lint 會在背景把每個檔案一次循序重寫一遍：比對 SHA-256，而且只在有空間放第二份時才做；不會讓任何操作等它，失敗時原檔維持原狀。伺服器繼續用它已載入的那份，所以從下一次載入（閒置釋放後、重新啟動或下次開啟 Lint）開始變快：在 16 GB 的 M1 Pro 上，從磁碟載入 Gemma 4 E4B 由約 14 秒降到 4 秒。
• **模型：**可在「設定 → 模型」選擇 Gemma 4 E4B（預設，約 5.2 GB）、Qwen3 4B（選用，2.5 GB）或 Gemma 4 12B（選用，7 GB）。Gemma 4 12B 標示為有記憶體風險：在 16 GB 的 Mac 上可能讓系統變得非常慢或沒有回應。切換模型不會刪除任何模型，已經有的模型也不會重新下載。升級會保留你已安裝的模型；只把 12B 存成舊預設、卻從未下載過的安裝會改用 E4B。
• **調校與閒置釋放：**Lint 給每個由它管理的模型各自的 llama-server 參數（context 8192、q8_0 KV cache，Gemma 4 另加 --reasoning off）。每個模型也都加上 --lazy-mode on：Gemma 4 E4B 的逐層嵌入（4.8 GiB 中的 2.15 GiB）改成每個 token 才讀需要的那一列、不整塊載入，常駐記憶體少約 2 GB，記憶體吃緊時載入也比較快；沒有這類張量的模型不受影響。llama-server 放在記憶體裡的 prompt cache 上限設為 128 MiB：預設最多可以長到 8 GiB，模型閒置釋放時也不會清掉，而且每校對一段較長的文字就多佔約 80 MB，之後都用不到。進階的「額外參數」欄位預設是空的，只會覆蓋它寫到的選項。5 分鐘沒有要求建議時（「設定 → 模型 → 記憶體」），llama-server 會釋放模型佔用的記憶體，下一次要求時再重新載入，約需幾秒。升級時會清掉舊版內建預設參數字串的存檔；你自己輸入的內容會保留。
• **升級：**已在 Hugging Face 快取（llama-server -hf 下載的）裡的模型會繼續使用，不會重複下載。設定裡舊的 Homebrew llama-server 路徑會改為使用內建執行環境；你自己選的路徑則保留為自訂執行環境。

讓其他 app 使用本機模型（選用，預設關閉）

「設定 → 模型 → 其他 app 使用」可以讓這台 Mac 上的腳本、其他 app、瀏覽器擴充功能和自製網頁透過 OpenAI 相容 API 呼叫 Lint 的本機模型，而 Lint 自己永遠優先。腳本和 app 只需要金鑰；擴充功能和網頁還要另外放行，見下方。

• 網址與金鑰：http://127.0.0.1:8001/v1（API 埠可以改），使用同一處列出的其中一把金鑰，以 Authorization: Bearer <金鑰> 或 X-Api-Key: <金鑰> 送出。只接受這台 Mac 的連線；Host 必須是 127.0.0.1 或 localhost。
• 一個 app 一把金鑰：「新增 API Key」用你取的名稱（給哪個 app 或網頁）建立一把新金鑰；「註銷…」立刻停用其中一把，只有用它的 app 會失去權限，已經在進行的請求會跑完。每把金鑰都存在鑰匙圈，隨時可以顯示或拷貝。Lint 0.16.0 的那把金鑰會保留，列為「預設」。診斷記錄只用 ID 的前幾個字元記下請求用了哪把金鑰，不記名稱，也不記金鑰本身。
• 路徑：POST /v1/chat/completions、POST /v1/completions、GET /v1/models 與 GET /health。llama-server 的其他路徑（例如 /props、/slots）都碰不到。
• **Lint 優先：**模型一次只處理一個請求。Lint 需要時（建議、翻譯、打字時的暖機），其他 app 的請求會立刻被中斷；如果它還沒收到任何回應，Lint 用完後會自動重送，那個 app 只會覺得比較慢。已經開始串流的回答則以錯誤（preempted_by_lint）結束。Lint 使用模型時與之後 3 秒內、或你正在打字時，其他請求會等候（最多 8 個、每個最多 2 分鐘），超過時回 503 並附 Retry-After。
• 瀏覽器擴充功能：「允許瀏覽器擴充功能使用 API」（預設關閉）會放行 Chrome、Brave、Edge、Firefox 與 Safari 的擴充功能（chrome-extension://、moz-extension://、safari-web-extension://），一樣需要金鑰；擴充功能看得到你瀏覽的網頁，只把金鑰給你信任的擴充功能。
• **自製網頁：網頁的網址必須在「允許的網站」**裡才能使用：預設是這台 Mac 上的網頁（http://localhost、http://127.0.0.1、https://localhost，任何埠）。架在區域網路或自己網域上的網頁，可以加入它的 http 或 https 網址，例如 http://192.168.1.5:3000，或用 https://*.example.com 代表 example.com 底下的所有子網域（不含 example.com 本身）。其他網站一律不能用，本機檔案（file://，送出的是 Origin: null）也不行。網頁一樣需要金鑰。2026-10-24 與 2026-10-25 實測：Chrome 與 Brave 會讓允許的 https 網站使用 API 埠，Chrome 也讓區域網路上的 http 網頁使用；Safari 不讓任何 https 網頁連到這台 Mac 的 http 位址（混合內容限制），所以在 Safari 上 https 網頁都無法使用。
• **只在 Lint 執行且使用本機模型時可用：**使用 Apple Intelligence 或其他來源時回 503。開關、新增或註銷金鑰、修改網站都立即生效，不會重新啟動模型。
• **從舊版 Lint 升級：**直接呼叫 http://127.0.0.1:8000 的腳本不再能用，因為 Lint 自己的 llama-server 現在只接受 Lint 的金鑰。請改用 API 埠與它的金鑰。
• AI agent：docs/LOCAL-API-AGENT-PROMPT.md 是可以直接交給 AI agent（Claude Code、Codex、Cursor）的英文 prompt，說明怎麼呼叫 API、怎麼等候輪到它，以及怎麼處理錯誤。

curl http://127.0.0.1:8001/v1/chat/completions \
  -H "Authorization: Bearer $LINT_API_KEY" -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Hello"}]}'

寫作模式

任務有文法校對與潤飾、翻譯、自訂 Prompt。校對可選五種語氣：「保留原語氣」只改錯，不動你的用字；「道地」（預設）也會改寫文法正確、但母語者不會這樣說的英文，並把組得不對的句子理順（主詞說了兩次、子句順序混亂），同時保留你的語氣：問句仍是問句、縮寫或完整形式照原文、俚語與表情符號保留，不加招呼語、委婉語或套語；「正式」、「輕鬆」、**「簡潔」**則改寫成那種風格。翻譯可選保留原語氣、正式、輕鬆、簡潔。每個任務各自記住自己的語氣，自訂 Prompt 不套用語氣。例如 “Kindly revert back to me at the earliest.” 在「道地」下會變成 “Please get back to me as soon as possible.”。「道地」「正式」「輕鬆」「簡潔」也接受中文或其他語言：會先理解文字的意思，再用英語母語者會說的方式寫出來，輸出一律是英文，例如「抱歉，這個需求我們這季排不進去，下季再評估看看。」會變成 “Sorry, we can't fit this request into this quarter. Let's reassess it next quarter.”。中文或日文、韓文、泰文等有自己文字的語言夾雜英文時，要整段寫成英文（預設），還是保留那個語言、只改英文，可在設定 → 一般選擇；越南文、印尼文等用拉丁字母的語言夾英文時一律寫成英文。「道地」的答案語氣跑掉時會重試一次；重試後只剩語氣略有不同時，會附上提醒顯示，自己加進太多新字則保留原文。英文裡夾著的其他語言文字（例如韓文的檔名或品名）會原樣保留。結果和原文相同時，Lint 會明確告知；如果用的是「保留原語氣」，還會提供改用「道地」的選項。取代原文之前請先看過結果：本機的小型模型有時會把本來就很道地的句子改寫，風格也可能偏離原意。Apple Intelligence 有時會回覆中文原文而不是改寫它，所以在「自動」模式下，從中文或其他語言寫成英文時，只要本機模型已經裝好就會改用本機模型。「保留原語氣」只處理英文：完全沒有英文、或用拉丁字母寫的其他語言（例如越南文、印尼文）不會送去校對，翻譯則是把英文翻成翻譯語言。

記憶與作夢（選用，預設關閉）

在「設定 → 記憶」開啟後，Lint 會留意你修正過的寫作習慣（拼錯的字、漏掉的冠詞），記成簡短的規則，從下一次建議就開始使用。關閉時，Lint 的行為與以前完全相同。符合你正在寫的內容的少數記憶（最多五行短句）會加在送給模型的 prompt 結尾；使用本機模型時，這些都留在你的 Mac 上。

• 全部只存在你的 Mac：~/Library/Application Support/Lint/LintLearning.sqlite（僅你本人可讀）。設定頁現在叫記憶，檔名仍是 LintLearning.sqlite。
• 只保存抽象後的規則（一個字、一小段詞組或模板句），不保存周圍的文字。數字、網址、路徑、縮寫與大寫開頭的人名不會被記下。Lint 認不出中文人名或全小寫的英文名，被你修正過的名字仍可能進入記憶；可在「設定 → 記憶 → 管理記憶」查看並刪除。
• 你對建議做了什麼（取代、複製、重寫）只以帶金鑰的雜湊記錄，不含文字；金鑰放在鑰匙圈。
• 觀察模式（「設定 → 記憶」，預設關閉）：給過建議後，Lint 會繼續讀取那個輸入框，直到文字送出（輸入框清空）、輸入框消失，或 10 分鐘沒有變動，並記下建議是被採用、打開後沒用，還是從未打開。文字只在記憶體裡比對；資料庫只會多出各 App（以 bundle ID 為鍵）會隨時間淡出的次數，以及「打開後沒有採用」的建議的帶金鑰雜湊事件。Lint 會從送出的文字學到哪些地方不要改：取代後你又改回原字，就記成「保留這個字」的記憶，下一次建議就開始使用；你看過建議、但送出時沒有採用的改動，要發生兩次才會成為記憶，而且只限單純校對（「保留原語氣」與「道地」），因為其他語氣本來就會改寫。你保留下來的冠詞或介系詞，只會削弱要求修正它的那條記憶。被檢查的那段文字之後才打的字，以及它的最後一個字，不列入判斷。它還會統計四種「建議想改、而你有自己寫法」的地方：保留縮寫、保留完整寫法、訊息結尾不加句點、開頭用小寫。某一種近期出現至少 8 次、其中八成你都保留自己的寫法時，作夢會把它寫進一條「你的寫作風格」記憶，提醒模型照原樣保留；保留的比例掉到六成以下就會撤回。只在「保留原語氣」與「道地」下統計；這條記憶和其他記憶一樣可以改寫、釘選、停用或刪除（刪除後不會再產生）。作夢時還會依 App 調整：某個 App 近期有 30 次 session 都沒有採用建議、也沒有任何一次採用，就變成「安靜」，Lint 不再自動為它準備建議，⌥⌘K 照常可用，在那裡按一次就會恢復；某個 App 近期被採用的建議裡，同一種語氣至少 3 次且佔八成，那裡的自動建議就改用那種語氣，選單列顯示的仍是你選的語氣，浮窗標題顯示實際用的語氣，手動選語氣就會取消。「設定 → 記憶」會列出這些調整，每一條都可以移除，也會顯示近期採用率。細節見 SECURITY.md。
• 記下就用，證明有用才留下。 新記下的記憶是短期記憶，下一次建議就會用到。7 天內同樣的樣式又出現（你又做了同樣的修正，或模型照提醒改了而你接受），它就轉成長期記憶；沒有的話就忘記：不再使用，只在背景留下痕跡，之後如果再出現，會被認出來並直接成為長期記憶。模型改的、要看句子而定的修正（換成另一個字，或同一個字的另一種形式，例如 tickets 改成 ticket）要再出現一次才會使用。你推翻某條記憶要求的改法時，除非它已經很穩固，否則會立刻忘記。長期記憶不再出現就會淡出：超過一個月沒出現後，證據每三個月減半（一般規則每六個月、核心記憶每一年），低於起始的一半就忘記。淡掉的痕跡會從資料庫永久刪除，大約是最後一次出現後三到十一個月。已釘選與已停用的記憶不會淡出，它們和你改寫過的記憶都不會被刪除；按「啟用」可以把忘記的記憶找回來。
• 作夢（「設定 → 記憶 → 作夢」）：Lint 會記下哪些記憶證明有用、哪些要忘記，刪除已經淡掉的痕跡，並把同一類的多條記憶歸納成一條一般規則（目前只處理：你在不同動詞後反覆刪掉的介系詞，例如「discuss about」與「mention about」）。規則由固定模板寫成，不會含有任何你寫過的字。被歸納的記憶都會保留：規則使用中時它們標示為「已由一般規則涵蓋」並暫時不進 prompt，規則淡出、停用或被刪除後就自動恢復；文字裡出現它自己那個字時，它仍會單獨提醒。已釘選、已停用與你手動改寫過的記憶不會被歸納，你刪掉的規則不會再被重新產生，持續數週都證明有用的規則會升為核心記憶。作夢只在這台 Mac 上進行（不連雲端、不下載模型），會等到你不在等建議時才開始；Lint 使用期間至少每天自動作夢一次（啟動後一分鐘，或當天第一次回饋後），累積足夠的新記憶後也會作夢，也可按「現在作夢」，完成後會顯示記住、忘記與刪除了幾條。
• 在「設定 → 記憶 → 管理記憶」可以查看、改寫、釘選、停用或刪除每一條記憶，看到它是短期、長期還是已忘記（已忘記的要切換才會列出）、是具體、一般還是核心，以及規則由哪些記憶歸納而來，也能全部清除或重設整個資料庫。

測試

swift test

測試不會下載模型。LINT_LIVE_DOWNLOAD=1 swift test --filter LiveModelDownloadTests 會另外從 Hugging Face 下載一個 1.2 MB 的公開檔案，用真實服務檢查轉址與續傳。

授權

MIT。內建的 llama.cpp 執行環境同為 MIT 授權，授權文件在 App 內（Contents/Resources/LlamaRuntime/<arch>/licenses，也可從「設定 → 關於」開啟）。