zed 0.91.3

Activate screen-sharing when leader activates a panel (#2614 )
Fixes https://linear.app/zed-industries/issue/Z-1875/screen-sharing-tab-is-not-activated-when-leader-is-on-a-panel Release Notes: - Fixed a bug that caused followers to not see the leader's screen when they activated a panel.
2023-06-16 17:27:42 +02:00 · 2023-06-16 17:26:33 +02:00 · 2023-06-15 15:34:43 -07:00 · 2023-06-15 15:34:09 -07:00 · 2023-06-15 15:34:01 -07:00 · 2023-06-14 18:10:16 -07:00
392 changed files with 24654 additions and 15239 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -2,4 +2,11 @@

 Release Notes:

-* [[Added foo / Fixed bar / No 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/build_dmg.yml
+++ b/.github/workflows/build_dmg.yml
@@ -1,54 +0,0 @@
-name: Build Zed.dmg
-
-on:
-  push:
-    branches:
-    - main
-    - "v[0-9]+.[0-9]+.x"
-  pull_request:
-
-defaults:
-  run:
-    shell: bash -euxo pipefail {0}
-
-concurrency:
-  # Allow only one workflow per any non-`main` branch.
-  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.ref_name == 'main' && github.sha || 'anysha' }}
-  cancel-in-progress: true
-
-env:
-  RUST_BACKTRACE: 1
-  COPT: '-Werror'
-
-jobs:
-  build-dmg:
-    if: github.ref_name == 'main' || contains(github.event.pull_request.labels.*.name, 'run-build-dmg')
-    runs-on:
-      - self-hosted
-      - test
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          clean: false
-          submodules: 'recursive'
-
-      - name: Install Rust
-        run: |
-          rustup set profile minimal
-          rustup update stable
-
-      - name: Install node
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18
-
-      - name: Build dmg bundle
-        run: ./script/bundle
-
-      - name: Upload the build artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
-          path: ./target/release/Zed.dmg
--- 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:
@@ -85,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: |
@@ -147,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
@@ -21,19 +21,3 @@ jobs:

          ${{ 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",
@@ -32,10 +32,10 @@ members = [
    "crates/journal",
    "crates/language",
    "crates/language_selector",
+    "crates/language_tools",
    "crates/live_kit_client",
    "crates/live_kit_server",
    "crates/lsp",
-    "crates/lsp_log",
    "crates/media",
    "crates/menu",
    "crates/node_runtime",
@@ -77,8 +77,9 @@ async-trait = { version = "0.1" }
 ctor = { version = "0.1" }
 env_logger = { version = "0.9" }
 futures = { version = "0.3" }
-glob = { version = "0.3" }
 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" }
@@ -86,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"] }
@@ -94,10 +97,12 @@ 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" }
+tree-sitter = "0.20"
 unindent = { version = "0.1.7" }

 [patch.crates-io]
-tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14" }
+tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "49226023693107fba9a1191136a4f47f38cdca73" }
 async-task = { git = "https://github.com/zed-industries/async-task", rev = "341b57d6de98cdfd7b418567b8de2022ca993a6e" }

 # TODO - Remove when a version is released with this PR: https://github.com/servo/core-foundation-rs/pull/457
@@ -112,3 +117,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/robot_14.svg
+++ b/assets/icons/robot_14.svg
@@ -0,0 +1,4 @@
+<svg width="14" height="16" viewBox="0 0 14 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M2.5 4C2.5 2.89531 3.39688 2 4.5 2H9.5C10.6031 2 11.5 2.89531 11.5 4V8C11.5 9.10312 10.6031 10 9.5 10H4.5C3.39688 10 2.5 9.10312 2.5 8V4ZM5 4C4.44687 4 4 4.44687 4 5C4 5.55313 4.44687 6 5 6C5.55313 6 6 5.55313 6 5C6 4.44687 5.55313 4 5 4ZM9 6C9.55313 6 10 5.55313 10 5C10 4.44687 9.55313 4 9 4C8.44687 4 8 4.44687 8 5C8 5.55313 8.44687 6 9 6ZM5 8.5C5.275 8.5 5.5 8.275 5.5 8C5.5 7.725 5.275 7.5 5 7.5C4.725 7.5 4.5 7.725 4.5 8C4.5 8.275 4.725 8.5 5 8.5ZM7 7.5C6.725 7.5 6.5 7.725 6.5 8C6.5 8.275 6.725 8.5 7 8.5C7.275 8.5 7.5 8.275 7.5 8C7.5 7.725 7.275 7.5 7 7.5ZM9 8.5C9.275 8.5 9.5 8.275 9.5 8C9.5 7.725 9.275 7.5 9 7.5C8.725 7.5 8.5 7.725 8.5 8C8.5 8.275 8.725 8.5 9 8.5ZM0 14C0 12.3156 1.34312 11 3 11H11C12.6562 11 14 12.3156 14 14V15C14 15.5531 13.5531 16 13 16H11V14C11 13.4469 10.5531 13 10 13H4C3.44687 13 3 13.4469 3 14V16H1C0.447812 16 0 15.5531 0 15V14Z" fill="#808080"/>
+<path d="M7.5 2H6.5V0.5C6.5 0.22375 6.725 0 7 0C7.275 0 7.5 0.22375 7.5 0.5V2ZM1.5 4.5V7.5C1.5 7.775 1.27625 8 1 8C0.72375 8 0.5 7.775 0.5 7.5V4.5C0.5 4.225 0.72375 4 1 4C1.27625 4 1.5 4.225 1.5 4.5ZM5.5 16H4.5V14.5C4.5 14.225 4.725 14 5 14C5.275 14 5.5 14.225 5.5 14.5V16ZM7.5 16H6.5V14.5C6.5 14.225 6.725 14 7 14C7.275 14 7.5 14.225 7.5 14.5V16ZM9 14C9.275 14 9.5 14.225 9.5 14.5V16H8.5V14.5C8.5 14.225 8.725 14 9 14ZM13.5 7.5C13.5 7.775 13.275 8 13 8C12.725 8 12.5 7.775 12.5 7.5V4.5C12.5 4.225 12.725 4 13 4C13.275 4 13.5 4.225 13.5 4.5V7.5Z" fill="#808080"/>
+</svg>
--- 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/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"
    }
  },
  {
@@ -190,6 +196,13 @@
      "cmd-alt-enter": "editor::NewlineBelow"
    }
  },
+  {
+    "context": "AssistantEditor > Editor",
+    "bindings": {
+      "cmd-enter": "assistant::Assist",
+      "cmd->": "assistant::QuoteSelection"
+    }
+  },
  {
    "context": "BufferSearchBar",
    "bindings": {
@@ -219,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
@@ -238,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",
@@ -361,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",
@@ -455,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": {
@@ -516,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
@@ -26,6 +26,12 @@
          "replace_newest": false
        }
      ],
+      "ctrl-cmd-g": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": false
+        }
+      ],
      "cmd-/": [
        "editor::ToggleComments",
        {
@@ -68,15 +74,8 @@
      "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,6 +39,9 @@
  // 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,
@@ -43,19 +55,40 @@
  // 3. Draw all invisible symbols:
  //   "all"
  "show_whitespaces": "selection",
-  // Whether 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_scrollbars": "auto",
+  // 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.
@@ -72,19 +105,11 @@
  // 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,
+  // Whether to start a new line with a comment when a previous line is a comment as well.
+  "extend_comment_on_newline": true,
  // Whether or not to ensure there's a single newline at the end of a buffer
  // when saving it.
  "ensure_final_newline_on_save": true,
@@ -93,9 +118,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}"]
@@ -172,6 +197,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
@@ -224,7 +255,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,5 @@
+// Folder-specific settings
+//
+// 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
+{}
--- 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))
                    }
@@ -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)
        });
--- 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/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -159,10 +159,7 @@ impl Bundle {
    fn path(&self) -> &Path {
        match self {
            Self::App { app_bundle, .. } => app_bundle,
-            Self::LocalPath {
-                executable: excutable,
-                ..
-            } => excutable,
+            Self::LocalPath { executable, .. } => executable,
        }
    }

--- 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,25 +1,13 @@
-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::{
-    io::Write,
-    mem,
-    path::PathBuf,
-    sync::Arc,
-    time::{Duration, SystemTime, UNIX_EPOCH},
-};
+use std::{env, io::Write, mem, path::PathBuf, sync::Arc, time::Duration};
 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 +22,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,13 +45,13 @@ 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>,
 }

 #[derive(Serialize, Debug)]
 struct ClickhouseEventWrapper {
-    time: u128,
    signed_in: bool,
    #[serde(flatten)]
    event: ClickhouseEvent,
@@ -93,47 +74,6 @@ pub enum ClickhouseEvent {
    },
 }

-#[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,
-}
-
 #[cfg(debug_assertions)]
 const MAX_QUEUE_LEN: usize = 1;

@@ -154,39 +94,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
    }

@@ -214,20 +140,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();
@@ -246,43 +161,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())
-                            .await?;
-                        anyhow::Ok(())
-                    }
-                    .log_err(),
-                )
-                .detach();
-        }
    }

    pub fn report_clickhouse_event(
@@ -290,23 +179,18 @@ impl Telemetry {
        event: ClickhouseEvent,
        telemetry_settings: TelemetrySettings,
    ) {
-        if !telemetry_settings.metrics() {
+        if !telemetry_settings.metrics {
            return;
        }

        let mut state = self.state.lock();
        let signed_in = state.metrics_id.is_some();
-        state.clickhouse_events_queue.push(ClickhouseEventWrapper {
-            time: SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_millis(),
-            signed_in,
-            event,
-        });
+        state
+            .clickhouse_events_queue
+            .push(ClickhouseEventWrapper { signed_in, event });

        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 {
@@ -320,55 +204,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()
    }
@@ -381,44 +216,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())
-                            .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);
@@ -452,6 +249,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,
                            },
--- 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.12.2"
+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,6 +76,7 @@ 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
 );
@@ -96,22 +97,16 @@ CREATE TABLE "worktree_repositories" (
 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_repository_statuses" (
+CREATE TABLE "worktree_settings_files" (
    "project_id" INTEGER NOT NULL,
    "worktree_id" INTEGER NOT NULL,
-    "work_directory_id" INTEGER NOT NULL,
-    "repo_path" VARCHAR NOT NULL,
-    "status" INTEGER NOT NULL,
-    "scan_id" INTEGER 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
+    "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_repository_statuses_on_project_id" ON "worktree_repository_statuses" ("project_id");
-CREATE INDEX "index_worktree_repository_statuses_on_project_id_and_worktree_id" ON "worktree_repository_statuses" ("project_id", "worktree_id");
-CREATE INDEX "index_worktree_repository_statuses_on_project_id_and_worktree_id_and_work_directory_id" ON "worktree_repository_statuses" ("project_id", "worktree_id", "work_directory_id");
-
+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,
--- 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
@@ -16,6 +16,7 @@ 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};
@@ -1494,6 +1495,7 @@ impl Database {
                        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,
                    };
@@ -1514,6 +1516,7 @@ impl Database {
                        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),
                            )
@@ -1536,6 +1539,7 @@ 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),
                                });
                            }
                        }
@@ -1553,6 +1557,7 @@ impl Database {
                        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),
                            )
@@ -1569,50 +1574,6 @@ impl Database {
                                worktree.updated_repositories.push(proto::RepositoryEntry {
                                    work_directory_id: db_repository.work_directory_id as u64,
                                    branch: db_repository.branch,
-                                    removed_repo_paths: Default::default(),
-                                    updated_statuses: Default::default(),
-                                });
-                            }
-                        }
-                    }
-
-                    // Repository Status Entries
-                    for repository in worktree.updated_repositories.iter_mut() {
-                        let repository_status_entry_filter =
-                            if let Some(rejoined_worktree) = rejoined_worktree {
-                                worktree_repository_statuses::Column::ScanId
-                                    .gt(rejoined_worktree.scan_id)
-                            } else {
-                                worktree_repository_statuses::Column::IsDeleted.eq(false)
-                            };
-
-                        let mut db_repository_statuses =
-                            worktree_repository_statuses::Entity::find()
-                                .filter(
-                                    Condition::all()
-                                        .add(
-                                            worktree_repository_statuses::Column::WorktreeId
-                                                .eq(worktree.id),
-                                        )
-                                        .add(
-                                            worktree_repository_statuses::Column::WorkDirectoryId
-                                                .eq(repository.work_directory_id),
-                                        )
-                                        .add(repository_status_entry_filter),
-                                )
-                                .stream(&*tx)
-                                .await?;
-
-                        while let Some(db_status_entry) = db_repository_statuses.next().await {
-                            let db_status_entry = db_status_entry?;
-                            if db_status_entry.is_deleted {
-                                repository
-                                    .removed_repo_paths
-                                    .push(db_status_entry.repo_path);
-                            } else {
-                                repository.updated_statuses.push(proto::StatusEntry {
-                                    repo_path: db_status_entry.repo_path,
-                                    status: db_status_entry.status as i32,
                                });
                            }
                        }
@@ -1632,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)
@@ -2369,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),
                    }
@@ -2387,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(),
@@ -2440,68 +2422,6 @@ impl Database {
                )
                .exec(&*tx)
                .await?;
-
-                for repository in update.updated_repositories.iter() {
-                    if !repository.updated_statuses.is_empty() {
-                        worktree_repository_statuses::Entity::insert_many(
-                            repository.updated_statuses.iter().map(|status_entry| {
-                                worktree_repository_statuses::ActiveModel {
-                                    project_id: ActiveValue::set(project_id),
-                                    worktree_id: ActiveValue::set(worktree_id),
-                                    work_directory_id: ActiveValue::set(
-                                        repository.work_directory_id as i64,
-                                    ),
-                                    repo_path: ActiveValue::set(status_entry.repo_path.clone()),
-                                    status: ActiveValue::set(status_entry.status as i64),
-                                    scan_id: ActiveValue::set(update.scan_id as i64),
-                                    is_deleted: ActiveValue::set(false),
-                                }
-                            }),
-                        )
-                        .on_conflict(
-                            OnConflict::columns([
-                                worktree_repository_statuses::Column::ProjectId,
-                                worktree_repository_statuses::Column::WorktreeId,
-                                worktree_repository_statuses::Column::WorkDirectoryId,
-                                worktree_repository_statuses::Column::RepoPath,
-                            ])
-                            .update_columns([
-                                worktree_repository_statuses::Column::ScanId,
-                                worktree_repository_statuses::Column::Status,
-                                worktree_repository_statuses::Column::IsDeleted,
-                            ])
-                            .to_owned(),
-                        )
-                        .exec(&*tx)
-                        .await?;
-                    }
-
-                    if !repository.removed_repo_paths.is_empty() {
-                        worktree_repository_statuses::Entity::update_many()
-                            .filter(
-                                worktree_repository_statuses::Column::ProjectId
-                                    .eq(project_id)
-                                    .and(
-                                        worktree_repository_statuses::Column::WorktreeId
-                                            .eq(worktree_id),
-                                    )
-                                    .and(
-                                        worktree_repository_statuses::Column::WorkDirectoryId
-                                            .eq(repository.work_directory_id as i64),
-                                    )
-                                    .and(worktree_repository_statuses::Column::RepoPath.is_in(
-                                        repository.removed_repo_paths.iter().map(String::as_str),
-                                    )),
-                            )
-                            .set(worktree_repository_statuses::ActiveModel {
-                                is_deleted: ActiveValue::Set(true),
-                                scan_id: ActiveValue::Set(update.scan_id as i64),
-                                ..Default::default()
-                            })
-                            .exec(&*tx)
-                            .await?;
-                    }
-                }
            }

            if !update.removed_repositories.is_empty() {
@@ -2631,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,
@@ -2701,6 +2673,7 @@ impl Database {
                            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,
                        },
@@ -2732,6 +2705,7 @@ 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),
                        });
                    }
                }
@@ -2757,41 +2731,12 @@ impl Database {
                            proto::RepositoryEntry {
                                work_directory_id: db_repository_entry.work_directory_id as u64,
                                branch: db_repository_entry.branch,
-                                removed_repo_paths: Default::default(),
-                                updated_statuses: Default::default(),
                            },
                        );
                    }
                }
            }

-            {
-                let mut db_status_entries = worktree_repository_statuses::Entity::find()
-                    .filter(
-                        Condition::all()
-                            .add(worktree_repository_statuses::Column::ProjectId.eq(project_id))
-                            .add(worktree_repository_statuses::Column::IsDeleted.eq(false)),
-                    )
-                    .stream(&*tx)
-                    .await?;
-
-                while let Some(db_status_entry) = db_status_entries.next().await {
-                    let db_status_entry = db_status_entry?;
-                    if let Some(worktree) = worktrees.get_mut(&(db_status_entry.worktree_id as u64))
-                    {
-                        if let Some(repository_entry) = worktree
-                            .repository_entries
-                            .get_mut(&(db_status_entry.work_directory_id as u64))
-                        {
-                            repository_entry.updated_statuses.push(proto::StatusEntry {
-                                repo_path: db_status_entry.repo_path,
-                                status: db_status_entry.status as i32,
-                            });
-                        }
-                    }
-                }
-            }
-
            // Populate worktree diagnostic summaries.
            {
                let mut db_summaries = worktree_diagnostic_summary::Entity::find()
@@ -2813,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)
@@ -3476,6 +3440,7 @@ pub struct RejoinedWorktree {
    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,
 }
@@ -3531,10 +3496,17 @@ pub struct Worktree {
    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_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)
@@ -1081,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 {
@@ -1403,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 {
@@ -1518,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
@@ -19,7 +19,7 @@ use gpui::{
 use language::LanguageRegistry;
 use parking_lot::Mutex;
 use project::{Project, WorktreeId};
-use settings::Settings;
+use settings::SettingsStore;
 use std::{
    cell::{Ref, RefCell, RefMut},
    env,
@@ -30,7 +30,6 @@ use std::{
        Arc,
    },
 };
-use theme::ThemeRegistry;
 use util::http::FakeHttpClient;
 use workspace::Workspace;

@@ -102,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();
@@ -191,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);
        });
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -18,6 +18,7 @@ use gpui::{
 };
 use indoc::indoc;
 use language::{
+    language_settings::{AllLanguageSettings, Formatter},
    tree_sitter_rust, Anchor, Diagnostic, DiagnosticEntry, FakeLspAdapter, Language,
    LanguageConfig, OffsetRangeExt, Point, Rope,
 };
@@ -26,7 +27,7 @@ use lsp::LanguageServerId;
 use project::{search::SearchQuery, DiagnosticSummary, HoverBlockKind, Project, ProjectPath};
 use rand::prelude::*;
 use serde_json::json;
-use settings::{Formatter, Settings};
+use settings::SettingsStore;
 use std::{
    cell::{Cell, RefCell},
    env, future, mem,
@@ -38,7 +39,12 @@ use std::{
    },
 };
 use unindent::Unindent as _;
-use workspace::{item::ItemHandle as _, shared_screen::SharedScreen, SplitDirection, Workspace};
+use workspace::{
+    dock::{test::TestPanel, DockPosition},
+    item::{test::TestItem, ItemHandle as _},
+    shared_screen::SharedScreen,
+    SplitDirection, Workspace,
+};

 #[ctor::ctor]
 fn init_logger() {
@@ -1438,7 +1444,6 @@ async fn test_host_disconnect(
    cx_b: &mut TestAppContext,
    cx_c: &mut TestAppContext,
 ) {
-    cx_b.update(editor::init);
    deterministic.forbid_parking();
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
@@ -1448,6 +1453,8 @@ async fn test_host_disconnect(
        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
        .await;

+    cx_b.update(editor::init);
+
    client_a
        .fs
        .insert_tree(
@@ -1545,7 +1552,6 @@ async fn test_project_reconnect(
    cx_a: &mut TestAppContext,
    cx_b: &mut TestAppContext,
 ) {
-    cx_b.update(editor::init);
    deterministic.forbid_parking();
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
@@ -1554,6 +1560,8 @@ async fn test_project_reconnect(
        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
        .await;

+    cx_b.update(editor::init);
+
    client_a
        .fs
        .insert_tree(
@@ -2412,14 +2420,10 @@ async fn test_git_diff_base_change(
    "
    .unindent();

-    client_a
-        .fs
-        .as_fake()
-        .set_index_for_repo(
-            Path::new("/dir/.git"),
-            &[(Path::new("a.txt"), diff_base.clone())],
-        )
-        .await;
+    client_a.fs.as_fake().set_index_for_repo(
+        Path::new("/dir/.git"),
+        &[(Path::new("a.txt"), diff_base.clone())],
+    );

    // Create the buffer
    let buffer_local_a = project_local
@@ -2461,14 +2465,10 @@ async fn test_git_diff_base_change(
        );
    });

-    client_a
-        .fs
-        .as_fake()
-        .set_index_for_repo(
-            Path::new("/dir/.git"),
-            &[(Path::new("a.txt"), new_diff_base.clone())],
-        )
-        .await;
+    client_a.fs.as_fake().set_index_for_repo(
+        Path::new("/dir/.git"),
+        &[(Path::new("a.txt"), new_diff_base.clone())],
+    );

    // Wait for buffer_local_a to receive it
    deterministic.run_until_parked();
@@ -2510,14 +2510,10 @@ async fn test_git_diff_base_change(
    "
    .unindent();

-    client_a
-        .fs
-        .as_fake()
-        .set_index_for_repo(
-            Path::new("/dir/sub/.git"),
-            &[(Path::new("b.txt"), diff_base.clone())],
-        )
-        .await;
+    client_a.fs.as_fake().set_index_for_repo(
+        Path::new("/dir/sub/.git"),
+        &[(Path::new("b.txt"), diff_base.clone())],
+    );

    // Create the buffer
    let buffer_local_b = project_local
@@ -2559,14 +2555,10 @@ async fn test_git_diff_base_change(
        );
    });

-    client_a
-        .fs
-        .as_fake()
-        .set_index_for_repo(
-            Path::new("/dir/sub/.git"),
-            &[(Path::new("b.txt"), new_diff_base.clone())],
-        )
-        .await;
+    client_a.fs.as_fake().set_index_for_repo(
+        Path::new("/dir/sub/.git"),
+        &[(Path::new("b.txt"), new_diff_base.clone())],
+    );

    // Wait for buffer_local_b to receive it
    deterministic.run_until_parked();
@@ -2643,8 +2635,7 @@ async fn test_git_branch_name(
    client_a
        .fs
        .as_fake()
-        .set_branch_name(Path::new("/dir/.git"), Some("branch-1"))
-        .await;
+        .set_branch_name(Path::new("/dir/.git"), Some("branch-1"));

    // Wait for it to catch up to the new branch
    deterministic.run_until_parked();
@@ -2670,8 +2661,7 @@ async fn test_git_branch_name(
    client_a
        .fs
        .as_fake()
-        .set_branch_name(Path::new("/dir/.git"), Some("branch-2"))
-        .await;
+        .set_branch_name(Path::new("/dir/.git"), Some("branch-2"));

    // Wait for buffer_local_a to receive it
    deterministic.run_until_parked();
@@ -2685,6 +2675,7 @@ async fn test_git_branch_name(
    });

    let project_remote_c = client_c.build_remote_project(project_id, cx_c).await;
+    deterministic.run_until_parked();
    project_remote_c.read_with(cx_c, |project, cx| {
        assert_branch(Some("branch-2"), project, cx)
    });
@@ -2722,17 +2713,13 @@ async fn test_git_status_sync(
    const A_TXT: &'static str = "a.txt";
    const B_TXT: &'static str = "b.txt";

-    client_a
-        .fs
-        .as_fake()
-        .set_status_for_repo(
-            Path::new("/dir/.git"),
-            &[
-                (&Path::new(A_TXT), GitFileStatus::Added),
-                (&Path::new(B_TXT), GitFileStatus::Added),
-            ],
-        )
-        .await;
+    client_a.fs.as_fake().set_status_for_repo_via_git_operation(
+        Path::new("/dir/.git"),
+        &[
+            (&Path::new(A_TXT), GitFileStatus::Added),
+            (&Path::new(B_TXT), GitFileStatus::Added),
+        ],
+    );

    let (project_local, _worktree_id) = client_a.build_local_project("/dir", cx_a).await;
    let project_id = active_call_a
@@ -2759,8 +2746,7 @@ async fn test_git_status_sync(
        assert_eq!(worktrees.len(), 1);
        let worktree = worktrees[0].clone();
        let snapshot = worktree.read(cx).snapshot();
-        let root_entry = snapshot.root_git_entry().unwrap();
-        assert_eq!(root_entry.status_for_file(&snapshot, file), status);
+        assert_eq!(snapshot.status_for_file(file), status);
    }

    // Smoke test status reading
@@ -2776,14 +2762,13 @@ async fn test_git_status_sync(
    client_a
        .fs
        .as_fake()
-        .set_status_for_repo(
+        .set_status_for_repo_via_working_copy_change(
            Path::new("/dir/.git"),
            &[
                (&Path::new(A_TXT), GitFileStatus::Modified),
                (&Path::new(B_TXT), GitFileStatus::Modified),
            ],
-        )
-        .await;
+        );

    // Wait for buffer_local_a to receive it
    deterministic.run_until_parked();
@@ -3110,6 +3095,135 @@ async fn test_fs_operations(
    });
 }

+#[gpui::test(iterations = 10)]
+async fn test_local_settings(
+    deterministic: Arc<Deterministic>,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+) {
+    deterministic.forbid_parking();
+    let mut server = TestServer::start(&deterministic).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+    let active_call_a = cx_a.read(ActiveCall::global);
+
+    // As client A, open a project that contains some local settings files
+    client_a
+        .fs
+        .insert_tree(
+            "/dir",
+            json!({
+                ".zed": {
+                    "settings.json": r#"{ "tab_size": 2 }"#
+                },
+                "a": {
+                    ".zed": {
+                        "settings.json": r#"{ "tab_size": 8 }"#
+                    },
+                    "a.txt": "a-contents",
+                },
+                "b": {
+                    "b.txt": "b-contents",
+                }
+            }),
+        )
+        .await;
+    let (project_a, _) = client_a.build_local_project("/dir", cx_a).await;
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+
+    // As client B, join that project and observe the local settings.
+    let project_b = client_b.build_remote_project(project_id, cx_b).await;
+    let worktree_b = project_b.read_with(cx_b, |project, cx| project.worktrees(cx).next().unwrap());
+    deterministic.run_until_parked();
+    cx_b.read(|cx| {
+        let store = cx.global::<SettingsStore>();
+        assert_eq!(
+            store.local_settings(worktree_b.id()).collect::<Vec<_>>(),
+            &[
+                (Path::new("").into(), r#"{"tab_size":2}"#.to_string()),
+                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
+            ]
+        )
+    });
+
+    // As client A, update a settings file. As Client B, see the changed settings.
+    client_a
+        .fs
+        .insert_file("/dir/.zed/settings.json", r#"{}"#.into())
+        .await;
+    deterministic.run_until_parked();
+    cx_b.read(|cx| {
+        let store = cx.global::<SettingsStore>();
+        assert_eq!(
+            store.local_settings(worktree_b.id()).collect::<Vec<_>>(),
+            &[
+                (Path::new("").into(), r#"{}"#.to_string()),
+                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
+            ]
+        )
+    });
+
+    // As client A, create and remove some settings files. As client B, see the changed settings.
+    client_a
+        .fs
+        .remove_file("/dir/.zed/settings.json".as_ref(), Default::default())
+        .await
+        .unwrap();
+    client_a
+        .fs
+        .create_dir("/dir/b/.zed".as_ref())
+        .await
+        .unwrap();
+    client_a
+        .fs
+        .insert_file("/dir/b/.zed/settings.json", r#"{"tab_size": 4}"#.into())
+        .await;
+    deterministic.run_until_parked();
+    cx_b.read(|cx| {
+        let store = cx.global::<SettingsStore>();
+        assert_eq!(
+            store.local_settings(worktree_b.id()).collect::<Vec<_>>(),
+            &[
+                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
+                (Path::new("b").into(), r#"{"tab_size":4}"#.to_string()),
+            ]
+        )
+    });
+
+    // As client B, disconnect.
+    server.forbid_connections();
+    server.disconnect_client(client_b.peer_id().unwrap());
+
+    // As client A, change and remove settings files while client B is disconnected.
+    client_a
+        .fs
+        .insert_file("/dir/a/.zed/settings.json", r#"{"hard_tabs":true}"#.into())
+        .await;
+    client_a
+        .fs
+        .remove_file("/dir/b/.zed/settings.json".as_ref(), Default::default())
+        .await
+        .unwrap();
+    deterministic.run_until_parked();
+
+    // As client B, reconnect and see the changed settings.
+    server.allow_connections();
+    deterministic.advance_clock(RECEIVE_TIMEOUT);
+    cx_b.read(|cx| {
+        let store = cx.global::<SettingsStore>();
+        assert_eq!(
+            store.local_settings(worktree_b.id()).collect::<Vec<_>>(),
+            &[(Path::new("a").into(), r#"{"hard_tabs":true}"#.to_string()),]
+        )
+    });
+}
+
 #[gpui::test(iterations = 10)]
 async fn test_buffer_conflict_after_save(
    deterministic: Arc<Deterministic>,
@@ -4367,10 +4481,12 @@ async fn test_formatting_buffer(
    // Ensure buffer can be formatted using an external command. Notice how the
    // host's configuration is honored as opposed to using the guest's settings.
    cx_a.update(|cx| {
-        cx.update_global(|settings: &mut Settings, _| {
-            settings.editor_defaults.formatter = Some(Formatter::External {
-                command: "awk".to_string(),
-                arguments: vec!["{sub(/two/,\"{buffer_path}\")}1".to_string()],
+        cx.update_global(|store: &mut SettingsStore, cx| {
+            store.update_user_settings::<AllLanguageSettings>(cx, |file| {
+                file.defaults.formatter = Some(Formatter::External {
+                    command: "awk".into(),
+                    arguments: vec!["{sub(/two/,\"{buffer_path}\")}1".to_string()].into(),
+                });
            });
        });
    });
@@ -5004,19 +5120,21 @@ async fn test_project_symbols(
        .unwrap();

    let fake_language_server = fake_language_servers.next().await.unwrap();
-    fake_language_server.handle_request::<lsp::request::WorkspaceSymbol, _, _>(|_, _| async move {
-        #[allow(deprecated)]
-        Ok(Some(vec![lsp::SymbolInformation {
-            name: "TWO".into(),
-            location: lsp::Location {
-                uri: lsp::Url::from_file_path("/code/crate-2/two.rs").unwrap(),
-                range: lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
+    fake_language_server.handle_request::<lsp::WorkspaceSymbolRequest, _, _>(|_, _| async move {
+        Ok(Some(lsp::WorkspaceSymbolResponse::Flat(vec![
+            #[allow(deprecated)]
+            lsp::SymbolInformation {
+                name: "TWO".into(),
+                location: lsp::Location {
+                    uri: lsp::Url::from_file_path("/code/crate-2/two.rs").unwrap(),
+                    range: lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
+                },
+                kind: lsp::SymbolKind::CONSTANT,
+                tags: None,
+                container_name: None,
+                deprecated: None,
            },
-            kind: lsp::SymbolKind::CONSTANT,
-            tags: None,
-            container_name: None,
-            deprecated: None,
-        }]))
+        ])))
    });

    // Request the definition of a symbol as the guest.
@@ -5137,7 +5255,6 @@ async fn test_collaborating_with_code_actions(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    cx_b.update(editor::init);
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -5146,6 +5263,8 @@ async fn test_collaborating_with_code_actions(
        .await;
    let active_call_a = cx_a.read(ActiveCall::global);

+    cx_b.update(editor::init);
+
    // Set up a fake language server.
    let mut language = Language::new(
        LanguageConfig {
@@ -5350,7 +5469,6 @@ async fn test_collaborating_with_renames(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    cx_b.update(editor::init);
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -5359,6 +5477,8 @@ async fn test_collaborating_with_renames(
        .await;
    let active_call_a = cx_a.read(ActiveCall::global);

+    cx_b.update(editor::init);
+
    // Set up a fake language server.
    let mut language = Language::new(
        LanguageConfig {
@@ -5540,8 +5660,6 @@ async fn test_language_server_statuses(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-
-    cx_b.update(editor::init);
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -5550,6 +5668,8 @@ async fn test_language_server_statuses(
        .await;
    let active_call_a = cx_a.read(ActiveCall::global);

+    cx_b.update(editor::init);
+
    // Set up a fake language server.
    let mut language = Language::new(
        LanguageConfig {
@@ -6257,8 +6377,6 @@ async fn test_basic_following(
    cx_d: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    cx_a.update(editor::init);
-    cx_b.update(editor::init);

    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
@@ -6276,6 +6394,9 @@ async fn test_basic_following(
    let active_call_a = cx_a.read(ActiveCall::global);
    let active_call_b = cx_b.read(ActiveCall::global);

+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+
    client_a
        .fs
        .insert_tree(
@@ -6597,7 +6718,7 @@ async fn test_basic_following(
    // When client A navigates back and forth, client B does so as well.
    workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace::Pane::go_back(workspace, None, cx)
+            workspace.go_back(workspace.active_pane().downgrade(), cx)
        })
        .await
        .unwrap();
@@ -6608,7 +6729,7 @@ async fn test_basic_following(

    workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace::Pane::go_back(workspace, None, cx)
+            workspace.go_back(workspace.active_pane().downgrade(), cx)
        })
        .await
        .unwrap();
@@ -6619,7 +6740,7 @@ async fn test_basic_following(

    workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace::Pane::go_forward(workspace, None, cx)
+            workspace.go_forward(workspace.active_pane().downgrade(), cx)
        })
        .await
        .unwrap();
@@ -6731,12 +6852,43 @@ async fn test_basic_following(
        )
    });

-    // Client B activates an external window again, and the previously-opened screen-sharing item
-    // gets activated.
-    active_call_b
-        .update(cx_b, |call, cx| call.set_location(None, cx))
-        .await
-        .unwrap();
+    // Client B activates a panel, and the previously-opened screen-sharing item gets activated.
+    let panel = cx_b.add_view(workspace_b.window_id(), |_| {
+        TestPanel::new(DockPosition::Left)
+    });
+    workspace_b.update(cx_b, |workspace, cx| {
+        workspace.add_panel(panel, cx);
+        workspace.toggle_panel_focus::<TestPanel>(cx);
+    });
+    deterministic.run_until_parked();
+    assert_eq!(
+        workspace_a.read_with(cx_a, |workspace, cx| workspace
+            .active_item(cx)
+            .unwrap()
+            .id()),
+        shared_screen.id()
+    );
+
+    // Toggling the focus back to the pane causes client A to return to the multibuffer.
+    workspace_b.update(cx_b, |workspace, cx| {
+        workspace.toggle_panel_focus::<TestPanel>(cx);
+    });
+    deterministic.run_until_parked();
+    workspace_a.read_with(cx_a, |workspace, cx| {
+        assert_eq!(
+            workspace.active_item(cx).unwrap().id(),
+            multibuffer_editor_a.id()
+        )
+    });
+
+    // Client B activates an item that doesn't implement following,
+    // so the previously-opened screen-sharing item gets activated.
+    let unfollowable_item = cx_b.add_view(workspace_b.window_id(), |_| TestItem::new());
+    workspace_b.update(cx_b, |workspace, cx| {
+        workspace.active_pane().update(cx, |pane, cx| {
+            pane.add_item(Box::new(unfollowable_item), true, true, None, cx)
+        })
+    });
    deterministic.run_until_parked();
    assert_eq!(
        workspace_a.read_with(cx_a, |workspace, cx| workspace
@@ -6854,9 +7006,6 @@ async fn test_following_tab_order(
    cx_a: &mut TestAppContext,
    cx_b: &mut TestAppContext,
 ) {
-    cx_a.update(editor::init);
-    cx_b.update(editor::init);
-
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -6866,6 +7015,9 @@ async fn test_following_tab_order(
    let active_call_a = cx_a.read(ActiveCall::global);
    let active_call_b = cx_b.read(ActiveCall::global);

+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+
    client_a
        .fs
        .insert_tree(
@@ -6976,9 +7128,6 @@ async fn test_peers_following_each_other(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    cx_a.update(editor::init);
-    cx_b.update(editor::init);
-
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -6988,6 +7137,9 @@ async fn test_peers_following_each_other(
    let active_call_a = cx_a.read(ActiveCall::global);
    let active_call_b = cx_b.read(ActiveCall::global);

+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+
    // Client A shares a project.
    client_a
        .fs
@@ -7147,8 +7299,6 @@ async fn test_auto_unfollowing(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    cx_a.update(editor::init);
-    cx_b.update(editor::init);

    // 2 clients connect to a server.
    let mut server = TestServer::start(&deterministic).await;
@@ -7160,6 +7310,9 @@ async fn test_auto_unfollowing(
    let active_call_a = cx_a.read(ActiveCall::global);
    let active_call_b = cx_b.read(ActiveCall::global);

+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+
    // Client A shares a project.
    client_a
        .fs
@@ -7314,8 +7467,6 @@ async fn test_peers_simultaneously_following_each_other(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    cx_a.update(editor::init);
-    cx_b.update(editor::init);

    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
@@ -7325,6 +7476,9 @@ async fn test_peers_simultaneously_following_each_other(
        .await;
    let active_call_a = cx_a.read(ActiveCall::global);

+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+
    client_a.fs.insert_tree("/a", json!({})).await;
    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
    let workspace_a = client_a.build_workspace(&project_a, cx_a);
@@ -7366,6 +7520,265 @@ async fn test_peers_simultaneously_following_each_other(
    });
 }

+#[gpui::test(iterations = 10)]
+async fn test_on_input_format_from_host_to_guest(
+    deterministic: Arc<Deterministic>,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+) {
+    deterministic.forbid_parking();
+    let mut server = TestServer::start(&deterministic).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+    let active_call_a = cx_a.read(ActiveCall::global);
+
+    // Set up a fake language server.
+    let mut language = Language::new(
+        LanguageConfig {
+            name: "Rust".into(),
+            path_suffixes: vec!["rs".to_string()],
+            ..Default::default()
+        },
+        Some(tree_sitter_rust::language()),
+    );
+    let mut fake_language_servers = language
+        .set_fake_lsp_adapter(Arc::new(FakeLspAdapter {
+            capabilities: lsp::ServerCapabilities {
+                document_on_type_formatting_provider: Some(lsp::DocumentOnTypeFormattingOptions {
+                    first_trigger_character: ":".to_string(),
+                    more_trigger_character: Some(vec![">".to_string()]),
+                }),
+                ..Default::default()
+            },
+            ..Default::default()
+        }))
+        .await;
+    client_a.language_registry.add(Arc::new(language));
+
+    client_a
+        .fs
+        .insert_tree(
+            "/a",
+            json!({
+                "main.rs": "fn main() { a }",
+                "other.rs": "// Test file",
+            }),
+        )
+        .await;
+    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+    let project_b = client_b.build_remote_project(project_id, cx_b).await;
+
+    // Open a file in an editor as the host.
+    let buffer_a = project_a
+        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx))
+        .await
+        .unwrap();
+    let (window_a, _) = cx_a.add_window(|_| EmptyView);
+    let editor_a = cx_a.add_view(window_a, |cx| {
+        Editor::for_buffer(buffer_a, Some(project_a.clone()), cx)
+    });
+
+    let fake_language_server = fake_language_servers.next().await.unwrap();
+    cx_b.foreground().run_until_parked();
+
+    // Receive an OnTypeFormatting request as the host's language server.
+    // Return some formattings from the host's language server.
+    fake_language_server.handle_request::<lsp::request::OnTypeFormatting, _, _>(
+        |params, _| async move {
+            assert_eq!(
+                params.text_document_position.text_document.uri,
+                lsp::Url::from_file_path("/a/main.rs").unwrap(),
+            );
+            assert_eq!(
+                params.text_document_position.position,
+                lsp::Position::new(0, 14),
+            );
+
+            Ok(Some(vec![lsp::TextEdit {
+                new_text: "~<".to_string(),
+                range: lsp::Range::new(lsp::Position::new(0, 14), lsp::Position::new(0, 14)),
+            }]))
+        },
+    );
+
+    // Open the buffer on the guest and see that the formattings worked
+    let buffer_b = project_b
+        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx))
+        .await
+        .unwrap();
+
+    // Type a on type formatting trigger character as the guest.
+    editor_a.update(cx_a, |editor, cx| {
+        cx.focus(&editor_a);
+        editor.change_selections(None, cx, |s| s.select_ranges([13..13]));
+        editor.handle_input(">", cx);
+    });
+
+    cx_b.foreground().run_until_parked();
+
+    buffer_b.read_with(cx_b, |buffer, _| {
+        assert_eq!(buffer.text(), "fn main() { a>~< }")
+    });
+
+    // Undo should remove LSP edits first
+    editor_a.update(cx_a, |editor, cx| {
+        assert_eq!(editor.text(cx), "fn main() { a>~< }");
+        editor.undo(&Undo, cx);
+        assert_eq!(editor.text(cx), "fn main() { a> }");
+    });
+    cx_b.foreground().run_until_parked();
+    buffer_b.read_with(cx_b, |buffer, _| {
+        assert_eq!(buffer.text(), "fn main() { a> }")
+    });
+
+    editor_a.update(cx_a, |editor, cx| {
+        assert_eq!(editor.text(cx), "fn main() { a> }");
+        editor.undo(&Undo, cx);
+        assert_eq!(editor.text(cx), "fn main() { a }");
+    });
+    cx_b.foreground().run_until_parked();
+    buffer_b.read_with(cx_b, |buffer, _| {
+        assert_eq!(buffer.text(), "fn main() { a }")
+    });
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_on_input_format_from_guest_to_host(
+    deterministic: Arc<Deterministic>,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+) {
+    deterministic.forbid_parking();
+    let mut server = TestServer::start(&deterministic).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+    let active_call_a = cx_a.read(ActiveCall::global);
+
+    // Set up a fake language server.
+    let mut language = Language::new(
+        LanguageConfig {
+            name: "Rust".into(),
+            path_suffixes: vec!["rs".to_string()],
+            ..Default::default()
+        },
+        Some(tree_sitter_rust::language()),
+    );
+    let mut fake_language_servers = language
+        .set_fake_lsp_adapter(Arc::new(FakeLspAdapter {
+            capabilities: lsp::ServerCapabilities {
+                document_on_type_formatting_provider: Some(lsp::DocumentOnTypeFormattingOptions {
+                    first_trigger_character: ":".to_string(),
+                    more_trigger_character: Some(vec![">".to_string()]),
+                }),
+                ..Default::default()
+            },
+            ..Default::default()
+        }))
+        .await;
+    client_a.language_registry.add(Arc::new(language));
+
+    client_a
+        .fs
+        .insert_tree(
+            "/a",
+            json!({
+                "main.rs": "fn main() { a }",
+                "other.rs": "// Test file",
+            }),
+        )
+        .await;
+    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+    let project_b = client_b.build_remote_project(project_id, cx_b).await;
+
+    // Open a file in an editor as the guest.
+    let buffer_b = project_b
+        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx))
+        .await
+        .unwrap();
+    let (window_b, _) = cx_b.add_window(|_| EmptyView);
+    let editor_b = cx_b.add_view(window_b, |cx| {
+        Editor::for_buffer(buffer_b, Some(project_b.clone()), cx)
+    });
+
+    let fake_language_server = fake_language_servers.next().await.unwrap();
+    cx_a.foreground().run_until_parked();
+    // Type a on type formatting trigger character as the guest.
+    editor_b.update(cx_b, |editor, cx| {
+        editor.change_selections(None, cx, |s| s.select_ranges([13..13]));
+        editor.handle_input(":", cx);
+        cx.focus(&editor_b);
+    });
+
+    // Receive an OnTypeFormatting request as the host's language server.
+    // Return some formattings from the host's language server.
+    cx_a.foreground().start_waiting();
+    fake_language_server
+        .handle_request::<lsp::request::OnTypeFormatting, _, _>(|params, _| async move {
+            assert_eq!(
+                params.text_document_position.text_document.uri,
+                lsp::Url::from_file_path("/a/main.rs").unwrap(),
+            );
+            assert_eq!(
+                params.text_document_position.position,
+                lsp::Position::new(0, 14),
+            );
+
+            Ok(Some(vec![lsp::TextEdit {
+                new_text: "~:".to_string(),
+                range: lsp::Range::new(lsp::Position::new(0, 14), lsp::Position::new(0, 14)),
+            }]))
+        })
+        .next()
+        .await
+        .unwrap();
+    cx_a.foreground().finish_waiting();
+
+    // Open the buffer on the host and see that the formattings worked
+    let buffer_a = project_a
+        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx))
+        .await
+        .unwrap();
+    cx_a.foreground().run_until_parked();
+    buffer_a.read_with(cx_a, |buffer, _| {
+        assert_eq!(buffer.text(), "fn main() { a:~: }")
+    });
+
+    // Undo should remove LSP edits first
+    editor_b.update(cx_b, |editor, cx| {
+        assert_eq!(editor.text(cx), "fn main() { a:~: }");
+        editor.undo(&Undo, cx);
+        assert_eq!(editor.text(cx), "fn main() { a: }");
+    });
+    cx_a.foreground().run_until_parked();
+    buffer_a.read_with(cx_a, |buffer, _| {
+        assert_eq!(buffer.text(), "fn main() { a: }")
+    });
+
+    editor_b.update(cx_b, |editor, cx| {
+        assert_eq!(editor.text(cx), "fn main() { a: }");
+        editor.undo(&Undo, cx);
+        assert_eq!(editor.text(cx), "fn main() { a }");
+    });
+    cx_a.foreground().run_until_parked();
+    buffer_a.read_with(cx_a, |buffer, _| {
+        assert_eq!(buffer.text(), "fn main() { a }")
+    });
+}
+
 #[derive(Debug, Eq, PartialEq)]
 struct RoomParticipants {
    remote: Vec<String>,
--- a/crates/collab/src/tests/randomized_integration_tests.rs
+++ b/crates/collab/src/tests/randomized_integration_tests.rs
@@ -21,7 +21,7 @@ use rand::{
    prelude::*,
 };
 use serde::{Deserialize, Serialize};
-use settings::Settings;
+use settings::SettingsStore;
 use std::{
    env,
    ops::Range,
@@ -149,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);
        });
    }
@@ -421,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
@@ -627,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 {
@@ -742,7 +744,7 @@ async fn apply_client_operation(
        } => {
            if !client
                .fs
-                .directories()
+                .directories(false)
                .contains(&path.parent().unwrap().to_owned())
            {
                return Err(TestError::Inapplicable);
@@ -769,10 +771,16 @@ async fn apply_client_operation(
                repo_path,
                contents,
            } => {
-                if !client.fs.directories().contains(&repo_path) {
+                if !client.fs.directories(false).contains(&repo_path) {
                    return Err(TestError::Inapplicable);
                }

+                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,
@@ -788,13 +796,13 @@ async fn apply_client_operation(
                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).await;
+                client.fs.set_index_for_repo(&dot_git_dir, &contents);
            }
            GitOperation::WriteGitBranch {
                repo_path,
                new_branch,
            } => {
-                if !client.fs.directories().contains(&repo_path) {
+                if !client.fs.directories(false).contains(&repo_path) {
                    return Err(TestError::Inapplicable);
                }

@@ -809,15 +817,21 @@ async fn apply_client_operation(
                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).await;
+                client.fs.set_branch_name(&dot_git_dir, new_branch);
            }
            GitOperation::WriteGitStatuses {
                repo_path,
                statuses,
+                git_operation,
            } => {
-                if !client.fs.directories().contains(&repo_path) {
+                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 {:?}: {:?}",
@@ -837,10 +851,16 @@ async fn apply_client_operation(
                    client.fs.create_dir(&dot_git_dir).await?;
                }

-                client
-                    .fs
-                    .set_status_for_repo(&dot_git_dir, statuses.as_slice())
-                    .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(),
+                    );
+                }
            }
        },
    }
@@ -912,9 +932,10 @@ 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<_>>(),
@@ -1229,6 +1250,7 @@ enum GitOperation {
    WriteGitStatuses {
        repo_path: PathBuf,
        statuses: Vec<(PathBuf, GitFileStatus)>,
+        git_operation: bool,
    },
 }

@@ -1574,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))
@@ -1754,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();
@@ -1808,7 +1830,7 @@ impl TestPlan {

        let repo_path = client
            .fs
-            .directories()
+            .directories(false)
            .choose(&mut self.rng)
            .unwrap()
            .clone();
@@ -1854,9 +1876,12 @@ impl TestPlan {
                    })
                    .collect::<Vec<_>>();

+                let git_operation = self.rng.gen::<bool>();
+
                GitOperation::WriteGitStatuses {
                    repo_path,
                    statuses,
+                    git_operation,
                }
            }
            _ => unreachable!(),
--- a/crates/collab_ui/src/collab_titlebar_item.rs
+++ b/crates/collab_ui/src/collab_titlebar_item.rs
@@ -18,7 +18,6 @@ use gpui::{
    ViewContext, ViewHandle, WeakViewHandle,
 };
 use project::Project;
-use settings::Settings;
 use std::{ops::Range, sync::Arc};
 use theme::{AvatarStyle, Theme};
 use util::ResultExt;
@@ -70,7 +69,7 @@ impl View for CollabTitlebarItem {
        };

        let project = self.project.read(cx);
-        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();

@@ -298,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| {
@@ -473,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()
@@ -866,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
--- 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();

@@ -1313,7 +1312,7 @@ impl View for ContactList {

    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/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
@@ -5,7 +5,6 @@ use gpui::{
    ViewContext,
 };
 use picker::{Picker, PickerDelegate, PickerEvent};
-use settings::Settings;
 use std::cmp;
 use util::ResultExt;
 use workspace::Workspace;
@@ -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,14 +292,7 @@ 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 (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
@@ -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) {
@@ -323,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)| {
@@ -403,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()
--- 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,
@@ -126,7 +127,7 @@ impl CopilotServer {
 struct RunningCopilotServer {
    lsp: Arc<LanguageServer>,
    sign_in_status: SignInStatus,
-    registered_buffers: HashMap<u64, RegisteredBuffer>,
+    registered_buffers: HashMap<usize, RegisteredBuffer>,
 }

 #[derive(Clone, Debug)]
@@ -162,7 +163,6 @@ impl Status {
 }

 struct RegisteredBuffer {
-    id: u64,
    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 {
@@ -267,7 +267,7 @@ pub struct Copilot {
    http: Arc<dyn HttpClient>,
    node_runtime: Arc<NodeRuntime>,
    server: CopilotServer,
-    buffers: HashMap<u64, 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),
@@ -580,8 +558,8 @@ impl Copilot {
    }

    pub fn register_buffer(&mut self, buffer: &ModelHandle<Buffer>, cx: &mut ModelContext<Self>) {
-        let buffer_id = buffer.read(cx).remote_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,
@@ -594,8 +572,7 @@ impl Copilot {
                return;
            }

-            let buffer_id = buffer.read(cx).remote_id();
-            registered_buffers.entry(buffer_id).or_insert_with(|| {
+            registered_buffers.entry(buffer.id()).or_insert_with(|| {
                let uri: lsp::Url = uri_for_buffer(buffer, cx);
                let language_id = id_for_language(buffer.read(cx).language());
                let snapshot = buffer.read(cx).snapshot();
@@ -613,7 +590,6 @@ impl Copilot {
                    .log_err();

                RegisteredBuffer {
-                    id: buffer_id,
                    uri,
                    language_id,
                    snapshot,
@@ -624,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);
                        }),
                    ],
                }
@@ -640,8 +616,7 @@ impl Copilot {
        cx: &mut ModelContext<Self>,
    ) -> Result<()> {
        if let Ok(server) = self.server.as_running() {
-            let buffer_id = buffer.read(cx).remote_id();
-            if let Some(registered_buffer) = server.registered_buffers.get_mut(&buffer_id) {
+            if let Some(registered_buffer) = server.registered_buffers.get_mut(&buffer.id()) {
                match event {
                    language::Event::Edited => {
                        let _ = registered_buffer.report_changes(&buffer, cx);
@@ -695,9 +670,9 @@ impl Copilot {
        Ok(())
    }

-    fn unregister_buffer(&mut self, buffer_id: u64) {
+    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>(
@@ -800,18 +775,14 @@ impl Copilot {
            Err(error) => return Task::ready(Err(error)),
        };
        let lsp = server.lsp.clone();
-        let buffer_id = buffer.read(cx).remote_id();
-        let registered_buffer = server.registered_buffers.get_mut(&buffer_id).unwrap();
+        let registered_buffer = server.registered_buffers.get_mut(&buffer.id()).unwrap();
        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())
@@ -874,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 {
@@ -882,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);
                        }
@@ -890,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);
                    }
                }
            }
@@ -920,9 +891,7 @@ fn uri_for_buffer(buffer: &ModelHandle<Buffer>, cx: &AppContext) -> lsp::Url {
    if let Some(file) = buffer.read(cx).file().and_then(|file| file.as_local()) {
        lsp::Url::from_file_path(file.abs_path(cx)).unwrap()
    } else {
-        format!("buffer://{}", buffer.read(cx).remote_id())
-            .parse()
-            .unwrap()
+        format!("buffer://{}", buffer.id()).parse().unwrap()
    }
 }

@@ -1196,6 +1165,10 @@ mod tests {
        fn to_proto(&self) -> rpc::proto::File {
            unimplemented!()
        }
+
+        fn worktree_id(&self) -> usize {
+            0
+        }
    }

    impl language::LocalFile for File {
--- 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,7 +148,7 @@ 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(button_view_id, cx);
@@ -155,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 {
@@ -163,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| {
@@ -188,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",
@@ -228,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()
@@ -266,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()
    }
@@ -310,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?
@@ -322,14 +325,16 @@ 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
                    .iter()
-                    .map(|glob| glob.as_str().to_string())
+                    .map(|glob| glob.glob().to_string())
                    .collect()
            });

@@ -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
@@ -421,7 +430,7 @@ impl ProjectDiagnosticsEditor {
        });

        self.editor.update(cx, |editor, cx| {
-            editor.remove_blocks(blocks_to_remove, cx);
+            editor.remove_blocks(blocks_to_remove, None, cx);
            let block_ids = editor.insert_blocks(
                blocks_to_add.into_iter().map(|block| {
                    let (excerpt_id, text_anchor) = block.position;
@@ -433,6 +442,7 @@ impl ProjectDiagnosticsEditor {
                        disposition: block.disposition,
                    }
                }),
+                Some(Autoscroll::fit()),
                cx,
            );

@@ -537,7 +547,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 +610,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 +680,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 +819,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(),
            }),
        )
@@ -1225,7 +1228,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",
@@ -1489,6 +1493,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/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,10 +81,9 @@ 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"
+tree-sitter.workspace = true
 tree-sitter-rust = "0.20"
 tree-sitter-html = "0.19"
 tree-sitter-typescript = { git = "https://github.com/tree-sitter/tree-sitter-typescript", rev = "5d20856f34315b068c41edaee2ac8a100081d259" }
--- 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
@@ -993,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;

@@ -1013,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()
@@ -1189,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()
@@ -1239,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"))
@@ -1647,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
@@ -1204,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;
@@ -1213,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);
@@ -1286,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);
@@ -1349,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);
@@ -1400,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);
@@ -1676,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
@@ -578,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},
@@ -631,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);
@@ -834,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/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
@@ -5,6 +5,7 @@ use super::{
 };
 use crate::{
    display_map::{BlockStyle, DisplaySnapshot, FoldStatus, TransformBlock},
+    editor_settings::ShowScrollbar,
    git::{diff_hunk_to_display, DisplayDiffHunk},
    hover_popover::{
        hide_hover, hover_at, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH,
@@ -13,7 +14,7 @@ use crate::{
    link_go_to_definition::{
        go_to_fetched_definition, go_to_fetched_type_definition, update_go_to_definition_link,
    },
-    mouse_context_menu, EditorStyle, GutterHover, UnfoldAt,
+    mouse_context_menu, EditorSettings, EditorStyle, GutterHover, UnfoldAt,
 };
 use clock::ReplicaId;
 use collections::{BTreeMap, HashMap};
@@ -35,9 +36,14 @@ use gpui::{
 };
 use itertools::Itertools;
 use json::json;
-use language::{Bias, CursorShape, DiagnosticSeverity, OffsetUtf16, Selection};
-use project::ProjectPath;
-use settings::{GitGutter, Settings, ShowWhitespaces};
+use language::{
+    language_settings::ShowWhitespaceSetting, Bias, CursorShape, DiagnosticSeverity, OffsetUtf16,
+    Selection,
+};
+use project::{
+    project_settings::{GitGutterSetting, ProjectSettings},
+    ProjectPath,
+};
 use smallvec::SmallVec;
 use std::{
    borrow::Cow,
@@ -85,7 +91,6 @@ impl SelectionLayout {
    }
 }

-#[derive(Clone)]
 pub struct EditorElement {
    style: Arc<EditorStyle>,
 }
@@ -548,11 +553,8 @@ impl EditorElement {
        let scroll_top = scroll_position.y() * line_height;

        let show_gutter = matches!(
-            &cx.global::<Settings>()
-                .git_overrides
-                .git_gutter
-                .unwrap_or_default(),
-            GitGutter::TrackedFiles
+            settings::get::<ProjectSettings>(cx).git.git_gutter,
+            Some(GitGutterSetting::TrackedFiles)
        );

        if show_gutter {
@@ -609,7 +611,7 @@ impl EditorElement {
        layout: &mut LayoutState,
        cx: &mut ViewContext<Editor>,
    ) {
-        let diff_style = &cx.global::<Settings>().theme.editor.diff.clone();
+        let diff_style = &theme::current(cx).editor.diff.clone();
        let line_height = layout.position_map.line_height;

        let scroll_position = layout.position_map.snapshot.scroll_position();
@@ -709,6 +711,7 @@ impl EditorElement {
        let scroll_left = scroll_position.x() * max_glyph_width;
        let content_origin = bounds.origin() + vec2f(layout.gutter_margin, 0.);
        let line_end_overshoot = 0.15 * layout.position_map.line_height;
+        let whitespace_setting = editor.buffer.read(cx).settings_at(0, cx).show_whitespaces;

        scene.push_layer(Some(bounds));

@@ -883,9 +886,10 @@ impl EditorElement {
                    content_origin,
                    scroll_left,
                    visible_text_bounds,
-                    cx,
+                    whitespace_setting,
                    &invisible_display_ranges,
                    visible_bounds,
+                    cx,
                )
            }
        }
@@ -1047,8 +1051,8 @@ impl EditorElement {
                ..Default::default()
            });

-            if layout.is_singleton {
-                let diff_style = cx.global::<Settings>().theme.editor.diff.clone();
+            if layout.is_singleton && settings::get::<EditorSettings>(cx).scrollbar.git_diff {
+                let diff_style = theme::current(cx).editor.scrollbar.git.clone();
                for hunk in layout
                    .position_map
                    .snapshot
@@ -1460,11 +1464,9 @@ impl EditorElement {
        line_height: f32,
        style: &EditorStyle,
        line_layouts: &[LineWithInvisibles],
-        include_root: bool,
        editor: &mut Editor,
        cx: &mut LayoutContext<Editor>,
    ) -> (f32, Vec<BlockLayout>) {
-        let tooltip_style = cx.global::<Settings>().theme.tooltip.clone();
        let scroll_x = snapshot.scroll_anchor.offset.x();
        let (fixed_blocks, non_fixed_blocks) = snapshot
            .blocks_in_range(rows.clone())
@@ -1506,7 +1508,12 @@ impl EditorElement {
                    starts_new_buffer,
                    ..
                } => {
-                    let id = *id;
+                    let tooltip_style = theme::current(cx).tooltip.clone();
+                    let include_root = editor
+                        .project
+                        .as_ref()
+                        .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
+                        .unwrap_or_default();
                    let jump_icon = project::File::from_dyn(buffer.file()).map(|file| {
                        let jump_path = ProjectPath {
                            worktree_id: file.worktree_id(cx),
@@ -1519,7 +1526,7 @@ impl EditorElement {
                        let jump_position = language::ToPoint::to_point(&jump_anchor, buffer);

                        enum JumpIcon {}
-                        MouseEventHandler::<JumpIcon, _>::new(id.into(), cx, |state, _| {
+                        MouseEventHandler::<JumpIcon, _>::new((*id).into(), cx, |state, _| {
                            let style = style.jump_icon.style_for(state, false);
                            Svg::new("icons/arrow_up_right_8.svg")
                                .with_color(style.color)
@@ -1551,7 +1558,7 @@ impl EditorElement {
                            }
                        })
                        .with_tooltip::<JumpIcon>(
-                            id.into(),
+                            (*id).into(),
                            "Jump to Buffer".to_string(),
                            Some(Box::new(crate::OpenExcerpts)),
                            tooltip_style.clone(),
@@ -1562,9 +1569,9 @@ impl EditorElement {
                    });

                    if *starts_new_buffer {
-                        let style = &self.style.diagnostic_path_header;
-                        let font_size =
-                            (style.text_scale_factor * self.style.text.font_size).round();
+                        let editor_font_size = style.text.font_size;
+                        let style = &style.diagnostic_path_header;
+                        let font_size = (style.text_scale_factor * editor_font_size).round();

                        let path = buffer.resolve_file_path(cx, include_root);
                        let mut filename = None;
@@ -1600,7 +1607,7 @@ impl EditorElement {
                            .expanded()
                            .into_any_named("path header block")
                    } else {
-                        let text_style = self.style.text.clone();
+                        let text_style = style.text.clone();
                        Flex::row()
                            .with_child(Label::new("⋯", text_style))
                            .with_children(jump_icon)
@@ -1790,9 +1797,10 @@ impl LineWithInvisibles {
        content_origin: Vector2F,
        scroll_left: f32,
        visible_text_bounds: RectF,
-        cx: &mut ViewContext<Editor>,
+        whitespace_setting: ShowWhitespaceSetting,
        selection_ranges: &[Range<DisplayPoint>],
        visible_bounds: RectF,
+        cx: &mut ViewContext<Editor>,
    ) {
        let line_height = layout.position_map.line_height;
        let line_y = row as f32 * line_height - scroll_top;
@@ -1806,7 +1814,6 @@ impl LineWithInvisibles {
        );

        self.draw_invisibles(
-            cx,
            &selection_ranges,
            layout,
            content_origin,
@@ -1816,12 +1823,13 @@ impl LineWithInvisibles {
            scene,
            visible_bounds,
            line_height,
+            whitespace_setting,
+            cx,
        );
    }

    fn draw_invisibles(
        &self,
-        cx: &mut ViewContext<Editor>,
        selection_ranges: &[Range<DisplayPoint>],
        layout: &LayoutState,
        content_origin: Vector2F,
@@ -1831,17 +1839,13 @@ impl LineWithInvisibles {
        scene: &mut SceneBuilder,
        visible_bounds: RectF,
        line_height: f32,
+        whitespace_setting: ShowWhitespaceSetting,
+        cx: &mut ViewContext<Editor>,
    ) {
-        let settings = cx.global::<Settings>();
-        let allowed_invisibles_regions = match settings
-            .editor_overrides
-            .show_whitespaces
-            .or(settings.editor_defaults.show_whitespaces)
-            .unwrap_or_default()
-        {
-            ShowWhitespaces::None => return,
-            ShowWhitespaces::Selection => Some(selection_ranges),
-            ShowWhitespaces::All => None,
+        let allowed_invisibles_regions = match whitespace_setting {
+            ShowWhitespaceSetting::None => return,
+            ShowWhitespaceSetting::Selection => Some(selection_ranges),
+            ShowWhitespaceSetting::All => None,
        };

        for invisible in &self.invisibles {
@@ -1897,7 +1901,7 @@ impl Element<Editor> for EditorElement {
        let gutter_padding;
        let gutter_width;
        let gutter_margin;
-        if snapshot.mode == EditorMode::Full {
+        if snapshot.show_gutter {
            let em_width = style.text.em_width(cx.font_cache());
            gutter_padding = (em_width * style.gutter_padding_factor).round();
            gutter_width = self.max_line_number_width(&snapshot, cx) + gutter_padding * 2.0;
@@ -1986,11 +1990,11 @@ impl Element<Editor> for EditorElement {
        let is_singleton = editor.is_singleton(cx);

        let highlighted_rows = editor.highlighted_rows();
-        let theme = cx.global::<Settings>().theme.as_ref();
+        let theme = theme::current(cx);
        let highlighted_ranges = editor.background_highlights_in_range(
            start_anchor..end_anchor,
            &snapshot.display_snapshot,
-            theme,
+            theme.as_ref(),
        );

        fold_ranges.extend(
@@ -2065,22 +2069,19 @@ impl Element<Editor> for EditorElement {
            ));
        }

-        let show_scrollbars = match cx.global::<Settings>().show_scrollbars {
-            settings::ShowScrollbars::Auto => {
-                snapshot.has_scrollbar_info(is_singleton)
-                    || editor.scroll_manager.scrollbars_visible()
+        let scrollbar_settings = &settings::get::<EditorSettings>(cx).scrollbar;
+        let show_scrollbars = match scrollbar_settings.show {
+            ShowScrollbar::Auto => {
+                // Git
+                (is_singleton && scrollbar_settings.git_diff && snapshot.buffer_snapshot.has_git_diffs())
+                // Scrollmanager
+                || editor.scroll_manager.scrollbars_visible()
            }
-            settings::ShowScrollbars::System => editor.scroll_manager.scrollbars_visible(),
-            settings::ShowScrollbars::Always => true,
-            settings::ShowScrollbars::Never => false,
+            ShowScrollbar::System => editor.scroll_manager.scrollbars_visible(),
+            ShowScrollbar::Always => true,
+            ShowScrollbar::Never => false,
        };

-        let include_root = editor
-            .project
-            .as_ref()
-            .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
-            .unwrap_or_default();
-
        let fold_ranges: Vec<(BufferRow, Range<DisplayPoint>, Color)> = fold_ranges
            .into_iter()
            .map(|(id, fold)| {
@@ -2139,7 +2140,6 @@ impl Element<Editor> for EditorElement {
            line_height,
            &style,
            &line_layouts,
-            include_root,
            editor,
            cx,
        );
@@ -2836,17 +2836,19 @@ mod tests {
    use super::*;
    use crate::{
        display_map::{BlockDisposition, BlockProperties},
+        editor_tests::{init_test, update_test_settings},
        Editor, MultiBuffer,
    };
    use gpui::TestAppContext;
+    use language::language_settings;
    use log::info;
-    use settings::Settings;
    use std::{num::NonZeroU32, sync::Arc};
    use util::test::sample_text;

    #[gpui::test]
    fn test_layout_line_numbers(cx: &mut TestAppContext) {
-        cx.update(|cx| cx.set_global(Settings::test(cx)));
+        init_test(cx, |_| {});
+
        let (_, editor) = cx.add_window(|cx| {
            let buffer = MultiBuffer::build_simple(&sample_text(6, 6, 'a'), cx);
            Editor::new(EditorMode::Full, buffer, None, None, cx)
@@ -2864,7 +2866,8 @@ mod tests {

    #[gpui::test]
    fn test_layout_with_placeholder_text_and_blocks(cx: &mut TestAppContext) {
-        cx.update(|cx| cx.set_global(Settings::test(cx)));
+        init_test(cx, |_| {});
+
        let (_, editor) = cx.add_window(|cx| {
            let buffer = MultiBuffer::build_simple("", cx);
            Editor::new(EditorMode::Full, buffer, None, None, cx)
@@ -2880,6 +2883,7 @@ mod tests {
                    position: Anchor::min(),
                    render: Arc::new(|_| Empty::new().into_any()),
                }],
+                None,
                cx,
            );

@@ -2924,26 +2928,27 @@ mod tests {

    #[gpui::test]
    fn test_all_invisibles_drawing(cx: &mut TestAppContext) {
-        let tab_size = 4;
+        const TAB_SIZE: u32 = 4;
+
        let input_text = "\t \t|\t| a b";
        let expected_invisibles = vec![
            Invisible::Tab {
                line_start_offset: 0,
            },
            Invisible::Whitespace {
-                line_offset: tab_size as usize,
+                line_offset: TAB_SIZE as usize,
            },
            Invisible::Tab {
-                line_start_offset: tab_size as usize + 1,
+                line_start_offset: TAB_SIZE as usize + 1,
            },
            Invisible::Tab {
-                line_start_offset: tab_size as usize * 2 + 1,
+                line_start_offset: TAB_SIZE as usize * 2 + 1,
            },
            Invisible::Whitespace {
-                line_offset: tab_size as usize * 3 + 1,
+                line_offset: TAB_SIZE as usize * 3 + 1,
            },
            Invisible::Whitespace {
-                line_offset: tab_size as usize * 3 + 3,
+                line_offset: TAB_SIZE as usize * 3 + 3,
            },
        ];
        assert_eq!(
@@ -2955,12 +2960,11 @@ mod tests {
            "Hardcoded expected invisibles differ from the actual ones in '{input_text}'"
        );

-        cx.update(|cx| {
-            let mut test_settings = Settings::test(cx);
-            test_settings.editor_defaults.show_whitespaces = Some(ShowWhitespaces::All);
-            test_settings.editor_defaults.tab_size = Some(NonZeroU32::new(tab_size).unwrap());
-            cx.set_global(test_settings);
+        init_test(cx, |s| {
+            s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
+            s.defaults.tab_size = NonZeroU32::new(TAB_SIZE);
        });
+
        let actual_invisibles =
            collect_invisibles_from_new_editor(cx, EditorMode::Full, &input_text, 500.0);

@@ -2969,11 +2973,9 @@ mod tests {

    #[gpui::test]
    fn test_invisibles_dont_appear_in_certain_editors(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let mut test_settings = Settings::test(cx);
-            test_settings.editor_defaults.show_whitespaces = Some(ShowWhitespaces::All);
-            test_settings.editor_defaults.tab_size = Some(NonZeroU32::new(4).unwrap());
-            cx.set_global(test_settings);
+        init_test(cx, |s| {
+            s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
+            s.defaults.tab_size = NonZeroU32::new(4);
        });

        for editor_mode_without_invisibles in [
@@ -3024,19 +3026,18 @@ mod tests {
        );
        info!("Expected invisibles: {expected_invisibles:?}");

+        init_test(cx, |_| {});
+
        // Put the same string with repeating whitespace pattern into editors of various size,
        // take deliberately small steps during resizing, to put all whitespace kinds near the wrap point.
        let resize_step = 10.0;
        let mut editor_width = 200.0;
        while editor_width <= 1000.0 {
-            cx.update(|cx| {
-                let mut test_settings = Settings::test(cx);
-                test_settings.editor_defaults.tab_size = Some(NonZeroU32::new(tab_size).unwrap());
-                test_settings.editor_defaults.show_whitespaces = Some(ShowWhitespaces::All);
-                test_settings.editor_defaults.preferred_line_length = Some(editor_width as u32);
-                test_settings.editor_defaults.soft_wrap =
-                    Some(settings::SoftWrap::PreferredLineLength);
-                cx.set_global(test_settings);
+            update_test_settings(cx, |s| {
+                s.defaults.tab_size = NonZeroU32::new(tab_size);
+                s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
+                s.defaults.preferred_line_length = Some(editor_width as u32);
+                s.defaults.soft_wrap = Some(language_settings::SoftWrap::PreferredLineLength);
            });

            let actual_invisibles =
@@ -3075,7 +3076,7 @@ mod tests {
        editor_width: f32,
    ) -> Vec<Invisible> {
        info!(
-            "Creating editor with mode {editor_mode:?}, witdh {editor_width} and text '{input_text}'"
+            "Creating editor with mode {editor_mode:?}, width {editor_width} and text '{input_text}'"
        );
        let (_, editor) = cx.add_window(|cx| {
            let buffer = MultiBuffer::build_simple(&input_text, cx);
@@ -3084,7 +3085,7 @@ mod tests {

        let mut element = EditorElement::new(editor.read_with(cx, |editor, cx| editor.style(cx)));
        let (_, layout_state) = editor.update(cx, |editor, cx| {
-            editor.set_soft_wrap_mode(settings::SoftWrap::EditorWidth, cx);
+            editor.set_soft_wrap_mode(language_settings::SoftWrap::EditorWidth, cx);
            editor.set_wrap_width(Some(editor_width), cx);

            let mut new_parents = Default::default();
--- 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
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -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,
@@ -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
@@ -295,7 +294,7 @@ impl FollowableItem for Editor {
        match event {
            Event::Edited => true,
            Event::SelectionsChanged { local } => *local,
-            Event::ScrollPositionChanged { local } => *local,
+            Event::ScrollPositionChanged { local, .. } => *local,
            _ => false,
        }
    }
@@ -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),
                );
            }
@@ -721,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 {
@@ -1116,7 +1104,7 @@ 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 theme = &theme::current(cx).workspace.status_bar;
            let mut text = format!(
                "{}{FILE_ROW_COLUMN_DELIMITER}{}",
                position.row + 1,
@@ -1232,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,
@@ -62,8 +64,12 @@ pub enum Event {
    ExcerptsRemoved {
        ids: Vec<ExcerptId>,
    },
+    ExcerptsEdited {
+        ids: Vec<ExcerptId>,
+    },
    Edited,
    Reloaded,
+    DiffBaseChanged,
    LanguageChanged,
    Reparsed,
    Saved,
@@ -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,
@@ -341,17 +354,6 @@ impl MultiBuffer {
        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,
@@ -395,6 +397,7 @@ impl MultiBuffer {
            original_indent_column: u32,
        }
        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> {
@@ -1108,7 +1118,7 @@ impl MultiBuffer {
        &self,
        point: T,
        cx: &AppContext,
-    ) -> Option<(ModelHandle<Buffer>, usize)> {
+    ) -> Option<(ModelHandle<Buffer>, usize, ExcerptId)> {
        let snapshot = self.read(cx);
        let offset = point.to_offset(&snapshot);
        let mut cursor = snapshot.excerpts.cursor::<usize>();
@@ -1122,7 +1132,7 @@ impl MultiBuffer {
            let buffer_point = excerpt_start + offset - *cursor.start();
            let buffer = self.buffers.borrow()[&excerpt.buffer_id].buffer.clone();

-            (buffer, buffer_point)
+            (buffer, buffer_point, excerpt.id)
        })
    }

@@ -1130,7 +1140,7 @@ impl MultiBuffer {
        &self,
        range: Range<T>,
        cx: &AppContext,
-    ) -> Vec<(ModelHandle<Buffer>, Range<usize>)> {
+    ) -> Vec<(ModelHandle<Buffer>, Range<usize>, ExcerptId)> {
        let snapshot = self.read(cx);
        let start = range.start.to_offset(&snapshot);
        let end = range.end.to_offset(&snapshot);
@@ -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;
@@ -1151,7 +1165,7 @@ impl MultiBuffer {
            let start = excerpt_start + (cmp::max(start, *cursor.start()) - *cursor.start());
            let end = excerpt_start + (cmp::min(end, end_before_newline) - *cursor.start());
            let buffer = self.buffers.borrow()[&excerpt.buffer_id].buffer.clone();
-            result.push((buffer, start..end));
+            result.push((buffer, start..end, excerpt.id));
            cursor.next(&());
        }

@@ -1306,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,
@@ -1372,7 +1387,22 @@ impl MultiBuffer {
        cx: &'a AppContext,
    ) -> Option<Arc<Language>> {
        self.point_to_buffer_offset(point, cx)
-            .and_then(|(buffer, offset)| buffer.read(cx).language_at(offset))
+            .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>)) {
@@ -1535,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);
@@ -1948,7 +1985,6 @@ impl MultiBufferSnapshot {
        } else {
            None
        };
-
        MultiBufferBytes {
            range,
            excerpts,
@@ -1957,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,
@@ -2767,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))
@@ -3376,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)
@@ -3694,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];

@@ -3845,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]
@@ -4540,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();
@@ -5052,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()
-                    .map(|(buffer, buffer_range)| {
+                    .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!(
@@ -5128,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));
@@ -5196,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/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
    }
 }

@@ -173,13 +173,14 @@ impl ScrollManager {
        scroll_position: Vector2F,
        map: &DisplaySnapshot,
        local: bool,
+        autoscroll: bool,
        workspace_id: Option<i64>,
        cx: &mut ViewContext<Editor>,
    ) {
        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 +194,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,
@@ -203,7 +204,7 @@ impl ScrollManager {
            )
        };

-        self.set_anchor(new_anchor, top_row, local, workspace_id, cx);
+        self.set_anchor(new_anchor, top_row, local, autoscroll, workspace_id, cx);
    }

    fn set_anchor(
@@ -211,11 +212,12 @@ impl ScrollManager {
        anchor: ScrollAnchor,
        top_row: u32,
        local: bool,
+        autoscroll: bool,
        workspace_id: Option<i64>,
        cx: &mut ViewContext<Editor>,
    ) {
        self.anchor = anchor;
-        cx.emit(Event::ScrollPositionChanged { local });
+        cx.emit(Event::ScrollPositionChanged { local, autoscroll });
        self.show_scrollbar(cx);
        self.autoscroll_request.take();
        if let Some(workspace_id) = workspace_id {
@@ -296,21 +298,28 @@ impl Editor {
    }

    pub fn set_scroll_position(&mut self, scroll_position: Vector2F, cx: &mut ViewContext<Self>) {
-        self.set_scroll_position_internal(scroll_position, true, cx);
+        self.set_scroll_position_internal(scroll_position, true, false, cx);
    }

    pub(crate) fn set_scroll_position_internal(
        &mut self,
        scroll_position: Vector2F,
        local: bool,
+        autoscroll: bool,
        cx: &mut ViewContext<Self>,
    ) {
        let map = self.display_map.update(cx, |map, cx| map.snapshot(cx));

        hide_hover(self, cx);
        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
-        self.scroll_manager
-            .set_scroll_position(scroll_position, &map, local, workspace_id, cx);
+        self.scroll_manager.set_scroll_position(
+            scroll_position,
+            &map,
+            local,
+            autoscroll,
+            workspace_id,
+            cx,
+        );
    }

    pub fn scroll_position(&self, cx: &mut ViewContext<Self>) -> Vector2F {
@@ -322,11 +331,11 @@ 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
-            .set_anchor(scroll_anchor, top_row, true, workspace_id, cx);
+            .set_anchor(scroll_anchor, top_row, true, false, workspace_id, cx);
    }

    pub(crate) fn set_scroll_anchor_remote(
@@ -337,11 +346,11 @@ 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
-            .set_anchor(scroll_anchor, top_row, false, workspace_id, cx);
+            .set_anchor(scroll_anchor, top_row, false, false, workspace_id, cx);
    }

    pub fn scroll_screen(&mut self, amount: &ScrollAmount, cx: &mut ViewContext<Self>) {
@@ -377,7 +386,7 @@ impl Editor {
        let screen_top = self
            .scroll_manager
            .anchor
-            .top_anchor
+            .anchor
            .to_display_point(&snapshot);

        if screen_top > newest_head {
@@ -408,7 +417,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/crates/editor/src/scroll/autoscroll.rs
+++ b/crates/editor/src/scroll/autoscroll.rs
@@ -136,23 +136,23 @@ impl Editor {

                if target_top < start_row {
                    scroll_position.set_y(target_top);
-                    self.set_scroll_position_internal(scroll_position, local, cx);
+                    self.set_scroll_position_internal(scroll_position, local, true, cx);
                } else if target_bottom >= end_row {
                    scroll_position.set_y(target_bottom - visible_lines);
-                    self.set_scroll_position_internal(scroll_position, local, cx);
+                    self.set_scroll_position_internal(scroll_position, local, true, cx);
                }
            }
            AutoscrollStrategy::Center => {
                scroll_position.set_y((first_cursor_top - margin).max(0.0));
-                self.set_scroll_position_internal(scroll_position, local, cx);
+                self.set_scroll_position_internal(scroll_position, local, true, cx);
            }
            AutoscrollStrategy::Top => {
                scroll_position.set_y((first_cursor_top).max(0.0));
-                self.set_scroll_position_internal(scroll_position, local, cx);
+                self.set_scroll_position_internal(scroll_position, local, true, cx);
            }
            AutoscrollStrategy::Bottom => {
                scroll_position.set_y((last_cursor_bottom - visible_lines).max(0.0));
-                self.set_scroll_position_internal(scroll_position, local, cx);
+                self.set_scroll_position_internal(scroll_position, local, true, cx);
            }
        }

--- a/crates/editor/src/selections_collection.rs
+++ b/crates/editor/src/selections_collection.rs
@@ -76,6 +76,9 @@ impl SelectionsCollection {
        count
    }

+    /// The non-pending, non-overlapping selections. There could still be a pending
+    /// selection that overlaps these if the mouse is being dragged, etc. Returned as
+    /// selections over Anchors.
    pub fn disjoint_anchors(&self) -> Arc<[Selection<Anchor>]> {
        self.disjoint.clone()
    }
--- a/crates/editor/src/test.rs
+++ b/crates/editor/src/test.rs
@@ -48,8 +48,8 @@ pub fn marked_display_snapshot(
 }

 pub fn select_ranges(editor: &mut Editor, marked_text: &str, cx: &mut ViewContext<Editor>) {
-    let (umarked_text, text_ranges) = marked_text_ranges(marked_text, true);
-    assert_eq!(editor.text(cx), umarked_text);
+    let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);
+    assert_eq!(editor.text(cx), unmarked_text);
    editor.change_selections(None, cx, |s| s.select_ranges(text_ranges));
 }

--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -34,13 +34,17 @@ impl<'a> EditorLspTestContext<'a> {
    ) -> EditorLspTestContext<'a> {
        use json::json;

+        let app_state = cx.update(AppState::test);
+
        cx.update(|cx| {
+            theme::init((), cx);
+            language::init(cx);
            crate::init(cx);
            pane::init(cx);
+            Project::init_settings(cx);
+            workspace::init_settings(cx);
        });

-        let app_state = cx.update(AppState::test);
-
        let file_name = format!(
            "file.{}",
            language
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -1,19 +1,17 @@
+use crate::{
+    display_map::ToDisplayPoint, AnchorRangeExt, Autoscroll, DisplayPoint, Editor, MultiBuffer,
+};
+use futures::Future;
+use gpui::{
+    keymap_matcher::Keystroke, AppContext, ContextHandle, ModelContext, ViewContext, ViewHandle,
+};
+use indoc::indoc;
+use language::{Buffer, BufferSnapshot};
+use project::{FakeFs, Project};
 use std::{
    any::TypeId,
    ops::{Deref, DerefMut, Range},
 };
-
-use futures::Future;
-use indoc::indoc;
-
-use crate::{
-    display_map::ToDisplayPoint, AnchorRangeExt, Autoscroll, DisplayPoint, Editor, MultiBuffer,
-};
-use gpui::{
-    keymap_matcher::Keystroke, AppContext, ContextHandle, ModelContext, ViewContext, ViewHandle,
-};
-use language::{Buffer, BufferSnapshot};
-use settings::Settings;
 use util::{
    assert_set_eq,
    test::{generate_marked_text, marked_text_ranges},
@@ -28,17 +26,17 @@ pub struct EditorTestContext<'a> {
 }

 impl<'a> EditorTestContext<'a> {
-    pub fn new(cx: &'a mut gpui::TestAppContext) -> EditorTestContext<'a> {
+    pub async fn new(cx: &'a mut gpui::TestAppContext) -> EditorTestContext<'a> {
+        let fs = FakeFs::new(cx.background());
+        let project = Project::test(fs, [], cx).await;
+        let buffer = project
+            .update(cx, |project, cx| project.create_buffer("", None, cx))
+            .unwrap();
        let (window_id, editor) = cx.update(|cx| {
-            cx.set_global(Settings::test(cx));
-            crate::init(cx);
-
-            let (window_id, editor) = cx.add_window(Default::default(), |cx| {
+            cx.add_window(Default::default(), |cx| {
                cx.focus_self();
-                build_editor(MultiBuffer::build_simple("", cx), cx)
-            });
-
-            (window_id, editor)
+                build_editor(MultiBuffer::build_from_buffer(buffer, cx), cx)
+            })
        });

        Self {
--- a/crates/feedback/Cargo.toml
+++ b/crates/feedback/Cargo.toml
@@ -16,6 +16,7 @@ editor = { path = "../editor" }
 language = { path = "../language" }
 gpui = { path = "../gpui" }
 project = { path = "../project" }
+regex.workspace = true
 search = { path = "../search" }
 settings = { path = "../settings" }
 theme = { path = "../theme" }
@@ -27,7 +28,7 @@ futures.workspace = true
 anyhow.workspace = true
 smallvec.workspace = true
 human_bytes = "0.4.1"
-isahc = "1.7"
+isahc.workspace = true
 lazy_static.workspace = true
 postage.workspace = true
 serde.workspace = true
@@ -35,3 +36,6 @@ serde_derive.workspace = true
 sysinfo = "0.27.1"
 tree-sitter-markdown = { git = "https://github.com/MDeiml/tree-sitter-markdown", rev = "330ecab87a3e3a7211ac69bbadc19eabecdb1cca" }
 urlencoding = "2.1.2"
+
+[dev-dependencies]
+editor = { path = "../editor", features = ["test-support"] }
--- a/crates/feedback/src/deploy_feedback_button.rs
+++ b/crates/feedback/src/deploy_feedback_button.rs
@@ -3,7 +3,6 @@ use gpui::{
    platform::{CursorStyle, MouseButton},
    Entity, View, ViewContext, WeakViewHandle,
 };
-use settings::Settings;
 use workspace::{item::ItemHandle, StatusItemView, Workspace};

 use crate::feedback_editor::{FeedbackEditor, GiveFeedback};
@@ -33,15 +32,15 @@ impl View for DeployFeedbackButton {

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
        let active = self.active;
-        let theme = cx.global::<Settings>().theme.clone();
+        let theme = theme::current(cx).clone();
        Stack::new()
            .with_child(
                MouseEventHandler::<Self, Self>::new(0, cx, |state, _| {
                    let style = &theme
                        .workspace
                        .status_bar
-                        .sidebar_buttons
-                        .item
+                        .panel_buttons
+                        .button
                        .style_for(state, active);

                    Svg::new("icons/feedback_16.svg")
--- a/crates/feedback/src/feedback_editor.rs
+++ b/crates/feedback/src/feedback_editor.rs
@@ -14,6 +14,7 @@ use isahc::Request;
 use language::Buffer;
 use postage::prelude::Stream;
 use project::Project;
+use regex::Regex;
 use serde::Serialize;
 use smallvec::SmallVec;
 use std::{
@@ -46,6 +47,7 @@ pub fn init(cx: &mut AppContext) {
 #[derive(Serialize)]
 struct FeedbackRequestBody<'a> {
    feedback_text: &'a str,
+    email: Option<String>,
    metrics_id: Option<Arc<str>>,
    installation_id: Option<Arc<str>>,
    system_specs: SystemSpecs,
@@ -157,8 +159,18 @@ impl FeedbackEditor {
        let is_staff = telemetry.is_staff();
        let http_client = zed_client.http_client();

+        let re = Regex::new(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b").unwrap();
+
+        let emails: Vec<&str> = re
+            .captures_iter(feedback_text)
+            .map(|capture| capture.get(0).unwrap().as_str())
+            .collect();
+
+        let email = emails.first().map(|e| e.to_string());
+
        let request = FeedbackRequestBody {
            feedback_text: &feedback_text,
+            email,
            metrics_id,
            installation_id,
            system_specs,
--- a/crates/feedback/src/feedback_info_text.rs
+++ b/crates/feedback/src/feedback_info_text.rs
@@ -3,7 +3,6 @@ use gpui::{
    platform::{CursorStyle, MouseButton},
    AnyElement, Element, Entity, View, ViewContext, ViewHandle,
 };
-use settings::Settings;
 use workspace::{item::ItemHandle, ToolbarItemLocation, ToolbarItemView};

 use crate::{feedback_editor::FeedbackEditor, open_zed_community_repo, OpenZedCommunityRepo};
@@ -30,12 +29,12 @@ impl View for FeedbackInfoText {
    }

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

        Flex::row()
            .with_child(
                Text::new(
-                    "We read whatever you submit here. For issues and discussions, visit the ",
+                    "Share your feedback. Include your email for replies. For issues and discussions, visit the ",
                    theme.feedback.info_text_default.text.clone(),
                )
                .with_soft_wrap(false)
@@ -61,7 +60,7 @@ impl View for FeedbackInfoText {
                }),
            )
            .with_child(
-                Text::new(" on GitHub.", theme.feedback.info_text_default.text.clone())
+                Text::new(".", theme.feedback.info_text_default.text.clone())
                    .with_soft_wrap(false)
                    .aligned(),
            )
--- a/crates/feedback/src/submit_feedback_button.rs
+++ b/crates/feedback/src/submit_feedback_button.rs
@@ -5,7 +5,6 @@ use gpui::{
    platform::{CursorStyle, MouseButton},
    AnyElement, AppContext, Element, Entity, Task, View, ViewContext, ViewHandle,
 };
-use settings::Settings;
 use workspace::{item::ItemHandle, ToolbarItemLocation, ToolbarItemView};

 pub fn init(cx: &mut AppContext) {
@@ -46,7 +45,7 @@ impl View for SubmitFeedbackButton {
    }

    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let theme = cx.global::<Settings>().theme.clone();
+        let theme = theme::current(cx).clone();
        enum SubmitFeedbackButton {}
        MouseEventHandler::<SubmitFeedbackButton, Self>::new(0, cx, |state, _| {
            let style = theme.feedback.submit_button.style_for(state, false);
--- a/crates/feedback/src/system_specs.rs
+++ b/crates/feedback/src/system_specs.rs
@@ -6,6 +6,8 @@ use std::{env, fmt::Display};
 use sysinfo::{System, SystemExt};
 use util::channel::ReleaseChannel;

+// TODO: Move this file out of feedback and into a more general place
+
 #[derive(Clone, Debug, Serialize)]
 pub struct SystemSpecs {
    #[serde(serialize_with = "serialize_app_version")]
--- a/Show More
+++ b/Show More