Allow unsaved buffers to be formatted when using an external formatter

Disable indent guides for single line editors by default.
elixir: Fix mix test $ZED_SYMBOL task (#11879 )
2024-06-03 10:44:29 +02:00 · 2024-06-02 17:12:35 +02:00 · 2024-05-31 12:54:14 +02:00 · 2024-05-31 05:50:03 +03:00 · 2024-05-30 18:27:03 -04:00 · 2024-05-30 22:55:47 +02:00
111 changed files with 2641 additions and 1354 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,6 +23,7 @@ env:

 jobs:
  style:
+    timeout-minutes: 60
    name: Check formatting and spelling
    runs-on:
      - self-hosted
@@ -77,6 +78,7 @@ jobs:
          against: "https://github.com/${GITHUB_REPOSITORY}.git#branch=${BUF_BASE_BRANCH},subdir=crates/rpc/proto/"

  macos_tests:
+    timeout-minutes: 60
    name: (macOS) Run Clippy and tests
    runs-on:
      - self-hosted
@@ -101,6 +103,7 @@ jobs:

  # todo(linux): Actually run the tests
  linux_tests:
+    timeout-minutes: 60
    name: (Linux) Run Clippy and tests
    runs-on:
      - self-hosted
@@ -122,6 +125,7 @@ jobs:

  # todo(windows): Actually run the tests
  windows_tests:
+    timeout-minutes: 60
    name: (Windows) Run Clippy and tests
    runs-on: hosted-windows-1
    steps:
@@ -142,6 +146,7 @@ jobs:
        run: cargo build -p zed

  bundle-mac:
+    timeout-minutes: 60
    name: Create a macOS bundle
    runs-on:
      - self-hosted
@@ -252,6 +257,7 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  bundle-linux:
+    timeout-minutes: 60
    name: Create a Linux bundle
    runs-on:
      - self-hosted
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -15,6 +15,7 @@ env:

 jobs:
  style:
+    timeout-minutes: 60
    name: Check formatting and Clippy lints
    if: github.repository_owner == 'zed-industries'
    runs-on:
@@ -33,6 +34,7 @@ jobs:
      - name: Run clippy
        run: cargo xtask clippy
  tests:
+    timeout-minutes: 60
    name: Run tests
    if: github.repository_owner == 'zed-industries'
    runs-on:
@@ -49,6 +51,7 @@ jobs:
        uses: ./.github/actions/run_tests

  bundle-mac:
+    timeout-minutes: 60
    name: Create a macOS bundle
    if: github.repository_owner == 'zed-industries'
    runs-on:
@@ -91,6 +94,7 @@ jobs:
        run: script/upload-nightly macos

  bundle-deb:
+    timeout-minutes: 60
    name: Create a Linux *.tar.gz bundle
    if: github.repository_owner == 'zed-industries'
    runs-on:
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -230,6 +230,7 @@ dependencies = [
 "schemars",
 "serde",
 "serde_json",
+ "strum",
 "tokio",
 ]

@@ -367,6 +368,7 @@ dependencies = [
 "rand 0.8.5",
 "regex",
 "rope",
+ "rustdoc_to_markdown",
 "schemars",
 "search",
 "semantic_index",
@@ -375,6 +377,7 @@ dependencies = [
 "settings",
 "smol",
 "strsim 0.11.1",
+ "strum",
 "telemetry_events",
 "theme",
 "tiktoken-rs",
@@ -1510,7 +1513,7 @@ dependencies = [
 [[package]]
 name = "blade-graphics"
 version = "0.4.0"
-source = "git+https://github.com/kvark/blade?rev=9c9cabf69e869fc7d9aef2fc76f7d5c354d5710a#9c9cabf69e869fc7d9aef2fc76f7d5c354d5710a"
+source = "git+https://github.com/kvark/blade?rev=bdaf8c534fbbc9fbca71d1cf272f45640b3a068d#bdaf8c534fbbc9fbca71d1cf272f45640b3a068d"
 dependencies = [
 "ash",
 "ash-window",
@@ -1540,13 +1543,24 @@ dependencies = [
 [[package]]
 name = "blade-macros"
 version = "0.2.1"
-source = "git+https://github.com/kvark/blade?rev=9c9cabf69e869fc7d9aef2fc76f7d5c354d5710a#9c9cabf69e869fc7d9aef2fc76f7d5c354d5710a"
+source = "git+https://github.com/kvark/blade?rev=bdaf8c534fbbc9fbca71d1cf272f45640b3a068d#bdaf8c534fbbc9fbca71d1cf272f45640b3a068d"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.59",
 ]

+[[package]]
+name = "blade-util"
+version = "0.1.0"
+source = "git+https://github.com/kvark/blade?rev=bdaf8c534fbbc9fbca71d1cf272f45640b3a068d#bdaf8c534fbbc9fbca71d1cf272f45640b3a068d"
+dependencies = [
+ "blade-graphics",
+ "bytemuck",
+ "log",
+ "profiling",
+]
+
 [[package]]
 name = "block"
 version = "0.1.6"
@@ -3379,7 +3393,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
 dependencies = [
- "libloading 0.8.0",
+ "libloading 0.7.4",
 ]

 [[package]]
@@ -4192,6 +4206,7 @@ name = "fs"
 version = "0.1.0"
 dependencies = [
 "anyhow",
+ "ashpd",
 "async-tar",
 "async-trait",
 "cocoa",
@@ -4690,6 +4705,7 @@ dependencies = [
 "bindgen 0.65.1",
 "blade-graphics",
 "blade-macros",
+ "blade-util",
 "block",
 "bytemuck",
 "calloop",
@@ -5049,6 +5065,20 @@ version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4d13cdbd5dbb29f9c88095bbdc2590c9cba0d0a1269b983fef6b2cdd7e9f4db1"

+[[package]]
+name = "html5ever"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c13771afe0e6e846f1e67d038d4cb29998a6779f93c809212e4e9c32efd244d4"
+dependencies = [
+ "log",
+ "mac",
+ "markup5ever",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.59",
+]
+
 [[package]]
 name = "http"
 version = "0.1.0"
@@ -5708,7 +5738,7 @@ dependencies = [
 "tree-sitter-embedded-template",
 "tree-sitter-heex",
 "tree-sitter-html",
- "tree-sitter-json 0.20.2",
+ "tree-sitter-json",
 "tree-sitter-markdown",
 "tree-sitter-ruby",
 "tree-sitter-rust",
@@ -5798,7 +5828,7 @@ dependencies = [
 "tree-sitter-gomod",
 "tree-sitter-gowork",
 "tree-sitter-jsdoc",
- "tree-sitter-json 0.20.2",
+ "tree-sitter-json",
 "tree-sitter-markdown",
 "tree-sitter-proto",
 "tree-sitter-python",
@@ -6170,6 +6200,32 @@ dependencies = [
 "workspace",
 ]

+[[package]]
+name = "markup5ever"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16ce3abbeba692c8b8441d036ef91aea6df8da2c6b6e21c7e14d3c18e526be45"
+dependencies = [
+ "log",
+ "phf",
+ "phf_codegen",
+ "string_cache",
+ "string_cache_codegen",
+ "tendril",
+]
+
+[[package]]
+name = "markup5ever_rcdom"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edaa21ab3701bfee5099ade5f7e1f84553fd19228cf332f13cd6e964bf59be18"
+dependencies = [
+ "html5ever",
+ "markup5ever",
+ "tendril",
+ "xml5ever",
+]
+
 [[package]]
 name = "matchers"
 version = "0.1.0"
@@ -6929,6 +6985,7 @@ dependencies = [
 "schemars",
 "serde",
 "serde_json",
+ "strum",
 ]

 [[package]]
@@ -7275,7 +7332,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
 dependencies = [
 "phf_macros",
- "phf_shared",
+ "phf_shared 0.11.2",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
+dependencies = [
+ "phf_generator 0.11.2",
+ "phf_shared 0.11.2",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
+dependencies = [
+ "phf_shared 0.10.0",
+ "rand 0.8.5",
 ]

 [[package]]
@@ -7284,7 +7361,7 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
 dependencies = [
- "phf_shared",
+ "phf_shared 0.11.2",
 "rand 0.8.5",
 ]

@@ -7294,13 +7371,22 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
 dependencies = [
- "phf_generator",
- "phf_shared",
+ "phf_generator 0.11.2",
+ "phf_shared 0.11.2",
 "proc-macro2",
 "quote",
 "syn 2.0.59",
 ]

+[[package]]
+name = "phf_shared"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+dependencies = [
+ "siphasher 0.3.11",
+]
+
 [[package]]
 name = "phf_shared"
 version = "0.11.2"
@@ -7544,6 +7630,12 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
 [[package]]
 name = "prettier"
 version = "0.1.0"
@@ -8543,6 +8635,18 @@ dependencies = [
 "semver",
 ]

+[[package]]
+name = "rustdoc_to_markdown"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "html5ever",
+ "indoc",
+ "markup5ever_rcdom",
+ "pretty_assertions",
+ "regex",
+]
+
 [[package]]
 name = "rustix"
 version = "0.37.23"
@@ -9107,7 +9211,7 @@ dependencies = [
 "serde_json_lenient",
 "smallvec",
 "tree-sitter",
- "tree-sitter-json 0.19.0",
+ "tree-sitter-json",
 "unindent",
 "util",
 ]
@@ -9791,6 +9895,32 @@ dependencies = [
 "float-cmp",
 ]

+[[package]]
+name = "string_cache"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b"
+dependencies = [
+ "new_debug_unreachable",
+ "once_cell",
+ "parking_lot",
+ "phf_shared 0.10.0",
+ "precomputed-hash",
+ "serde",
+]
+
+[[package]]
+name = "string_cache_codegen"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bb30289b722be4ff74a408c3cc27edeaad656e06cb1fe8fa9231fa59c728988"
+dependencies = [
+ "phf_generator 0.10.0",
+ "phf_shared 0.10.0",
+ "proc-macro2",
+ "quote",
+]
+
 [[package]]
 name = "stringprep"
 version = "0.1.4"
@@ -10980,16 +11110,6 @@ dependencies = [
 "tree-sitter",
 ]

-[[package]]
-name = "tree-sitter-json"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90b04c4e1a92139535eb9fca4ec8fa9666cc96b618005d3ae35f3c957fa92f92"
-dependencies = [
- "cc",
- "tree-sitter",
-]
-
 [[package]]
 name = "tree-sitter-json"
 version = "0.20.2"
@@ -12926,6 +13046,17 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "054a8e68b76250b253f671d1268cb7f1ae089ec35e195b2efb2a4e9a836d0621"

+[[package]]
+name = "xml5ever"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c376f76ed09df711203e20c3ef5ce556f0166fa03d39590016c0fd625437fad"
+dependencies = [
+ "log",
+ "mac",
+ "markup5ever",
+]
+
 [[package]]
 name = "xmlparser"
 version = "0.13.5"
@@ -13047,7 +13178,7 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.138.4"
+version = "0.139.0"
 dependencies = [
 "activity_indicator",
 "anyhow",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -76,6 +76,7 @@ members = [
    "crates/rich_text",
    "crates/rope",
    "crates/rpc",
+    "crates/rustdoc_to_markdown",
    "crates/task",
    "crates/tasks_ui",
    "crates/search",
@@ -220,6 +221,7 @@ dev_server_projects = { path = "crates/dev_server_projects" }
 rich_text = { path = "crates/rich_text" }
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
+rustdoc_to_markdown = { path = "crates/rustdoc_to_markdown" }
 task = { path = "crates/task" }
 tasks_ui = { path = "crates/tasks_ui" }
 search = { path = "crates/search" }
@@ -255,6 +257,7 @@ zed_actions = { path = "crates/zed_actions" }

 anyhow = "1.0.57"
 any_vec = "0.13"
+ashpd = "0.8.0"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-fs = "1.6"
 async-recursion = "1.0.0"
@@ -262,8 +265,9 @@ async-tar = "0.4.2"
 async-trait = "0.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 bitflags = "2.4.2"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "9c9cabf69e869fc7d9aef2fc76f7d5c354d5710a" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "9c9cabf69e869fc7d9aef2fc76f7d5c354d5710a" }
+blade-graphics = { git = "https://github.com/kvark/blade", rev = "bdaf8c534fbbc9fbca71d1cf272f45640b3a068d" }
+blade-macros = { git = "https://github.com/kvark/blade", rev = "bdaf8c534fbbc9fbca71d1cf272f45640b3a068d" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "bdaf8c534fbbc9fbca71d1cf272f45640b3a068d" }
 cap-std = "3.0"
 cargo_toml = "0.20"
 chrono = { version = "0.4", features = ["serde"] }
@@ -283,10 +287,9 @@ futures-batch = "0.6.1"
 futures-lite = "1.13"
 git2 = { version = "0.18", default-features = false }
 globset = "0.4"
-heed = { version = "0.20.1", features = [
-    "read-txn-no-tls",
-] }
+heed = { version = "0.20.1", features = ["read-txn-no-tls"] }
 hex = "0.4.3"
+html5ever = "0.27.0"
 ignore = "0.4.22"
 indoc = "1"
 # We explicitly disable http2 support in isahc.
@@ -299,6 +302,7 @@ lazy_static = "1.4.0"
 libc = "0.2"
 linkify = "0.10.0"
 log = { version = "0.4.16", features = ["kv_unstable_serde"] }
+markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
 nix = "0.28"
 once_cell = "1.19.0"
@@ -492,7 +496,7 @@ type_complexity = "allow"

 [workspace.lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = [
-    'cfg(gles)' # used in gpui
+    'cfg(gles)', # used in gpui
 ] }

 [workspace.metadata.cargo-machete]
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -1,15 +1,15 @@
 {
  "stems": {
+    "Dockerfile": "docker",
    "Podfile": "ruby",
-    "Procfile": "heroku",
-    "Dockerfile": "docker"
+    "Procfile": "heroku"
  },
  "suffixes": {
-    "astro": "astro",
    "Emakefile": "erlang",
    "aac": "audio",
    "accdb": "storage",
    "app.src": "erlang",
+    "astro": "astro",
    "avi": "video",
    "avif": "image",
    "bak": "backup",
@@ -22,12 +22,12 @@
    "c": "c",
    "cc": "cpp",
    "cjs": "javascript",
+    "coffee": "coffeescript",
    "conf": "settings",
    "cpp": "cpp",
    "css": "css",
    "csv": "storage",
    "cts": "typescript",
-    "coffee": "coffeescript",
    "dart": "dart",
    "dat": "storage",
    "db": "storage",
@@ -61,12 +61,12 @@
    "graphql": "graphql",
    "graphqls": "graphql",
    "h": "c",
-    "hpp": "cpp",
    "handlebars": "code",
    "hbs": "template",
    "heex": "elixir",
-    "heif": "image",
    "heic": "image",
+    "heif": "image",
+    "hpp": "cpp",
    "hrl": "erlang",
    "hs": "haskell",
    "htm": "template",
@@ -81,9 +81,9 @@
    "jpeg": "image",
    "jpg": "image",
    "js": "javascript",
-    "jsx": "react",
    "json": "storage",
    "jsonc": "storage",
+    "jsx": "react",
    "jxl": "image",
    "kt": "kotlin",
    "ldf": "storage",
@@ -98,9 +98,9 @@
    "mdf": "storage",
    "mdx": "document",
    "metadata": "code",
-    "mkv": "video",
    "mjs": "javascript",
    "mka": "audio",
+    "mkv": "video",
    "ml": "ocaml",
    "mli": "ocaml",
    "mov": "video",
@@ -109,8 +109,8 @@
    "mts": "typescript",
    "myd": "storage",
    "myi": "storage",
-    "nu": "terminal",
    "nim": "nim",
+    "nu": "terminal",
    "odp": "document",
    "ods": "document",
    "odt": "document",
@@ -132,33 +132,33 @@
    "psd": "image",
    "py": "python",
    "qoi": "image",
+    "r": "r",
    "rb": "ruby",
    "rebar.config": "erlang",
    "rkt": "code",
    "rs": "rust",
-    "r": "r",
    "rtf": "document",
    "sav": "storage",
+    "sc": "scala",
+    "scala": "scala",
    "scm": "code",
    "sdf": "storage",
    "sh": "terminal",
+    "sql": "storage",
    "sqlite": "storage",
    "svelte": "template",
    "svg": "image",
-    "sc": "scala",
-    "scala": "scala",
-    "sql": "storage",
    "swift": "swift",
+    "tcl": "tcl",
    "tf": "terraform",
    "tfvars": "terraform",
    "tiff": "image",
    "toml": "toml",
    "ts": "typescript",
    "tsv": "storage",
-    "ttf": "font",
    "tsx": "react",
+    "ttf": "font",
    "txt": "document",
-    "tcl": "tcl",
    "vue": "vue",
    "wav": "audio",
    "webm": "video",
@@ -190,27 +190,30 @@
    "audio": {
      "icon": "icons/file_icons/audio.svg"
    },
+    "bun": {
+      "icon": "icons/file_icons/bun.svg"
+    },
+    "c": {
+      "icon": "icons/file_icons/c.svg"
+    },
    "code": {
      "icon": "icons/file_icons/code.svg"
    },
+    "coffeescript": {
+      "icon": "icons/file_icons/coffeescript.svg"
+    },
    "collapsed_chevron": {
      "icon": "icons/file_icons/chevron_right.svg"
    },
    "collapsed_folder": {
      "icon": "icons/file_icons/folder.svg"
    },
-    "c": {
-      "icon": "icons/file_icons/c.svg"
-    },
    "cpp": {
      "icon": "icons/file_icons/cpp.svg"
    },
    "css": {
      "icon": "icons/file_icons/css.svg"
    },
-    "coffeescript": {
-      "icon": "icons/file_icons/coffeescript.svg"
-    },
    "dart": {
      "icon": "icons/file_icons/dart.svg"
    },
@@ -247,18 +250,18 @@
    "fsharp": {
      "icon": "icons/file_icons/fsharp.svg"
    },
-    "haskell": {
-      "icon": "icons/file_icons/haskell.svg"
-    },
-    "heroku": {
-      "icon": "icons/file_icons/heroku.svg"
-    },
    "go": {
      "icon": "icons/file_icons/go.svg"
    },
    "graphql": {
      "icon": "icons/file_icons/graphql.svg"
    },
+    "haskell": {
+      "icon": "icons/file_icons/haskell.svg"
+    },
+    "heroku": {
+      "icon": "icons/file_icons/heroku.svg"
+    },
    "image": {
      "icon": "icons/file_icons/image.svg"
    },
@@ -274,21 +277,18 @@
    "lock": {
      "icon": "icons/file_icons/lock.svg"
    },
-    "bun": {
-      "icon": "icons/file_icons/bun.svg"
-    },
    "log": {
      "icon": "icons/file_icons/info.svg"
    },
    "lua": {
      "icon": "icons/file_icons/lua.svg"
    },
-    "ocaml": {
-      "icon": "icons/file_icons/ocaml.svg"
-    },
    "nim": {
      "icon": "icons/file_icons/nim.svg"
    },
+    "ocaml": {
+      "icon": "icons/file_icons/ocaml.svg"
+    },
    "phoenix": {
      "icon": "icons/file_icons/phoenix.svg"
    },
@@ -316,36 +316,36 @@
    "rust": {
      "icon": "icons/file_icons/rust.svg"
    },
+    "scala": {
+      "icon": "icons/file_icons/scala.svg"
+    },
    "settings": {
      "icon": "icons/file_icons/settings.svg"
    },
    "storage": {
      "icon": "icons/file_icons/database.svg"
    },
-    "scala": {
-      "icon": "icons/file_icons/scala.svg"
-    },
    "swift": {
      "icon": "icons/file_icons/swift.svg"
    },
+    "tcl": {
+      "icon": "icons/file_icons/tcl.svg"
+    },
    "template": {
      "icon": "icons/file_icons/html.svg"
    },
-    "terraform": {
-      "icon": "icons/file_icons/terraform.svg"
-    },
    "terminal": {
      "icon": "icons/file_icons/terminal.svg"
    },
+    "terraform": {
+      "icon": "icons/file_icons/terraform.svg"
+    },
    "toml": {
      "icon": "icons/file_icons/toml.svg"
    },
    "typescript": {
      "icon": "icons/file_icons/typescript.svg"
    },
-    "tcl": {
-      "icon": "icons/file_icons/tcl.svg"
-    },
    "vcs": {
      "icon": "icons/file_icons/git.svg"
    },
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -201,7 +201,8 @@
    "context": "AssistantPanel",
    "bindings": {
      "ctrl-g": "search::SelectNextMatch",
-      "ctrl-shift-g": "search::SelectPrevMatch"
+      "ctrl-shift-g": "search::SelectPrevMatch",
+      "alt-m": "assistant::ToggleModelSelector"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -214,10 +214,11 @@
    }
  },
  {
-    "context": "AssistantPanel", // Used in the assistant crate, which we're replacing
+    "context": "AssistantPanel",
    "bindings": {
      "cmd-g": "search::SelectNextMatch",
-      "cmd-shift-g": "search::SelectPrevMatch"
+      "cmd-shift-g": "search::SelectPrevMatch",
+      "alt-m": "assistant::ToggleModelSelector"
    }
  },
  {
--- a/crates/anthropic/Cargo.toml
+++ b/crates/anthropic/Cargo.toml
@@ -23,6 +23,7 @@ isahc.workspace = true
 schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
+strum.workspace = true

 [dev-dependencies]
 tokio.workspace = true
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -4,11 +4,12 @@ use http::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use isahc::config::Configurable;
 use serde::{Deserialize, Serialize};
 use std::{convert::TryFrom, time::Duration};
+use strum::EnumIter;

 pub const ANTHROPIC_API_URL: &'static str = "https://api.anthropic.com";

 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
    #[default]
    #[serde(alias = "claude-3-opus", rename = "claude-3-opus-20240229")]
--- a/crates/assets/src/assets.rs
+++ b/crates/assets/src/assets.rs
@@ -16,9 +16,9 @@ use rust_embed::RustEmbed;
 pub struct Assets;

 impl AssetSource for Assets {
-    fn load(&self, path: &str) -> Result<std::borrow::Cow<'static, [u8]>> {
+    fn load(&self, path: &str) -> Result<Option<std::borrow::Cow<'static, [u8]>>> {
        Self::get(path)
-            .map(|f| f.data)
+            .map(|f| Some(f.data))
            .ok_or_else(|| anyhow!("could not find asset at path \"{}\"", path))
    }

@@ -42,7 +42,10 @@ impl Assets {
        let mut embedded_fonts = Vec::new();
        for font_path in font_paths {
            if font_path.ends_with(".ttf") {
-                let font_bytes = cx.asset_source().load(&font_path)?;
+                let font_bytes = cx
+                    .asset_source()
+                    .load(&font_path)?
+                    .expect("Assets should never return None");
                embedded_fonts.push(font_bytes);
            }
        }
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -40,6 +40,7 @@ parking_lot.workspace = true
 project.workspace = true
 regex.workspace = true
 rope.workspace = true
+rustdoc_to_markdown.workspace = true
 schemars.workspace = true
 search.workspace = true
 semantic_index.workspace = true
@@ -48,6 +49,7 @@ serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
 strsim = "0.11"
+strum.workspace = true
 telemetry_events.workspace = true
 theme.workspace = true
 tiktoken-rs.workspace = true
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -2,6 +2,7 @@ pub mod assistant_panel;
 pub mod assistant_settings;
 mod codegen;
 mod completion_provider;
+mod model_selector;
 mod prompts;
 mod saved_conversation;
 mod search;
@@ -15,6 +16,7 @@ use client::{proto, Client};
 use command_palette_hooks::CommandPaletteFilter;
 pub(crate) use completion_provider::*;
 use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
+pub(crate) use model_selector::*;
 pub(crate) use saved_conversation::*;
 use semantic_index::{CloudEmbeddingProvider, SemanticIndex};
 use serde::{Deserialize, Serialize};
@@ -38,7 +40,8 @@ actions!(
        InsertActivePrompt,
        ToggleHistory,
        ApplyEdit,
-        ConfirmCommand
+        ConfirmCommand,
+        ToggleModelSelector
    ]
 );

--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -1,7 +1,7 @@
 use crate::prompts::{generate_content_prompt, PromptLibrary, PromptManager};
-use crate::slash_command::{search_command, tabs_command};
+use crate::slash_command::{rustdoc_command, search_command, tabs_command};
 use crate::{
-    assistant_settings::{AssistantDockPosition, AssistantSettings, ZedDotDevModel},
+    assistant_settings::{AssistantDockPosition, AssistantSettings},
    codegen::{self, Codegen, CodegenKind},
    search::*,
    slash_command::{
@@ -9,17 +9,18 @@ use crate::{
        SlashCommandCompletionProvider, SlashCommandLine, SlashCommandRegistry,
    },
    ApplyEdit, Assist, CompletionProvider, ConfirmCommand, CycleMessageRole, InlineAssist,
-    LanguageModel, LanguageModelRequest, LanguageModelRequestMessage, MessageId, MessageMetadata,
-    MessageStatus, QuoteSelection, ResetKey, Role, SavedConversation, SavedConversationMetadata,
-    SavedMessage, Split, ToggleFocus, ToggleHistory,
+    LanguageModelRequest, LanguageModelRequestMessage, MessageId, MessageMetadata, MessageStatus,
+    QuoteSelection, ResetKey, Role, SavedConversation, SavedConversationMetadata, SavedMessage,
+    Split, ToggleFocus, ToggleHistory,
 };
+use crate::{ModelSelector, ToggleModelSelector};
 use anyhow::{anyhow, Result};
 use assistant_slash_command::{SlashCommandOutput, SlashCommandOutputSection};
 use client::telemetry::Telemetry;
 use collections::{hash_map, BTreeSet, HashMap, HashSet, VecDeque};
-use editor::actions::UnfoldAt;
+use editor::actions::ShowCompletions;
 use editor::{
-    actions::{FoldAt, MoveDown, MoveUp},
+    actions::{FoldAt, MoveDown, MoveToEndOfLine, MoveUp, Newline, UnfoldAt},
    display_map::{
        BlockContext, BlockDisposition, BlockId, BlockProperties, BlockStyle, Flap, ToDisplayPoint,
    },
@@ -64,8 +65,8 @@ use std::{
 use telemetry_events::AssistantKind;
 use theme::ThemeSettings;
 use ui::{
-    popover_menu, prelude::*, ButtonLike, ContextMenu, ElevationIndex, KeyBinding, Tab, TabBar,
-    Tooltip,
+    popover_menu, prelude::*, ButtonLike, ContextMenu, ElevationIndex, KeyBinding,
+    PopoverMenuHandle, Tab, TabBar, Tooltip,
 };
 use util::{paths::CONVERSATIONS_DIR, post_inc, ResultExt, TryFutureExt};
 use uuid::Uuid;
@@ -119,8 +120,8 @@ pub struct AssistantPanel {
    pending_inline_assist_ids_by_editor: HashMap<WeakView<Editor>, Vec<usize>>,
    inline_prompt_history: VecDeque<String>,
    _watch_saved_conversations: Task<Result<()>>,
-    model: LanguageModel,
    authentication_prompt: Option<AnyView>,
+    model_menu_handle: PopoverMenuHandle<ContextMenu>,
 }

 struct ActiveConversationEditor {
@@ -203,7 +204,6 @@ impl AssistantPanel {
                            }
                        }),
                    ];
-                    let model = CompletionProvider::global(cx).default_model();

                    cx.observe_global::<FileIcons>(|_, cx| {
                        cx.notify();
@@ -212,14 +212,20 @@ impl AssistantPanel {

                    let slash_command_registry = SlashCommandRegistry::global(cx);

-                    slash_command_registry.register_command(file_command::FileSlashCommand);
+                    slash_command_registry.register_command(file_command::FileSlashCommand, true);
                    slash_command_registry.register_command(
                        prompt_command::PromptSlashCommand::new(prompt_library.clone()),
+                        true,
                    );
-                    slash_command_registry.register_command(active_command::ActiveSlashCommand);
-                    slash_command_registry.register_command(tabs_command::TabsSlashCommand);
-                    slash_command_registry.register_command(project_command::ProjectSlashCommand);
-                    slash_command_registry.register_command(search_command::SearchSlashCommand);
+                    slash_command_registry
+                        .register_command(active_command::ActiveSlashCommand, true);
+                    slash_command_registry.register_command(tabs_command::TabsSlashCommand, true);
+                    slash_command_registry
+                        .register_command(project_command::ProjectSlashCommand, true);
+                    slash_command_registry
+                        .register_command(search_command::SearchSlashCommand, true);
+                    slash_command_registry
+                        .register_command(rustdoc_command::RustdocSlashCommand, false);

                    Self {
                        workspace: workspace_handle,
@@ -243,8 +249,8 @@ impl AssistantPanel {
                        pending_inline_assist_ids_by_editor: Default::default(),
                        inline_prompt_history: Default::default(),
                        _watch_saved_conversations,
-                        model,
                        authentication_prompt: None,
+                        model_menu_handle: PopoverMenuHandle::default(),
                    }
                })
            })
@@ -276,12 +282,20 @@ impl AssistantPanel {
        if self.is_authenticated(cx) {
            self.authentication_prompt = None;

-            let model = CompletionProvider::global(cx).default_model();
-            self.set_model(model, cx);
+            if let Some(editor) = self.active_conversation_editor() {
+                editor.update(cx, |active_conversation, cx| {
+                    active_conversation
+                        .conversation
+                        .update(cx, |conversation, cx| {
+                            conversation.completion_provider_changed(cx)
+                        })
+                })
+            }

            if self.active_conversation_editor().is_none() {
                self.new_conversation(cx);
            }
+            cx.notify();
        } else if self.authentication_prompt.is_none()
            || prev_settings_version != CompletionProvider::global(cx).settings_version()
        {
@@ -289,6 +303,7 @@ impl AssistantPanel {
                Some(cx.update_global::<CompletionProvider, _>(|provider, cx| {
                    provider.authentication_prompt(cx)
                }));
+            cx.notify();
        }
    }

@@ -437,8 +452,8 @@ impl AssistantPanel {
                        let inline_assistant = inline_assistant.clone();
                        move |cx: &mut BlockContext| {
                            *measurements.lock() = BlockMeasurements {
-                                anchor_x: cx.anchor_x,
                                gutter_width: cx.gutter_dimensions.width,
+                                gutter_margin: cx.gutter_dimensions.margin,
                            };
                            inline_assistant.clone().into_any_element()
                        }
@@ -733,7 +748,7 @@ impl AssistantPanel {
                    .map(|message| message.to_request_message(buffer)),
            );
        }
-        let model = self.model.clone();
+        let model = CompletionProvider::global(cx).model();

        cx.spawn(|_, mut cx| async move {
            // I Don't know if we want to return a ? here.
@@ -808,7 +823,6 @@ impl AssistantPanel {

        let editor = cx.new_view(|cx| {
            ConversationEditor::new(
-                self.model.clone(),
                self.languages.clone(),
                self.slash_commands.clone(),
                self.fs.clone(),
@@ -849,53 +863,6 @@ impl AssistantPanel {
        cx.notify();
    }

-    fn cycle_model(&mut self, cx: &mut ViewContext<Self>) {
-        let next_model = match &self.model {
-            LanguageModel::OpenAi(model) => LanguageModel::OpenAi(match &model {
-                open_ai::Model::ThreePointFiveTurbo => open_ai::Model::Four,
-                open_ai::Model::Four => open_ai::Model::FourTurbo,
-                open_ai::Model::FourTurbo => open_ai::Model::FourOmni,
-                open_ai::Model::FourOmni => open_ai::Model::ThreePointFiveTurbo,
-            }),
-            LanguageModel::Anthropic(model) => LanguageModel::Anthropic(match &model {
-                anthropic::Model::Claude3Opus => anthropic::Model::Claude3Sonnet,
-                anthropic::Model::Claude3Sonnet => anthropic::Model::Claude3Haiku,
-                anthropic::Model::Claude3Haiku => anthropic::Model::Claude3Opus,
-            }),
-            LanguageModel::ZedDotDev(model) => LanguageModel::ZedDotDev(match &model {
-                ZedDotDevModel::Gpt3Point5Turbo => ZedDotDevModel::Gpt4,
-                ZedDotDevModel::Gpt4 => ZedDotDevModel::Gpt4Turbo,
-                ZedDotDevModel::Gpt4Turbo => ZedDotDevModel::Gpt4Omni,
-                ZedDotDevModel::Gpt4Omni => ZedDotDevModel::Claude3Opus,
-                ZedDotDevModel::Claude3Opus => ZedDotDevModel::Claude3Sonnet,
-                ZedDotDevModel::Claude3Sonnet => ZedDotDevModel::Claude3Haiku,
-                ZedDotDevModel::Claude3Haiku => {
-                    match CompletionProvider::global(cx).default_model() {
-                        LanguageModel::ZedDotDev(custom @ ZedDotDevModel::Custom(_)) => custom,
-                        _ => ZedDotDevModel::Gpt3Point5Turbo,
-                    }
-                }
-                ZedDotDevModel::Custom(_) => ZedDotDevModel::Gpt3Point5Turbo,
-            }),
-        };
-
-        self.set_model(next_model, cx);
-    }
-
-    fn set_model(&mut self, model: LanguageModel, cx: &mut ViewContext<Self>) {
-        self.model = model.clone();
-        if let Some(editor) = self.active_conversation_editor() {
-            editor.update(cx, |active_conversation, cx| {
-                active_conversation
-                    .conversation
-                    .update(cx, |conversation, cx| {
-                        conversation.set_model(model, cx);
-                    })
-            })
-        }
-        cx.notify();
-    }
-
    fn handle_conversation_editor_event(
        &mut self,
        _: View<ConversationEditor>,
@@ -977,6 +944,18 @@ impl AssistantPanel {
            .detach_and_log_err(cx);
    }

+    fn toggle_model_selector(&mut self, _: &ToggleModelSelector, cx: &mut ViewContext<Self>) {
+        self.model_menu_handle.toggle(cx);
+    }
+
+    fn insert_command(&mut self, name: &str, cx: &mut ViewContext<Self>) {
+        if let Some(conversation_editor) = self.active_conversation_editor() {
+            conversation_editor.update(cx, |conversation_editor, cx| {
+                conversation_editor.insert_command(name, cx)
+            });
+        }
+    }
+
    fn active_conversation_editor(&self) -> Option<&View<ConversationEditor>> {
        Some(&self.active_conversation_editor.as_ref()?.editor)
    }
@@ -1014,52 +993,65 @@ impl AssistantPanel {
            })
    }

-    fn render_inject_context_menu(&self, _cx: &mut ViewContext<Self>) -> impl Element {
-        let workspace = self.workspace.clone();
+    fn render_inject_context_menu(&self, cx: &mut ViewContext<Self>) -> impl Element {
+        let commands = self.slash_commands.clone();
+        let assistant_panel = cx.view().downgrade();
+        let active_editor_focus_handle = self.workspace.upgrade().and_then(|workspace| {
+            Some(
+                workspace
+                    .read(cx)
+                    .active_item_as::<Editor>(cx)?
+                    .focus_handle(cx),
+            )
+        });

        popover_menu("inject-context-menu")
            .trigger(IconButton::new("trigger", IconName::Quote).tooltip(|cx| {
-                // Tooltip::with_meta("Insert Context", None, "Type # to insert via keyboard", cx)
-                Tooltip::text("Insert Context", cx)
+                Tooltip::with_meta("Insert Context", None, "Type / to insert via keyboard", cx)
            }))
            .menu(move |cx| {
-                ContextMenu::build(cx, |menu, _cx| {
-                    // menu.entry("Insert Search", None, {
-                    //     let assistant = assistant.clone();
-                    //     move |_cx| {}
-                    // })
-                    // .entry("Insert Docs", None, {
-                    //     let assistant = assistant.clone();
-                    //     move |cx| {}
-                    // })
-                    menu.entry("Quote Selection", None, {
-                        let workspace = workspace.clone();
-                        move |cx| {
-                            workspace
-                                .update(cx, |workspace, cx| {
-                                    ConversationEditor::quote_selection(
-                                        workspace,
-                                        &Default::default(),
-                                        cx,
-                                    )
-                                })
-                                .ok();
+                ContextMenu::build(cx, |mut menu, _cx| {
+                    for command_name in commands.featured_command_names() {
+                        if let Some(command) = commands.command(&command_name) {
+                            let menu_text = SharedString::from(Arc::from(command.menu_text()));
+                            menu = menu.custom_entry(
+                                {
+                                    let command_name = command_name.clone();
+                                    move |_cx| {
+                                        h_flex()
+                                            .w_full()
+                                            .justify_between()
+                                            .child(Label::new(menu_text.clone()))
+                                            .child(
+                                                div().ml_4().child(
+                                                    Label::new(format!("/{command_name}"))
+                                                        .color(Color::Muted),
+                                                ),
+                                            )
+                                            .into_any()
+                                    }
+                                },
+                                {
+                                    let assistant_panel = assistant_panel.clone();
+                                    move |cx| {
+                                        assistant_panel
+                                            .update(cx, |assistant_panel, cx| {
+                                                assistant_panel.insert_command(&command_name, cx)
+                                            })
+                                            .ok();
+                                    }
+                                },
+                            )
                        }
-                    })
-                    // .entry("Insert Active Prompt", None, {
-                    //     let workspace = workspace.clone();
-                    //     move |cx| {
-                    //         workspace
-                    //             .update(cx, |workspace, cx| {
-                    //                 ConversationEditor::insert_active_prompt(
-                    //                     workspace,
-                    //                     &Default::default(),
-                    //                     cx,
-                    //                 )
-                    //             })
-                    //             .ok();
-                    //     }
-                    // })
+                    }
+
+                    if let Some(active_editor_focus_handle) = active_editor_focus_handle.clone() {
+                        menu = menu
+                            .context(active_editor_focus_handle)
+                            .action("Quote Selection", Box::new(QuoteSelection));
+                    }
+
+                    menu
                })
                .into()
            })
@@ -1132,10 +1124,8 @@ impl AssistantPanel {

        cx.spawn(|this, mut cx| async move {
            let saved_conversation = SavedConversation::load(&path, fs.as_ref()).await?;
-            let model = this.update(&mut cx, |this, _| this.model.clone())?;
            let conversation = Conversation::deserialize(
                saved_conversation,
-                model,
                path.clone(),
                languages,
                slash_commands,
@@ -1205,7 +1195,10 @@ impl AssistantPanel {
                        this.child(
                            h_flex()
                                .gap_1()
-                                .child(self.render_model(&conversation, cx))
+                                .child(ModelSelector::new(
+                                    self.model_menu_handle.clone(),
+                                    self.fs.clone(),
+                                ))
                                .children(self.render_remaining_tokens(&conversation, cx)),
                        )
                        .child(
@@ -1255,6 +1248,7 @@ impl AssistantPanel {
            .on_action(cx.listener(AssistantPanel::select_prev_match))
            .on_action(cx.listener(AssistantPanel::handle_editor_cancel))
            .on_action(cx.listener(AssistantPanel::reset_credentials))
+            .on_action(cx.listener(AssistantPanel::toggle_model_selector))
            .track_focus(&self.focus_handle)
            .child(header)
            .children(if self.toolbar.read(cx).hidden() {
@@ -1313,23 +1307,12 @@ impl AssistantPanel {
            ))
    }

-    fn render_model(
-        &self,
-        conversation: &Model<Conversation>,
-        cx: &mut ViewContext<Self>,
-    ) -> impl IntoElement {
-        Button::new("current_model", conversation.read(cx).model.display_name())
-            .style(ButtonStyle::Filled)
-            .tooltip(move |cx| Tooltip::text("Change Model", cx))
-            .on_click(cx.listener(|this, _, cx| this.cycle_model(cx)))
-    }
-
    fn render_remaining_tokens(
        &self,
        conversation: &Model<Conversation>,
        cx: &mut ViewContext<Self>,
    ) -> Option<impl IntoElement> {
-        let remaining_tokens = conversation.read(cx).remaining_tokens()?;
+        let remaining_tokens = conversation.read(cx).remaining_tokens(cx)?;
        let remaining_tokens_color = if remaining_tokens <= 0 {
            Color::Error
        } else if remaining_tokens <= 500 {
@@ -1485,7 +1468,6 @@ pub struct Conversation {
    pending_summary: Task<Option<()>>,
    completion_count: usize,
    pending_completions: Vec<PendingCompletion>,
-    model: LanguageModel,
    token_count: Option<usize>,
    pending_token_count: Task<Option<()>>,
    pending_edit_suggestion_parse: Option<Task<()>>,
@@ -1501,7 +1483,6 @@ impl EventEmitter<ConversationEvent> for Conversation {}

 impl Conversation {
    fn new(
-        model: LanguageModel,
        language_registry: Arc<LanguageRegistry>,
        slash_command_registry: Arc<SlashCommandRegistry>,
        telemetry: Option<Arc<Telemetry>>,
@@ -1529,7 +1510,6 @@ impl Conversation {
            token_count: None,
            pending_token_count: Task::ready(None),
            pending_edit_suggestion_parse: None,
-            model,
            _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)],
            pending_save: Task::ready(Ok(())),
            path: None,
@@ -1582,7 +1562,6 @@ impl Conversation {
    #[allow(clippy::too_many_arguments)]
    async fn deserialize(
        saved_conversation: SavedConversation,
-        model: LanguageModel,
        path: PathBuf,
        language_registry: Arc<LanguageRegistry>,
        slash_command_registry: Arc<SlashCommandRegistry>,
@@ -1639,7 +1618,6 @@ impl Conversation {
                token_count: None,
                pending_edit_suggestion_parse: None,
                pending_token_count: Task::ready(None),
-                model,
                _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)],
                pending_save: Task::ready(Ok(())),
                path: Some(path),
@@ -1768,7 +1746,6 @@ impl Conversation {
                            let pending_command = PendingSlashCommand {
                                name: name.to_string(),
                                argument: argument.map(ToString::to_string),
-                                tooltip_text: command.tooltip_text().into(),
                                source_range,
                                status: PendingSlashCommandStatus::Idle,
                            };
@@ -1937,12 +1914,12 @@ impl Conversation {
        }
    }

-    fn remaining_tokens(&self) -> Option<isize> {
-        Some(self.model.max_token_count() as isize - self.token_count? as isize)
+    fn remaining_tokens(&self, cx: &AppContext) -> Option<isize> {
+        let model = CompletionProvider::global(cx).model();
+        Some(model.max_token_count() as isize - self.token_count? as isize)
    }

-    fn set_model(&mut self, model: LanguageModel, cx: &mut ModelContext<Self>) {
-        self.model = model;
+    fn completion_provider_changed(&mut self, cx: &mut ModelContext<Self>) {
        self.count_remaining_tokens(cx);
    }

@@ -2078,10 +2055,11 @@ impl Conversation {
                            }

                            if let Some(telemetry) = this.telemetry.as_ref() {
+                                let model = CompletionProvider::global(cx).model();
                                telemetry.report_assistant_event(
                                    this.id.clone(),
                                    AssistantKind::Panel,
-                                    this.model.telemetry_id(),
+                                    model.telemetry_id(),
                                    response_latency,
                                    error_message,
                                );
@@ -2110,7 +2088,7 @@ impl Conversation {
            .map(|message| message.to_request_message(self.buffer.read(cx)));

        LanguageModelRequest {
-            model: self.model.clone(),
+            model: CompletionProvider::global(cx).model(),
            messages: messages.collect(),
            stop: vec![],
            temperature: 1.0,
@@ -2299,7 +2277,7 @@ impl Conversation {
                        .into(),
                }));
            let request = LanguageModelRequest {
-                model: self.model.clone(),
+                model: CompletionProvider::global(cx).model(),
                messages: messages.collect(),
                stop: vec![],
                temperature: 1.0,
@@ -2564,7 +2542,6 @@ struct PendingSlashCommand {
    argument: Option<String>,
    status: PendingSlashCommandStatus,
    source_range: Range<language::Anchor>,
-    tooltip_text: SharedString,
 }

 #[derive(Clone)]
@@ -2604,7 +2581,6 @@ pub struct ConversationEditor {

 impl ConversationEditor {
    fn new(
-        model: LanguageModel,
        language_registry: Arc<LanguageRegistry>,
        slash_command_registry: Arc<SlashCommandRegistry>,
        fs: Arc<dyn Fs>,
@@ -2617,7 +2593,6 @@ impl ConversationEditor {

        let conversation = cx.new_model(|cx| {
            Conversation::new(
-                model,
                language_registry,
                slash_command_registry,
                Some(telemetry),
@@ -2739,11 +2714,47 @@ impl ConversationEditor {
            .collect()
    }

+    fn insert_command(&mut self, name: &str, cx: &mut ViewContext<Self>) {
+        if let Some(command) = self.slash_command_registry.command(name) {
+            self.editor.update(cx, |editor, cx| {
+                editor.transact(cx, |editor, cx| {
+                    editor.change_selections(Some(Autoscroll::fit()), cx, |s| s.try_cancel());
+                    let snapshot = editor.buffer().read(cx).snapshot(cx);
+                    let newest_cursor = editor.selections.newest::<Point>(cx).head();
+                    if newest_cursor.column > 0
+                        || snapshot
+                            .chars_at(newest_cursor)
+                            .next()
+                            .map_or(false, |ch| ch != '\n')
+                    {
+                        editor.move_to_end_of_line(
+                            &MoveToEndOfLine {
+                                stop_at_soft_wraps: false,
+                            },
+                            cx,
+                        );
+                        editor.newline(&Newline, cx);
+                    }
+
+                    editor.insert(&format!("/{name}"), cx);
+                    if command.requires_argument() {
+                        editor.insert(" ", cx);
+                        editor.show_completions(&ShowCompletions, cx);
+                    }
+                });
+            });
+            if !command.requires_argument() {
+                self.confirm_command(&ConfirmCommand, cx);
+            }
+        }
+    }
+
    pub fn confirm_command(&mut self, _: &ConfirmCommand, cx: &mut ViewContext<Self>) {
        let selections = self.editor.read(cx).selections.disjoint_anchors();
        let mut commands_by_range = HashMap::default();
        let workspace = self.workspace.clone();
        self.conversation.update(cx, |conversation, cx| {
+            conversation.reparse_slash_commands(cx);
            for selection in selections.iter() {
                if let Some(command) =
                    conversation.pending_command_for_position(selection.head().text_anchor, cx)
@@ -2900,9 +2911,8 @@ impl ConversationEditor {
                                let confirm_command = confirm_command.clone();
                                let command = command.clone();
                                move |row, _, _, _cx: &mut WindowContext| {
-                                    render_pending_slash_command_toggle(
+                                    render_pending_slash_command_gutter_decoration(
                                        row,
-                                        command.tooltip_text.clone(),
                                        command.status.clone(),
                                        confirm_command.clone(),
                                    )
@@ -3514,8 +3524,7 @@ impl Render for InlineAssistant {
            .on_action(cx.listener(Self::move_down))
            .child(
                h_flex()
-                    .justify_center()
-                    .w(measurements.gutter_width)
+                    .w(measurements.gutter_width + measurements.gutter_margin)
                    .children(if let Some(error) = self.codegen.read(cx).error() {
                        let error_message = SharedString::from(error.to_string());
                        Some(
@@ -3528,12 +3537,7 @@ impl Render for InlineAssistant {
                        None
                    }),
            )
-            .child(
-                h_flex()
-                    .w_full()
-                    .ml(measurements.anchor_x - measurements.gutter_width)
-                    .child(self.render_prompt_editor(cx)),
-            )
+            .child(h_flex().flex_1().child(self.render_prompt_editor(cx)))
    }
 }

@@ -3702,8 +3706,8 @@ impl InlineAssistant {
 // This wouldn't need to exist if we could pass parameters when rendering child views.
 #[derive(Copy, Clone, Default)]
 struct BlockMeasurements {
-    anchor_x: Pixels,
    gutter_width: Pixels,
+    gutter_margin: Pixels,
 }

 struct PendingInlineAssist {
@@ -3735,14 +3739,13 @@ fn render_slash_command_output_toggle(
    .into_any_element()
 }

-fn render_pending_slash_command_toggle(
+fn render_pending_slash_command_gutter_decoration(
    row: MultiBufferRow,
-    tooltip_text: SharedString,
    status: PendingSlashCommandStatus,
    confirm_command: Arc<dyn Fn(&mut WindowContext)>,
 ) -> AnyElement {
    let mut icon = IconButton::new(
-        ("slash-command-output-fold-indicator", row.0),
+        ("slash-command-gutter-decoration", row.0),
        ui::IconName::TriangleRight,
    )
    .on_click(move |_e, cx| confirm_command(cx))
@@ -3751,14 +3754,10 @@ fn render_pending_slash_command_toggle(

    match status {
        PendingSlashCommandStatus::Idle => {
-            icon = icon
-                .icon_color(Color::Muted)
-                .tooltip(move |cx| Tooltip::text(tooltip_text.clone(), cx));
+            icon = icon.icon_color(Color::Muted);
        }
        PendingSlashCommandStatus::Running { .. } => {
-            icon = icon
-                .selected(true)
-                .tooltip(move |cx| Tooltip::text(tooltip_text.clone(), cx));
+            icon = icon.selected(true);
        }
        PendingSlashCommandStatus::Error(error) => {
            icon = icon
@@ -3846,15 +3845,8 @@ mod tests {
        init(cx);
        let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));

-        let conversation = cx.new_model(|cx| {
-            Conversation::new(
-                LanguageModel::default(),
-                registry,
-                Default::default(),
-                None,
-                cx,
-            )
-        });
+        let conversation =
+            cx.new_model(|cx| Conversation::new(registry, Default::default(), None, cx));
        let buffer = conversation.read(cx).buffer.clone();

        let message_1 = conversation.read(cx).message_anchors[0].clone();
@@ -3985,15 +3977,8 @@ mod tests {
        init(cx);
        let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));

-        let conversation = cx.new_model(|cx| {
-            Conversation::new(
-                LanguageModel::default(),
-                registry,
-                Default::default(),
-                None,
-                cx,
-            )
-        });
+        let conversation =
+            cx.new_model(|cx| Conversation::new(registry, Default::default(), None, cx));
        let buffer = conversation.read(cx).buffer.clone();

        let message_1 = conversation.read(cx).message_anchors[0].clone();
@@ -4091,15 +4076,8 @@ mod tests {
        cx.set_global(settings_store);
        init(cx);
        let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
-        let conversation = cx.new_model(|cx| {
-            Conversation::new(
-                LanguageModel::default(),
-                registry,
-                Default::default(),
-                None,
-                cx,
-            )
-        });
+        let conversation =
+            cx.new_model(|cx| Conversation::new(registry, Default::default(), None, cx));
        let buffer = conversation.read(cx).buffer.clone();

        let message_1 = conversation.read(cx).message_anchors[0].clone();
@@ -4202,21 +4180,15 @@ mod tests {
        let prompt_library = Arc::new(PromptLibrary::default());
        let slash_command_registry = SlashCommandRegistry::new();

-        slash_command_registry.register_command(file_command::FileSlashCommand);
-        slash_command_registry.register_command(prompt_command::PromptSlashCommand::new(
-            prompt_library.clone(),
-        ));
+        slash_command_registry.register_command(file_command::FileSlashCommand, false);
+        slash_command_registry.register_command(
+            prompt_command::PromptSlashCommand::new(prompt_library.clone()),
+            false,
+        );

        let registry = Arc::new(LanguageRegistry::test(cx.executor()));
-        let conversation = cx.new_model(|cx| {
-            Conversation::new(
-                LanguageModel::default(),
-                registry.clone(),
-                slash_command_registry,
-                None,
-                cx,
-            )
-        });
+        let conversation = cx
+            .new_model(|cx| Conversation::new(registry.clone(), slash_command_registry, None, cx));

        let output_ranges = Rc::new(RefCell::new(HashSet::default()));
        conversation.update(cx, |_, cx| {
@@ -4389,15 +4361,8 @@ mod tests {
        cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
        cx.update(init);
        let registry = Arc::new(LanguageRegistry::test(cx.executor()));
-        let conversation = cx.new_model(|cx| {
-            Conversation::new(
-                LanguageModel::default(),
-                registry.clone(),
-                Default::default(),
-                None,
-                cx,
-            )
-        });
+        let conversation =
+            cx.new_model(|cx| Conversation::new(registry.clone(), Default::default(), None, cx));
        let buffer = conversation.read_with(cx, |conversation, _| conversation.buffer.clone());
        let message_0 =
            conversation.read_with(cx, |conversation, _| conversation.message_anchors[0].id);
@@ -4433,7 +4398,6 @@ mod tests {

        let deserialized_conversation = Conversation::deserialize(
            conversation.read_with(cx, |conversation, cx| conversation.serialize(cx)),
-            LanguageModel::default(),
            Default::default(),
            registry.clone(),
            Default::default(),
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -12,8 +12,11 @@ use serde::{
    Deserialize, Deserializer, Serialize, Serializer,
 };
 use settings::{Settings, SettingsSources};
+use strum::{EnumIter, IntoEnumIterator};

-#[derive(Clone, Debug, Default, PartialEq)]
+use crate::LanguageModel;
+
+#[derive(Clone, Debug, Default, PartialEq, EnumIter)]
 pub enum ZedDotDevModel {
    Gpt3Point5Turbo,
    Gpt4,
@@ -53,13 +56,10 @@ impl<'de> Deserialize<'de> for ZedDotDevModel {
            where
                E: de::Error,
            {
-                match value {
-                    "gpt-3.5-turbo" => Ok(ZedDotDevModel::Gpt3Point5Turbo),
-                    "gpt-4" => Ok(ZedDotDevModel::Gpt4),
-                    "gpt-4-turbo-preview" => Ok(ZedDotDevModel::Gpt4Turbo),
-                    "gpt-4o" => Ok(ZedDotDevModel::Gpt4Omni),
-                    _ => Ok(ZedDotDevModel::Custom(value.to_owned())),
-                }
+                let model = ZedDotDevModel::iter()
+                    .find(|model| model.id() == value)
+                    .unwrap_or_else(|| ZedDotDevModel::Custom(value.to_string()));
+                Ok(model)
            }
        }

@@ -73,24 +73,23 @@ impl JsonSchema for ZedDotDevModel {
    }

    fn json_schema(_generator: &mut schemars::gen::SchemaGenerator) -> Schema {
-        let variants = vec![
-            "gpt-3.5-turbo".to_owned(),
-            "gpt-4".to_owned(),
-            "gpt-4-turbo-preview".to_owned(),
-            "gpt-4o".to_owned(),
-        ];
+        let variants = ZedDotDevModel::iter()
+            .filter_map(|model| {
+                let id = model.id();
+                if id.is_empty() {
+                    None
+                } else {
+                    Some(id.to_string())
+                }
+            })
+            .collect::<Vec<_>>();
        Schema::Object(SchemaObject {
            instance_type: Some(InstanceType::String.into()),
-            enum_values: Some(variants.into_iter().map(|s| s.into()).collect()),
+            enum_values: Some(variants.iter().map(|s| s.clone().into()).collect()),
            metadata: Some(Box::new(Metadata {
                title: Some("ZedDotDevModel".to_owned()),
-                default: Some(serde_json::json!("gpt-4-turbo-preview")),
-                examples: vec![
-                    serde_json::json!("gpt-3.5-turbo"),
-                    serde_json::json!("gpt-4"),
-                    serde_json::json!("gpt-4-turbo-preview"),
-                    serde_json::json!("custom-model-name"),
-                ],
+                default: Some(ZedDotDevModel::default().id().into()),
+                examples: variants.into_iter().map(Into::into).collect(),
                ..Default::default()
            })),
            ..Default::default()
@@ -145,51 +144,55 @@ pub enum AssistantDockPosition {
    Bottom,
 }

-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
-#[serde(tag = "name", rename_all = "snake_case")]
+#[derive(Debug, PartialEq)]
 pub enum AssistantProvider {
-    #[serde(rename = "zed.dev")]
    ZedDotDev {
-        #[serde(default)]
-        default_model: ZedDotDevModel,
+        model: ZedDotDevModel,
    },
-    #[serde(rename = "openai")]
    OpenAi {
-        #[serde(default)]
-        default_model: OpenAiModel,
-        #[serde(default = "open_ai_url")]
+        model: OpenAiModel,
        api_url: String,
-        #[serde(default)]
        low_speed_timeout_in_seconds: Option<u64>,
    },
-    #[serde(rename = "anthropic")]
    Anthropic {
-        #[serde(default)]
-        default_model: AnthropicModel,
-        #[serde(default = "anthropic_api_url")]
+        model: AnthropicModel,
        api_url: String,
-        #[serde(default)]
        low_speed_timeout_in_seconds: Option<u64>,
    },
 }

 impl Default for AssistantProvider {
    fn default() -> Self {
-        Self::ZedDotDev {
-            default_model: ZedDotDevModel::default(),
+        Self::OpenAi {
+            model: OpenAiModel::default(),
+            api_url: open_ai::OPEN_AI_API_URL.into(),
+            low_speed_timeout_in_seconds: None,
        }
    }
 }

-fn open_ai_url() -> String {
-    open_ai::OPEN_AI_API_URL.to_string()
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[serde(tag = "name", rename_all = "snake_case")]
+pub enum AssistantProviderContent {
+    #[serde(rename = "zed.dev")]
+    ZedDotDev {
+        default_model: Option<ZedDotDevModel>,
+    },
+    #[serde(rename = "openai")]
+    OpenAi {
+        default_model: Option<OpenAiModel>,
+        api_url: Option<String>,
+        low_speed_timeout_in_seconds: Option<u64>,
+    },
+    #[serde(rename = "anthropic")]
+    Anthropic {
+        default_model: Option<AnthropicModel>,
+        api_url: Option<String>,
+        low_speed_timeout_in_seconds: Option<u64>,
+    },
 }

-fn anthropic_api_url() -> String {
-    anthropic::ANTHROPIC_API_URL.to_string()
-}
-
-#[derive(Default, Debug, Deserialize, Serialize)]
+#[derive(Debug, Default)]
 pub struct AssistantSettings {
    pub enabled: bool,
    pub button: bool,
@@ -240,16 +243,16 @@ impl AssistantSettingsContent {
                default_width: settings.default_width,
                default_height: settings.default_height,
                provider: if let Some(open_ai_api_url) = settings.openai_api_url.as_ref() {
-                    Some(AssistantProvider::OpenAi {
-                        default_model: settings.default_open_ai_model.clone().unwrap_or_default(),
-                        api_url: open_ai_api_url.clone(),
+                    Some(AssistantProviderContent::OpenAi {
+                        default_model: settings.default_open_ai_model.clone(),
+                        api_url: Some(open_ai_api_url.clone()),
                        low_speed_timeout_in_seconds: None,
                    })
                } else {
                    settings.default_open_ai_model.clone().map(|open_ai_model| {
-                        AssistantProvider::OpenAi {
-                            default_model: open_ai_model,
-                            api_url: open_ai_url(),
+                        AssistantProviderContent::OpenAi {
+                            default_model: Some(open_ai_model),
+                            api_url: None,
                            low_speed_timeout_in_seconds: None,
                        }
                    })
@@ -270,6 +273,64 @@ impl AssistantSettingsContent {
            }
        }
    }
+
+    pub fn set_model(&mut self, new_model: LanguageModel) {
+        match self {
+            AssistantSettingsContent::Versioned(settings) => match settings {
+                VersionedAssistantSettingsContent::V1(settings) => match &mut settings.provider {
+                    Some(AssistantProviderContent::ZedDotDev {
+                        default_model: model,
+                    }) => {
+                        if let LanguageModel::ZedDotDev(new_model) = new_model {
+                            *model = Some(new_model);
+                        }
+                    }
+                    Some(AssistantProviderContent::OpenAi {
+                        default_model: model,
+                        ..
+                    }) => {
+                        if let LanguageModel::OpenAi(new_model) = new_model {
+                            *model = Some(new_model);
+                        }
+                    }
+                    Some(AssistantProviderContent::Anthropic {
+                        default_model: model,
+                        ..
+                    }) => {
+                        if let LanguageModel::Anthropic(new_model) = new_model {
+                            *model = Some(new_model);
+                        }
+                    }
+                    provider => match new_model {
+                        LanguageModel::ZedDotDev(model) => {
+                            *provider = Some(AssistantProviderContent::ZedDotDev {
+                                default_model: Some(model),
+                            })
+                        }
+                        LanguageModel::OpenAi(model) => {
+                            *provider = Some(AssistantProviderContent::OpenAi {
+                                default_model: Some(model),
+                                api_url: None,
+                                low_speed_timeout_in_seconds: None,
+                            })
+                        }
+                        LanguageModel::Anthropic(model) => {
+                            *provider = Some(AssistantProviderContent::Anthropic {
+                                default_model: Some(model),
+                                api_url: None,
+                                low_speed_timeout_in_seconds: None,
+                            })
+                        }
+                    },
+                },
+            },
+            AssistantSettingsContent::Legacy(settings) => {
+                if let LanguageModel::OpenAi(model) = new_model {
+                    settings.default_open_ai_model = Some(model);
+                }
+            }
+        }
+    }
 }

 #[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
@@ -318,7 +379,7 @@ pub struct AssistantSettingsContentV1 {
    ///
    /// This can either be the internal `zed.dev` service or an external `openai` service,
    /// each with their respective default models and configurations.
-    provider: Option<AssistantProvider>,
+    provider: Option<AssistantProviderContent>,
 }

 #[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
@@ -376,31 +437,82 @@ impl Settings for AssistantSettings {
            if let Some(provider) = value.provider.clone() {
                match (&mut settings.provider, provider) {
                    (
-                        AssistantProvider::ZedDotDev { default_model },
-                        AssistantProvider::ZedDotDev {
-                            default_model: default_model_override,
+                        AssistantProvider::ZedDotDev { model },
+                        AssistantProviderContent::ZedDotDev {
+                            default_model: model_override,
                        },
                    ) => {
-                        *default_model = default_model_override;
+                        merge(model, model_override);
                    }
                    (
                        AssistantProvider::OpenAi {
-                            default_model,
+                            model,
                            api_url,
                            low_speed_timeout_in_seconds,
                        },
-                        AssistantProvider::OpenAi {
-                            default_model: default_model_override,
+                        AssistantProviderContent::OpenAi {
+                            default_model: model_override,
                            api_url: api_url_override,
                            low_speed_timeout_in_seconds: low_speed_timeout_in_seconds_override,
                        },
                    ) => {
-                        *default_model = default_model_override;
-                        *api_url = api_url_override;
-                        *low_speed_timeout_in_seconds = low_speed_timeout_in_seconds_override;
+                        merge(model, model_override);
+                        merge(api_url, api_url_override);
+                        if let Some(low_speed_timeout_in_seconds_override) =
+                            low_speed_timeout_in_seconds_override
+                        {
+                            *low_speed_timeout_in_seconds =
+                                Some(low_speed_timeout_in_seconds_override);
+                        }
                    }
-                    (merged, provider_override) => {
-                        *merged = provider_override;
+                    (
+                        AssistantProvider::Anthropic {
+                            model,
+                            api_url,
+                            low_speed_timeout_in_seconds,
+                        },
+                        AssistantProviderContent::Anthropic {
+                            default_model: model_override,
+                            api_url: api_url_override,
+                            low_speed_timeout_in_seconds: low_speed_timeout_in_seconds_override,
+                        },
+                    ) => {
+                        merge(model, model_override);
+                        merge(api_url, api_url_override);
+                        if let Some(low_speed_timeout_in_seconds_override) =
+                            low_speed_timeout_in_seconds_override
+                        {
+                            *low_speed_timeout_in_seconds =
+                                Some(low_speed_timeout_in_seconds_override);
+                        }
+                    }
+                    (provider, provider_override) => {
+                        *provider = match provider_override {
+                            AssistantProviderContent::ZedDotDev {
+                                default_model: model,
+                            } => AssistantProvider::ZedDotDev {
+                                model: model.unwrap_or_default(),
+                            },
+                            AssistantProviderContent::OpenAi {
+                                default_model: model,
+                                api_url,
+                                low_speed_timeout_in_seconds,
+                            } => AssistantProvider::OpenAi {
+                                model: model.unwrap_or_default(),
+                                api_url: api_url.unwrap_or_else(|| open_ai::OPEN_AI_API_URL.into()),
+                                low_speed_timeout_in_seconds,
+                            },
+                            AssistantProviderContent::Anthropic {
+                                default_model: model,
+                                api_url,
+                                low_speed_timeout_in_seconds,
+                            } => AssistantProvider::Anthropic {
+                                model: model.unwrap_or_default(),
+                                api_url: api_url
+                                    .unwrap_or_else(|| anthropic::ANTHROPIC_API_URL.into()),
+                                low_speed_timeout_in_seconds,
+                            },
+                        };
                    }
                }
            }
@@ -410,7 +522,7 @@ impl Settings for AssistantSettings {
    }
 }

-fn merge<T: Copy>(target: &mut T, value: Option<T>) {
+fn merge<T>(target: &mut T, value: Option<T>) {
    if let Some(value) = value {
        *target = value;
    }
@@ -433,8 +545,8 @@ mod tests {
        assert_eq!(
            AssistantSettings::get_global(cx).provider,
            AssistantProvider::OpenAi {
-                default_model: OpenAiModel::FourOmni,
-                api_url: open_ai_url(),
+                model: OpenAiModel::FourOmni,
+                api_url: open_ai::OPEN_AI_API_URL.into(),
                low_speed_timeout_in_seconds: None,
            }
        );
@@ -455,7 +567,7 @@ mod tests {
        assert_eq!(
            AssistantSettings::get_global(cx).provider,
            AssistantProvider::OpenAi {
-                default_model: OpenAiModel::FourOmni,
+                model: OpenAiModel::FourOmni,
                api_url: "test-url".into(),
                low_speed_timeout_in_seconds: None,
            }
@@ -475,8 +587,8 @@ mod tests {
        assert_eq!(
            AssistantSettings::get_global(cx).provider,
            AssistantProvider::OpenAi {
-                default_model: OpenAiModel::Four,
-                api_url: open_ai_url(),
+                model: OpenAiModel::Four,
+                api_url: open_ai::OPEN_AI_API_URL.into(),
                low_speed_timeout_in_seconds: None,
            }
        );
@@ -501,7 +613,7 @@ mod tests {
        assert_eq!(
            AssistantSettings::get_global(cx).provider,
            AssistantProvider::ZedDotDev {
-                default_model: ZedDotDevModel::Custom("custom".into())
+                model: ZedDotDevModel::Custom("custom".into())
            }
        );
    }
--- a/crates/assistant/src/completion_provider.rs
+++ b/crates/assistant/src/completion_provider.rs
@@ -25,31 +25,26 @@ use std::time::Duration;
 pub fn init(client: Arc<Client>, cx: &mut AppContext) {
    let mut settings_version = 0;
    let provider = match &AssistantSettings::get_global(cx).provider {
-        AssistantProvider::ZedDotDev { default_model } => {
-            CompletionProvider::ZedDotDev(ZedDotDevCompletionProvider::new(
-                default_model.clone(),
-                client.clone(),
-                settings_version,
-                cx,
-            ))
-        }
+        AssistantProvider::ZedDotDev { model } => CompletionProvider::ZedDotDev(
+            ZedDotDevCompletionProvider::new(model.clone(), client.clone(), settings_version, cx),
+        ),
        AssistantProvider::OpenAi {
-            default_model,
+            model,
            api_url,
            low_speed_timeout_in_seconds,
        } => CompletionProvider::OpenAi(OpenAiCompletionProvider::new(
-            default_model.clone(),
+            model.clone(),
            api_url.clone(),
            client.http_client(),
            low_speed_timeout_in_seconds.map(Duration::from_secs),
            settings_version,
        )),
        AssistantProvider::Anthropic {
-            default_model,
+            model,
            api_url,
            low_speed_timeout_in_seconds,
        } => CompletionProvider::Anthropic(AnthropicCompletionProvider::new(
-            default_model.clone(),
+            model.clone(),
            api_url.clone(),
            client.http_client(),
            low_speed_timeout_in_seconds.map(Duration::from_secs),
@@ -65,13 +60,13 @@ pub fn init(client: Arc<Client>, cx: &mut AppContext) {
                (
                    CompletionProvider::OpenAi(provider),
                    AssistantProvider::OpenAi {
-                        default_model,
+                        model,
                        api_url,
                        low_speed_timeout_in_seconds,
                    },
                ) => {
                    provider.update(
-                        default_model.clone(),
+                        model.clone(),
                        api_url.clone(),
                        low_speed_timeout_in_seconds.map(Duration::from_secs),
                        settings_version,
@@ -80,13 +75,13 @@ pub fn init(client: Arc<Client>, cx: &mut AppContext) {
                (
                    CompletionProvider::Anthropic(provider),
                    AssistantProvider::Anthropic {
-                        default_model,
+                        model,
                        api_url,
                        low_speed_timeout_in_seconds,
                    },
                ) => {
                    provider.update(
-                        default_model.clone(),
+                        model.clone(),
                        api_url.clone(),
                        low_speed_timeout_in_seconds.map(Duration::from_secs),
                        settings_version,
@@ -94,13 +89,13 @@ pub fn init(client: Arc<Client>, cx: &mut AppContext) {
                }
                (
                    CompletionProvider::ZedDotDev(provider),
-                    AssistantProvider::ZedDotDev { default_model },
+                    AssistantProvider::ZedDotDev { model },
                ) => {
-                    provider.update(default_model.clone(), settings_version);
+                    provider.update(model.clone(), settings_version);
                }
-                (_, AssistantProvider::ZedDotDev { default_model }) => {
+                (_, AssistantProvider::ZedDotDev { model }) => {
                    *provider = CompletionProvider::ZedDotDev(ZedDotDevCompletionProvider::new(
-                        default_model.clone(),
+                        model.clone(),
                        client.clone(),
                        settings_version,
                        cx,
@@ -109,13 +104,13 @@ pub fn init(client: Arc<Client>, cx: &mut AppContext) {
                (
                    _,
                    AssistantProvider::OpenAi {
-                        default_model,
+                        model,
                        api_url,
                        low_speed_timeout_in_seconds,
                    },
                ) => {
                    *provider = CompletionProvider::OpenAi(OpenAiCompletionProvider::new(
-                        default_model.clone(),
+                        model.clone(),
                        api_url.clone(),
                        client.http_client(),
                        low_speed_timeout_in_seconds.map(Duration::from_secs),
@@ -125,13 +120,13 @@ pub fn init(client: Arc<Client>, cx: &mut AppContext) {
                (
                    _,
                    AssistantProvider::Anthropic {
-                        default_model,
+                        model,
                        api_url,
                        low_speed_timeout_in_seconds,
                    },
                ) => {
                    *provider = CompletionProvider::Anthropic(AnthropicCompletionProvider::new(
-                        default_model.clone(),
+                        model.clone(),
                        api_url.clone(),
                        client.http_client(),
                        low_speed_timeout_in_seconds.map(Duration::from_secs),
@@ -159,6 +154,25 @@ impl CompletionProvider {
        cx.global::<Self>()
    }

+    pub fn available_models(&self) -> Vec<LanguageModel> {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider
+                .available_models()
+                .map(LanguageModel::OpenAi)
+                .collect(),
+            CompletionProvider::Anthropic(provider) => provider
+                .available_models()
+                .map(LanguageModel::Anthropic)
+                .collect(),
+            CompletionProvider::ZedDotDev(provider) => provider
+                .available_models()
+                .map(LanguageModel::ZedDotDev)
+                .collect(),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => unimplemented!(),
+        }
+    }
+
    pub fn settings_version(&self) -> usize {
        match self {
            CompletionProvider::OpenAi(provider) => provider.settings_version(),
@@ -209,17 +223,13 @@ impl CompletionProvider {
        }
    }

-    pub fn default_model(&self) -> LanguageModel {
+    pub fn model(&self) -> LanguageModel {
        match self {
-            CompletionProvider::OpenAi(provider) => LanguageModel::OpenAi(provider.default_model()),
-            CompletionProvider::Anthropic(provider) => {
-                LanguageModel::Anthropic(provider.default_model())
-            }
-            CompletionProvider::ZedDotDev(provider) => {
-                LanguageModel::ZedDotDev(provider.default_model())
-            }
+            CompletionProvider::OpenAi(provider) => LanguageModel::OpenAi(provider.model()),
+            CompletionProvider::Anthropic(provider) => LanguageModel::Anthropic(provider.model()),
+            CompletionProvider::ZedDotDev(provider) => LanguageModel::ZedDotDev(provider.model()),
            #[cfg(test)]
-            CompletionProvider::Fake(_) => unimplemented!(),
+            CompletionProvider::Fake(_) => LanguageModel::default(),
        }
    }

--- a/crates/assistant/src/completion_provider/anthropic.rs
+++ b/crates/assistant/src/completion_provider/anthropic.rs
@@ -12,6 +12,7 @@ use http::HttpClient;
 use settings::Settings;
 use std::time::Duration;
 use std::{env, sync::Arc};
+use strum::IntoEnumIterator;
 use theme::ThemeSettings;
 use ui::prelude::*;
 use util::ResultExt;
@@ -19,7 +20,7 @@ use util::ResultExt;
 pub struct AnthropicCompletionProvider {
    api_key: Option<String>,
    api_url: String,
-    default_model: AnthropicModel,
+    model: AnthropicModel,
    http_client: Arc<dyn HttpClient>,
    low_speed_timeout: Option<Duration>,
    settings_version: usize,
@@ -27,7 +28,7 @@ pub struct AnthropicCompletionProvider {

 impl AnthropicCompletionProvider {
    pub fn new(
-        default_model: AnthropicModel,
+        model: AnthropicModel,
        api_url: String,
        http_client: Arc<dyn HttpClient>,
        low_speed_timeout: Option<Duration>,
@@ -36,7 +37,7 @@ impl AnthropicCompletionProvider {
        Self {
            api_key: None,
            api_url,
-            default_model,
+            model,
            http_client,
            low_speed_timeout,
            settings_version,
@@ -45,17 +46,21 @@ impl AnthropicCompletionProvider {

    pub fn update(
        &mut self,
-        default_model: AnthropicModel,
+        model: AnthropicModel,
        api_url: String,
        low_speed_timeout: Option<Duration>,
        settings_version: usize,
    ) {
-        self.default_model = default_model;
+        self.model = model;
        self.api_url = api_url;
        self.low_speed_timeout = low_speed_timeout;
        self.settings_version = settings_version;
    }

+    pub fn available_models(&self) -> impl Iterator<Item = AnthropicModel> {
+        AnthropicModel::iter()
+    }
+
    pub fn settings_version(&self) -> usize {
        self.settings_version
    }
@@ -105,8 +110,8 @@ impl AnthropicCompletionProvider {
            .into()
    }

-    pub fn default_model(&self) -> AnthropicModel {
-        self.default_model.clone()
+    pub fn model(&self) -> AnthropicModel {
+        self.model.clone()
    }

    pub fn count_tokens(
@@ -165,7 +170,7 @@ impl AnthropicCompletionProvider {
    fn to_anthropic_request(&self, request: LanguageModelRequest) -> Request {
        let model = match request.model {
            LanguageModel::Anthropic(model) => model,
-            _ => self.default_model(),
+            _ => self.model(),
        };

        let mut system_message = String::new();
--- a/crates/assistant/src/completion_provider/open_ai.rs
+++ b/crates/assistant/src/completion_provider/open_ai.rs
@@ -11,6 +11,7 @@ use open_ai::{stream_completion, Request, RequestMessage, Role as OpenAiRole};
 use settings::Settings;
 use std::time::Duration;
 use std::{env, sync::Arc};
+use strum::IntoEnumIterator;
 use theme::ThemeSettings;
 use ui::prelude::*;
 use util::ResultExt;
@@ -18,7 +19,7 @@ use util::ResultExt;
 pub struct OpenAiCompletionProvider {
    api_key: Option<String>,
    api_url: String,
-    default_model: OpenAiModel,
+    model: OpenAiModel,
    http_client: Arc<dyn HttpClient>,
    low_speed_timeout: Option<Duration>,
    settings_version: usize,
@@ -26,7 +27,7 @@ pub struct OpenAiCompletionProvider {

 impl OpenAiCompletionProvider {
    pub fn new(
-        default_model: OpenAiModel,
+        model: OpenAiModel,
        api_url: String,
        http_client: Arc<dyn HttpClient>,
        low_speed_timeout: Option<Duration>,
@@ -35,7 +36,7 @@ impl OpenAiCompletionProvider {
        Self {
            api_key: None,
            api_url,
-            default_model,
+            model,
            http_client,
            low_speed_timeout,
            settings_version,
@@ -44,17 +45,21 @@ impl OpenAiCompletionProvider {

    pub fn update(
        &mut self,
-        default_model: OpenAiModel,
+        model: OpenAiModel,
        api_url: String,
        low_speed_timeout: Option<Duration>,
        settings_version: usize,
    ) {
-        self.default_model = default_model;
+        self.model = model;
        self.api_url = api_url;
        self.low_speed_timeout = low_speed_timeout;
        self.settings_version = settings_version;
    }

+    pub fn available_models(&self) -> impl Iterator<Item = OpenAiModel> {
+        OpenAiModel::iter()
+    }
+
    pub fn settings_version(&self) -> usize {
        self.settings_version
    }
@@ -104,8 +109,8 @@ impl OpenAiCompletionProvider {
            .into()
    }

-    pub fn default_model(&self) -> OpenAiModel {
-        self.default_model.clone()
+    pub fn model(&self) -> OpenAiModel {
+        self.model.clone()
    }

    pub fn count_tokens(
@@ -152,7 +157,7 @@ impl OpenAiCompletionProvider {
    fn to_open_ai_request(&self, request: LanguageModelRequest) -> Request {
        let model = match request.model {
            LanguageModel::OpenAi(model) => model,
-            _ => self.default_model(),
+            _ => self.model(),
        };

        Request {
--- a/crates/assistant/src/completion_provider/zed.rs
+++ b/crates/assistant/src/completion_provider/zed.rs
@@ -7,11 +7,12 @@ use client::{proto, Client};
 use futures::{future::BoxFuture, stream::BoxStream, FutureExt, StreamExt, TryFutureExt};
 use gpui::{AnyView, AppContext, Task};
 use std::{future, sync::Arc};
+use strum::IntoEnumIterator;
 use ui::prelude::*;

 pub struct ZedDotDevCompletionProvider {
    client: Arc<Client>,
-    default_model: ZedDotDevModel,
+    model: ZedDotDevModel,
    settings_version: usize,
    status: client::Status,
    _maintain_client_status: Task<()>,
@@ -19,7 +20,7 @@ pub struct ZedDotDevCompletionProvider {

 impl ZedDotDevCompletionProvider {
    pub fn new(
-        default_model: ZedDotDevModel,
+        model: ZedDotDevModel,
        client: Arc<Client>,
        settings_version: usize,
        cx: &mut AppContext,
@@ -39,24 +40,39 @@ impl ZedDotDevCompletionProvider {
        });
        Self {
            client,
-            default_model,
+            model,
            settings_version,
            status,
            _maintain_client_status: maintain_client_status,
        }
    }

-    pub fn update(&mut self, default_model: ZedDotDevModel, settings_version: usize) {
-        self.default_model = default_model;
+    pub fn update(&mut self, model: ZedDotDevModel, settings_version: usize) {
+        self.model = model;
        self.settings_version = settings_version;
    }

+    pub fn available_models(&self) -> impl Iterator<Item = ZedDotDevModel> {
+        let mut custom_model = if let ZedDotDevModel::Custom(custom_model) = self.model.clone() {
+            Some(custom_model)
+        } else {
+            None
+        };
+        ZedDotDevModel::iter().filter_map(move |model| {
+            if let ZedDotDevModel::Custom(_) = model {
+                Some(ZedDotDevModel::Custom(custom_model.take()?))
+            } else {
+                Some(model)
+            }
+        })
+    }
+
    pub fn settings_version(&self) -> usize {
        self.settings_version
    }

-    pub fn default_model(&self) -> ZedDotDevModel {
-        self.default_model.clone()
+    pub fn model(&self) -> ZedDotDevModel {
+        self.model.clone()
    }

    pub fn is_authenticated(&self) -> bool {
--- a/crates/assistant/src/model_selector.rs
+++ b/crates/assistant/src/model_selector.rs
@@ -0,0 +1,84 @@
+use std::sync::Arc;
+
+use crate::{assistant_settings::AssistantSettings, CompletionProvider, ToggleModelSelector};
+use fs::Fs;
+use settings::update_settings_file;
+use ui::{popover_menu, prelude::*, ButtonLike, ContextMenu, PopoverMenuHandle, Tooltip};
+
+#[derive(IntoElement)]
+pub struct ModelSelector {
+    handle: PopoverMenuHandle<ContextMenu>,
+    fs: Arc<dyn Fs>,
+}
+
+impl ModelSelector {
+    pub fn new(handle: PopoverMenuHandle<ContextMenu>, fs: Arc<dyn Fs>) -> Self {
+        ModelSelector { handle, fs }
+    }
+}
+
+impl RenderOnce for ModelSelector {
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        popover_menu("model-switcher")
+            .with_handle(self.handle)
+            .menu(move |cx| {
+                ContextMenu::build(cx, |mut menu, cx| {
+                    for model in CompletionProvider::global(cx).available_models() {
+                        menu = menu.custom_entry(
+                            {
+                                let model = model.clone();
+                                move |_| Label::new(model.display_name()).into_any_element()
+                            },
+                            {
+                                let fs = self.fs.clone();
+                                let model = model.clone();
+                                move |cx| {
+                                    let model = model.clone();
+                                    update_settings_file::<AssistantSettings>(
+                                        fs.clone(),
+                                        cx,
+                                        move |settings| settings.set_model(model),
+                                    );
+                                }
+                            },
+                        );
+                    }
+                    menu
+                })
+                .into()
+            })
+            .trigger(
+                ButtonLike::new("active-model")
+                    .child(
+                        h_flex()
+                            .w_full()
+                            .gap_0p5()
+                            .child(
+                                div()
+                                    .overflow_x_hidden()
+                                    .flex_grow()
+                                    .whitespace_nowrap()
+                                    .child(
+                                        Label::new(
+                                            CompletionProvider::global(cx).model().display_name(),
+                                        )
+                                        .size(LabelSize::Small)
+                                        .color(Color::Muted),
+                                    ),
+                            )
+                            .child(
+                                div().child(
+                                    Icon::new(IconName::ChevronDown)
+                                        .color(Color::Muted)
+                                        .size(IconSize::XSmall),
+                                ),
+                            ),
+                    )
+                    .style(ButtonStyle::Subtle)
+                    .tooltip(move |cx| {
+                        Tooltip::for_action("Change Model", &ToggleModelSelector, cx)
+                    }),
+            )
+            .anchor(gpui::AnchorCorner::BottomRight)
+    }
+}
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -20,6 +20,7 @@ pub mod active_command;
 pub mod file_command;
 pub mod project_command;
 pub mod prompt_command;
+pub mod rustdoc_command;
 pub mod search_command;
 pub mod tabs_command;

--- a/crates/assistant/src/slash_command/active_command.rs
+++ b/crates/assistant/src/slash_command/active_command.rs
@@ -19,8 +19,8 @@ impl SlashCommand for ActiveSlashCommand {
        "insert active tab".into()
    }

-    fn tooltip_text(&self) -> String {
-        "insert active tab".into()
+    fn menu_text(&self) -> String {
+        "Insert Active Tab".into()
    }

    fn complete_argument(
--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -86,11 +86,11 @@ impl SlashCommand for FileSlashCommand {
    }

    fn description(&self) -> String {
-        "insert a file".into()
+        "insert file".into()
    }

-    fn tooltip_text(&self) -> String {
-        "insert file".into()
+    fn menu_text(&self) -> String {
+        "Insert File".into()
    }

    fn requires_argument(&self) -> bool {
--- a/crates/assistant/src/slash_command/project_command.rs
+++ b/crates/assistant/src/slash_command/project_command.rs
@@ -94,11 +94,11 @@ impl SlashCommand for ProjectSlashCommand {
    }

    fn description(&self) -> String {
-        "insert current project context".into()
+        "insert project metadata".into()
    }

-    fn tooltip_text(&self) -> String {
-        "insert current project context".into()
+    fn menu_text(&self) -> String {
+        "Insert Project Metadata".into()
    }

    fn complete_argument(
--- a/crates/assistant/src/slash_command/prompt_command.rs
+++ b/crates/assistant/src/slash_command/prompt_command.rs
@@ -25,11 +25,11 @@ impl SlashCommand for PromptSlashCommand {
    }

    fn description(&self) -> String {
-        "insert a prompt from the library".into()
+        "insert prompt from library".into()
    }

-    fn tooltip_text(&self) -> String {
-        "insert prompt".into()
+    fn menu_text(&self) -> String {
+        "Insert Prompt from Library".into()
    }

    fn requires_argument(&self) -> bool {
--- a/crates/assistant/src/slash_command/rustdoc_command.rs
+++ b/crates/assistant/src/slash_command/rustdoc_command.rs
@@ -0,0 +1,137 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use anyhow::{anyhow, bail, Context, Result};
+use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use futures::AsyncReadExt;
+use gpui::{AppContext, Task, WeakView};
+use http::{AsyncBody, HttpClient, HttpClientWithUrl};
+use language::LspAdapterDelegate;
+use rustdoc_to_markdown::convert_rustdoc_to_markdown;
+use ui::{prelude::*, ButtonLike, ElevationIndex};
+use workspace::Workspace;
+
+pub(crate) struct RustdocSlashCommand;
+
+impl RustdocSlashCommand {
+    async fn build_message(
+        http_client: Arc<HttpClientWithUrl>,
+        crate_name: String,
+    ) -> Result<String> {
+        let mut response = http_client
+            .get(
+                &format!("https://docs.rs/{crate_name}"),
+                AsyncBody::default(),
+                true,
+            )
+            .await?;
+
+        let mut body = Vec::new();
+        response
+            .body_mut()
+            .read_to_end(&mut body)
+            .await
+            .context("error reading docs.rs response body")?;
+
+        if response.status().is_client_error() {
+            let text = String::from_utf8_lossy(body.as_slice());
+            bail!(
+                "status error {}, response: {text:?}",
+                response.status().as_u16()
+            );
+        }
+
+        convert_rustdoc_to_markdown(&body[..])
+    }
+}
+
+impl SlashCommand for RustdocSlashCommand {
+    fn name(&self) -> String {
+        "rustdoc".into()
+    }
+
+    fn description(&self) -> String {
+        "insert Rust docs".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Insert Rust Documentation".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        true
+    }
+
+    fn complete_argument(
+        &self,
+        _query: String,
+        _cancel: Arc<AtomicBool>,
+        _workspace: WeakView<Workspace>,
+        _cx: &mut AppContext,
+    ) -> Task<Result<Vec<String>>> {
+        Task::ready(Ok(Vec::new()))
+    }
+
+    fn run(
+        self: Arc<Self>,
+        argument: Option<&str>,
+        workspace: WeakView<Workspace>,
+        _delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let Some(argument) = argument else {
+            return Task::ready(Err(anyhow!("missing crate name")));
+        };
+        let Some(workspace) = workspace.upgrade() else {
+            return Task::ready(Err(anyhow!("workspace was dropped")));
+        };
+
+        let http_client = workspace.read(cx).client().http_client();
+        let crate_name = argument.to_string();
+
+        let text = cx.background_executor().spawn({
+            let crate_name = crate_name.clone();
+            async move { Self::build_message(http_client, crate_name).await }
+        });
+
+        let crate_name = SharedString::from(crate_name);
+        cx.foreground_executor().spawn(async move {
+            let text = text.await?;
+            let range = 0..text.len();
+            Ok(SlashCommandOutput {
+                text,
+                sections: vec![SlashCommandOutputSection {
+                    range,
+                    render_placeholder: Arc::new(move |id, unfold, _cx| {
+                        RustdocPlaceholder {
+                            id,
+                            unfold,
+                            crate_name: crate_name.clone(),
+                        }
+                        .into_any_element()
+                    }),
+                }],
+            })
+        })
+    }
+}
+
+#[derive(IntoElement)]
+struct RustdocPlaceholder {
+    pub id: ElementId,
+    pub unfold: Arc<dyn Fn(&mut WindowContext)>,
+    pub crate_name: SharedString,
+}
+
+impl RenderOnce for RustdocPlaceholder {
+    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
+        let unfold = self.unfold;
+
+        ButtonLike::new(self.id)
+            .style(ButtonStyle::Filled)
+            .layer(ElevationIndex::ElevatedSurface)
+            .child(Icon::new(IconName::FileRust))
+            .child(Label::new(format!("rustdoc: {}", self.crate_name)))
+            .on_click(move |_, cx| unfold(cx))
+    }
+}
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -32,11 +32,11 @@ impl SlashCommand for SearchSlashCommand {
    }

    fn description(&self) -> String {
-        "semantically search files".into()
+        "semantic search".into()
    }

-    fn tooltip_text(&self) -> String {
-        "search".into()
+    fn menu_text(&self) -> String {
+        "Semantic Search".into()
    }

    fn requires_argument(&self) -> bool {
--- a/crates/assistant/src/slash_command/tabs_command.rs
+++ b/crates/assistant/src/slash_command/tabs_command.rs
@@ -17,11 +17,11 @@ impl SlashCommand for TabsSlashCommand {
    }

    fn description(&self) -> String {
-        "insert content from open tabs".into()
+        "insert open tabs".into()
    }

-    fn tooltip_text(&self) -> String {
-        "insert open tabs".into()
+    fn menu_text(&self) -> String {
+        "Insert Open Tabs".into()
    }

    fn requires_argument(&self) -> bool {
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -20,7 +20,7 @@ pub trait SlashCommand: 'static + Send + Sync {
        CodeLabel::plain(self.name(), None)
    }
    fn description(&self) -> String;
-    fn tooltip_text(&self) -> String;
+    fn menu_text(&self) -> String;
    fn complete_argument(
        &self,
        query: String,
--- a/crates/assistant_slash_command/src/slash_command_registry.rs
+++ b/crates/assistant_slash_command/src/slash_command_registry.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;

-use collections::HashMap;
+use collections::{BTreeSet, HashMap};
 use derive_more::{Deref, DerefMut};
 use gpui::Global;
 use gpui::{AppContext, ReadGlobal};
@@ -16,6 +16,7 @@ impl Global for GlobalSlashCommandRegistry {}
 #[derive(Default)]
 struct SlashCommandRegistryState {
    commands: HashMap<Arc<str>, Arc<dyn SlashCommand>>,
+    featured_commands: BTreeSet<Arc<str>>,
 }

 #[derive(Default)]
@@ -40,16 +41,19 @@ impl SlashCommandRegistry {
        Arc::new(Self {
            state: RwLock::new(SlashCommandRegistryState {
                commands: HashMap::default(),
+                featured_commands: BTreeSet::default(),
            }),
        })
    }

    /// Registers the provided [`SlashCommand`].
-    pub fn register_command(&self, command: impl SlashCommand) {
-        self.state
-            .write()
-            .commands
-            .insert(command.name().into(), Arc::new(command));
+    pub fn register_command(&self, command: impl SlashCommand, is_featured: bool) {
+        let mut state = self.state.write();
+        let command_name: Arc<str> = command.name().into();
+        if is_featured {
+            state.featured_commands.insert(command_name.clone());
+        }
+        state.commands.insert(command_name, Arc::new(command));
    }

    /// Returns the names of registered [`SlashCommand`]s.
@@ -57,6 +61,16 @@ impl SlashCommandRegistry {
        self.state.read().commands.keys().cloned().collect()
    }

+    /// Returns the names of registered, featured [`SlashCommand`]s.
+    pub fn featured_command_names(&self) -> Vec<Arc<str>> {
+        self.state
+            .read()
+            .featured_commands
+            .iter()
+            .cloned()
+            .collect()
+    }
+
    /// Returns the [`SlashCommand`] with the given name.
    pub fn command(&self, name: &str) -> Option<Arc<dyn SlashCommand>> {
        self.state.read().commands.get(name).cloned()
--- a/crates/audio/src/assets.rs
+++ b/crates/audio/src/assets.rs
@@ -41,7 +41,12 @@ impl SoundRegistry {
        }

        let path = format!("sounds/{}.wav", name);
-        let bytes = self.assets.load(&path)?.into_owned();
+        let bytes = self
+            .assets
+            .load(&path)?
+            .map(|asset| Ok(asset))
+            .unwrap_or_else(|| Err(anyhow::anyhow!("No such asset available")))?
+            .into_owned();
        let cursor = Cursor::new(bytes);
        let source = Decoder::new(cursor)?.convert_samples::<f32>().buffered();

--- a/crates/channel/src/channel_store.rs
+++ b/crates/channel/src/channel_store.rs
@@ -62,6 +62,7 @@ pub struct ChannelStore {
    opened_buffers: HashMap<ChannelId, OpenedModelHandle<ChannelBuffer>>,
    opened_chats: HashMap<ChannelId, OpenedModelHandle<ChannelChat>>,
    client: Arc<Client>,
+    did_subscribe: bool,
    user_store: Model<UserStore>,
    _rpc_subscriptions: [Subscription; 2],
    _watch_connection_status: Task<Option<()>>,
@@ -243,6 +244,20 @@ impl ChannelStore {
                .log_err();
            }),
            channel_states: Default::default(),
+            did_subscribe: false,
+        }
+    }
+
+    pub fn initialize(&mut self) {
+        if !self.did_subscribe {
+            if self
+                .client
+                .send(proto::SubscribeToChannels {})
+                .log_err()
+                .is_some()
+            {
+                self.did_subscribe = true;
+            }
        }
    }

@@ -1035,7 +1050,7 @@ impl ChannelStore {

    fn handle_disconnect(&mut self, wait_for_reconnect: bool, cx: &mut ModelContext<Self>) {
        cx.notify();
-
+        self.did_subscribe = false;
        self.disconnect_channel_buffers_task.get_or_insert_with(|| {
            cx.spawn(move |this, mut cx| async move {
                if wait_for_reconnect {
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -654,6 +654,7 @@ pub struct ChannelsForUser {
    pub channel_memberships: Vec<channel_member::Model>,
    pub channel_participants: HashMap<ChannelId, Vec<UserId>>,
    pub hosted_projects: Vec<proto::HostedProject>,
+    pub invited_channels: Vec<Channel>,

    pub observed_buffer_versions: Vec<proto::ChannelBufferVersion>,
    pub observed_channel_messages: Vec<proto::ChannelMessageId>,
--- a/crates/collab/src/db/queries/channels.rs
+++ b/crates/collab/src/db/queries/channels.rs
@@ -416,7 +416,9 @@ impl Database {
        user_id: UserId,
        tx: &DatabaseTransaction,
    ) -> Result<MembershipUpdated> {
-        let new_channels = self.get_user_channels(user_id, Some(channel), tx).await?;
+        let new_channels = self
+            .get_user_channels(user_id, Some(channel), false, tx)
+            .await?;
        let removed_channels = self
            .get_channel_descendants_excluding_self([channel], tx)
            .await?
@@ -481,44 +483,10 @@ impl Database {
        .await
    }

-    /// Returns all channel invites for the user with the given ID.
-    pub async fn get_channel_invites_for_user(&self, user_id: UserId) -> Result<Vec<Channel>> {
-        self.transaction(|tx| async move {
-            let mut role_for_channel: HashMap<ChannelId, ChannelRole> = HashMap::default();
-
-            let channel_invites = channel_member::Entity::find()
-                .filter(
-                    channel_member::Column::UserId
-                        .eq(user_id)
-                        .and(channel_member::Column::Accepted.eq(false)),
-                )
-                .all(&*tx)
-                .await?;
-
-            for invite in channel_invites {
-                role_for_channel.insert(invite.channel_id, invite.role);
-            }
-
-            let channels = channel::Entity::find()
-                .filter(channel::Column::Id.is_in(role_for_channel.keys().copied()))
-                .all(&*tx)
-                .await?;
-
-            let channels = channels.into_iter().map(Channel::from_model).collect();
-
-            Ok(channels)
-        })
-        .await
-    }
-
    /// Returns all channels for the user with the given ID.
    pub async fn get_channels_for_user(&self, user_id: UserId) -> Result<ChannelsForUser> {
-        self.transaction(|tx| async move {
-            let tx = tx;
-
-            self.get_user_channels(user_id, None, &tx).await
-        })
-        .await
+        self.transaction(|tx| async move { self.get_user_channels(user_id, None, true, &tx).await })
+            .await
    }

    /// Returns all channels for the user with the given ID that are descendants
@@ -527,25 +495,37 @@ impl Database {
        &self,
        user_id: UserId,
        ancestor_channel: Option<&channel::Model>,
+        include_invites: bool,
        tx: &DatabaseTransaction,
    ) -> Result<ChannelsForUser> {
-        let mut filter = channel_member::Column::UserId
-            .eq(user_id)
-            .and(channel_member::Column::Accepted.eq(true));
-
+        let mut filter = channel_member::Column::UserId.eq(user_id);
+        if !include_invites {
+            filter = filter.and(channel_member::Column::Accepted.eq(true))
+        }
        if let Some(ancestor) = ancestor_channel {
            filter = filter.and(channel_member::Column::ChannelId.eq(ancestor.root_id()));
        }

-        let channel_memberships = channel_member::Entity::find()
+        let mut channels = Vec::<channel::Model>::new();
+        let mut invited_channels = Vec::<Channel>::new();
+        let mut channel_memberships = Vec::<channel_member::Model>::new();
+        let mut rows = channel_member::Entity::find()
            .filter(filter)
-            .all(tx)
-            .await?;
-
-        let channels = channel::Entity::find()
-            .filter(channel::Column::Id.is_in(channel_memberships.iter().map(|m| m.channel_id)))
-            .all(tx)
+            .inner_join(channel::Entity)
+            .select_also(channel::Entity)
+            .stream(tx)
            .await?;
+        while let Some(row) = rows.next().await {
+            if let (membership, Some(channel)) = row? {
+                if membership.accepted {
+                    channel_memberships.push(membership);
+                    channels.push(channel);
+                } else {
+                    invited_channels.push(Channel::from_model(channel));
+                }
+            }
+        }
+        drop(rows);

        let mut descendants = self
            .get_channel_descendants_excluding_self(channels.iter(), tx)
@@ -643,6 +623,7 @@ impl Database {
        Ok(ChannelsForUser {
            channel_memberships,
            channels,
+            invited_channels,
            hosted_projects,
            channel_participants,
            latest_buffer_versions,
--- a/crates/collab/src/db/tests/channel_tests.rs
+++ b/crates/collab/src/db/tests/channel_tests.rs
@@ -176,23 +176,23 @@ async fn test_channel_invites(db: &Arc<Database>) {
        .unwrap();

    let user_2_invites = db
-        .get_channel_invites_for_user(user_2) // -> [channel_1_1, channel_1_2]
+        .get_channels_for_user(user_2)
        .await
        .unwrap()
+        .invited_channels
        .into_iter()
        .map(|channel| channel.id)
        .collect::<Vec<_>>();
-
    assert_eq!(user_2_invites, &[channel_1_1, channel_1_2]);

    let user_3_invites = db
-        .get_channel_invites_for_user(user_3) // -> [channel_1_1]
+        .get_channels_for_user(user_3)
        .await
        .unwrap()
+        .invited_channels
        .into_iter()
        .map(|channel| channel.id)
        .collect::<Vec<_>>();
-
    assert_eq!(user_3_invites, &[channel_1_1]);

    let (mut members, _) = db
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -557,6 +557,7 @@ impl Server {
            .add_request_handler(user_handler(request_contact))
            .add_request_handler(user_handler(remove_contact))
            .add_request_handler(user_handler(respond_to_contact_request))
+            .add_message_handler(subscribe_to_channels)
            .add_request_handler(user_handler(create_channel))
            .add_request_handler(user_handler(delete_channel))
            .add_request_handler(user_handler(invite_channel_member))
@@ -1105,34 +1106,25 @@ impl Server {
                        .await?;
                }

-                let (contacts, channels_for_user, channel_invites, dev_server_projects) =
-                    future::try_join4(
-                        self.app_state.db.get_contacts(user.id),
-                        self.app_state.db.get_channels_for_user(user.id),
-                        self.app_state.db.get_channel_invites_for_user(user.id),
-                        self.app_state.db.dev_server_projects_update(user.id),
-                    )
-                    .await?;
+                let (contacts, dev_server_projects) = future::try_join(
+                    self.app_state.db.get_contacts(user.id),
+                    self.app_state.db.dev_server_projects_update(user.id),
+                )
+                .await?;

                {
                    let mut pool = self.connection_pool.lock();
                    pool.add_connection(connection_id, user.id, user.admin, zed_version);
-                    for membership in &channels_for_user.channel_memberships {
-                        pool.subscribe_to_channel(user.id, membership.channel_id, membership.role)
-                    }
                    self.peer.send(
                        connection_id,
                        build_initial_contacts_update(contacts, &pool),
                    )?;
-                    self.peer.send(
-                        connection_id,
-                        build_update_user_channels(&channels_for_user),
-                    )?;
-                    self.peer.send(
-                        connection_id,
-                        build_channels_update(channels_for_user, channel_invites),
-                    )?;
                }
+
+                if should_auto_subscribe_to_channels(zed_version) {
+                    subscribe_user_to_channels(user.id, session).await?;
+                }
+
                send_dev_server_projects_update(user.id, dev_server_projects, session).await;

                if let Some(incoming_call) =
@@ -3399,6 +3391,36 @@ async fn remove_contact(
    Ok(())
 }

+fn should_auto_subscribe_to_channels(version: ZedVersion) -> bool {
+    version.0.minor() < 139
+}
+
+async fn subscribe_to_channels(_: proto::SubscribeToChannels, session: Session) -> Result<()> {
+    subscribe_user_to_channels(
+        session.user_id().ok_or_else(|| anyhow!("must be a user"))?,
+        &session,
+    )
+    .await?;
+    Ok(())
+}
+
+async fn subscribe_user_to_channels(user_id: UserId, session: &Session) -> Result<(), Error> {
+    let channels_for_user = session.db().await.get_channels_for_user(user_id).await?;
+    let mut pool = session.connection_pool().await;
+    for membership in &channels_for_user.channel_memberships {
+        pool.subscribe_to_channel(user_id, membership.channel_id, membership.role)
+    }
+    session.peer.send(
+        session.connection_id,
+        build_update_user_channels(&channels_for_user),
+    )?;
+    session.peer.send(
+        session.connection_id,
+        build_channels_update(channels_for_user),
+    )?;
+    Ok(())
+}
+
 /// Creates a new channel.
 async fn create_channel(
    request: proto::CreateChannel,
@@ -5034,7 +5056,7 @@ fn notify_membership_updated(
        ..Default::default()
    };

-    let mut update = build_channels_update(result.new_channels, vec![]);
+    let mut update = build_channels_update(result.new_channels);
    update.delete_channels = result
        .removed_channels
        .into_iter()
@@ -5064,10 +5086,7 @@ fn build_update_user_channels(channels: &ChannelsForUser) -> proto::UpdateUserCh
    }
 }

-fn build_channels_update(
-    channels: ChannelsForUser,
-    channel_invites: Vec<db::Channel>,
-) -> proto::UpdateChannels {
+fn build_channels_update(channels: ChannelsForUser) -> proto::UpdateChannels {
    let mut update = proto::UpdateChannels::default();

    for channel in channels.channels {
@@ -5086,7 +5105,7 @@ fn build_channels_update(
            });
    }

-    for channel in channel_invites {
+    for channel in channels.invited_channels {
        update.channel_invitations.push(channel.to_proto());
    }

--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -42,7 +42,7 @@ use std::{
    },
 };
 use text::Point;
-use workspace::{Workspace, WorkspaceId};
+use workspace::Workspace;

 #[gpui::test(iterations = 10)]
 async fn test_host_disconnect(
@@ -85,14 +85,8 @@ async fn test_host_disconnect(

    assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));

-    let workspace_b = cx_b.add_window(|cx| {
-        Workspace::new(
-            WorkspaceId::default(),
-            project_b.clone(),
-            client_b.app_state.clone(),
-            cx,
-        )
-    });
+    let workspace_b = cx_b
+        .add_window(|cx| Workspace::new(None, project_b.clone(), client_b.app_state.clone(), cx));
    let cx_b = &mut VisualTestContext::from_window(*workspace_b, cx_b);
    let workspace_b_view = workspace_b.root_view(cx_b).unwrap();

--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -42,7 +42,7 @@ use std::{
        Arc,
    },
 };
-use workspace::{Workspace, WorkspaceId, WorkspaceStore};
+use workspace::{Workspace, WorkspaceStore};

 pub struct TestServer {
    pub app_state: Arc<AppState>,
@@ -906,12 +906,7 @@ impl TestClient {
    ) -> (View<Workspace>, &'a mut VisualTestContext) {
        cx.add_window_view(|cx| {
            cx.activate_window();
-            Workspace::new(
-                WorkspaceId::default(),
-                project.clone(),
-                self.app_state.clone(),
-                cx,
-            )
+            Workspace::new(None, project.clone(), self.app_state.clone(), cx)
        })
    }

@@ -922,12 +917,7 @@ impl TestClient {
        let project = self.build_test_project(cx).await;
        cx.add_window_view(|cx| {
            cx.activate_window();
-            Workspace::new(
-                WorkspaceId::default(),
-                project.clone(),
-                self.app_state.clone(),
-                cx,
-            )
+            Workspace::new(None, project.clone(), self.app_state.clone(), cx)
        })
    }

--- a/crates/collab_ui/src/channel_view.rs
+++ b/crates/collab_ui/src/channel_view.rs
@@ -400,7 +400,11 @@ impl Item for ChannelView {
        None
    }

-    fn clone_on_split(&self, _: WorkspaceId, cx: &mut ViewContext<Self>) -> Option<View<Self>> {
+    fn clone_on_split(
+        &self,
+        _: Option<WorkspaceId>,
+        cx: &mut ViewContext<Self>,
+    ) -> Option<View<Self>> {
        Some(cx.new_view(|cx| {
            Self::new(
                self.project.clone(),
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2161,6 +2161,9 @@ impl CollabPanel {
    }

    fn render_signed_in(&mut self, cx: &mut ViewContext<Self>) -> Div {
+        self.channel_store.update(cx, |channel_store, _| {
+            channel_store.initialize();
+        });
        v_flex()
            .size_full()
            .child(list(self.list_state.clone()).size_full())
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -704,7 +704,7 @@ impl Item for ProjectDiagnosticsEditor {

    fn clone_on_split(
        &self,
-        _workspace_id: workspace::WorkspaceId,
+        _workspace_id: Option<workspace::WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Option<View<Self>>
    where
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -41,7 +41,7 @@ pub struct MovePageDown {
 #[derive(PartialEq, Clone, Deserialize, Default)]
 pub struct MoveToEndOfLine {
    #[serde(default = "default_true")]
-    pub(super) stop_at_soft_wraps: bool,
+    pub stop_at_soft_wraps: bool,
 }

 #[derive(PartialEq, Clone, Deserialize, Default)]
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -484,7 +484,7 @@ pub struct Editor {
    current_line_highlight: CurrentLineHighlight,
    collapse_matches: bool,
    autoindent_mode: Option<AutoindentMode>,
-    workspace: Option<(WeakView<Workspace>, WorkspaceId)>,
+    workspace: Option<(WeakView<Workspace>, Option<WorkspaceId>)>,
    keymap_context_layers: BTreeMap<TypeId, KeyContext>,
    input_enabled: bool,
    use_modal_editing: bool,
@@ -3767,7 +3767,7 @@ impl Editor {
        }))
    }

-    fn show_completions(&mut self, _: &ShowCompletions, cx: &mut ViewContext<Self>) {
+    pub fn show_completions(&mut self, _: &ShowCompletions, cx: &mut ViewContext<Self>) {
        if self.pending_rename.is_some() {
            return;
        }
@@ -9776,19 +9776,19 @@ impl Editor {
    }

    pub fn toggle_indent_guides(&mut self, _: &ToggleIndentGuides, cx: &mut ViewContext<Self>) {
-        let currently_enabled = self.should_show_indent_guides().unwrap_or_else(|| {
+        let currently_enabled = self.should_show_indent_guides(cx);
+        self.show_indent_guides = Some(!currently_enabled);
+        cx.notify();
+    }
+
+    fn should_show_indent_guides(&self, cx: &mut ViewContext<Self>) -> bool {
+        self.show_indent_guides.unwrap_or_else(|| {
            self.buffer
                .read(cx)
                .settings_at(0, cx)
                .indent_guides
                .enabled
-        });
-        self.show_indent_guides = Some(!currently_enabled);
-        cx.notify();
-    }
-
-    fn should_show_indent_guides(&self) -> Option<bool> {
-        self.show_indent_guides
+        })
    }

    pub fn toggle_line_numbers(&mut self, _: &ToggleLineNumbers, cx: &mut ViewContext<Self>) {
@@ -9963,10 +9963,33 @@ impl Editor {
    }

    fn get_permalink_to_line(&mut self, cx: &mut ViewContext<Self>) -> Result<url::Url> {
-        let (path, repo) = maybe!({
+        let (path, selection, repo) = maybe!({
            let project_handle = self.project.as_ref()?.clone();
            let project = project_handle.read(cx);
-            let buffer = self.buffer().read(cx).as_singleton()?;
+
+            let selection = self.selections.newest::<Point>(cx);
+            let selection_range = selection.range();
+
+            let (buffer, selection) = if let Some(buffer) = self.buffer().read(cx).as_singleton() {
+                (buffer, selection_range.start.row..selection_range.end.row)
+            } else {
+                let buffer_ranges = self
+                    .buffer()
+                    .read(cx)
+                    .range_to_buffer_ranges(selection_range, cx);
+
+                let (buffer, range, _) = if selection.reversed {
+                    buffer_ranges.first()
+                } else {
+                    buffer_ranges.last()
+                }?;
+
+                let snapshot = buffer.read(cx).snapshot();
+                let selection = text::ToPoint::to_point(&range.start, &snapshot).row
+                    ..text::ToPoint::to_point(&range.end, &snapshot).row;
+                (buffer.clone(), selection)
+            };
+
            let path = buffer
                .read(cx)
                .file()?
@@ -9975,21 +9998,17 @@ impl Editor {
                .to_str()?
                .to_string();
            let repo = project.get_repo(&buffer.read(cx).project_path(cx)?, cx)?;
-            Some((path, repo))
+            Some((path, selection, repo))
        })
        .ok_or_else(|| anyhow!("unable to open git repository"))?;

        const REMOTE_NAME: &str = "origin";
        let origin_url = repo
-            .lock()
            .remote_url(REMOTE_NAME)
            .ok_or_else(|| anyhow!("remote \"{REMOTE_NAME}\" not found"))?;
        let sha = repo
-            .lock()
            .head_sha()
            .ok_or_else(|| anyhow!("failed to read HEAD SHA"))?;
-        let selections = self.selections.all::<Point>(cx);
-        let selection = selections.iter().peekable().next();

        let (provider, remote) =
            parse_git_remote_url(GitHostingProviderRegistry::default_global(cx), &origin_url)
@@ -10000,12 +10019,7 @@ impl Editor {
            BuildPermalinkParams {
                sha: &sha,
                path: &path,
-                selection: selection.map(|selection| {
-                    let range = selection.range();
-                    let start = range.start.row;
-                    let end = range.end.row;
-                    start..end
-                }),
+                selection: Some(selection),
            },
        ))
    }
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -20,7 +20,6 @@ use language::{
    FakeLspAdapter, IndentGuide, LanguageConfig, LanguageConfigOverride, LanguageMatcher, Override,
    Point,
 };
-use language_settings::IndentGuideSettings;
 use multi_buffer::MultiBufferIndentGuide;
 use parking_lot::Mutex;
 use project::project_settings::{LspSettings, ProjectSettings};
@@ -11506,7 +11505,6 @@ fn assert_indent_guides(
        let snapshot = editor.snapshot(cx).display_snapshot;
        let mut indent_guides: Vec<_> = crate::indent_guides::indent_guides_in_range(
            MultiBufferRow(range.start)..MultiBufferRow(range.end),
-            true,
            &snapshot,
            cx,
        );
@@ -11545,21 +11543,6 @@ fn assert_indent_guides(
    assert_eq!(indent_guides, expected, "Indent guides do not match");
 }

-fn indent_guide(buffer_id: BufferId, start_row: u32, end_row: u32, depth: u32) -> IndentGuide {
-    IndentGuide {
-        buffer_id,
-        start_row,
-        end_row,
-        depth,
-        tab_size: 4,
-        settings: IndentGuideSettings {
-            enabled: true,
-            line_width: 1,
-            ..Default::default()
-        },
-    }
-}
-
 #[gpui::test]
 async fn test_indent_guide_single_line(cx: &mut gpui::TestAppContext) {
    let (buffer_id, mut cx) = setup_indent_guides_editor(
@@ -11572,7 +11555,12 @@ async fn test_indent_guide_single_line(cx: &mut gpui::TestAppContext) {
    )
    .await;

-    assert_indent_guides(0..3, vec![indent_guide(buffer_id, 1, 1, 0)], None, &mut cx);
+    assert_indent_guides(
+        0..3,
+        vec![IndentGuide::new(buffer_id, 1, 1, 0, 4)],
+        None,
+        &mut cx,
+    );
 }

 #[gpui::test]
@@ -11588,7 +11576,12 @@ async fn test_indent_guide_simple_block(cx: &mut gpui::TestAppContext) {
    )
    .await;

-    assert_indent_guides(0..4, vec![indent_guide(buffer_id, 1, 2, 0)], None, &mut cx);
+    assert_indent_guides(
+        0..4,
+        vec![IndentGuide::new(buffer_id, 1, 2, 0, 4)],
+        None,
+        &mut cx,
+    );
 }

 #[gpui::test]
@@ -11611,9 +11604,9 @@ async fn test_indent_guide_nested(cx: &mut gpui::TestAppContext) {
    assert_indent_guides(
        0..8,
        vec![
-            indent_guide(buffer_id, 1, 6, 0),
-            indent_guide(buffer_id, 3, 3, 1),
-            indent_guide(buffer_id, 5, 5, 1),
+            IndentGuide::new(buffer_id, 1, 6, 0, 4),
+            IndentGuide::new(buffer_id, 3, 3, 1, 4),
+            IndentGuide::new(buffer_id, 5, 5, 1, 4),
        ],
        None,
        &mut cx,
@@ -11637,8 +11630,8 @@ async fn test_indent_guide_tab(cx: &mut gpui::TestAppContext) {
    assert_indent_guides(
        0..5,
        vec![
-            indent_guide(buffer_id, 1, 3, 0),
-            indent_guide(buffer_id, 2, 2, 1),
+            IndentGuide::new(buffer_id, 1, 3, 0, 4),
+            IndentGuide::new(buffer_id, 2, 2, 1, 4),
        ],
        None,
        &mut cx,
@@ -11659,7 +11652,12 @@ async fn test_indent_guide_continues_on_empty_line(cx: &mut gpui::TestAppContext
    )
    .await;

-    assert_indent_guides(0..5, vec![indent_guide(buffer_id, 1, 3, 0)], None, &mut cx);
+    assert_indent_guides(
+        0..5,
+        vec![IndentGuide::new(buffer_id, 1, 3, 0, 4)],
+        None,
+        &mut cx,
+    );
 }

 #[gpui::test]
@@ -11685,9 +11683,9 @@ async fn test_indent_guide_complex(cx: &mut gpui::TestAppContext) {
    assert_indent_guides(
        0..11,
        vec![
-            indent_guide(buffer_id, 1, 9, 0),
-            indent_guide(buffer_id, 6, 6, 1),
-            indent_guide(buffer_id, 8, 8, 1),
+            IndentGuide::new(buffer_id, 1, 9, 0, 4),
+            IndentGuide::new(buffer_id, 6, 6, 1, 4),
+            IndentGuide::new(buffer_id, 8, 8, 1, 4),
        ],
        None,
        &mut cx,
@@ -11717,9 +11715,9 @@ async fn test_indent_guide_starts_off_screen(cx: &mut gpui::TestAppContext) {
    assert_indent_guides(
        1..11,
        vec![
-            indent_guide(buffer_id, 1, 9, 0),
-            indent_guide(buffer_id, 6, 6, 1),
-            indent_guide(buffer_id, 8, 8, 1),
+            IndentGuide::new(buffer_id, 1, 9, 0, 4),
+            IndentGuide::new(buffer_id, 6, 6, 1, 4),
+            IndentGuide::new(buffer_id, 8, 8, 1, 4),
        ],
        None,
        &mut cx,
@@ -11749,9 +11747,9 @@ async fn test_indent_guide_ends_off_screen(cx: &mut gpui::TestAppContext) {
    assert_indent_guides(
        1..10,
        vec![
-            indent_guide(buffer_id, 1, 9, 0),
-            indent_guide(buffer_id, 6, 6, 1),
-            indent_guide(buffer_id, 8, 8, 1),
+            IndentGuide::new(buffer_id, 1, 9, 0, 4),
+            IndentGuide::new(buffer_id, 6, 6, 1, 4),
+            IndentGuide::new(buffer_id, 8, 8, 1, 4),
        ],
        None,
        &mut cx,
@@ -11777,9 +11775,9 @@ async fn test_indent_guide_without_brackets(cx: &mut gpui::TestAppContext) {
    assert_indent_guides(
        1..10,
        vec![
-            indent_guide(buffer_id, 1, 4, 0),
-            indent_guide(buffer_id, 2, 3, 1),
-            indent_guide(buffer_id, 3, 3, 2),
+            IndentGuide::new(buffer_id, 1, 4, 0, 4),
+            IndentGuide::new(buffer_id, 2, 3, 1, 4),
+            IndentGuide::new(buffer_id, 3, 3, 2, 4),
        ],
        None,
        &mut cx,
@@ -11804,8 +11802,8 @@ async fn test_indent_guide_ends_before_empty_line(cx: &mut gpui::TestAppContext)
    assert_indent_guides(
        0..6,
        vec![
-            indent_guide(buffer_id, 1, 2, 0),
-            indent_guide(buffer_id, 2, 2, 1),
+            IndentGuide::new(buffer_id, 1, 2, 0, 4),
+            IndentGuide::new(buffer_id, 2, 2, 1, 4),
        ],
        None,
        &mut cx,
@@ -11827,7 +11825,12 @@ async fn test_indent_guide_continuing_off_screen(cx: &mut gpui::TestAppContext)
    )
    .await;

-    assert_indent_guides(0..1, vec![indent_guide(buffer_id, 1, 1, 0)], None, &mut cx);
+    assert_indent_guides(
+        0..1,
+        vec![IndentGuide::new(buffer_id, 1, 1, 0, 4)],
+        None,
+        &mut cx,
+    );
 }

 #[gpui::test]
@@ -11849,8 +11852,8 @@ async fn test_indent_guide_tabs(cx: &mut gpui::TestAppContext) {
    assert_indent_guides(
        0..6,
        vec![
-            indent_guide(buffer_id, 1, 6, 0),
-            indent_guide(buffer_id, 3, 4, 1),
+            IndentGuide::new(buffer_id, 1, 6, 0, 4),
+            IndentGuide::new(buffer_id, 3, 4, 1, 4),
        ],
        None,
        &mut cx,
@@ -11877,7 +11880,7 @@ async fn test_active_indent_guide_single_line(cx: &mut gpui::TestAppContext) {

    assert_indent_guides(
        0..3,
-        vec![indent_guide(buffer_id, 1, 1, 0)],
+        vec![IndentGuide::new(buffer_id, 1, 1, 0, 4)],
        Some(vec![0]),
        &mut cx,
    );
@@ -11906,8 +11909,8 @@ async fn test_active_indent_guide_respect_indented_range(cx: &mut gpui::TestAppC
    assert_indent_guides(
        0..4,
        vec![
-            indent_guide(buffer_id, 1, 3, 0),
-            indent_guide(buffer_id, 2, 2, 1),
+            IndentGuide::new(buffer_id, 1, 3, 0, 4),
+            IndentGuide::new(buffer_id, 2, 2, 1, 4),
        ],
        Some(vec![1]),
        &mut cx,
@@ -11922,8 +11925,8 @@ async fn test_active_indent_guide_respect_indented_range(cx: &mut gpui::TestAppC
    assert_indent_guides(
        0..4,
        vec![
-            indent_guide(buffer_id, 1, 3, 0),
-            indent_guide(buffer_id, 2, 2, 1),
+            IndentGuide::new(buffer_id, 1, 3, 0, 4),
+            IndentGuide::new(buffer_id, 2, 2, 1, 4),
        ],
        Some(vec![1]),
        &mut cx,
@@ -11938,8 +11941,8 @@ async fn test_active_indent_guide_respect_indented_range(cx: &mut gpui::TestAppC
    assert_indent_guides(
        0..4,
        vec![
-            indent_guide(buffer_id, 1, 3, 0),
-            indent_guide(buffer_id, 2, 2, 1),
+            IndentGuide::new(buffer_id, 1, 3, 0, 4),
+            IndentGuide::new(buffer_id, 2, 2, 1, 4),
        ],
        Some(vec![0]),
        &mut cx,
@@ -11968,7 +11971,7 @@ async fn test_active_indent_guide_empty_line(cx: &mut gpui::TestAppContext) {

    assert_indent_guides(
        0..5,
-        vec![indent_guide(buffer_id, 1, 3, 0)],
+        vec![IndentGuide::new(buffer_id, 1, 3, 0, 4)],
        Some(vec![0]),
        &mut cx,
    );
@@ -11994,7 +11997,7 @@ async fn test_active_indent_guide_non_matching_indent(cx: &mut gpui::TestAppCont

    assert_indent_guides(
        0..3,
-        vec![indent_guide(buffer_id, 1, 2, 0)],
+        vec![IndentGuide::new(buffer_id, 1, 2, 0, 4)],
        Some(vec![0]),
        &mut cx,
    );
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -38,7 +38,7 @@ use gpui::{
 };
 use itertools::Itertools;
 use language::language_settings::{
-    IndentGuideBackgroundColoring, IndentGuideColoring, IndentGuideSettings, ShowWhitespaceSetting,
+    IndentGuideBackgroundColoring, IndentGuideColoring, ShowWhitespaceSetting,
 };
 use lsp::DiagnosticSeverity;
 use multi_buffer::{Anchor, MultiBufferPoint, MultiBufferRow};
@@ -1438,7 +1438,6 @@ impl EditorElement {
                            single_indent_width,
                            depth: indent_guide.depth,
                            active: active_indent_guide_indices.contains(&i),
-                            settings: indent_guide.settings,
                        })
                    } else {
                        None
@@ -2731,6 +2730,14 @@ impl EditorElement {
            return;
        };

+        let settings = self
+            .editor
+            .read(cx)
+            .buffer()
+            .read(cx)
+            .settings_at(0, cx)
+            .indent_guides;
+
        let faded_color = |color: Hsla, alpha: f32| {
            let mut faded = color;
            faded.a = alpha;
@@ -2739,7 +2746,6 @@ impl EditorElement {

        for indent_guide in indent_guides {
            let indent_accent_colors = cx.theme().accents().color_for_index(indent_guide.depth);
-            let settings = indent_guide.settings;

            // TODO fixed for now, expose them through themes later
            const INDENT_AWARE_ALPHA: f32 = 0.2;
@@ -2747,7 +2753,7 @@ impl EditorElement {
            const INDENT_AWARE_BACKGROUND_ALPHA: f32 = 0.1;
            const INDENT_AWARE_BACKGROUND_ACTIVE_ALPHA: f32 = 0.2;

-            let line_color = match (settings.coloring, indent_guide.active) {
+            let line_color = match (&settings.coloring, indent_guide.active) {
                (IndentGuideColoring::Disabled, _) => None,
                (IndentGuideColoring::Fixed, false) => {
                    Some(cx.theme().colors().editor_indent_guide)
@@ -2763,7 +2769,7 @@ impl EditorElement {
                }
            };

-            let background_color = match (settings.background_coloring, indent_guide.active) {
+            let background_color = match (&settings.background_coloring, indent_guide.active) {
                (IndentGuideBackgroundColoring::Disabled, _) => None,
                (IndentGuideBackgroundColoring::IndentAware, false) => Some(faded_color(
                    indent_accent_colors,
@@ -5280,7 +5286,6 @@ pub struct IndentGuideLayout {
    single_indent_width: Pixels,
    depth: u32,
    active: bool,
-    settings: IndentGuideSettings,
 }

 pub struct CursorLayout {
--- a/crates/editor/src/indent_guides.rs
+++ b/crates/editor/src/indent_guides.rs
@@ -2,7 +2,7 @@ use std::{ops::Range, time::Duration};

 use collections::HashSet;
 use gpui::{AppContext, Task};
-use language::{language_settings::language_settings, BufferRow};
+use language::BufferRow;
 use multi_buffer::{MultiBufferIndentGuide, MultiBufferRow};
 use text::{BufferId, LineIndent, Point};
 use ui::ViewContext;
@@ -37,26 +37,13 @@ impl Editor {
        snapshot: &DisplaySnapshot,
        cx: &mut ViewContext<Editor>,
    ) -> Option<Vec<MultiBufferIndentGuide>> {
-        let show_indent_guides = self.should_show_indent_guides().unwrap_or_else(|| {
-            if let Some(buffer) = self.buffer().read(cx).as_singleton() {
-                language_settings(buffer.read(cx).language(), buffer.read(cx).file(), cx)
-                    .indent_guides
-                    .enabled
-            } else {
-                true
-            }
-        });
+        let enabled = self.should_show_indent_guides(cx);

-        if !show_indent_guides {
-            return None;
+        if enabled {
+            Some(indent_guides_in_range(visible_buffer_range, snapshot, cx))
+        } else {
+            None
        }
-
-        Some(indent_guides_in_range(
-            visible_buffer_range,
-            self.should_show_indent_guides() == Some(true),
-            snapshot,
-            cx,
-        ))
    }

    pub fn find_active_indent_guide_indices(
@@ -90,13 +77,8 @@ impl Editor {

        if state.should_refresh() {
            state.cursor_row = cursor_row;
-            state.dirty = false;
-
-            if indent_guides.is_empty() {
-                return None;
-            }
-
            let snapshot = snapshot.clone();
+            state.dirty = false;

            let task = cx
                .background_executor()
@@ -149,7 +131,6 @@ impl Editor {

 pub fn indent_guides_in_range(
    visible_buffer_range: Range<MultiBufferRow>,
-    ignore_disabled_for_language: bool,
    snapshot: &DisplaySnapshot,
    cx: &AppContext,
 ) -> Vec<MultiBufferIndentGuide> {
@@ -162,7 +143,7 @@ pub fn indent_guides_in_range(

    snapshot
        .buffer_snapshot
-        .indent_guides_in_range(start_anchor..end_anchor, ignore_disabled_for_language, cx)
+        .indent_guides_in_range(start_anchor..end_anchor, cx)
        .into_iter()
        .filter(|indent_guide| {
            // Filter out indent guides that are inside a fold
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -657,7 +657,7 @@ impl Item for Editor {

    fn clone_on_split(
        &self,
-        _workspace_id: WorkspaceId,
+        _workspace_id: Option<WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Option<View<Editor>>
    where
@@ -846,9 +846,12 @@ impl Item for Editor {
    }

    fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
-        let workspace_id = workspace.database_id();
-        let item_id = cx.view().item_id().as_u64() as ItemId;
        self.workspace = Some((workspace.weak_handle(), workspace.database_id()));
+        let Some(workspace_id) = workspace.database_id() else {
+            return;
+        };
+
+        let item_id = cx.view().item_id().as_u64() as ItemId;

        fn serialize(
            buffer: Model<Buffer>,
@@ -873,7 +876,7 @@ impl Item for Editor {
            serialize(buffer.clone(), workspace_id, item_id, cx);

            cx.subscribe(&buffer, |this, buffer, event, cx| {
-                if let Some((_, workspace_id)) = this.workspace.as_ref() {
+                if let Some((_, Some(workspace_id))) = this.workspace.as_ref() {
                    if let language::Event::FileHandleChanged = event {
                        serialize(
                            buffer,
--- a/crates/editor/src/scroll.rs
+++ b/crates/editor/src/scroll.rs
@@ -389,7 +389,8 @@ impl Editor {
        cx: &mut ViewContext<Self>,
    ) {
        hide_hover(self, cx);
-        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
+        let workspace_id = self.workspace.as_ref().and_then(|workspace| workspace.1);
+
        self.scroll_manager.set_scroll_position(
            scroll_position,
            &display_map,
@@ -409,7 +410,7 @@ impl Editor {

    pub fn set_scroll_anchor(&mut self, scroll_anchor: ScrollAnchor, cx: &mut ViewContext<Self>) {
        hide_hover(self, cx);
-        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
+        let workspace_id = self.workspace.as_ref().and_then(|workspace| workspace.1);
        let top_row = scroll_anchor
            .anchor
            .to_point(&self.buffer().read(cx).snapshot(cx))
@@ -424,7 +425,7 @@ impl Editor {
        cx: &mut ViewContext<Self>,
    ) {
        hide_hover(self, cx);
-        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
+        let workspace_id = self.workspace.as_ref().and_then(|workspace| workspace.1);
        let snapshot = &self.buffer().read(cx).snapshot(cx);
        if !scroll_anchor.anchor.is_valid(snapshot) {
            log::warn!("Invalid scroll anchor: {:?}", scroll_anchor);
--- a/crates/extension/src/extension_slash_command.rs
+++ b/crates/extension/src/extension_slash_command.rs
@@ -27,7 +27,7 @@ impl SlashCommand for ExtensionSlashCommand {
        self.command.description.clone()
    }

-    fn tooltip_text(&self) -> String {
+    fn menu_text(&self) -> String {
        self.command.tooltip_text.clone()
    }

--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -1178,8 +1178,8 @@ impl ExtensionStore {
                    }

                    for (slash_command_name, slash_command) in &manifest.slash_commands {
-                        this.slash_command_registry
-                            .register_command(ExtensionSlashCommand {
+                        this.slash_command_registry.register_command(
+                            ExtensionSlashCommand {
                                command: crate::wit::SlashCommand {
                                    name: slash_command_name.to_string(),
                                    description: slash_command.description.to_string(),
@@ -1188,7 +1188,9 @@ impl ExtensionStore {
                                },
                                extension: wasm_extension.clone(),
                                host: this.wasm_host.clone(),
-                            });
+                            },
+                            false,
+                        );
                    }
                }
                this.wasm_extensions.extend(wasm_extensions);
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -992,7 +992,7 @@ impl Item for ExtensionsPage {

    fn clone_on_split(
        &self,
-        _workspace_id: WorkspaceId,
+        _workspace_id: Option<WorkspaceId>,
        _: &mut ViewContext<Self>,
    ) -> Option<View<Self>> {
        None
--- a/crates/file_icons/src/file_icons.rs
+++ b/crates/file_icons/src/file_icons.rs
@@ -38,11 +38,10 @@ impl FileIcons {
    pub fn new(assets: impl AssetSource) -> Self {
        assets
            .load("icons/file_icons/file_types.json")
-            .and_then(|file| {
-                serde_json::from_str::<FileIcons>(str::from_utf8(&file).unwrap())
-                    .map_err(Into::into)
-            })
-            .unwrap_or_else(|_| FileIcons {
+            .ok()
+            .flatten()
+            .and_then(|file| serde_json::from_str::<FileIcons>(str::from_utf8(&file).unwrap()).ok())
+            .unwrap_or_else(|| FileIcons {
                stems: HashMap::default(),
                suffixes: HashMap::default(),
                types: HashMap::default(),
--- a/crates/fs/Cargo.toml
+++ b/crates/fs/Cargo.toml
@@ -46,6 +46,9 @@ notify = "6.1.1"
 [target.'cfg(target_os = "windows")'.dependencies]
 windows.workspace = true

+[target.'cfg(target_os = "linux")'.dependencies]
+ashpd.workspace = true
+
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }

--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -1,24 +1,24 @@
 use anyhow::{anyhow, Result};
 use git::GitHostingProviderRegistry;

+#[cfg(target_os = "linux")]
+use ashpd::desktop::trash;
+#[cfg(target_os = "linux")]
+use std::{fs::File, os::fd::AsFd};
+
 #[cfg(unix)]
 use std::os::unix::fs::MetadataExt;

 use async_tar::Archive;
 use futures::{future::BoxFuture, AsyncRead, Stream, StreamExt};
 use git::repository::{GitRepository, RealGitRepository};
-use git2::Repository as LibGitRepository;
-use parking_lot::Mutex;
 use rope::Rope;
-#[cfg(any(test, feature = "test-support"))]
-use smol::io::AsyncReadExt;
 use smol::io::AsyncWriteExt;
-use std::io::Write;
-use std::sync::Arc;
 use std::{
-    io,
+    io::{self, Write},
    path::{Component, Path, PathBuf},
    pin::Pin,
+    sync::Arc,
    time::{Duration, SystemTime},
 };
 use tempfile::{NamedTempFile, TempDir};
@@ -30,6 +30,10 @@ use collections::{btree_map, BTreeMap};
 #[cfg(any(test, feature = "test-support"))]
 use git::repository::{FakeGitRepositoryState, GitFileStatus};
 #[cfg(any(test, feature = "test-support"))]
+use parking_lot::Mutex;
+#[cfg(any(test, feature = "test-support"))]
+use smol::io::AsyncReadExt;
+#[cfg(any(test, feature = "test-support"))]
 use std::ffi::OsStr;

 #[async_trait::async_trait]
@@ -77,7 +81,7 @@ pub trait Fs: Send + Sync {
        latency: Duration,
    ) -> Pin<Box<dyn Send + Stream<Item = Vec<PathBuf>>>>;

-    fn open_repo(&self, abs_dot_git: &Path) -> Option<Arc<Mutex<dyn GitRepository>>>;
+    fn open_repo(&self, abs_dot_git: &Path) -> Option<Arc<dyn GitRepository>>;
    fn is_fake(&self) -> bool;
    async fn is_case_sensitive(&self) -> Result<bool>;
    #[cfg(any(test, feature = "test-support"))]
@@ -273,11 +277,25 @@ impl Fs for RealFs {
        Ok(())
    }

+    #[cfg(target_os = "linux")]
+    async fn trash_file(&self, path: &Path, _options: RemoveOptions) -> Result<()> {
+        let file = File::open(path)?;
+        match trash::trash_file(&file.as_fd()).await {
+            Ok(_) => Ok(()),
+            Err(err) => Err(anyhow::Error::new(err)),
+        }
+    }
+
    #[cfg(target_os = "macos")]
    async fn trash_dir(&self, path: &Path, options: RemoveOptions) -> Result<()> {
        self.trash_file(path, options).await
    }

+    #[cfg(target_os = "linux")]
+    async fn trash_dir(&self, path: &Path, options: RemoveOptions) -> Result<()> {
+        self.trash_file(path, options).await
+    }
+
    async fn open_sync(&self, path: &Path) -> Result<Box<dyn io::Read>> {
        Ok(Box::new(std::fs::File::open(path)?))
    }
@@ -486,16 +504,13 @@ impl Fs for RealFs {
        })))
    }

-    fn open_repo(&self, dotgit_path: &Path) -> Option<Arc<Mutex<dyn GitRepository>>> {
-        LibGitRepository::open(dotgit_path)
-            .log_err()
-            .map::<Arc<Mutex<dyn GitRepository>>, _>(|libgit_repository| {
-                Arc::new(Mutex::new(RealGitRepository::new(
-                    libgit_repository,
-                    self.git_binary_path.clone(),
-                    self.git_hosting_provider_registry.clone(),
-                )))
-            })
+    fn open_repo(&self, dotgit_path: &Path) -> Option<Arc<dyn GitRepository>> {
+        let repo = git2::Repository::open(dotgit_path).log_err()?;
+        Some(Arc::new(RealGitRepository::new(
+            repo,
+            self.git_binary_path.clone(),
+            self.git_hosting_provider_registry.clone(),
+        )))
    }

    fn is_fake(&self) -> bool {
@@ -1469,7 +1484,7 @@ impl Fs for FakeFs {
        }))
    }

-    fn open_repo(&self, abs_dot_git: &Path) -> Option<Arc<Mutex<dyn GitRepository>>> {
+    fn open_repo(&self, abs_dot_git: &Path) -> Option<Arc<dyn GitRepository>> {
        let state = self.state.lock();
        let entry = state.read_path(abs_dot_git).unwrap();
        let mut entry = entry.lock();
--- a/crates/git/src/blame.rs
+++ b/crates/git/src/blame.rs
@@ -8,15 +8,11 @@ use std::process::{Command, Stdio};
 use std::sync::Arc;
 use std::{ops::Range, path::Path};
 use text::Rope;
-use time;
 use time::macros::format_description;
 use time::OffsetDateTime;
 use time::UtcOffset;
 use url::Url;

-#[cfg(windows)]
-use std::os::windows::process::CommandExt;
-
 pub use git2 as libgit;

 #[derive(Debug, Clone, Default)]
@@ -98,7 +94,10 @@ fn run_git_blame(
        .stderr(Stdio::piped());

    #[cfg(windows)]
-    child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
+    {
+        use std::os::windows::process::CommandExt;
+        child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
+    }

    let child = child
        .spawn()
--- a/crates/git/src/git.rs
+++ b/crates/git/src/git.rs
@@ -15,6 +15,7 @@ pub mod blame;
 pub mod commit;
 pub mod diff;
 pub mod repository;
+pub mod status;

 lazy_static! {
    pub static ref DOT_GIT: &'static OsStr = OsStr::new(".git");
--- a/crates/git/src/repository.rs
+++ b/crates/git/src/repository.rs
@@ -1,8 +1,8 @@
-use crate::blame::Blame;
 use crate::GitHostingProviderRegistry;
+use crate::{blame::Blame, status::GitStatus};
 use anyhow::{Context, Result};
 use collections::HashMap;
-use git2::{BranchType, StatusShow};
+use git2::BranchType;
 use parking_lot::Mutex;
 use rope::Rope;
 use serde::{Deserialize, Serialize};
@@ -10,12 +10,9 @@ use std::{
    cmp::Ordering,
    path::{Component, Path, PathBuf},
    sync::Arc,
-    time::SystemTime,
 };
-use sum_tree::{MapSeekTarget, TreeMap};
-use util::{paths::PathExt, ResultExt};
-
-pub use git2::Repository as LibGitRepository;
+use sum_tree::MapSeekTarget;
+use util::ResultExt;

 #[derive(Clone, Debug, Hash, PartialEq)]
 pub struct Branch {
@@ -25,7 +22,7 @@ pub struct Branch {
    pub unix_timestamp: Option<i64>,
 }

-pub trait GitRepository: Send {
+pub trait GitRepository: Send + Sync {
    fn reload_index(&self);

    /// Loads a git repository entry's contents.
@@ -39,23 +36,11 @@ pub trait GitRepository: Send {
    /// Returns the SHA of the current HEAD.
    fn head_sha(&self) -> Option<String>;

-    /// Get the statuses of all of the files in the index that start with the given
-    /// path and have changes with respect to the HEAD commit. This is fast because
-    /// the index stores hashes of trees, so that unchanged directories can be skipped.
-    fn staged_statuses(&self, path_prefix: &Path) -> TreeMap<RepoPath, GitFileStatus>;
+    fn statuses(&self, path_prefix: &Path) -> Result<GitStatus>;

-    /// Get the status of a given file in the working directory with respect to
-    /// the index. In the common case, when there are no changes, this only requires
-    /// an index lookup. The index stores the mtime of each file when it was added,
-    /// so there's no work to do if the mtime matches.
-    fn unstaged_status(&self, path: &RepoPath, mtime: SystemTime) -> Option<GitFileStatus>;
-
-    /// Get the status of a given file in the working directory with respect to
-    /// the HEAD commit. In the common case, when there are no changes, this only
-    /// requires an index lookup and blob comparison between the index and the HEAD
-    /// commit. The index stores the mtime of each file when it was added, so there's
-    /// no need to consider the working directory file if the mtime matches.
-    fn status(&self, path: &RepoPath, mtime: SystemTime) -> Option<GitFileStatus>;
+    fn status(&self, path: &Path) -> Option<GitFileStatus> {
+        Some(self.statuses(path).ok()?.entries.first()?.1)
+    }

    fn branches(&self) -> Result<Vec<Branch>>;
    fn change_branch(&self, _: &str) -> Result<()>;
@@ -71,19 +56,19 @@ impl std::fmt::Debug for dyn GitRepository {
 }

 pub struct RealGitRepository {
-    pub repository: LibGitRepository,
+    pub repository: Mutex<git2::Repository>,
    pub git_binary_path: PathBuf,
    hosting_provider_registry: Arc<GitHostingProviderRegistry>,
 }

 impl RealGitRepository {
    pub fn new(
-        repository: LibGitRepository,
+        repository: git2::Repository,
        git_binary_path: Option<PathBuf>,
        hosting_provider_registry: Arc<GitHostingProviderRegistry>,
    ) -> Self {
        Self {
-            repository,
+            repository: Mutex::new(repository),
            git_binary_path: git_binary_path.unwrap_or_else(|| PathBuf::from("git")),
            hosting_provider_registry,
        }
@@ -92,13 +77,13 @@ impl RealGitRepository {

 impl GitRepository for RealGitRepository {
    fn reload_index(&self) {
-        if let Ok(mut index) = self.repository.index() {
+        if let Ok(mut index) = self.repository.lock().index() {
            _ = index.read(false);
        }
    }

    fn load_index_text(&self, relative_file_path: &Path) -> Option<String> {
-        fn logic(repo: &LibGitRepository, relative_file_path: &Path) -> Result<Option<String>> {
+        fn logic(repo: &git2::Repository, relative_file_path: &Path) -> Result<Option<String>> {
            const STAGE_NORMAL: i32 = 0;
            let index = repo.index()?;

@@ -114,7 +99,7 @@ impl GitRepository for RealGitRepository {
            Ok(Some(String::from_utf8(content)?))
        }

-        match logic(&self.repository, relative_file_path) {
+        match logic(&self.repository.lock(), relative_file_path) {
            Ok(value) => return value,
            Err(err) => log::error!("Error loading head text: {:?}", err),
        }
@@ -122,84 +107,35 @@ impl GitRepository for RealGitRepository {
    }

    fn remote_url(&self, name: &str) -> Option<String> {
-        let remote = self.repository.find_remote(name).ok()?;
+        let repo = self.repository.lock();
+        let remote = repo.find_remote(name).ok()?;
        remote.url().map(|url| url.to_string())
    }

    fn branch_name(&self) -> Option<String> {
-        let head = self.repository.head().log_err()?;
+        let repo = self.repository.lock();
+        let head = repo.head().log_err()?;
        let branch = String::from_utf8_lossy(head.shorthand_bytes());
        Some(branch.to_string())
    }

    fn head_sha(&self) -> Option<String> {
-        let head = self.repository.head().ok()?;
-        head.target().map(|oid| oid.to_string())
+        Some(self.repository.lock().head().ok()?.target()?.to_string())
    }

-    fn staged_statuses(&self, path_prefix: &Path) -> TreeMap<RepoPath, GitFileStatus> {
-        let mut map = TreeMap::default();
-
-        let mut options = git2::StatusOptions::new();
-        options.pathspec(path_prefix);
-        options.show(StatusShow::Index);
-
-        if let Some(statuses) = self.repository.statuses(Some(&mut options)).log_err() {
-            for status in statuses.iter() {
-                let path = RepoPath(PathBuf::try_from_bytes(status.path_bytes()).unwrap());
-                let status = status.status();
-                if !status.contains(git2::Status::IGNORED) {
-                    if let Some(status) = read_status(status) {
-                        map.insert(path, status)
-                    }
-                }
-            }
-        }
-        map
-    }
-
-    fn unstaged_status(&self, path: &RepoPath, mtime: SystemTime) -> Option<GitFileStatus> {
-        // If the file has not changed since it was added to the index, then
-        // there can't be any changes.
-        if matches_index(&self.repository, path, mtime) {
-            return None;
-        }
-
-        let mut options = git2::StatusOptions::new();
-        options.pathspec(&path.0);
-        options.disable_pathspec_match(true);
-        options.include_untracked(true);
-        options.recurse_untracked_dirs(true);
-        options.include_unmodified(true);
-        options.show(StatusShow::Workdir);
-
-        let statuses = self.repository.statuses(Some(&mut options)).log_err()?;
-        let status = statuses.get(0).and_then(|s| read_status(s.status()));
-        status
-    }
-
-    fn status(&self, path: &RepoPath, mtime: SystemTime) -> Option<GitFileStatus> {
-        let mut options = git2::StatusOptions::new();
-        options.pathspec(&path.0);
-        options.disable_pathspec_match(true);
-        options.include_untracked(true);
-        options.recurse_untracked_dirs(true);
-        options.include_unmodified(true);
-
-        // If the file has not changed since it was added to the index, then
-        // there's no need to examine the working directory file: just compare
-        // the blob in the index to the one in the HEAD commit.
-        if matches_index(&self.repository, path, mtime) {
-            options.show(StatusShow::Index);
-        }
-
-        let statuses = self.repository.statuses(Some(&mut options)).log_err()?;
-        let status = statuses.get(0).and_then(|s| read_status(s.status()));
-        status
+    fn statuses(&self, path_prefix: &Path) -> Result<GitStatus> {
+        let working_directory = self
+            .repository
+            .lock()
+            .workdir()
+            .context("failed to read git work directory")?
+            .to_path_buf();
+        GitStatus::new(&self.git_binary_path, &working_directory, path_prefix)
    }

    fn branches(&self) -> Result<Vec<Branch>> {
-        let local_branches = self.repository.branches(Some(BranchType::Local))?;
+        let repo = self.repository.lock();
+        let local_branches = repo.branches(Some(BranchType::Local))?;
        let valid_branches = local_branches
            .filter_map(|branch| {
                branch.ok().and_then(|(branch, _)| {
@@ -222,37 +158,42 @@ impl GitRepository for RealGitRepository {
            .collect();
        Ok(valid_branches)
    }
+
    fn change_branch(&self, name: &str) -> Result<()> {
-        let revision = self.repository.find_branch(name, BranchType::Local)?;
+        let repo = self.repository.lock();
+        let revision = repo.find_branch(name, BranchType::Local)?;
        let revision = revision.get();
        let as_tree = revision.peel_to_tree()?;
-        self.repository.checkout_tree(as_tree.as_object(), None)?;
-        self.repository.set_head(
+        repo.checkout_tree(as_tree.as_object(), None)?;
+        repo.set_head(
            revision
                .name()
                .ok_or_else(|| anyhow::anyhow!("Branch name could not be retrieved"))?,
        )?;
        Ok(())
    }
-    fn create_branch(&self, name: &str) -> Result<()> {
-        let current_commit = self.repository.head()?.peel_to_commit()?;
-        self.repository.branch(name, &current_commit, false)?;

+    fn create_branch(&self, name: &str) -> Result<()> {
+        let repo = self.repository.lock();
+        let current_commit = repo.head()?.peel_to_commit()?;
+        repo.branch(name, &current_commit, false)?;
        Ok(())
    }

    fn blame(&self, path: &Path, content: Rope) -> Result<crate::blame::Blame> {
        let working_directory = self
            .repository
+            .lock()
            .workdir()
-            .with_context(|| format!("failed to get git working directory for file {:?}", path))?;
+            .with_context(|| format!("failed to get git working directory for file {:?}", path))?
+            .to_path_buf();

        const REMOTE_NAME: &str = "origin";
        let remote_url = self.remote_url(REMOTE_NAME);

        crate::blame::Blame::for_path(
            &self.git_binary_path,
-            working_directory,
+            &working_directory,
            path,
            &content,
            remote_url,
@@ -261,38 +202,6 @@ impl GitRepository for RealGitRepository {
    }
 }

-fn matches_index(repo: &LibGitRepository, path: &RepoPath, mtime: SystemTime) -> bool {
-    if let Some(index) = repo.index().log_err() {
-        if let Some(entry) = index.get_path(path, 0) {
-            if let Some(mtime) = mtime.duration_since(SystemTime::UNIX_EPOCH).log_err() {
-                if entry.mtime.seconds() == mtime.as_secs() as i32
-                    && entry.mtime.nanoseconds() == mtime.subsec_nanos()
-                {
-                    return true;
-                }
-            }
-        }
-    }
-    false
-}
-
-fn read_status(status: git2::Status) -> Option<GitFileStatus> {
-    if status.contains(git2::Status::CONFLICTED) {
-        Some(GitFileStatus::Conflict)
-    } else if status.intersects(
-        git2::Status::WT_MODIFIED
-            | git2::Status::WT_RENAMED
-            | git2::Status::INDEX_MODIFIED
-            | git2::Status::INDEX_RENAMED,
-    ) {
-        Some(GitFileStatus::Modified)
-    } else if status.intersects(git2::Status::WT_NEW | git2::Status::INDEX_NEW) {
-        Some(GitFileStatus::Added)
-    } else {
-        None
-    }
-}
-
 #[derive(Debug, Clone, Default)]
 pub struct FakeGitRepository {
    state: Arc<Mutex<FakeGitRepositoryState>>,
@@ -307,8 +216,8 @@ pub struct FakeGitRepositoryState {
 }

 impl FakeGitRepository {
-    pub fn open(state: Arc<Mutex<FakeGitRepositoryState>>) -> Arc<Mutex<dyn GitRepository>> {
-        Arc::new(Mutex::new(FakeGitRepository { state }))
+    pub fn open(state: Arc<Mutex<FakeGitRepositoryState>>) -> Arc<dyn GitRepository> {
+        Arc::new(FakeGitRepository { state })
    }
 }

@@ -333,24 +242,23 @@ impl GitRepository for FakeGitRepository {
        None
    }

-    fn staged_statuses(&self, path_prefix: &Path) -> TreeMap<RepoPath, GitFileStatus> {
-        let mut map = TreeMap::default();
+    fn statuses(&self, path_prefix: &Path) -> Result<GitStatus> {
        let state = self.state.lock();
-        for (repo_path, status) in state.worktree_statuses.iter() {
-            if repo_path.0.starts_with(path_prefix) {
-                map.insert(repo_path.to_owned(), status.to_owned());
-            }
-        }
-        map
-    }
-
-    fn unstaged_status(&self, _path: &RepoPath, _mtime: SystemTime) -> Option<GitFileStatus> {
-        None
-    }
-
-    fn status(&self, path: &RepoPath, _mtime: SystemTime) -> Option<GitFileStatus> {
-        let state = self.state.lock();
-        state.worktree_statuses.get(path).cloned()
+        let mut entries = state
+            .worktree_statuses
+            .iter()
+            .filter_map(|(repo_path, status)| {
+                if repo_path.0.starts_with(path_prefix) {
+                    Some((repo_path.to_owned(), *status))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        entries.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+        Ok(GitStatus {
+            entries: entries.into(),
+        })
    }

    fn branches(&self) -> Result<Vec<Branch>> {
--- a/crates/git/src/status.rs
+++ b/crates/git/src/status.rs
@@ -0,0 +1,99 @@
+use crate::repository::{GitFileStatus, RepoPath};
+use anyhow::{anyhow, Result};
+use std::{
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+    sync::Arc,
+};
+
+#[derive(Clone)]
+pub struct GitStatus {
+    pub entries: Arc<[(RepoPath, GitFileStatus)]>,
+}
+
+impl GitStatus {
+    pub(crate) fn new(
+        git_binary: &Path,
+        working_directory: &Path,
+        mut path_prefix: &Path,
+    ) -> Result<Self> {
+        let mut child = Command::new(git_binary);
+
+        if path_prefix == Path::new("") {
+            path_prefix = Path::new(".");
+        }
+
+        child
+            .current_dir(working_directory)
+            .args([
+                "--no-optional-locks",
+                "status",
+                "--porcelain=v1",
+                "--untracked-files=all",
+                "-z",
+            ])
+            .arg(path_prefix)
+            .stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+
+        #[cfg(windows)]
+        {
+            use std::os::windows::process::CommandExt;
+            child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
+        }
+
+        let child = child
+            .spawn()
+            .map_err(|e| anyhow!("Failed to start git status process: {}", e))?;
+
+        let output = child
+            .wait_with_output()
+            .map_err(|e| anyhow!("Failed to read git blame output: {}", e))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(anyhow!("git status process failed: {}", stderr));
+        }
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let mut entries = stdout
+            .split('\0')
+            .filter_map(|entry| {
+                if entry.is_char_boundary(3) {
+                    let (status, path) = entry.split_at(3);
+                    let status = status.trim();
+                    Some((
+                        RepoPath(PathBuf::from(path)),
+                        match status {
+                            "A" | "??" => GitFileStatus::Added,
+                            "M" => GitFileStatus::Modified,
+                            _ => return None,
+                        },
+                    ))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        entries.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+        Ok(Self {
+            entries: entries.into(),
+        })
+    }
+
+    pub fn get(&self, path: &Path) -> Option<GitFileStatus> {
+        self.entries
+            .binary_search_by(|(repo_path, _)| repo_path.0.as_path().cmp(path))
+            .ok()
+            .map(|index| self.entries[index].1)
+    }
+}
+
+impl Default for GitStatus {
+    fn default() -> Self {
+        Self {
+            entries: Arc::new([]),
+        }
+    }
+}
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -12,9 +12,14 @@ workspace = true

 [features]
 default = []
-test-support = ["backtrace", "collections/test-support", "util/test-support", "http/test-support"]
+test-support = [
+    "backtrace",
+    "collections/test-support",
+    "util/test-support",
+    "http/test-support",
+]
 runtime_shaders = []
-macos-blade = ["blade-graphics", "blade-macros", "bytemuck"]
+macos-blade = ["blade-graphics", "blade-macros", "blade-util", "bytemuck"]

 [lib]
 path = "src/gpui.rs"
@@ -26,6 +31,7 @@ async-task = "4.7"
 backtrace = { version = "0.3", optional = true }
 blade-graphics = { workspace = true, optional = true }
 blade-macros = { workspace = true, optional = true }
+blade-util = { workspace = true, optional = true }
 bytemuck = { version = "1", optional = true }
 collections.workspace = true
 ctor.workspace = true
@@ -96,13 +102,14 @@ flume = "0.11"
 #TODO: use these on all platforms
 blade-graphics.workspace = true
 blade-macros.workspace = true
+blade-util.workspace = true
 bytemuck = "1"
 cosmic-text = "0.11.2"
 copypasta = "0.10.1"

 [target.'cfg(target_os = "linux")'.dependencies]
 as-raw-xcb-connection = "1"
-ashpd = "0.8.0"
+ashpd.workspace = true
 calloop = "0.12.4"
 calloop-wayland-source = "0.2.0"
 wayland-backend = { version = "0.3.3", features = ["client_system"] }
@@ -126,7 +133,10 @@ x11rb = { version = "0.13.0", features = [
    "resource_manager",
 ] }
 xkbcommon = { version = "0.7", features = ["wayland", "x11"] }
-xim = { git = "https://github.com/npmania/xim-rs", rev = "27132caffc5b9bc9c432ca4afad184ab6e7c16af", features = ["x11rb-xcb", "x11rb-client"] }
+xim = { git = "https://github.com/npmania/xim-rs", rev = "27132caffc5b9bc9c432ca4afad184ab6e7c16af", features = [
+    "x11rb-xcb",
+    "x11rb-client",
+] }

 [target.'cfg(windows)'.dependencies]
 windows.workspace = true
--- a/crates/gpui/examples/animation.rs
+++ b/crates/gpui/examples/animation.rs
@@ -5,8 +5,11 @@ use gpui::*;
 struct Assets {}

 impl AssetSource for Assets {
-    fn load(&self, path: &str) -> Result<std::borrow::Cow<'static, [u8]>> {
-        std::fs::read(path).map(Into::into).map_err(Into::into)
+    fn load(&self, path: &str) -> Result<Option<std::borrow::Cow<'static, [u8]>>> {
+        std::fs::read(path)
+            .map(Into::into)
+            .map_err(Into::into)
+            .map(|result| Some(result))
    }

    fn list(&self, path: &str) -> Result<Vec<SharedString>> {
--- a/crates/gpui/src/assets.rs
+++ b/crates/gpui/src/assets.rs
@@ -1,5 +1,5 @@
 use crate::{size, DevicePixels, Result, SharedString, Size};
-use anyhow::anyhow;
+
 use image::{Bgra, ImageBuffer};
 use std::{
    borrow::Cow,
@@ -11,18 +11,15 @@ use std::{
 /// A source of assets for this app to use.
 pub trait AssetSource: 'static + Send + Sync {
    /// Load the given asset from the source path.
-    fn load(&self, path: &str) -> Result<Cow<'static, [u8]>>;
+    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>>;

    /// List the assets at the given path.
    fn list(&self, path: &str) -> Result<Vec<SharedString>>;
 }

 impl AssetSource for () {
-    fn load(&self, path: &str) -> Result<Cow<'static, [u8]>> {
-        Err(anyhow!(
-            "load called on empty asset provider with \"{}\"",
-            path
-        ))
+    fn load(&self, _path: &str) -> Result<Option<Cow<'static, [u8]>>> {
+        Ok(None)
    }

    fn list(&self, _path: &str) -> Result<Vec<SharedString>> {
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -344,8 +344,8 @@ pub(crate) trait PlatformAtlas: Send + Sync {
    fn get_or_insert_with<'a>(
        &self,
        key: &AtlasKey,
-        build: &mut dyn FnMut() -> Result<(Size<DevicePixels>, Cow<'a, [u8]>)>,
-    ) -> Result<AtlasTile>;
+        build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,
+    ) -> Result<Option<AtlasTile>>;
 }

 #[derive(Clone, Debug, PartialEq, Eq)]
--- a/crates/gpui/src/platform/blade.rs
+++ b/crates/gpui/src/platform/blade.rs
@@ -1,8 +1,5 @@
 mod blade_atlas;
-mod blade_belt;
 mod blade_renderer;

 pub(crate) use blade_atlas::*;
 pub(crate) use blade_renderer::*;
-
-use blade_belt::*;
--- a/crates/gpui/src/platform/blade/blade_atlas.rs
+++ b/crates/gpui/src/platform/blade/blade_atlas.rs
@@ -1,10 +1,10 @@
-use super::{BladeBelt, BladeBeltDescriptor};
 use crate::{
    AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTile, Bounds, DevicePixels, PlatformAtlas,
    Point, Size,
 };
 use anyhow::Result;
 use blade_graphics as gpu;
+use blade_util::{BufferBelt, BufferBeltDescriptor};
 use collections::FxHashMap;
 use etagere::BucketedAtlasAllocator;
 use parking_lot::Mutex;
@@ -22,7 +22,7 @@ struct PendingUpload {

 struct BladeAtlasState {
    gpu: Arc<gpu::Context>,
-    upload_belt: BladeBelt,
+    upload_belt: BufferBelt,
    storage: BladeAtlasStorage,
    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
    initializations: Vec<AtlasTextureId>,
@@ -48,7 +48,7 @@ impl BladeAtlas {
    pub(crate) fn new(gpu: &Arc<gpu::Context>) -> Self {
        BladeAtlas(Mutex::new(BladeAtlasState {
            gpu: Arc::clone(gpu),
-            upload_belt: BladeBelt::new(BladeBeltDescriptor {
+            upload_belt: BufferBelt::new(BufferBeltDescriptor {
                memory: gpu::Memory::Upload,
                min_chunk_size: 0x10000,
                alignment: 64, // Vulkan `optimalBufferCopyOffsetAlignment` on Intel XE
@@ -114,18 +114,20 @@ impl PlatformAtlas for BladeAtlas {
    fn get_or_insert_with<'a>(
        &self,
        key: &AtlasKey,
-        build: &mut dyn FnMut() -> Result<(Size<DevicePixels>, Cow<'a, [u8]>)>,
-    ) -> Result<AtlasTile> {
+        build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,
+    ) -> Result<Option<AtlasTile>> {
        let mut lock = self.0.lock();
        if let Some(tile) = lock.tiles_by_key.get(key) {
-            Ok(tile.clone())
+            Ok(Some(tile.clone()))
        } else {
            profiling::scope!("new tile");
-            let (size, bytes) = build()?;
+            let Some((size, bytes)) = build()? else {
+                return Ok(None);
+            };
            let tile = lock.allocate(size, key.texture_kind());
            lock.upload_texture(tile.texture_id, tile.bounds, &bytes);
            lock.tiles_by_key.insert(key.clone(), tile.clone());
-            Ok(tile)
+            Ok(Some(tile))
        }
    }
 }
@@ -212,7 +214,7 @@ impl BladeAtlasState {
    }

    fn upload_texture(&mut self, id: AtlasTextureId, bounds: Bounds<DevicePixels>, bytes: &[u8]) {
-        let data = unsafe { self.upload_belt.alloc_data(bytes, &self.gpu) };
+        let data = self.upload_belt.alloc_bytes(bytes, &self.gpu);
        self.uploads.push(PendingUpload { id, bounds, data });
    }

--- a/crates/gpui/src/platform/blade/blade_belt.rs
+++ b/crates/gpui/src/platform/blade/blade_belt.rs
@@ -1,101 +0,0 @@
-use blade_graphics as gpu;
-use std::mem;
-
-struct ReusableBuffer {
-    raw: gpu::Buffer,
-    size: u64,
-}
-
-pub struct BladeBeltDescriptor {
-    pub memory: gpu::Memory,
-    pub min_chunk_size: u64,
-    pub alignment: u64,
-}
-
-/// A belt of buffers, used by the BladeAtlas to cheaply
-/// find staging space for uploads.
-pub struct BladeBelt {
-    desc: BladeBeltDescriptor,
-    buffers: Vec<(ReusableBuffer, gpu::SyncPoint)>,
-    active: Vec<(ReusableBuffer, u64)>,
-}
-
-impl BladeBelt {
-    pub fn new(desc: BladeBeltDescriptor) -> Self {
-        assert_ne!(desc.alignment, 0);
-        Self {
-            desc,
-            buffers: Vec::new(),
-            active: Vec::new(),
-        }
-    }
-
-    pub fn destroy(&mut self, gpu: &gpu::Context) {
-        for (buffer, _) in self.buffers.drain(..) {
-            gpu.destroy_buffer(buffer.raw);
-        }
-        for (buffer, _) in self.active.drain(..) {
-            gpu.destroy_buffer(buffer.raw);
-        }
-    }
-
-    #[profiling::function]
-    pub fn alloc(&mut self, size: u64, gpu: &gpu::Context) -> gpu::BufferPiece {
-        for &mut (ref rb, ref mut offset) in self.active.iter_mut() {
-            let aligned = offset.next_multiple_of(self.desc.alignment);
-            if aligned + size <= rb.size {
-                let piece = rb.raw.at(aligned);
-                *offset = aligned + size;
-                return piece;
-            }
-        }
-
-        let index_maybe = self
-            .buffers
-            .iter()
-            .position(|(rb, sp)| size <= rb.size && gpu.wait_for(sp, 0));
-        if let Some(index) = index_maybe {
-            let (rb, _) = self.buffers.remove(index);
-            let piece = rb.raw.into();
-            self.active.push((rb, size));
-            return piece;
-        }
-
-        let chunk_index = self.buffers.len() + self.active.len();
-        let chunk_size = size.max(self.desc.min_chunk_size);
-        let chunk = gpu.create_buffer(gpu::BufferDesc {
-            name: &format!("chunk-{}", chunk_index),
-            size: chunk_size,
-            memory: self.desc.memory,
-        });
-        let rb = ReusableBuffer {
-            raw: chunk,
-            size: chunk_size,
-        };
-        self.active.push((rb, size));
-        chunk.into()
-    }
-
-    // SAFETY: T should be zeroable and ordinary data, no references, pointers, cells or other complicated data type.
-    pub unsafe fn alloc_data<T>(&mut self, data: &[T], gpu: &gpu::Context) -> gpu::BufferPiece {
-        assert!(!data.is_empty());
-        let type_alignment = mem::align_of::<T>() as u64;
-        debug_assert_eq!(
-            self.desc.alignment % type_alignment,
-            0,
-            "Type alignment {} is too big",
-            type_alignment
-        );
-        let total_bytes = std::mem::size_of_val(data);
-        let bp = self.alloc(total_bytes as u64, gpu);
-        unsafe {
-            std::ptr::copy_nonoverlapping(data.as_ptr() as *const u8, bp.data(), total_bytes);
-        }
-        bp
-    }
-
-    pub fn flush(&mut self, sp: &gpu::SyncPoint) {
-        self.buffers
-            .extend(self.active.drain(..).map(|(rb, _)| (rb, sp.clone())));
-    }
-}
--- a/crates/gpui/src/platform/blade/blade_renderer.rs
+++ b/crates/gpui/src/platform/blade/blade_renderer.rs
@@ -1,7 +1,7 @@
 // Doing `if let` gives you nice scoping with passes/encoders
 #![allow(irrefutable_let_patterns)]

-use super::{BladeAtlas, BladeBelt, BladeBeltDescriptor, PATH_TEXTURE_FORMAT};
+use super::{BladeAtlas, PATH_TEXTURE_FORMAT};
 use crate::{
    AtlasTextureKind, AtlasTile, Bounds, ContentMask, Hsla, MonochromeSprite, Path, PathId,
    PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,
@@ -15,6 +15,7 @@ use media::core_video::CVMetalTextureCache;
 use std::{ffi::c_void, ptr::NonNull};

 use blade_graphics as gpu;
+use blade_util::{BufferBelt, BufferBeltDescriptor};
 use std::{mem, sync::Arc};

 const MAX_FRAME_TIME_MS: u32 = 1000;
@@ -346,7 +347,7 @@ pub struct BladeRenderer {
    command_encoder: gpu::CommandEncoder,
    last_sync_point: Option<gpu::SyncPoint>,
    pipelines: BladePipelines,
-    instance_belt: BladeBelt,
+    instance_belt: BufferBelt,
    path_tiles: HashMap<PathId, AtlasTile>,
    atlas: Arc<BladeAtlas>,
    atlas_sampler: gpu::Sampler,
@@ -371,7 +372,7 @@ impl BladeRenderer {
            buffer_count: 2,
        });
        let pipelines = BladePipelines::new(&gpu, surface_info);
-        let instance_belt = BladeBelt::new(BladeBeltDescriptor {
+        let instance_belt = BufferBelt::new(BufferBeltDescriptor {
            memory: gpu::Memory::Shared,
            min_chunk_size: 0x1000,
            alignment: 0x40, // Vulkan `minStorageBufferOffsetAlignment` on Intel Xe
@@ -492,7 +493,7 @@ impl BladeRenderer {
                pad: 0,
            };

-            let vertex_buf = unsafe { self.instance_belt.alloc_data(&vertices, &self.gpu) };
+            let vertex_buf = unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) };
            let mut pass = self.command_encoder.render(gpu::RenderTargetSet {
                colors: &[gpu::RenderTarget {
                    view: tex_info.raw_view,
@@ -557,7 +558,7 @@ impl BladeRenderer {
                match batch {
                    PrimitiveBatch::Quads(quads) => {
                        let instance_buf =
-                            unsafe { self.instance_belt.alloc_data(quads, &self.gpu) };
+                            unsafe { self.instance_belt.alloc_typed(quads, &self.gpu) };
                        let mut encoder = pass.with(&self.pipelines.quads);
                        encoder.bind(
                            0,
@@ -570,7 +571,7 @@ impl BladeRenderer {
                    }
                    PrimitiveBatch::Shadows(shadows) => {
                        let instance_buf =
-                            unsafe { self.instance_belt.alloc_data(shadows, &self.gpu) };
+                            unsafe { self.instance_belt.alloc_typed(shadows, &self.gpu) };
                        let mut encoder = pass.with(&self.pipelines.shadows);
                        encoder.bind(
                            0,
@@ -598,7 +599,7 @@ impl BladeRenderer {
                            }];

                            let instance_buf =
-                                unsafe { self.instance_belt.alloc_data(&sprites, &self.gpu) };
+                                unsafe { self.instance_belt.alloc_typed(&sprites, &self.gpu) };
                            encoder.bind(
                                0,
                                &ShaderPathsData {
@@ -613,7 +614,7 @@ impl BladeRenderer {
                    }
                    PrimitiveBatch::Underlines(underlines) => {
                        let instance_buf =
-                            unsafe { self.instance_belt.alloc_data(underlines, &self.gpu) };
+                            unsafe { self.instance_belt.alloc_typed(underlines, &self.gpu) };
                        let mut encoder = pass.with(&self.pipelines.underlines);
                        encoder.bind(
                            0,
@@ -630,7 +631,7 @@ impl BladeRenderer {
                    } => {
                        let tex_info = self.atlas.get_texture_info(texture_id);
                        let instance_buf =
-                            unsafe { self.instance_belt.alloc_data(sprites, &self.gpu) };
+                            unsafe { self.instance_belt.alloc_typed(sprites, &self.gpu) };
                        let mut encoder = pass.with(&self.pipelines.mono_sprites);
                        encoder.bind(
                            0,
@@ -649,7 +650,7 @@ impl BladeRenderer {
                    } => {
                        let tex_info = self.atlas.get_texture_info(texture_id);
                        let instance_buf =
-                            unsafe { self.instance_belt.alloc_data(sprites, &self.gpu) };
+                            unsafe { self.instance_belt.alloc_typed(sprites, &self.gpu) };
                        let mut encoder = pass.with(&self.pipelines.poly_sprites);
                        encoder.bind(
                            0,
--- a/crates/gpui/src/platform/mac/metal_atlas.rs
+++ b/crates/gpui/src/platform/mac/metal_atlas.rs
@@ -60,20 +60,22 @@ impl PlatformAtlas for MetalAtlas {
    fn get_or_insert_with<'a>(
        &self,
        key: &AtlasKey,
-        build: &mut dyn FnMut() -> Result<(Size<DevicePixels>, Cow<'a, [u8]>)>,
-    ) -> Result<AtlasTile> {
+        build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,
+    ) -> Result<Option<AtlasTile>> {
        let mut lock = self.0.lock();
        if let Some(tile) = lock.tiles_by_key.get(key) {
-            Ok(tile.clone())
+            Ok(Some(tile.clone()))
        } else {
-            let (size, bytes) = build()?;
+            let Some((size, bytes)) = build()? else {
+                return Ok(None);
+            };
            let tile = lock
                .allocate(size, key.texture_kind())
                .ok_or_else(|| anyhow!("failed to allocate"))?;
            let texture = lock.texture(tile.texture_id);
            texture.upload(tile.bounds, &bytes);
            lock.tiles_by_key.insert(key.clone(), tile.clone());
-            Ok(tile)
+            Ok(Some(tile))
        }
    }
 }
--- a/crates/gpui/src/platform/test/window.rs
+++ b/crates/gpui/src/platform/test/window.rs
@@ -291,25 +291,26 @@ impl PlatformAtlas for TestAtlas {
    fn get_or_insert_with<'a>(
        &self,
        key: &crate::AtlasKey,
-        build: &mut dyn FnMut() -> anyhow::Result<(
-            Size<crate::DevicePixels>,
-            std::borrow::Cow<'a, [u8]>,
-        )>,
-    ) -> anyhow::Result<crate::AtlasTile> {
+        build: &mut dyn FnMut() -> anyhow::Result<
+            Option<(Size<crate::DevicePixels>, std::borrow::Cow<'a, [u8]>)>,
+        >,
+    ) -> anyhow::Result<Option<crate::AtlasTile>> {
        let mut state = self.0.lock();
        if let Some(tile) = state.tiles.get(key) {
-            return Ok(tile.clone());
+            return Ok(Some(tile.clone()));
        }
+        drop(state);

+        let Some((size, _)) = build()? else {
+            return Ok(None);
+        };
+
+        let mut state = self.0.lock();
        state.next_id += 1;
        let texture_id = state.next_id;
        state.next_id += 1;
        let tile_id = state.next_id;

-        drop(state);
-        let (size, _) = build()?;
-        let mut state = self.0.lock();
-
        state.tiles.insert(
            key.clone(),
            crate::AtlasTile {
@@ -326,6 +327,6 @@ impl PlatformAtlas for TestAtlas {
            },
        );

-        Ok(state.tiles[key].clone())
+        Ok(Some(state.tiles[key].clone()))
    }
 }
--- a/crates/gpui/src/svg_renderer.rs
+++ b/crates/gpui/src/svg_renderer.rs
@@ -24,13 +24,15 @@ impl SvgRenderer {
        Self { asset_source }
    }

-    pub fn render(&self, params: &RenderSvgParams) -> Result<Vec<u8>> {
+    pub fn render(&self, params: &RenderSvgParams) -> Result<Option<Vec<u8>>> {
        if params.size.is_zero() {
            return Err(anyhow!("can't render at a zero size"));
        }

        // Load the tree.
-        let bytes = self.asset_source.load(&params.path)?;
+        let Some(bytes) = self.asset_source.load(&params.path)? else {
+            return Ok(None);
+        };

        let pixmap = self.render_pixmap(&bytes, SvgSize::Size(params.size))?;

@@ -40,7 +42,7 @@ impl SvgRenderer {
            .iter()
            .map(|p| p.alpha())
            .collect::<Vec<_>>();
-        Ok(alpha_mask)
+        Ok(Some(alpha_mask))
    }

    pub fn render_pixmap(&self, bytes: &[u8], size: SvgSize) -> Result<Pixmap, usvg::Error> {
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -2347,13 +2347,14 @@ impl<'a> WindowContext<'a> {

        let raster_bounds = self.text_system().raster_bounds(&params)?;
        if !raster_bounds.is_zero() {
-            let tile =
-                self.window
-                    .sprite_atlas
-                    .get_or_insert_with(&params.clone().into(), &mut || {
-                        let (size, bytes) = self.text_system().rasterize_glyph(&params)?;
-                        Ok((size, Cow::Owned(bytes)))
-                    })?;
+            let tile = self
+                .window
+                .sprite_atlas
+                .get_or_insert_with(&params.clone().into(), &mut || {
+                    let (size, bytes) = self.text_system().rasterize_glyph(&params)?;
+                    Ok(Some((size, Cow::Owned(bytes))))
+                })?
+                .expect("Callback above only errors or returns Some");
            let bounds = Bounds {
                origin: glyph_origin.map(|px| px.floor()) + raster_bounds.origin.map(Into::into),
                size: tile.bounds.size.map(Into::into),
@@ -2410,13 +2411,15 @@ impl<'a> WindowContext<'a> {

        let raster_bounds = self.text_system().raster_bounds(&params)?;
        if !raster_bounds.is_zero() {
-            let tile =
-                self.window
-                    .sprite_atlas
-                    .get_or_insert_with(&params.clone().into(), &mut || {
-                        let (size, bytes) = self.text_system().rasterize_glyph(&params)?;
-                        Ok((size, Cow::Owned(bytes)))
-                    })?;
+            let tile = self
+                .window
+                .sprite_atlas
+                .get_or_insert_with(&params.clone().into(), &mut || {
+                    let (size, bytes) = self.text_system().rasterize_glyph(&params)?;
+                    Ok(Some((size, Cow::Owned(bytes))))
+                })?
+                .expect("Callback above only errors or returns Some");
+
            let bounds = Bounds {
                origin: glyph_origin.map(|px| px.floor()) + raster_bounds.origin.map(Into::into),
                size: tile.bounds.size.map(Into::into),
@@ -2464,13 +2467,18 @@ impl<'a> WindowContext<'a> {
                .map(|pixels| DevicePixels::from((pixels.0 * 2.).ceil() as i32)),
        };

-        let tile =
+        let Some(tile) =
            self.window
                .sprite_atlas
                .get_or_insert_with(&params.clone().into(), &mut || {
-                    let bytes = self.svg_renderer.render(&params)?;
-                    Ok((params.size, Cow::Owned(bytes)))
-                })?;
+                    let Some(bytes) = self.svg_renderer.render(&params)? else {
+                        return Ok(None);
+                    };
+                    Ok(Some((params.size, Cow::Owned(bytes))))
+                })?
+        else {
+            return Ok(());
+        };
        let content_mask = self.content_mask().scale(scale_factor);

        self.window
@@ -2513,8 +2521,9 @@ impl<'a> WindowContext<'a> {
            .window
            .sprite_atlas
            .get_or_insert_with(&params.clone().into(), &mut || {
-                Ok((data.size(), Cow::Borrowed(data.as_bytes())))
-            })?;
+                Ok(Some((data.size(), Cow::Borrowed(data.as_bytes()))))
+            })?
+            .expect("Callback above only returns Some");
        let content_mask = self.content_mask().scale(scale_factor);
        let corner_radii = corner_radii.scale(scale_factor);

--- a/crates/image_viewer/src/image_viewer.rs
+++ b/crates/image_viewer/src/image_viewer.rs
@@ -95,17 +95,19 @@ impl Item for ImageView {
        let workspace_id = workspace.database_id();
        let image_path = self.path.clone();

-        cx.background_executor()
-            .spawn({
-                let image_path = image_path.clone();
-                async move {
-                    IMAGE_VIEWER
-                        .save_image_path(item_id, workspace_id, image_path)
-                        .await
-                        .log_err();
-                }
-            })
-            .detach();
+        if let Some(workspace_id) = workspace_id {
+            cx.background_executor()
+                .spawn({
+                    let image_path = image_path.clone();
+                    async move {
+                        IMAGE_VIEWER
+                            .save_image_path(item_id, workspace_id, image_path)
+                            .await
+                            .log_err();
+                    }
+                })
+                .detach();
+        }
    }

    fn serialized_item_kind() -> Option<&'static str> {
@@ -133,7 +135,7 @@ impl Item for ImageView {

    fn clone_on_split(
        &self,
-        _workspace_id: WorkspaceId,
+        _workspace_id: Option<WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Option<View<Self>>
    where
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -6,7 +6,7 @@ pub use crate::{
 };
 use crate::{
    diagnostic_set::{DiagnosticEntry, DiagnosticGroup},
-    language_settings::{language_settings, IndentGuideSettings, LanguageSettings},
+    language_settings::{language_settings, LanguageSettings},
    markdown::parse_markdown,
    outline::OutlineItem,
    syntax_map::{
@@ -542,10 +542,25 @@ pub struct IndentGuide {
    pub end_row: BufferRow,
    pub depth: u32,
    pub tab_size: u32,
-    pub settings: IndentGuideSettings,
 }

 impl IndentGuide {
+    pub fn new(
+        buffer_id: BufferId,
+        start_row: BufferRow,
+        end_row: BufferRow,
+        depth: u32,
+        tab_size: u32,
+    ) -> Self {
+        Self {
+            buffer_id,
+            start_row,
+            end_row,
+            depth,
+            tab_size,
+        }
+    }
+
    pub fn indent_level(&self) -> u32 {
        self.depth * self.tab_size
    }
@@ -3136,15 +3151,9 @@ impl BufferSnapshot {
    pub fn indent_guides_in_range(
        &self,
        range: Range<Anchor>,
-        ignore_disabled_for_language: bool,
        cx: &AppContext,
    ) -> Vec<IndentGuide> {
-        let language_settings = language_settings(self.language(), self.file.as_ref(), cx);
-        let settings = language_settings.indent_guides;
-        if !ignore_disabled_for_language && !settings.enabled {
-            return Vec::new();
-        }
-        let tab_size = language_settings.tab_size.get() as u32;
+        let tab_size = language_settings(self.language(), None, cx).tab_size.get() as u32;

        let start_row = range.start.to_point(self).row;
        let end_row = range.end.to_point(self).row;
@@ -3225,7 +3234,6 @@ impl BufferSnapshot {
                        end_row: last_row,
                        depth: next_depth,
                        tab_size,
-                        settings,
                    });
                }
            }
--- a/crates/language_tools/src/syntax_tree_view.rs
+++ b/crates/language_tools/src/syntax_tree_view.rs
@@ -407,7 +407,7 @@ impl Item for SyntaxTreeView {

    fn clone_on_split(
        &self,
-        _: workspace::WorkspaceId,
+        _: Option<workspace::WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Option<View<Self>>
    where
--- a/crates/languages/src/typescript/highlights.scm
+++ b/crates/languages/src/typescript/highlights.scm
@@ -5,6 +5,8 @@
 ; Properties

 (property_identifier) @property
+(shorthand_property_identifier) @property
+(shorthand_property_identifier_pattern) @property

 ; Function and method calls

--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -3289,17 +3289,12 @@ impl MultiBufferSnapshot {
    pub fn indent_guides_in_range(
        &self,
        range: Range<Anchor>,
-        ignore_disabled_for_language: bool,
        cx: &AppContext,
    ) -> Vec<MultiBufferIndentGuide> {
        // Fast path for singleton buffers, we can skip the conversion between offsets.
        if let Some((_, _, snapshot)) = self.as_singleton() {
            return snapshot
-                .indent_guides_in_range(
-                    range.start.text_anchor..range.end.text_anchor,
-                    ignore_disabled_for_language,
-                    cx,
-                )
+                .indent_guides_in_range(range.start.text_anchor..range.end.text_anchor, cx)
                .into_iter()
                .map(|guide| MultiBufferIndentGuide {
                    multibuffer_row_range: MultiBufferRow(guide.start_row)
@@ -3319,11 +3314,7 @@ impl MultiBufferSnapshot {

                excerpt
                    .buffer
-                    .indent_guides_in_range(
-                        excerpt.range.context.clone(),
-                        ignore_disabled_for_language,
-                        cx,
-                    )
+                    .indent_guides_in_range(excerpt.range.context.clone(), cx)
                    .into_iter()
                    .map(move |indent_guide| {
                        let start_row = excerpt_offset_row
--- a/crates/open_ai/Cargo.toml
+++ b/crates/open_ai/Cargo.toml
@@ -20,3 +20,4 @@ isahc.workspace = true
 schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
+strum.workspace = true
--- a/crates/open_ai/src/open_ai.rs
+++ b/crates/open_ai/src/open_ai.rs
@@ -4,8 +4,8 @@ use http::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use isahc::config::Configurable;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
-use std::time::Duration;
-use std::{convert::TryFrom, future::Future};
+use std::{convert::TryFrom, future::Future, time::Duration};
+use strum::EnumIter;

 pub const OPEN_AI_API_URL: &str = "https://api.openai.com/v1";

@@ -44,7 +44,7 @@ impl From<Role> for String {
 }

 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
    #[serde(rename = "gpt-3.5-turbo", alias = "gpt-3.5-turbo-0613")]
    ThreePointFiveTurbo,
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -4989,21 +4989,20 @@ impl Project {
                    FormatOnSave::On | FormatOnSave::Off,
                )
                | (_, FormatOnSave::External { command, arguments }) => {
-                    if let Some(buffer_abs_path) = buffer_abs_path {
-                        format_operation = Self::format_via_external_command(
-                            buffer,
-                            buffer_abs_path,
-                            command,
-                            arguments,
-                            &mut cx,
-                        )
-                        .await
-                        .context(format!(
-                            "failed to format via external command {:?}",
-                            command
-                        ))?
-                        .map(FormatOperation::External);
-                    }
+                    let buffer_abs_path = buffer_abs_path.as_ref().map(|path| path.as_path());
+                    format_operation = Self::format_via_external_command(
+                        buffer,
+                        buffer_abs_path,
+                        command,
+                        arguments,
+                        &mut cx,
+                    )
+                    .await
+                    .context(format!(
+                        "failed to format via external command {:?}",
+                        command
+                    ))?
+                    .map(FormatOperation::External);
                }
                (Formatter::Auto, FormatOnSave::On | FormatOnSave::Off) => {
                    let prettier = if prettier_settings.allowed {
@@ -5142,7 +5141,7 @@ impl Project {

    async fn format_via_external_command(
        buffer: &Model<Buffer>,
-        buffer_abs_path: &Path,
+        buffer_abs_path: Option<&Path>,
        command: &str,
        arguments: &[String],
        cx: &mut AsyncAppContext,
@@ -5157,46 +5156,51 @@ impl Project {
            Some(worktree_path)
        })?;

-        if let Some(working_dir_path) = working_dir_path {
-            let mut child =
-                smol::process::Command::new(command)
-                    .args(arguments.iter().map(|arg| {
-                        arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())
-                    }))
-                    .current_dir(&working_dir_path)
-                    .stdin(smol::process::Stdio::piped())
-                    .stdout(smol::process::Stdio::piped())
-                    .stderr(smol::process::Stdio::piped())
-                    .spawn()?;
-            let stdin = child
-                .stdin
-                .as_mut()
-                .ok_or_else(|| anyhow!("failed to acquire stdin"))?;
-            let text = buffer.update(cx, |buffer, _| buffer.as_rope().clone())?;
-            for chunk in text.chunks() {
-                stdin.write_all(chunk.as_bytes()).await?;
-            }
-            stdin.flush().await?;
+        let mut child = smol::process::Command::new(command);

-            let output = child.output().await?;
-            if !output.status.success() {
-                return Err(anyhow!(
-                    "command failed with exit code {:?}:\nstdout: {}\nstderr: {}",
-                    output.status.code(),
-                    String::from_utf8_lossy(&output.stdout),
-                    String::from_utf8_lossy(&output.stderr),
-                ));
-            }
-
-            let stdout = String::from_utf8(output.stdout)?;
-            Ok(Some(
-                buffer
-                    .update(cx, |buffer, cx| buffer.diff(stdout, cx))?
-                    .await,
-            ))
-        } else {
-            Ok(None)
+        if let Some(buffer_abs_path) = buffer_abs_path {
+            child.args(
+                arguments
+                    .iter()
+                    .map(|arg| arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())),
+            );
        }
+        if let Some(working_dir_path) = working_dir_path {
+            child.current_dir(working_dir_path);
+        }
+
+        let mut child = child
+            .stdin(smol::process::Stdio::piped())
+            .stdout(smol::process::Stdio::piped())
+            .stderr(smol::process::Stdio::piped())
+            .spawn()?;
+
+        let stdin = child
+            .stdin
+            .as_mut()
+            .ok_or_else(|| anyhow!("failed to acquire stdin"))?;
+        let text = buffer.update(cx, |buffer, _| buffer.as_rope().clone())?;
+        for chunk in text.chunks() {
+            stdin.write_all(chunk.as_bytes()).await?;
+        }
+        stdin.flush().await?;
+
+        let output = child.output().await?;
+        if !output.status.success() {
+            return Err(anyhow!(
+                "command failed with exit code {:?}:\nstdout: {}\nstderr: {}",
+                output.status.code(),
+                String::from_utf8_lossy(&output.stdout),
+                String::from_utf8_lossy(&output.stderr),
+            ));
+        }
+
+        let stdout = String::from_utf8(output.stdout)?;
+        Ok(Some(
+            buffer
+                .update(cx, |buffer, cx| buffer.diff(stdout, cx))?
+                .await,
+        ))
    }

    #[inline(never)]
@@ -7856,10 +7860,7 @@ impl Project {
                                    None
                                } else {
                                    let relative_path = repo.relativize(&snapshot, &path).ok()?;
-                                    local_repo_entry
-                                        .repo()
-                                        .lock()
-                                        .load_index_text(&relative_path)
+                                    local_repo_entry.repo().load_index_text(&relative_path)
                                };
                                Some((buffer, base_text))
                            }
@@ -8194,7 +8195,7 @@ impl Project {
        &self,
        project_path: &ProjectPath,
        cx: &AppContext,
-    ) -> Option<Arc<Mutex<dyn GitRepository>>> {
+    ) -> Option<Arc<dyn GitRepository>> {
        self.worktree_for_id(project_path.worktree_id, cx)?
            .read(cx)
            .as_local()?
@@ -8202,10 +8203,7 @@ impl Project {
            .local_git_repo(&project_path.path)
    }

-    pub fn get_first_worktree_root_repo(
-        &self,
-        cx: &AppContext,
-    ) -> Option<Arc<Mutex<dyn GitRepository>>> {
+    pub fn get_first_worktree_root_repo(&self, cx: &AppContext) -> Option<Arc<dyn GitRepository>> {
        let worktree = self.visible_worktrees(cx).next()?.read(cx).as_local()?;
        let root_entry = worktree.root_git_entry()?;

@@ -8255,8 +8253,7 @@ impl Project {

            cx.background_executor().spawn(async move {
                let (repo, relative_path, content) = blame_params?;
-                let lock = repo.lock();
-                lock.blame(&relative_path, content)
+                repo.blame(&relative_path, content)
                    .with_context(|| format!("Failed to blame {:?}", relative_path.0))
            })
        } else {
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -229,6 +229,7 @@ impl PickerDelegate for RecentProjectsDelegate {
            .workspaces
            .iter()
            .enumerate()
+            .filter(|(_, (id, _))| !self.is_current_workspace(*id, cx))
            .map(|(id, (_, location))| {
                let combined_string = match location {
                    SerializedWorkspaceLocation::Local(paths, _) => paths
@@ -287,7 +288,7 @@ impl PickerDelegate for RecentProjectsDelegate {
            };
            workspace
                .update(cx, |workspace, cx| {
-                    if workspace.database_id() == *candidate_workspace_id {
+                    if workspace.database_id() == Some(*candidate_workspace_id) {
                        Task::ready(Ok(()))
                    } else {
                        match candidate_workspace_location {
@@ -393,8 +394,7 @@ impl PickerDelegate for RecentProjectsDelegate {
            return None;
        };

-        let (workspace_id, location) = &self.workspaces[hit.candidate_id];
-        let is_current_workspace = self.is_current_workspace(*workspace_id, cx);
+        let (_, location) = self.workspaces.get(hit.candidate_id)?;

        let is_remote = matches!(location, SerializedWorkspaceLocation::DevServer(_));
        let dev_server_status =
@@ -487,7 +487,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                            highlighted.render(cx)
                        }),
                )
-                .when(!is_current_workspace, |el| {
+                .map(|el| {
                    let delete_button = div()
                        .child(
                            IconButton::new("delete", IconName::Close)
@@ -675,7 +675,7 @@ impl RecentProjectsDelegate {
    ) -> bool {
        if let Some(workspace) = self.workspace.upgrade() {
            let workspace = workspace.read(cx);
-            if workspace_id == workspace.database_id() {
+            if Some(workspace_id) == workspace.database_id() {
                return true;
            }
        }
--- a/crates/rpc/proto/zed.proto
+++ b/crates/rpc/proto/zed.proto
@@ -159,6 +159,7 @@ message Envelope {
        SetChannelMemberRole set_channel_member_role = 123;
        RenameChannel rename_channel = 124;
        RenameChannelResponse rename_channel_response = 125;
+        SubscribeToChannels subscribe_to_channels = 207; // current max

        JoinChannelBuffer join_channel_buffer = 126;
        JoinChannelBufferResponse join_channel_buffer_response = 127;
@@ -250,7 +251,7 @@ message Envelope {
        TaskContextForLocation task_context_for_location = 203;
        TaskContext task_context = 204;
        TaskTemplatesResponse task_templates_response = 205;
-        TaskTemplates task_templates = 206; // Current max
+        TaskTemplates task_templates = 206;
    }

    reserved 158 to 161;
@@ -1297,6 +1298,8 @@ message ChannelMember {
    }
 }

+message SubscribeToChannels {}
+
 message CreateChannel {
    string name = 1;
    optional uint64 parent_id = 2;
--- a/crates/rpc/src/proto.rs
+++ b/crates/rpc/src/proto.rs
@@ -277,6 +277,7 @@ messages!(
    (ShareProjectResponse, Foreground),
    (ShowContacts, Foreground),
    (StartLanguageServer, Foreground),
+    (SubscribeToChannels, Foreground),
    (SynchronizeBuffers, Foreground),
    (SynchronizeBuffersResponse, Foreground),
    (TaskContextForLocation, Background),
--- a/crates/rustdoc_to_markdown/Cargo.toml
+++ b/crates/rustdoc_to_markdown/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "rustdoc_to_markdown"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/rustdoc_to_markdown.rs"
+
+[dependencies]
+anyhow.workspace = true
+html5ever.workspace = true
+markup5ever_rcdom.workspace = true
+regex.workspace = true
+
+[dev-dependencies]
+indoc.workspace = true
+pretty_assertions.workspace = true
--- a/crates/rustdoc_to_markdown/LICENSE-GPL
+++ b/crates/rustdoc_to_markdown/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
--- a/crates/rustdoc_to_markdown/examples/test.rs
+++ b/crates/rustdoc_to_markdown/examples/test.rs
@@ -0,0 +1,29 @@
+use indoc::indoc;
+use rustdoc_to_markdown::convert_rustdoc_to_markdown;
+
+pub fn main() {
+    let html = indoc! {"
+        <html>
+            <body>
+                <h1>Hello World</h1>
+                <p>
+                    Here is some content.
+                </p>
+                <h2>Some items</h2>
+                <ul>
+                    <li>One</li>
+                    <li>Two</li>
+                    <li>Three</li>
+                </ul>
+            </body>
+        </html>
+    "};
+    // To test this out with some real input, try this:
+    //
+    // ```
+    // let html = include_str!("/path/to/zed/target/doc/gpui/index.html");
+    // ```
+    let markdown = convert_rustdoc_to_markdown(html.as_bytes()).unwrap();
+
+    println!("{markdown}");
+}
--- a/crates/rustdoc_to_markdown/src/html_element.rs
+++ b/crates/rustdoc_to_markdown/src/html_element.rs
@@ -0,0 +1,75 @@
+use std::cell::RefCell;
+use std::collections::HashSet;
+use std::sync::OnceLock;
+
+use html5ever::Attribute;
+
+/// Returns a [`HashSet`] containing the HTML elements that are inline by default.
+///
+/// [MDN: List of "inline" elements](https://yari-demos.prod.mdn.mozit.cloud/en-US/docs/Web/HTML/Inline_elements)
+fn inline_elements() -> &'static HashSet<&'static str> {
+    static INLINE_ELEMENTS: OnceLock<HashSet<&str>> = OnceLock::new();
+    &INLINE_ELEMENTS.get_or_init(|| {
+        HashSet::from_iter([
+            "a", "abbr", "acronym", "audio", "b", "bdi", "bdo", "big", "br", "button", "canvas",
+            "cite", "code", "data", "datalist", "del", "dfn", "em", "embed", "i", "iframe", "img",
+            "input", "ins", "kbd", "label", "map", "mark", "meter", "noscript", "object", "output",
+            "picture", "progress", "q", "ruby", "s", "samp", "script", "select", "slot", "small",
+            "span", "strong", "sub", "sup", "svg", "template", "textarea", "time", "tt", "u",
+            "var", "video", "wbr",
+        ])
+    })
+}
+
+#[derive(Debug, Clone)]
+pub struct HtmlElement {
+    pub(crate) tag: String,
+    pub(crate) attrs: RefCell<Vec<Attribute>>,
+}
+
+impl HtmlElement {
+    /// Returns whether this [`HtmlElement`] is an inline element.
+    pub fn is_inline(&self) -> bool {
+        inline_elements().contains(self.tag.as_str())
+    }
+
+    /// Returns the attribute with the specified name.
+    pub fn attr(&self, name: &str) -> Option<String> {
+        self.attrs
+            .borrow()
+            .iter()
+            .find(|attr| attr.name.local.to_string() == name)
+            .map(|attr| attr.value.to_string())
+    }
+
+    /// Returns the list of classes on this [`HtmlElement`].
+    pub fn classes(&self) -> Vec<String> {
+        self.attrs
+            .borrow()
+            .iter()
+            .find(|attr| attr.name.local.to_string() == "class")
+            .map(|attr| {
+                attr.value
+                    .split(' ')
+                    .map(|class| class.trim().to_string())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Returns whether this [`HtmlElement`] has the specified class.
+    pub fn has_class(&self, class: &str) -> bool {
+        self.has_any_classes(&[class])
+    }
+
+    /// Returns whether this [`HtmlElement`] has any of the specified classes.
+    pub fn has_any_classes(&self, classes: &[&str]) -> bool {
+        self.attrs.borrow().iter().any(|attr| {
+            attr.name.local.to_string() == "class"
+                && attr
+                    .value
+                    .split(' ')
+                    .any(|class| classes.contains(&class.trim()))
+        })
+    }
+}
--- a/crates/rustdoc_to_markdown/src/markdown_writer.rs
+++ b/crates/rustdoc_to_markdown/src/markdown_writer.rs
@@ -0,0 +1,296 @@
+use std::collections::VecDeque;
+use std::sync::OnceLock;
+
+use anyhow::Result;
+use markup5ever_rcdom::{Handle, NodeData};
+use regex::Regex;
+
+use crate::html_element::HtmlElement;
+
+fn empty_line_regex() -> &'static Regex {
+    static REGEX: OnceLock<Regex> = OnceLock::new();
+    REGEX.get_or_init(|| Regex::new(r"^\s*$").unwrap())
+}
+
+fn more_than_three_newlines_regex() -> &'static Regex {
+    static REGEX: OnceLock<Regex> = OnceLock::new();
+    REGEX.get_or_init(|| Regex::new(r"\n{3,}").unwrap())
+}
+
+const RUSTDOC_ITEM_NAME_CLASS: &str = "item-name";
+
+enum StartTagOutcome {
+    Continue,
+    Skip,
+}
+
+pub struct MarkdownWriter {
+    current_element_stack: VecDeque<HtmlElement>,
+    /// The number of columns in the current `<table>`.
+    current_table_columns: usize,
+    is_first_th: bool,
+    is_first_td: bool,
+    /// The Markdown output.
+    markdown: String,
+}
+
+impl MarkdownWriter {
+    pub fn new() -> Self {
+        Self {
+            current_element_stack: VecDeque::new(),
+            current_table_columns: 0,
+            is_first_th: true,
+            is_first_td: true,
+            markdown: String::new(),
+        }
+    }
+
+    fn is_inside(&self, tag: &str) -> bool {
+        self.current_element_stack
+            .iter()
+            .any(|parent_element| parent_element.tag == tag)
+    }
+
+    /// Appends the given string slice onto the end of the Markdown output.
+    fn push_str(&mut self, str: &str) {
+        self.markdown.push_str(str);
+    }
+
+    /// Appends a newline to the end of the Markdown output.
+    fn push_newline(&mut self) {
+        self.push_str("\n");
+    }
+
+    /// Appends a blank line to the end of the Markdown output.
+    fn push_blank_line(&mut self) {
+        self.push_str("\n\n");
+    }
+
+    pub fn run(mut self, root_node: &Handle) -> Result<String> {
+        self.visit_node(&root_node)?;
+        Ok(Self::prettify_markdown(self.markdown))
+    }
+
+    fn prettify_markdown(markdown: String) -> String {
+        let markdown = empty_line_regex().replace_all(&markdown, "");
+        let markdown = more_than_three_newlines_regex().replace_all(&markdown, "\n\n");
+
+        markdown.trim().to_string()
+    }
+
+    fn visit_node(&mut self, node: &Handle) -> Result<()> {
+        let mut current_element = None;
+
+        match node.data {
+            NodeData::Document
+            | NodeData::Doctype { .. }
+            | NodeData::ProcessingInstruction { .. }
+            | NodeData::Comment { .. } => {
+                // Currently left unimplemented, as we're not interested in this data
+                // at this time.
+            }
+            NodeData::Element {
+                ref name,
+                ref attrs,
+                ..
+            } => {
+                let tag_name = name.local.to_string();
+                if !tag_name.is_empty() {
+                    current_element = Some(HtmlElement {
+                        tag: tag_name,
+                        attrs: attrs.clone(),
+                    });
+                }
+            }
+            NodeData::Text { ref contents } => {
+                let text = contents.borrow().to_string();
+                self.visit_text(text)?;
+            }
+        }
+
+        if let Some(current_element) = current_element.as_ref() {
+            match self.start_tag(&current_element) {
+                StartTagOutcome::Continue => {}
+                StartTagOutcome::Skip => return Ok(()),
+            }
+
+            self.current_element_stack
+                .push_back(current_element.clone());
+        }
+
+        for child in node.children.borrow().iter() {
+            self.visit_node(child)?;
+        }
+
+        if let Some(current_element) = current_element {
+            self.current_element_stack.pop_back();
+            self.end_tag(&current_element);
+        }
+
+        Ok(())
+    }
+
+    fn start_tag(&mut self, tag: &HtmlElement) -> StartTagOutcome {
+        if tag.is_inline() && self.is_inside("p") {
+            if let Some(parent) = self.current_element_stack.iter().last() {
+                if !parent.is_inline() {
+                    if !(self.markdown.ends_with(' ') || self.markdown.ends_with('\n')) {
+                        self.push_str(" ");
+                    }
+                }
+            }
+        }
+
+        match tag.tag.as_str() {
+            "head" | "script" | "nav" => return StartTagOutcome::Skip,
+            "h1" => self.push_str("\n\n# "),
+            "h2" => self.push_str("\n\n## "),
+            "h3" => self.push_str("\n\n### "),
+            "h4" => self.push_str("\n\n#### "),
+            "h5" => self.push_str("\n\n##### "),
+            "h6" => self.push_str("\n\n###### "),
+            "p" => self.push_blank_line(),
+            "strong" => self.push_str("**"),
+            "em" => self.push_str("_"),
+            "code" => {
+                if !self.is_inside("pre") {
+                    self.push_str("`");
+                }
+            }
+            "pre" => {
+                let classes = tag.classes();
+                let is_rust = classes.iter().any(|class| class == "rust");
+                let language = is_rust
+                    .then(|| "rs")
+                    .or_else(|| {
+                        classes.iter().find_map(|class| {
+                            if let Some((_, language)) = class.split_once("language-") {
+                                Some(language.trim())
+                            } else {
+                                None
+                            }
+                        })
+                    })
+                    .unwrap_or("");
+
+                self.push_str(&format!("\n\n```{language}\n"));
+            }
+            "ul" | "ol" => self.push_newline(),
+            "li" => self.push_str("- "),
+            "thead" => self.push_blank_line(),
+            "tr" => self.push_newline(),
+            "th" => {
+                self.current_table_columns += 1;
+                if self.is_first_th {
+                    self.is_first_th = false;
+                } else {
+                    self.push_str(" ");
+                }
+                self.push_str("| ");
+            }
+            "td" => {
+                if self.is_first_td {
+                    self.is_first_td = false;
+                } else {
+                    self.push_str(" ");
+                }
+                self.push_str("| ");
+            }
+            "summary" => {
+                if tag.has_class("hideme") {
+                    return StartTagOutcome::Skip;
+                }
+            }
+            "button" => {
+                if tag.attr("id").as_deref() == Some("copy-path") {
+                    return StartTagOutcome::Skip;
+                }
+            }
+            "div" | "span" => {
+                let classes_to_skip = ["nav-container", "sidebar-elems", "out-of-band"];
+                if tag.has_any_classes(&classes_to_skip) {
+                    return StartTagOutcome::Skip;
+                }
+
+                if self.is_inside_item_name() && tag.has_class("stab") {
+                    self.push_str(" [");
+                }
+            }
+            _ => {}
+        }
+
+        StartTagOutcome::Continue
+    }
+
+    fn end_tag(&mut self, tag: &HtmlElement) {
+        match tag.tag.as_str() {
+            "h1" | "h2" | "h3" | "h4" | "h5" | "h6" => self.push_str("\n\n"),
+            "strong" => self.push_str("**"),
+            "em" => self.push_str("_"),
+            "code" => {
+                if !self.is_inside("pre") {
+                    self.push_str("`");
+                }
+            }
+            "pre" => self.push_str("\n```\n"),
+            "ul" | "ol" => self.push_newline(),
+            "li" => self.push_newline(),
+            "thead" => {
+                self.push_newline();
+                for ix in 0..self.current_table_columns {
+                    if ix > 0 {
+                        self.push_str(" ");
+                    }
+                    self.push_str("| ---");
+                }
+                self.push_str(" |");
+                self.is_first_th = true;
+            }
+            "tr" => {
+                self.push_str(" |");
+                self.is_first_td = true;
+            }
+            "table" => {
+                self.current_table_columns = 0;
+            }
+            "div" | "span" => {
+                if tag.has_class(RUSTDOC_ITEM_NAME_CLASS) {
+                    self.push_str(": ");
+                }
+
+                if self.is_inside_item_name() && tag.has_class("stab") {
+                    self.push_str("]");
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_text(&mut self, text: String) -> Result<()> {
+        if self.is_inside("pre") {
+            self.push_str(&text);
+            return Ok(());
+        }
+
+        let text = text
+            .trim_matches(|char| char == '\n' || char == '\r' || char == '§')
+            .replace('\n', " ");
+
+        if self.is_inside_item_name() && !self.is_inside("span") && !self.is_inside("code") {
+            self.push_str(&format!("`{text}`"));
+            return Ok(());
+        }
+
+        self.push_str(&text);
+
+        Ok(())
+    }
+
+    /// Returns whether we're currently inside of an `.item-name` element, which
+    /// rustdoc uses to display Rust items in a list.
+    fn is_inside_item_name(&self) -> bool {
+        self.current_element_stack
+            .iter()
+            .any(|element| element.has_class(RUSTDOC_ITEM_NAME_CLASS))
+    }
+}
--- a/crates/rustdoc_to_markdown/src/rustdoc_to_markdown.rs
+++ b/crates/rustdoc_to_markdown/src/rustdoc_to_markdown.rs
@@ -0,0 +1,317 @@
+//! Provides conversion from rustdoc's HTML output to Markdown.
+
+#![deny(missing_docs)]
+
+mod html_element;
+mod markdown_writer;
+
+use std::io::Read;
+
+use anyhow::{Context, Result};
+use html5ever::driver::ParseOpts;
+use html5ever::parse_document;
+use html5ever::tendril::TendrilSink;
+use html5ever::tree_builder::TreeBuilderOpts;
+use markup5ever_rcdom::RcDom;
+
+use crate::markdown_writer::MarkdownWriter;
+
+/// Converts the provided rustdoc HTML to Markdown.
+pub fn convert_rustdoc_to_markdown(mut html: impl Read) -> Result<String> {
+    let parse_options = ParseOpts {
+        tree_builder: TreeBuilderOpts {
+            drop_doctype: true,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    let dom = parse_document(RcDom::default(), parse_options)
+        .from_utf8()
+        .read_from(&mut html)
+        .context("failed to parse rustdoc HTML")?;
+
+    let markdown_writer = MarkdownWriter::new();
+    let markdown = markdown_writer
+        .run(&dom.document)
+        .context("failed to convert rustdoc to HTML")?;
+
+    Ok(markdown)
+}
+
+#[cfg(test)]
+mod tests {
+    use indoc::indoc;
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_main_heading_buttons_get_removed() {
+        let html = indoc! {r##"
+            <div class="main-heading">
+                <h1>Crate <a class="mod" href="#">serde</a><button id="copy-path" title="Copy item path to clipboard">Copy item path</button></h1>
+                <span class="out-of-band">
+                    <a class="src" href="../src/serde/lib.rs.html#1-340">source</a> · <button id="toggle-all-docs" title="collapse all docs">[<span>−</span>]</button>
+                </span>
+            </div>
+        "##};
+        let expected = indoc! {"
+            # Crate serde
+        "}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+
+    #[test]
+    fn test_single_paragraph() {
+        let html = indoc! {r#"
+            <p>In particular, the last point is what sets <code>axum</code> apart from other frameworks.
+            <code>axum</code> doesn’t have its own middleware system but instead uses
+            <a href="https://docs.rs/tower-service/0.3.2/x86_64-unknown-linux-gnu/tower_service/trait.Service.html" title="trait tower_service::Service"><code>tower::Service</code></a>. This means <code>axum</code> gets timeouts, tracing, compression,
+            authorization, and more, for free. It also enables you to share middleware with
+            applications written using <a href="http://crates.io/crates/hyper"><code>hyper</code></a> or <a href="http://crates.io/crates/tonic"><code>tonic</code></a>.</p>
+        "#};
+        let expected = indoc! {"
+            In particular, the last point is what sets `axum` apart from other frameworks. `axum` doesn’t have its own middleware system but instead uses `tower::Service`. This means `axum` gets timeouts, tracing, compression, authorization, and more, for free. It also enables you to share middleware with applications written using `hyper` or `tonic`.
+        "}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+
+    #[test]
+    fn test_multiple_paragraphs() {
+        let html = indoc! {r##"
+            <h2 id="serde"><a class="doc-anchor" href="#serde">§</a>Serde</h2>
+            <p>Serde is a framework for <em><strong>ser</strong></em>ializing and <em><strong>de</strong></em>serializing Rust data
+            structures efficiently and generically.</p>
+            <p>The Serde ecosystem consists of data structures that know how to serialize
+            and deserialize themselves along with data formats that know how to
+            serialize and deserialize other things. Serde provides the layer by which
+            these two groups interact with each other, allowing any supported data
+            structure to be serialized and deserialized using any supported data format.</p>
+            <p>See the Serde website <a href="https://serde.rs/">https://serde.rs/</a> for additional documentation and
+            usage examples.</p>
+            <h3 id="design"><a class="doc-anchor" href="#design">§</a>Design</h3>
+            <p>Where many other languages rely on runtime reflection for serializing data,
+            Serde is instead built on Rust’s powerful trait system. A data structure
+            that knows how to serialize and deserialize itself is one that implements
+            Serde’s <code>Serialize</code> and <code>Deserialize</code> traits (or uses Serde’s derive
+            attribute to automatically generate implementations at compile time). This
+            avoids any overhead of reflection or runtime type information. In fact in
+            many situations the interaction between data structure and data format can
+            be completely optimized away by the Rust compiler, leaving Serde
+            serialization to perform the same speed as a handwritten serializer for the
+            specific selection of data structure and data format.</p>
+        "##};
+        let expected = indoc! {"
+            ## Serde
+
+            Serde is a framework for _**ser**_ializing and _**de**_serializing Rust data structures efficiently and generically.
+
+            The Serde ecosystem consists of data structures that know how to serialize and deserialize themselves along with data formats that know how to serialize and deserialize other things. Serde provides the layer by which these two groups interact with each other, allowing any supported data structure to be serialized and deserialized using any supported data format.
+
+            See the Serde website https://serde.rs/ for additional documentation and usage examples.
+
+            ### Design
+
+            Where many other languages rely on runtime reflection for serializing data, Serde is instead built on Rust’s powerful trait system. A data structure that knows how to serialize and deserialize itself is one that implements Serde’s `Serialize` and `Deserialize` traits (or uses Serde’s derive attribute to automatically generate implementations at compile time). This avoids any overhead of reflection or runtime type information. In fact in many situations the interaction between data structure and data format can be completely optimized away by the Rust compiler, leaving Serde serialization to perform the same speed as a handwritten serializer for the specific selection of data structure and data format.
+        "}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+
+    #[test]
+    fn test_styled_text() {
+        let html = indoc! {r#"
+            <p>This text is <strong>bolded</strong>.</p>
+            <p>This text is <em>italicized</em>.</p>
+        "#};
+        let expected = indoc! {"
+            This text is **bolded**.
+
+            This text is _italicized_.
+        "}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+
+    #[test]
+    fn test_rust_code_block() {
+        let html = indoc! {r#"
+            <pre class="rust rust-example-rendered"><code><span class="kw">use </span>axum::extract::{Path, Query, Json};
+            <span class="kw">use </span>std::collections::HashMap;
+
+            <span class="comment">// `Path` gives you the path parameters and deserializes them.
+            </span><span class="kw">async fn </span>path(Path(user_id): Path&lt;u32&gt;) {}
+
+            <span class="comment">// `Query` gives you the query parameters and deserializes them.
+            </span><span class="kw">async fn </span>query(Query(params): Query&lt;HashMap&lt;String, String&gt;&gt;) {}
+
+            <span class="comment">// Buffer the request body and deserialize it as JSON into a
+            // `serde_json::Value`. `Json` supports any type that implements
+            // `serde::Deserialize`.
+            </span><span class="kw">async fn </span>json(Json(payload): Json&lt;serde_json::Value&gt;) {}</code></pre>
+        "#};
+        let expected = indoc! {"
+            ```rs
+            use axum::extract::{Path, Query, Json};
+            use std::collections::HashMap;
+
+            // `Path` gives you the path parameters and deserializes them.
+            async fn path(Path(user_id): Path<u32>) {}
+
+            // `Query` gives you the query parameters and deserializes them.
+            async fn query(Query(params): Query<HashMap<String, String>>) {}
+
+            // Buffer the request body and deserialize it as JSON into a
+            // `serde_json::Value`. `Json` supports any type that implements
+            // `serde::Deserialize`.
+            async fn json(Json(payload): Json<serde_json::Value>) {}
+            ```
+        "}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+
+    #[test]
+    fn test_toml_code_block() {
+        let html = indoc! {r##"
+            <h2 id="required-dependencies"><a class="doc-anchor" href="#required-dependencies">§</a>Required dependencies</h2>
+            <p>To use axum there are a few dependencies you have to pull in as well:</p>
+            <div class="example-wrap"><pre class="language-toml"><code>[dependencies]
+            axum = &quot;&lt;latest-version&gt;&quot;
+            tokio = { version = &quot;&lt;latest-version&gt;&quot;, features = [&quot;full&quot;] }
+            tower = &quot;&lt;latest-version&gt;&quot;
+            </code></pre></div>
+        "##};
+        let expected = indoc! {r#"
+            ## Required dependencies
+
+            To use axum there are a few dependencies you have to pull in as well:
+
+            ```toml
+            [dependencies]
+            axum = "<latest-version>"
+            tokio = { version = "<latest-version>", features = ["full"] }
+            tower = "<latest-version>"
+
+            ```
+        "#}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+
+    #[test]
+    fn test_item_table() {
+        let html = indoc! {r##"
+            <h2 id="structs" class="section-header">Structs<a href="#structs" class="anchor">§</a></h2>
+            <ul class="item-table">
+            <li><div class="item-name"><a class="struct" href="struct.Error.html" title="struct axum::Error">Error</a></div><div class="desc docblock-short">Errors that can happen when using axum.</div></li>
+            <li><div class="item-name"><a class="struct" href="struct.Extension.html" title="struct axum::Extension">Extension</a></div><div class="desc docblock-short">Extractor and response for extensions.</div></li>
+            <li><div class="item-name"><a class="struct" href="struct.Form.html" title="struct axum::Form">Form</a><span class="stab portability" title="Available on crate feature `form` only"><code>form</code></span></div><div class="desc docblock-short">URL encoded extractor and response.</div></li>
+            <li><div class="item-name"><a class="struct" href="struct.Json.html" title="struct axum::Json">Json</a><span class="stab portability" title="Available on crate feature `json` only"><code>json</code></span></div><div class="desc docblock-short">JSON Extractor / Response.</div></li>
+            <li><div class="item-name"><a class="struct" href="struct.Router.html" title="struct axum::Router">Router</a></div><div class="desc docblock-short">The router type for composing handlers and services.</div></li></ul>
+            <h2 id="functions" class="section-header">Functions<a href="#functions" class="anchor">§</a></h2>
+            <ul class="item-table">
+            <li><div class="item-name"><a class="fn" href="fn.serve.html" title="fn axum::serve">serve</a><span class="stab portability" title="Available on crate feature `tokio` and (crate features `http1` or `http2`) only"><code>tokio</code> and (<code>http1</code> or <code>http2</code>)</span></div><div class="desc docblock-short">Serve the service with the supplied listener.</div></li>
+            </ul>
+        "##};
+        let expected = indoc! {r#"
+            ## Structs
+
+            - `Error`: Errors that can happen when using axum.
+            - `Extension`: Extractor and response for extensions.
+            - `Form` [`form`]: URL encoded extractor and response.
+            - `Json` [`json`]: JSON Extractor / Response.
+            - `Router`: The router type for composing handlers and services.
+
+            ## Functions
+
+            - `serve` [`tokio` and (`http1` or `http2`)]: Serve the service with the supplied listener.
+        "#}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+
+    #[test]
+    fn test_table() {
+        let html = indoc! {r##"
+            <h2 id="feature-flags"><a class="doc-anchor" href="#feature-flags">§</a>Feature flags</h2>
+            <p>axum uses a set of <a href="https://doc.rust-lang.org/cargo/reference/features.html#the-features-section">feature flags</a> to reduce the amount of compiled and
+            optional dependencies.</p>
+            <p>The following optional features are available:</p>
+            <div><table><thead><tr><th>Name</th><th>Description</th><th>Default?</th></tr></thead><tbody>
+            <tr><td><code>http1</code></td><td>Enables hyper’s <code>http1</code> feature</td><td>Yes</td></tr>
+            <tr><td><code>http2</code></td><td>Enables hyper’s <code>http2</code> feature</td><td>No</td></tr>
+            <tr><td><code>json</code></td><td>Enables the <a href="struct.Json.html" title="struct axum::Json"><code>Json</code></a> type and some similar convenience functionality</td><td>Yes</td></tr>
+            <tr><td><code>macros</code></td><td>Enables optional utility macros</td><td>No</td></tr>
+            <tr><td><code>matched-path</code></td><td>Enables capturing of every request’s router path and the <a href="extract/struct.MatchedPath.html" title="struct axum::extract::MatchedPath"><code>MatchedPath</code></a> extractor</td><td>Yes</td></tr>
+            <tr><td><code>multipart</code></td><td>Enables parsing <code>multipart/form-data</code> requests with <a href="extract/struct.Multipart.html" title="struct axum::extract::Multipart"><code>Multipart</code></a></td><td>No</td></tr>
+            <tr><td><code>original-uri</code></td><td>Enables capturing of every request’s original URI and the <a href="extract/struct.OriginalUri.html" title="struct axum::extract::OriginalUri"><code>OriginalUri</code></a> extractor</td><td>Yes</td></tr>
+            <tr><td><code>tokio</code></td><td>Enables <code>tokio</code> as a dependency and <code>axum::serve</code>, <code>SSE</code> and <code>extract::connect_info</code> types.</td><td>Yes</td></tr>
+            <tr><td><code>tower-log</code></td><td>Enables <code>tower</code>’s <code>log</code> feature</td><td>Yes</td></tr>
+            <tr><td><code>tracing</code></td><td>Log rejections from built-in extractors</td><td>Yes</td></tr>
+            <tr><td><code>ws</code></td><td>Enables WebSockets support via <a href="extract/ws/index.html" title="mod axum::extract::ws"><code>extract::ws</code></a></td><td>No</td></tr>
+            <tr><td><code>form</code></td><td>Enables the <code>Form</code> extractor</td><td>Yes</td></tr>
+            <tr><td><code>query</code></td><td>Enables the <code>Query</code> extractor</td><td>Yes</td></tr>
+            </tbody></table>
+        "##};
+        let expected = indoc! {r#"
+            ## Feature flags
+
+            axum uses a set of feature flags to reduce the amount of compiled and optional dependencies.
+
+            The following optional features are available:
+
+            | Name | Description | Default? |
+            | --- | --- | --- |
+            | `http1` | Enables hyper’s `http1` feature | Yes |
+            | `http2` | Enables hyper’s `http2` feature | No |
+            | `json` | Enables the `Json` type and some similar convenience functionality | Yes |
+            | `macros` | Enables optional utility macros | No |
+            | `matched-path` | Enables capturing of every request’s router path and the `MatchedPath` extractor | Yes |
+            | `multipart` | Enables parsing `multipart/form-data` requests with `Multipart` | No |
+            | `original-uri` | Enables capturing of every request’s original URI and the `OriginalUri` extractor | Yes |
+            | `tokio` | Enables `tokio` as a dependency and `axum::serve`, `SSE` and `extract::connect_info` types. | Yes |
+            | `tower-log` | Enables `tower`’s `log` feature | Yes |
+            | `tracing` | Log rejections from built-in extractors | Yes |
+            | `ws` | Enables WebSockets support via `extract::ws` | No |
+            | `form` | Enables the `Form` extractor | Yes |
+            | `query` | Enables the `Query` extractor | Yes |
+        "#}
+        .trim();
+
+        assert_eq!(
+            convert_rustdoc_to_markdown(html.as_bytes()).unwrap(),
+            expected
+        )
+    }
+}
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -456,7 +456,7 @@ impl Item for ProjectSearchView {

    fn clone_on_split(
        &self,
-        _workspace_id: WorkspaceId,
+        _workspace_id: Option<WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Option<View<Self>>
    where
--- a/crates/semantic_index/src/project_index_debug_view.rs
+++ b/crates/semantic_index/src/project_index_debug_view.rs
@@ -283,7 +283,7 @@ impl Item for ProjectIndexDebugView {

    fn clone_on_split(
        &self,
-        _: workspace::WorkspaceId,
+        _: Option<workspace::WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Option<View<Self>>
    where
--- a/crates/storybook/src/assets.rs
+++ b/crates/storybook/src/assets.rs
@@ -15,10 +15,11 @@ use rust_embed::RustEmbed;
 pub struct Assets;

 impl AssetSource for Assets {
-    fn load(&self, path: &str) -> Result<Cow<'static, [u8]>> {
+    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
        Self::get(path)
            .map(|f| f.data)
            .ok_or_else(|| anyhow!("could not find asset at path \"{}\"", path))
+            .map(|data| Some(data))
    }

    fn list(&self, path: &str) -> Result<Vec<SharedString>> {
--- a/crates/storybook/src/storybook.rs
+++ b/crates/storybook/src/storybook.rs
@@ -128,7 +128,10 @@ fn load_embedded_fonts(cx: &AppContext) -> gpui::Result<()> {
    let mut embedded_fonts = Vec::new();
    for font_path in font_paths {
        if font_path.ends_with(".ttf") {
-            let font_bytes = cx.asset_source().load(&font_path)?;
+            let font_bytes = cx
+                .asset_source()
+                .load(&font_path)?
+                .expect("Should never be None in the storybook");
            embedded_fonts.push(font_bytes);
        }
    }
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -553,6 +553,7 @@ impl Element for TerminalElement {
        global_id: Option<&GlobalElementId>,
        cx: &mut WindowContext,
    ) -> (LayoutId, Self::RequestLayoutState) {
+        self.interactivity.occlude_mouse();
        let layout_id = self
            .interactivity
            .request_layout(global_id, cx, |mut style, cx| {
--- a/crates/terminal_view/src/terminal_panel.rs
+++ b/crates/terminal_view/src/terminal_panel.rs
@@ -221,7 +221,9 @@ impl TerminalPanel {

        let (panel, pane, items) = workspace.update(&mut cx, |workspace, cx| {
            let panel = cx.new_view(|cx| TerminalPanel::new(workspace, cx));
-            let items = if let Some(serialized_panel) = serialized_panel.as_ref() {
+            let items = if let Some((serialized_panel, database_id)) =
+                serialized_panel.as_ref().zip(workspace.database_id())
+            {
                panel.update(cx, |panel, cx| {
                    cx.notify();
                    panel.height = serialized_panel.height.map(|h| h.round());
@@ -234,7 +236,7 @@ impl TerminalPanel {
                                TerminalView::deserialize(
                                    workspace.project().clone(),
                                    workspace.weak_handle(),
-                                    workspace.database_id(),
+                                    database_id,
                                    *item_id,
                                    cx,
                                )
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -91,7 +91,7 @@ pub struct TerminalView {
    blinking_paused: bool,
    blink_epoch: usize,
    can_navigate_to_selected_word: bool,
-    workspace_id: WorkspaceId,
+    workspace_id: Option<WorkspaceId>,
    show_title: bool,
    _subscriptions: Vec<Subscription>,
    _terminal_subscriptions: Vec<Subscription>,
@@ -142,7 +142,7 @@ impl TerminalView {
    pub fn new(
        terminal: Model<Terminal>,
        workspace: WeakView<Workspace>,
-        workspace_id: WorkspaceId,
+        workspace_id: Option<WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let workspace_handle = workspace.clone();
@@ -458,15 +458,16 @@ fn subscribe_for_terminal_events(
                if terminal.task().is_none() {
                    if let Some(cwd) = terminal.get_cwd() {
                        let item_id = cx.entity_id();
-                        let workspace_id = this.workspace_id;
-                        cx.background_executor()
-                            .spawn(async move {
-                                TERMINAL_DB
-                                    .save_working_directory(item_id.as_u64(), workspace_id, cwd)
-                                    .await
-                                    .log_err();
-                            })
-                            .detach();
+                        if let Some(workspace_id) = this.workspace_id {
+                            cx.background_executor()
+                                .spawn(async move {
+                                    TERMINAL_DB
+                                        .save_working_directory(item_id.as_u64(), workspace_id, cwd)
+                                        .await
+                                        .log_err();
+                                })
+                                .detach();
+                        }
                    }
                }
            }
@@ -853,7 +854,7 @@ impl Item for TerminalView {

    fn clone_on_split(
        &self,
-        _workspace_id: WorkspaceId,
+        _workspace_id: Option<WorkspaceId>,
        _cx: &mut ViewContext<Self>,
    ) -> Option<View<Self>> {
        //From what I can tell, there's no  way to tell the current working
@@ -941,20 +942,18 @@ impl Item for TerminalView {
                project.create_terminal(cwd, None, window, cx)
            })??;
            pane.update(&mut cx, |_, cx| {
-                cx.new_view(|cx| TerminalView::new(terminal, workspace, workspace_id, cx))
+                cx.new_view(|cx| TerminalView::new(terminal, workspace, Some(workspace_id), cx))
            })
        })
    }

    fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
        if self.terminal().read(cx).task().is_none() {
-            cx.background_executor()
-                .spawn(TERMINAL_DB.update_workspace_id(
-                    workspace.database_id(),
-                    self.workspace_id,
-                    cx.entity_id().as_u64(),
-                ))
-                .detach();
+            if let Some((new_id, old_id)) = workspace.database_id().zip(self.workspace_id) {
+                cx.background_executor()
+                    .spawn(TERMINAL_DB.update_workspace_id(new_id, old_id, cx.entity_id().as_u64()))
+                    .detach();
+            }
            self.workspace_id = workspace.database_id();
        }
    }
--- a/crates/theme/src/registry.rs
+++ b/crates/theme/src/registry.rs
@@ -1,5 +1,5 @@
-use std::path::Path;
 use std::sync::Arc;
+use std::{fmt::Debug, path::Path};

 use anyhow::{anyhow, Context, Result};
 use collections::HashMap;
@@ -226,7 +226,7 @@ impl ThemeRegistry {
            .filter(|path| path.ends_with(".json"));

        for path in theme_paths {
-            let Some(theme) = self.assets.load(&path).log_err() else {
+            let Some(theme) = self.assets.load(&path).log_err().flatten() else {
                continue;
            };

--- a/crates/theme_importer/src/assets.rs
+++ b/crates/theme_importer/src/assets.rs
@@ -11,10 +11,11 @@ use rust_embed::RustEmbed;
 pub struct Assets;

 impl AssetSource for Assets {
-    fn load(&self, path: &str) -> Result<Cow<'static, [u8]>> {
+    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
        Self::get(path)
            .map(|f| f.data)
            .ok_or_else(|| anyhow!("could not find asset at path \"{}\"", path))
+            .map(|result| Some(result))
    }

    fn list(&self, path: &str) -> Result<Vec<SharedString>> {
--- a/crates/ui/src/components/context_menu.rs
+++ b/crates/ui/src/components/context_menu.rs
@@ -357,7 +357,7 @@ impl Render for ContextMenu {
                                                        .unwrap_or_else(|| {
                                                            KeyBinding::for_action(&**action, cx)
                                                        })
-                                                        .map(|binding| div().ml_1().child(binding))
+                                                        .map(|binding| div().ml_4().child(binding))
                                                })),
                                        )
                                        .on_click(move |_, cx| {
--- a/crates/ui/src/components/keybinding.rs
+++ b/crates/ui/src/components/keybinding.rs
@@ -77,13 +77,14 @@ impl RenderOnce for KeyBinding {
                        .join(" ")
                )
            })
+            .gap(rems(0.125))
            .flex_none()
            .children(self.key_binding.keystrokes().iter().map(|keystroke| {
                let key_icon = Self::icon_for_key(keystroke);

                h_flex()
                    .flex_none()
-                    .p_0p5()
+                    .py_0p5()
                    .rounded_sm()
                    .text_color(cx.theme().colors().text_muted)
                    .when(keystroke.modifiers.function, |el| {
--- a/crates/ui/src/components/popover_menu.rs
+++ b/crates/ui/src/components/popover_menu.rs
@@ -13,6 +13,51 @@ pub trait PopoverTrigger: IntoElement + Clickable + Selectable + 'static {}

 impl<T: IntoElement + Clickable + Selectable + 'static> PopoverTrigger for T {}

+pub struct PopoverMenuHandle<M>(Rc<RefCell<Option<PopoverMenuHandleState<M>>>>);
+
+impl<M> Clone for PopoverMenuHandle<M> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<M> Default for PopoverMenuHandle<M> {
+    fn default() -> Self {
+        Self(Rc::default())
+    }
+}
+
+struct PopoverMenuHandleState<M> {
+    menu_builder: Rc<dyn Fn(&mut WindowContext) -> Option<View<M>>>,
+    menu: Rc<RefCell<Option<View<M>>>>,
+}
+
+impl<M: ManagedView> PopoverMenuHandle<M> {
+    pub fn show(&self, cx: &mut WindowContext) {
+        if let Some(state) = self.0.borrow().as_ref() {
+            show_menu(&state.menu_builder, &state.menu, cx);
+        }
+    }
+
+    pub fn hide(&self, cx: &mut WindowContext) {
+        if let Some(state) = self.0.borrow().as_ref() {
+            if let Some(menu) = state.menu.borrow().as_ref() {
+                menu.update(cx, |_, cx| cx.emit(DismissEvent));
+            }
+        }
+    }
+
+    pub fn toggle(&self, cx: &mut WindowContext) {
+        if let Some(state) = self.0.borrow().as_ref() {
+            if state.menu.borrow().is_some() {
+                self.hide(cx);
+            } else {
+                self.show(cx);
+            }
+        }
+    }
+}
+
 pub struct PopoverMenu<M: ManagedView> {
    id: ElementId,
    child_builder: Option<
@@ -28,6 +73,7 @@ pub struct PopoverMenu<M: ManagedView> {
    anchor: AnchorCorner,
    attach: Option<AnchorCorner>,
    offset: Option<Point<Pixels>>,
+    trigger_handle: Option<PopoverMenuHandle<M>>,
 }

 impl<M: ManagedView> PopoverMenu<M> {
@@ -36,35 +82,17 @@ impl<M: ManagedView> PopoverMenu<M> {
        self
    }

+    pub fn with_handle(mut self, handle: PopoverMenuHandle<M>) -> Self {
+        self.trigger_handle = Some(handle);
+        self
+    }
+
    pub fn trigger<T: PopoverTrigger>(mut self, t: T) -> Self {
        self.child_builder = Some(Box::new(|menu, builder| {
            let open = menu.borrow().is_some();
            t.selected(open)
                .when_some(builder, |el, builder| {
-                    el.on_click({
-                        move |_, cx| {
-                            let Some(new_menu) = (builder)(cx) else {
-                                return;
-                            };
-                            let menu2 = menu.clone();
-                            let previous_focus_handle = cx.focused();
-
-                            cx.subscribe(&new_menu, move |modal, _: &DismissEvent, cx| {
-                                if modal.focus_handle(cx).contains_focused(cx) {
-                                    if let Some(previous_focus_handle) =
-                                        previous_focus_handle.as_ref()
-                                    {
-                                        cx.focus(previous_focus_handle);
-                                    }
-                                }
-                                *menu2.borrow_mut() = None;
-                                cx.refresh();
-                            })
-                            .detach();
-                            cx.focus_view(&new_menu);
-                            *menu.borrow_mut() = Some(new_menu);
-                        }
-                    })
+                    el.on_click(move |_, cx| show_menu(&builder, &menu, cx))
                })
                .into_any_element()
        }));
@@ -111,6 +139,32 @@ impl<M: ManagedView> PopoverMenu<M> {
    }
 }

+fn show_menu<M: ManagedView>(
+    builder: &Rc<dyn Fn(&mut WindowContext) -> Option<View<M>>>,
+    menu: &Rc<RefCell<Option<View<M>>>>,
+    cx: &mut WindowContext,
+) {
+    let Some(new_menu) = (builder)(cx) else {
+        return;
+    };
+    let menu2 = menu.clone();
+    let previous_focus_handle = cx.focused();
+
+    cx.subscribe(&new_menu, move |modal, _: &DismissEvent, cx| {
+        if modal.focus_handle(cx).contains_focused(cx) {
+            if let Some(previous_focus_handle) = previous_focus_handle.as_ref() {
+                cx.focus(previous_focus_handle);
+            }
+        }
+        *menu2.borrow_mut() = None;
+        cx.refresh();
+    })
+    .detach();
+    cx.focus_view(&new_menu);
+    *menu.borrow_mut() = Some(new_menu);
+    cx.refresh();
+}
+
 /// Creates a [`PopoverMenu`]
 pub fn popover_menu<M: ManagedView>(id: impl Into<ElementId>) -> PopoverMenu<M> {
    PopoverMenu {
@@ -120,6 +174,7 @@ pub fn popover_menu<M: ManagedView>(id: impl Into<ElementId>) -> PopoverMenu<M>
        anchor: AnchorCorner::TopLeft,
        attach: None,
        offset: None,
+        trigger_handle: None,
    }
 }

@@ -190,6 +245,15 @@ impl<M: ManagedView> Element for PopoverMenu<M> {
                    (child_builder)(element_state.menu.clone(), self.menu_builder.clone())
                });

+                if let Some(trigger_handle) = self.trigger_handle.take() {
+                    if let Some(menu_builder) = self.menu_builder.clone() {
+                        *trigger_handle.0.borrow_mut() = Some(PopoverMenuHandleState {
+                            menu_builder,
+                            menu: element_state.menu.clone(),
+                        });
+                    }
+                }
+
                let child_layout_id = child_element
                    .as_mut()
                    .map(|child_element| child_element.request_layout(cx));
--- a/crates/vcs_menu/src/lib.rs
+++ b/crates/vcs_menu/src/lib.rs
@@ -109,7 +109,7 @@ impl BranchListDelegate {
            .get_first_worktree_root_repo(cx)
            .context("failed to get root repository for first worktree")?;

-        let all_branches = repo.lock().branches()?;
+        let all_branches = repo.branches()?;
        Ok(Self {
            matches: vec![],
            workspace: handle,
@@ -237,7 +237,6 @@ impl PickerDelegate for BranchListDelegate {
                        .get_first_worktree_root_repo(cx)
                        .context("failed to get root repository for first worktree")?;
                    let status = repo
-                        .lock()
                        .change_branch(&current_pick);
                    if status.is_err() {
                        this.delegate.display_error_toast(format!("Failed to checkout branch '{current_pick}', check for conflicts or unstashed files"), cx);
@@ -316,8 +315,6 @@ impl PickerDelegate for BranchListDelegate {
                                            let repo = project
                                                .get_first_worktree_root_repo(cx)
                                                .context("failed to get root repository for first worktree")?;
-                                            let repo = repo
-                                                .lock();
                                            let status = repo
                                                .create_branch(&current_pick);
                                            if status.is_err() {
--- a/crates/welcome/src/welcome.rs
+++ b/crates/welcome/src/welcome.rs
@@ -313,7 +313,7 @@ impl Item for WelcomePage {

    fn clone_on_split(
        &self,
-        _workspace_id: WorkspaceId,
+        _workspace_id: Option<WorkspaceId>,
        cx: &mut ViewContext<Self>,
    ) -> Option<View<Self>> {
        Some(cx.new_view(|cx| WelcomePage {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Bennet Bo Fenner	dd36c1682f	Allow unsaved buffers to be formatted when using an external formatter	2024-06-03 10:44:29 +02:00
Bennet Bo Fenner	47b70bb112	Disable indent guides for single line editors by default.	2024-06-02 17:12:35 +02:00
Felipe Renan	2cff075c53	elixir: Fix `mix test $ZED_SYMBOL` task (#11879 ) $ZED_SYMBOL doesn't really work here once that will try to do something like this: mix test MyModule.MyModuleTest instead of using the path of the file: mix test test/my_module/my_module_test.exs Release Notes: - Fix mix test $ZED_SYMBOL to use ZED_RELATIVE_FILE instead - Use ZED_RELATIVE_FILE instead of ZED_FILE to improve mix tasks results on Elixir umbrella projects	2024-05-31 12:54:14 +02:00
Vladas Zakrevskis	819bb2663d	Fix recent project index order (#12507 ) Fixed bug introduced in: https://github.com/zed-industries/zed/pull/12502 Filtering before `enumerate` call breaks project order and instead of hiding current project it hides some other project. Release Notes: - N/A	2024-05-31 05:50:03 +03:00
moshyfawn	dc141d0f61	typescript: Fix shorthand property highlight (#12505 ) Release Notes: - Fixed Typescript shorthand property highlight ([#5239](https://github.com/zed-industries/zed/issues/5239)). Closes: #5239	2024-05-30 18:27:03 -04:00
Bennet Bo Fenner	22cf73acec	indent guides: Use primary buffer language to determine tab size (#12506 ) When indent guides were still WIP, I thought it might be a good idea to detect the tab size for every line individually, so we can handle files with mixed indentations. However, while optimizing the performance of indent guides I found that getting the language at a given anchor was pretty expensive, therefore I only resolved the language for the first visible row. However, this could lead to some weird flickering, where the indent guides would use different tab sizes depending on the first visible row (see #12492). This can be fixed by just using the primary buffer language size. So as of right now indent guides cannot handle files with mixed indentations. Im not sure if anyone actually does/expects this, but one use case I could imagine is something like this: User x has a svelte file, where the tab size is set to `4`. However the svelte code uses typescript inside a script tag, which User x wants to use a tab size of `2`. The approach used here would not work for this, but then again I think our formatter does not even support something like this. Im probably overcomplicating things, so let's stick with the simple solution for now. Release Notes: - Fixed an issue where indent guides would use an incorrect tab size ([#12492](https://github.com/zed-industries/zed/issues/12492)).	2024-05-30 22:55:47 +02:00
Marshall Bowers	1d46a52c62	rustdoc_to_markdown: Don't push blank space after newline (#12504 ) This PR fixes a small issue in `rustdoc_to_markdown` where we could push a blank space after a newline, leading to an unwanted leading space. Release Notes: - N/A	2024-05-30 16:38:01 -04:00
Max Brunsfeld	fda975fb76	Re-subscribe to channels after signing back out	2024-05-30 13:32:34 -07:00
Vladas Zakrevskis	0f32145ecb	Skip current project in recent projects (#12502 ) Discussion: https://github.com/zed-industries/zed/discussions/12497 Release Notes: - Removed current project from the recent projects modals	2024-05-30 23:30:34 +03:00
Marshall Bowers	6fe665ab94	rustdoc_to_markdown: Support bold and italics (#12501 ) This PR extends `rustdoc_to_markdown` with support for bold and italic text. Release Notes: - N/A	2024-05-30 16:06:21 -04:00
Max Brunsfeld	279c5ab81f	Reduce DB load upon initial connection due to channel loading (#12500 ) #### Lazily loading channels I've added a new RPC message called `SubscribeToChannels` that the client now sends when it first renders the channels panel. This causes the server to load the channels for that client and send updates to that client as channels are updated. Previously, the server did this upon connection. For backwards compatibility, the server will inspect clients' version, and continue to do this work immediately for old clients. #### Optimizations Running collab locally, I realized that upon connecting, we were running two concurrent transactions that both queried the `channel_members` table: one for loading your channels, and one for loading your channel invites. I've combined these into one query. In addition, we now use a join to load channels + members, as opposed to two separate queries. Even though `where id in` is efficient, it adds an extra round trip to the database, keeping the transaction open for slightly longer. Release Notes: - N/A	2024-05-30 13:02:55 -07:00
Marshall Bowers	99901801f4	rustdoc_to_markdown: Improve paragraph handling (#12498 ) This PR improves `rustdoc_to_markdown`'s paragraph handling to produce better output. Specifically, there should now be fewer instances where a space is missing between words as the result of line breaks in the source HTML. Release Notes: - N/A	2024-05-30 15:14:02 -04:00
Marshall Bowers	4dc98026c4	rustdoc_to_markdown: Add helper methods for checking HTML attributes (#12496 ) This PR adds some helper methods to `HtmlElement` to make it easier to interact with the element's attributes. This cleans up a bunch of the code by a fair amount. Release Notes: - N/A	2024-05-30 14:15:08 -04:00
Marshall Bowers	c83d1c23d7	rustdoc_to_markdown: Handle "stabs" in item name entries (#12494 ) This PR extends `rustdoc_to_markdown` with support for rustdoc's "stabs". These are used in item name lists to indicate that the construct is behind a feature flag: <img width="641" alt="Screenshot 2024-05-30 at 1 34 53 PM" src="https://github.com/zed-industries/zed/assets/1486634/0216f325-dc4e-4302-b6db-149ace31deea"> We now treat these specially in the Markdown output: <img width="813" alt="Screenshot 2024-05-30 at 1 35 27 PM" src="https://github.com/zed-industries/zed/assets/1486634/96396305-123d-40b2-af49-7eed71b62971"> Release Notes: - N/A	2024-05-30 13:46:14 -04:00
Marshall Bowers	39a2cdb13f	rustdoc_to_markdown: Strip "Copy item path to clipboard" button (#12490 ) This PR strips the "Copy item path to clipboard" button from the rustdoc output. Release Notes: - N/A	2024-05-30 12:55:37 -04:00
Max Brunsfeld	8f942bf647	Use repository mutex more sparingly. Don't hold it while running git status. (#12489 ) Previously, each git `Repository` object was held inside of a mutex. This was needed because libgit2's Repository object is (as one would expect) not thread safe. But now, the two longest-running git operations that Zed performs, (`status` and `blame`) do not use libgit2 - they invoke the `git` executable. For these operations, it's not necessary to hold a lock on the repository. In this PR, I've moved our mutex usage so that it only wraps the libgit2 calls, not our `git` subprocess spawns. The main user-facing impact of this is that the UI is much more responsive when initially opening a project with a very large git repository (e.g. `chromium`, `webkit`, `linux`). Release Notes: - Improved Zed's responsiveness when initially opening a project containing a very large git repository.	2024-05-30 09:37:11 -07:00
Bennet Bo Fenner	1ecd13ba50	Support copying permalink in multibuffer (#12435 ) Closes #11392 Release Notes: - Added support for copying permalinks inside multi-buffers ([#11392](https://github.com/zed-industries/zed/issues/11392))	2024-05-30 18:36:24 +02:00
Marshall Bowers	c118012223	rustdoc_to_markdown: Add table support (#12488 ) This PR extends `rustdoc_to_markdown` with support for tables: <img width="1007" alt="Screenshot 2024-05-30 at 12 05 35 PM" src="https://github.com/zed-industries/zed/assets/1486634/4e9a2a65-8aaa-4df1-98c4-4dd4e7874514"> Release Notes: - N/A	2024-05-30 12:17:10 -04:00
Marshall Bowers	7a30937e21	Sort `file_types.json` (#12487 ) This PR sorts the `file_types.json` file alphabetically. This is the command I used to sort it: ``` pnpm --package=json-sort-cli dlx jsonsort assets/icons/file_icons/file_types.json ``` Release Notes: - N/A	2024-05-30 11:26:52 -04:00
Kirill Bulatov	3c5d141a04	Force 60 minutes timeout for all regular CI jobs (#12486 ) After gazing at https://github.com/zed-industries/zed/actions/runs/9296132630/job/25596939148 for some time, I've decided to add a hard limit on every test-related CI job. Release Notes: - N/A	2024-05-30 18:17:03 +03:00
Marshall Bowers	bf7c6a676a	rustdoc_to_markdown: Recognize code blocks in other languages (#12484 ) This PR updates `rustdoc_to_markdown` to be able to recognize code blocks using non-Rust languages. Release Notes: - N/A	2024-05-30 10:50:27 -04:00
Antonio Scandurra	a259042f92	Make slash commands more discoverable (#12480 ) <img width="648" alt="image" src="https://github.com/zed-industries/zed/assets/482957/a63df904-fbbe-4e0a-80b2-c98ebee90690"> Release Notes: - N/A Co-authored-by: Nathan <nathan@zed.dev>	2024-05-30 16:45:05 +02:00
Sean Washington	436a8fa0ce	php: Update Pest tree-sitter queries to capture single quotes (#12467 ) Improved PHP Pest outline and runnables to support single quoted arguments ([#12461](https://github.com/zed-industries/zed/issues/12461)). Release Notes: - N/A \| Before \| After \| \|--------\|--------\| \| ![image](https://github.com/zed-industries/zed/assets/428033/e0966510-da11-4a80-8901-7dba541ab721) \| ![CleanShot 2024-05-29 at 20 13 00@2x](https://github.com/zed-industries/zed/assets/428033/5f7ab492-2791-4a04-9ec3-f0adfa9b2986) \| \| ![CleanShot 2024-05-29 at 20 18 11@2x](https://github.com/zed-industries/zed/assets/428033/ac6bf58b-4e7d-410d-af51-328c41a76ba0) \| ![CleanShot 2024-05-29 at 20 14 35@2x](https://github.com/zed-industries/zed/assets/428033/1d226bb8-f102-4171-906d-e122ab8299cf) \|	2024-05-30 16:37:41 +02:00
Antonio Scandurra	55c47305c8	Align the inline assistant correctly (#12478 ) Release Notes: - Fixed the the alignment for the inline assistant.	2024-05-30 14:29:17 +02:00
Antonio Scandurra	6ff01b17ca	Improve model selection in the assistant (#12472 ) https://github.com/zed-industries/zed/assets/482957/3b017850-b7b6-457a-9b2f-324d5533442e Release Notes: - Improved the UX for selecting a model in the assistant panel. You can now switch model using just the keyboard by pressing `alt-m`. Also, when switching models via the UI, settings will now be updated automatically.	2024-05-30 12:36:07 +02:00
Mikayla Maki	5a149b970c	Make tests less noisy (#12463 ) When running the tests for linux, I found a lot of benign errors getting logged. This PR cuts down some of the noise from unnecessary workspace serialization and SVG renders Release Notes: - N/A	2024-05-29 18:06:45 -07:00
Marshall Bowers	bdf627ce07	rustdoc_to_markdown: Fix code blocks (#12460 ) This PR fixes an issue in `rustdoc_to_markdown` with code blocks being trimmed incorrectly. We were erroneously popping from the current element stack even if we didn't push an element onto the stack. Added test coverage for this case as well, so we don't regress. Release Notes: - N/A	2024-05-29 19:23:06 -04:00
Marshall Bowers	a5011996fb	rustdoc_to_markdown: Recognize Rust code blocks (#12458 ) This PR makes it so Rust code blocks are recognized and syntax-highlighted when converting from rustdoc to Markdown. Release Notes: - N/A	2024-05-29 18:57:20 -04:00
Nathan Sobo	b8d9713b4f	Make prompt library icon in context panel staff-only for now (#12457 ) This is still pretty raw, so I'd like to hold off on shipping it to all users. Release Notes: - Hide the prompt library for non-staff until it is in a more complete state.	2024-05-29 16:53:45 -06:00
Marshall Bowers	abec028e58	rustdoc_to_markdown: Clean up heading spacing (#12456 ) This PR cleans up the spacing around the Markdown headings in the output so that they are consistent. Release Notes: - N/A	2024-05-29 18:39:51 -04:00
Marshall Bowers	08881828ce	assistant: Add `/rustdoc` slash command (#12453 ) This PR adds a `/rustdoc` slash command for retrieving and inserting rustdoc docs into the Assistant. Right now the command accepts the crate name as an argument and will return the top-level docs from `docs.rs`. Release Notes: - N/A	2024-05-29 18:14:29 -04:00
Max Brunsfeld	dd328efaa7	Compute git statuses using the bundled git executable, not libgit2 (#12444 ) I realized that somehow, the `git` executable is able to compute `git status` much more quickly than libgit2, so I've switched our git status logic to use `git`. Follow-up to https://github.com/zed-industries/zed/pull/12266. Release Notes: - Improved the performance of git status updated when working in large git repositories.	2024-05-29 14:31:24 -07:00
Joshua Ferguson	6294a3b80b	Add xdg trash support (#12391 ) - Added support for xdg trash when deleting files on linux - moved ashpd depency to toplevel to use it in both fs and gpui If I need to add test, or change anything, please let me know. I tested locally by creating and deleting a file and confirming it showed up in my trashcan, but that probably a less than ideal method of confirming correct behavior Also, I could remove the delete directory function for linux, and change the one configured for macos to compile for both macos and linux (they are the same, the version of the function they are calling is different). Release Notes: - N/A	2024-05-29 14:15:29 -07:00
Kirill Bulatov	0f927fa6fb	One less unwrap (#12448 ) Fixes https://zed-industries.slack.com/archives/C04S6T1T7TQ/p1717011343884699 Release Notes: - N/A	2024-05-29 23:44:56 +03:00
Marshall Bowers	5bcb9ed017	Add `rustdoc_to_markdown` crate (#12445 ) This PR adds a new crate for converting rustdoc output to Markdown. We're leveraging Servo's `html5ever` to parse the Markdown content, and then walking the DOM nodes to convert it to a Markdown string. The Markdown output will be continued to be refined, but it's in a place where it should be reasonable. Release Notes: - N/A	2024-05-29 16:05:16 -04:00
Bennet Bo Fenner	a22cd95f9d	Fix deleted hunk offset when zooming (#12442 ) Release Notes: - Fixed an issue where expanded hunks could be rendered at the wrong position when zooming - Fixed an issue where expanded hunks could be rendered at the wrong position when toggling git blame ([#11941](https://github.com/zed-industries/zed/issues/11941))	2024-05-29 20:06:10 +02:00
Dzmitry Malyshau	44c50da94f	blade: Use BufferBelt from blade-utils (#12411 ) Release Notes: - N/A Follow-up to #12340 Carries https://github.com/kvark/blade/pull/122 and https://github.com/kvark/blade/pull/119	2024-05-29 09:50:45 -07:00
Joseph T. Lyons	c34d36161d	v0.139.x dev	2024-05-29 12:15:12 -04:00