@@ -34,6 +34,11 @@ export const ModelLabel = Schema.Literals(["name", "id"]).annotate({
   description:
     "How message footers and the prompt label a model: 'name' (default) shows its display name, 'id' shows providerID/modelID, e.g. anthropic/claude-sonnet-4-5",
 })
+export const Syntax = Schema.Struct({
+  bash: Schema.optional(Schema.Boolean).annotate({
+    description: "Color the bash tool's command as shell code (default: true)",
+  }),
+}).annotate({ description: "Syntax highlighting in tool calls" })
 export const Cursor = Schema.Struct({
   style: Schema.optional(Schema.Literals(["block", "underline", "line", "default"])).annotate({
     description: "Cursor shape. Use 'default' to preserve the terminal setting",
@@ -471,6 +476,7 @@ export const Info = Schema.Struct({
   footer: Schema.optional(Footer),
   datetime_format: Schema.optional(DateTimeFormat),
   tool_output: Schema.optional(ToolOutput),
+  syntax: Schema.optional(Syntax),
   cursor: Schema.optional(Cursor),
   sidebar: Schema.optional(Sidebar),
   usage: Schema.optional(Usage),
 
@@ -65,6 +65,8 @@ import { DialogSessionRename } from "../../component/dialog-session-rename"
 import { Sidebar } from "./sidebar"
 import { SubagentFooter } from "./subagent-footer.tsx"
 import { filetype } from "../../util/filetype"
+import { cachedTreeSitterClient } from "../../util/highlight-cache"
+import { narrowBashHighlights } from "../../util/bash-highlight"
 import parsers from "../../parsers-config"
 import { errorMessage } from "../../util/error"
 import { Toast, useToast } from "../../ui/toast"
@@ -2569,8 +2571,15 @@ function Shell(props: ToolProps) {
           onClick={collapsed().overflow ? () => setExpanded((prev) => !prev) : undefined}
         >
           <box gap={1}>
-            <Show when={isRunning()} fallback={<text fg={theme.text}>$ {stringValue(props.input.command)}</text>}>
-              <Spinner color={theme.text}>{stringValue(props.input.command)}</Spinner>
+            <Show
+              when={ctx.tui.syntax?.bash !== false}
+              fallback={
+                <Show when={isRunning()} fallback={<text fg={theme.text}>$ {stringValue(props.input.command)}</text>}>
+                  <Spinner color={theme.text}>{stringValue(props.input.command)}</Spinner>
+                </Show>
+              }
+            >
+              <ShellCommand command={stringValue(props.input.command) ?? ""} running={isRunning()} />
             </Show>
             <Show when={limited()}>
               <text fg={theme.text}>{limited()}</text>
@@ -2587,6 +2596,32 @@ function Shell(props: ToolProps) {
   )
 }
 
+// The command as shell code. It draws as plain text at once and takes its colors when the parser
+// worker answers, which the shared cache makes immediate for a command already seen.
+export function ShellCommand(props: { command: string; running: boolean }) {
+  const { theme, syntax } = useTheme()
+  return (
+    <box flexDirection="row">
+      <Show when={props.running} fallback={<text fg={theme.text}>$ </text>}>
+        <box paddingRight={1}>
+          <Spinner color={theme.text} />
+        </box>
+      </Show>
+      <code
+        flexGrow={1}
+        flexShrink={1}
+        conceal={false}
+        fg={theme.text}
+        filetype="bash"
+        syntaxStyle={syntax()}
+        treeSitterClient={cachedTreeSitterClient()}
+        onHighlight={(highlights, context) => narrowBashHighlights(highlights, context.content)}
+        content={props.command}
+      />
+    </box>
+  )
+}
+
 function Write(props: ToolProps) {
   const { theme, syntax } = useTheme()
   const pathFormatter = usePathFormatter()
 
@@ -0,0 +1,21 @@
+import type { SimpleHighlight } from "@opentui/core"
+
+// nvim-treesitter's bash query narrows three captures with #lua-match?, a Neovim predicate that
+// web-tree-sitter does not evaluate, so every word would come back as a number and every variable
+// as a constant. These are those patterns, widened to the other captures sharing the group name:
+// number nodes in arithmetic and special variables such as $? and $@.
+const NARROWED: Record<string, RegExp> = {
+  number: /^[-+]?(0x[\da-f]+|\d+(#\w+)?)$/i,
+  constant: /^([A-Z][A-Z_0-9]*|[*@?!#$0_-])$/,
+  "keyword.directive": /^#!\//,
+}
+
+// The query also tags comments `@comment @spell`, and the theme colors spell as plain text, which
+// would override the comment color. Spell marks text for a spell checker, not for color.
+const SPELL = new Set(["spell", "nospell"])
+
+export function narrowBashHighlights(highlights: SimpleHighlight[], content: string) {
+  return highlights.filter(
+    ([start, end, group]) => !SPELL.has(group) && (NARROWED[group]?.test(content.slice(start, end)) ?? true),
+  )
+}
@@ -0,0 +1,60 @@
+import { getTreeSitterClient, type TreeSitterClient } from "@opentui/core"
+
+type HighlightOnce = TreeSitterClient["highlightOnce"]
+type HighlightResult = Awaited<ReturnType<HighlightOnce>>
+
+// The parser worker's answer for a piece of text, kept by content and language. A <code> block
+// asks the worker every time it is created, so without this a remounted transcript, a reopened
+// session or a theme switch reparses every command it shows. Concurrent requests for the same
+// text share one worker round trip, and a failed request is forgotten so it can be retried.
+export function createHighlightCache(highlightOnce: HighlightOnce, limit = { entries: 1000, chars: 4_000_000 }) {
+  const entries = new Map<string, { result: Promise<HighlightResult>; chars: number }>()
+  let chars = 0
+
+  function evict() {
+    for (const [key, entry] of entries) {
+      if (entries.size <= limit.entries && chars <= limit.chars) return
+      entries.delete(key)
+      chars -= entry.chars
+    }
+  }
+
+  return (content: string, filetype: string): Promise<HighlightResult> => {
+    const key = `${filetype}\0${content}`
+    const hit = entries.get(key)
+    if (hit) {
+      entries.delete(key)
+      entries.set(key, hit)
+      return hit.result
+    }
+    const result = highlightOnce(content, filetype)
+    const entry = { result, chars: content.length }
+    entries.set(key, entry)
+    chars += entry.chars
+    evict()
+    result.catch(() => {
+      if (entries.get(key) !== entry) return
+      entries.delete(key)
+      chars -= entry.chars
+    })
+    return result
+  }
+}
+
+let shared: TreeSitterClient | undefined
+
+// The shared parser worker with highlightOnce answered from the cache above. Everything else is
+// the worker itself, so <code treeSitterClient={...}> keeps a single worker.
+export function cachedTreeSitterClient() {
+  if (shared) return shared
+  const client = getTreeSitterClient()
+  const highlightOnce = createHighlightCache(client.highlightOnce.bind(client))
+  shared = new Proxy(client, {
+    get(target, property) {
+      if (property === "highlightOnce") return highlightOnce
+      const value = Reflect.get(target, property, target)
+      return typeof value === "function" ? value.bind(target) : value
+    },
+  })
+  return shared
+}
@@ -100,6 +100,8 @@ test("validates config constraints", () => {
   expect(() => decodeInfo({ datetime_format: { date: "YYYY-mm-dd" } })).toThrow()
   expect(() => decodeInfo({ datetime_format: { date: "DD Mon YYYY" } })).toThrow()
   expect(() => decodeInfo({ datetime_format: { time: "" } })).toThrow()
+  expect(decodeInfo({ syntax: { bash: false } })).toEqual({ syntax: { bash: false } })
+  expect(() => decodeInfo({ syntax: { bash: "off" } })).toThrow()
   expect(decodeInfo({ attention: { sounds: { unknown: "sound.wav" } } })).toEqual({ attention: { sounds: {} } })
 })
 
 
@@ -0,0 +1,54 @@
+import { expect, test } from "bun:test"
+import type { SimpleHighlight } from "@opentui/core"
+import { narrowBashHighlights } from "../../src/util/bash-highlight"
+
+function groups(content: string, highlights: SimpleHighlight[]) {
+  return narrowBashHighlights(highlights, content).map(([start, end, group]) => `${content.slice(start, end)}:${group}`)
+}
+
+test("keeps the number capture only on numbers", () => {
+  const content = "sleep 10 ls 0x1F 2#101"
+  expect(
+    groups(content, [
+      [0, 5, "number"],
+      [6, 8, "number"],
+      [9, 11, "number"],
+      [12, 16, "number"],
+      [17, 22, "number"],
+    ]),
+  ).toEqual(["10:number", "0x1F:number", "2#101:number"])
+})
+
+test("keeps the constant capture only on upper-case and special variables", () => {
+  const content = "$HOME $path $? $@"
+  expect(
+    groups(content, [
+      [1, 5, "constant"],
+      [7, 11, "constant"],
+      [13, 14, "constant"],
+      [16, 17, "constant"],
+    ]),
+  ).toEqual(["HOME:constant", "?:constant", "@:constant"])
+})
+
+test("keeps the directive capture only on a shebang and leaves other groups alone", () => {
+  const content = "#!/bin/sh\n# note\necho"
+  expect(
+    groups(content, [
+      [0, 9, "keyword.directive"],
+      [10, 16, "keyword.directive"],
+      [17, 21, "function.call"],
+    ]),
+  ).toEqual(["#!/bin/sh:keyword.directive", "echo:function.call"])
+})
+
+test("drops the spell captures that would override a comment's color", () => {
+  const content = "ls # list"
+  expect(
+    groups(content, [
+      [3, 9, "comment"],
+      [3, 9, "spell"],
+      [0, 2, "nospell"],
+    ]),
+  ).toEqual(["# list:comment"])
+})
@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test"
+import { createHighlightCache } from "../../src/util/highlight-cache"
+
+function worker() {
+  const calls: string[] = []
+  const highlightOnce = (content: string, filetype: string) => {
+    calls.push(`${filetype}:${content}`)
+    if (content === "fail") return Promise.reject(new Error("worker failed"))
+    return Promise.resolve({ highlights: [[0, content.length, "string"] as [number, number, string]] })
+  }
+  return { calls, highlightOnce }
+}
+
+describe("createHighlightCache", () => {
+  test("answers the same text and language from the first result", async () => {
+    const fake = worker()
+    const highlight = createHighlightCache(fake.highlightOnce)
+    const first = highlight("echo hi", "bash")
+    const second = highlight("echo hi", "bash")
+    expect(second).toBe(first)
+    expect(await second).toEqual({ highlights: [[0, 7, "string"]] })
+    expect(fake.calls).toEqual(["bash:echo hi"])
+  })
+
+  test("keys by language as well as content", async () => {
+    const fake = worker()
+    const highlight = createHighlightCache(fake.highlightOnce)
+    await highlight("x = 1", "bash")
+    await highlight("x = 1", "python")
+    expect(fake.calls).toEqual(["bash:x = 1", "python:x = 1"])
+  })
+
+  test("drops the least recently used entry past the entry limit", async () => {
+    const fake = worker()
+    const highlight = createHighlightCache(fake.highlightOnce, { entries: 2, chars: 1000 })
+    await highlight("a", "bash")
+    await highlight("b", "bash")
+    await highlight("a", "bash")
+    await highlight("c", "bash")
+    await highlight("a", "bash")
+    await highlight("b", "bash")
+    expect(fake.calls).toEqual(["bash:a", "bash:b", "bash:c", "bash:b"])
+  })
+
+  test("drops entries past the character budget", async () => {
+    const fake = worker()
+    const highlight = createHighlightCache(fake.highlightOnce, { entries: 100, chars: 5 })
+    await highlight("aaa", "bash")
+    await highlight("bbb", "bash")
+    await highlight("aaa", "bash")
+    expect(fake.calls).toEqual(["bash:aaa", "bash:bbb", "bash:aaa"])
+  })
+
+  test("asks the worker again after a failed request", async () => {
+    const fake = worker()
+    const highlight = createHighlightCache(fake.highlightOnce)
+    await expect(highlight("fail", "bash")).rejects.toThrow("worker failed")
+    await expect(highlight("fail", "bash")).rejects.toThrow("worker failed")
+    expect(fake.calls).toEqual(["bash:fail", "bash:fail"])
+  })
+})
@@ -528,6 +528,7 @@ No key is shared between the prompt and conversation scrolling, so each one does
 - `transcript.max_messages` - How many of a session's most recent messages the TUI keeps loaded (default: `100`). Older messages are hidden behind a divider showing how many there are, with actions to load 50 more from either edge of the gap or all of them. The same actions are in the command palette and `/load-hidden` loads all of them.
 - `transcript.keep_first_prompt` - Keep the session's first prompt at the top, above the divider, when older messages are hidden (default: `true`).
 - `attention` - Configures TUI desktop notifications and sounds. Disabled by default.
+- `syntax` - Controls syntax highlighting in tool calls. [Learn more](#syntax-highlighting).
 - `sidebar.order` - Session sidebar sections in display order, for example `["todo", "context"]`. Built-in sections are `context`, `mcp`, `lsp`, `todo`, and `files`; plugin sections use their plugin id. Sections you do not list follow in their default order. The session title always stays first.
 - `sidebar.hidden` - Session sidebar sections to hide, using the same names as `sidebar.order`.
 
@@ -657,6 +658,20 @@ Each value is a number of lines or `"never"`:
 
 `write`, `edit` and `apply_patch` count rendered rows of the file or diff, so a side-by-side diff collapses to that many rows. A deleted file in a patch is a single line and never collapses. Generic tools show their output only while **Show generic tool output** is on.
 
+### Syntax highlighting
+
+Tool calls are colored by language. Each part can be turned on or off under `syntax`:
+
+```json title="tui.json"
+{
+  "syntax": {
+    "bash": true
+  }
+}
+```
+
+- `bash` - Color the bash tool's command as shell code. Defaults to `true`.
+
 ### Paste summary
 
 A paste of three lines or more, or of more than 150 characters, goes into the prompt as a placeholder such as `[Pasted ~12 lines]`; the pasted text is sent in its place. `prompt.paste_summary` changes when that happens and what the placeholder says: