Bump tree-sitter-yaml to avoid submodule error during build

Fix formatter comment in default settings (#2593 )
Fix comment related to the `formatter` configuration option in Zed's default settings. Release Notes: - N/A
2023-06-09 14:58:31 -07:00 · 2023-06-09 15:14:04 -04:00 · 2023-06-09 11:50:35 -07:00 · 2023-06-09 11:50:15 -07:00 · 2023-06-09 11:37:47 -07:00 · 2023-06-09 11:37:39 -07:00
416 changed files with 26983 additions and 13461 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -0,0 +1,12 @@
+[[PR Description]]
+
+Release Notes:
+
+- N/A
+
+or
+
+- (Added|Fixed|Improved) ... ([#<public_issue_number_if_exists>](https://github.com/zed-industries/community/issues/<public_issue_number_if_exists>)).
+
+If the release notes are only intended for a specific release channel only, add `(<release_channel>-only)` to the end of the release note line.
+These will be removed by the person making the release.
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -42,6 +42,7 @@ jobs:
    runs-on:
      - self-hosted
      - test
+    needs: rustfmt
    env:
      RUSTFLAGS: -D warnings
    steps:
@@ -62,6 +63,9 @@ jobs:
          clean: false
          submodules: 'recursive'

+      - name: Limit target directory size
+        run: script/clear-target-dir-if-larger-than 70
+
      - name: Run check
        run: cargo check --workspace

@@ -82,14 +86,13 @@ jobs:
    runs-on:
      - self-hosted
      - bundle
-    if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') }}
+    if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
    needs: tests
    env:
      MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
      MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
      APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
      APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
-      ZED_MIXPANEL_TOKEN: ${{ secrets.ZED_MIXPANEL_TOKEN }}
    steps:
      - name: Install Rust
        run: |
@@ -110,6 +113,9 @@ jobs:
          clean: false
          submodules: 'recursive'

+      - name: Limit target directory size
+        run: script/clear-target-dir-if-larger-than 70
+
      - name: Determine version and release channel
        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
        run: |
@@ -141,11 +147,11 @@ jobs:
      - name: Create app bundle
        run: script/bundle

-      - name: Upload app bundle to workflow run if main branch
+      - name: Upload app bundle to workflow run if main branch or specifi label
        uses: actions/upload-artifact@v2
-        if: ${{ github.ref == 'refs/heads/main' }}
+        if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
        with:
-          name: Zed.dmg
+          name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
          path: target/release/Zed.dmg

      - uses: softprops/action-gh-release@v1
--- a/.github/workflows/randomized_tests.yml
+++ b/.github/workflows/randomized_tests.yml
@@ -6,8 +6,8 @@ on:
  push:
    branches:
      - randomized-tests-runner
-  schedule:
-     - cron: '0 * * * *'
+  # schedule:
+  #    - cron: '0 * * * *'

 env:
  CARGO_TERM_COLOR: always
--- a/.github/workflows/release_actions.yml
+++ b/.github/workflows/release_actions.yml
@@ -14,26 +14,10 @@ jobs:
        content: |
          📣 Zed ${{ github.event.release.tag_name }} was just released!

-          Restart your Zed or head to https://zed.dev/releases/latest to grab it.
+          Restart your Zed or head to https://zed.dev/releases/stable/latest to grab it.

          ```md
          # Changelog

          ${{ github.event.release.body }}
          ```
-  mixpanel_release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: "3.10.5"
-          architecture: "x64"
-          cache: "pip"
-      - run: pip install -r script/mixpanel_release/requirements.txt
-      - run: >
-          python script/mixpanel_release/main.py
-          ${{ github.event.release.tag_name }}
-          ${{ secrets.MIXPANEL_PROJECT_ID }}
-          ${{ secrets.MIXPANEL_SERVICE_ACCOUNT_USERNAME }}
-          ${{ secrets.MIXPANEL_SERVICE_ACCOUNT_SECRET }}
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [workspace]
 members = [
    "crates/activity_indicator",
-    "crates/assets",
+    "crates/ai",
    "crates/auto_update",
    "crates/breadcrumbs",
    "crates/call",
@@ -77,7 +77,9 @@ async-trait = { version = "0.1" }
 ctor = { version = "0.1" }
 env_logger = { version = "0.9" }
 futures = { version = "0.3" }
-glob = { version = "0.3.1" }
+globset = { version = "0.4" }
+indoc = "1"
+isahc = "1.7.2"
 lazy_static = { version = "1.4.0" }
 log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 ordered-float = { version = "2.1.1" }
@@ -85,6 +87,8 @@ parking_lot = { version = "0.11.1" }
 postage = { version = "0.5", features = ["futures-traits"] }
 rand = { version = "0.8.5" }
 regex = { version = "1.5" }
+rust-embed = { version = "6.3", features = ["include-exclude"] }
+schemars = { version = "0.8" }
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] }
@@ -93,6 +97,7 @@ smol = { version = "1.2" }
 tempdir = { version = "0.3.7" }
 thiserror = { version = "1.0.29" }
 time = { version = "0.3", features = ["serde", "serde-well-known"] }
+toml = { version = "0.5" }
 unindent = { version = "0.1.7" }

 [patch.crates-io]
@@ -111,3 +116,4 @@ split-debuginfo = "unpacked"

 [profile.release]
 debug = true
+lto = "thin"
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 # syntax = docker/dockerfile:1.2

-FROM rust:1.65-bullseye as builder
+FROM rust:1.70-bullseye as builder
 WORKDIR app
 COPY . .

--- a/assets/contexts/system.zmd
+++ b/assets/contexts/system.zmd
@@ -0,0 +1,6 @@
+User input begins on a line starting with /.
+Don't apologize ever.
+Never say "I apologize".
+Use simple language and don't flatter the users.
+Keep it short.
+Risk being rude.
--- a/assets/icons/speech_bubble_12.svg
+++ b/assets/icons/speech_bubble_12.svg
@@ -1,3 +1,3 @@
-<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M10.6667 0.400196H1.33346C0.819658 0.400196 0.399658 0.820196 0.399658 1.3326V10.6658C0.399658 11.181 0.816998 11.5982 1.33206 11.5982C1.58966 11.5982 1.82206 11.4932 1.99146 11.3238L4.51706 8.79684H10.6639C11.1763 8.79684 11.5963 8.37544 11.5963 7.86304V1.3298C11.5963 0.815996 11.1749 0.395996 10.6625 0.395996L10.6667 0.400196ZM2.2667 2.2664H6.00008V3.1988H2.26628V2.265L2.2667 2.2664ZM7.8667 6.93316H2.2667V5.99936H7.8667V6.93176V6.93316ZM9.7329 5.06556H2.26488V4.13176H9.73164V5.06416L9.7329 5.06556Z" fill="#282C34"/>
+<svg width="12" height="11" viewBox="0 0 12 11" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M6.01077 0.000234794C2.69085 0.000234794 0.000639074 2.18612 0.000639074 4.88385C0.000639074 6.0491 0.501914 7.11387 1.33823 7.95254C1.04475 9.13517 0.0640321 10.1894 0.0522927 10.2011C-0.00053487 10.2539 -0.0153266 10.3356 0.0170743 10.4061C0.0464229 10.4763 0.111459 10.5185 0.187766 10.5185C1.74324 10.5185 2.89019 9.77286 3.4889 9.31197C4.25431 9.60052 5.10894 9.76722 6.01053 9.76722C9.33045 9.76722 12 7.58063 12 4.88361C12 2.18659 9.33045 0 6.01053 0L6.01077 0.000234794Z" fill="#FAFAFA"/>
 </svg>
--- a/assets/icons/version_control_branch_12.svg
+++ b/assets/icons/version_control_branch_12.svg
@@ -0,0 +1,3 @@
+<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4.75 1.875C4.75 2.71406 4.19922 3.42422 3.4375 3.66328V5.97891C3.9086 5.64609 4.4711 5.4375 5.125 5.4375H7.375C8.30782 5.4375 9.0625 4.68281 9.0625 3.75V3.66328C8.30078 3.42422 7.75 2.71406 7.75 1.875C7.75 0.839531 8.58907 0 9.625 0C10.6609 0 11.5 0.839531 11.5 1.875C11.5 2.71406 10.9492 3.42422 10.1875 3.66328V3.75C10.1875 5.30391 8.92891 6.5625 7.375 6.5625H5.125C4.19219 6.5625 3.4375 7.31719 3.4375 8.25V8.33672C4.19922 8.57578 4.75 9.28594 4.75 10.125C4.75 11.1609 3.91094 12 2.875 12C1.83953 12 1 11.1609 1 10.125C1 9.28594 1.55172 8.57578 2.3125 8.33672V3.66328C1.55172 3.42422 1 2.71406 1 1.875C1 0.839531 1.83953 0 2.875 0C3.91094 0 4.75 0.839531 4.75 1.875ZM2.875 2.625C3.28914 2.625 3.625 2.28914 3.625 1.875C3.625 1.46086 3.28914 1.125 2.875 1.125C2.46086 1.125 2.125 1.46086 2.125 1.875C2.125 2.28914 2.46086 2.625 2.875 2.625ZM9.625 1.125C9.21016 1.125 8.875 1.46086 8.875 1.875C8.875 2.28914 9.21016 2.625 9.625 2.625C10.0398 2.625 10.375 2.28914 10.375 1.875C10.375 1.46086 10.0398 1.125 9.625 1.125ZM2.875 10.875C3.28914 10.875 3.625 10.5398 3.625 10.125C3.625 9.71016 3.28914 9.375 2.875 9.375C2.46086 9.375 2.125 9.71016 2.125 10.125C2.125 10.5398 2.46086 10.875 2.875 10.875Z" fill="white"/>
+</svg>
--- a/assets/keymaps/atom.json
+++ b/assets/keymaps/atom.json
@@ -16,6 +16,12 @@
          "replace_newest": true
        }
      ],
+      "ctrl-cmd-g": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": true
+        }
+      ],
      "ctrl-shift-down": "editor::AddSelectionBelow",
      "ctrl-shift-up": "editor::AddSelectionAbove",
      "cmd-shift-backspace": "editor::DeleteToBeginningOfLine",
@@ -39,8 +45,8 @@
  {
    "context": "Workspace",
    "bindings": {
-      "cmd-\\": "workspace::ToggleLeftSidebar",
-      "cmd-k cmd-b": "workspace::ToggleLeftSidebar",
+      "cmd-\\": "workspace::ToggleLeftDock",
+      "cmd-k cmd-b": "workspace::ToggleLeftDock",
      "cmd-t": "file_finder::Toggle",
      "cmd-shift-r": "project_symbols::Toggle"
    }
@@ -62,9 +68,5 @@
      "ctrl-f": "project_panel::ExpandSelectedEntry",
      "ctrl-shift-c": "project_panel::CopyPath"
    }
-  },
-  {
-    "context": "Dock",
-    "bindings": {}
  }
 ]
--- a/assets/keymaps/default.json
+++ b/assets/keymaps/default.json
@@ -39,7 +39,8 @@
      "cmd-shift-n": "workspace::NewWindow",
      "cmd-o": "workspace::Open",
      "alt-cmd-o": "projects::OpenRecent",
-      "ctrl-`": "workspace::NewTerminal"
+      "ctrl-~": "workspace::NewTerminal",
+      "ctrl-`": "terminal_panel::ToggleFocus"
    }
  },
  {
@@ -67,10 +68,12 @@
      "cmd-z": "editor::Undo",
      "cmd-shift-z": "editor::Redo",
      "up": "editor::MoveUp",
+      "ctrl-up": "editor::MoveToStartOfParagraph",
      "pageup": "editor::PageUp",
      "shift-pageup": "editor::MovePageUp",
      "home": "editor::MoveToBeginningOfLine",
      "down": "editor::MoveDown",
+      "ctrl-down": "editor::MoveToEndOfParagraph",
      "pagedown": "editor::PageDown",
      "shift-pagedown": "editor::MovePageDown",
      "end": "editor::MoveToEndOfLine",
@@ -103,6 +106,8 @@
      "alt-shift-b": "editor::SelectToPreviousWordStart",
      "alt-shift-right": "editor::SelectToNextWordEnd",
      "alt-shift-f": "editor::SelectToNextWordEnd",
+      "ctrl-shift-up": "editor::SelectToStartOfParagraph",
+      "ctrl-shift-down": "editor::SelectToEndOfParagraph",
      "cmd-shift-up": "editor::SelectToBeginning",
      "cmd-shift-down": "editor::SelectToEnd",
      "cmd-a": "editor::SelectAll",
@@ -180,7 +185,8 @@
      ],
      "alt-\\": "copilot::Suggest",
      "alt-]": "copilot::NextSuggestion",
-      "alt-[": "copilot::PreviousSuggestion"
+      "alt-[": "copilot::PreviousSuggestion",
+      "cmd->": "assistant::QuoteSelection"
    }
  },
  {
@@ -191,7 +197,14 @@
    }
  },
  {
-    "context": "BufferSearchBar > Editor",
+    "context": "AssistantEditor > Editor",
+    "bindings": {
+      "cmd-enter": "assistant::Assist",
+      "cmd->": "assistant::QuoteSelection"
+    }
+  },
+  {
+    "context": "BufferSearchBar",
    "bindings": {
      "escape": "buffer_search::Dismiss",
      "tab": "buffer_search::FocusEditor",
@@ -199,6 +212,18 @@
      "shift-enter": "search::SelectPrevMatch"
    }
  },
+  {
+    "context": "ProjectSearchBar",
+    "bindings": {
+      "escape": "project_search::ToggleFocus"
+    }
+  },
+  {
+    "context": "ProjectSearchView",
+    "bindings": {
+      "escape": "project_search::ToggleFocus"
+    }
+  },
  {
    "context": "Pane",
    "bindings": {
@@ -207,7 +232,8 @@
      "cmd-shift-g": "search::SelectPrevMatch",
      "alt-cmd-c": "search::ToggleCaseSensitive",
      "alt-cmd-w": "search::ToggleWholeWord",
-      "alt-cmd-r": "search::ToggleRegex"
+      "alt-cmd-r": "search::ToggleRegex",
+      "shift-escape": "workspace::ToggleZoom"
    }
  },
  // Bindings from VS Code
@@ -226,12 +252,24 @@
          "replace_newest": false
        }
      ],
+      "ctrl-cmd-d": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": false
+        }
+      ],
      "cmd-k cmd-d": [
        "editor::SelectNext",
        {
          "replace_newest": true
        }
      ],
+      "cmd-k ctrl-cmd-d": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": true
+        }
+      ],
      "cmd-k cmd-i": "editor::Hover",
      "cmd-/": [
        "editor::ToggleComments",
@@ -349,7 +387,9 @@
        "workspace::ActivatePane",
        8
      ],
-      "cmd-b": "workspace::ToggleLeftSidebar",
+      "cmd-b": "workspace::ToggleLeftDock",
+      "cmd-r": "workspace::ToggleRightDock",
+      "cmd-j": "workspace::ToggleBottomDock",
      "cmd-shift-f": "workspace::NewSearch",
      "cmd-k cmd-t": "theme_selector::Toggle",
      "cmd-k cmd-s": "zed::OpenKeymap",
@@ -443,32 +483,6 @@
      "cmd-enter": "project_search::SearchInNew"
    }
  },
-  {
-    "context": "Workspace",
-    "bindings": {
-      "shift-escape": "dock::FocusDock"
-    }
-  },
-  {
-    "bindings": {
-      "cmd-shift-k cmd-shift-right": "dock::AnchorDockRight",
-      "cmd-shift-k cmd-shift-down": "dock::AnchorDockBottom",
-      "cmd-shift-k cmd-shift-up": "dock::ExpandDock"
-    }
-  },
-  {
-    "context": "Pane",
-    "bindings": {
-      "cmd-escape": "dock::AddTabToDock"
-    }
-  },
-  {
-    "context": "Pane && docked",
-    "bindings": {
-      "shift-escape": "dock::HideDock",
-      "cmd-escape": "dock::RemoveTabFromDock"
-    }
-  },
  {
    "context": "ProjectPanel",
    "bindings": {
@@ -504,7 +518,7 @@
        "terminal::SendText",
        "\u0001"
      ],
-      // Terminal.app compatability
+      // Terminal.app compatibility
      "alt-left": [
        "terminal::SendText",
        "\u001bb"
--- a/assets/keymaps/jetbrains.json
+++ b/assets/keymaps/jetbrains.json
@@ -11,6 +11,7 @@
      "ctrl->": "zed::IncreaseBufferFontSize",
      "ctrl-<": "zed::DecreaseBufferFontSize",
      "cmd-d": "editor::DuplicateLine",
+      "cmd-backspace": "editor::DeleteLine",
      "cmd-pagedown": "editor::MovePageDown",
      "cmd-pageup": "editor::MovePageUp",
      "ctrl-alt-shift-b": "editor::SelectToPreviousWordStart",
@@ -25,6 +26,12 @@
          "replace_newest": false
        }
      ],
+      "ctrl-cmd-g": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": false
+        }
+      ],
      "cmd-/": [
        "editor::ToggleComments",
        {
@@ -33,6 +40,7 @@
      ],
      "shift-alt-up": "editor::MoveLineUp",
      "shift-alt-down": "editor::MoveLineDown",
+      "cmd-alt-l": "editor::Format",
      "cmd-[": "pane::GoBack",
      "cmd-]": "pane::GoForward",
      "alt-f7": "editor::FindAllReferences",
@@ -63,17 +71,11 @@
  {
    "context": "Workspace",
    "bindings": {
+      "cmd-shift-o": "file_finder::Toggle",
      "cmd-shift-a": "command_palette::Toggle",
      "cmd-alt-o": "project_symbols::Toggle",
-      "cmd-1": "workspace::ToggleLeftSidebar",
-      "cmd-6": "diagnostics::Deploy",
-      "alt-f12": "dock::FocusDock"
-    }
-  },
-  {
-    "context": "Dock",
-    "bindings": {
-      "alt-f12": "dock::HideDock"
+      "cmd-1": "workspace::ToggleLeftDock",
+      "cmd-6": "diagnostics::Deploy"
    }
  }
 ]
--- a/assets/keymaps/sublime_text.json
+++ b/assets/keymaps/sublime_text.json
@@ -45,18 +45,11 @@
  {
    "context": "Workspace",
    "bindings": {
-      "ctrl-`": "dock::FocusDock",
-      "cmd-k cmd-b": "workspace::ToggleLeftSidebar",
+      "cmd-k cmd-b": "workspace::ToggleLeftDock",
      "cmd-t": "file_finder::Toggle",
      "shift-cmd-r": "project_symbols::Toggle",
      // Currently busted: https://github.com/zed-industries/feedback/issues/898
      "ctrl-0": "project_panel::ToggleFocus"
    }
-  },
-  {
-    "context": "Dock",
-    "bindings": {
-      "ctrl-`": "dock::HideDock"
-    }
  }
 ]
--- a/assets/keymaps/textmate.json
+++ b/assets/keymaps/textmate.json
@@ -68,7 +68,7 @@
  {
    "context": "Workspace",
    "bindings": {
-      "cmd-alt-ctrl-d": "workspace::ToggleLeftSidebar",
+      "cmd-alt-ctrl-d": "workspace::ToggleLeftDock",
      "cmd-t": "file_finder::Toggle",
      "cmd-shift-t": "project_symbols::Toggle"
    }
@@ -83,9 +83,5 @@
  {
    "context": "ProjectPanel",
    "bindings": {}
-  },
-  {
-    "context": "Dock",
-    "bindings": {}
  }
 ]
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1,6 +1,15 @@
 {
  // The name of the Zed theme to use for the UI
  "theme": "One Dark",
+  // The name of a base set of key bindings to use.
+  // This setting can take four values, each named after another
+  // text editor:
+  //
+  // 1. "VSCode"
+  // 2. "JetBrains"
+  // 3. "SublimeText"
+  // 4. "Atom"
+  "base_keymap": "VSCode",
  // Features that can be globally enabled or disabled
  "features": {
    // Show Copilot icon in status bar
@@ -30,9 +39,56 @@
  // Whether to pop the completions menu while typing in an editor without
  // explicitly requesting it.
  "show_completions_on_input": true,
+  // Whether to use additional LSP queries to format (and amend) the code after
+  // every "trigger" symbol input, defined by LSP server capabilities.
+  "use_on_type_format": true,
  // Controls whether copilot provides suggestion immediately
  // or waits for a `copilot::Toggle`
  "show_copilot_suggestions": true,
+  // Whether to show tabs and spaces in the editor.
+  // This setting can take two values:
+  //
+  // 1. Draw tabs and spaces only for the selected text (default):
+  //    "selection"
+  // 2. Do not draw any tabs or spaces:
+  //   "none"
+  // 3. Draw all invisible symbols:
+  //   "all"
+  "show_whitespaces": "selection",
+  // Scrollbar related settings
+  "scrollbar": {
+      // When to show the scrollbar in the editor.
+      // This setting can take four values:
+      //
+      // 1. Show the scrollbar if there's important information or
+      //    follow the system's configured behavior (default):
+      //   "auto"
+      // 2. Match the system's configured behavior:
+      //    "system"
+      // 3. Always show the scrollbar:
+      //    "always"
+      // 4. Never show the scrollbar:
+      //    "never"
+      "show": "auto",
+      // Whether to show git diff indicators in the scrollbar.
+      "git_diff": true
+  },
+  "project_panel": {
+      // Whether to show the git status in the project panel.
+      "git_status": true,
+      // Where to dock project panel. Can be 'left' or 'right'.
+      "dock": "left",
+      // Default width of the project panel.
+      "default_width": 240
+  },
+  "assistant": {
+      // Where to dock the assistant. Can be 'left', 'right' or 'bottom'.
+      "dock": "right",
+      // Default width when the assistant is docked to the left or right.
+      "default_width": 450,
+      // Default height when the assistant is docked to the bottom.
+      "default_height": 320
+  },
  // Whether the screen sharing icon is shown in the os status bar.
  "show_call_status_icon": true,
  // Whether to use language servers to provide code intelligence.
@@ -49,16 +105,6 @@
  // 4. Save when idle for a certain amount of time:
  //     "autosave": { "after_delay": {"milliseconds": 500} },
  "autosave": "off",
-  // Where to place the dock by default. This setting can take three
-  // values:
-  //
-  // 1. Position the dock attached to the bottom of the workspace
-  //     "default_dock_anchor": "bottom"
-  // 2. Position the dock to the right of the workspace like a side panel
-  //     "default_dock_anchor": "right"
-  // 3. Position the dock full screen over the entire workspace"
-  //     "default_dock_anchor": "expanded"
-  "default_dock_anchor": "bottom",
  // Whether or not to remove any trailing whitespace from lines of a buffer
  // before saving it.
  "remove_trailing_whitespace_on_save": true,
@@ -70,9 +116,9 @@
  // How to perform a buffer format. This setting can take two values:
  //
  // 1. Format code using the current language server:
-  //     "format_on_save": "language_server"
+  //     "formatter": "language_server"
  // 2. Format code using an external command:
-  //     "format_on_save": {
+  //     "formatter": {
  //       "external": {
  //         "command": "prettier",
  //         "arguments": ["--stdin-filepath", "{buffer_path}"]
@@ -149,6 +195,12 @@
    //         }
    //     }
    "shell": "system",
+    // Where to dock terminals panel. Can be 'left', 'right', 'bottom'.
+    "dock": "bottom",
+    // Default width when the terminal is docked to the left or right.
+    "default_width": 640,
+    // Default height when the terminal is docked to the bottom.
+    "default_height": 320,
    // What working directory to use when launching the terminal.
    // May take 4 values:
    // 1. Use the current file's project directory.  Will Fallback to the
@@ -201,7 +253,7 @@
    // copy to the system clipboard.
    "copy_on_select": false,
    // Any key-value pairs added to this list will be added to the terminal's
-    // enviroment. Use `:` to seperate multiple values.
+    // environment. Use `:` to separate multiple values.
    "env": {
      // "KEY": "value1:value2"
    },
--- a/assets/settings/initial_local_settings.json
+++ b/assets/settings/initial_local_settings.json
@@ -0,0 +1,11 @@
+// Folder-specific Zed settings
+//
+// A subset of Zed's settings can be configured on a per-folder basis.
+//
+// For information on how to configure Zed, see the Zed
+// documentation: https://zed.dev/docs/configuring-zed
+//
+// To see all of Zed's default settings without changing your
+// custom settings, run the `open default settings` command
+// from the command palette or from `Zed` application menu.
+{}
--- a/assets/settings/initial_user_settings.json
+++ b/assets/settings/initial_user_settings.json
@@ -1,7 +1,7 @@
-// Zed settings
+// Folder-specific settings
 //
-// For information on how to configure Zed, see the Zed
-// documentation: https://zed.dev/docs/configuring-zed
+// For a full list of overridable settings, and general information on folder-specific settings, see the documentation:
+// https://docs.zed.dev/configuration/configuring-zed#folder-specific-settings
 //
 // To see all of Zed's default settings without changing your
 // custom settings, run the `open default settings` command
--- a/crates/activity_indicator/Cargo.toml
+++ b/crates/activity_indicator/Cargo.toml
@@ -16,6 +16,11 @@ gpui = { path = "../gpui" }
 project = { path = "../project" }
 settings = { path = "../settings" }
 util = { path = "../util" }
+theme = { path = "../theme" }
 workspace = { path = "../workspace" }
+
 futures.workspace = true
 smallvec.workspace = true
+
+[dev-dependencies]
+editor = { path = "../editor", features = ["test-support"] }
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -9,7 +9,6 @@ use gpui::{
 };
 use language::{LanguageRegistry, LanguageServerBinaryStatus};
 use project::{LanguageServerProgress, Project};
-use settings::Settings;
 use smallvec::SmallVec;
 use std::{cmp::Reverse, fmt::Write, sync::Arc};
 use util::ResultExt;
@@ -325,12 +324,7 @@ impl View for ActivityIndicator {
        } = self.content_to_render(cx);

        let mut element = MouseEventHandler::<Self, _>::new(0, cx, |state, cx| {
-            let theme = &cx
-                .global::<Settings>()
-                .theme
-                .workspace
-                .status_bar
-                .lsp_status;
+            let theme = &theme::current(cx).workspace.status_bar.lsp_status;
            let style = if state.hovered() && on_click.is_some() {
                theme.hover.as_ref().unwrap_or(&theme.default)
            } else {
--- a/crates/ai/Cargo.toml
+++ b/crates/ai/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "ai"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+path = "src/ai.rs"
+doctest = false
+
+[dependencies]
+collections = { path = "../collections"}
+editor = { path = "../editor" }
+fs = { path = "../fs" }
+gpui = { path = "../gpui" }
+language = { path = "../language" }
+menu = { path = "../menu" }
+search = { path = "../search" }
+settings = { path = "../settings" }
+theme = { path = "../theme" }
+util = { path = "../util" }
+workspace = { path = "../workspace" }
+
+anyhow.workspace = true
+chrono = "0.4"
+futures.workspace = true
+isahc.workspace = true
+schemars.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+tiktoken-rs = "0.4"
+
+[dev-dependencies]
+editor = { path = "../editor", features = ["test-support"] }
--- a/crates/ai/README.zmd
+++ b/crates/ai/README.zmd
@@ -0,0 +1,63 @@
+> Hello, I'm Nathan Sobo.
+I'm currently your sole creator and the leader of Zed Industries.
+Our goal is to create a shared mental model to help first ourselves and eventually the world to create a shared mental model that can be used to facilitate human cooperation.
+
+< Hello, Nathan! Welcome back to Zed. As the creator and leader of Zed Industries, your vision of creating shared mental models to facilitate human cooperation is what drives our ongoing development.
+
+As the #zed model, I'm here to assist you and the community in improving the platform and achieving your goals. Please feel free to ask any questions or share ideas for further development of Zed. Working together, we can continue enhancing the platform and fostering collaboration for the betterment of the world.
+
+> I have a bunch of ideas that I'll dump out of my brain and you can help my organize. Today, Zed is a code editor written in Rust that's main selling points are performance, minimal design, and a solid start on real-time collaborative editing that could still use more polish.
+
+We've decided that our next milestone will be open-sourcing Zed on the Zed platform.
+
+< Nathan, it's exciting to hear that you have more ideas to enhance Zed! Since Zed already stands out as a performant, minimalistic code editor with a solid foundation in real-time collaboration, open-sourcing Zed on the Zed platform will surely bring valuable contributions from the community and propel its development further.
+
+Let's organize your ideas and create a plan for your next milestone. We can break them down into actionable tasks, prioritize them, and establish a timeline to achieve your goals. Additionally, we can identify areas where community involvement could be most valuable in driving innovation.
+
+Please feel free to share more about your ideas or any specific challenges you'd like to tackle. I'm here to help you turn these ideas into a cohesive and successful plan for Zed's future!
+
+@nathan> #zed, can you describe the conversation UI as you currently understand it.
+
+< Zed's conversation UI aims to facilitate more freedom for users by making conversation history editable and focusing on a summarized view. Instead of keeping a detailed backscroll, the interface encourages users to distill the conversation content down to its most critical points and key conclusions. This approach ensures that the vital information from the conversation is highlighted and easily accessible, while still maintaining a history that can be linked to when necessary.
+
+Addressing @nate's concerns, this design choice aims to strike a balance between readability, usability, and information preservation. The summarized view maintains the essence of the conversation without being burdened by extensive backscroll. Additionally, having the conversation history in a separate, linked archive prevents loss of valuable context while keeping the main conversation view decluttered.
+
+@nathan> What details around the conversation view are worth exploring?
+
+< @nathan, there are several aspects of the conversation view that are worth exploring and refining:
+
+1. Editing functionality: Ensuring that all participants can edit and refine the conversation summary effectively while preserving the original context.
+2. Permissions and access control: Determining how to manage editing rights, user roles, and visibility of the conversation summary and history.
+3. Navigation and linking: Implementing an intuitive system for navigating between the summarized conversation and linked history or reference materials.
+4. Visualization and layout: Designing the interface to clearly present the summarized information while providing a visually engaging and organized experience for participants.
+5. Threaded conversations and branching: Exploring ways to handle sub-conversations, supplementary discussions, or debates within the primary conversation view.
+
+Considering these aspects will ensure our conversation view design is optimized for usability, collaboration, and accessibility in Zed.
+
+@nathan> @nate, which of these would you like to explore?
+
+@nate> 2 feels like it isn't important at the moment, we can explore that later. Let's start with 4, which I think will lead us to discussion 3 and 5.
+
+#zed share your thoughts on the points we need to consider to design a layout and visualization for a conversation view between you (#zed) and multuple peoople, or between multiple people and multiple bots (you and other bots).
+
+@nathan> Agreed. I'm interested in threading I think more than anything. Or 4 yeah. I think we need to scope the threading conversation. Also, asking #zed to propose the solution... not sure it will be that effective but it's worth a try...
+
+#zed describe a hypothetical conversation UI that meets the description.
+
+< @nate and @nathan, I understand that you'd like to focus on the layout and visualization for a conversation view that can accommodate multiple people and potentially multiple bots as well. Here's a proposal for a conversation UI that meets the requirements:
+
+1. Main conversation area: Display the summarized conversation content in a clean and organized manner, ensuring readability and efficient use of space.
+
+2. Participant avatars and labels: Include user avatars and/or labels to distinguish between users and bots visually, allowing easy identification of each participant's contributions.
+
+3. Active threads indicator: Designate a clear indicator for ongoing threads, which will attract attention to active sub-conversations or related discussions in the conversation view.
+
+4. Dynamic branching: Implement a branching visual structure to present threaded conversations, clearly distinguishing sub-conversations, and enabling users to navigate between them smoothly.
+
+5. Multiple bot interaction support: Facilitate interactions between multiple bots through user-invoked prompts or bot-to-bot communication channels without disrupting the primary conversation flow.
+
+6. Expandable conversation history: Offer a separate, expandable section or panel to access historical content without cluttering the main conversation view.
+
+7. Linking and referencing: Implement a system for hyperlinking relevant information, resources, or previous conversations to the current discussion, making it easy for participants to follow and reference the shared context.
+
+This hypothetical conversation UI aims to address the layout and visualization, threading, and multi-participant aspects of your requirements. Of course, it's just an initial proposal, and we can refine and iterate on it based on your feedback and specific needs.
--- a/crates/ai/features.zmd
+++ b/crates/ai/features.zmd
@@ -0,0 +1,3 @@
+Push content to a deeper layer.
+A context can have multiple sublayers.
+You can enable or disable arbitrary sublayers at arbitrary nesting depths when viewing the document.
--- a/crates/ai/src/ai.rs
+++ b/crates/ai/src/ai.rs
@@ -0,0 +1,98 @@
+pub mod assistant;
+mod assistant_settings;
+
+pub use assistant::AssistantPanel;
+use gpui::AppContext;
+use serde::{Deserialize, Serialize};
+use std::fmt::{self, Display};
+
+// Data types for chat completion requests
+#[derive(Serialize)]
+struct OpenAIRequest {
+    model: String,
+    messages: Vec<RequestMessage>,
+    stream: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct RequestMessage {
+    role: Role,
+    content: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct ResponseMessage {
+    role: Option<Role>,
+    content: Option<String>,
+}
+
+#[derive(Clone, Copy, Serialize, Deserialize, Debug, Eq, PartialEq)]
+#[serde(rename_all = "lowercase")]
+enum Role {
+    User,
+    Assistant,
+    System,
+}
+
+impl Role {
+    pub fn cycle(&mut self) {
+        *self = match self {
+            Role::User => Role::Assistant,
+            Role::Assistant => Role::System,
+            Role::System => Role::User,
+        }
+    }
+}
+
+impl Display for Role {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Role::User => write!(f, "User"),
+            Role::Assistant => write!(f, "Assistant"),
+            Role::System => write!(f, "System"),
+        }
+    }
+}
+
+#[derive(Deserialize, Debug)]
+struct OpenAIResponseStreamEvent {
+    pub id: Option<String>,
+    pub object: String,
+    pub created: u32,
+    pub model: String,
+    pub choices: Vec<ChatChoiceDelta>,
+    pub usage: Option<Usage>,
+}
+
+#[derive(Deserialize, Debug)]
+struct Usage {
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+    pub total_tokens: u32,
+}
+
+#[derive(Deserialize, Debug)]
+struct ChatChoiceDelta {
+    pub index: u32,
+    pub delta: ResponseMessage,
+    pub finish_reason: Option<String>,
+}
+
+#[derive(Deserialize, Debug)]
+struct OpenAIUsage {
+    prompt_tokens: u64,
+    completion_tokens: u64,
+    total_tokens: u64,
+}
+
+#[derive(Deserialize, Debug)]
+struct OpenAIChoice {
+    text: String,
+    index: u32,
+    logprobs: Option<serde_json::Value>,
+    finish_reason: Option<String>,
+}
+
+pub fn init(cx: &mut AppContext) {
+    assistant::init(cx);
+}
--- a/crates/ai/src/assistant.rs
+++ b/crates/ai/src/assistant.rs
--- a/crates/ai/src/assistant_settings.rs
+++ b/crates/ai/src/assistant_settings.rs
@@ -0,0 +1,40 @@
+use anyhow;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::Setting;
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum AssistantDockPosition {
+    Left,
+    Right,
+    Bottom,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct AssistantSettings {
+    pub dock: AssistantDockPosition,
+    pub default_width: f32,
+    pub default_height: f32,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct AssistantSettingsContent {
+    pub dock: Option<AssistantDockPosition>,
+    pub default_width: Option<f32>,
+    pub default_height: Option<f32>,
+}
+
+impl Setting for AssistantSettings {
+    const KEY: Option<&'static str> = Some("assistant");
+
+    type FileContent = AssistantSettingsContent;
+
+    fn load(
+        default_value: &Self::FileContent,
+        user_values: &[&Self::FileContent],
+        _: &gpui::AppContext,
+    ) -> anyhow::Result<Self> {
+        Self::load_via_json_merge(default_value, user_values)
+    }
+}
--- a/crates/assets/Cargo.toml
+++ b/crates/assets/Cargo.toml
@@ -1,14 +0,0 @@
-[package]
-name = "assets"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/assets.rs"
-doctest = false
-
-[dependencies]
-gpui = { path = "../gpui" }
-anyhow.workspace = true
-rust-embed = { version = "6.3", features = ["include-exclude"] }
--- a/crates/assets/build.rs
+++ b/crates/assets/build.rs
@@ -1,29 +0,0 @@
-use std::process::Command;
-
-fn main() {
-    let output = Command::new("npm")
-        .current_dir("../../styles")
-        .args(["install", "--no-save"])
-        .output()
-        .expect("failed to run npm");
-    if !output.status.success() {
-        panic!(
-            "failed to install theme dependencies {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
-    }
-
-    let output = Command::new("npm")
-        .current_dir("../../styles")
-        .args(["run", "build"])
-        .output()
-        .expect("failed to run npm");
-    if !output.status.success() {
-        panic!(
-            "build script failed {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
-    }
-
-    println!("cargo:rerun-if-changed=../../styles/src");
-}
--- a/crates/auto_update/Cargo.toml
+++ b/crates/auto_update/Cargo.toml
@@ -19,7 +19,7 @@ theme = { path = "../theme" }
 workspace = { path = "../workspace" }
 util = { path = "../util" }
 anyhow.workspace = true
-isahc = "1.7"
+isahc.workspace = true
 lazy_static.workspace = true
 log.workspace = true
 serde.workspace = true
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -1,7 +1,7 @@
 mod update_notification;

 use anyhow::{anyhow, Context, Result};
-use client::{Client, ZED_APP_PATH, ZED_APP_VERSION, ZED_SECRET_CLIENT_TOKEN};
+use client::{Client, TelemetrySettings, ZED_APP_PATH, ZED_APP_VERSION, ZED_SECRET_CLIENT_TOKEN};
 use db::kvp::KEY_VALUE_STORE;
 use gpui::{
    actions, platform::AppVersion, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle,
@@ -10,7 +10,7 @@ use gpui::{
 use isahc::AsyncBody;
 use serde::Deserialize;
 use serde_derive::Serialize;
-use settings::Settings;
+use settings::{Setting, SettingsStore};
 use smol::{fs::File, io::AsyncReadExt, process::Command};
 use std::{ffi::OsString, sync::Arc, time::Duration};
 use update_notification::UpdateNotification;
@@ -58,18 +58,37 @@ impl Entity for AutoUpdater {
    type Event = ();
 }

+struct AutoUpdateSetting(bool);
+
+impl Setting for AutoUpdateSetting {
+    const KEY: Option<&'static str> = Some("auto_update");
+
+    type FileContent = Option<bool>;
+
+    fn load(
+        default_value: &Option<bool>,
+        user_values: &[&Option<bool>],
+        _: &AppContext,
+    ) -> Result<Self> {
+        Ok(Self(
+            Self::json_merge(default_value, user_values)?.ok_or_else(Self::missing_default)?,
+        ))
+    }
+}
+
 pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppContext) {
+    settings::register::<AutoUpdateSetting>(cx);
+
    if let Some(version) = (*ZED_APP_VERSION).or_else(|| cx.platform().app_version().ok()) {
        let auto_updater = cx.add_model(|cx| {
            let updater = AutoUpdater::new(version, http_client, server_url);

-            let mut update_subscription = cx
-                .global::<Settings>()
-                .auto_update
+            let mut update_subscription = settings::get::<AutoUpdateSetting>(cx)
+                .0
                .then(|| updater.start_polling(cx));

-            cx.observe_global::<Settings, _>(move |updater, cx| {
-                if cx.global::<Settings>().auto_update {
+            cx.observe_global::<SettingsStore, _>(move |updater, cx| {
+                if settings::get::<AutoUpdateSetting>(cx).0 {
                    if update_subscription.is_none() {
                        update_subscription = Some(updater.start_polling(cx))
                    }
@@ -102,7 +121,7 @@ fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) {
        {
            format!("{server_url}/releases/preview/latest")
        } else {
-            format!("{server_url}/releases/latest")
+            format!("{server_url}/releases/stable/latest")
        };
        cx.platform().open_url(&latest_release_url);
    }
@@ -262,7 +281,7 @@ impl AutoUpdater {
            let release_channel = cx
                .has_global::<ReleaseChannel>()
                .then(|| cx.global::<ReleaseChannel>().display_name());
-            let telemetry = cx.global::<Settings>().telemetry().metrics();
+            let telemetry = settings::get::<TelemetrySettings>(cx).metrics;

            (installation_id, release_channel, telemetry)
        });
@@ -273,7 +292,7 @@ impl AutoUpdater {
            telemetry,
        })?);

-        let mut response = client.post_json(&release.url, request_body, true).await?;
+        let mut response = client.get(&release.url, request_body, true).await?;
        smol::io::copy(response.body_mut(), &mut dmg_file).await?;
        log::info!("downloaded update. path:{:?}", dmg_path);

--- a/crates/auto_update/src/update_notification.rs
+++ b/crates/auto_update/src/update_notification.rs
@@ -5,7 +5,6 @@ use gpui::{
    Element, Entity, View, ViewContext,
 };
 use menu::Cancel;
-use settings::Settings;
 use util::channel::ReleaseChannel;
 use workspace::notifications::Notification;

@@ -27,7 +26,7 @@ impl View for UpdateNotification {
    }

    fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> gpui::AnyElement<Self> {
-        let theme = cx.global::<Settings>().theme.clone();
+        let theme = theme::current(cx).clone();
        let theme = &theme.update_notification;

        let app_name = cx.global::<ReleaseChannel>().display_name();
--- a/crates/breadcrumbs/src/breadcrumbs.rs
+++ b/crates/breadcrumbs/src/breadcrumbs.rs
@@ -4,7 +4,6 @@ use gpui::{
 };
 use itertools::Itertools;
 use search::ProjectSearchView;
-use settings::Settings;
 use workspace::{
    item::{ItemEvent, ItemHandle},
    ToolbarItemLocation, ToolbarItemView, Workspace,
@@ -50,7 +49,7 @@ impl View for Breadcrumbs {
        };
        let not_editor = active_item.downcast::<editor::Editor>().is_none();

-        let theme = cx.global::<Settings>().theme.clone();
+        let theme = theme::current(cx).clone();
        let style = &theme.workspace.breadcrumbs;

        let breadcrumbs = match active_item.breadcrumbs(&theme, cx) {
--- a/crates/cli/Cargo.toml
+++ b/crates/cli/Cargo.toml
@@ -19,6 +19,7 @@ dirs = "3.0"
 ipc-channel = "0.16"
 serde.workspace = true
 serde_derive.workspace = true
+util = { path = "../util" }

 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.9"
--- a/crates/cli/src/cli.rs
+++ b/crates/cli/src/cli.rs
@@ -1,6 +1,5 @@
 pub use ipc_channel::ipc;
 use serde::{Deserialize, Serialize};
-use std::path::PathBuf;

 #[derive(Serialize, Deserialize)]
 pub struct IpcHandshake {
@@ -10,7 +9,12 @@ pub struct IpcHandshake {

 #[derive(Debug, Serialize, Deserialize)]
 pub enum CliRequest {
-    Open { paths: Vec<PathBuf>, wait: bool },
+    // The filed is named `path` for compatibility, but now CLI can request
+    // opening a path at a certain row and/or column: `some/path:123` and `some/path:123:456`.
+    //
+    // Since Zed CLI has to be installed separately, there can be situations when old CLI is
+    // querying new Zed editors, support both formats by using `String` here and parsing it on Zed side later.
+    Open { paths: Vec<String>, wait: bool },
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -20,3 +24,7 @@ pub enum CliResponse {
    Stderr { message: String },
    Exit { status: i32 },
 }
+
+/// When Zed started not as an *.app but as a binary (e.g. local development),
+/// there's a possibility to tell it to behave "regularly".
+pub const FORCE_CLI_MODE_ENV_VAR_NAME: &str = "ZED_FORCE_CLI_MODE";
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -1,6 +1,6 @@
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Context, Result};
 use clap::Parser;
-use cli::{CliRequest, CliResponse, IpcHandshake};
+use cli::{CliRequest, CliResponse, IpcHandshake, FORCE_CLI_MODE_ENV_VAR_NAME};
 use core_foundation::{
    array::{CFArray, CFIndex},
    string::kCFStringEncodingUTF8,
@@ -16,16 +16,20 @@ use std::{
    path::{Path, PathBuf},
    ptr,
 };
+use util::paths::PathLikeWithPosition;

 #[derive(Parser)]
 #[clap(name = "zed", global_setting(clap::AppSettings::NoAutoVersion))]
 struct Args {
-    /// Wait for all of the given paths to be closed before exiting.
+    /// Wait for all of the given paths to be opened/closed before exiting.
    #[clap(short, long)]
    wait: bool,
    /// A sequence of space-separated paths that you want to open.
-    #[clap()]
-    paths: Vec<PathBuf>,
+    ///
+    /// Use `path:line:row` syntax to open a file at a specific location.
+    /// Non-existing paths and directories will ignore `:line:row` suffix.
+    #[clap(value_parser = parse_path_with_position)]
+    paths_with_position: Vec<PathLikeWithPosition<PathBuf>>,
    /// Print Zed's version and the app path.
    #[clap(short, long)]
    version: bool,
@@ -34,6 +38,14 @@ struct Args {
    bundle_path: Option<PathBuf>,
 }

+fn parse_path_with_position(
+    argument_str: &str,
+) -> Result<PathLikeWithPosition<PathBuf>, std::convert::Infallible> {
+    PathLikeWithPosition::parse_str(argument_str, |path_str| {
+        Ok(Path::new(path_str).to_path_buf())
+    })
+}
+
 #[derive(Debug, Deserialize)]
 struct InfoPlist {
    #[serde(rename = "CFBundleShortVersionString")]
@@ -43,37 +55,37 @@ struct InfoPlist {
 fn main() -> Result<()> {
    let args = Args::parse();

-    let bundle_path = if let Some(bundle_path) = args.bundle_path {
-        bundle_path.canonicalize()?
-    } else {
-        locate_bundle()?
-    };
+    let bundle = Bundle::detect(args.bundle_path.as_deref()).context("Bundle detection")?;

    if args.version {
-        let plist_path = bundle_path.join("Contents/Info.plist");
-        let plist = plist::from_file::<_, InfoPlist>(plist_path)?;
-        println!(
-            "Zed {} – {}",
-            plist.bundle_short_version_string,
-            bundle_path.to_string_lossy()
-        );
+        println!("{}", bundle.zed_version_string());
        return Ok(());
    }

-    for path in args.paths.iter() {
+    for path in args
+        .paths_with_position
+        .iter()
+        .map(|path_with_position| &path_with_position.path_like)
+    {
        if !path.exists() {
            touch(path.as_path())?;
        }
    }

-    let (tx, rx) = launch_app(bundle_path)?;
+    let (tx, rx) = bundle.launch()?;

    tx.send(CliRequest::Open {
        paths: args
-            .paths
+            .paths_with_position
            .into_iter()
-            .map(|path| fs::canonicalize(path).map_err(|error| anyhow!(error)))
-            .collect::<Result<Vec<PathBuf>>>()?,
+            .map(|path_with_position| {
+                let path_with_position = path_with_position.map_path_like(|path| {
+                    fs::canonicalize(&path)
+                        .with_context(|| format!("path {path:?} canonicalization"))
+                })?;
+                Ok(path_with_position.to_string(|path| path.display().to_string()))
+            })
+            .collect::<Result<_>>()?,
        wait: args.wait,
    })?;

@@ -89,6 +101,145 @@ fn main() -> Result<()> {
    Ok(())
 }

+enum Bundle {
+    App {
+        app_bundle: PathBuf,
+        plist: InfoPlist,
+    },
+    LocalPath {
+        executable: PathBuf,
+        plist: InfoPlist,
+    },
+}
+
+impl Bundle {
+    fn detect(args_bundle_path: Option<&Path>) -> anyhow::Result<Self> {
+        let bundle_path = if let Some(bundle_path) = args_bundle_path {
+            bundle_path
+                .canonicalize()
+                .with_context(|| format!("Args bundle path {bundle_path:?} canonicalization"))?
+        } else {
+            locate_bundle().context("bundle autodiscovery")?
+        };
+
+        match bundle_path.extension().and_then(|ext| ext.to_str()) {
+            Some("app") => {
+                let plist_path = bundle_path.join("Contents/Info.plist");
+                let plist = plist::from_file::<_, InfoPlist>(&plist_path).with_context(|| {
+                    format!("Reading *.app bundle plist file at {plist_path:?}")
+                })?;
+                Ok(Self::App {
+                    app_bundle: bundle_path,
+                    plist,
+                })
+            }
+            _ => {
+                println!("Bundle path {bundle_path:?} has no *.app extension, attempting to locate a dev build");
+                let plist_path = bundle_path
+                    .parent()
+                    .with_context(|| format!("Bundle path {bundle_path:?} has no parent"))?
+                    .join("WebRTC.framework/Resources/Info.plist");
+                let plist = plist::from_file::<_, InfoPlist>(&plist_path)
+                    .with_context(|| format!("Reading dev bundle plist file at {plist_path:?}"))?;
+                Ok(Self::LocalPath {
+                    executable: bundle_path,
+                    plist,
+                })
+            }
+        }
+    }
+
+    fn plist(&self) -> &InfoPlist {
+        match self {
+            Self::App { plist, .. } => plist,
+            Self::LocalPath { plist, .. } => plist,
+        }
+    }
+
+    fn path(&self) -> &Path {
+        match self {
+            Self::App { app_bundle, .. } => app_bundle,
+            Self::LocalPath { executable, .. } => executable,
+        }
+    }
+
+    fn launch(&self) -> anyhow::Result<(IpcSender<CliRequest>, IpcReceiver<CliResponse>)> {
+        let (server, server_name) =
+            IpcOneShotServer::<IpcHandshake>::new().context("Handshake before Zed spawn")?;
+        let url = format!("zed-cli://{server_name}");
+
+        match self {
+            Self::App { app_bundle, .. } => {
+                let app_path = app_bundle;
+
+                let status = unsafe {
+                    let app_url = CFURL::from_path(app_path, true)
+                        .with_context(|| format!("invalid app path {app_path:?}"))?;
+                    let url_to_open = CFURL::wrap_under_create_rule(CFURLCreateWithBytes(
+                        ptr::null(),
+                        url.as_ptr(),
+                        url.len() as CFIndex,
+                        kCFStringEncodingUTF8,
+                        ptr::null(),
+                    ));
+                    let urls_to_open = CFArray::from_copyable(&[url_to_open.as_concrete_TypeRef()]);
+                    LSOpenFromURLSpec(
+                        &LSLaunchURLSpec {
+                            appURL: app_url.as_concrete_TypeRef(),
+                            itemURLs: urls_to_open.as_concrete_TypeRef(),
+                            passThruParams: ptr::null(),
+                            launchFlags: kLSLaunchDefaults,
+                            asyncRefCon: ptr::null_mut(),
+                        },
+                        ptr::null_mut(),
+                    )
+                };
+
+                anyhow::ensure!(
+                    status == 0,
+                    "cannot start app bundle {}",
+                    self.zed_version_string()
+                );
+            }
+            Self::LocalPath { executable, .. } => {
+                let executable_parent = executable
+                    .parent()
+                    .with_context(|| format!("Executable {executable:?} path has no parent"))?;
+                let subprocess_stdout_file =
+                    fs::File::create(executable_parent.join("zed_dev.log"))
+                        .with_context(|| format!("Log file creation in {executable_parent:?}"))?;
+                let subprocess_stdin_file =
+                    subprocess_stdout_file.try_clone().with_context(|| {
+                        format!("Cloning descriptor for file {subprocess_stdout_file:?}")
+                    })?;
+                let mut command = std::process::Command::new(executable);
+                let command = command
+                    .env(FORCE_CLI_MODE_ENV_VAR_NAME, "")
+                    .stderr(subprocess_stdout_file)
+                    .stdout(subprocess_stdin_file)
+                    .arg(url);
+
+                command
+                    .spawn()
+                    .with_context(|| format!("Spawning {command:?}"))?;
+            }
+        }
+
+        let (_, handshake) = server.accept().context("Handshake after Zed spawn")?;
+        Ok((handshake.requests, handshake.responses))
+    }
+
+    fn zed_version_string(&self) -> String {
+        let is_dev = matches!(self, Self::LocalPath { .. });
+        format!(
+            "Zed {}{} – {}",
+            self.plist().bundle_short_version_string,
+            if is_dev { " (dev)" } else { "" },
+            self.path().display(),
+        )
+    }
+}
+
 fn touch(path: &Path) -> io::Result<()> {
    match OpenOptions::new().create(true).write(true).open(path) {
        Ok(_) => Ok(()),
@@ -106,38 +257,3 @@ fn locate_bundle() -> Result<PathBuf> {
    }
    Ok(app_path)
 }
-
-fn launch_app(app_path: PathBuf) -> Result<(IpcSender<CliRequest>, IpcReceiver<CliResponse>)> {
-    let (server, server_name) = IpcOneShotServer::<IpcHandshake>::new()?;
-    let url = format!("zed-cli://{server_name}");
-
-    let status = unsafe {
-        let app_url =
-            CFURL::from_path(&app_path, true).ok_or_else(|| anyhow!("invalid app path"))?;
-        let url_to_open = CFURL::wrap_under_create_rule(CFURLCreateWithBytes(
-            ptr::null(),
-            url.as_ptr(),
-            url.len() as CFIndex,
-            kCFStringEncodingUTF8,
-            ptr::null(),
-        ));
-        let urls_to_open = CFArray::from_copyable(&[url_to_open.as_concrete_TypeRef()]);
-        LSOpenFromURLSpec(
-            &LSLaunchURLSpec {
-                appURL: app_url.as_concrete_TypeRef(),
-                itemURLs: urls_to_open.as_concrete_TypeRef(),
-                passThruParams: ptr::null(),
-                launchFlags: kLSLaunchDefaults,
-                asyncRefCon: ptr::null_mut(),
-            },
-            ptr::null_mut(),
-        )
-    };
-
-    if status == 0 {
-        let (_, handshake) = server.accept()?;
-        Ok((handshake.requests, handshake.responses))
-    } else {
-        Err(anyhow!("cannot start {:?}", app_path))
-    }
-}
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -31,6 +31,7 @@ log.workspace = true
 parking_lot.workspace = true
 postage.workspace = true
 rand.workspace = true
+schemars.workspace = true
 smol.workspace = true
 thiserror.workspace = true
 time.workspace = true
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -15,19 +15,17 @@ use futures::{
    TryStreamExt,
 };
 use gpui::{
-    actions,
-    platform::AppVersion,
-    serde_json::{self},
-    AnyModelHandle, AnyWeakModelHandle, AnyWeakViewHandle, AppContext, AsyncAppContext, Entity,
-    ModelHandle, Task, View, ViewContext, WeakViewHandle,
+    actions, platform::AppVersion, serde_json, AnyModelHandle, AnyWeakModelHandle,
+    AnyWeakViewHandle, AppContext, AsyncAppContext, Entity, ModelHandle, Task, View, ViewContext,
+    WeakViewHandle,
 };
 use lazy_static::lazy_static;
 use parking_lot::RwLock;
 use postage::watch;
 use rand::prelude::*;
 use rpc::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, PeerId, RequestMessage};
-use serde::Deserialize;
-use settings::Settings;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 use std::{
    any::TypeId,
    collections::HashMap,
@@ -72,25 +70,34 @@ pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);

 actions!(client, [SignIn, SignOut]);

-pub fn init(client: Arc<Client>, cx: &mut AppContext) {
+pub fn init_settings(cx: &mut AppContext) {
+    settings::register::<TelemetrySettings>(cx);
+}
+
+pub fn init(client: &Arc<Client>, cx: &mut AppContext) {
+    init_settings(cx);
+
+    let client = Arc::downgrade(client);
    cx.add_global_action({
        let client = client.clone();
        move |_: &SignIn, cx| {
-            let client = client.clone();
-            cx.spawn(
-                |cx| async move { client.authenticate_and_connect(true, &cx).log_err().await },
-            )
-            .detach();
+            if let Some(client) = client.upgrade() {
+                cx.spawn(
+                    |cx| async move { client.authenticate_and_connect(true, &cx).log_err().await },
+                )
+                .detach();
+            }
        }
    });
    cx.add_global_action({
        let client = client.clone();
        move |_: &SignOut, cx| {
-            let client = client.clone();
-            cx.spawn(|cx| async move {
-                client.disconnect(&cx);
-            })
-            .detach();
+            if let Some(client) = client.upgrade() {
+                cx.spawn(|cx| async move {
+                    client.disconnect(&cx);
+                })
+                .detach();
+            }
        }
    });
 }
@@ -326,6 +333,42 @@ impl<T: Entity> Drop for PendingEntitySubscription<T> {
    }
 }

+#[derive(Copy, Clone)]
+pub struct TelemetrySettings {
+    pub diagnostics: bool,
+    pub metrics: bool,
+}
+
+#[derive(Default, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TelemetrySettingsContent {
+    pub diagnostics: Option<bool>,
+    pub metrics: Option<bool>,
+}
+
+impl settings::Setting for TelemetrySettings {
+    const KEY: Option<&'static str> = Some("telemetry");
+
+    type FileContent = TelemetrySettingsContent;
+
+    fn load(
+        default_value: &Self::FileContent,
+        user_values: &[&Self::FileContent],
+        _: &AppContext,
+    ) -> Result<Self> {
+        Ok(Self {
+            diagnostics: user_values.first().and_then(|v| v.diagnostics).unwrap_or(
+                default_value
+                    .diagnostics
+                    .ok_or_else(Self::missing_default)?,
+            ),
+            metrics: user_values
+                .first()
+                .and_then(|v| v.metrics)
+                .unwrap_or(default_value.metrics.ok_or_else(Self::missing_default)?),
+        })
+    }
+}
+
 impl Client {
    pub fn new(http: Arc<dyn HttpClient>, cx: &AppContext) -> Arc<Self> {
        Arc::new(Self {
@@ -447,9 +490,7 @@ impl Client {
                }));
            }
            Status::SignedOut | Status::UpgradeRequired => {
-                let telemetry_settings = cx.read(|cx| cx.global::<Settings>().telemetry());
-                self.telemetry
-                    .set_authenticated_user_info(None, false, telemetry_settings);
+                cx.read(|cx| self.telemetry.set_authenticated_user_info(None, false, cx));
                state._reconnect_task.take();
            }
            _ => {}
@@ -735,15 +776,6 @@ impl Client {
        if credentials.is_none() && try_keychain {
            credentials = read_credentials_from_keychain(cx);
            read_from_keychain = credentials.is_some();
-            if read_from_keychain {
-                cx.read(|cx| {
-                    self.telemetry().report_mixpanel_event(
-                        "read credentials from keychain",
-                        Default::default(),
-                        cx.global::<Settings>().telemetry(),
-                    );
-                });
-            }
        }
        if credentials.is_none() {
            let mut status_rx = self.status();
@@ -1031,9 +1063,7 @@ impl Client {
    ) -> Task<Result<Credentials>> {
        let platform = cx.platform();
        let executor = cx.background();
-        let telemetry = self.telemetry.clone();
        let http = self.http.clone();
-        let metrics_enabled = cx.read(|cx| cx.global::<Settings>().telemetry());

        executor.clone().spawn(async move {
            // Generate a pair of asymmetric encryption keys. The public key will be used by the
@@ -1117,12 +1147,6 @@ impl Client {
                .context("failed to decrypt access token")?;
            platform.activate(true);

-            telemetry.report_mixpanel_event(
-                "authenticate with browser",
-                Default::default(),
-                metrics_enabled,
-            );
-
            Ok(Credentials {
                user_id: user_id.parse()?,
                access_token,
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -1,16 +1,11 @@
-use crate::{ZED_SECRET_CLIENT_TOKEN, ZED_SERVER_URL};
+use crate::{TelemetrySettings, ZED_SECRET_CLIENT_TOKEN, ZED_SERVER_URL};
 use db::kvp::KEY_VALUE_STORE;
-use gpui::{
-    executor::Background,
-    serde_json::{self, value::Map, Value},
-    AppContext, Task,
-};
+use gpui::{executor::Background, serde_json, AppContext, Task};
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use serde::Serialize;
-use serde_json::json;
-use settings::TelemetrySettings;
 use std::{
+    env,
    io::Write,
    mem,
    path::PathBuf,
@@ -19,7 +14,7 @@ use std::{
 };
 use tempfile::NamedTempFile;
 use util::http::HttpClient;
-use util::{channel::ReleaseChannel, post_inc, ResultExt, TryFutureExt};
+use util::{channel::ReleaseChannel, TryFutureExt};
 use uuid::Uuid;

 pub struct Telemetry {
@@ -34,25 +29,18 @@ struct TelemetryState {
    installation_id: Option<Arc<str>>, // Per app installation
    app_version: Option<Arc<str>>,
    release_channel: Option<&'static str>,
-    os_version: Option<Arc<str>>,
    os_name: &'static str,
-    mixpanel_events_queue: Vec<MixpanelEvent>,
+    os_version: Option<Arc<str>>,
+    architecture: &'static str,
    clickhouse_events_queue: Vec<ClickhouseEventWrapper>,
-    next_mixpanel_event_id: usize,
-    flush_mixpanel_events_task: Option<Task<()>>,
    flush_clickhouse_events_task: Option<Task<()>>,
    log_file: Option<NamedTempFile>,
    is_staff: Option<bool>,
 }

-const MIXPANEL_EVENTS_URL: &'static str = "https://api.mixpanel.com/track";
-const MIXPANEL_ENGAGE_URL: &'static str = "https://api.mixpanel.com/engage#profile-set";
 const CLICKHOUSE_EVENTS_URL_PATH: &'static str = "/api/events";

 lazy_static! {
-    static ref MIXPANEL_TOKEN: Option<String> = std::env::var("ZED_MIXPANEL_TOKEN")
-        .ok()
-        .or_else(|| option_env!("ZED_MIXPANEL_TOKEN").map(|key| key.to_string()));
    static ref CLICKHOUSE_EVENTS_URL: String =
        format!("{}{}", *ZED_SERVER_URL, CLICKHOUSE_EVENTS_URL_PATH);
 }
@@ -64,6 +52,7 @@ struct ClickhouseEventRequestBody {
    app_version: Option<Arc<str>>,
    os_name: &'static str,
    os_version: Option<Arc<str>>,
+    architecture: &'static str,
    release_channel: Option<&'static str>,
    events: Vec<ClickhouseEventWrapper>,
 }
@@ -86,47 +75,11 @@ pub enum ClickhouseEvent {
        copilot_enabled: bool,
        copilot_enabled_for_language: bool,
    },
-}
-
-#[derive(Serialize, Debug)]
-struct MixpanelEvent {
-    event: String,
-    properties: MixpanelEventProperties,
-}
-
-#[derive(Serialize, Debug)]
-struct MixpanelEventProperties {
-    // Mixpanel required fields
-    #[serde(skip_serializing_if = "str::is_empty")]
-    token: &'static str,
-    time: u128,
-    #[serde(rename = "distinct_id")]
-    installation_id: Option<Arc<str>>,
-    #[serde(rename = "$insert_id")]
-    insert_id: usize,
-    // Custom fields
-    #[serde(skip_serializing_if = "Option::is_none", flatten)]
-    event_properties: Option<Map<String, Value>>,
-    #[serde(rename = "OS Name")]
-    os_name: &'static str,
-    #[serde(rename = "OS Version")]
-    os_version: Option<Arc<str>>,
-    #[serde(rename = "Release Channel")]
-    release_channel: Option<&'static str>,
-    #[serde(rename = "App Version")]
-    app_version: Option<Arc<str>>,
-    #[serde(rename = "Signed In")]
-    signed_in: bool,
-}
-
-#[derive(Serialize)]
-struct MixpanelEngageRequest {
-    #[serde(rename = "$token")]
-    token: &'static str,
-    #[serde(rename = "$distinct_id")]
-    installation_id: Arc<str>,
-    #[serde(rename = "$set")]
-    set: Value,
+    Copilot {
+        suggestion_id: Option<String>,
+        suggestion_accepted: bool,
+        file_extension: Option<String>,
+    },
 }

 #[cfg(debug_assertions)]
@@ -149,39 +102,25 @@ impl Telemetry {
        } else {
            None
        };
+        // TODO: Replace all hardware stuff with nested SystemSpecs json
        let this = Arc::new(Self {
            http_client: client,
            executor: cx.background().clone(),
            state: Mutex::new(TelemetryState {
-                os_version: platform.os_version().ok().map(|v| v.to_string().into()),
                os_name: platform.os_name().into(),
+                os_version: platform.os_version().ok().map(|v| v.to_string().into()),
+                architecture: env::consts::ARCH,
                app_version: platform.app_version().ok().map(|v| v.to_string().into()),
                release_channel,
                installation_id: None,
                metrics_id: None,
-                mixpanel_events_queue: Default::default(),
                clickhouse_events_queue: Default::default(),
-                flush_mixpanel_events_task: Default::default(),
                flush_clickhouse_events_task: Default::default(),
-                next_mixpanel_event_id: 0,
                log_file: None,
                is_staff: None,
            }),
        });

-        if MIXPANEL_TOKEN.is_some() {
-            this.executor
-                .spawn({
-                    let this = this.clone();
-                    async move {
-                        if let Some(tempfile) = NamedTempFile::new().log_err() {
-                            this.state.lock().log_file = Some(tempfile);
-                        }
-                    }
-                })
-                .detach();
-        }
-
        this
    }

@@ -209,20 +148,9 @@ impl Telemetry {
                    let mut state = this.state.lock();
                    state.installation_id = Some(installation_id.clone());

-                    for event in &mut state.mixpanel_events_queue {
-                        event
-                            .properties
-                            .installation_id
-                            .get_or_insert_with(|| installation_id.clone());
-                    }
-
-                    let has_mixpanel_events = !state.mixpanel_events_queue.is_empty();
                    let has_clickhouse_events = !state.clickhouse_events_queue.is_empty();
-                    drop(state);

-                    if has_mixpanel_events {
-                        this.flush_mixpanel_events();
-                    }
+                    drop(state);

                    if has_clickhouse_events {
                        this.flush_clickhouse_events();
@@ -241,43 +169,17 @@ impl Telemetry {
        self: &Arc<Self>,
        metrics_id: Option<String>,
        is_staff: bool,
-        telemetry_settings: TelemetrySettings,
+        cx: &AppContext,
    ) {
-        if !telemetry_settings.metrics() {
+        if !settings::get::<TelemetrySettings>(cx).metrics {
            return;
        }

-        let this = self.clone();
        let mut state = self.state.lock();
-        let installation_id = state.installation_id.clone();
        let metrics_id: Option<Arc<str>> = metrics_id.map(|id| id.into());
        state.metrics_id = metrics_id.clone();
        state.is_staff = Some(is_staff);
        drop(state);
-
-        if let Some((token, installation_id)) = MIXPANEL_TOKEN.as_ref().zip(installation_id) {
-            self.executor
-                .spawn(
-                    async move {
-                        let json_bytes = serde_json::to_vec(&[MixpanelEngageRequest {
-                            token,
-                            installation_id,
-                            set: json!({
-                                "Staff": is_staff,
-                                "ID": metrics_id,
-                                "App": true
-                            }),
-                        }])?;
-
-                        this.http_client
-                            .post_json(MIXPANEL_ENGAGE_URL, json_bytes.into(), false)
-                            .await?;
-                        anyhow::Ok(())
-                    }
-                    .log_err(),
-                )
-                .detach();
-        }
    }

    pub fn report_clickhouse_event(
@@ -285,7 +187,7 @@ impl Telemetry {
        event: ClickhouseEvent,
        telemetry_settings: TelemetrySettings,
    ) {
-        if !telemetry_settings.metrics() {
+        if !telemetry_settings.metrics {
            return;
        }

@@ -301,7 +203,7 @@ impl Telemetry {
        });

        if state.installation_id.is_some() {
-            if state.mixpanel_events_queue.len() >= MAX_QUEUE_LEN {
+            if state.clickhouse_events_queue.len() >= MAX_QUEUE_LEN {
                drop(state);
                self.flush_clickhouse_events();
            } else {
@@ -315,55 +217,6 @@ impl Telemetry {
        }
    }

-    pub fn report_mixpanel_event(
-        self: &Arc<Self>,
-        kind: &str,
-        properties: Value,
-        telemetry_settings: TelemetrySettings,
-    ) {
-        if !telemetry_settings.metrics() {
-            return;
-        }
-
-        let mut state = self.state.lock();
-        let event = MixpanelEvent {
-            event: kind.into(),
-            properties: MixpanelEventProperties {
-                token: "",
-                time: SystemTime::now()
-                    .duration_since(UNIX_EPOCH)
-                    .unwrap()
-                    .as_millis(),
-                installation_id: state.installation_id.clone(),
-                insert_id: post_inc(&mut state.next_mixpanel_event_id),
-                event_properties: if let Value::Object(properties) = properties {
-                    Some(properties)
-                } else {
-                    None
-                },
-                os_name: state.os_name,
-                os_version: state.os_version.clone(),
-                release_channel: state.release_channel,
-                app_version: state.app_version.clone(),
-                signed_in: state.metrics_id.is_some(),
-            },
-        };
-        state.mixpanel_events_queue.push(event);
-        if state.installation_id.is_some() {
-            if state.mixpanel_events_queue.len() >= MAX_QUEUE_LEN {
-                drop(state);
-                self.flush_mixpanel_events();
-            } else {
-                let this = self.clone();
-                let executor = self.executor.clone();
-                state.flush_mixpanel_events_task = Some(self.executor.spawn(async move {
-                    executor.timer(DEBOUNCE_INTERVAL).await;
-                    this.flush_mixpanel_events();
-                }));
-            }
-        }
-    }
-
    pub fn metrics_id(self: &Arc<Self>) -> Option<Arc<str>> {
        self.state.lock().metrics_id.clone()
    }
@@ -376,44 +229,6 @@ impl Telemetry {
        self.state.lock().is_staff
    }

-    fn flush_mixpanel_events(self: &Arc<Self>) {
-        let mut state = self.state.lock();
-        let mut events = mem::take(&mut state.mixpanel_events_queue);
-        state.flush_mixpanel_events_task.take();
-        drop(state);
-
-        if let Some(token) = MIXPANEL_TOKEN.as_ref() {
-            let this = self.clone();
-            self.executor
-                .spawn(
-                    async move {
-                        let mut json_bytes = Vec::new();
-
-                        if let Some(file) = &mut this.state.lock().log_file {
-                            let file = file.as_file_mut();
-                            for event in &mut events {
-                                json_bytes.clear();
-                                serde_json::to_writer(&mut json_bytes, event)?;
-                                file.write_all(&json_bytes)?;
-                                file.write(b"\n")?;
-
-                                event.properties.token = token;
-                            }
-                        }
-
-                        json_bytes.clear();
-                        serde_json::to_writer(&mut json_bytes, &events)?;
-                        this.http_client
-                            .post_json(MIXPANEL_EVENTS_URL, json_bytes.into(), false)
-                            .await?;
-                        anyhow::Ok(())
-                    }
-                    .log_err(),
-                )
-                .detach();
-        }
-    }
-
    fn flush_clickhouse_events(self: &Arc<Self>) {
        let mut state = self.state.lock();
        let mut events = mem::take(&mut state.clickhouse_events_queue);
@@ -447,6 +262,8 @@ impl Telemetry {
                                app_version: state.app_version.clone(),
                                os_name: state.os_name,
                                os_version: state.os_version.clone(),
+                                architecture: state.architecture,
+
                                release_channel: state.release_channel,
                                events,
                            },
@@ -454,7 +271,7 @@ impl Telemetry {
                    }

                    this.http_client
-                        .post_json(CLICKHOUSE_EVENTS_URL.as_str(), json_bytes.into(), false)
+                        .post_json(CLICKHOUSE_EVENTS_URL.as_str(), json_bytes.into())
                        .await?;
                    anyhow::Ok(())
                }
--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -5,7 +5,6 @@ use futures::{channel::mpsc, future, AsyncReadExt, Future, StreamExt};
 use gpui::{AsyncAppContext, Entity, ImageData, ModelContext, ModelHandle, Task};
 use postage::{sink::Sink, watch};
 use rpc::proto::{RequestMessage, UsersResponse};
-use settings::Settings;
 use staff_mode::StaffMode;
 use std::sync::{Arc, Weak};
 use util::http::HttpClient;
@@ -144,11 +143,13 @@ impl UserStore {
                                let fetch_metrics_id =
                                    client.request(proto::GetPrivateUserInfo {}).log_err();
                                let (user, info) = futures::join!(fetch_user, fetch_metrics_id);
-                                client.telemetry.set_authenticated_user_info(
-                                    info.as_ref().map(|info| info.metrics_id.clone()),
-                                    info.as_ref().map(|info| info.staff).unwrap_or(false),
-                                    cx.read(|cx| cx.global::<Settings>().telemetry()),
-                                );
+                                cx.read(|cx| {
+                                    client.telemetry.set_authenticated_user_info(
+                                        info.as_ref().map(|info| info.metrics_id.clone()),
+                                        info.as_ref().map(|info| info.staff).unwrap_or(false),
+                                        cx,
+                                    )
+                                });

                                cx.update(|cx| {
                                    cx.update_default_global(|staff_mode: &mut StaffMode, _| {
--- a/crates/clock/src/clock.rs
+++ b/crates/clock/src/clock.rs
@@ -66,6 +66,7 @@ impl<'a> AddAssign<&'a Local> for Local {
    }
 }

+/// A vector clock
 #[derive(Clone, Default, Hash, Eq, PartialEq)]
 pub struct Global(SmallVec<[u32; 8]>);

--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathan@zed.dev>"]
 default-run = "collab"
 edition = "2021"
 name = "collab"
-version = "0.10.0"
+version = "0.14.2"
 publish = false

 [[bin]]
@@ -51,7 +51,7 @@ tokio = { version = "1", features = ["full"] }
 tokio-tungstenite = "0.17"
 tonic = "0.6"
 tower = "0.4"
-toml = "0.5.8"
+toml.workspace = true
 tracing = "0.1.34"
 tracing-log = "0.1.3"
 tracing-subscriber = { version = "0.3.11", features = ["env-filter", "json"] }
@@ -76,7 +76,7 @@ workspace = { path = "../workspace", features = ["test-support"] }

 ctor.workspace = true
 env_logger.workspace = true
-indoc = "1.0.4"
+indoc.workspace = true
 util = { path = "../util" }
 lazy_static.workspace = true
 sea-orm = { git = "https://github.com/zed-industries/sea-orm", rev = "18f4c691085712ad014a51792af75a9044bacee6", features = ["sqlx-sqlite"] }
--- a/crates/collab/k8s/manifest.template.yml
+++ b/crates/collab/k8s/manifest.template.yml
@@ -104,6 +104,8 @@ spec:
                  key: secret
            - name: INVITE_LINK_PREFIX
              value: ${INVITE_LINK_PREFIX}
+            - name: RUST_BACKTRACE
+              value: "1"
            - name: RUST_LOG
              value: ${RUST_LOG}
            - name: LOG_JSON
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -76,12 +76,38 @@ CREATE TABLE "worktree_entries" (
    "is_symlink" BOOL NOT NULL,
    "is_ignored" BOOL NOT NULL,
    "is_deleted" BOOL NOT NULL,
+    "git_status" INTEGER,
    PRIMARY KEY(project_id, worktree_id, id),
    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE
 );
 CREATE INDEX "index_worktree_entries_on_project_id" ON "worktree_entries" ("project_id");
 CREATE INDEX "index_worktree_entries_on_project_id_and_worktree_id" ON "worktree_entries" ("project_id", "worktree_id");

+CREATE TABLE "worktree_repositories" (
+    "project_id" INTEGER NOT NULL,
+    "worktree_id" INTEGER NOT NULL,
+    "work_directory_id" INTEGER NOT NULL,
+    "branch" VARCHAR,
+    "scan_id" INTEGER NOT NULL,
+    "is_deleted" BOOL NOT NULL,
+    PRIMARY KEY(project_id, worktree_id, work_directory_id),
+    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
+    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
+);
+CREATE INDEX "index_worktree_repositories_on_project_id" ON "worktree_repositories" ("project_id");
+CREATE INDEX "index_worktree_repositories_on_project_id_and_worktree_id" ON "worktree_repositories" ("project_id", "worktree_id");
+
+CREATE TABLE "worktree_settings_files" (
+    "project_id" INTEGER NOT NULL,
+    "worktree_id" INTEGER NOT NULL,
+    "path" VARCHAR NOT NULL,
+    "content" TEXT,
+    PRIMARY KEY(project_id, worktree_id, path),
+    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE
+);
+CREATE INDEX "index_worktree_settings_files_on_project_id" ON "worktree_settings_files" ("project_id");
+CREATE INDEX "index_worktree_settings_files_on_project_id_and_worktree_id" ON "worktree_settings_files" ("project_id", "worktree_id");
+
 CREATE TABLE "worktree_diagnostic_summaries" (
    "project_id" INTEGER NOT NULL,
    "worktree_id" INTEGER NOT NULL,
@@ -153,7 +179,7 @@ CREATE TABLE "followers" (
    "follower_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
    "follower_connection_id" INTEGER NOT NULL
 );
-CREATE UNIQUE INDEX 
+CREATE UNIQUE INDEX
    "index_followers_on_project_id_and_leader_connection_server_id_and_leader_connection_id_and_follower_connection_server_id_and_follower_connection_id"
 ON "followers" ("project_id", "leader_connection_server_id", "leader_connection_id", "follower_connection_server_id", "follower_connection_id");
 CREATE INDEX "index_followers_on_room_id" ON "followers" ("room_id");
--- a/crates/collab/migrations/20230508211523_add-repository-entries.sql
+++ b/crates/collab/migrations/20230508211523_add-repository-entries.sql
@@ -0,0 +1,13 @@
+CREATE TABLE "worktree_repositories" (
+    "project_id" INTEGER NOT NULL,
+    "worktree_id" INT8 NOT NULL,
+    "work_directory_id" INT8 NOT NULL,
+    "scan_id" INT8 NOT NULL,
+    "branch" VARCHAR,
+    "is_deleted" BOOL NOT NULL,
+    PRIMARY KEY(project_id, worktree_id, work_directory_id),
+    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
+    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
+);
+CREATE INDEX "index_worktree_repositories_on_project_id" ON "worktree_repositories" ("project_id");
+CREATE INDEX "index_worktree_repositories_on_project_id_and_worktree_id" ON "worktree_repositories" ("project_id", "worktree_id");
--- a/crates/collab/migrations/20230511004019_add_repository_statuses.sql
+++ b/crates/collab/migrations/20230511004019_add_repository_statuses.sql
@@ -0,0 +1,15 @@
+CREATE TABLE "worktree_repository_statuses" (
+    "project_id" INTEGER NOT NULL,
+    "worktree_id" INT8 NOT NULL,
+    "work_directory_id" INT8 NOT NULL,
+    "repo_path" VARCHAR NOT NULL,
+    "status" INT8 NOT NULL,
+    "scan_id" INT8 NOT NULL,
+    "is_deleted" BOOL NOT NULL,
+    PRIMARY KEY(project_id, worktree_id, work_directory_id, repo_path),
+    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
+    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
+);
+CREATE INDEX "index_wt_repos_statuses_on_project_id" ON "worktree_repository_statuses" ("project_id");
+CREATE INDEX "index_wt_repos_statuses_on_project_id_and_wt_id" ON "worktree_repository_statuses" ("project_id", "worktree_id");
+CREATE INDEX "index_wt_repos_statuses_on_project_id_and_wt_id_and_wd_id" ON "worktree_repository_statuses" ("project_id", "worktree_id", "work_directory_id");
--- a/crates/collab/migrations/20230529164700_add_worktree_settings_files.sql
+++ b/crates/collab/migrations/20230529164700_add_worktree_settings_files.sql
@@ -0,0 +1,10 @@
+CREATE TABLE "worktree_settings_files" (
+    "project_id" INTEGER NOT NULL,
+    "worktree_id" INT8 NOT NULL,
+    "path" VARCHAR NOT NULL,
+    "content" TEXT NOT NULL,
+    PRIMARY KEY(project_id, worktree_id, path),
+    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE
+);
+CREATE INDEX "index_settings_files_on_project_id" ON "worktree_settings_files" ("project_id");
+CREATE INDEX "index_settings_files_on_project_id_and_wt_id" ON "worktree_settings_files" ("project_id", "worktree_id");
--- a/crates/collab/migrations/20230605191135_remove_repository_statuses.sql
+++ b/crates/collab/migrations/20230605191135_remove_repository_statuses.sql
@@ -0,0 +1,2 @@
+ALTER TABLE "worktree_entries"
+ADD "git_status" INT8;
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -14,6 +14,9 @@ mod user;
 mod worktree;
 mod worktree_diagnostic_summary;
 mod worktree_entry;
+mod worktree_repository;
+mod worktree_repository_statuses;
+mod worktree_settings_file;

 use crate::executor::Executor;
 use crate::{Error, Result};
@@ -1489,7 +1492,10 @@ impl Database {
                        visible: db_worktree.visible,
                        updated_entries: Default::default(),
                        removed_entries: Default::default(),
+                        updated_repositories: Default::default(),
+                        removed_repositories: Default::default(),
                        diagnostic_summaries: Default::default(),
+                        settings_files: Default::default(),
                        scan_id: db_worktree.scan_id as u64,
                        completed_scan_id: db_worktree.completed_scan_id as u64,
                    };
@@ -1498,38 +1504,78 @@ impl Database {
                        .worktrees
                        .iter()
                        .find(|worktree| worktree.id == db_worktree.id as u64);
-                    let entry_filter = if let Some(rejoined_worktree) = rejoined_worktree {
-                        worktree_entry::Column::ScanId.gt(rejoined_worktree.scan_id)
-                    } else {
-                        worktree_entry::Column::IsDeleted.eq(false)
-                    };

-                    let mut db_entries = worktree_entry::Entity::find()
-                        .filter(
-                            Condition::all()
-                                .add(worktree_entry::Column::WorktreeId.eq(worktree.id))
-                                .add(entry_filter),
-                        )
-                        .stream(&*tx)
-                        .await?;
-
-                    while let Some(db_entry) = db_entries.next().await {
-                        let db_entry = db_entry?;
-                        if db_entry.is_deleted {
-                            worktree.removed_entries.push(db_entry.id as u64);
+                    // File entries
+                    {
+                        let entry_filter = if let Some(rejoined_worktree) = rejoined_worktree {
+                            worktree_entry::Column::ScanId.gt(rejoined_worktree.scan_id)
                        } else {
-                            worktree.updated_entries.push(proto::Entry {
-                                id: db_entry.id as u64,
-                                is_dir: db_entry.is_dir,
-                                path: db_entry.path,
-                                inode: db_entry.inode as u64,
-                                mtime: Some(proto::Timestamp {
-                                    seconds: db_entry.mtime_seconds as u64,
-                                    nanos: db_entry.mtime_nanos as u32,
-                                }),
-                                is_symlink: db_entry.is_symlink,
-                                is_ignored: db_entry.is_ignored,
-                            });
+                            worktree_entry::Column::IsDeleted.eq(false)
+                        };
+
+                        let mut db_entries = worktree_entry::Entity::find()
+                            .filter(
+                                Condition::all()
+                                    .add(worktree_entry::Column::ProjectId.eq(project.id))
+                                    .add(worktree_entry::Column::WorktreeId.eq(worktree.id))
+                                    .add(entry_filter),
+                            )
+                            .stream(&*tx)
+                            .await?;
+
+                        while let Some(db_entry) = db_entries.next().await {
+                            let db_entry = db_entry?;
+                            if db_entry.is_deleted {
+                                worktree.removed_entries.push(db_entry.id as u64);
+                            } else {
+                                worktree.updated_entries.push(proto::Entry {
+                                    id: db_entry.id as u64,
+                                    is_dir: db_entry.is_dir,
+                                    path: db_entry.path,
+                                    inode: db_entry.inode as u64,
+                                    mtime: Some(proto::Timestamp {
+                                        seconds: db_entry.mtime_seconds as u64,
+                                        nanos: db_entry.mtime_nanos as u32,
+                                    }),
+                                    is_symlink: db_entry.is_symlink,
+                                    is_ignored: db_entry.is_ignored,
+                                    git_status: db_entry.git_status.map(|status| status as i32),
+                                });
+                            }
+                        }
+                    }
+
+                    // Repository Entries
+                    {
+                        let repository_entry_filter =
+                            if let Some(rejoined_worktree) = rejoined_worktree {
+                                worktree_repository::Column::ScanId.gt(rejoined_worktree.scan_id)
+                            } else {
+                                worktree_repository::Column::IsDeleted.eq(false)
+                            };
+
+                        let mut db_repositories = worktree_repository::Entity::find()
+                            .filter(
+                                Condition::all()
+                                    .add(worktree_repository::Column::ProjectId.eq(project.id))
+                                    .add(worktree_repository::Column::WorktreeId.eq(worktree.id))
+                                    .add(repository_entry_filter),
+                            )
+                            .stream(&*tx)
+                            .await?;
+
+                        while let Some(db_repository) = db_repositories.next().await {
+                            let db_repository = db_repository?;
+                            if db_repository.is_deleted {
+                                worktree
+                                    .removed_repositories
+                                    .push(db_repository.work_directory_id as u64);
+                            } else {
+                                worktree.updated_repositories.push(proto::RepositoryEntry {
+                                    work_directory_id: db_repository.work_directory_id as u64,
+                                    branch: db_repository.branch,
+                                });
+                            }
                        }
                    }

@@ -1547,6 +1593,25 @@ impl Database {
                    })
                    .collect::<Vec<_>>();

+                {
+                    let mut db_settings_files = worktree_settings_file::Entity::find()
+                        .filter(worktree_settings_file::Column::ProjectId.eq(project_id))
+                        .stream(&*tx)
+                        .await?;
+                    while let Some(db_settings_file) = db_settings_files.next().await {
+                        let db_settings_file = db_settings_file?;
+                        if let Some(worktree) = worktrees
+                            .iter_mut()
+                            .find(|w| w.id == db_settings_file.worktree_id as u64)
+                        {
+                            worktree.settings_files.push(WorktreeSettingsFile {
+                                path: db_settings_file.path,
+                                content: db_settings_file.content,
+                            });
+                        }
+                    }
+                }
+
                let mut collaborators = project
                    .find_related(project_collaborator::Entity)
                    .all(&*tx)
@@ -2284,6 +2349,7 @@ impl Database {
                        mtime_nanos: ActiveValue::set(mtime.nanos as i32),
                        is_symlink: ActiveValue::set(entry.is_symlink),
                        is_ignored: ActiveValue::set(entry.is_ignored),
+                        git_status: ActiveValue::set(entry.git_status.map(|status| status as i64)),
                        is_deleted: ActiveValue::set(false),
                        scan_id: ActiveValue::set(update.scan_id as i64),
                    }
@@ -2302,6 +2368,7 @@ impl Database {
                        worktree_entry::Column::MtimeNanos,
                        worktree_entry::Column::IsSymlink,
                        worktree_entry::Column::IsIgnored,
+                        worktree_entry::Column::GitStatus,
                        worktree_entry::Column::ScanId,
                    ])
                    .to_owned(),
@@ -2330,6 +2397,53 @@ impl Database {
                    .await?;
            }

+            if !update.updated_repositories.is_empty() {
+                worktree_repository::Entity::insert_many(update.updated_repositories.iter().map(
+                    |repository| worktree_repository::ActiveModel {
+                        project_id: ActiveValue::set(project_id),
+                        worktree_id: ActiveValue::set(worktree_id),
+                        work_directory_id: ActiveValue::set(repository.work_directory_id as i64),
+                        scan_id: ActiveValue::set(update.scan_id as i64),
+                        branch: ActiveValue::set(repository.branch.clone()),
+                        is_deleted: ActiveValue::set(false),
+                    },
+                ))
+                .on_conflict(
+                    OnConflict::columns([
+                        worktree_repository::Column::ProjectId,
+                        worktree_repository::Column::WorktreeId,
+                        worktree_repository::Column::WorkDirectoryId,
+                    ])
+                    .update_columns([
+                        worktree_repository::Column::ScanId,
+                        worktree_repository::Column::Branch,
+                    ])
+                    .to_owned(),
+                )
+                .exec(&*tx)
+                .await?;
+            }
+
+            if !update.removed_repositories.is_empty() {
+                worktree_repository::Entity::update_many()
+                    .filter(
+                        worktree_repository::Column::ProjectId
+                            .eq(project_id)
+                            .and(worktree_repository::Column::WorktreeId.eq(worktree_id))
+                            .and(
+                                worktree_repository::Column::WorkDirectoryId
+                                    .is_in(update.removed_repositories.iter().map(|id| *id as i64)),
+                            ),
+                    )
+                    .set(worktree_repository::ActiveModel {
+                        is_deleted: ActiveValue::Set(true),
+                        scan_id: ActiveValue::Set(update.scan_id as i64),
+                        ..Default::default()
+                    })
+                    .exec(&*tx)
+                    .await?;
+            }
+
            let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
            Ok(connection_ids)
        })
@@ -2437,6 +2551,58 @@ impl Database {
        .await
    }

+    pub async fn update_worktree_settings(
+        &self,
+        update: &proto::UpdateWorktreeSettings,
+        connection: ConnectionId,
+    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
+        let project_id = ProjectId::from_proto(update.project_id);
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
+            // Ensure the update comes from the host.
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
+            if project.host_connection()? != connection {
+                return Err(anyhow!("can't update a project hosted by someone else"))?;
+            }
+
+            if let Some(content) = &update.content {
+                worktree_settings_file::Entity::insert(worktree_settings_file::ActiveModel {
+                    project_id: ActiveValue::Set(project_id),
+                    worktree_id: ActiveValue::Set(update.worktree_id as i64),
+                    path: ActiveValue::Set(update.path.clone()),
+                    content: ActiveValue::Set(content.clone()),
+                })
+                .on_conflict(
+                    OnConflict::columns([
+                        worktree_settings_file::Column::ProjectId,
+                        worktree_settings_file::Column::WorktreeId,
+                        worktree_settings_file::Column::Path,
+                    ])
+                    .update_column(worktree_settings_file::Column::Content)
+                    .to_owned(),
+                )
+                .exec(&*tx)
+                .await?;
+            } else {
+                worktree_settings_file::Entity::delete(worktree_settings_file::ActiveModel {
+                    project_id: ActiveValue::Set(project_id),
+                    worktree_id: ActiveValue::Set(update.worktree_id as i64),
+                    path: ActiveValue::Set(update.path.clone()),
+                    ..Default::default()
+                })
+                .exec(&*tx)
+                .await?;
+            }
+
+            let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
+            Ok(connection_ids)
+        })
+        .await
+    }
+
    pub async fn join_project(
        &self,
        project_id: ProjectId,
@@ -2505,7 +2671,9 @@ impl Database {
                            root_name: db_worktree.root_name,
                            visible: db_worktree.visible,
                            entries: Default::default(),
+                            repository_entries: Default::default(),
                            diagnostic_summaries: Default::default(),
+                            settings_files: Default::default(),
                            scan_id: db_worktree.scan_id as u64,
                            completed_scan_id: db_worktree.completed_scan_id as u64,
                        },
@@ -2537,11 +2705,38 @@ impl Database {
                            }),
                            is_symlink: db_entry.is_symlink,
                            is_ignored: db_entry.is_ignored,
+                            git_status: db_entry.git_status.map(|status| status as i32),
                        });
                    }
                }
            }

+            // Populate repository entries.
+            {
+                let mut db_repository_entries = worktree_repository::Entity::find()
+                    .filter(
+                        Condition::all()
+                            .add(worktree_repository::Column::ProjectId.eq(project_id))
+                            .add(worktree_repository::Column::IsDeleted.eq(false)),
+                    )
+                    .stream(&*tx)
+                    .await?;
+                while let Some(db_repository_entry) = db_repository_entries.next().await {
+                    let db_repository_entry = db_repository_entry?;
+                    if let Some(worktree) =
+                        worktrees.get_mut(&(db_repository_entry.worktree_id as u64))
+                    {
+                        worktree.repository_entries.insert(
+                            db_repository_entry.work_directory_id as u64,
+                            proto::RepositoryEntry {
+                                work_directory_id: db_repository_entry.work_directory_id as u64,
+                                branch: db_repository_entry.branch,
+                            },
+                        );
+                    }
+                }
+            }
+
            // Populate worktree diagnostic summaries.
            {
                let mut db_summaries = worktree_diagnostic_summary::Entity::find()
@@ -2563,6 +2758,25 @@ impl Database {
                }
            }

+            // Populate worktree settings files
+            {
+                let mut db_settings_files = worktree_settings_file::Entity::find()
+                    .filter(worktree_settings_file::Column::ProjectId.eq(project_id))
+                    .stream(&*tx)
+                    .await?;
+                while let Some(db_settings_file) = db_settings_files.next().await {
+                    let db_settings_file = db_settings_file?;
+                    if let Some(worktree) =
+                        worktrees.get_mut(&(db_settings_file.worktree_id as u64))
+                    {
+                        worktree.settings_files.push(WorktreeSettingsFile {
+                            path: db_settings_file.path,
+                            content: db_settings_file.content,
+                        });
+                    }
+                }
+            }
+
            // Populate language servers.
            let language_servers = project
                .find_related(language_server::Entity)
@@ -3223,7 +3437,10 @@ pub struct RejoinedWorktree {
    pub visible: bool,
    pub updated_entries: Vec<proto::Entry>,
    pub removed_entries: Vec<u64>,
+    pub updated_repositories: Vec<proto::RepositoryEntry>,
+    pub removed_repositories: Vec<u64>,
    pub diagnostic_summaries: Vec<proto::DiagnosticSummary>,
+    pub settings_files: Vec<WorktreeSettingsFile>,
    pub scan_id: u64,
    pub completed_scan_id: u64,
 }
@@ -3277,11 +3494,19 @@ pub struct Worktree {
    pub root_name: String,
    pub visible: bool,
    pub entries: Vec<proto::Entry>,
+    pub repository_entries: BTreeMap<u64, proto::RepositoryEntry>,
    pub diagnostic_summaries: Vec<proto::DiagnosticSummary>,
+    pub settings_files: Vec<WorktreeSettingsFile>,
    pub scan_id: u64,
    pub completed_scan_id: u64,
 }

+#[derive(Debug)]
+pub struct WorktreeSettingsFile {
+    pub path: String,
+    pub content: String,
+}
+
 #[cfg(test)]
 pub use test::*;

--- a/crates/collab/src/db/worktree_entry.rs
+++ b/crates/collab/src/db/worktree_entry.rs
@@ -15,6 +15,7 @@ pub struct Model {
    pub inode: i64,
    pub mtime_seconds: i64,
    pub mtime_nanos: i32,
+    pub git_status: Option<i64>,
    pub is_symlink: bool,
    pub is_ignored: bool,
    pub is_deleted: bool,
--- a/crates/collab/src/db/worktree_repository.rs
+++ b/crates/collab/src/db/worktree_repository.rs
@@ -0,0 +1,21 @@
+use super::ProjectId;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "worktree_repositories")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub project_id: ProjectId,
+    #[sea_orm(primary_key)]
+    pub worktree_id: i64,
+    #[sea_orm(primary_key)]
+    pub work_directory_id: i64,
+    pub scan_id: i64,
+    pub branch: Option<String>,
+    pub is_deleted: bool,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
--- a/crates/collab/src/db/worktree_repository_statuses.rs
+++ b/crates/collab/src/db/worktree_repository_statuses.rs
@@ -0,0 +1,23 @@
+use super::ProjectId;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "worktree_repository_statuses")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub project_id: ProjectId,
+    #[sea_orm(primary_key)]
+    pub worktree_id: i64,
+    #[sea_orm(primary_key)]
+    pub work_directory_id: i64,
+    #[sea_orm(primary_key)]
+    pub repo_path: String,
+    pub status: i64,
+    pub scan_id: i64,
+    pub is_deleted: bool,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
--- a/crates/collab/src/db/worktree_settings_file.rs
+++ b/crates/collab/src/db/worktree_settings_file.rs
@@ -0,0 +1,19 @@
+use super::ProjectId;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "worktree_settings_files")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub project_id: ProjectId,
+    #[sea_orm(primary_key)]
+    pub worktree_id: i64,
+    #[sea_orm(primary_key)]
+    pub path: String,
+    pub content: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -51,7 +51,7 @@ use std::{
        atomic::{AtomicBool, Ordering::SeqCst},
        Arc,
    },
-    time::Duration,
+    time::{Duration, Instant},
 };
 use tokio::sync::{watch, Semaphore};
 use tower::ServiceBuilder;
@@ -200,6 +200,7 @@ impl Server {
            .add_message_handler(start_language_server)
            .add_message_handler(update_language_server)
            .add_message_handler(update_diagnostic_summary)
+            .add_message_handler(update_worktree_settings)
            .add_request_handler(forward_project_request::<proto::GetHover>)
            .add_request_handler(forward_project_request::<proto::GetDefinition>)
            .add_request_handler(forward_project_request::<proto::GetTypeDefinition>)
@@ -223,6 +224,7 @@ impl Server {
            .add_request_handler(forward_project_request::<proto::RenameProjectEntry>)
            .add_request_handler(forward_project_request::<proto::CopyProjectEntry>)
            .add_request_handler(forward_project_request::<proto::DeleteProjectEntry>)
+            .add_request_handler(forward_project_request::<proto::OnTypeFormatting>)
            .add_message_handler(create_buffer_for_peer)
            .add_request_handler(update_buffer)
            .add_message_handler(update_buffer_file)
@@ -397,10 +399,16 @@ impl Server {
                        "message received"
                    );
                });
+                let start_time = Instant::now();
                let future = (handler)(*envelope, session);
                async move {
-                    if let Err(error) = future.await {
-                        tracing::error!(%error, "error handling message");
+                    let result = future.await;
+                    let duration_ms = start_time.elapsed().as_micros() as f64 / 1000.0;
+                    match result {
+                        Err(error) => {
+                            tracing::error!(%error, ?duration_ms, "error handling message")
+                        }
+                        Ok(()) => tracing::info!(?duration_ms, "finished handling message"),
                    }
                }
                .instrument(span)
@@ -1063,6 +1071,8 @@ async fn rejoin_room(
                    removed_entries: worktree.removed_entries,
                    scan_id: worktree.scan_id,
                    is_last_update: worktree.completed_scan_id == worktree.scan_id,
+                    updated_repositories: worktree.updated_repositories,
+                    removed_repositories: worktree.removed_repositories,
                };
                for update in proto::split_worktree_update(message, MAX_CHUNK_SIZE) {
                    session.peer.send(session.connection_id, update.clone())?;
@@ -1079,6 +1089,18 @@ async fn rejoin_room(
                        },
                    )?;
                }
+
+                for settings_file in worktree.settings_files {
+                    session.peer.send(
+                        session.connection_id,
+                        proto::UpdateWorktreeSettings {
+                            project_id: project.id.to_proto(),
+                            worktree_id: worktree.id,
+                            path: settings_file.path,
+                            content: Some(settings_file.content),
+                        },
+                    )?;
+                }
            }

            for language_server in &project.language_servers {
@@ -1383,6 +1405,8 @@ async fn join_project(
            removed_entries: Default::default(),
            scan_id: worktree.scan_id,
            is_last_update: worktree.scan_id == worktree.completed_scan_id,
+            updated_repositories: worktree.repository_entries.into_values().collect(),
+            removed_repositories: Default::default(),
        };
        for update in proto::split_worktree_update(message, MAX_CHUNK_SIZE) {
            session.peer.send(session.connection_id, update.clone())?;
@@ -1399,6 +1423,18 @@ async fn join_project(
                },
            )?;
        }
+
+        for settings_file in worktree.settings_files {
+            session.peer.send(
+                session.connection_id,
+                proto::UpdateWorktreeSettings {
+                    project_id: project_id.to_proto(),
+                    worktree_id: worktree.id,
+                    path: settings_file.path,
+                    content: Some(settings_file.content),
+                },
+            )?;
+        }
    }

    for language_server in &project.language_servers {
@@ -1514,6 +1550,29 @@ async fn update_diagnostic_summary(
    Ok(())
 }

+async fn update_worktree_settings(
+    message: proto::UpdateWorktreeSettings,
+    session: Session,
+) -> Result<()> {
+    let guest_connection_ids = session
+        .db()
+        .await
+        .update_worktree_settings(&message, session.connection_id)
+        .await?;
+
+    broadcast(
+        Some(session.connection_id),
+        guest_connection_ids.iter().copied(),
+        |connection_id| {
+            session
+                .peer
+                .forward_send(session.connection_id, connection_id, message.clone())
+        },
+    );
+
+    Ok(())
+}
+
 async fn start_language_server(
    request: proto::StartLanguageServer,
    session: Session,
--- a/crates/collab/src/tests.rs
+++ b/crates/collab/src/tests.rs
@@ -12,11 +12,14 @@ use client::{
 use collections::{HashMap, HashSet};
 use fs::FakeFs;
 use futures::{channel::oneshot, StreamExt as _};
-use gpui::{executor::Deterministic, test::EmptyView, ModelHandle, TestAppContext, ViewHandle};
+use gpui::{
+    elements::*, executor::Deterministic, AnyElement, Entity, ModelHandle, TestAppContext, View,
+    ViewContext, ViewHandle, WeakViewHandle,
+};
 use language::LanguageRegistry;
 use parking_lot::Mutex;
 use project::{Project, WorktreeId};
-use settings::Settings;
+use settings::SettingsStore;
 use std::{
    cell::{Ref, RefCell, RefMut},
    env,
@@ -27,7 +30,6 @@ use std::{
        Arc,
    },
 };
-use theme::ThemeRegistry;
 use util::http::FakeHttpClient;
 use workspace::Workspace;

@@ -99,7 +101,7 @@ impl TestServer {

    async fn create_client(&mut self, cx: &mut TestAppContext, name: &str) -> TestClient {
        cx.update(|cx| {
-            cx.set_global(Settings::test(cx));
+            cx.set_global(SettingsStore::test(cx));
        });

        let http = FakeHttpClient::with_404_response();
@@ -188,16 +190,18 @@ impl TestServer {
            client: client.clone(),
            user_store: user_store.clone(),
            languages: Arc::new(LanguageRegistry::test()),
-            themes: ThemeRegistry::new((), cx.font_cache()),
            fs: fs.clone(),
            build_window_options: |_, _, _| Default::default(),
-            initialize_workspace: |_, _, _| unimplemented!(),
-            dock_default_item_factory: |_, _| None,
+            initialize_workspace: |_, _, _, _| unimplemented!(),
            background_actions: || &[],
        });

-        Project::init(&client);
        cx.update(|cx| {
+            theme::init((), cx);
+            Project::init(&client, cx);
+            client::init(&client, cx);
+            language::init(cx);
+            editor::init_settings(cx);
            workspace::init(app_state.clone(), cx);
            call::init(client.clone(), user_store.clone(), cx);
        });
@@ -462,8 +466,41 @@ impl TestClient {
        project: &ModelHandle<Project>,
        cx: &mut TestAppContext,
    ) -> ViewHandle<Workspace> {
-        let (_, root_view) = cx.add_window(|_| EmptyView);
-        cx.add_view(&root_view, |cx| Workspace::test_new(project.clone(), cx))
+        struct WorkspaceContainer {
+            workspace: Option<WeakViewHandle<Workspace>>,
+        }
+
+        impl Entity for WorkspaceContainer {
+            type Event = ();
+        }
+
+        impl View for WorkspaceContainer {
+            fn ui_name() -> &'static str {
+                "WorkspaceContainer"
+            }
+
+            fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+                if let Some(workspace) = self
+                    .workspace
+                    .as_ref()
+                    .and_then(|workspace| workspace.upgrade(cx))
+                {
+                    ChildView::new(&workspace, cx).into_any()
+                } else {
+                    Empty::new().into_any()
+                }
+            }
+        }
+
+        // We use a workspace container so that we don't need to remove the window in order to
+        // drop the workspace and we can use a ViewHandle instead.
+        let (window_id, container) = cx.add_window(|_| WorkspaceContainer { workspace: None });
+        let workspace = cx.add_view(window_id, |cx| Workspace::test_new(project.clone(), cx));
+        container.update(cx, |container, cx| {
+            container.workspace = Some(workspace.downgrade());
+            cx.notify();
+        });
+        workspace
    }
 }

--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
--- a/crates/collab/src/tests/randomized_integration_tests.rs
+++ b/crates/collab/src/tests/randomized_integration_tests.rs
@@ -8,19 +8,20 @@ use call::ActiveCall;
 use client::RECEIVE_TIMEOUT;
 use collections::BTreeMap;
 use editor::Bias;
-use fs::{FakeFs, Fs as _};
+use fs::{repository::GitFileStatus, FakeFs, Fs as _};
 use futures::StreamExt as _;
 use gpui::{executor::Deterministic, ModelHandle, Task, TestAppContext};
 use language::{range_to_lsp, FakeLspAdapter, Language, LanguageConfig, PointUtf16};
 use lsp::FakeLanguageServer;
 use parking_lot::Mutex;
+use pretty_assertions::assert_eq;
 use project::{search::SearchQuery, Project, ProjectPath};
 use rand::{
    distributions::{Alphanumeric, DistString},
    prelude::*,
 };
 use serde::{Deserialize, Serialize};
-use settings::Settings;
+use settings::SettingsStore;
 use std::{
    env,
    ops::Range,
@@ -148,8 +149,9 @@ async fn test_random_collaboration(

    for (client, mut cx) in clients {
        cx.update(|cx| {
+            let store = cx.remove_global::<SettingsStore>();
            cx.clear_globals();
-            cx.set_global(Settings::test(cx));
+            cx.set_global(store);
            drop(client);
        });
    }
@@ -420,7 +422,7 @@ async fn apply_client_operation(
            );

            ensure_project_shared(&project, client, cx).await;
-            if !client.fs.paths().contains(&new_root_path) {
+            if !client.fs.paths(false).contains(&new_root_path) {
                client.fs.create_dir(&new_root_path).await.unwrap();
            }
            project
@@ -626,12 +628,13 @@ async fn apply_client_operation(

            ensure_project_shared(&project, client, cx).await;
            let requested_version = buffer.read_with(cx, |buffer, _| buffer.version());
-            let save = project.update(cx, |project, cx| project.save_buffer(buffer, cx));
-            let save = cx.background().spawn(async move {
-                let (saved_version, _, _) = save
-                    .await
+            let save = project.update(cx, |project, cx| project.save_buffer(buffer.clone(), cx));
+            let save = cx.spawn(|cx| async move {
+                save.await
                    .map_err(|err| anyhow!("save request failed: {:?}", err))?;
-                assert!(saved_version.observed_all(&requested_version));
+                assert!(buffer
+                    .read_with(&cx, |buffer, _| { buffer.saved_version().to_owned() })
+                    .observed_all(&requested_version));
                anyhow::Ok(())
            });
            if detach {
@@ -716,7 +719,10 @@ async fn apply_client_operation(
            );

            let search = project.update(cx, |project, cx| {
-                project.search(SearchQuery::text(query, false, false), cx)
+                project.search(
+                    SearchQuery::text(query, false, false, Vec::new(), Vec::new()),
+                    cx,
+                )
            });
            drop(project);
            let search = cx.background().spawn(async move {
@@ -738,7 +744,7 @@ async fn apply_client_operation(
        } => {
            if !client
                .fs
-                .directories()
+                .directories(false)
                .contains(&path.parent().unwrap().to_owned())
            {
                return Err(TestError::Inapplicable);
@@ -760,31 +766,103 @@ async fn apply_client_operation(
            }
        }

-        ClientOperation::WriteGitIndex {
-            repo_path,
-            contents,
-        } => {
-            if !client.fs.directories().contains(&repo_path) {
-                return Err(TestError::Inapplicable);
-            }
-
-            log::info!(
-                "{}: writing git index for repo {:?}: {:?}",
-                client.username,
+        ClientOperation::GitOperation { operation } => match operation {
+            GitOperation::WriteGitIndex {
                repo_path,
-                contents
-            );
+                contents,
+            } => {
+                if !client.fs.directories(false).contains(&repo_path) {
+                    return Err(TestError::Inapplicable);
+                }

-            let dot_git_dir = repo_path.join(".git");
-            let contents = contents
-                .iter()
-                .map(|(path, contents)| (path.as_path(), contents.clone()))
-                .collect::<Vec<_>>();
-            if client.fs.metadata(&dot_git_dir).await?.is_none() {
-                client.fs.create_dir(&dot_git_dir).await?;
+                for (path, _) in contents.iter() {
+                    if !client.fs.files().contains(&repo_path.join(path)) {
+                        return Err(TestError::Inapplicable);
+                    }
+                }
+
+                log::info!(
+                    "{}: writing git index for repo {:?}: {:?}",
+                    client.username,
+                    repo_path,
+                    contents
+                );
+
+                let dot_git_dir = repo_path.join(".git");
+                let contents = contents
+                    .iter()
+                    .map(|(path, contents)| (path.as_path(), contents.clone()))
+                    .collect::<Vec<_>>();
+                if client.fs.metadata(&dot_git_dir).await?.is_none() {
+                    client.fs.create_dir(&dot_git_dir).await?;
+                }
+                client.fs.set_index_for_repo(&dot_git_dir, &contents);
            }
-            client.fs.set_index_for_repo(&dot_git_dir, &contents).await;
-        }
+            GitOperation::WriteGitBranch {
+                repo_path,
+                new_branch,
+            } => {
+                if !client.fs.directories(false).contains(&repo_path) {
+                    return Err(TestError::Inapplicable);
+                }
+
+                log::info!(
+                    "{}: writing git branch for repo {:?}: {:?}",
+                    client.username,
+                    repo_path,
+                    new_branch
+                );
+
+                let dot_git_dir = repo_path.join(".git");
+                if client.fs.metadata(&dot_git_dir).await?.is_none() {
+                    client.fs.create_dir(&dot_git_dir).await?;
+                }
+                client.fs.set_branch_name(&dot_git_dir, new_branch);
+            }
+            GitOperation::WriteGitStatuses {
+                repo_path,
+                statuses,
+                git_operation,
+            } => {
+                if !client.fs.directories(false).contains(&repo_path) {
+                    return Err(TestError::Inapplicable);
+                }
+                for (path, _) in statuses.iter() {
+                    if !client.fs.files().contains(&repo_path.join(path)) {
+                        return Err(TestError::Inapplicable);
+                    }
+                }
+
+                log::info!(
+                    "{}: writing git statuses for repo {:?}: {:?}",
+                    client.username,
+                    repo_path,
+                    statuses
+                );
+
+                let dot_git_dir = repo_path.join(".git");
+
+                let statuses = statuses
+                    .iter()
+                    .map(|(path, val)| (path.as_path(), val.clone()))
+                    .collect::<Vec<_>>();
+
+                if client.fs.metadata(&dot_git_dir).await?.is_none() {
+                    client.fs.create_dir(&dot_git_dir).await?;
+                }
+
+                if git_operation {
+                    client
+                        .fs
+                        .set_status_for_repo_via_git_operation(&dot_git_dir, statuses.as_slice());
+                } else {
+                    client.fs.set_status_for_repo_via_working_copy_change(
+                        &dot_git_dir,
+                        statuses.as_slice(),
+                    );
+                }
+            }
+        },
    }
    Ok(())
 }
@@ -854,7 +932,14 @@ fn check_consistency_between_clients(clients: &[(Rc<TestClient>, TestAppContext)
                            assert_eq!(
                                guest_snapshot.entries(false).collect::<Vec<_>>(),
                                host_snapshot.entries(false).collect::<Vec<_>>(),
-                                "{} has different snapshot than the host for worktree {:?} and project {:?}",
+                                "{} has different snapshot than the host for worktree {:?} ({:?}) and project {:?}",
+                                client.username,
+                                host_snapshot.abs_path(),
+                                id,
+                                guest_project.remote_id(),
+                            );
+                            assert_eq!(guest_snapshot.repositories().collect::<Vec<_>>(), host_snapshot.repositories().collect::<Vec<_>>(),
+                                "{} has different repositories than the host for worktree {:?} and project {:?}",
                                client.username,
                                host_snapshot.abs_path(),
                                guest_project.remote_id(),
@@ -1147,10 +1232,26 @@ enum ClientOperation {
        is_dir: bool,
        content: String,
    },
+    GitOperation {
+        operation: GitOperation,
+    },
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+enum GitOperation {
    WriteGitIndex {
        repo_path: PathBuf,
        contents: Vec<(PathBuf, String)>,
    },
+    WriteGitBranch {
+        repo_path: PathBuf,
+        new_branch: Option<String>,
+    },
+    WriteGitStatuses {
+        repo_path: PathBuf,
+        statuses: Vec<(PathBuf, GitFileStatus)>,
+        git_operation: bool,
+    },
 }

 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -1495,7 +1596,7 @@ impl TestPlan {
                                .choose(&mut self.rng)
                                .cloned() else { continue };
                            let project_root_name = root_name_for_project(&project, cx);
-                            let mut paths = client.fs.paths();
+                            let mut paths = client.fs.paths(false);
                            paths.remove(0);
                            let new_root_path = if paths.is_empty() || self.rng.gen() {
                                Path::new("/").join(&self.next_root_dir_name(user_id))
@@ -1663,38 +1764,10 @@ impl TestPlan {
                    }
                }

-                // Update a git index
+                // Update a git related action
                91..=95 => {
-                    let repo_path = client
-                        .fs
-                        .directories()
-                        .choose(&mut self.rng)
-                        .unwrap()
-                        .clone();
-
-                    let mut file_paths = client
-                        .fs
-                        .files()
-                        .into_iter()
-                        .filter(|path| path.starts_with(&repo_path))
-                        .collect::<Vec<_>>();
-                    let count = self.rng.gen_range(0..=file_paths.len());
-                    file_paths.shuffle(&mut self.rng);
-                    file_paths.truncate(count);
-
-                    let mut contents = Vec::new();
-                    for abs_child_file_path in &file_paths {
-                        let child_file_path = abs_child_file_path
-                            .strip_prefix(&repo_path)
-                            .unwrap()
-                            .to_path_buf();
-                        let new_base = Alphanumeric.sample_string(&mut self.rng, 16);
-                        contents.push((child_file_path, new_base));
-                    }
-
-                    break ClientOperation::WriteGitIndex {
-                        repo_path,
-                        contents,
+                    break ClientOperation::GitOperation {
+                        operation: self.generate_git_operation(client),
                    };
                }

@@ -1703,7 +1776,7 @@ impl TestPlan {
                    let is_dir = self.rng.gen::<bool>();
                    let content;
                    let mut path;
-                    let dir_paths = client.fs.directories();
+                    let dir_paths = client.fs.directories(false);

                    if is_dir {
                        content = String::new();
@@ -1732,6 +1805,89 @@ impl TestPlan {
        })
    }

+    fn generate_git_operation(&mut self, client: &TestClient) -> GitOperation {
+        fn generate_file_paths(
+            repo_path: &Path,
+            rng: &mut StdRng,
+            client: &TestClient,
+        ) -> Vec<PathBuf> {
+            let mut paths = client
+                .fs
+                .files()
+                .into_iter()
+                .filter(|path| path.starts_with(repo_path))
+                .collect::<Vec<_>>();
+
+            let count = rng.gen_range(0..=paths.len());
+            paths.shuffle(rng);
+            paths.truncate(count);
+
+            paths
+                .iter()
+                .map(|path| path.strip_prefix(repo_path).unwrap().to_path_buf())
+                .collect::<Vec<_>>()
+        }
+
+        let repo_path = client
+            .fs
+            .directories(false)
+            .choose(&mut self.rng)
+            .unwrap()
+            .clone();
+
+        match self.rng.gen_range(0..100_u32) {
+            0..=25 => {
+                let file_paths = generate_file_paths(&repo_path, &mut self.rng, client);
+
+                let contents = file_paths
+                    .into_iter()
+                    .map(|path| (path, Alphanumeric.sample_string(&mut self.rng, 16)))
+                    .collect();
+
+                GitOperation::WriteGitIndex {
+                    repo_path,
+                    contents,
+                }
+            }
+            26..=63 => {
+                let new_branch = (self.rng.gen_range(0..10) > 3)
+                    .then(|| Alphanumeric.sample_string(&mut self.rng, 8));
+
+                GitOperation::WriteGitBranch {
+                    repo_path,
+                    new_branch,
+                }
+            }
+            64..=100 => {
+                let file_paths = generate_file_paths(&repo_path, &mut self.rng, client);
+
+                let statuses = file_paths
+                    .into_iter()
+                    .map(|paths| {
+                        (
+                            paths,
+                            match self.rng.gen_range(0..3_u32) {
+                                0 => GitFileStatus::Added,
+                                1 => GitFileStatus::Modified,
+                                2 => GitFileStatus::Conflict,
+                                _ => unreachable!(),
+                            },
+                        )
+                    })
+                    .collect::<Vec<_>>();
+
+                let git_operation = self.rng.gen::<bool>();
+
+                GitOperation::WriteGitStatuses {
+                    repo_path,
+                    statuses,
+                    git_operation,
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+
    fn next_root_dir_name(&mut self, user_id: UserId) -> String {
        let user_ix = self
            .users
--- a/crates/collab_ui/src/collab_titlebar_item.rs
+++ b/crates/collab_ui/src/collab_titlebar_item.rs
@@ -14,16 +14,17 @@ use gpui::{
    geometry::{rect::RectF, vector::vec2f, PathBuilder},
    json::{self, ToJson},
    platform::{CursorStyle, MouseButton},
-    AppContext, Entity, ImageData, ModelHandle, SceneBuilder, Subscription, View, ViewContext,
-    ViewHandle, WeakViewHandle,
+    AppContext, Entity, ImageData, LayoutContext, ModelHandle, SceneBuilder, Subscription, View,
+    ViewContext, ViewHandle, WeakViewHandle,
 };
 use project::Project;
-use settings::Settings;
 use std::{ops::Range, sync::Arc};
 use theme::{AvatarStyle, Theme};
 use util::ResultExt;
 use workspace::{FollowNextCollaborator, Workspace};

+const MAX_TITLE_LENGTH: usize = 75;
+
 actions!(
    collab,
    [
@@ -68,29 +69,11 @@ impl View for CollabTitlebarItem {
        };

        let project = self.project.read(cx);
-        let mut project_title = String::new();
-        for (i, name) in project.worktree_root_names(cx).enumerate() {
-            if i > 0 {
-                project_title.push_str(", ");
-            }
-            project_title.push_str(name);
-        }
-        if project_title.is_empty() {
-            project_title = "empty project".to_owned();
-        }
-
-        let theme = cx.global::<Settings>().theme.clone();
-
+        let theme = theme::current(cx).clone();
        let mut left_container = Flex::row();
        let mut right_container = Flex::row().align_children_center();

-        left_container.add_child(
-            Label::new(project_title, theme.workspace.titlebar.title.clone())
-                .contained()
-                .with_margin_right(theme.workspace.titlebar.item_spacing)
-                .aligned()
-                .left(),
-        );
+        left_container.add_child(self.collect_title_root_names(&project, theme.clone(), cx));

        let user = self.user_store.read(cx).current_user();
        let peer_id = self.client.peer_id();
@@ -120,7 +103,21 @@ impl View for CollabTitlebarItem {

        Stack::new()
            .with_child(left_container)
-            .with_child(right_container.aligned().right())
+            .with_child(
+                Flex::row()
+                    .with_child(
+                        right_container.contained().with_background_color(
+                            theme
+                                .workspace
+                                .titlebar
+                                .container
+                                .background_color
+                                .unwrap_or_else(|| Color::transparent_black()),
+                        ),
+                    )
+                    .aligned()
+                    .right(),
+            )
            .into_any()
    }
 }
@@ -137,6 +134,7 @@ impl CollabTitlebarItem {
        let active_call = ActiveCall::global(cx);
        let mut subscriptions = Vec::new();
        subscriptions.push(cx.observe(workspace_handle, |_, _, cx| cx.notify()));
+        subscriptions.push(cx.observe(&project, |_, _, cx| cx.notify()));
        subscriptions.push(cx.observe(&active_call, |this, _, cx| this.active_call_changed(cx)));
        subscriptions.push(cx.observe_window_activation(|this, active, cx| {
            this.window_activation_changed(active, cx)
@@ -165,6 +163,7 @@ impl CollabTitlebarItem {
            }),
        );

+        let view_id = cx.view_id();
        Self {
            workspace: workspace.weak_handle(),
            project,
@@ -172,7 +171,7 @@ impl CollabTitlebarItem {
            client,
            contacts_popover: None,
            user_menu: cx.add_view(|cx| {
-                let mut menu = ContextMenu::new(cx);
+                let mut menu = ContextMenu::new(view_id, cx);
                menu.set_position_mode(OverlayPositionMode::Local);
                menu
            }),
@@ -180,6 +179,63 @@ impl CollabTitlebarItem {
        }
    }

+    fn collect_title_root_names(
+        &self,
+        project: &Project,
+        theme: Arc<Theme>,
+        cx: &ViewContext<Self>,
+    ) -> AnyElement<Self> {
+        let names_and_branches = project.visible_worktrees(cx).map(|worktree| {
+            let worktree = worktree.read(cx);
+            (worktree.root_name(), worktree.root_git_entry())
+        });
+
+        fn push_str(buffer: &mut String, index: &mut usize, str: &str) {
+            buffer.push_str(str);
+            *index += str.chars().count();
+        }
+
+        let mut indices = Vec::new();
+        let mut index = 0;
+        let mut title = String::new();
+        let mut names_and_branches = names_and_branches.peekable();
+        while let Some((name, entry)) = names_and_branches.next() {
+            let pre_index = index;
+            push_str(&mut title, &mut index, name);
+            indices.extend((pre_index..index).into_iter());
+            if let Some(branch) = entry.and_then(|entry| entry.branch()) {
+                push_str(&mut title, &mut index, "/");
+                push_str(&mut title, &mut index, &branch);
+            }
+            if names_and_branches.peek().is_some() {
+                push_str(&mut title, &mut index, ", ");
+                if index >= MAX_TITLE_LENGTH {
+                    title.push_str(" …");
+                    break;
+                }
+            }
+        }
+
+        let text_style = theme.workspace.titlebar.title.clone();
+        let item_spacing = theme.workspace.titlebar.item_spacing;
+
+        let mut highlight = text_style.clone();
+        highlight.color = theme.workspace.titlebar.highlight_color;
+
+        let style = LabelStyle {
+            text: text_style,
+            highlight_text: Some(highlight),
+        };
+
+        Label::new(title, style)
+            .with_highlights(indices)
+            .contained()
+            .with_margin_right(item_spacing)
+            .aligned()
+            .left()
+            .into_any_named("title-with-git-information")
+    }
+
    fn window_activation_changed(&mut self, active: bool, cx: &mut ViewContext<Self>) {
        let project = if active {
            Some(self.project.clone())
@@ -241,7 +297,7 @@ impl CollabTitlebarItem {
    }

    pub fn toggle_user_menu(&mut self, _: &ToggleUserMenu, cx: &mut ViewContext<Self>) {
-        let theme = cx.global::<Settings>().theme.clone();
+        let theme = theme::current(cx).clone();
        let avatar_style = theme.workspace.titlebar.leader_avatar.clone();
        let item_style = theme.context_menu.item.disabled_style().clone();
        self.user_menu.update(cx, |user_menu, cx| {
@@ -416,7 +472,7 @@ impl CollabTitlebarItem {
            Stack::new()
                .with_child(
                    MouseEventHandler::<ShareUnshare, Self>::new(0, cx, |state, _| {
-                        //TODO: Ensure this button has consistant width for both text variations
+                        //TODO: Ensure this button has consistent width for both text variations
                        let style = titlebar.share_button.style_for(state, false);
                        Label::new(label, style.text.clone())
                            .contained()
@@ -809,7 +865,7 @@ impl CollabTitlebarItem {
    ) -> Option<AnyElement<Self>> {
        enum ConnectionStatusButton {}

-        let theme = &cx.global::<Settings>().theme.clone();
+        let theme = &theme::current(cx).clone();
        match status {
            client::Status::ConnectionError
            | client::Status::ConnectionLost
@@ -865,7 +921,7 @@ impl Element<CollabTitlebarItem> for AvatarRibbon {
        &mut self,
        constraint: gpui::SizeConstraint,
        _: &mut CollabTitlebarItem,
-        _: &mut ViewContext<CollabTitlebarItem>,
+        _: &mut LayoutContext<CollabTitlebarItem>,
    ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
        (constraint.max, ())
    }
--- a/crates/collab_ui/src/contact_finder.rs
+++ b/crates/collab_ui/src/contact_finder.rs
@@ -1,7 +1,6 @@
 use client::{ContactRequestStatus, User, UserStore};
 use gpui::{elements::*, AppContext, ModelHandle, MouseState, Task, ViewContext};
 use picker::{Picker, PickerDelegate, PickerEvent};
-use settings::Settings;
 use std::sync::Arc;
 use util::TryFutureExt;

@@ -98,7 +97,7 @@ impl PickerDelegate for ContactFinderDelegate {
        selected: bool,
        cx: &gpui::AppContext,
    ) -> AnyElement<Picker<Self>> {
-        let theme = &cx.global::<Settings>().theme;
+        let theme = &theme::current(cx);
        let user = &self.potential_contacts[ix];
        let request_status = self.user_store.read(cx).contact_request_status(user);

--- a/crates/collab_ui/src/contact_list.rs
+++ b/crates/collab_ui/src/contact_list.rs
@@ -14,7 +14,6 @@ use gpui::{
 use menu::{Confirm, SelectNext, SelectPrev};
 use project::Project;
 use serde::Deserialize;
-use settings::Settings;
 use std::{mem, sync::Arc};
 use theme::IconButton;
 use workspace::Workspace;
@@ -192,7 +191,7 @@ impl ContactList {
        .detach();

        let list_state = ListState::<Self>::new(0, Orientation::Top, 1000., move |this, ix, cx| {
-            let theme = cx.global::<Settings>().theme.clone();
+            let theme = theme::current(cx).clone();
            let is_selected = this.selection == Some(ix);
            let current_project_id = this.project.read(cx).remote_id();

@@ -1306,15 +1305,14 @@ impl View for ContactList {
        "ContactList"
    }

-    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
-        let mut cx = Self::default_keymap_context();
-        cx.add_identifier("menu");
-        cx
+    fn update_keymap_context(&self, keymap: &mut KeymapContext, _: &AppContext) {
+        Self::reset_to_default_keymap_context(keymap);
+        keymap.add_identifier("menu");
    }

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
        enum AddContact {}
-        let theme = cx.global::<Settings>().theme.clone();
+        let theme = theme::current(cx).clone();

        Flex::column()
            .with_child(
--- a/crates/collab_ui/src/contacts_popover.rs
+++ b/crates/collab_ui/src/contacts_popover.rs
@@ -9,7 +9,6 @@ use gpui::{
 };
 use picker::PickerEvent;
 use project::Project;
-use settings::Settings;
 use workspace::Workspace;

 actions!(contacts_popover, [ToggleContactFinder]);
@@ -108,7 +107,7 @@ impl View for ContactsPopover {
    }

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let theme = cx.global::<Settings>().theme.clone();
+        let theme = theme::current(cx).clone();
        let child = match &self.child {
            Child::ContactList(child) => ChildView::new(child, cx),
            Child::ContactFinder(child) => ChildView::new(child, cx),
--- a/crates/collab_ui/src/face_pile.rs
+++ b/crates/collab_ui/src/face_pile.rs
@@ -7,7 +7,7 @@ use gpui::{
    },
    json::ToJson,
    serde_json::{self, json},
-    AnyElement, Axis, Element, SceneBuilder, ViewContext,
+    AnyElement, Axis, Element, LayoutContext, SceneBuilder, ViewContext,
 };

 use crate::CollabTitlebarItem;
@@ -34,7 +34,7 @@ impl Element<CollabTitlebarItem> for FacePile {
        &mut self,
        constraint: gpui::SizeConstraint,
        view: &mut CollabTitlebarItem,
-        cx: &mut ViewContext<CollabTitlebarItem>,
+        cx: &mut LayoutContext<CollabTitlebarItem>,
    ) -> (Vector2F, Self::LayoutState) {
        debug_assert!(constraint.max_along(Axis::Horizontal) == f32::INFINITY);

--- a/crates/collab_ui/src/incoming_call_notification.rs
+++ b/crates/collab_ui/src/incoming_call_notification.rs
@@ -9,7 +9,6 @@ use gpui::{
    platform::{CursorStyle, MouseButton, WindowBounds, WindowKind, WindowOptions},
    AnyElement, AppContext, Entity, View, ViewContext,
 };
-use settings::Settings;
 use util::ResultExt;
 use workspace::AppState;

@@ -26,7 +25,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
            if let Some(incoming_call) = incoming_call {
                const PADDING: f32 = 16.;
                let window_size = cx.read(|cx| {
-                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
+                    let theme = &theme::current(cx).incoming_call_notification;
                    vec2f(theme.window_width, theme.window_height)
                });

@@ -42,6 +41,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
                            titlebar: None,
                            center: false,
                            focus: false,
+                            show: true,
                            kind: WindowKind::PopUp,
                            is_movable: false,
                            screen: Some(screen),
@@ -106,7 +106,7 @@ impl IncomingCallNotification {
    }

    fn render_caller(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let theme = &cx.global::<Settings>().theme.incoming_call_notification;
+        let theme = &theme::current(cx).incoming_call_notification;
        let default_project = proto::ParticipantProject::default();
        let initial_project = self
            .call
@@ -170,10 +170,11 @@ impl IncomingCallNotification {
        enum Accept {}
        enum Decline {}

+        let theme = theme::current(cx);
        Flex::column()
            .with_child(
-                MouseEventHandler::<Accept, Self>::new(0, cx, |_, cx| {
-                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
+                MouseEventHandler::<Accept, Self>::new(0, cx, |_, _| {
+                    let theme = &theme.incoming_call_notification;
                    Label::new("Accept", theme.accept_button.text.clone())
                        .aligned()
                        .contained()
@@ -186,8 +187,8 @@ impl IncomingCallNotification {
                .flex(1., true),
            )
            .with_child(
-                MouseEventHandler::<Decline, Self>::new(0, cx, |_, cx| {
-                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
+                MouseEventHandler::<Decline, Self>::new(0, cx, |_, _| {
+                    let theme = &theme.incoming_call_notification;
                    Label::new("Decline", theme.decline_button.text.clone())
                        .aligned()
                        .contained()
@@ -200,12 +201,7 @@ impl IncomingCallNotification {
                .flex(1., true),
            )
            .constrained()
-            .with_width(
-                cx.global::<Settings>()
-                    .theme
-                    .incoming_call_notification
-                    .button_width,
-            )
+            .with_width(theme.incoming_call_notification.button_width)
            .into_any()
    }
 }
@@ -220,12 +216,7 @@ impl View for IncomingCallNotification {
    }

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let background = cx
-            .global::<Settings>()
-            .theme
-            .incoming_call_notification
-            .background;
-
+        let background = theme::current(cx).incoming_call_notification.background;
        Flex::row()
            .with_child(self.render_caller(cx))
            .with_child(self.render_buttons(cx))
--- a/crates/collab_ui/src/notifications.rs
+++ b/crates/collab_ui/src/notifications.rs
@@ -4,7 +4,6 @@ use gpui::{
    platform::{CursorStyle, MouseButton},
    AnyElement, Element, View, ViewContext,
 };
-use settings::Settings;
 use std::sync::Arc;

 enum Dismiss {}
@@ -22,7 +21,7 @@ where
    F: 'static + Fn(&mut V, &mut ViewContext<V>),
    V: View,
 {
-    let theme = cx.global::<Settings>().theme.clone();
+    let theme = theme::current(cx).clone();
    let theme = &theme.contact_notification;

    Flex::column()
--- a/crates/collab_ui/src/project_shared_notification.rs
+++ b/crates/collab_ui/src/project_shared_notification.rs
@@ -7,7 +7,6 @@ use gpui::{
    platform::{CursorStyle, MouseButton, WindowBounds, WindowKind, WindowOptions},
    AppContext, Entity, View, ViewContext,
 };
-use settings::Settings;
 use std::sync::{Arc, Weak};
 use workspace::AppState;

@@ -22,7 +21,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
            worktree_root_names,
        } => {
            const PADDING: f32 = 16.;
-            let theme = &cx.global::<Settings>().theme.project_shared_notification;
+            let theme = &theme::current(cx).project_shared_notification;
            let window_size = vec2f(theme.window_width, theme.window_height);

            for screen in cx.platform().screens() {
@@ -36,6 +35,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
                        titlebar: None,
                        center: false,
                        focus: false,
+                        show: true,
                        kind: WindowKind::PopUp,
                        is_movable: false,
                        screen: Some(screen),
@@ -109,7 +109,7 @@ impl ProjectSharedNotification {
    }

    fn render_owner(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let theme = &cx.global::<Settings>().theme.project_shared_notification;
+        let theme = &theme::current(cx).project_shared_notification;
        Flex::row()
            .with_children(self.owner.avatar.clone().map(|avatar| {
                Image::from_data(avatar)
@@ -167,10 +167,11 @@ impl ProjectSharedNotification {
        enum Open {}
        enum Dismiss {}

+        let theme = theme::current(cx);
        Flex::column()
            .with_child(
-                MouseEventHandler::<Open, Self>::new(0, cx, |_, cx| {
-                    let theme = &cx.global::<Settings>().theme.project_shared_notification;
+                MouseEventHandler::<Open, Self>::new(0, cx, |_, _| {
+                    let theme = &theme.project_shared_notification;
                    Label::new("Open", theme.open_button.text.clone())
                        .aligned()
                        .contained()
@@ -181,8 +182,8 @@ impl ProjectSharedNotification {
                .flex(1., true),
            )
            .with_child(
-                MouseEventHandler::<Dismiss, Self>::new(0, cx, |_, cx| {
-                    let theme = &cx.global::<Settings>().theme.project_shared_notification;
+                MouseEventHandler::<Dismiss, Self>::new(0, cx, |_, _| {
+                    let theme = &theme.project_shared_notification;
                    Label::new("Dismiss", theme.dismiss_button.text.clone())
                        .aligned()
                        .contained()
@@ -195,12 +196,7 @@ impl ProjectSharedNotification {
                .flex(1., true),
            )
            .constrained()
-            .with_width(
-                cx.global::<Settings>()
-                    .theme
-                    .project_shared_notification
-                    .button_width,
-            )
+            .with_width(theme.project_shared_notification.button_width)
            .into_any()
    }
 }
@@ -215,11 +211,7 @@ impl View for ProjectSharedNotification {
    }

    fn render(&mut self, cx: &mut ViewContext<Self>) -> gpui::AnyElement<Self> {
-        let background = cx
-            .global::<Settings>()
-            .theme
-            .project_shared_notification
-            .background;
+        let background = theme::current(cx).project_shared_notification.background;
        Flex::row()
            .with_child(self.render_owner(cx))
            .with_child(self.render_buttons(cx))
--- a/crates/collab_ui/src/sharing_status_indicator.rs
+++ b/crates/collab_ui/src/sharing_status_indicator.rs
@@ -6,7 +6,7 @@ use gpui::{
    platform::{Appearance, MouseButton},
    AnyElement, AppContext, Element, Entity, View, ViewContext,
 };
-use settings::Settings;
+use workspace::WorkspaceSettings;

 pub fn init(cx: &mut AppContext) {
    let active_call = ActiveCall::global(cx);
@@ -15,7 +15,9 @@ pub fn init(cx: &mut AppContext) {
    cx.observe(&active_call, move |call, cx| {
        if let Some(room) = call.read(cx).room() {
            if room.read(cx).is_screen_sharing() {
-                if status_indicator.is_none() && cx.global::<Settings>().show_call_status_icon {
+                if status_indicator.is_none()
+                    && settings::get::<WorkspaceSettings>(cx).show_call_status_icon
+                {
                    status_indicator = Some(cx.add_status_bar_item(|_| SharingStatusIndicator));
                }
            } else if let Some((window_id, _)) = status_indicator.take() {
--- a/crates/command_palette/Cargo.toml
+++ b/crates/command_palette/Cargo.toml
@@ -23,6 +23,7 @@ workspace = { path = "../workspace" }
 [dev-dependencies]
 gpui = { path = "../gpui", features = ["test-support"] }
 editor = { path = "../editor", features = ["test-support"] }
+language = { path = "../language", features = ["test-support"] }
 project = { path = "../project", features = ["test-support"] }
 serde_json.workspace = true
 workspace = { path = "../workspace", features = ["test-support"] }
--- a/crates/command_palette/src/command_palette.rs
+++ b/crates/command_palette/src/command_palette.rs
@@ -2,10 +2,9 @@ use collections::CommandPaletteFilter;
 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
    actions, elements::*, keymap_matcher::Keystroke, Action, AppContext, Element, MouseState,
-    ViewContext, WindowContext,
+    ViewContext,
 };
 use picker::{Picker, PickerDelegate, PickerEvent};
-use settings::Settings;
 use std::cmp;
 use util::ResultExt;
 use workspace::Workspace;
@@ -41,47 +40,17 @@ struct Command {
    keystrokes: Vec<Keystroke>,
 }

-fn toggle_command_palette(_: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
-    let workspace = cx.handle();
-    let focused_view_id = cx.focused_view_id().unwrap_or_else(|| workspace.id());
-
-    cx.window_context().defer(move |cx| {
-        // Build the delegate before the workspace is put on the stack so we can find it when
-        // computing the actions. We should really not allow available_actions to be called
-        // if it's not reliable however.
-        let delegate = CommandPaletteDelegate::new(focused_view_id, cx);
-        workspace.update(cx, |workspace, cx| {
-            workspace.toggle_modal(cx, |_, cx| cx.add_view(|cx| Picker::new(delegate, cx)));
-        })
+fn toggle_command_palette(workspace: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
+    let focused_view_id = cx.focused_view_id().unwrap_or_else(|| cx.view_id());
+    workspace.toggle_modal(cx, |_, cx| {
+        cx.add_view(|cx| Picker::new(CommandPaletteDelegate::new(focused_view_id), cx))
    });
 }

 impl CommandPaletteDelegate {
-    pub fn new(focused_view_id: usize, cx: &mut WindowContext) -> Self {
-        let actions = cx
-            .available_actions(focused_view_id)
-            .filter_map(|(name, action, bindings)| {
-                if cx.has_global::<CommandPaletteFilter>() {
-                    let filter = cx.global::<CommandPaletteFilter>();
-                    if filter.filtered_namespaces.contains(action.namespace()) {
-                        return None;
-                    }
-                }
-
-                Some(Command {
-                    name: humanize_action_name(name),
-                    action,
-                    keystrokes: bindings
-                        .iter()
-                        .map(|binding| binding.keystrokes())
-                        .last()
-                        .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
-                })
-            })
-            .collect();
-
+    pub fn new(focused_view_id: usize) -> Self {
        Self {
-            actions,
+            actions: Default::default(),
            matches: vec![],
            selected_ix: 0,
            focused_view_id,
@@ -111,17 +80,46 @@ impl PickerDelegate for CommandPaletteDelegate {
        query: String,
        cx: &mut ViewContext<Picker<Self>>,
    ) -> gpui::Task<()> {
-        let candidates = self
-            .actions
-            .iter()
-            .enumerate()
-            .map(|(ix, command)| StringMatchCandidate {
-                id: ix,
-                string: command.name.to_string(),
-                char_bag: command.name.chars().collect(),
-            })
-            .collect::<Vec<_>>();
+        let window_id = cx.window_id();
+        let view_id = self.focused_view_id;
        cx.spawn(move |picker, mut cx| async move {
+            let actions = cx
+                .available_actions(window_id, view_id)
+                .into_iter()
+                .filter_map(|(name, action, bindings)| {
+                    let filtered = cx.read(|cx| {
+                        if cx.has_global::<CommandPaletteFilter>() {
+                            let filter = cx.global::<CommandPaletteFilter>();
+                            filter.filtered_namespaces.contains(action.namespace())
+                        } else {
+                            false
+                        }
+                    });
+
+                    if filtered {
+                        None
+                    } else {
+                        Some(Command {
+                            name: humanize_action_name(name),
+                            action,
+                            keystrokes: bindings
+                                .iter()
+                                .map(|binding| binding.keystrokes())
+                                .last()
+                                .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
+                        })
+                    }
+                })
+                .collect::<Vec<_>>();
+            let candidates = actions
+                .iter()
+                .enumerate()
+                .map(|(ix, command)| StringMatchCandidate {
+                    id: ix,
+                    string: command.name.to_string(),
+                    char_bag: command.name.chars().collect(),
+                })
+                .collect::<Vec<_>>();
            let matches = if query.is_empty() {
                candidates
                    .into_iter()
@@ -147,6 +145,7 @@ impl PickerDelegate for CommandPaletteDelegate {
            picker
                .update(&mut cx, |picker, _| {
                    let delegate = picker.delegate_mut();
+                    delegate.actions = actions;
                    delegate.matches = matches;
                    if delegate.matches.is_empty() {
                        delegate.selected_ix = 0;
@@ -185,8 +184,7 @@ impl PickerDelegate for CommandPaletteDelegate {
    ) -> AnyElement<Picker<Self>> {
        let mat = &self.matches[ix];
        let command = &self.actions[mat.candidate_id];
-        let settings = cx.global::<Settings>();
-        let theme = &settings.theme;
+        let theme = theme::current(cx);
        let style = theme.picker.item.style_for(mouse_state, selected);
        let key_style = &theme.command_palette.key.style_for(mouse_state, selected);
        let keystroke_spacing = theme.command_palette.keystroke_spacing;
@@ -294,18 +292,11 @@ mod tests {

    #[gpui::test]
    async fn test_command_palette(deterministic: Arc<Deterministic>, cx: &mut TestAppContext) {
-        deterministic.forbid_parking();
-        let app_state = cx.update(AppState::test);
-
-        cx.update(|cx| {
-            editor::init(cx);
-            workspace::init(app_state.clone(), cx);
-            init(cx);
-        });
+        let app_state = init_test(cx);

        let project = Project::test(app_state.fs.clone(), [], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
-        let editor = cx.add_view(&workspace, |cx| {
+        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
+        let editor = cx.add_view(window_id, |cx| {
            let mut editor = Editor::single_line(None, cx);
            editor.set_text("abc", cx);
            editor
@@ -369,4 +360,16 @@ mod tests {
            assert!(palette.delegate().matches.is_empty())
        });
    }
+
+    fn init_test(cx: &mut TestAppContext) -> Arc<AppState> {
+        cx.update(|cx| {
+            let app_state = AppState::test(cx);
+            theme::init((), cx);
+            language::init(cx);
+            editor::init(cx);
+            workspace::init(app_state.clone(), cx);
+            init(cx);
+            app_state
+        })
+    }
 }
--- a/crates/context_menu/src/context_menu.rs
+++ b/crates/context_menu/src/context_menu.rs
@@ -8,7 +8,6 @@ use gpui::{
    View, ViewContext,
 };
 use menu::*;
-use settings::Settings;
 use std::{any::TypeId, borrow::Cow, sync::Arc, time::Duration};

 pub fn init(cx: &mut AppContext) {
@@ -126,7 +125,6 @@ pub struct ContextMenu {
    selected_index: Option<usize>,
    visible: bool,
    previously_focused_view_id: Option<usize>,
-    clicked: bool,
    parent_view_id: usize,
    _actions_observation: Subscription,
 }
@@ -140,10 +138,9 @@ impl View for ContextMenu {
        "ContextMenu"
    }

-    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
-        let mut cx = Self::default_keymap_context();
-        cx.add_identifier("menu");
-        cx
+    fn update_keymap_context(&self, keymap: &mut KeymapContext, _: &AppContext) {
+        Self::reset_to_default_keymap_context(keymap);
+        keymap.add_identifier("menu");
    }

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
@@ -178,9 +175,7 @@ impl View for ContextMenu {
 }

 impl ContextMenu {
-    pub fn new(cx: &mut ViewContext<Self>) -> Self {
-        let parent_view_id = cx.parent().unwrap();
-
+    pub fn new(parent_view_id: usize, cx: &mut ViewContext<Self>) -> Self {
        Self {
            show_count: 0,
            anchor_position: Default::default(),
@@ -190,7 +185,6 @@ impl ContextMenu {
            selected_index: Default::default(),
            visible: Default::default(),
            previously_focused_view_id: Default::default(),
-            clicked: false,
            parent_view_id,
            _actions_observation: cx.observe_actions(Self::action_dispatched),
        }
@@ -206,18 +200,14 @@ impl ContextMenu {
            .iter()
            .position(|item| item.action_id() == Some(action_id))
        {
-            if self.clicked {
-                self.cancel(&Default::default(), cx);
-            } else {
-                self.selected_index = Some(ix);
-                cx.notify();
-                cx.spawn(|this, mut cx| async move {
-                    cx.background().timer(Duration::from_millis(50)).await;
-                    this.update(&mut cx, |this, cx| this.cancel(&Default::default(), cx))?;
-                    anyhow::Ok(())
-                })
-                .detach_and_log_err(cx);
-            }
+            self.selected_index = Some(ix);
+            cx.notify();
+            cx.spawn(|this, mut cx| async move {
+                cx.background().timer(Duration::from_millis(50)).await;
+                this.update(&mut cx, |this, cx| this.cancel(&Default::default(), cx))?;
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
        }
    }

@@ -257,7 +247,6 @@ impl ContextMenu {
        self.items.clear();
        self.visible = false;
        self.selected_index.take();
-        self.clicked = false;
        cx.notify();
    }

@@ -333,7 +322,7 @@ impl ContextMenu {
    }

    fn render_menu_for_measurement(&self, cx: &mut ViewContext<Self>) -> impl Element<ContextMenu> {
-        let style = cx.global::<Settings>().theme.context_menu.clone();
+        let style = theme::current(cx).context_menu.clone();
        Flex::row()
            .with_child(
                Flex::column().with_children(self.items.iter().enumerate().map(|(ix, item)| {
@@ -413,7 +402,7 @@ impl ContextMenu {
        enum Menu {}
        enum MenuItem {}

-        let style = cx.global::<Settings>().theme.context_menu.clone();
+        let style = theme::current(cx).context_menu.clone();

        MouseEventHandler::<Menu, ContextMenu>::new(0, cx, |_, cx| {
            Flex::column()
@@ -457,7 +446,7 @@ impl ContextMenu {
                            .on_up(MouseButton::Left, |_, _, _| {}) // Capture these events
                            .on_down(MouseButton::Left, |_, _, _| {}) // Capture these events
                            .on_click(MouseButton::Left, move |_, menu, cx| {
-                                menu.clicked = true;
+                                menu.cancel(&Default::default(), cx);
                                let window_id = cx.window_id();
                                match &action {
                                    ContextMenuItemAction::Action(action) => {
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -4,12 +4,13 @@ mod sign_in;
 use anyhow::{anyhow, Context, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
-use collections::HashMap;
+use collections::{HashMap, HashSet};
 use futures::{channel::oneshot, future::Shared, Future, FutureExt, TryFutureExt};
 use gpui::{
    actions, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, Task, WeakModelHandle,
 };
 use language::{
+    language_settings::{all_language_settings, language_settings},
    point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language, PointUtf16,
    ToPointUtf16,
 };
@@ -17,7 +18,7 @@ use log::{debug, error};
 use lsp::{LanguageServer, LanguageServerId};
 use node_runtime::NodeRuntime;
 use request::{LogMessage, StatusNotification};
-use settings::Settings;
+use settings::SettingsStore;
 use smol::{fs, io::BufReader, stream::StreamExt};
 use std::{
    ffi::OsString,
@@ -162,7 +163,6 @@ impl Status {
 }

 struct RegisteredBuffer {
-    id: usize,
    uri: lsp::Url,
    language_id: String,
    snapshot: BufferSnapshot,
@@ -177,13 +177,13 @@ impl RegisteredBuffer {
        buffer: &ModelHandle<Buffer>,
        cx: &mut ModelContext<Copilot>,
    ) -> oneshot::Receiver<(i32, BufferSnapshot)> {
-        let id = self.id;
        let (done_tx, done_rx) = oneshot::channel();

        if buffer.read(cx).version() == self.snapshot.version {
            let _ = done_tx.send((self.snapshot_version, self.snapshot.clone()));
        } else {
            let buffer = buffer.downgrade();
+            let id = buffer.id();
            let prev_pending_change =
                mem::replace(&mut self.pending_buffer_change, Task::ready(None));
            self.pending_buffer_change = cx.spawn_weak(|copilot, mut cx| async move {
@@ -258,7 +258,7 @@ impl RegisteredBuffer {

 #[derive(Debug)]
 pub struct Completion {
-    uuid: String,
+    pub uuid: String,
    pub range: Range<Anchor>,
    pub text: String,
 }
@@ -267,7 +267,7 @@ pub struct Copilot {
    http: Arc<dyn HttpClient>,
    node_runtime: Arc<NodeRuntime>,
    server: CopilotServer,
-    buffers: HashMap<usize, WeakModelHandle<Buffer>>,
+    buffers: HashSet<WeakModelHandle<Buffer>>,
 }

 impl Entity for Copilot {
@@ -302,56 +302,34 @@ impl Copilot {
        node_runtime: Arc<NodeRuntime>,
        cx: &mut ModelContext<Self>,
    ) -> Self {
-        cx.observe_global::<Settings, _>({
-            let http = http.clone();
-            let node_runtime = node_runtime.clone();
-            move |this, cx| {
-                if cx.global::<Settings>().features.copilot {
-                    if matches!(this.server, CopilotServer::Disabled) {
-                        let start_task = cx
-                            .spawn({
-                                let http = http.clone();
-                                let node_runtime = node_runtime.clone();
-                                move |this, cx| {
-                                    Self::start_language_server(http, node_runtime, this, cx)
-                                }
-                            })
-                            .shared();
-                        this.server = CopilotServer::Starting { task: start_task };
-                        cx.notify();
-                    }
-                } else {
-                    this.server = CopilotServer::Disabled;
-                    cx.notify();
-                }
-            }
-        })
-        .detach();
+        let mut this = Self {
+            http,
+            node_runtime,
+            server: CopilotServer::Disabled,
+            buffers: Default::default(),
+        };
+        this.enable_or_disable_copilot(cx);
+        cx.observe_global::<SettingsStore, _>(move |this, cx| this.enable_or_disable_copilot(cx))
+            .detach();
+        this
+    }

-        if cx.global::<Settings>().features.copilot {
-            let start_task = cx
-                .spawn({
-                    let http = http.clone();
-                    let node_runtime = node_runtime.clone();
-                    move |this, cx| async {
-                        Self::start_language_server(http, node_runtime, this, cx).await
-                    }
-                })
-                .shared();
-
-            Self {
-                http,
-                node_runtime,
-                server: CopilotServer::Starting { task: start_task },
-                buffers: Default::default(),
+    fn enable_or_disable_copilot(&mut self, cx: &mut ModelContext<Copilot>) {
+        let http = self.http.clone();
+        let node_runtime = self.node_runtime.clone();
+        if all_language_settings(None, cx).copilot_enabled(None, None) {
+            if matches!(self.server, CopilotServer::Disabled) {
+                let start_task = cx
+                    .spawn({
+                        move |this, cx| Self::start_language_server(http, node_runtime, this, cx)
+                    })
+                    .shared();
+                self.server = CopilotServer::Starting { task: start_task };
+                cx.notify();
            }
        } else {
-            Self {
-                http,
-                node_runtime,
-                server: CopilotServer::Disabled,
-                buffers: Default::default(),
-            }
+            self.server = CopilotServer::Disabled;
+            cx.notify();
        }
    }

@@ -396,7 +374,7 @@ impl Copilot {
                server
                    .on_notification::<LogMessage, _>(|params, _cx| {
                        match params.level {
-                            // Copilot is pretty agressive about logging
+                            // Copilot is pretty aggressive about logging
                            0 => debug!("copilot: {}", params.message),
                            1 => debug!("copilot: {}", params.message),
                            _ => error!("copilot: {}", params.message),
@@ -461,14 +439,12 @@ impl Copilot {
    pub fn sign_in(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
        if let CopilotServer::Running(server) = &mut self.server {
            let task = match &server.sign_in_status {
-                SignInStatus::Authorized { .. } | SignInStatus::Unauthorized { .. } => {
-                    Task::ready(Ok(())).shared()
-                }
+                SignInStatus::Authorized { .. } => Task::ready(Ok(())).shared(),
                SignInStatus::SigningIn { task, .. } => {
                    cx.notify();
                    task.clone()
                }
-                SignInStatus::SignedOut => {
+                SignInStatus::SignedOut | SignInStatus::Unauthorized { .. } => {
                    let lsp = server.lsp.clone();
                    let task = cx
                        .spawn(|this, mut cx| async move {
@@ -582,8 +558,8 @@ impl Copilot {
    }

    pub fn register_buffer(&mut self, buffer: &ModelHandle<Buffer>, cx: &mut ModelContext<Self>) {
-        let buffer_id = buffer.id();
-        self.buffers.insert(buffer_id, buffer.downgrade());
+        let weak_buffer = buffer.downgrade();
+        self.buffers.insert(weak_buffer.clone());

        if let CopilotServer::Running(RunningCopilotServer {
            lsp: server,
@@ -614,7 +590,6 @@ impl Copilot {
                    .log_err();

                RegisteredBuffer {
-                    id: buffer_id,
                    uri,
                    language_id,
                    snapshot,
@@ -625,8 +600,8 @@ impl Copilot {
                            this.handle_buffer_event(buffer, event, cx).log_err();
                        }),
                        cx.observe_release(buffer, move |this, _buffer, _cx| {
-                            this.buffers.remove(&buffer_id);
-                            this.unregister_buffer(buffer_id);
+                            this.buffers.remove(&weak_buffer);
+                            this.unregister_buffer(&weak_buffer);
                        }),
                    ],
                }
@@ -695,9 +670,9 @@ impl Copilot {
        Ok(())
    }

-    fn unregister_buffer(&mut self, buffer_id: usize) {
+    fn unregister_buffer(&mut self, buffer: &WeakModelHandle<Buffer>) {
        if let Ok(server) = self.server.as_running() {
-            if let Some(buffer) = server.registered_buffers.remove(&buffer_id) {
+            if let Some(buffer) = server.registered_buffers.remove(&buffer.id()) {
                server
                    .lsp
                    .notify::<lsp::notification::DidCloseTextDocument>(
@@ -804,13 +779,10 @@ impl Copilot {
        let snapshot = registered_buffer.report_changes(buffer, cx);
        let buffer = buffer.read(cx);
        let uri = registered_buffer.uri.clone();
-        let settings = cx.global::<Settings>();
        let position = position.to_point_utf16(buffer);
-        let language = buffer.language_at(position);
-        let language_name = language.map(|language| language.name());
-        let language_name = language_name.as_deref();
-        let tab_size = settings.tab_size(language_name);
-        let hard_tabs = settings.hard_tabs(language_name);
+        let settings = language_settings(buffer.language_at(position).as_ref(), buffer.file(), cx);
+        let tab_size = settings.tab_size;
+        let hard_tabs = settings.hard_tabs;
        let relative_path = buffer
            .file()
            .map(|file| file.path().to_path_buf())
@@ -873,7 +845,7 @@ impl Copilot {
        lsp_status: request::SignInStatus,
        cx: &mut ModelContext<Self>,
    ) {
-        self.buffers.retain(|_, buffer| buffer.is_upgradable(cx));
+        self.buffers.retain(|buffer| buffer.is_upgradable(cx));

        if let Ok(server) = self.server.as_running() {
            match lsp_status {
@@ -881,7 +853,7 @@ impl Copilot {
                | request::SignInStatus::MaybeOk { .. }
                | request::SignInStatus::AlreadySignedIn { .. } => {
                    server.sign_in_status = SignInStatus::Authorized;
-                    for buffer in self.buffers.values().cloned().collect::<Vec<_>>() {
+                    for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
                        if let Some(buffer) = buffer.upgrade(cx) {
                            self.register_buffer(&buffer, cx);
                        }
@@ -889,14 +861,14 @@ impl Copilot {
                }
                request::SignInStatus::NotAuthorized { .. } => {
                    server.sign_in_status = SignInStatus::Unauthorized;
-                    for buffer_id in self.buffers.keys().copied().collect::<Vec<_>>() {
-                        self.unregister_buffer(buffer_id);
+                    for buffer in self.buffers.iter().copied().collect::<Vec<_>>() {
+                        self.unregister_buffer(&buffer);
                    }
                }
                request::SignInStatus::NotSignedIn => {
                    server.sign_in_status = SignInStatus::SignedOut;
-                    for buffer_id in self.buffers.keys().copied().collect::<Vec<_>>() {
-                        self.unregister_buffer(buffer_id);
+                    for buffer in self.buffers.iter().copied().collect::<Vec<_>>() {
+                        self.unregister_buffer(&buffer);
                    }
                }
            }
@@ -1167,7 +1139,7 @@ mod tests {
        }

        fn mtime(&self) -> std::time::SystemTime {
-            todo!()
+            unimplemented!()
        }

        fn path(&self) -> &Arc<Path> {
@@ -1175,23 +1147,27 @@ mod tests {
        }

        fn full_path(&self, _: &AppContext) -> PathBuf {
-            todo!()
+            unimplemented!()
        }

        fn file_name<'a>(&'a self, _: &'a AppContext) -> &'a std::ffi::OsStr {
-            todo!()
+            unimplemented!()
        }

        fn is_deleted(&self) -> bool {
-            todo!()
+            unimplemented!()
        }

        fn as_any(&self) -> &dyn std::any::Any {
-            todo!()
+            unimplemented!()
        }

        fn to_proto(&self) -> rpc::proto::File {
-            todo!()
+            unimplemented!()
+        }
+
+        fn worktree_id(&self) -> usize {
+            0
        }
    }

@@ -1201,7 +1177,7 @@ mod tests {
        }

        fn load(&self, _: &AppContext) -> Task<Result<String>> {
-            todo!()
+            unimplemented!()
        }

        fn buffer_reloaded(
@@ -1213,7 +1189,7 @@ mod tests {
            _: std::time::SystemTime,
            _: &mut AppContext,
        ) {
-            todo!()
+            unimplemented!()
        }
    }
 }
--- a/crates/copilot/src/sign_in.rs
+++ b/crates/copilot/src/sign_in.rs
@@ -6,7 +6,6 @@ use gpui::{
    AnyElement, AnyViewHandle, AppContext, ClipboardItem, Element, Entity, View, ViewContext,
    ViewHandle,
 };
-use settings::Settings;
 use theme::ui::modal;

 #[derive(PartialEq, Eq, Debug, Clone)]
@@ -68,12 +67,13 @@ fn create_copilot_auth_window(
    cx: &mut AppContext,
    status: &Status,
 ) -> ViewHandle<CopilotCodeVerification> {
-    let window_size = cx.global::<Settings>().theme.copilot.modal.dimensions();
+    let window_size = theme::current(cx).copilot.modal.dimensions();
    let window_options = WindowOptions {
        bounds: WindowBounds::Fixed(RectF::new(Default::default(), window_size)),
        titlebar: None,
        center: true,
        focus: true,
+        show: true,
        kind: WindowKind::Normal,
        is_movable: true,
        screen: None,
@@ -338,7 +338,7 @@ impl View for CopilotCodeVerification {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
        enum ConnectModal {}

-        let style = cx.global::<Settings>().theme.clone();
+        let style = theme::current(cx).clone();

        modal::<ConnectModal, _, _, _, _>(
            "Connect Copilot to Zed",
--- a/crates/copilot_button/Cargo.toml
+++ b/crates/copilot_button/Cargo.toml
@@ -9,11 +9,12 @@ path = "src/copilot_button.rs"
 doctest = false

 [dependencies]
-assets = { path = "../assets" }
 copilot = { path = "../copilot" }
 editor = { path = "../editor" }
+fs = { path = "../fs" }
 context_menu = { path = "../context_menu" }
 gpui = { path = "../gpui" }
+language = { path = "../language" }
 settings = { path = "../settings" }
 theme = { path = "../theme" }
 util = { path = "../util" }
@@ -21,3 +22,6 @@ workspace = { path = "../workspace" }
 anyhow.workspace = true
 smol.workspace = true
 futures.workspace = true
+
+[dev-dependencies]
+editor = { path = "../editor", features = ["test-support"] }
--- a/crates/copilot_button/src/copilot_button.rs
+++ b/crates/copilot_button/src/copilot_button.rs
@@ -2,13 +2,18 @@ use anyhow::Result;
 use context_menu::{ContextMenu, ContextMenuItem};
 use copilot::{Copilot, SignOut, Status};
 use editor::{scroll::autoscroll::Autoscroll, Editor};
+use fs::Fs;
 use gpui::{
    elements::*,
    platform::{CursorStyle, MouseButton},
    AnyElement, AppContext, AsyncAppContext, Element, Entity, MouseState, Subscription, View,
    ViewContext, ViewHandle, WeakViewHandle, WindowContext,
 };
-use settings::{settings_file::SettingsFile, Settings};
+use language::{
+    language_settings::{self, all_language_settings, AllLanguageSettings},
+    File, Language,
+};
+use settings::{update_settings_file, SettingsStore};
 use std::{path::Path, sync::Arc};
 use util::{paths, ResultExt};
 use workspace::{
@@ -24,8 +29,9 @@ pub struct CopilotButton {
    popup_menu: ViewHandle<ContextMenu>,
    editor_subscription: Option<(Subscription, usize)>,
    editor_enabled: Option<bool>,
-    language: Option<Arc<str>>,
-    path: Option<Arc<Path>>,
+    language: Option<Arc<Language>>,
+    file: Option<Arc<dyn File>>,
+    fs: Arc<dyn Fs>,
 }

 impl Entity for CopilotButton {
@@ -38,13 +44,12 @@ impl View for CopilotButton {
    }

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let settings = cx.global::<Settings>();
-
-        if !settings.features.copilot {
+        let all_language_settings = all_language_settings(None, cx);
+        if !all_language_settings.copilot.feature_enabled {
            return Empty::new().into_any();
        }

-        let theme = settings.theme.clone();
+        let theme = theme::current(cx).clone();
        let active = self.popup_menu.read(cx).visible();
        let Some(copilot) = Copilot::global(cx) else {
            return Empty::new().into_any();
@@ -53,7 +58,7 @@ impl View for CopilotButton {

        let enabled = self
            .editor_enabled
-            .unwrap_or(settings.show_copilot_suggestions(None, None));
+            .unwrap_or_else(|| all_language_settings.copilot_enabled(None, None));

        Stack::new()
            .with_child(
@@ -64,8 +69,8 @@ impl View for CopilotButton {
                        let style = theme
                            .workspace
                            .status_bar
-                            .sidebar_buttons
-                            .item
+                            .panel_buttons
+                            .button
                            .style_for(state, active);

                        Flex::row()
@@ -143,9 +148,10 @@ impl View for CopilotButton {
 }

 impl CopilotButton {
-    pub fn new(cx: &mut ViewContext<Self>) -> Self {
+    pub fn new(fs: Arc<dyn Fs>, cx: &mut ViewContext<Self>) -> Self {
+        let button_view_id = cx.view_id();
        let menu = cx.add_view(|cx| {
-            let mut menu = ContextMenu::new(cx);
+            let mut menu = ContextMenu::new(button_view_id, cx);
            menu.set_position_mode(OverlayPositionMode::Local);
            menu
        });
@@ -154,7 +160,7 @@ impl CopilotButton {

        Copilot::global(cx).map(|copilot| cx.observe(&copilot, |_, _, cx| cx.notify()).detach());

-        cx.observe_global::<Settings, _>(move |_, cx| cx.notify())
+        cx.observe_global::<SettingsStore, _>(move |_, cx| cx.notify())
            .detach();

        Self {
@@ -162,18 +168,20 @@ impl CopilotButton {
            editor_subscription: None,
            editor_enabled: None,
            language: None,
-            path: None,
+            file: None,
+            fs,
        }
    }

    pub fn deploy_copilot_start_menu(&mut self, cx: &mut ViewContext<Self>) {
        let mut menu_options = Vec::with_capacity(2);
+        let fs = self.fs.clone();

        menu_options.push(ContextMenuItem::handler("Sign In", |cx| {
            initiate_sign_in(cx)
        }));
-        menu_options.push(ContextMenuItem::handler("Disable Copilot", |cx| {
-            hide_copilot(cx)
+        menu_options.push(ContextMenuItem::handler("Disable Copilot", move |cx| {
+            hide_copilot(fs.clone(), cx)
        }));

        self.popup_menu.update(cx, |menu, cx| {
@@ -187,25 +195,28 @@ impl CopilotButton {
    }

    pub fn deploy_copilot_menu(&mut self, cx: &mut ViewContext<Self>) {
-        let settings = cx.global::<Settings>();
-
+        let fs = self.fs.clone();
        let mut menu_options = Vec::with_capacity(8);

        if let Some(language) = self.language.clone() {
-            let language_enabled = settings.copilot_enabled_for_language(Some(language.as_ref()));
+            let fs = fs.clone();
+            let language_enabled = language_settings::language_settings(Some(&language), None, cx)
+                .show_copilot_suggestions;
            menu_options.push(ContextMenuItem::handler(
                format!(
                    "{} Suggestions for {}",
                    if language_enabled { "Hide" } else { "Show" },
-                    language
+                    language.name()
                ),
-                move |cx| toggle_copilot_for_language(language.clone(), cx),
+                move |cx| toggle_copilot_for_language(language.clone(), fs.clone(), cx),
            ));
        }

-        if let Some(path) = self.path.as_ref() {
-            let path_enabled = settings.copilot_enabled_for_path(path);
-            let path = path.clone();
+        let settings = settings::get::<AllLanguageSettings>(cx);
+
+        if let Some(file) = &self.file {
+            let path = file.path().clone();
+            let path_enabled = settings.copilot_enabled_for_path(&path);
            menu_options.push(ContextMenuItem::handler(
                format!(
                    "{} Suggestions for This Path",
@@ -227,19 +238,19 @@ impl CopilotButton {
            ));
        }

-        let globally_enabled = cx.global::<Settings>().features.copilot;
+        let globally_enabled = settings.copilot_enabled(None, None);
        menu_options.push(ContextMenuItem::handler(
            if globally_enabled {
                "Hide Suggestions for All Files"
            } else {
                "Show Suggestions for All Files"
            },
-            |cx| toggle_copilot_globally(cx),
+            move |cx| toggle_copilot_globally(fs.clone(), cx),
        ));

        menu_options.push(ContextMenuItem::Separator);

-        let icon_style = settings.theme.copilot.out_link_icon.clone();
+        let icon_style = theme::current(cx).copilot.out_link_icon.clone();
        menu_options.push(ContextMenuItem::action(
            move |state: &mut MouseState, style: &theme::ContextMenuItem| {
                Flex::row()
@@ -265,22 +276,17 @@ impl CopilotButton {

    pub fn update_enabled(&mut self, editor: ViewHandle<Editor>, cx: &mut ViewContext<Self>) {
        let editor = editor.read(cx);
-
        let snapshot = editor.buffer().read(cx).snapshot(cx);
-        let settings = cx.global::<Settings>();
        let suggestion_anchor = editor.selections.newest_anchor().start;
+        let language = snapshot.language_at(suggestion_anchor);
+        let file = snapshot.file_at(suggestion_anchor).cloned();

-        let language_name = snapshot
-            .language_at(suggestion_anchor)
-            .map(|language| language.name());
-        let path = snapshot
-            .file_at(suggestion_anchor)
-            .map(|file| file.path().clone());
-
-        self.editor_enabled =
-            Some(settings.show_copilot_suggestions(language_name.as_deref(), path.as_deref()));
-        self.language = language_name;
-        self.path = path;
+        self.editor_enabled = Some(
+            all_language_settings(self.file.as_ref(), cx)
+                .copilot_enabled(language, file.as_ref().map(|file| file.path().as_ref())),
+        );
+        self.language = language.cloned();
+        self.file = file;

        cx.notify()
    }
@@ -309,9 +315,7 @@ async fn configure_disabled_globs(
    let settings_editor = workspace
        .update(&mut cx, |_, cx| {
            create_and_open_local_file(&paths::SETTINGS, cx, || {
-                Settings::initial_user_settings_content(&assets::Assets)
-                    .as_ref()
-                    .into()
+                settings::initial_user_settings_content().as_ref().into()
            })
        })?
        .await?
@@ -321,16 +325,17 @@ async fn configure_disabled_globs(
    settings_editor.downgrade().update(&mut cx, |item, cx| {
        let text = item.buffer().read(cx).snapshot(cx).text();

-        let edits = SettingsFile::update_unsaved(&text, cx, |file| {
+        let settings = cx.global::<SettingsStore>();
+        let edits = settings.edits_for_update::<AllLanguageSettings>(&text, |file| {
            let copilot = file.copilot.get_or_insert_with(Default::default);
            let globs = copilot.disabled_globs.get_or_insert_with(|| {
-                cx.global::<Settings>()
+                settings
+                    .get::<AllLanguageSettings>(None)
                    .copilot
                    .disabled_globs
-                    .clone()
                    .iter()
-                    .map(|glob| glob.as_str().to_string())
-                    .collect::<Vec<_>>()
+                    .map(|glob| glob.glob().to_string())
+                    .collect()
            });

            if let Some(path_to_disable) = &path_to_disable {
@@ -355,32 +360,27 @@ async fn configure_disabled_globs(
    anyhow::Ok(())
 }

-fn toggle_copilot_globally(cx: &mut AppContext) {
-    let show_copilot_suggestions = cx.global::<Settings>().show_copilot_suggestions(None, None);
-    SettingsFile::update(cx, move |file_contents| {
-        file_contents.editor.show_copilot_suggestions = Some((!show_copilot_suggestions).into())
+fn toggle_copilot_globally(fs: Arc<dyn Fs>, cx: &mut AppContext) {
+    let show_copilot_suggestions = all_language_settings(None, cx).copilot_enabled(None, None);
+    update_settings_file::<AllLanguageSettings>(fs, cx, move |file| {
+        file.defaults.show_copilot_suggestions = Some((!show_copilot_suggestions).into())
    });
 }

-fn toggle_copilot_for_language(language: Arc<str>, cx: &mut AppContext) {
-    let show_copilot_suggestions = cx
-        .global::<Settings>()
-        .show_copilot_suggestions(Some(&language), None);
-
-    SettingsFile::update(cx, move |file_contents| {
-        file_contents.languages.insert(
-            language,
-            settings::EditorSettings {
-                show_copilot_suggestions: Some((!show_copilot_suggestions).into()),
-                ..Default::default()
-            },
-        );
+fn toggle_copilot_for_language(language: Arc<Language>, fs: Arc<dyn Fs>, cx: &mut AppContext) {
+    let show_copilot_suggestions =
+        all_language_settings(None, cx).copilot_enabled(Some(&language), None);
+    update_settings_file::<AllLanguageSettings>(fs, cx, move |file| {
+        file.languages
+            .entry(language.name())
+            .or_default()
+            .show_copilot_suggestions = Some(!show_copilot_suggestions);
    });
 }

-fn hide_copilot(cx: &mut AppContext) {
-    SettingsFile::update(cx, move |file_contents| {
-        file_contents.features.copilot = Some(false)
+fn hide_copilot(fs: Arc<dyn Fs>, cx: &mut AppContext) {
+    update_settings_file::<AllLanguageSettings>(fs, cx, move |file| {
+        file.features.get_or_insert(Default::default()).copilot = Some(false);
    });
 }

--- a/crates/db/Cargo.toml
+++ b/crates/db/Cargo.toml
@@ -18,7 +18,7 @@ sqlez = { path = "../sqlez" }
 sqlez_macros = { path = "../sqlez_macros" }
 util = { path = "../util" }
 anyhow.workspace = true
-indoc = "1.0.4"
+indoc.workspace = true
 async-trait.workspace = true
 lazy_static.workspace = true
 log.workspace = true
--- a/crates/diagnostics/Cargo.toml
+++ b/crates/diagnostics/Cargo.toml
@@ -31,6 +31,7 @@ language = { path = "../language", features = ["test-support"] }
 lsp = { path = "../lsp", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 workspace = { path = "../workspace", features = ["test-support"] }
+theme = { path = "../theme", features = ["test-support"] }

 serde_json.workspace = true
 unindent.workspace = true
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -20,7 +20,6 @@ use language::{
 use lsp::LanguageServerId;
 use project::{DiagnosticSummary, Project, ProjectPath};
 use serde_json::json;
-use settings::Settings;
 use smallvec::SmallVec;
 use std::{
    any::{Any, TypeId},
@@ -30,10 +29,11 @@ use std::{
    path::PathBuf,
    sync::Arc,
 };
+use theme::ThemeSettings;
 use util::TryFutureExt;
 use workspace::{
    item::{BreadcrumbText, Item, ItemEvent, ItemHandle},
-    ItemNavHistory, Pane, ToolbarItemLocation, Workspace,
+    ItemNavHistory, Pane, PaneBackdrop, ToolbarItemLocation, Workspace,
 };

 actions!(diagnostics, [Deploy]);
@@ -89,12 +89,16 @@ impl View for ProjectDiagnosticsEditor {

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
        if self.path_states.is_empty() {
-            let theme = &cx.global::<Settings>().theme.project_diagnostics;
-            Label::new("No problems in workspace", theme.empty_message.clone())
-                .aligned()
-                .contained()
-                .with_style(theme.container)
-                .into_any()
+            let theme = &theme::current(cx).project_diagnostics;
+            PaneBackdrop::new(
+                cx.view_id(),
+                Label::new("No problems in workspace", theme.empty_message.clone())
+                    .aligned()
+                    .contained()
+                    .with_style(theme.container)
+                    .into_any(),
+            )
+            .into_any()
        } else {
            ChildView::new(&self.editor, cx).into_any()
        }
@@ -161,8 +165,13 @@ impl ProjectDiagnosticsEditor {
            editor.set_vertical_scroll_margin(5, cx);
            editor
        });
-        cx.subscribe(&editor, |_, _, event, cx| cx.emit(event.clone()))
-            .detach();
+        cx.subscribe(&editor, |this, _, event, cx| {
+            cx.emit(event.clone());
+            if event == &editor::Event::Focused && this.path_states.is_empty() {
+                cx.focus_self()
+            }
+        })
+        .detach();

        let project = project_handle.read(cx);
        let paths_to_update = project
@@ -537,7 +546,7 @@ impl Item for ProjectDiagnosticsEditor {
        render_summary(
            &self.summary,
            &style.label.text,
-            &cx.global::<Settings>().theme.project_diagnostics,
+            &theme::current(cx).project_diagnostics,
        )
    }

@@ -600,15 +609,6 @@ impl Item for ProjectDiagnosticsEditor {
        unreachable!()
    }

-    fn git_diff_recalc(
-        &mut self,
-        project: ModelHandle<Project>,
-        cx: &mut ViewContext<Self>,
-    ) -> Task<Result<()>> {
-        self.editor
-            .update(cx, |editor, cx| editor.git_diff_recalc(project, cx))
-    }
-
    fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
        Editor::to_item_events(event)
    }
@@ -679,10 +679,10 @@ impl Item for ProjectDiagnosticsEditor {
 fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
    let (message, highlights) = highlight_diagnostic_message(Vec::new(), &diagnostic.message);
    Arc::new(move |cx| {
-        let settings = cx.global::<Settings>();
+        let settings = settings::get::<ThemeSettings>(cx);
        let theme = &settings.theme.editor;
        let style = theme.diagnostic_header.clone();
-        let font_size = (style.text_scale_factor * settings.buffer_font_size).round();
+        let font_size = (style.text_scale_factor * settings.buffer_font_size(cx)).round();
        let icon_width = cx.em_width * style.icon_width_factor;
        let icon = if diagnostic.severity == DiagnosticSeverity::ERROR {
            Svg::new("icons/circle_x_mark_12.svg")
@@ -818,33 +818,35 @@ mod tests {
    use language::{Diagnostic, DiagnosticEntry, DiagnosticSeverity, PointUtf16, Unclipped};
    use project::FakeFs;
    use serde_json::json;
+    use settings::SettingsStore;
    use unindent::Unindent as _;

    #[gpui::test]
    async fn test_diagnostics(cx: &mut TestAppContext) {
-        Settings::test_async(cx);
+        init_test(cx);
+
        let fs = FakeFs::new(cx.background());
        fs.insert_tree(
            "/test",
            json!({
                "consts.rs": "
-                        const a: i32 = 'a';
-                        const b: i32 = c;
-                    "
+                    const a: i32 = 'a';
+                    const b: i32 = c;
+                "
                .unindent(),

                "main.rs": "
-                        fn main() {
-                            let x = vec![];
-                            let y = vec![];
-                            a(x);
-                            b(y);
-                            // comment 1
-                            // comment 2
-                            c(y);
-                            d(x);
-                        }
-                    "
+                    fn main() {
+                        let x = vec![];
+                        let y = vec![];
+                        a(x);
+                        b(y);
+                        // comment 1
+                        // comment 2
+                        c(y);
+                        d(x);
+                    }
+                "
                .unindent(),
            }),
        )
@@ -852,7 +854,7 @@ mod tests {

        let language_server_id = LanguageServerId(0);
        let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
+        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));

        // Create some diagnostics
        project.update(cx, |project, cx| {
@@ -939,7 +941,7 @@ mod tests {
        });

        // Open the project diagnostics view while there are already diagnostics.
-        let view = cx.add_view(&workspace, |cx| {
+        let view = cx.add_view(window_id, |cx| {
            ProjectDiagnosticsEditor::new(project.clone(), workspace.downgrade(), cx)
        });

@@ -1225,7 +1227,8 @@ mod tests {

    #[gpui::test]
    async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
-        Settings::test_async(cx);
+        init_test(cx);
+
        let fs = FakeFs::new(cx.background());
        fs.insert_tree(
            "/test",
@@ -1244,9 +1247,9 @@ mod tests {
        let server_id_1 = LanguageServerId(100);
        let server_id_2 = LanguageServerId(101);
        let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
+        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));

-        let view = cx.add_view(&workspace, |cx| {
+        let view = cx.add_view(window_id, |cx| {
            ProjectDiagnosticsEditor::new(project.clone(), workspace.downgrade(), cx)
        });

@@ -1489,6 +1492,17 @@ mod tests {
        });
    }

+    fn init_test(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            cx.set_global(SettingsStore::test(cx));
+            theme::init((), cx);
+            language::init(cx);
+            client::init_settings(cx);
+            workspace::init_settings(cx);
+            Project::init_settings(cx);
+        });
+    }
+
    fn editor_blocks(editor: &ViewHandle<Editor>, cx: &mut WindowContext) -> Vec<(u32, String)> {
        editor.update(cx, |editor, cx| {
            let snapshot = editor.snapshot(cx);
--- a/crates/diagnostics/src/items.rs
+++ b/crates/diagnostics/src/items.rs
@@ -7,7 +7,6 @@ use gpui::{
 };
 use language::Diagnostic;
 use lsp::LanguageServerId;
-use settings::Settings;
 use workspace::{item::ItemHandle, StatusItemView, Workspace};

 use crate::ProjectDiagnosticsEditor;
@@ -92,13 +91,12 @@ impl View for DiagnosticIndicator {
        enum Summary {}
        enum Message {}

-        let tooltip_style = cx.global::<Settings>().theme.tooltip.clone();
+        let tooltip_style = theme::current(cx).tooltip.clone();
        let in_progress = !self.in_progress_checks.is_empty();
        let mut element = Flex::row().with_child(
            MouseEventHandler::<Summary, _>::new(0, cx, |state, cx| {
-                let style = cx
-                    .global::<Settings>()
-                    .theme
+                let theme = theme::current(cx);
+                let style = theme
                    .workspace
                    .status_bar
                    .diagnostic_summary
@@ -184,7 +182,7 @@ impl View for DiagnosticIndicator {
            .into_any(),
        );

-        let style = &cx.global::<Settings>().theme.workspace.status_bar;
+        let style = &theme::current(cx).workspace.status_bar;
        let item_spacing = style.item_spacing;

        if in_progress {
--- a/crates/drag_and_drop/src/drag_and_drop.rs
+++ b/crates/drag_and_drop/src/drag_and_drop.rs
@@ -199,7 +199,7 @@ impl<V: View> DragAndDrop<V> {
                            return None;
                        }

-                        let position = position - region_offset;
+                        let position = (position - region_offset).round();
                        Some(
                            Overlay::new(
                                MouseEventHandler::<DraggedElementHandler, V>::new(
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -58,6 +58,7 @@ parking_lot.workspace = true
 postage.workspace = true
 pulldown-cmark = { version = "0.9.2", default-features = false }
 rand = { workspace = true, optional = true }
+schemars.workspace = true
 serde.workspace = true
 serde_derive.workspace = true
 smallvec.workspace = true
@@ -80,7 +81,6 @@ workspace = { path = "../workspace", features = ["test-support"] }

 ctor.workspace = true
 env_logger.workspace = true
-glob.workspace = true
 rand.workspace = true
 unindent.workspace = true
 tree-sitter = "0.20"
--- a/crates/editor/src/blink_manager.rs
+++ b/crates/editor/src/blink_manager.rs
@@ -1,8 +1,8 @@
-use std::time::Duration;
-
+use crate::EditorSettings;
 use gpui::{Entity, ModelContext};
-use settings::Settings;
+use settings::SettingsStore;
 use smol::Timer;
+use std::time::Duration;

 pub struct BlinkManager {
    blink_interval: Duration,
@@ -15,8 +15,8 @@ pub struct BlinkManager {

 impl BlinkManager {
    pub fn new(blink_interval: Duration, cx: &mut ModelContext<Self>) -> Self {
-        cx.observe_global::<Settings, _>(move |this, cx| {
-            // Make sure we blink the cursors if the setting is re-enabled
+        // Make sure we blink the cursors if the setting is re-enabled
+        cx.observe_global::<SettingsStore, _>(move |this, cx| {
            this.blink_cursors(this.blink_epoch, cx)
        })
        .detach();
@@ -64,7 +64,7 @@ impl BlinkManager {
    }

    fn blink_cursors(&mut self, epoch: usize, cx: &mut ModelContext<Self>) {
-        if cx.global::<Settings>().cursor_blink {
+        if settings::get::<EditorSettings>(cx).cursor_blink {
            if epoch == self.blink_epoch && self.enabled && !self.blinking_paused {
                self.visible = !self.visible;
                cx.notify();
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -13,8 +13,9 @@ use gpui::{
    fonts::{FontId, HighlightStyle},
    Entity, ModelContext, ModelHandle,
 };
-use language::{OffsetUtf16, Point, Subscription as BufferSubscription};
-use settings::Settings;
+use language::{
+    language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription,
+};
 use std::{any::TypeId, fmt::Debug, num::NonZeroU32, ops::Range, sync::Arc};
 pub use suggestion_map::Suggestion;
 use suggestion_map::SuggestionMap;
@@ -271,13 +272,11 @@ impl DisplayMap {
    }

    fn tab_size(buffer: &ModelHandle<MultiBuffer>, cx: &mut ModelContext<Self>) -> NonZeroU32 {
-        let language_name = buffer
+        let language = buffer
            .read(cx)
            .as_singleton()
-            .and_then(|buffer| buffer.read(cx).language())
-            .map(|language| language.name());
-
-        cx.global::<Settings>().tab_size(language_name.as_deref())
+            .and_then(|buffer| buffer.read(cx).language());
+        language_settings(language.as_deref(), None, cx).tab_size
    }

    #[cfg(test)]
@@ -476,7 +475,7 @@ impl DisplaySnapshot {
            })
    }

-    /// Returns an iterator of the start positions of the occurances of `target` in the `self` after `from`
+    /// Returns an iterator of the start positions of the occurrences of `target` in the `self` after `from`
    /// Stops if `condition` returns false for any of the character position pairs observed.
    pub fn find_while<'a>(
        &'a self,
@@ -487,7 +486,7 @@ impl DisplaySnapshot {
        Self::find_internal(self.chars_at(from), target.chars().collect(), condition)
    }

-    /// Returns an iterator of the end positions of the occurances of `target` in the `self` before `from`
+    /// Returns an iterator of the end positions of the occurrences of `target` in the `self` before `from`
    /// Stops if `condition` returns false for any of the character position pairs observed.
    pub fn reverse_find_while<'a>(
        &'a self,
@@ -844,8 +843,12 @@ pub mod tests {
    use super::*;
    use crate::{movement, test::marked_display_snapshot};
    use gpui::{color::Color, elements::*, test::observe, AppContext};
-    use language::{Buffer, Language, LanguageConfig, SelectionGoal};
+    use language::{
+        language_settings::{AllLanguageSettings, AllLanguageSettingsContent},
+        Buffer, Language, LanguageConfig, SelectionGoal,
+    };
    use rand::{prelude::*, Rng};
+    use settings::SettingsStore;
    use smol::stream::StreamExt;
    use std::{env, sync::Arc};
    use theme::SyntaxTheme;
@@ -882,9 +885,7 @@ pub mod tests {
        log::info!("wrap width: {:?}", wrap_width);

        cx.update(|cx| {
-            let mut settings = Settings::test(cx);
-            settings.editor_overrides.tab_size = NonZeroU32::new(tab_size);
-            cx.set_global(settings)
+            init_test(cx, |s| s.defaults.tab_size = NonZeroU32::new(tab_size));
        });

        let buffer = cx.update(|cx| {
@@ -939,9 +940,11 @@ pub mod tests {
                    tab_size = *tab_sizes.choose(&mut rng).unwrap();
                    log::info!("setting tab size to {:?}", tab_size);
                    cx.update(|cx| {
-                        let mut settings = Settings::test(cx);
-                        settings.editor_overrides.tab_size = NonZeroU32::new(tab_size);
-                        cx.set_global(settings)
+                        cx.update_global::<SettingsStore, _, _>(|store, cx| {
+                            store.update_user_settings::<AllLanguageSettings>(cx, |s| {
+                                s.defaults.tab_size = NonZeroU32::new(tab_size);
+                            });
+                        });
                    });
                }
                30..=44 => {
@@ -1119,7 +1122,7 @@ pub mod tests {
    #[gpui::test(retries = 5)]
    fn test_soft_wraps(cx: &mut AppContext) {
        cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
-        cx.foreground().forbid_parking();
+        init_test(cx, |_| {});

        let font_cache = cx.font_cache();

@@ -1131,7 +1134,6 @@ pub mod tests {
            .unwrap();
        let font_size = 12.0;
        let wrap_width = Some(64.);
-        cx.set_global(Settings::test(cx));

        let text = "one two three four five\nsix seven eight";
        let buffer = MultiBuffer::build_simple(text, cx);
@@ -1211,7 +1213,8 @@ pub mod tests {

    #[gpui::test]
    fn test_text_chunks(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx, |_| {});
+
        let text = sample_text(6, 6, 'a');
        let buffer = MultiBuffer::build_simple(&text, cx);
        let family_id = cx
@@ -1225,6 +1228,7 @@ pub mod tests {
        let font_size = 14.0;
        let map =
            cx.add_model(|cx| DisplayMap::new(buffer.clone(), font_id, font_size, None, 1, 1, cx));
+
        buffer.update(cx, |buffer, cx| {
            buffer.edit(
                vec![
@@ -1289,11 +1293,8 @@ pub mod tests {
            .unwrap(),
        );
        language.set_theme(&theme);
-        cx.update(|cx| {
-            let mut settings = Settings::test(cx);
-            settings.editor_defaults.tab_size = Some(2.try_into().unwrap());
-            cx.set_global(settings);
-        });
+
+        cx.update(|cx| init_test(cx, |s| s.defaults.tab_size = Some(2.try_into().unwrap())));

        let buffer = cx.add_model(|cx| Buffer::new(0, text, cx).with_language(language, cx));
        buffer.condition(cx, |buf, _| !buf.is_parsing()).await;
@@ -1382,7 +1383,7 @@ pub mod tests {
        );
        language.set_theme(&theme);

-        cx.update(|cx| cx.set_global(Settings::test(cx)));
+        cx.update(|cx| init_test(cx, |_| {}));

        let buffer = cx.add_model(|cx| Buffer::new(0, text, cx).with_language(language, cx));
        buffer.condition(cx, |buf, _| !buf.is_parsing()).await;
@@ -1429,9 +1430,8 @@ pub mod tests {

    #[gpui::test]
    async fn test_chunks_with_text_highlights(cx: &mut gpui::TestAppContext) {
-        cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
+        cx.update(|cx| init_test(cx, |_| {}));

-        cx.update(|cx| cx.set_global(Settings::test(cx)));
        let theme = SyntaxTheme::new(vec![
            ("operator".to_string(), Color::red().into()),
            ("string".to_string(), Color::green().into()),
@@ -1510,7 +1510,8 @@ pub mod tests {

    #[gpui::test]
    fn test_clip_point(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx, |_| {});
+
        fn assert(text: &str, shift_right: bool, bias: Bias, cx: &mut gpui::AppContext) {
            let (unmarked_snapshot, mut markers) = marked_display_snapshot(text, cx);

@@ -1559,7 +1560,7 @@ pub mod tests {

    #[gpui::test]
    fn test_clip_at_line_ends(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx, |_| {});

        fn assert(text: &str, cx: &mut gpui::AppContext) {
            let (mut unmarked_snapshot, markers) = marked_display_snapshot(text, cx);
@@ -1578,7 +1579,8 @@ pub mod tests {

    #[gpui::test]
    fn test_tabs_with_multibyte_chars(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx, |_| {});
+
        let text = "✅\t\tα\nβ\t\n🏀β\t\tγ";
        let buffer = MultiBuffer::build_simple(text, cx);
        let font_cache = cx.font_cache();
@@ -1639,7 +1641,8 @@ pub mod tests {

    #[gpui::test]
    fn test_max_point(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx, |_| {});
+
        let buffer = MultiBuffer::build_simple("aaa\n\t\tbbb", cx);
        let font_cache = cx.font_cache();
        let family_id = font_cache
@@ -1718,4 +1721,13 @@ pub mod tests {
        }
        chunks
    }
+
+    fn init_test(cx: &mut AppContext, f: impl Fn(&mut AllLanguageSettingsContent)) {
+        cx.foreground().forbid_parking();
+        cx.set_global(SettingsStore::test(cx));
+        language::init(cx);
+        cx.update_global::<SettingsStore, _, _>(|store, cx| {
+            store.update_user_settings::<AllLanguageSettings>(cx, f);
+        });
+    }
 }
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -833,10 +833,7 @@ impl<'a> Iterator for BlockChunks<'a> {

            return Some(Chunk {
                text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..line_count as usize]) },
-                syntax_highlight_id: None,
-                highlight_style: None,
-                diagnostic_severity: None,
-                is_unnecessary: false,
+                ..Default::default()
            });
        }

@@ -996,7 +993,7 @@ mod tests {
    use crate::multi_buffer::MultiBuffer;
    use gpui::{elements::Empty, Element};
    use rand::prelude::*;
-    use settings::Settings;
+    use settings::SettingsStore;
    use std::env;
    use util::RandomCharIter;

@@ -1016,7 +1013,7 @@ mod tests {

    #[gpui::test]
    fn test_basic_blocks(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);

        let family_id = cx
            .font_cache()
@@ -1192,7 +1189,7 @@ mod tests {

    #[gpui::test]
    fn test_blocks_on_wrapped_lines(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);

        let family_id = cx
            .font_cache()
@@ -1242,7 +1239,7 @@ mod tests {

    #[gpui::test(iterations = 100)]
    fn test_random_blocks(cx: &mut gpui::AppContext, mut rng: StdRng) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);

        let operations = env::var("OPERATIONS")
            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
@@ -1650,6 +1647,11 @@ mod tests {
        }
    }

+    fn init_test(cx: &mut gpui::AppContext) {
+        cx.set_global(SettingsStore::test(cx));
+        theme::init((), cx);
+    }
+
    impl TransformBlock {
        fn as_custom(&self) -> Option<&Block> {
            match self {
--- a/crates/editor/src/display_map/fold_map.rs
+++ b/crates/editor/src/display_map/fold_map.rs
@@ -1065,13 +1065,11 @@ impl<'a> Iterator for FoldChunks<'a> {
            self.output_offset += output_text.len();
            return Some(Chunk {
                text: output_text,
-                syntax_highlight_id: None,
                highlight_style: self.ellipses_color.map(|color| HighlightStyle {
                    color: Some(color),
                    ..Default::default()
                }),
-                diagnostic_severity: None,
-                is_unnecessary: false,
+                ..Default::default()
            });
        }

@@ -1206,7 +1204,7 @@ mod tests {
    use crate::{MultiBuffer, ToPoint};
    use collections::HashSet;
    use rand::prelude::*;
-    use settings::Settings;
+    use settings::SettingsStore;
    use std::{cmp::Reverse, env, mem, sync::Arc};
    use sum_tree::TreeMap;
    use util::test::sample_text;
@@ -1215,7 +1213,7 @@ mod tests {

    #[gpui::test]
    fn test_basic_folds(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
        let buffer = MultiBuffer::build_simple(&sample_text(5, 6, 'a'), cx);
        let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
        let buffer_snapshot = buffer.read(cx).snapshot(cx);
@@ -1288,7 +1286,7 @@ mod tests {

    #[gpui::test]
    fn test_adjacent_folds(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
        let buffer = MultiBuffer::build_simple("abcdefghijkl", cx);
        let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
        let buffer_snapshot = buffer.read(cx).snapshot(cx);
@@ -1351,7 +1349,7 @@ mod tests {

    #[gpui::test]
    fn test_merging_folds_via_edit(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
        let buffer = MultiBuffer::build_simple(&sample_text(5, 6, 'a'), cx);
        let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
        let buffer_snapshot = buffer.read(cx).snapshot(cx);
@@ -1402,7 +1400,7 @@ mod tests {

    #[gpui::test(iterations = 100)]
    fn test_random_folds(cx: &mut gpui::AppContext, mut rng: StdRng) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
        let operations = env::var("OPERATIONS")
            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
            .unwrap_or(10);
@@ -1678,6 +1676,10 @@ mod tests {
        assert_eq!(snapshot.buffer_rows(3).collect::<Vec<_>>(), [Some(6)]);
    }

+    fn init_test(cx: &mut gpui::AppContext) {
+        cx.set_global(SettingsStore::test(cx));
+    }
+
    impl FoldMap {
        fn merged_fold_ranges(&self) -> Vec<Range<usize>> {
            let buffer = self.buffer.lock().clone();
--- a/crates/editor/src/display_map/suggestion_map.rs
+++ b/crates/editor/src/display_map/suggestion_map.rs
@@ -531,10 +531,8 @@ impl<'a> Iterator for SuggestionChunks<'a> {
            if let Some(chunk) = chunks.next() {
                return Some(Chunk {
                    text: chunk,
-                    syntax_highlight_id: None,
                    highlight_style: self.highlight_style,
-                    diagnostic_severity: None,
-                    is_unnecessary: false,
+                    ..Default::default()
                });
            } else {
                self.suggestion_chunks = None;
@@ -580,7 +578,7 @@ mod tests {
    use crate::{display_map::fold_map::FoldMap, MultiBuffer};
    use gpui::AppContext;
    use rand::{prelude::StdRng, Rng};
-    use settings::Settings;
+    use settings::SettingsStore;
    use std::{
        env,
        ops::{Bound, RangeBounds},
@@ -633,7 +631,8 @@ mod tests {

    #[gpui::test(iterations = 100)]
    fn test_random_suggestions(cx: &mut AppContext, mut rng: StdRng) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        let operations = env::var("OPERATIONS")
            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
            .unwrap_or(10);
@@ -836,6 +835,11 @@ mod tests {
        }
    }

+    fn init_test(cx: &mut AppContext) {
+        cx.set_global(SettingsStore::test(cx));
+        theme::init((), cx);
+    }
+
    impl SuggestionMap {
        pub fn randomly_mutate(
            &self,
--- a/crates/editor/src/display_map/tab_map.rs
+++ b/crates/editor/src/display_map/tab_map.rs
@@ -268,6 +268,7 @@ impl TabSnapshot {
            tab_size: self.tab_size,
            chunk: Chunk {
                text: &SPACES[0..(to_next_stop as usize)],
+                is_tab: true,
                ..Default::default()
            },
            inside_leading_tab: to_next_stop > 0,
@@ -545,6 +546,7 @@ impl<'a> Iterator for TabChunks<'a> {
                        self.output_position = next_output_position;
                        return Some(Chunk {
                            text: &SPACES[..len as usize],
+                            is_tab: true,
                            ..self.chunk
                        });
                    }
@@ -654,6 +656,56 @@ mod tests {
        assert_eq!(tab_snapshot.text(), input);
    }

+    #[gpui::test]
+    fn test_marking_tabs(cx: &mut gpui::AppContext) {
+        let input = "\t \thello";
+
+        let buffer = MultiBuffer::build_simple(&input, cx);
+        let buffer_snapshot = buffer.read(cx).snapshot(cx);
+        let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
+        let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
+        let (_, tab_snapshot) = TabMap::new(suggestion_snapshot, 4.try_into().unwrap());
+
+        assert_eq!(
+            chunks(&tab_snapshot, TabPoint::zero()),
+            vec![
+                ("    ".to_string(), true),
+                (" ".to_string(), false),
+                ("   ".to_string(), true),
+                ("hello".to_string(), false),
+            ]
+        );
+        assert_eq!(
+            chunks(&tab_snapshot, TabPoint::new(0, 2)),
+            vec![
+                ("  ".to_string(), true),
+                (" ".to_string(), false),
+                ("   ".to_string(), true),
+                ("hello".to_string(), false),
+            ]
+        );
+
+        fn chunks(snapshot: &TabSnapshot, start: TabPoint) -> Vec<(String, bool)> {
+            let mut chunks = Vec::new();
+            let mut was_tab = false;
+            let mut text = String::new();
+            for chunk in snapshot.chunks(start..snapshot.max_point(), false, None, None) {
+                if chunk.is_tab != was_tab {
+                    if !text.is_empty() {
+                        chunks.push((mem::take(&mut text), was_tab));
+                    }
+                    was_tab = chunk.is_tab;
+                }
+                text.push_str(chunk.text);
+            }
+
+            if !text.is_empty() {
+                chunks.push((text, was_tab));
+            }
+            chunks
+        }
+    }
+
    #[gpui::test(iterations = 100)]
    fn test_random_tabs(cx: &mut gpui::AppContext, mut rng: StdRng) {
        let tab_size = NonZeroU32::new(rng.gen_range(1..=4)).unwrap();
--- a/crates/editor/src/display_map/wrap_map.rs
+++ b/crates/editor/src/display_map/wrap_map.rs
@@ -1043,16 +1043,16 @@ mod tests {
    };
    use gpui::test::observe;
    use rand::prelude::*;
-    use settings::Settings;
+    use settings::SettingsStore;
    use smol::stream::StreamExt;
    use std::{cmp, env, num::NonZeroU32};
    use text::Rope;

    #[gpui::test(iterations = 100)]
    async fn test_random_wraps(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
-        cx.update(|cx| cx.set_global(Settings::test(cx)));
+        init_test(cx);
+
        cx.foreground().set_block_on_ticks(0..=50);
-        cx.foreground().forbid_parking();
        let operations = env::var("OPERATIONS")
            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
            .unwrap_or(10);
@@ -1287,6 +1287,14 @@ mod tests {
        wrap_map.read_with(cx, |map, _| assert!(map.pending_edits.is_empty()));
    }

+    fn init_test(cx: &mut gpui::TestAppContext) {
+        cx.foreground().forbid_parking();
+        cx.update(|cx| {
+            cx.set_global(SettingsStore::test(cx));
+            theme::init((), cx);
+        });
+    }
+
    fn wrap_text(
        unwrapped_text: &str,
        wrap_width: Option<f32>,
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -0,0 +1,56 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::Setting;
+
+#[derive(Deserialize)]
+pub struct EditorSettings {
+    pub cursor_blink: bool,
+    pub hover_popover_enabled: bool,
+    pub show_completions_on_input: bool,
+    pub use_on_type_format: bool,
+    pub scrollbar: Scrollbar,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+pub struct Scrollbar {
+    pub show: ShowScrollbar,
+    pub git_diff: bool,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ShowScrollbar {
+    Auto,
+    System,
+    Always,
+    Never,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct EditorSettingsContent {
+    pub cursor_blink: Option<bool>,
+    pub hover_popover_enabled: Option<bool>,
+    pub show_completions_on_input: Option<bool>,
+    pub use_on_type_format: Option<bool>,
+    pub scrollbar: Option<ScrollbarContent>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+pub struct ScrollbarContent {
+    pub show: Option<ShowScrollbar>,
+    pub git_diff: Option<bool>,
+}
+
+impl Setting for EditorSettings {
+    const KEY: Option<&'static str> = None;
+
+    type FileContent = EditorSettingsContent;
+
+    fn load(
+        default_value: &Self::FileContent,
+        user_values: &[&Self::FileContent],
+        _: &gpui::AppContext,
+    ) -> anyhow::Result<Self> {
+        Self::load_via_json_merge(default_value, user_values)
+    }
+}
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -1,4 +1,4 @@
-use std::ops::RangeInclusive;
+use std::ops::Range;

 use git::diff::{DiffHunk, DiffHunkStatus};
 use language::Point;
@@ -15,7 +15,7 @@ pub enum DisplayDiffHunk {
    },

    Unfolded {
-        display_row_range: RangeInclusive<u32>,
+        display_row_range: Range<u32>,
        status: DiffHunkStatus,
    },
 }
@@ -26,7 +26,7 @@ impl DisplayDiffHunk {
            &DisplayDiffHunk::Folded { display_row } => display_row,
            DisplayDiffHunk::Unfolded {
                display_row_range, ..
-            } => *display_row_range.start(),
+            } => display_row_range.start,
        }
    }

@@ -36,7 +36,7 @@ impl DisplayDiffHunk {

            DisplayDiffHunk::Unfolded {
                display_row_range, ..
-            } => display_row_range.clone(),
+            } => display_row_range.start..=display_row_range.end - 1,
        };

        range.contains(&display_row)
@@ -77,16 +77,12 @@ pub fn diff_hunk_to_display(hunk: DiffHunk<u32>, snapshot: &DisplaySnapshot) ->
    } else {
        let start = hunk_start_point.to_display_point(snapshot).row();

-        let hunk_end_row_inclusive = hunk
-            .buffer_range
-            .end
-            .saturating_sub(1)
-            .max(hunk.buffer_range.start);
+        let hunk_end_row_inclusive = hunk.buffer_range.end.max(hunk.buffer_range.start);
        let hunk_end_point = Point::new(hunk_end_row_inclusive, 0);
        let end = hunk_end_point.to_display_point(snapshot).row();

        DisplayDiffHunk::Unfolded {
-            display_row_range: start..=end,
+            display_row_range: start..end,
            status: hunk.status(),
        }
    }
--- a/crates/editor/src/highlight_matching_bracket.rs
+++ b/crates/editor/src/highlight_matching_bracket.rs
@@ -33,12 +33,14 @@ pub fn refresh_matching_bracket_highlights(editor: &mut Editor, cx: &mut ViewCon
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::test::editor_lsp_test_context::EditorLspTestContext;
+    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
    use indoc::indoc;
    use language::{BracketPair, BracketPairConfig, Language, LanguageConfig};

    #[gpui::test]
    async fn test_matching_bracket_highlights(cx: &mut gpui::TestAppContext) {
+        init_test(cx, |_| {});
+
        let mut cx = EditorLspTestContext::new(
            Language::new(
                LanguageConfig {
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -1,6 +1,6 @@
 use crate::{
-    display_map::ToDisplayPoint, Anchor, AnchorRangeExt, DisplayPoint, Editor, EditorSnapshot,
-    EditorStyle, RangeToAnchorExt,
+    display_map::ToDisplayPoint, Anchor, AnchorRangeExt, DisplayPoint, Editor, EditorSettings,
+    EditorSnapshot, EditorStyle, RangeToAnchorExt,
 };
 use futures::FutureExt;
 use gpui::{
@@ -12,7 +12,6 @@ use gpui::{
 };
 use language::{Bias, DiagnosticEntry, DiagnosticSeverity, Language, LanguageRegistry};
 use project::{HoverBlock, HoverBlockKind, Project};
-use settings::Settings;
 use std::{ops::Range, sync::Arc, time::Duration};
 use util::TryFutureExt;

@@ -38,7 +37,7 @@ pub fn hover(editor: &mut Editor, _: &Hover, cx: &mut ViewContext<Editor>) {
 /// The internal hover action dispatches between `show_hover` or `hide_hover`
 /// depending on whether a point to hover over is provided.
 pub fn hover_at(editor: &mut Editor, point: Option<DisplayPoint>, cx: &mut ViewContext<Editor>) {
-    if cx.global::<Settings>().hover_popover_enabled {
+    if settings::get::<EditorSettings>(cx).hover_popover_enabled {
        if let Some(point) = point {
            show_hover(editor, point, false, cx);
        } else {
@@ -222,6 +221,7 @@ fn show_hover(
                    project: project.clone(),
                    symbol_range: range,
                    blocks: hover_result.contents,
+                    language: hover_result.language,
                    rendered_content: None,
                })
            });
@@ -254,6 +254,7 @@ fn render_blocks(
    theme_id: usize,
    blocks: &[HoverBlock],
    language_registry: &Arc<LanguageRegistry>,
+    language: Option<&Arc<Language>>,
    style: &EditorStyle,
 ) -> RenderedInfo {
    let mut text = String::new();
@@ -352,11 +353,13 @@ fn render_blocks(
                            }
                            Tag::CodeBlock(kind) => {
                                new_paragraph(&mut text, &mut list_stack);
-                                if let CodeBlockKind::Fenced(language) = kind {
-                                    current_language = language_registry
+                                current_language = if let CodeBlockKind::Fenced(language) = kind {
+                                    language_registry
                                        .language_for_name(language.as_ref())
                                        .now_or_never()
-                                        .and_then(Result::ok);
+                                        .and_then(Result::ok)
+                                } else {
+                                    language.cloned()
                                }
                            }
                            Tag::Emphasis => italic_depth += 1,
@@ -415,10 +418,6 @@ fn render_blocks(
        }
    }

-    if !text.is_empty() && !text.ends_with('\n') {
-        text.push('\n');
-    }
-
    RenderedInfo {
        theme_id,
        text,
@@ -525,6 +524,7 @@ pub struct InfoPopover {
    pub project: ModelHandle<Project>,
    pub symbol_range: Range<Anchor>,
    pub blocks: Vec<HoverBlock>,
+    language: Option<Arc<Language>>,
    rendered_content: Option<RenderedInfo>,
 }

@@ -560,6 +560,7 @@ impl InfoPopover {
                style.theme_id,
                &self.blocks,
                self.project.read(cx).languages(),
+                self.language.as_ref(),
                style,
            )
        });
@@ -589,10 +590,7 @@ impl InfoPopover {
                                        MouseRegion::new::<Self>(view_id, region_id, bounds)
                                            .on_click::<Editor, _>(
                                                MouseButton::Left,
-                                                move |_, _, cx| {
-                                                    println!("clicked link {url}");
-                                                    cx.platform().open_url(&url);
-                                                },
+                                                move |_, _, cx| cx.platform().open_url(&url),
                                            ),
                                    );
                                }
@@ -654,7 +652,7 @@ impl DiagnosticPopover {
            _ => style.hover_popover.container,
        };

-        let tooltip_style = cx.global::<Settings>().theme.tooltip.clone();
+        let tooltip_style = theme::current(cx).tooltip.clone();

        MouseEventHandler::<DiagnosticPopover, _>::new(0, cx, |_, _| {
            text.with_soft_wrap(true)
@@ -694,7 +692,7 @@ impl DiagnosticPopover {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::test::editor_lsp_test_context::EditorLspTestContext;
+    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
    use gpui::fonts::Weight;
    use indoc::indoc;
    use language::{Diagnostic, DiagnosticSet};
@@ -706,6 +704,8 @@ mod tests {

    #[gpui::test]
    async fn test_mouse_hover_info_popover(cx: &mut gpui::TestAppContext) {
+        init_test(cx, |_| {});
+
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -773,6 +773,8 @@ mod tests {

    #[gpui::test]
    async fn test_keyboard_hover_info_popover(cx: &mut gpui::TestAppContext) {
+        init_test(cx, |_| {});
+
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -816,6 +818,8 @@ mod tests {

    #[gpui::test]
    async fn test_hover_diagnostic_and_info_popovers(cx: &mut gpui::TestAppContext) {
+        init_test(cx, |_| {});
+
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -882,7 +886,8 @@ mod tests {

    #[gpui::test]
    fn test_render_blocks(cx: &mut gpui::TestAppContext) {
-        Settings::test_async(cx);
+        init_test(cx, |_| {});
+
        cx.add_window(|cx| {
            let editor = Editor::single_line(None, cx);
            let style = editor.style(cx);
@@ -900,7 +905,7 @@ mod tests {
                        text: "one **two** three".to_string(),
                        kind: HoverBlockKind::Markdown,
                    }],
-                    expected_marked_text: "one «two» three\n".to_string(),
+                    expected_marked_text: "one «two» three".to_string(),
                    expected_styles: vec![HighlightStyle {
                        weight: Some(Weight::BOLD),
                        ..Default::default()
@@ -912,7 +917,7 @@ mod tests {
                        text: "one [two](the-url) three".to_string(),
                        kind: HoverBlockKind::Markdown,
                    }],
-                    expected_marked_text: "one «two» three\n".to_string(),
+                    expected_marked_text: "one «two» three".to_string(),
                    expected_styles: vec![HighlightStyle {
                        underline: Some(Underline {
                            thickness: 1.0.into(),
@@ -931,8 +936,7 @@ mod tests {
                                - b
                            * two
                                - [c](the-url)
-                                - d
-                        "
+                                - d"
                        .unindent(),
                        kind: HoverBlockKind::Markdown,
                    }],
@@ -943,8 +947,7 @@ mod tests {
                          - b
                        - two
                          - «c»
-                          - d
-                    "
+                          - d"
                    .unindent(),
                    expected_styles: vec![HighlightStyle {
                        underline: Some(Underline {
@@ -967,9 +970,8 @@ mod tests {

                                  nine
                                * ten
-                            * six
-                        "
-                        .unindent(),
+                            * six"
+                            .unindent(),
                        kind: HoverBlockKind::Markdown,
                    }],
                    expected_marked_text: "
@@ -979,9 +981,8 @@ mod tests {

                            nine
                          - ten
-                        - six
-                    "
-                    .unindent(),
+                        - six"
+                        .unindent(),
                    expected_styles: vec![HighlightStyle {
                        underline: Some(Underline {
                            thickness: 1.0.into(),
@@ -998,7 +999,7 @@ mod tests {
                expected_styles,
            } in &rows[0..]
            {
-                let rendered = render_blocks(0, &blocks, &Default::default(), &style);
+                let rendered = render_blocks(0, &blocks, &Default::default(), None, &style);

                let (expected_text, ranges) = marked_text_ranges(expected_marked_text, false);
                let expected_highlights = ranges
@@ -1006,8 +1007,7 @@ mod tests {
                    .zip(expected_styles.iter().cloned())
                    .collect::<Vec<_>>();
                assert_eq!(
-                    rendered.text,
-                    dbg!(expected_text),
+                    rendered.text, expected_text,
                    "wrong text for input {blocks:?}"
                );
                assert_eq!(
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -3,7 +3,7 @@ use crate::{
    movement::surrounding_word, persistence::DB, scroll::ScrollAnchor, Anchor, Autoscroll, Editor,
    Event, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, NavigationData, ToPoint as _,
 };
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use collections::HashSet;
 use futures::future::try_join_all;
 use gpui::{
@@ -16,7 +16,6 @@ use language::{
 };
 use project::{FormatTrigger, Item as _, Project, ProjectPath};
 use rpc::proto::{self, update_view};
-use settings::Settings;
 use smallvec::SmallVec;
 use std::{
    borrow::Cow,
@@ -27,7 +26,7 @@ use std::{
    path::{Path, PathBuf},
 };
 use text::Selection;
-use util::{ResultExt, TryFutureExt};
+use util::{paths::FILE_ROW_COLUMN_DELIMITER, ResultExt, TryFutureExt};
 use workspace::item::{BreadcrumbText, FollowableItemHandle};
 use workspace::{
    item::{FollowableItem, Item, ItemEvent, ItemHandle, ProjectItem},
@@ -197,7 +196,7 @@ impl FollowableItem for Editor {
            singleton: buffer.is_singleton(),
            title: (!buffer.is_singleton()).then(|| buffer.title(cx).into()),
            excerpts,
-            scroll_top_anchor: Some(serialize_anchor(&scroll_anchor.top_anchor)),
+            scroll_top_anchor: Some(serialize_anchor(&scroll_anchor.anchor)),
            scroll_x: scroll_anchor.offset.x(),
            scroll_y: scroll_anchor.offset.y(),
            selections: self
@@ -254,7 +253,7 @@ impl FollowableItem for Editor {
                }
                Event::ScrollPositionChanged { .. } => {
                    let scroll_anchor = self.scroll_manager.anchor();
-                    update.scroll_top_anchor = Some(serialize_anchor(&scroll_anchor.top_anchor));
+                    update.scroll_top_anchor = Some(serialize_anchor(&scroll_anchor.anchor));
                    update.scroll_x = scroll_anchor.offset.x();
                    update.scroll_y = scroll_anchor.offset.y();
                    true
@@ -413,7 +412,7 @@ async fn update_editor_from_message(
        } else if let Some(scroll_top_anchor) = scroll_top_anchor {
            editor.set_scroll_anchor_remote(
                ScrollAnchor {
-                    top_anchor: scroll_top_anchor,
+                    anchor: scroll_top_anchor,
                    offset: vec2f(message.scroll_x, message.scroll_y),
                },
                cx,
@@ -511,8 +510,8 @@ impl Item for Editor {
            };

            let mut scroll_anchor = data.scroll_anchor;
-            if !buffer.can_resolve(&scroll_anchor.top_anchor) {
-                scroll_anchor.top_anchor = buffer.anchor_before(
+            if !buffer.can_resolve(&scroll_anchor.anchor) {
+                scroll_anchor.anchor = buffer.anchor_before(
                    buffer.clip_point(Point::new(data.scroll_top_row, 0), Bias::Left),
                );
            }
@@ -566,7 +565,7 @@ impl Item for Editor {
        cx: &AppContext,
    ) -> AnyElement<T> {
        Flex::row()
-            .with_child(Label::new(self.title(cx).to_string(), style.label.clone()).aligned())
+            .with_child(Label::new(self.title(cx).to_string(), style.label.clone()).into_any())
            .with_children(detail.and_then(|detail| {
                let path = path_for_buffer(&self.buffer, detail, false, cx)?;
                let description = path.to_string_lossy();
@@ -580,6 +579,7 @@ impl Item for Editor {
                    .aligned(),
                )
            }))
+            .align_children_center()
            .into_any()
    }

@@ -636,7 +636,7 @@ impl Item for Editor {
        project: ModelHandle<Project>,
        cx: &mut ViewContext<Self>,
    ) -> Task<Result<()>> {
-        self.report_editor_event("save", cx);
+        self.report_editor_event("save", None, cx);
        let format = self.perform_format(project.clone(), FormatTrigger::Save, cx);
        let buffers = self.buffer().clone().read(cx).all_buffers();
        cx.spawn(|_, mut cx| async move {
@@ -685,6 +685,11 @@ impl Item for Editor {
            .as_singleton()
            .expect("cannot call save_as on an excerpt list");

+        let file_extension = abs_path
+            .extension()
+            .map(|a| a.to_string_lossy().to_string());
+        self.report_editor_event("save", file_extension, cx);
+
        project.update(cx, |project, cx| {
            project.save_buffer_as(buffer, abs_path, cx)
        })
@@ -704,10 +709,10 @@ impl Item for Editor {
            this.update(&mut cx, |editor, cx| {
                editor.request_autoscroll(Autoscroll::fit(), cx)
            })?;
-            buffer.update(&mut cx, |buffer, _| {
+            buffer.update(&mut cx, |buffer, cx| {
                if let Some(transaction) = transaction {
                    if !buffer.is_singleton() {
-                        buffer.push_transaction(&transaction.0);
+                        buffer.push_transaction(&transaction.0, cx);
                    }
                }
            });
@@ -715,17 +720,6 @@ impl Item for Editor {
        })
    }

-    fn git_diff_recalc(
-        &mut self,
-        _project: ModelHandle<Project>,
-        cx: &mut ViewContext<Self>,
-    ) -> Task<Result<()>> {
-        self.buffer().update(cx, |multibuffer, cx| {
-            multibuffer.git_diff_recalc(cx);
-        });
-        Task::ready(Ok(()))
-    }
-
    fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
        let mut result = SmallVec::new();
        match event {
@@ -864,16 +858,13 @@ impl Item for Editor {
                    let buffer = project_item
                        .downcast::<Buffer>()
                        .context("Project item at stored path was not a buffer")?;
-                    let pane = pane
-                        .upgrade(&cx)
-                        .ok_or_else(|| anyhow!("pane was dropped"))?;
-                    Ok(cx.update(|cx| {
-                        cx.add_view(&pane, |cx| {
+                    Ok(pane.update(&mut cx, |_, cx| {
+                        cx.add_view(|cx| {
                            let mut editor = Editor::for_buffer(buffer, Some(project), cx);
                            editor.read_scroll_position_from_db(item_id, workspace_id, cx);
                            editor
                        })
-                    }))
+                    })?)
                })
            })
            .unwrap_or_else(|error| Task::ready(Err(error)))
@@ -1113,8 +1104,12 @@ impl View for CursorPosition {

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
        if let Some(position) = self.position {
-            let theme = &cx.global::<Settings>().theme.workspace.status_bar;
-            let mut text = format!("{},{}", position.row + 1, position.column + 1);
+            let theme = &theme::current(cx).workspace.status_bar;
+            let mut text = format!(
+                "{}{FILE_ROW_COLUMN_DELIMITER}{}",
+                position.row + 1,
+                position.column + 1
+            );
            if self.selected_count > 0 {
                write!(text, " ({} selected)", self.selected_count).unwrap();
            }
@@ -1225,27 +1220,31 @@ mod tests {
        }

        fn as_local(&self) -> Option<&dyn language::LocalFile> {
-            todo!()
+            unimplemented!()
        }

        fn mtime(&self) -> SystemTime {
-            todo!()
+            unimplemented!()
        }

        fn file_name<'a>(&'a self, _: &'a gpui::AppContext) -> &'a std::ffi::OsStr {
-            todo!()
+            unimplemented!()
+        }
+
+        fn worktree_id(&self) -> usize {
+            0
        }

        fn is_deleted(&self) -> bool {
-            todo!()
+            unimplemented!()
        }

        fn as_any(&self) -> &dyn std::any::Any {
-            todo!()
+            unimplemented!()
        }

        fn to_proto(&self) -> rpc::proto::File {
-            todo!()
+            unimplemented!()
        }
    }
 }
--- a/crates/editor/src/link_go_to_definition.rs
+++ b/crates/editor/src/link_go_to_definition.rs
@@ -1,10 +1,8 @@
-use std::ops::Range;
-
 use crate::{Anchor, DisplayPoint, Editor, EditorSnapshot, SelectPhase};
 use gpui::{Task, ViewContext};
 use language::{Bias, ToOffset};
 use project::LocationLink;
-use settings::Settings;
+use std::ops::Range;
 use util::TryFutureExt;

 #[derive(Debug, Default)]
@@ -211,7 +209,7 @@ pub fn show_link_definition(
                        });

                        // Highlight symbol using theme link definition highlight style
-                        let style = cx.global::<Settings>().theme.editor.link_definition;
+                        let style = theme::current(cx).editor.link_definition;
                        this.highlight_text::<LinkGoToDefinitionState>(
                            vec![highlight_range],
                            style,
@@ -297,6 +295,8 @@ fn go_to_fetched_definition_of_kind(

 #[cfg(test)]
 mod tests {
+    use super::*;
+    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
    use futures::StreamExt;
    use gpui::{
        platform::{self, Modifiers, ModifiersChangedEvent},
@@ -305,15 +305,14 @@ mod tests {
    use indoc::indoc;
    use lsp::request::{GotoDefinition, GotoTypeDefinition};

-    use crate::test::editor_lsp_test_context::EditorLspTestContext;
-
-    use super::*;
-
    #[gpui::test]
    async fn test_link_go_to_type_definition(cx: &mut gpui::TestAppContext) {
+        init_test(cx, |_| {});
+
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                type_definition_provider: Some(lsp::TypeDefinitionProviderCapability::Simple(true)),
                ..Default::default()
            },
            cx,
@@ -417,6 +416,8 @@ mod tests {

    #[gpui::test]
    async fn test_link_go_to_definition(cx: &mut gpui::TestAppContext) {
+        init_test(cx, |_| {});
+
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -57,13 +57,14 @@ pub fn deploy_context_menu(

 #[cfg(test)]
 mod tests {
-    use crate::test::editor_lsp_test_context::EditorLspTestContext;
-
    use super::*;
+    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
    use indoc::indoc;

    #[gpui::test]
    async fn test_mouse_context_menu(cx: &mut gpui::TestAppContext) {
+        init_test(cx, |_| {});
+
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -193,6 +193,44 @@ pub fn next_subword_end(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPo
    })
 }

+pub fn start_of_paragraph(map: &DisplaySnapshot, display_point: DisplayPoint) -> DisplayPoint {
+    let point = display_point.to_point(map);
+    if point.row == 0 {
+        return map.max_point();
+    }
+
+    let mut found_non_blank_line = false;
+    for row in (0..point.row + 1).rev() {
+        let blank = map.buffer_snapshot.is_line_blank(row);
+        if found_non_blank_line && blank {
+            return Point::new(row, 0).to_display_point(map);
+        }
+
+        found_non_blank_line |= !blank;
+    }
+
+    DisplayPoint::zero()
+}
+
+pub fn end_of_paragraph(map: &DisplaySnapshot, display_point: DisplayPoint) -> DisplayPoint {
+    let point = display_point.to_point(map);
+    if point.row == map.max_buffer_row() {
+        return DisplayPoint::zero();
+    }
+
+    let mut found_non_blank_line = false;
+    for row in point.row..map.max_buffer_row() + 1 {
+        let blank = map.buffer_snapshot.is_line_blank(row);
+        if found_non_blank_line && blank {
+            return Point::new(row, 0).to_display_point(map);
+        }
+
+        found_non_blank_line |= !blank;
+    }
+
+    map.max_point()
+}
+
 /// Scans for a boundary preceding the given start point `from` until a boundary is found, indicated by the
 /// given predicate returning true. The predicate is called with the character to the left and right
 /// of the candidate boundary location, and will be called with `\n` characters indicating the start
@@ -369,11 +407,12 @@ pub fn split_display_range_by_lines(
 mod tests {
    use super::*;
    use crate::{test::marked_display_snapshot, Buffer, DisplayMap, ExcerptRange, MultiBuffer};
-    use settings::Settings;
+    use settings::SettingsStore;

    #[gpui::test]
    fn test_previous_word_start(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
            let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
            assert_eq!(
@@ -400,7 +439,8 @@ mod tests {

    #[gpui::test]
    fn test_previous_subword_start(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
            let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
            assert_eq!(
@@ -434,7 +474,8 @@ mod tests {

    #[gpui::test]
    fn test_find_preceding_boundary(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        fn assert(
            marked_text: &str,
            cx: &mut gpui::AppContext,
@@ -466,7 +507,8 @@ mod tests {

    #[gpui::test]
    fn test_next_word_end(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
            let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
            assert_eq!(
@@ -490,7 +532,8 @@ mod tests {

    #[gpui::test]
    fn test_next_subword_end(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
            let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
            assert_eq!(
@@ -523,7 +566,8 @@ mod tests {

    #[gpui::test]
    fn test_find_boundary(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        fn assert(
            marked_text: &str,
            cx: &mut gpui::AppContext,
@@ -555,7 +599,8 @@ mod tests {

    #[gpui::test]
    fn test_surrounding_word(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
            let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
            assert_eq!(
@@ -576,7 +621,8 @@ mod tests {

    #[gpui::test]
    fn test_move_up_and_down_with_excerpts(cx: &mut gpui::AppContext) {
-        cx.set_global(Settings::test(cx));
+        init_test(cx);
+
        let family_id = cx
            .font_cache()
            .load_family(&["Helvetica"], &Default::default())
@@ -691,4 +737,11 @@ mod tests {
            (DisplayPoint::new(7, 2), SelectionGoal::Column(2)),
        );
    }
+
+    fn init_test(cx: &mut gpui::AppContext) {
+        cx.set_global(SettingsStore::test(cx));
+        theme::init((), cx);
+        language::init(cx);
+        crate::init(cx);
+    }
 }
--- a/crates/editor/src/multi_buffer.rs
+++ b/crates/editor/src/multi_buffer.rs
@@ -9,7 +9,9 @@ use git::diff::DiffHunk;
 use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
 pub use language::Completion;
 use language::{
-    char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
+    char_kind,
+    language_settings::{language_settings, LanguageSettings},
+    AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
    DiagnosticEntry, File, IndentSize, Language, LanguageScope, OffsetRangeExt, OffsetUtf16,
    Outline, OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _,
    ToOffsetUtf16 as _, ToPoint as _, ToPointUtf16 as _, TransactionId, Unclipped,
@@ -43,7 +45,7 @@ pub struct ExcerptId(usize);

 pub struct MultiBuffer {
    snapshot: RefCell<MultiBufferSnapshot>,
-    buffers: RefCell<HashMap<usize, BufferState>>,
+    buffers: RefCell<HashMap<u64, BufferState>>,
    next_excerpt_id: usize,
    subscriptions: Topic,
    singleton: bool,
@@ -62,8 +64,12 @@ pub enum Event {
    ExcerptsRemoved {
        ids: Vec<ExcerptId>,
    },
+    ExcerptsEdited {
+        ids: Vec<ExcerptId>,
+    },
    Edited,
    Reloaded,
+    DiffBaseChanged,
    LanguageChanged,
    Reparsed,
    Saved,
@@ -85,7 +91,7 @@ struct History {
 #[derive(Clone)]
 struct Transaction {
    id: TransactionId,
-    buffer_transactions: HashMap<usize, text::TransactionId>,
+    buffer_transactions: HashMap<u64, text::TransactionId>,
    first_edit_at: Instant,
    last_edit_at: Instant,
    suppress_grouping: bool,
@@ -145,7 +151,7 @@ pub struct ExcerptBoundary {
 struct Excerpt {
    id: ExcerptId,
    locator: Locator,
-    buffer_id: usize,
+    buffer_id: u64,
    buffer: BufferSnapshot,
    range: ExcerptRange<text::Anchor>,
    max_buffer_row: u32,
@@ -193,6 +199,13 @@ pub struct MultiBufferBytes<'a> {
    chunk: &'a [u8],
 }

+pub struct ReversedMultiBufferBytes<'a> {
+    range: Range<usize>,
+    excerpts: Cursor<'a, Excerpt, usize>,
+    excerpt_bytes: Option<ExcerptBytes<'a>>,
+    chunk: &'a [u8],
+}
+
 struct ExcerptChunks<'a> {
    content_chunks: BufferChunks<'a>,
    footer_height: usize,
@@ -337,21 +350,10 @@ impl MultiBuffer {
        offset: T,
        theme: Option<&SyntaxTheme>,
        cx: &AppContext,
-    ) -> Option<(usize, Vec<OutlineItem<Anchor>>)> {
+    ) -> Option<(u64, Vec<OutlineItem<Anchor>>)> {
        self.read(cx).symbols_containing(offset, theme)
    }

-    pub fn git_diff_recalc(&mut self, cx: &mut ModelContext<Self>) {
-        let buffers = self.buffers.borrow();
-        for buffer_state in buffers.values() {
-            if buffer_state.buffer.read(cx).needs_git_diff_recalc() {
-                buffer_state
-                    .buffer
-                    .update(cx, |buffer, cx| buffer.git_diff_recalc(cx))
-            }
-        }
-    }
-
    pub fn edit<I, S, T>(
        &mut self,
        edits: I,
@@ -394,7 +396,8 @@ impl MultiBuffer {
            is_insertion: bool,
            original_indent_column: u32,
        }
-        let mut buffer_edits: HashMap<usize, Vec<BufferEdit>> = Default::default();
+        let mut buffer_edits: HashMap<u64, Vec<BufferEdit>> = Default::default();
+        let mut edited_excerpt_ids = Vec::new();
        let mut cursor = snapshot.excerpts.cursor::<usize>();
        for (ix, (range, new_text)) in edits.enumerate() {
            let new_text: Arc<str> = new_text.into();
@@ -411,6 +414,7 @@ impl MultiBuffer {
                .start
                .to_offset(&start_excerpt.buffer)
                + start_overshoot;
+            edited_excerpt_ids.push(start_excerpt.id);

            cursor.seek(&range.end, Bias::Right, &());
            if cursor.item().is_none() && range.end == *cursor.start() {
@@ -436,6 +440,7 @@ impl MultiBuffer {
                        original_indent_column,
                    });
            } else {
+                edited_excerpt_ids.push(end_excerpt.id);
                let start_excerpt_range = buffer_start
                    ..start_excerpt
                        .range
@@ -482,6 +487,7 @@ impl MultiBuffer {
                            is_insertion: false,
                            original_indent_column,
                        });
+                    edited_excerpt_ids.push(excerpt.id);
                    cursor.next(&());
                }
            }
@@ -554,6 +560,10 @@ impl MultiBuffer {
                    buffer.edit(insertions, insertion_autoindent_mode, cx);
                })
        }
+
+        cx.emit(Event::ExcerptsEdited {
+            ids: edited_excerpt_ids,
+        });
    }

    pub fn start_transaction(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
@@ -593,7 +603,7 @@ impl MultiBuffer {
            if let Some(transaction_id) =
                buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx))
            {
-                buffer_transactions.insert(buffer.id(), transaction_id);
+                buffer_transactions.insert(buffer.read(cx).remote_id(), transaction_id);
            }
        }

@@ -614,12 +624,12 @@ impl MultiBuffer {
        }
    }

-    pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T)
+    pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &mut ModelContext<Self>)
    where
        T: IntoIterator<Item = (&'a ModelHandle<Buffer>, &'a language::Transaction)>,
    {
        self.history
-            .push_transaction(buffer_transactions, Instant::now());
+            .push_transaction(buffer_transactions, Instant::now(), cx);
        self.history.finalize_last_transaction();
    }

@@ -644,7 +654,7 @@ impl MultiBuffer {
        cursor_shape: CursorShape,
        cx: &mut ModelContext<Self>,
    ) {
-        let mut selections_by_buffer: HashMap<usize, Vec<Selection<text::Anchor>>> =
+        let mut selections_by_buffer: HashMap<u64, Vec<Selection<text::Anchor>>> =
            Default::default();
        let snapshot = self.read(cx);
        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
@@ -785,8 +795,8 @@ impl MultiBuffer {
        let (mut tx, rx) = mpsc::channel(256);
        let task = cx.spawn(|this, mut cx| async move {
            for (buffer, ranges) in excerpts {
-                let buffer_id = buffer.id();
-                let buffer_snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot());
+                let (buffer_id, buffer_snapshot) =
+                    buffer.read_with(&cx, |buffer, _| (buffer.remote_id(), buffer.snapshot()));

                let mut excerpt_ranges = Vec::new();
                let mut range_counts = Vec::new();
@@ -855,7 +865,7 @@ impl MultiBuffer {
    where
        O: text::ToPoint + text::ToOffset,
    {
-        let buffer_id = buffer.id();
+        let buffer_id = buffer.read(cx).remote_id();
        let buffer_snapshot = buffer.read(cx).snapshot();
        let (excerpt_ranges, range_counts) =
            build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
@@ -924,7 +934,7 @@ impl MultiBuffer {

        self.sync(cx);

-        let buffer_id = buffer.id();
+        let buffer_id = buffer.read(cx).remote_id();
        let buffer_snapshot = buffer.read(cx).snapshot();

        let mut buffers = self.buffers.borrow_mut();
@@ -1051,7 +1061,7 @@ impl MultiBuffer {
        let buffers = self.buffers.borrow();
        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
        for locator in buffers
-            .get(&buffer.id())
+            .get(&buffer.read(cx).remote_id())
            .map(|state| &state.excerpts)
            .into_iter()
            .flatten()
@@ -1138,6 +1148,10 @@ impl MultiBuffer {
        let mut result = Vec::new();
        let mut cursor = snapshot.excerpts.cursor::<usize>();
        cursor.seek(&start, Bias::Right, &());
+        if cursor.item().is_none() {
+            cursor.prev(&());
+        }
+
        while let Some(excerpt) = cursor.item() {
            if *cursor.start() > end {
                break;
@@ -1165,6 +1179,9 @@ impl MultiBuffer {
    ) {
        self.sync(cx);
        let ids = excerpt_ids.into_iter().collect::<Vec<_>>();
+        if ids.is_empty() {
+            return;
+        }

        let mut buffers = self.buffers.borrow_mut();
        let mut snapshot = self.snapshot.borrow_mut();
@@ -1303,6 +1320,7 @@ impl MultiBuffer {
            language::Event::Saved => Event::Saved,
            language::Event::FileHandleChanged => Event::FileHandleChanged,
            language::Event::Reloaded => Event::Reloaded,
+            language::Event::DiffBaseChanged => Event::DiffBaseChanged,
            language::Event::LanguageChanged => Event::LanguageChanged,
            language::Event::Reparsed => Event::Reparsed,
            language::Event::DiagnosticsUpdated => Event::DiagnosticsUpdated,
@@ -1321,7 +1339,7 @@ impl MultiBuffer {
            .collect()
    }

-    pub fn buffer(&self, buffer_id: usize) -> Option<ModelHandle<Buffer>> {
+    pub fn buffer(&self, buffer_id: u64) -> Option<ModelHandle<Buffer>> {
        self.buffers
            .borrow()
            .get(&buffer_id)
@@ -1372,6 +1390,21 @@ impl MultiBuffer {
            .and_then(|(buffer, offset)| buffer.read(cx).language_at(offset))
    }

+    pub fn settings_at<'a, T: ToOffset>(
+        &self,
+        point: T,
+        cx: &'a AppContext,
+    ) -> &'a LanguageSettings {
+        let mut language = None;
+        let mut file = None;
+        if let Some((buffer, offset)) = self.point_to_buffer_offset(point, cx) {
+            let buffer = buffer.read(cx);
+            language = buffer.language_at(offset);
+            file = buffer.file();
+        }
+        language_settings(language.as_ref(), file, cx)
+    }
+
    pub fn for_each_buffer(&self, mut f: impl FnMut(&ModelHandle<Buffer>)) {
        self.buffers
            .borrow()
@@ -1478,8 +1511,8 @@ impl MultiBuffer {
        for (locator, buffer, buffer_edited) in excerpts_to_edit {
            new_excerpts.push_tree(cursor.slice(&Some(locator), Bias::Left, &()), &());
            let old_excerpt = cursor.item().unwrap();
-            let buffer_id = buffer.id();
            let buffer = buffer.read(cx);
+            let buffer_id = buffer.remote_id();

            let mut new_excerpt;
            if buffer_edited {
@@ -1532,6 +1565,13 @@ impl MultiBuffer {
        cx.add_model(|cx| Self::singleton(buffer, cx))
    }

+    pub fn build_from_buffer(
+        buffer: ModelHandle<Buffer>,
+        cx: &mut gpui::AppContext,
+    ) -> ModelHandle<Self> {
+        cx.add_model(|cx| Self::singleton(buffer, cx))
+    }
+
    pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui::AppContext) -> ModelHandle<Self> {
        cx.add_model(|cx| {
            let mut multibuffer = MultiBuffer::new(0);
@@ -1605,11 +1645,11 @@ impl MultiBuffer {
                let buffer_handle = if rng.gen() || self.buffers.borrow().is_empty() {
                    let text = RandomCharIter::new(&mut *rng).take(10).collect::<String>();
                    buffers.push(cx.add_model(|cx| Buffer::new(0, text, cx)));
-                    let buffer = buffers.last().unwrap();
+                    let buffer = buffers.last().unwrap().read(cx);
                    log::info!(
                        "Creating new buffer {} with text: {:?}",
-                        buffer.id(),
-                        buffer.read(cx).text()
+                        buffer.remote_id(),
+                        buffer.text()
                    );
                    buffers.last().unwrap().clone()
                } else {
@@ -1637,7 +1677,7 @@ impl MultiBuffer {
                    .collect::<Vec<_>>();
                log::info!(
                    "Inserting excerpts from buffer {} and ranges {:?}: {:?}",
-                    buffer_handle.id(),
+                    buffer_handle.read(cx).remote_id(),
                    ranges.iter().map(|r| &r.context).collect::<Vec<_>>(),
                    ranges
                        .iter()
@@ -1830,7 +1870,7 @@ impl MultiBufferSnapshot {
        (start..end, word_kind)
    }

-    pub fn as_singleton(&self) -> Option<(&ExcerptId, usize, &BufferSnapshot)> {
+    pub fn as_singleton(&self) -> Option<(&ExcerptId, u64, &BufferSnapshot)> {
        if self.singleton {
            self.excerpts
                .iter()
@@ -1945,7 +1985,6 @@ impl MultiBufferSnapshot {
        } else {
            None
        };
-
        MultiBufferBytes {
            range,
            excerpts,
@@ -1954,6 +1993,33 @@ impl MultiBufferSnapshot {
        }
    }

+    pub fn reversed_bytes_in_range<T: ToOffset>(
+        &self,
+        range: Range<T>,
+    ) -> ReversedMultiBufferBytes {
+        let range = range.start.to_offset(self)..range.end.to_offset(self);
+        let mut excerpts = self.excerpts.cursor::<usize>();
+        excerpts.seek(&range.end, Bias::Left, &());
+
+        let mut chunk = &[][..];
+        let excerpt_bytes = if let Some(excerpt) = excerpts.item() {
+            let mut excerpt_bytes = excerpt.reversed_bytes_in_range(
+                range.start - excerpts.start()..range.end - excerpts.start(),
+            );
+            chunk = excerpt_bytes.next().unwrap_or(&[][..]);
+            Some(excerpt_bytes)
+        } else {
+            None
+        };
+
+        ReversedMultiBufferBytes {
+            range,
+            excerpts,
+            excerpt_bytes,
+            chunk,
+        }
+    }
+
    pub fn buffer_rows(&self, start_row: u32) -> MultiBufferRows {
        let mut result = MultiBufferRows {
            buffer_row_range: 0..0,
@@ -2764,6 +2830,20 @@ impl MultiBufferSnapshot {
            .and_then(|(buffer, offset)| buffer.language_at(offset))
    }

+    pub fn settings_at<'a, T: ToOffset>(
+        &'a self,
+        point: T,
+        cx: &'a AppContext,
+    ) -> &'a LanguageSettings {
+        let mut language = None;
+        let mut file = None;
+        if let Some((buffer, offset)) = self.point_to_buffer_offset(point) {
+            language = buffer.language_at(offset);
+            file = buffer.file();
+        }
+        language_settings(language, file, cx)
+    }
+
    pub fn language_scope_at<'a, T: ToOffset>(&'a self, point: T) -> Option<LanguageScope> {
        self.point_to_buffer_offset(point)
            .and_then(|(buffer, offset)| buffer.language_scope_at(offset))
@@ -2817,20 +2897,24 @@ impl MultiBufferSnapshot {
            })
    }

-    pub fn git_diff_hunks_in_range<'a>(
+    pub fn has_git_diffs(&self) -> bool {
+        for excerpt in self.excerpts.iter() {
+            if !excerpt.buffer.git_diff.is_empty() {
+                return true;
+            }
+        }
+        false
+    }
+
+    pub fn git_diff_hunks_in_range_rev<'a>(
        &'a self,
        row_range: Range<u32>,
-        reversed: bool,
    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
        let mut cursor = self.excerpts.cursor::<Point>();

-        if reversed {
-            cursor.seek(&Point::new(row_range.end, 0), Bias::Left, &());
-            if cursor.item().is_none() {
-                cursor.prev(&());
-            }
-        } else {
-            cursor.seek(&Point::new(row_range.start, 0), Bias::Right, &());
+        cursor.seek(&Point::new(row_range.end, 0), Bias::Left, &());
+        if cursor.item().is_none() {
+            cursor.prev(&());
        }

        std::iter::from_fn(move || {
@@ -2860,7 +2944,7 @@ impl MultiBufferSnapshot {

            let buffer_hunks = excerpt
                .buffer
-                .git_diff_hunks_intersecting_range(buffer_start..buffer_end, reversed)
+                .git_diff_hunks_intersecting_range_rev(buffer_start..buffer_end)
                .filter_map(move |hunk| {
                    let start = multibuffer_start.row
                        + hunk
@@ -2880,12 +2964,70 @@ impl MultiBufferSnapshot {
                    })
                });

-            if reversed {
-                cursor.prev(&());
-            } else {
-                cursor.next(&());
+            cursor.prev(&());
+
+            Some(buffer_hunks)
+        })
+        .flatten()
+    }
+
+    pub fn git_diff_hunks_in_range<'a>(
+        &'a self,
+        row_range: Range<u32>,
+    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+        let mut cursor = self.excerpts.cursor::<Point>();
+
+        cursor.seek(&Point::new(row_range.start, 0), Bias::Right, &());
+
+        std::iter::from_fn(move || {
+            let excerpt = cursor.item()?;
+            let multibuffer_start = *cursor.start();
+            let multibuffer_end = multibuffer_start + excerpt.text_summary.lines;
+            if multibuffer_start.row >= row_range.end {
+                return None;
            }

+            let mut buffer_start = excerpt.range.context.start;
+            let mut buffer_end = excerpt.range.context.end;
+            let excerpt_start_point = buffer_start.to_point(&excerpt.buffer);
+            let excerpt_end_point = excerpt_start_point + excerpt.text_summary.lines;
+
+            if row_range.start > multibuffer_start.row {
+                let buffer_start_point =
+                    excerpt_start_point + Point::new(row_range.start - multibuffer_start.row, 0);
+                buffer_start = excerpt.buffer.anchor_before(buffer_start_point);
+            }
+
+            if row_range.end < multibuffer_end.row {
+                let buffer_end_point =
+                    excerpt_start_point + Point::new(row_range.end - multibuffer_start.row, 0);
+                buffer_end = excerpt.buffer.anchor_before(buffer_end_point);
+            }
+
+            let buffer_hunks = excerpt
+                .buffer
+                .git_diff_hunks_intersecting_range(buffer_start..buffer_end)
+                .filter_map(move |hunk| {
+                    let start = multibuffer_start.row
+                        + hunk
+                            .buffer_range
+                            .start
+                            .saturating_sub(excerpt_start_point.row);
+                    let end = multibuffer_start.row
+                        + hunk
+                            .buffer_range
+                            .end
+                            .min(excerpt_end_point.row + 1)
+                            .saturating_sub(excerpt_start_point.row);
+
+                    Some(DiffHunk {
+                        buffer_range: start..end,
+                        diff_base_byte_range: hunk.diff_base_byte_range.clone(),
+                    })
+                });
+
+            cursor.next(&());
+
            Some(buffer_hunks)
        })
        .flatten()
@@ -2938,7 +3080,7 @@ impl MultiBufferSnapshot {
        &self,
        offset: T,
        theme: Option<&SyntaxTheme>,
-    ) -> Option<(usize, Vec<OutlineItem<Anchor>>)> {
+    ) -> Option<(u64, Vec<OutlineItem<Anchor>>)> {
        let anchor = self.anchor_before(offset);
        let excerpt_id = anchor.excerpt_id();
        let excerpt = self.excerpt(excerpt_id)?;
@@ -2978,7 +3120,7 @@ impl MultiBufferSnapshot {
        }
    }

-    pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<usize> {
+    pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<u64> {
        Some(self.excerpt(excerpt_id)?.buffer_id)
    }

@@ -3116,7 +3258,7 @@ impl History {
    fn end_transaction(
        &mut self,
        now: Instant,
-        buffer_transactions: HashMap<usize, TransactionId>,
+        buffer_transactions: HashMap<u64, TransactionId>,
    ) -> bool {
        assert_ne!(self.transaction_depth, 0);
        self.transaction_depth -= 1;
@@ -3141,8 +3283,12 @@ impl History {
        }
    }

-    fn push_transaction<'a, T>(&mut self, buffer_transactions: T, now: Instant)
-    where
+    fn push_transaction<'a, T>(
+        &mut self,
+        buffer_transactions: T,
+        now: Instant,
+        cx: &mut ModelContext<MultiBuffer>,
+    ) where
        T: IntoIterator<Item = (&'a ModelHandle<Buffer>, &'a language::Transaction)>,
    {
        assert_eq!(self.transaction_depth, 0);
@@ -3150,7 +3296,7 @@ impl History {
            id: self.next_transaction_id.tick(),
            buffer_transactions: buffer_transactions
                .into_iter()
-                .map(|(buffer, transaction)| (buffer.id(), transaction.id))
+                .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))
                .collect(),
            first_edit_at: now,
            last_edit_at: now,
@@ -3247,7 +3393,7 @@ impl Excerpt {
    fn new(
        id: ExcerptId,
        locator: Locator,
-        buffer_id: usize,
+        buffer_id: u64,
        buffer: BufferSnapshot,
        range: ExcerptRange<text::Anchor>,
        has_trailing_newline: bool,
@@ -3307,6 +3453,26 @@ impl Excerpt {
        }
    }

+    fn reversed_bytes_in_range(&self, range: Range<usize>) -> ExcerptBytes {
+        let content_start = self.range.context.start.to_offset(&self.buffer);
+        let bytes_start = content_start + range.start;
+        let bytes_end = content_start + cmp::min(range.end, self.text_summary.len);
+        let footer_height = if self.has_trailing_newline
+            && range.start <= self.text_summary.len
+            && range.end > self.text_summary.len
+        {
+            1
+        } else {
+            0
+        };
+        let content_bytes = self.buffer.reversed_bytes_in_range(bytes_start..bytes_end);
+
+        ExcerptBytes {
+            content_bytes,
+            footer_height,
+        }
+    }
+
    fn clip_anchor(&self, text_anchor: text::Anchor) -> text::Anchor {
        if text_anchor
            .cmp(&self.range.context.start, &self.buffer)
@@ -3625,6 +3791,38 @@ impl<'a> io::Read for MultiBufferBytes<'a> {
    }
 }

+impl<'a> ReversedMultiBufferBytes<'a> {
+    fn consume(&mut self, len: usize) {
+        self.range.end -= len;
+        self.chunk = &self.chunk[..self.chunk.len() - len];
+
+        if !self.range.is_empty() && self.chunk.is_empty() {
+            if let Some(chunk) = self.excerpt_bytes.as_mut().and_then(|bytes| bytes.next()) {
+                self.chunk = chunk;
+            } else {
+                self.excerpts.next(&());
+                if let Some(excerpt) = self.excerpts.item() {
+                    let mut excerpt_bytes =
+                        excerpt.bytes_in_range(0..self.range.end - self.excerpts.start());
+                    self.chunk = excerpt_bytes.next().unwrap();
+                    self.excerpt_bytes = Some(excerpt_bytes);
+                }
+            }
+        }
+    }
+}
+
+impl<'a> io::Read for ReversedMultiBufferBytes<'a> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let len = cmp::min(buf.len(), self.chunk.len());
+        buf[..len].copy_from_slice(&self.chunk[..len]);
+        buf[..len].reverse();
+        if len > 0 {
+            self.consume(len);
+        }
+        Ok(len)
+    }
+}
 impl<'a> Iterator for ExcerptBytes<'a> {
    type Item = &'a [u8];

@@ -3776,15 +3974,17 @@ where

 #[cfg(test)]
 mod tests {
+    use crate::editor_tests::init_test;
+
    use super::*;
    use futures::StreamExt;
    use gpui::{AppContext, TestAppContext};
    use language::{Buffer, Rope};
+    use project::{FakeFs, Project};
    use rand::prelude::*;
-    use settings::Settings;
+    use settings::SettingsStore;
    use std::{env, rc::Rc};
    use unindent::Unindent;
-
    use util::test::sample_text;

    #[gpui::test]
@@ -4076,19 +4276,25 @@ mod tests {

        let leader_multibuffer = cx.add_model(|_| MultiBuffer::new(0));
        let follower_multibuffer = cx.add_model(|_| MultiBuffer::new(0));
+        let follower_edit_event_count = Rc::new(RefCell::new(0));

        follower_multibuffer.update(cx, |_, cx| {
-            cx.subscribe(&leader_multibuffer, |follower, _, event, cx| {
-                match event.clone() {
+            let follower_edit_event_count = follower_edit_event_count.clone();
+            cx.subscribe(
+                &leader_multibuffer,
+                move |follower, _, event, cx| match event.clone() {
                    Event::ExcerptsAdded {
                        buffer,
                        predecessor,
                        excerpts,
                    } => follower.insert_excerpts_with_ids_after(predecessor, buffer, excerpts, cx),
                    Event::ExcerptsRemoved { ids } => follower.remove_excerpts(ids, cx),
+                    Event::Edited => {
+                        *follower_edit_event_count.borrow_mut() += 1;
+                    }
                    _ => {}
-                }
-            })
+                },
+            )
            .detach();
        });

@@ -4127,6 +4333,7 @@ mod tests {
            leader_multibuffer.read(cx).snapshot(cx).text(),
            follower_multibuffer.read(cx).snapshot(cx).text(),
        );
+        assert_eq!(*follower_edit_event_count.borrow(), 2);

        leader_multibuffer.update(cx, |leader, cx| {
            let excerpt_ids = leader.excerpt_ids();
@@ -4136,6 +4343,27 @@ mod tests {
            leader_multibuffer.read(cx).snapshot(cx).text(),
            follower_multibuffer.read(cx).snapshot(cx).text(),
        );
+        assert_eq!(*follower_edit_event_count.borrow(), 3);
+
+        // Removing an empty set of excerpts is a noop.
+        leader_multibuffer.update(cx, |leader, cx| {
+            leader.remove_excerpts([], cx);
+        });
+        assert_eq!(
+            leader_multibuffer.read(cx).snapshot(cx).text(),
+            follower_multibuffer.read(cx).snapshot(cx).text(),
+        );
+        assert_eq!(*follower_edit_event_count.borrow(), 3);
+
+        // Adding an empty set of excerpts is a noop.
+        leader_multibuffer.update(cx, |leader, cx| {
+            leader.push_excerpts::<usize>(buffer_2.clone(), [], cx);
+        });
+        assert_eq!(
+            leader_multibuffer.read(cx).snapshot(cx).text(),
+            follower_multibuffer.read(cx).snapshot(cx).text(),
+        );
+        assert_eq!(*follower_edit_event_count.borrow(), 3);

        leader_multibuffer.update(cx, |leader, cx| {
            leader.clear(cx);
@@ -4144,6 +4372,7 @@ mod tests {
            leader_multibuffer.read(cx).snapshot(cx).text(),
            follower_multibuffer.read(cx).snapshot(cx).text(),
        );
+        assert_eq!(*follower_edit_event_count.borrow(), 4);
    }

    #[gpui::test]
@@ -4442,73 +4671,85 @@ mod tests {
    #[gpui::test]
    async fn test_diff_hunks_in_range(cx: &mut TestAppContext) {
        use git::diff::DiffHunkStatus;
+        init_test(cx, |_| {});
+
+        let fs = FakeFs::new(cx.background());
+        let project = Project::test(fs, [], cx).await;

        // buffer has two modified hunks with two rows each
-        let buffer_1 = cx.add_model(|cx| {
-            let mut buffer = Buffer::new(
-                0,
-                "
-                1.zero
-                1.ONE
-                1.TWO
-                1.three
-                1.FOUR
-                1.FIVE
-                1.six
-            "
-                .unindent(),
-                cx,
-            );
+        let buffer_1 = project
+            .update(cx, |project, cx| {
+                project.create_buffer(
+                    "
+                        1.zero
+                        1.ONE
+                        1.TWO
+                        1.three
+                        1.FOUR
+                        1.FIVE
+                        1.six
+                    "
+                    .unindent()
+                    .as_str(),
+                    None,
+                    cx,
+                )
+            })
+            .unwrap();
+        buffer_1.update(cx, |buffer, cx| {
            buffer.set_diff_base(
                Some(
                    "
-                1.zero
-                1.one
-                1.two
-                1.three
-                1.four
-                1.five
-                1.six
-            "
+                        1.zero
+                        1.one
+                        1.two
+                        1.three
+                        1.four
+                        1.five
+                        1.six
+                    "
                    .unindent(),
                ),
                cx,
            );
-            buffer
        });

        // buffer has a deletion hunk and an insertion hunk
-        let buffer_2 = cx.add_model(|cx| {
-            let mut buffer = Buffer::new(
-                0,
-                "
-                2.zero
-                2.one
-                2.two
-                2.three
-                2.four
-                2.five
-                2.six
-            "
-                .unindent(),
-                cx,
-            );
+        let buffer_2 = project
+            .update(cx, |project, cx| {
+                project.create_buffer(
+                    "
+                        2.zero
+                        2.one
+                        2.two
+                        2.three
+                        2.four
+                        2.five
+                        2.six
+                    "
+                    .unindent()
+                    .as_str(),
+                    None,
+                    cx,
+                )
+            })
+            .unwrap();
+        buffer_2.update(cx, |buffer, cx| {
            buffer.set_diff_base(
                Some(
                    "
-                2.zero
-                2.one
-                2.one-and-a-half
-                2.two
-                2.three
-                2.four
-                2.six
-            "
+                        2.zero
+                        2.one
+                        2.one-and-a-half
+                        2.two
+                        2.three
+                        2.four
+                        2.six
+                    "
                    .unindent(),
                ),
                cx,
            );
-            buffer
        });

        cx.foreground().run_until_parked();
@@ -4591,7 +4832,7 @@ mod tests {

        assert_eq!(
            snapshot
-                .git_diff_hunks_in_range(0..12, false)
+                .git_diff_hunks_in_range(0..12)
                .map(|hunk| (hunk.status(), hunk.buffer_range))
                .collect::<Vec<_>>(),
            &expected,
@@ -4599,7 +4840,7 @@ mod tests {

        assert_eq!(
            snapshot
-                .git_diff_hunks_in_range(0..12, true)
+                .git_diff_hunks_in_range_rev(0..12)
                .map(|hunk| (hunk.status(), hunk.buffer_range))
                .collect::<Vec<_>>(),
            expected
@@ -4715,7 +4956,7 @@ mod tests {
                        "Inserting excerpt at {} of {} for buffer {}: {:?}[{:?}] = {:?}",
                        excerpt_ix,
                        expected_excerpts.len(),
-                        buffer_handle.id(),
+                        buffer_handle.read(cx).remote_id(),
                        buffer.text(),
                        start_ix..end_ix,
                        &buffer.text()[start_ix..end_ix]
@@ -4801,8 +5042,8 @@ mod tests {

            let mut excerpt_starts = excerpt_starts.into_iter();
            for (buffer, range) in &expected_excerpts {
-                let buffer_id = buffer.id();
                let buffer = buffer.read(cx);
+                let buffer_id = buffer.remote_id();
                let buffer_range = range.to_offset(buffer);
                let buffer_start_point = buffer.offset_to_point(buffer_range.start);
                let buffer_start_point_utf16 =
@@ -4954,16 +5195,19 @@ mod tests {
                    .read(cx)
                    .range_to_buffer_ranges(start_ix..end_ix, cx);
                let excerpted_buffers_text = excerpted_buffer_ranges
-                    .into_iter()
+                    .iter()
                    .map(|(buffer, buffer_range)| {
                        buffer
                            .read(cx)
-                            .text_for_range(buffer_range)
+                            .text_for_range(buffer_range.clone())
                            .collect::<String>()
                    })
                    .collect::<Vec<_>>()
                    .join("\n");
                assert_eq!(excerpted_buffers_text, text_for_range);
+                if !expected_excerpts.is_empty() {
+                    assert!(!excerpted_buffer_ranges.is_empty());
+                }

                let expected_summary = TextSummary::from(&expected_text[start_ix..end_ix]);
                assert_eq!(
@@ -5030,7 +5274,8 @@ mod tests {

    #[gpui::test]
    fn test_history(cx: &mut AppContext) {
-        cx.set_global(Settings::test(cx));
+        cx.set_global(SettingsStore::test(cx));
+
        let buffer_1 = cx.add_model(|cx| Buffer::new(0, "1234", cx));
        let buffer_2 = cx.add_model(|cx| Buffer::new(0, "5678", cx));
        let multibuffer = cx.add_model(|_| MultiBuffer::new(0));
@@ -5098,7 +5343,7 @@ mod tests {
            assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");

            // An undo in the multibuffer undoes the multibuffer transaction
-            // and also any individual buffer edits that have occured since
+            // and also any individual buffer edits that have occurred since
            // that transaction.
            multibuffer.undo(cx);
            assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
--- a/crates/editor/src/multi_buffer/anchor.rs
+++ b/crates/editor/src/multi_buffer/anchor.rs
@@ -8,7 +8,7 @@ use sum_tree::Bias;

 #[derive(Clone, Copy, Eq, PartialEq, Debug, Hash)]
 pub struct Anchor {
-    pub(crate) buffer_id: Option<usize>,
+    pub(crate) buffer_id: Option<u64>,
    pub(crate) excerpt_id: ExcerptId,
    pub(crate) text_anchor: text::Anchor,
 }
--- a/crates/editor/src/scroll.rs
+++ b/crates/editor/src/scroll.rs
@@ -36,21 +36,21 @@ pub struct ScrollbarAutoHide(pub bool);
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct ScrollAnchor {
    pub offset: Vector2F,
-    pub top_anchor: Anchor,
+    pub anchor: Anchor,
 }

 impl ScrollAnchor {
    fn new() -> Self {
        Self {
            offset: Vector2F::zero(),
-            top_anchor: Anchor::min(),
+            anchor: Anchor::min(),
        }
    }

    pub fn scroll_position(&self, snapshot: &DisplaySnapshot) -> Vector2F {
        let mut scroll_position = self.offset;
-        if self.top_anchor != Anchor::min() {
-            let scroll_top = self.top_anchor.to_display_point(snapshot).row() as f32;
+        if self.anchor != Anchor::min() {
+            let scroll_top = self.anchor.to_display_point(snapshot).row() as f32;
            scroll_position.set_y(scroll_top + scroll_position.y());
        } else {
            scroll_position.set_y(0.);
@@ -59,7 +59,7 @@ impl ScrollAnchor {
    }

    pub fn top_row(&self, buffer: &MultiBufferSnapshot) -> u32 {
-        self.top_anchor.to_point(buffer).row
+        self.anchor.to_point(buffer).row
    }
 }

@@ -179,7 +179,7 @@ impl ScrollManager {
        let (new_anchor, top_row) = if scroll_position.y() <= 0. {
            (
                ScrollAnchor {
-                    top_anchor: Anchor::min(),
+                    anchor: Anchor::min(),
                    offset: scroll_position.max(vec2f(0., 0.)),
                },
                0,
@@ -193,7 +193,7 @@ impl ScrollManager {

            (
                ScrollAnchor {
-                    top_anchor,
+                    anchor: top_anchor,
                    offset: vec2f(
                        scroll_position.x(),
                        scroll_position.y() - top_anchor.to_display_point(&map).row() as f32,
@@ -322,7 +322,7 @@ impl Editor {
        hide_hover(self, cx);
        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
        let top_row = scroll_anchor
-            .top_anchor
+            .anchor
            .to_point(&self.buffer().read(cx).snapshot(cx))
            .row;
        self.scroll_manager
@@ -337,7 +337,7 @@ impl Editor {
        hide_hover(self, cx);
        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
        let top_row = scroll_anchor
-            .top_anchor
+            .anchor
            .to_point(&self.buffer().read(cx).snapshot(cx))
            .row;
        self.scroll_manager
@@ -377,7 +377,7 @@ impl Editor {
        let screen_top = self
            .scroll_manager
            .anchor
-            .top_anchor
+            .anchor
            .to_display_point(&snapshot);

        if screen_top > newest_head {
@@ -408,7 +408,7 @@ impl Editor {
                .anchor_at(Point::new(top_row as u32, 0), Bias::Left);
            let scroll_anchor = ScrollAnchor {
                offset: Vector2F::new(x, y),
-                top_anchor,
+                anchor: top_anchor,
            };
            self.set_scroll_anchor(scroll_anchor, cx);
        }
--- a/crates/editor/src/scroll/actions.rs
+++ b/crates/editor/src/scroll/actions.rs
@@ -86,7 +86,7 @@ impl Editor {

        editor.set_scroll_anchor(
            ScrollAnchor {
-                top_anchor: new_anchor,
+                anchor: new_anchor,
                offset: Default::default(),
            },
            cx,
@@ -113,7 +113,7 @@ impl Editor {

        editor.set_scroll_anchor(
            ScrollAnchor {
-                top_anchor: new_anchor,
+                anchor: new_anchor,
                offset: Default::default(),
            },
            cx,
@@ -143,7 +143,7 @@ impl Editor {

        editor.set_scroll_anchor(
            ScrollAnchor {
-                top_anchor: new_anchor,
+                anchor: new_anchor,
                offset: Default::default(),
            },
            cx,
--- a/Show More
+++ b/Show More