Update git_ui.rs

Update git_panel.rs
Revert "Merge branch 'main' into git-panel-commit-editor"
2024-12-16 15:30:27 -05:00 · 2024-12-16 15:30:25 -05:00 · 2024-12-16 15:29:44 -05:00 · 2024-12-16 15:26:45 -05:00 · 2024-12-16 15:12:49 -05:00 · 2024-12-16 16:42:09 -03:00
216 changed files with 15750 additions and 4318 deletions
--- a/.github/ISSUE_TEMPLATE/1_bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/1_bug_report.yml
@@ -26,8 +26,8 @@ body:
      required: true
  - type: textarea
    attributes:
-      label: If applicable, add mockups / screenshots to help explain present your vision of the feature
-      description: Drag issues into the text input below
+      label: If applicable, add screenshots or screencasts of the incorrect state / behavior
+      description: Drag images / videos into the text input below
    validations:
      required: false
  - type: textarea
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,3 +1,4 @@
+# yaml-language-server: $schema=https://json.schemastore.org/github-issue-config.json
 blank_issues_enabled: false
 contact_links:
  - name: Language Request
--- a/.github/workflows/community_update_all_top_ranking_issues.yml
+++ b/.github/workflows/community_update_all_top_ranking_issues.yml
@@ -8,7 +8,7 @@ on:
 jobs:
  update_top_ranking_issues:
    runs-on: ubuntu-latest
-    if: github.repository_owner == 'zed-industries'
+    if: github.repository == 'zed-industries/zed'
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
      - name: Set up uv
--- a/.github/workflows/community_update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/community_update_weekly_top_ranking_issues.yml
@@ -8,7 +8,7 @@ on:
 jobs:
  update_top_ranking_issues:
    runs-on: ubuntu-latest
-    if: github.repository_owner == 'zed-industries'
+    if: github.repository == 'zed-industries/zed'
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
      - name: Set up uv
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -140,7 +140,7 @@ jobs:
    name: Create a Linux *.tar.gz bundle for ARM
    if: github.repository_owner == 'zed-industries'
    runs-on:
-      - hosted-linux-arm-1
+      - buildjet-16vcpu-ubuntu-2204-arm
    needs: tests
    env:
      DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -142,6 +142,7 @@ members = [
    "crates/zed",
    "crates/zed_actions",
    "crates/zeta",
+    "crates/git_ui",

    #
    # Extensions
@@ -227,6 +228,7 @@ fs = { path = "crates/fs" }
 fsevent = { path = "crates/fsevent" }
 fuzzy = { path = "crates/fuzzy" }
 git = { path = "crates/git" }
+git_ui = { path = "crates/git_ui" }
 git_hosting_providers = { path = "crates/git_hosting_providers" }
 go_to_line = { path = "crates/go_to_line" }
 google_ai = { path = "crates/google_ai" }
--- a/assets/icons/file_diff.svg
+++ b/assets/icons/file_diff.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-file-diff"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M9 10h6"/><path d="M12 13V7"/><path d="M9 17h6"/></svg>
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -59,6 +59,11 @@
    "gitignore": "vcs",
    "gitkeep": "vcs",
    "gitmodules": "vcs",
+    "TAG_EDITMSG": "vcs",
+    "MERGE_MSG": "vcs",
+    "COMMIT_EDITMSG": "vcs",
+    "NOTES_EDITMSG": "vcs",
+    "EDIT_DESCRIPTION": "vcs",
    "gleam": "gleam",
    "go": "go",
    "gql": "graphql",
@@ -108,6 +113,7 @@
    "mdf": "storage",
    "mdx": "document",
    "metadata": "code",
+    "metal": "metal",
    "mjs": "javascript",
    "mka": "audio",
    "mkv": "video",
@@ -317,6 +323,9 @@
    "lua": {
      "icon": "icons/file_icons/lua.svg"
    },
+    "metal": {
+      "icon": "icons/file_icons/metal.svg"
+    },
    "nim": {
      "icon": "icons/file_icons/nim.svg"
    },
--- a/assets/icons/file_icons/metal.svg
+++ b/assets/icons/file_icons/metal.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" fill="none" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd" clip-rule="evenodd" d="M4.56 4.502 3.25 3.027V11.5h1.5V6.973l2.69 3.025 1.31 1.475V7.918l3.306 3.582h2.042L8.55 5.491 7.25 4.081V7.528L4.56 4.502Z" fill="#000"/></svg>
--- a/assets/icons/git_branch.svg
+++ b/assets/icons/git_branch.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-git-branch"><line x1="6" x2="6" y1="3" y2="15"/><circle cx="18" cy="6" r="3"/><circle cx="6" cy="18" r="3"/><path d="M18 9a9 9 0 0 1-9 9"/></svg>
--- a/assets/icons/panel_left.svg
+++ b/assets/icons/panel_left.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-panel-left"><rect width="18" height="18" x="3" y="3" rx="2"/><path d="M9 3v18"/></svg>
--- a/assets/icons/panel_right.svg
+++ b/assets/icons/panel_right.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-panel-right"><rect width="18" height="18" x="3" y="3" rx="2"/><path d="M15 3v18"/></svg>
--- a/assets/icons/square_dot.svg
+++ b/assets/icons/square_dot.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square-dot"><rect width="18" height="18" x="3" y="3" rx="2"/><circle cx="12" cy="12" r="1"/></svg>
--- a/assets/icons/square_minus.svg
+++ b/assets/icons/square_minus.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square-minus"><rect width="18" height="18" x="3" y="3" rx="2"/><path d="M8 12h8"/></svg>
--- a/assets/icons/square_plus.svg
+++ b/assets/icons/square_plus.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square-plus"><rect width="18" height="18" x="3" y="3" rx="2"/><path d="M8 12h8"/><path d="M12 8v8"/></svg>
--- a/assets/icons/thumbs_down.svg
+++ b/assets/icons/thumbs_down.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-thumbs-down"><path d="M17 14V2"/><path d="M9 18.12 10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88Z"/></svg>
--- a/assets/icons/thumbs_up.svg
+++ b/assets/icons/thumbs_up.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-thumbs-up"><path d="M7 10v12"/><path d="M15 5.88 14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88Z"/></svg>
--- a/assets/icons/zed_predict.svg
+++ b/assets/icons/zed_predict.svg
@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8 8.9V11C5.93097 11 5.06903 11 3 11V10.4L8 5.6V5H3V7.1" stroke="black" stroke-width="1.5"/>
+<path d="M11 5L13 8L11 11" stroke="black" stroke-width="1.5"/>
+</svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -468,13 +468,21 @@
  },
  {
    "context": "Editor && showing_completions",
+    "use_key_equivalents": true,
+    "bindings": {
+      "enter": "editor::ConfirmCompletion"
+    }
+  },
+  {
+    "context": "Editor && !inline_completion && showing_completions",
+    "use_key_equivalents": true,
    "bindings": {
-      "enter": "editor::ConfirmCompletion",
      "tab": "editor::ComposeCompletion"
    }
  },
  {
-    "context": "Editor && inline_completion && !showing_completions",
+    "context": "Editor && inline_completion",
+    "use_key_equivalents": true,
    "bindings": {
      "tab": "editor::AcceptInlineCompletion"
    }
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -66,6 +66,7 @@
      "cmd-v": "editor::Paste",
      "cmd-z": "editor::Undo",
      "cmd-shift-z": "editor::Redo",
+      "ctrl-shift-z": "zeta::RateCompletions",
      "up": "editor::MoveUp",
      "ctrl-up": "editor::MoveToStartOfParagraph",
      "pageup": "editor::MovePageUp",
@@ -540,12 +541,18 @@
    "context": "Editor && showing_completions",
    "use_key_equivalents": true,
    "bindings": {
-      "enter": "editor::ConfirmCompletion",
+      "enter": "editor::ConfirmCompletion"
+    }
+  },
+  {
+    "context": "Editor && !inline_completion && showing_completions",
+    "use_key_equivalents": true,
+    "bindings": {
      "tab": "editor::ComposeCompletion"
    }
  },
  {
-    "context": "Editor && inline_completion && !showing_completions",
+    "context": "Editor && inline_completion",
    "use_key_equivalents": true,
    "bindings": {
      "tab": "editor::AcceptInlineCompletion"
@@ -788,5 +795,24 @@
      "ctrl-k left": "pane::SplitLeft",
      "ctrl-k right": "pane::SplitRight"
    }
+  },
+  {
+    "context": "RateCompletionModal",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-enter": "zeta::ThumbsUp",
+      "shift-down": "zeta::NextEdit",
+      "shift-up": "zeta::PreviousEdit",
+      "right": "zeta::PreviewCompletion"
+    }
+  },
+  {
+    "context": "RateCompletionModal > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "zeta::FocusCompletions",
+      "cmd-shift-enter": "zeta::ThumbsUpActiveCompletion",
+      "cmd-shift-backspace": "zeta::ThumbsDownActiveCompletion"
+    }
  }
 ]
--- a/assets/keymaps/linux/emacs.json
+++ b/assets/keymaps/linux/emacs.json
@@ -15,8 +15,10 @@
      "ctrl-b": "editor::MoveLeft",
      "ctrl-n": "editor::MoveDown",
      "ctrl-p": "editor::MoveUp",
-      "ctrl-a": "editor::MoveToBeginningOfLine",
-      "ctrl-e": "editor::MoveToEndOfLine",
+      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
+      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
+      "ctrl-a": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
+      "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
      "alt-f": "editor::MoveToNextSubwordEnd",
      "alt-b": "editor::MoveToPreviousSubwordStart",
      "ctrl-d": "editor::Delete",
@@ -53,6 +55,14 @@
      "shift shift": "file_finder::Toggle"
    }
  },
+  {
+    "context": "BufferSearchBar > Editor",
+    "bindings": {
+      "ctrl-s": "search::SelectNextMatch",
+      "ctrl-r": "search::SelectPrevMatch",
+      "ctrl-g": "buffer_search::Dismiss"
+    }
+  },
  {
    "context": "Pane",
    "bindings": {
--- a/assets/keymaps/linux/jetbrains.json
+++ b/assets/keymaps/linux/jetbrains.json
@@ -12,7 +12,7 @@
      "ctrl->": "zed::IncreaseBufferFontSize",
      "ctrl-<": "zed::DecreaseBufferFontSize",
      "ctrl-shift-j": "editor::JoinLines",
-      "ctrl-d": "editor::DuplicateLineDown",
+      "ctrl-d": "editor::DuplicateSelection",
      "ctrl-y": "editor::DeleteLine",
      "ctrl-m": "editor::ScrollCursorCenter",
      "ctrl-pagedown": "editor::MovePageDown",
--- a/assets/keymaps/linux/sublime_text.json
+++ b/assets/keymaps/linux/sublime_text.json
@@ -15,7 +15,7 @@
      "ctrl-shift-m": "editor::SelectLargerSyntaxNode",
      "ctrl-shift-l": "editor::SplitSelectionIntoLines",
      "ctrl-shift-a": "editor::SelectLargerSyntaxNode",
-      "ctrl-shift-d": "editor::DuplicateLineDown",
+      "ctrl-shift-d": "editor::DuplicateSelection",
      "alt-f3": "editor::SelectAllMatches", // find_all_under
      "f12": "editor::GoToDefinition",
      "ctrl-f12": "editor::GoToDefinitionSplit",
--- a/assets/keymaps/macos/emacs.json
+++ b/assets/keymaps/macos/emacs.json
@@ -15,8 +15,10 @@
      "ctrl-b": "editor::MoveLeft",
      "ctrl-n": "editor::MoveDown",
      "ctrl-p": "editor::MoveUp",
-      "ctrl-a": "editor::MoveToBeginningOfLine",
-      "ctrl-e": "editor::MoveToEndOfLine",
+      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
+      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
+      "ctrl-a": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
+      "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
      "alt-f": "editor::MoveToNextSubwordEnd",
      "alt-b": "editor::MoveToPreviousSubwordStart",
      "ctrl-d": "editor::Delete",
@@ -53,6 +55,14 @@
      "shift shift": "file_finder::Toggle"
    }
  },
+  {
+    "context": "BufferSearchBar > Editor",
+    "bindings": {
+      "ctrl-s": "search::SelectNextMatch",
+      "ctrl-r": "search::SelectPrevMatch",
+      "ctrl-g": "buffer_search::Dismiss"
+    }
+  },
  {
    "context": "Pane",
    "bindings": {
--- a/assets/keymaps/macos/jetbrains.json
+++ b/assets/keymaps/macos/jetbrains.json
@@ -11,7 +11,7 @@
      "ctrl->": "zed::IncreaseBufferFontSize",
      "ctrl-<": "zed::DecreaseBufferFontSize",
      "ctrl-shift-j": "editor::JoinLines",
-      "cmd-d": "editor::DuplicateLineDown",
+      "cmd-d": "editor::DuplicateSelection",
      "cmd-backspace": "editor::DeleteLine",
      "cmd-pagedown": "editor::MovePageDown",
      "cmd-pageup": "editor::MovePageUp",
--- a/assets/keymaps/macos/sublime_text.json
+++ b/assets/keymaps/macos/sublime_text.json
@@ -18,7 +18,7 @@
      "ctrl-shift-m": "editor::SelectLargerSyntaxNode",
      "cmd-shift-l": "editor::SplitSelectionIntoLines",
      "cmd-shift-a": "editor::SelectLargerSyntaxNode",
-      "cmd-shift-d": "editor::DuplicateLineDown",
+      "cmd-shift-d": "editor::DuplicateSelection",
      "ctrl-cmd-g": "editor::SelectAllMatches", // find_all_under
      "shift-f12": "editor::FindAllReferences",
      "alt-cmd-down": "editor::GoToDefinition",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -144,6 +144,9 @@
  // 4. Highlight the full line (default):
  //    "all"
  "current_line_highlight": "all",
+  // The debounce delay before querying highlights from the language
+  // server based on the current cursor location.
+  "lsp_highlight_debounce": 75,
  // Whether to pop the completions menu while typing in an editor without
  // explicitly requesting it.
  "show_completions_on_input": true,
@@ -471,6 +474,14 @@
    // Default width of the chat panel.
    "default_width": 240
  },
+  "git_panel": {
+    // Whether to show the git panel button in the status bar.
+    "button": true,
+    // Where to the git panel. Can be 'left' or 'right'.
+    "dock": "left",
+    // Default width of the git panel.
+    "default_width": 360
+  },
  "message_editor": {
    // Whether to automatically replace emoji shortcodes with emoji characters.
    // For example: typing `:wave:` gets replaced with `👋`.
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -55,7 +55,7 @@ use language_model::{
    LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry, Role,
    ZED_CLOUD_PROVIDER_ID,
 };
-use language_model_selector::{LanguageModelPickerDelegate, LanguageModelSelector};
+use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use multi_buffer::MultiBufferRow;
 use picker::{Picker, PickerDelegate};
 use project::lsp_store::LocalLspAdapterDelegate;
@@ -143,7 +143,7 @@ pub struct AssistantPanel {
    languages: Arc<LanguageRegistry>,
    fs: Arc<dyn Fs>,
    subscriptions: Vec<Subscription>,
-    model_selector_menu_handle: PopoverMenuHandle<Picker<LanguageModelPickerDelegate>>,
+    model_selector_menu_handle: PopoverMenuHandle<LanguageModelSelector>,
    model_summary_editor: View<Editor>,
    authenticate_provider_task: Option<(LanguageModelProviderId, Task<()>)>,
    configuration_subscription: Option<Subscription>,
@@ -305,7 +305,7 @@ impl PickerDelegate for SavedContextPickerDelegate {
            ListItem::new(ix)
                .inset(true)
                .spacing(ListItemSpacing::Sparse)
-                .selected(selected)
+                .toggle_state(selected)
                .child(item),
        )
    }
@@ -341,11 +341,12 @@ impl AssistantPanel {
    ) -> Self {
        let model_selector_menu_handle = PopoverMenuHandle::default();
        let model_summary_editor = cx.new_view(Editor::single_line);
-        let context_editor_toolbar = cx.new_view(|_| {
+        let context_editor_toolbar = cx.new_view(|cx| {
            ContextEditorToolbarItem::new(
                workspace,
                model_selector_menu_handle.clone(),
                model_summary_editor.clone(),
+                cx,
            )
        });

@@ -441,7 +442,7 @@ impl AssistantPanel {
                            )
                        }
                    })
-                    .selected(
+                    .toggle_state(
                        pane.active_item()
                            .map_or(false, |item| item.downcast::<ContextHistory>().is_some()),
                    );
@@ -4455,23 +4456,36 @@ impl FollowableItem for ContextEditor {
 }

 pub struct ContextEditorToolbarItem {
-    fs: Arc<dyn Fs>,
    active_context_editor: Option<WeakView<ContextEditor>>,
    model_summary_editor: View<Editor>,
-    model_selector_menu_handle: PopoverMenuHandle<Picker<LanguageModelPickerDelegate>>,
+    language_model_selector: View<LanguageModelSelector>,
+    language_model_selector_menu_handle: PopoverMenuHandle<LanguageModelSelector>,
 }

 impl ContextEditorToolbarItem {
    pub fn new(
        workspace: &Workspace,
-        model_selector_menu_handle: PopoverMenuHandle<Picker<LanguageModelPickerDelegate>>,
+        model_selector_menu_handle: PopoverMenuHandle<LanguageModelSelector>,
        model_summary_editor: View<Editor>,
+        cx: &mut ViewContext<Self>,
    ) -> Self {
        Self {
-            fs: workspace.app_state().fs.clone(),
            active_context_editor: None,
            model_summary_editor,
-            model_selector_menu_handle,
+            language_model_selector: cx.new_view(|cx| {
+                let fs = workspace.app_state().fs.clone();
+                LanguageModelSelector::new(
+                    move |model, cx| {
+                        update_settings_file::<AssistantSettings>(
+                            fs.clone(),
+                            cx,
+                            move |settings, _| settings.set_model(model.clone()),
+                        );
+                    },
+                    cx,
+                )
+            }),
+            language_model_selector_menu_handle: model_selector_menu_handle,
        }
    }

@@ -4560,17 +4574,8 @@ impl Render for ContextEditorToolbarItem {
            //         .map(|remaining_items| format!("Files to scan: {}", remaining_items))
            // })
            .child(
-                LanguageModelSelector::new(
-                    {
-                        let fs = self.fs.clone();
-                        move |model, cx| {
-                            update_settings_file::<AssistantSettings>(
-                                fs.clone(),
-                                cx,
-                                move |settings, _| settings.set_model(model.clone()),
-                            );
-                        }
-                    },
+                LanguageModelSelectorPopoverMenu::new(
+                    self.language_model_selector.clone(),
                    ButtonLike::new("active-model")
                        .style(ButtonStyle::Subtle)
                        .child(
@@ -4616,7 +4621,7 @@ impl Render for ContextEditorToolbarItem {
                            Tooltip::for_action("Change Model", &ToggleModelSelector, cx)
                        }),
                )
-                .with_handle(self.model_selector_menu_handle.clone()),
+                .with_handle(self.language_model_selector_menu_handle.clone()),
            )
            .children(self.render_remaining_tokens(cx));

@@ -4951,7 +4956,7 @@ fn render_slash_command_output_toggle(
        ("slash-command-output-fold-indicator", row.0 as u64),
        !is_folded,
    )
-    .selected(is_folded)
+    .toggle_state(is_folded)
    .on_click(move |_e, cx| fold(!is_folded, cx))
    .into_any_element()
 }
@@ -4966,7 +4971,7 @@ fn fold_toggle(
 ) -> AnyElement {
    move |row, is_folded, fold, _cx| {
        Disclosure::new((name, row.0 as u64), !is_folded)
-            .selected(is_folded)
+            .toggle_state(is_folded)
            .on_click(move |_e, cx| fold(!is_folded, cx))
            .into_any_element()
    }
@@ -5008,7 +5013,7 @@ fn render_quote_selection_output_toggle(
    _cx: &mut WindowContext,
 ) -> AnyElement {
    Disclosure::new(("quote-selection-indicator", row.0 as u64), !is_folded)
-        .selected(is_folded)
+        .toggle_state(is_folded)
        .on_click(move |_e, cx| fold(!is_folded, cx))
        .into_any_element()
 }
@@ -5031,7 +5036,7 @@ fn render_pending_slash_command_gutter_decoration(
            icon = icon.icon_color(Color::Muted);
        }
        PendingSlashCommandStatus::Running { .. } => {
-            icon = icon.selected(true);
+            icon = icon.toggle_state(true);
        }
        PendingSlashCommandStatus::Error(_) => icon = icon.icon_color(Color::Error),
    }
@@ -5113,9 +5118,11 @@ fn make_lsp_adapter_delegate(
            return Ok(None::<Arc<dyn LspAdapterDelegate>>);
        };
        let http_client = project.client().http_client().clone();
-        project.lsp_store().update(cx, |lsp_store, cx| {
+        project.lsp_store().update(cx, |_, cx| {
            Ok(Some(LocalLspAdapterDelegate::new(
-                lsp_store,
+                project.languages().clone(),
+                project.environment(),
+                cx.weak_model(),
                &worktree,
                http_client,
                project.fs().clone(),
--- a/crates/assistant/src/context/context_tests.rs
+++ b/crates/assistant/src/context/context_tests.rs
@@ -17,7 +17,7 @@ use futures::{
    channel::mpsc,
    stream::{self, StreamExt},
 };
-use gpui::{AppContext, Model, SharedString, Task, TestAppContext, WeakView};
+use gpui::{prelude::*, AppContext, Model, SharedString, Task, TestAppContext, WeakView};
 use language::{Buffer, BufferSnapshot, LanguageRegistry, LspAdapterDelegate};
 use language_model::{LanguageModelCacheConfiguration, LanguageModelRegistry, Role};
 use parking_lot::Mutex;
@@ -35,7 +35,7 @@ use std::{
    sync::{atomic::AtomicBool, Arc},
 };
 use text::{network::Network, OffsetRangeExt as _, ReplicaId, ToOffset};
-use ui::{Context as _, IconName, WindowContext};
+use ui::{IconName, WindowContext};
 use unindent::Unindent;
 use util::{
    test::{generate_marked_text, marked_text_ranges},
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -33,7 +33,7 @@ use language_model::{
    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
    LanguageModelTextStream, Role,
 };
-use language_model_selector::LanguageModelSelector;
+use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use language_models::report_assistant_event;
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
@@ -1358,8 +1358,8 @@ enum PromptEditorEvent {

 struct PromptEditor {
    id: InlineAssistId,
-    fs: Arc<dyn Fs>,
    editor: View<Editor>,
+    language_model_selector: View<LanguageModelSelector>,
    edited_since_done: bool,
    gutter_dimensions: Arc<Mutex<GutterDimensions>>,
    prompt_history: VecDeque<String>,
@@ -1500,43 +1500,27 @@ impl Render for PromptEditor {
                    .w(gutter_dimensions.full_width() + (gutter_dimensions.margin / 2.0))
                    .justify_center()
                    .gap_2()
-                    .child(
-                        LanguageModelSelector::new(
-                            {
-                                let fs = self.fs.clone();
-                                move |model, cx| {
-                                    update_settings_file::<AssistantSettings>(
-                                        fs.clone(),
-                                        cx,
-                                        move |settings, _| settings.set_model(model.clone()),
-                                    );
-                                }
-                            },
-                            IconButton::new("context", IconName::SettingsAlt)
-                                .shape(IconButtonShape::Square)
-                                .icon_size(IconSize::Small)
-                                .icon_color(Color::Muted)
-                                .tooltip(move |cx| {
-                                    Tooltip::with_meta(
-                                        format!(
-                                            "Using {}",
-                                            LanguageModelRegistry::read_global(cx)
-                                                .active_model()
-                                                .map(|model| model.name().0)
-                                                .unwrap_or_else(|| "No model selected".into()),
-                                        ),
-                                        None,
-                                        "Change Model",
-                                        cx,
-                                    )
-                                }),
-                        )
-                        .info_text(
-                            "Inline edits use context\n\
-                            from the currently selected\n\
-                            assistant panel tab.",
-                        ),
-                    )
+                    .child(LanguageModelSelectorPopoverMenu::new(
+                        self.language_model_selector.clone(),
+                        IconButton::new("context", IconName::SettingsAlt)
+                            .shape(IconButtonShape::Square)
+                            .icon_size(IconSize::Small)
+                            .icon_color(Color::Muted)
+                            .tooltip(move |cx| {
+                                Tooltip::with_meta(
+                                    format!(
+                                        "Using {}",
+                                        LanguageModelRegistry::read_global(cx)
+                                            .active_model()
+                                            .map(|model| model.name().0)
+                                            .unwrap_or_else(|| "No model selected".into()),
+                                    ),
+                                    None,
+                                    "Change Model",
+                                    cx,
+                                )
+                            }),
+                    ))
                    .map(|el| {
                        let CodegenStatus::Error(error) = self.codegen.read(cx).status(cx) else {
                            return el;
@@ -1550,7 +1534,7 @@ impl Render for PromptEditor {
                                v_flex()
                                    .child(
                                        IconButton::new("rate-limit-error", IconName::XCircle)
-                                            .selected(self.show_rate_limit_notice)
+                                            .toggle_state(self.show_rate_limit_notice)
                                            .shape(IconButtonShape::Square)
                                            .icon_size(IconSize::Small)
                                            .on_click(cx.listener(Self::toggle_rate_limit_notice)),
@@ -1642,6 +1626,19 @@ impl PromptEditor {
        let mut this = Self {
            id,
            editor: prompt_editor,
+            language_model_selector: cx.new_view(|cx| {
+                let fs = fs.clone();
+                LanguageModelSelector::new(
+                    move |model, cx| {
+                        update_settings_file::<AssistantSettings>(
+                            fs.clone(),
+                            cx,
+                            move |settings, _| settings.set_model(model.clone()),
+                        );
+                    },
+                    cx,
+                )
+            }),
            edited_since_done: false,
            gutter_dimensions,
            prompt_history,
@@ -1650,7 +1647,6 @@ impl PromptEditor {
            _codegen_subscription: cx.observe(&codegen, Self::handle_codegen_changed),
            editor_subscriptions: Vec::new(),
            codegen,
-            fs,
            pending_token_count: Task::ready(Ok(())),
            token_counts: None,
            _token_count_subscriptions: token_count_subscriptions,
@@ -2137,15 +2133,15 @@ impl PromptEditor {
                            "dont-show-again",
                            Label::new("Don't show again"),
                            if dismissed_rate_limit_notice() {
-                                ui::Selection::Selected
+                                ui::ToggleState::Selected
                            } else {
-                                ui::Selection::Unselected
+                                ui::ToggleState::Unselected
                            },
                            |selection, cx| {
                                let is_dismissed = match selection {
-                                    ui::Selection::Unselected => false,
-                                    ui::Selection::Indeterminate => return,
-                                    ui::Selection::Selected => true,
+                                    ui::ToggleState::Unselected => false,
+                                    ui::ToggleState::Indeterminate => return,
+                                    ui::ToggleState::Selected => true,
                                };

                                set_rate_limit_notice_dismissed(is_dismissed, cx)
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -11,8 +11,8 @@ use futures::{
 use fuzzy::StringMatchCandidate;
 use gpui::{
    actions, point, size, transparent_black, Action, AppContext, BackgroundExecutor, Bounds,
-    EventEmitter, Global, HighlightStyle, PromptLevel, ReadGlobal, Subscription, Task, TextStyle,
-    TitlebarOptions, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
+    EventEmitter, Global, PromptLevel, ReadGlobal, Subscription, Task, TextStyle, TitlebarOptions,
+    UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
 };
 use heed::{
    types::{SerdeBincode, SerdeJson, Str},
@@ -232,13 +232,13 @@ impl PickerDelegate for PromptPickerDelegate {
        let element = ListItem::new(ix)
            .inset(true)
            .spacing(ListItemSpacing::Sparse)
-            .selected(selected)
+            .toggle_state(selected)
            .child(h_flex().h_5().line_height(relative(1.)).child(Label::new(
                prompt.title.clone().unwrap_or("Untitled".into()),
            )))
            .end_slot::<IconButton>(default.then(|| {
                IconButton::new("toggle-default-prompt", IconName::SparkleFilled)
-                    .selected(true)
+                    .toggle_state(true)
                    .icon_color(Color::Accent)
                    .shape(IconButtonShape::Square)
                    .tooltip(move |cx| Tooltip::text("Remove from Default Prompt", cx))
@@ -274,7 +274,7 @@ impl PickerDelegate for PromptPickerDelegate {
                    })
                    .child(
                        IconButton::new("toggle-default-prompt", IconName::Sparkle)
-                            .selected(default)
+                            .toggle_state(default)
                            .selected_icon(IconName::SparkleFilled)
                            .icon_color(if default { Color::Accent } else { Color::Muted })
                            .shape(IconButtonShape::Square)
@@ -928,10 +928,8 @@ impl PromptLibrary {
                                                    status: cx.theme().status().clone(),
                                                    inlay_hints_style:
                                                        editor::make_inlay_hints_style(cx),
-                                                    suggestions_style: HighlightStyle {
-                                                        color: Some(cx.theme().status().predictive),
-                                                        ..HighlightStyle::default()
-                                                    },
+                                                    inline_completion_styles:
+                                                        editor::make_suggestion_styles(cx),
                                                    ..EditorStyle::default()
                                                },
                                            )),
@@ -1055,7 +1053,7 @@ impl PromptLibrary {
                                                        IconName::Sparkle,
                                                    )
                                                    .style(ButtonStyle::Transparent)
-                                                    .selected(prompt_metadata.default)
+                                                    .toggle_state(prompt_metadata.default)
                                                    .selected_icon(IconName::SparkleFilled)
                                                    .icon_color(if prompt_metadata.default {
                                                        Color::Accent
--- a/crates/assistant/src/slash_command_picker.rs
+++ b/crates/assistant/src/slash_command_picker.rs
@@ -176,7 +176,7 @@ impl PickerDelegate for SlashCommandDelegate {
                ListItem::new(ix)
                    .inset(true)
                    .spacing(ListItemSpacing::Dense)
-                    .selected(selected)
+                    .toggle_state(selected)
                    .tooltip({
                        let description = info.description.clone();
                        move |cx| cx.new_view(|_| Tooltip::new(description.clone())).into()
@@ -229,7 +229,7 @@ impl PickerDelegate for SlashCommandDelegate {
                ListItem::new(ix)
                    .inset(true)
                    .spacing(ListItemSpacing::Dense)
-                    .selected(selected)
+                    .toggle_state(selected)
                    .child(renderer(cx)),
            ),
        }
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -20,7 +20,7 @@ use language::Buffer;
 use language_model::{
    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
-use language_model_selector::LanguageModelSelector;
+use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use language_models::report_assistant_event;
 use settings::{update_settings_file, Settings};
 use std::{
@@ -476,9 +476,9 @@ enum PromptEditorEvent {

 struct PromptEditor {
    id: TerminalInlineAssistId,
-    fs: Arc<dyn Fs>,
    height_in_lines: u8,
    editor: View<Editor>,
+    language_model_selector: View<LanguageModelSelector>,
    edited_since_done: bool,
    prompt_history: VecDeque<String>,
    prompt_history_ix: Option<usize>,
@@ -614,17 +614,8 @@ impl Render for PromptEditor {
                    .w_12()
                    .justify_center()
                    .gap_2()
-                    .child(LanguageModelSelector::new(
-                        {
-                            let fs = self.fs.clone();
-                            move |model, cx| {
-                                update_settings_file::<AssistantSettings>(
-                                    fs.clone(),
-                                    cx,
-                                    move |settings, _| settings.set_model(model.clone()),
-                                );
-                            }
-                        },
+                    .child(LanguageModelSelectorPopoverMenu::new(
+                        self.language_model_selector.clone(),
                        IconButton::new("context", IconName::SettingsAlt)
                            .shape(IconButtonShape::Square)
                            .icon_size(IconSize::Small)
@@ -718,6 +709,19 @@ impl PromptEditor {
            id,
            height_in_lines: 1,
            editor: prompt_editor,
+            language_model_selector: cx.new_view(|cx| {
+                let fs = fs.clone();
+                LanguageModelSelector::new(
+                    move |model, cx| {
+                        update_settings_file::<AssistantSettings>(
+                            fs.clone(),
+                            cx,
+                            move |settings, _| settings.set_model(model.clone()),
+                        );
+                    },
+                    cx,
+                )
+            }),
            edited_since_done: false,
            prompt_history,
            prompt_history_ix: None,
@@ -725,7 +729,6 @@ impl PromptEditor {
            _codegen_subscription: cx.observe(&codegen, Self::handle_codegen_changed),
            editor_subscriptions: Vec::new(),
            codegen,
-            fs,
            pending_token_count: Task::ready(Ok(())),
            token_count: None,
            _token_count_subscriptions: token_count_subscriptions,
--- a/crates/assistant2/Cargo.toml
+++ b/crates/assistant2/Cargo.toml
@@ -13,30 +13,55 @@ path = "src/assistant.rs"
 doctest = false

 [dependencies]
+anthropic = { workspace = true, features = ["schemars"] }
 anyhow.workspace = true
+assets.workspace = true
 assistant_tool.workspace = true
-chrono.workspace = true
+async-watch.workspace = true
 client.workspace = true
+chrono.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 context_server.workspace = true
+db.workspace = true
 editor.workspace = true
 feature_flags.workspace = true
+fs.workspace = true
 futures.workspace = true
+fuzzy.workspace = true
 gpui.workspace = true
+handlebars.workspace = true
+html_to_markdown.workspace = true
+http_client.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_model_selector.workspace = true
 language_models.workspace = true
 log.workspace = true
+lsp.workspace = true
 markdown.workspace = true
+menu.workspace = true
+multi_buffer.workspace = true
+ollama = { workspace = true, features = ["schemars"] }
+open_ai = { workspace = true, features = ["schemars"] }
+ordered-float.workspace = true
+paths.workspace = true
+parking_lot.workspace = true
 picker.workspace = true
 project.workspace = true
 proto.workspace = true
+rope.workspace = true
+schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+serde_json_lenient.workspace = true
 settings.workspace = true
+similar.workspace = true
 smol.workspace = true
+telemetry_events.workspace = true
+terminal_view.workspace = true
+text.workspace = true
+terminal.workspace = true
 theme.workspace = true
 time.workspace = true
 time_format.workspace = true
@@ -45,3 +70,8 @@ unindent.workspace = true
 util.workspace = true
 uuid.workspace = true
 workspace.workspace = true
+zed_actions.workspace = true
+
+[dev-dependencies]
+rand.workspace = true
+indoc.workspace = true
--- a/crates/assistant2/src/assistant.rs
+++ b/crates/assistant2/src/assistant.rs
@@ -1,16 +1,29 @@
 mod active_thread;
 mod assistant_panel;
+mod assistant_settings;
 mod context;
 mod context_picker;
+mod inline_assistant;
 mod message_editor;
+mod prompts;
+mod streaming_diff;
+mod terminal_inline_assistant;
 mod thread;
 mod thread_history;
 mod thread_store;
 mod ui;

+use std::sync::Arc;
+
+use assistant_settings::AssistantSettings;
+use client::Client;
 use command_palette_hooks::CommandPaletteFilter;
 use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt};
+use fs::Fs;
 use gpui::{actions, AppContext};
+use prompts::PromptLoadingParams;
+use settings::Settings as _;
+use util::ResultExt;

 pub use crate::assistant_panel::AssistantPanel;

@@ -21,15 +34,43 @@ actions!(
        NewThread,
        ToggleModelSelector,
        OpenHistory,
-        Chat
+        Chat,
+        ToggleInlineAssist,
+        CycleNextInlineAssist,
+        CyclePreviousInlineAssist
    ]
 );

 const NAMESPACE: &str = "assistant2";

 /// Initializes the `assistant2` crate.
-pub fn init(cx: &mut AppContext) {
+pub fn init(fs: Arc<dyn Fs>, client: Arc<Client>, stdout_is_a_pty: bool, cx: &mut AppContext) {
+    AssistantSettings::register(cx);
    assistant_panel::init(cx);
+
+    let prompt_builder = prompts::PromptBuilder::new(Some(PromptLoadingParams {
+        fs: fs.clone(),
+        repo_path: stdout_is_a_pty
+            .then(|| std::env::current_dir().log_err())
+            .flatten(),
+        cx,
+    }))
+    .log_err()
+    .map(Arc::new)
+    .unwrap_or_else(|| Arc::new(prompts::PromptBuilder::new(None).unwrap()));
+    inline_assistant::init(
+        fs.clone(),
+        prompt_builder.clone(),
+        client.telemetry().clone(),
+        cx,
+    );
+    terminal_inline_assistant::init(
+        fs.clone(),
+        prompt_builder.clone(),
+        client.telemetry().clone(),
+        cx,
+    );
+
    feature_gate_assistant2_actions(cx);
 }

--- a/crates/assistant2/src/assistant_panel.rs
+++ b/crates/assistant2/src/assistant_panel.rs
@@ -88,13 +88,13 @@ impl AssistantPanel {
            thread: cx.new_view(|cx| {
                ActiveThread::new(
                    thread.clone(),
-                    workspace,
+                    workspace.clone(),
                    language_registry,
                    tools.clone(),
                    cx,
                )
            }),
-            message_editor: cx.new_view(|cx| MessageEditor::new(thread.clone(), cx)),
+            message_editor: cx.new_view(|cx| MessageEditor::new(workspace, thread.clone(), cx)),
            tools,
            local_timezone: UtcOffset::from_whole_seconds(
                chrono::Local::now().offset().local_minus_utc(),
@@ -123,7 +123,8 @@ impl AssistantPanel {
                cx,
            )
        });
-        self.message_editor = cx.new_view(|cx| MessageEditor::new(thread, cx));
+        self.message_editor =
+            cx.new_view(|cx| MessageEditor::new(self.workspace.clone(), thread, cx));
        self.message_editor.focus_handle(cx).focus(cx);
    }

@@ -145,7 +146,8 @@ impl AssistantPanel {
                cx,
            )
        });
-        self.message_editor = cx.new_view(|cx| MessageEditor::new(thread, cx));
+        self.message_editor =
+            cx.new_view(|cx| MessageEditor::new(self.workspace.clone(), thread, cx));
        self.message_editor.focus_handle(cx).focus(cx);
    }

--- a/crates/assistant2/src/assistant_settings.rs
+++ b/crates/assistant2/src/assistant_settings.rs
@@ -0,0 +1,485 @@
+use std::sync::Arc;
+
+use ::open_ai::Model as OpenAiModel;
+use anthropic::Model as AnthropicModel;
+use gpui::Pixels;
+use language_model::{CloudModel, LanguageModel};
+use ollama::Model as OllamaModel;
+use schemars::{schema::Schema, JsonSchema};
+use serde::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources};
+
+#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum AssistantDockPosition {
+    Left,
+    #[default]
+    Right,
+    Bottom,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[serde(tag = "name", rename_all = "snake_case")]
+pub enum AssistantProviderContentV1 {
+    #[serde(rename = "zed.dev")]
+    ZedDotDev { default_model: Option<CloudModel> },
+    #[serde(rename = "openai")]
+    OpenAi {
+        default_model: Option<OpenAiModel>,
+        api_url: Option<String>,
+        available_models: Option<Vec<OpenAiModel>>,
+    },
+    #[serde(rename = "anthropic")]
+    Anthropic {
+        default_model: Option<AnthropicModel>,
+        api_url: Option<String>,
+    },
+    #[serde(rename = "ollama")]
+    Ollama {
+        default_model: Option<OllamaModel>,
+        api_url: Option<String>,
+    },
+}
+
+#[derive(Debug, Default)]
+pub struct AssistantSettings {
+    pub enabled: bool,
+    pub button: bool,
+    pub dock: AssistantDockPosition,
+    pub default_width: Pixels,
+    pub default_height: Pixels,
+    pub default_model: LanguageModelSelection,
+    pub inline_alternatives: Vec<LanguageModelSelection>,
+    pub using_outdated_settings_version: bool,
+    pub enable_experimental_live_diffs: bool,
+}
+
+/// Assistant panel settings
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(untagged)]
+pub enum AssistantSettingsContent {
+    Versioned(VersionedAssistantSettingsContent),
+    Legacy(LegacyAssistantSettingsContent),
+}
+
+impl JsonSchema for AssistantSettingsContent {
+    fn schema_name() -> String {
+        VersionedAssistantSettingsContent::schema_name()
+    }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> Schema {
+        VersionedAssistantSettingsContent::json_schema(gen)
+    }
+
+    fn is_referenceable() -> bool {
+        VersionedAssistantSettingsContent::is_referenceable()
+    }
+}
+
+impl Default for AssistantSettingsContent {
+    fn default() -> Self {
+        Self::Versioned(VersionedAssistantSettingsContent::default())
+    }
+}
+
+impl AssistantSettingsContent {
+    pub fn is_version_outdated(&self) -> bool {
+        match self {
+            AssistantSettingsContent::Versioned(settings) => match settings {
+                VersionedAssistantSettingsContent::V1(_) => true,
+                VersionedAssistantSettingsContent::V2(_) => false,
+            },
+            AssistantSettingsContent::Legacy(_) => true,
+        }
+    }
+
+    fn upgrade(&self) -> AssistantSettingsContentV2 {
+        match self {
+            AssistantSettingsContent::Versioned(settings) => match settings {
+                VersionedAssistantSettingsContent::V1(settings) => AssistantSettingsContentV2 {
+                    enabled: settings.enabled,
+                    button: settings.button,
+                    dock: settings.dock,
+                    default_width: settings.default_width,
+                    default_height: settings.default_width,
+                    default_model: settings
+                        .provider
+                        .clone()
+                        .and_then(|provider| match provider {
+                            AssistantProviderContentV1::ZedDotDev { default_model } => {
+                                default_model.map(|model| LanguageModelSelection {
+                                    provider: "zed.dev".to_string(),
+                                    model: model.id().to_string(),
+                                })
+                            }
+                            AssistantProviderContentV1::OpenAi { default_model, .. } => {
+                                default_model.map(|model| LanguageModelSelection {
+                                    provider: "openai".to_string(),
+                                    model: model.id().to_string(),
+                                })
+                            }
+                            AssistantProviderContentV1::Anthropic { default_model, .. } => {
+                                default_model.map(|model| LanguageModelSelection {
+                                    provider: "anthropic".to_string(),
+                                    model: model.id().to_string(),
+                                })
+                            }
+                            AssistantProviderContentV1::Ollama { default_model, .. } => {
+                                default_model.map(|model| LanguageModelSelection {
+                                    provider: "ollama".to_string(),
+                                    model: model.id().to_string(),
+                                })
+                            }
+                        }),
+                    inline_alternatives: None,
+                    enable_experimental_live_diffs: None,
+                },
+                VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
+            },
+            AssistantSettingsContent::Legacy(settings) => AssistantSettingsContentV2 {
+                enabled: None,
+                button: settings.button,
+                dock: settings.dock,
+                default_width: settings.default_width,
+                default_height: settings.default_height,
+                default_model: Some(LanguageModelSelection {
+                    provider: "openai".to_string(),
+                    model: settings
+                        .default_open_ai_model
+                        .clone()
+                        .unwrap_or_default()
+                        .id()
+                        .to_string(),
+                }),
+                inline_alternatives: None,
+                enable_experimental_live_diffs: None,
+            },
+        }
+    }
+
+    pub fn set_model(&mut self, language_model: Arc<dyn LanguageModel>) {
+        let model = language_model.id().0.to_string();
+        let provider = language_model.provider_id().0.to_string();
+
+        match self {
+            AssistantSettingsContent::Versioned(settings) => match settings {
+                VersionedAssistantSettingsContent::V1(settings) => match provider.as_ref() {
+                    "zed.dev" => {
+                        log::warn!("attempted to set zed.dev model on outdated settings");
+                    }
+                    "anthropic" => {
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::Anthropic {
+                            default_model: AnthropicModel::from_id(&model).ok(),
+                            api_url,
+                        });
+                    }
+                    "ollama" => {
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::Ollama {
+                            default_model: Some(ollama::Model::new(&model, None, None)),
+                            api_url,
+                        });
+                    }
+                    "openai" => {
+                        let (api_url, available_models) = match &settings.provider {
+                            Some(AssistantProviderContentV1::OpenAi {
+                                api_url,
+                                available_models,
+                                ..
+                            }) => (api_url.clone(), available_models.clone()),
+                            _ => (None, None),
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::OpenAi {
+                            default_model: OpenAiModel::from_id(&model).ok(),
+                            api_url,
+                            available_models,
+                        });
+                    }
+                    _ => {}
+                },
+                VersionedAssistantSettingsContent::V2(settings) => {
+                    settings.default_model = Some(LanguageModelSelection { provider, model });
+                }
+            },
+            AssistantSettingsContent::Legacy(settings) => {
+                if let Ok(model) = OpenAiModel::from_id(&language_model.id().0) {
+                    settings.default_open_ai_model = Some(model);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(tag = "version")]
+pub enum VersionedAssistantSettingsContent {
+    #[serde(rename = "1")]
+    V1(AssistantSettingsContentV1),
+    #[serde(rename = "2")]
+    V2(AssistantSettingsContentV2),
+}
+
+impl Default for VersionedAssistantSettingsContent {
+    fn default() -> Self {
+        Self::V2(AssistantSettingsContentV2 {
+            enabled: None,
+            button: None,
+            dock: None,
+            default_width: None,
+            default_height: None,
+            default_model: None,
+            inline_alternatives: None,
+            enable_experimental_live_diffs: None,
+        })
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct AssistantSettingsContentV2 {
+    /// Whether the Assistant is enabled.
+    ///
+    /// Default: true
+    enabled: Option<bool>,
+    /// Whether to show the assistant panel button in the status bar.
+    ///
+    /// Default: true
+    button: Option<bool>,
+    /// Where to dock the assistant.
+    ///
+    /// Default: right
+    dock: Option<AssistantDockPosition>,
+    /// Default width in pixels when the assistant is docked to the left or right.
+    ///
+    /// Default: 640
+    default_width: Option<f32>,
+    /// Default height in pixels when the assistant is docked to the bottom.
+    ///
+    /// Default: 320
+    default_height: Option<f32>,
+    /// The default model to use when creating new chats.
+    default_model: Option<LanguageModelSelection>,
+    /// Additional models with which to generate alternatives when performing inline assists.
+    inline_alternatives: Option<Vec<LanguageModelSelection>>,
+    /// Enable experimental live diffs in the assistant panel.
+    ///
+    /// Default: false
+    enable_experimental_live_diffs: Option<bool>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+pub struct LanguageModelSelection {
+    #[schemars(schema_with = "providers_schema")]
+    pub provider: String,
+    pub model: String,
+}
+
+fn providers_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+    schemars::schema::SchemaObject {
+        enum_values: Some(vec![
+            "anthropic".into(),
+            "google".into(),
+            "ollama".into(),
+            "openai".into(),
+            "zed.dev".into(),
+            "copilot_chat".into(),
+        ]),
+        ..Default::default()
+    }
+    .into()
+}
+
+impl Default for LanguageModelSelection {
+    fn default() -> Self {
+        Self {
+            provider: "openai".to_string(),
+            model: "gpt-4".to_string(),
+        }
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct AssistantSettingsContentV1 {
+    /// Whether the Assistant is enabled.
+    ///
+    /// Default: true
+    enabled: Option<bool>,
+    /// Whether to show the assistant panel button in the status bar.
+    ///
+    /// Default: true
+    button: Option<bool>,
+    /// Where to dock the assistant.
+    ///
+    /// Default: right
+    dock: Option<AssistantDockPosition>,
+    /// Default width in pixels when the assistant is docked to the left or right.
+    ///
+    /// Default: 640
+    default_width: Option<f32>,
+    /// Default height in pixels when the assistant is docked to the bottom.
+    ///
+    /// Default: 320
+    default_height: Option<f32>,
+    /// The provider of the assistant service.
+    ///
+    /// This can be "openai", "anthropic", "ollama", "zed.dev"
+    /// each with their respective default models and configurations.
+    provider: Option<AssistantProviderContentV1>,
+}
+
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct LegacyAssistantSettingsContent {
+    /// Whether to show the assistant panel button in the status bar.
+    ///
+    /// Default: true
+    pub button: Option<bool>,
+    /// Where to dock the assistant.
+    ///
+    /// Default: right
+    pub dock: Option<AssistantDockPosition>,
+    /// Default width in pixels when the assistant is docked to the left or right.
+    ///
+    /// Default: 640
+    pub default_width: Option<f32>,
+    /// Default height in pixels when the assistant is docked to the bottom.
+    ///
+    /// Default: 320
+    pub default_height: Option<f32>,
+    /// The default OpenAI model to use when creating new chats.
+    ///
+    /// Default: gpt-4-1106-preview
+    pub default_open_ai_model: Option<OpenAiModel>,
+    /// OpenAI API base URL to use when creating new chats.
+    ///
+    /// Default: https://api.openai.com/v1
+    pub openai_api_url: Option<String>,
+}
+
+impl Settings for AssistantSettings {
+    const KEY: Option<&'static str> = Some("assistant");
+
+    const PRESERVED_KEYS: Option<&'static [&'static str]> = Some(&["version"]);
+
+    type FileContent = AssistantSettingsContent;
+
+    fn load(
+        sources: SettingsSources<Self::FileContent>,
+        _: &mut gpui::AppContext,
+    ) -> anyhow::Result<Self> {
+        let mut settings = AssistantSettings::default();
+
+        for value in sources.defaults_and_customizations() {
+            if value.is_version_outdated() {
+                settings.using_outdated_settings_version = true;
+            }
+
+            let value = value.upgrade();
+            merge(&mut settings.enabled, value.enabled);
+            merge(&mut settings.button, value.button);
+            merge(&mut settings.dock, value.dock);
+            merge(
+                &mut settings.default_width,
+                value.default_width.map(Into::into),
+            );
+            merge(
+                &mut settings.default_height,
+                value.default_height.map(Into::into),
+            );
+            merge(&mut settings.default_model, value.default_model);
+            merge(&mut settings.inline_alternatives, value.inline_alternatives);
+            merge(
+                &mut settings.enable_experimental_live_diffs,
+                value.enable_experimental_live_diffs,
+            );
+        }
+
+        Ok(settings)
+    }
+}
+
+fn merge<T>(target: &mut T, value: Option<T>) {
+    if let Some(value) = value {
+        *target = value;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use fs::Fs;
+    use gpui::{ReadGlobal, TestAppContext};
+
+    use super::*;
+
+    #[gpui::test]
+    async fn test_deserialize_assistant_settings_with_version(cx: &mut TestAppContext) {
+        let fs = fs::FakeFs::new(cx.executor().clone());
+        fs.create_dir(paths::settings_file().parent().unwrap())
+            .await
+            .unwrap();
+
+        cx.update(|cx| {
+            let test_settings = settings::SettingsStore::test(cx);
+            cx.set_global(test_settings);
+            AssistantSettings::register(cx);
+        });
+
+        cx.update(|cx| {
+            assert!(!AssistantSettings::get_global(cx).using_outdated_settings_version);
+            assert_eq!(
+                AssistantSettings::get_global(cx).default_model,
+                LanguageModelSelection {
+                    provider: "zed.dev".into(),
+                    model: "claude-3-5-sonnet".into(),
+                }
+            );
+        });
+
+        cx.update(|cx| {
+            settings::SettingsStore::global(cx).update_settings_file::<AssistantSettings>(
+                fs.clone(),
+                |settings, _| {
+                    *settings = AssistantSettingsContent::Versioned(
+                        VersionedAssistantSettingsContent::V2(AssistantSettingsContentV2 {
+                            default_model: Some(LanguageModelSelection {
+                                provider: "test-provider".into(),
+                                model: "gpt-99".into(),
+                            }),
+                            inline_alternatives: None,
+                            enabled: None,
+                            button: None,
+                            dock: None,
+                            default_width: None,
+                            default_height: None,
+                            enable_experimental_live_diffs: None,
+                        }),
+                    )
+                },
+            );
+        });
+
+        cx.run_until_parked();
+
+        let raw_settings_value = fs.load(paths::settings_file()).await.unwrap();
+        assert!(raw_settings_value.contains(r#""version": "2""#));
+
+        #[derive(Debug, Deserialize)]
+        struct AssistantSettingsTest {
+            assistant: AssistantSettingsContent,
+        }
+
+        let assistant_settings: AssistantSettingsTest =
+            serde_json_lenient::from_str(&raw_settings_value).unwrap();
+
+        assert!(!assistant_settings.assistant.is_version_outdated());
+    }
+}
--- a/crates/assistant2/src/context.rs
+++ b/crates/assistant2/src/context.rs
@@ -1,8 +1,20 @@
 use gpui::SharedString;
+use serde::{Deserialize, Serialize};
+use util::post_inc;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
+pub struct ContextId(pub(crate) usize);
+
+impl ContextId {
+    pub fn post_inc(&mut self) -> Self {
+        Self(post_inc(&mut self.0))
+    }
+}

 /// Some context attached to a message in a thread.
 #[derive(Debug, Clone)]
 pub struct Context {
+    pub id: ContextId,
    pub name: SharedString,
    pub kind: ContextKind,
    pub text: SharedString,
@@ -11,4 +23,5 @@ pub struct Context {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ContextKind {
    File,
+    FetchedUrl,
 }
--- a/crates/assistant2/src/context_picker.rs
+++ b/crates/assistant2/src/context_picker.rs
@@ -1,15 +1,101 @@
+mod fetch_context_picker;
+mod file_context_picker;
+
 use std::sync::Arc;

-use gpui::{DismissEvent, SharedString, Task, WeakView};
-use picker::{Picker, PickerDelegate, PickerEditorPosition};
-use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger, Tooltip};
+use gpui::{
+    AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView, SharedString, Task, View,
+    WeakView,
+};
+use picker::{Picker, PickerDelegate};
+use ui::{prelude::*, ListItem, ListItemSpacing, Tooltip};
+use util::ResultExt;
+use workspace::Workspace;

+use crate::context_picker::fetch_context_picker::FetchContextPicker;
+use crate::context_picker::file_context_picker::FileContextPicker;
 use crate::message_editor::MessageEditor;

-#[derive(IntoElement)]
-pub(super) struct ContextPicker<T: PopoverTrigger> {
-    message_editor: WeakView<MessageEditor>,
-    trigger: T,
+#[derive(Debug, Clone)]
+enum ContextPickerMode {
+    Default,
+    File(View<FileContextPicker>),
+    Fetch(View<FetchContextPicker>),
+}
+
+pub(super) struct ContextPicker {
+    mode: ContextPickerMode,
+    picker: View<Picker<ContextPickerDelegate>>,
+}
+
+impl ContextPicker {
+    pub fn new(
+        workspace: WeakView<Workspace>,
+        message_editor: WeakView<MessageEditor>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let delegate = ContextPickerDelegate {
+            context_picker: cx.view().downgrade(),
+            workspace: workspace.clone(),
+            message_editor: message_editor.clone(),
+            entries: vec![
+                ContextPickerEntry {
+                    name: "directory".into(),
+                    description: "Insert any directory".into(),
+                    icon: IconName::Folder,
+                },
+                ContextPickerEntry {
+                    name: "file".into(),
+                    description: "Insert any file".into(),
+                    icon: IconName::File,
+                },
+                ContextPickerEntry {
+                    name: "fetch".into(),
+                    description: "Fetch content from URL".into(),
+                    icon: IconName::Globe,
+                },
+            ],
+            selected_ix: 0,
+        };
+
+        let picker = cx.new_view(|cx| {
+            Picker::nonsearchable_uniform_list(delegate, cx).max_height(Some(rems(20.).into()))
+        });
+
+        ContextPicker {
+            mode: ContextPickerMode::Default,
+            picker,
+        }
+    }
+
+    pub fn reset_mode(&mut self) {
+        self.mode = ContextPickerMode::Default;
+    }
+}
+
+impl EventEmitter<DismissEvent> for ContextPicker {}
+
+impl FocusableView for ContextPicker {
+    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
+        match &self.mode {
+            ContextPickerMode::Default => self.picker.focus_handle(cx),
+            ContextPickerMode::File(file_picker) => file_picker.focus_handle(cx),
+            ContextPickerMode::Fetch(fetch_picker) => fetch_picker.focus_handle(cx),
+        }
+    }
+}
+
+impl Render for ContextPicker {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        v_flex()
+            .w(px(400.))
+            .min_w(px(400.))
+            .map(|parent| match &self.mode {
+                ContextPickerMode::Default => parent.child(self.picker.clone()),
+                ContextPickerMode::File(file_picker) => parent.child(file_picker.clone()),
+                ContextPickerMode::Fetch(fetch_picker) => parent.child(fetch_picker.clone()),
+            })
+    }
 }

 #[derive(Clone)]
@@ -20,26 +106,18 @@ struct ContextPickerEntry {
 }

 pub(crate) struct ContextPickerDelegate {
-    all_entries: Vec<ContextPickerEntry>,
-    filtered_entries: Vec<ContextPickerEntry>,
+    context_picker: WeakView<ContextPicker>,
+    workspace: WeakView<Workspace>,
    message_editor: WeakView<MessageEditor>,
+    entries: Vec<ContextPickerEntry>,
    selected_ix: usize,
 }

-impl<T: PopoverTrigger> ContextPicker<T> {
-    pub(crate) fn new(message_editor: WeakView<MessageEditor>, trigger: T) -> Self {
-        ContextPicker {
-            message_editor,
-            trigger,
-        }
-    }
-}
-
 impl PickerDelegate for ContextPickerDelegate {
    type ListItem = ListItem;

    fn match_count(&self) -> usize {
-        self.filtered_entries.len()
+        self.entries.len()
    }

    fn selected_index(&self) -> usize {
@@ -47,7 +125,7 @@ impl PickerDelegate for ContextPickerDelegate {
    }

    fn set_selected_index(&mut self, ix: usize, cx: &mut ViewContext<Picker<Self>>) {
-        self.selected_ix = ix.min(self.filtered_entries.len().saturating_sub(1));
+        self.selected_ix = ix.min(self.entries.len().saturating_sub(1));
        cx.notify();
    }

@@ -55,52 +133,51 @@ impl PickerDelegate for ContextPickerDelegate {
        "Select a context source…".into()
    }

-    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
-        let all_commands = self.all_entries.clone();
-        cx.spawn(|this, mut cx| async move {
-            let filtered_commands = cx
-                .background_executor()
-                .spawn(async move {
-                    if query.is_empty() {
-                        all_commands
-                    } else {
-                        all_commands
-                            .into_iter()
-                            .filter(|model_info| {
-                                model_info
-                                    .name
-                                    .to_lowercase()
-                                    .contains(&query.to_lowercase())
-                            })
-                            .collect()
-                    }
-                })
-                .await;
-
-            this.update(&mut cx, |this, cx| {
-                this.delegate.filtered_entries = filtered_commands;
-                this.delegate.set_selected_index(0, cx);
-                cx.notify();
-            })
-            .ok();
-        })
+    fn update_matches(&mut self, _query: String, _cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
+        Task::ready(())
    }

    fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
-        if let Some(entry) = self.filtered_entries.get(self.selected_ix) {
-            self.message_editor
-                .update(cx, |_message_editor, _cx| {
-                    println!("Insert context from {}", entry.name);
+        if let Some(entry) = self.entries.get(self.selected_ix) {
+            self.context_picker
+                .update(cx, |this, cx| {
+                    match entry.name.to_string().as_str() {
+                        "file" => {
+                            this.mode = ContextPickerMode::File(cx.new_view(|cx| {
+                                FileContextPicker::new(
+                                    self.context_picker.clone(),
+                                    self.workspace.clone(),
+                                    self.message_editor.clone(),
+                                    cx,
+                                )
+                            }));
+                        }
+                        "fetch" => {
+                            this.mode = ContextPickerMode::Fetch(cx.new_view(|cx| {
+                                FetchContextPicker::new(
+                                    self.context_picker.clone(),
+                                    self.workspace.clone(),
+                                    self.message_editor.clone(),
+                                    cx,
+                                )
+                            }));
+                        }
+                        _ => {}
+                    }
+
+                    cx.focus_self();
                })
-                .ok();
-            cx.emit(DismissEvent);
+                .log_err();
        }
    }

-    fn dismissed(&mut self, _cx: &mut ViewContext<Picker<Self>>) {}
-
-    fn editor_position(&self) -> PickerEditorPosition {
-        PickerEditorPosition::End
+    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
+        self.context_picker
+            .update(cx, |this, cx| match this.mode {
+                ContextPickerMode::Default => cx.emit(DismissEvent),
+                ContextPickerMode::File(_) | ContextPickerMode::Fetch(_) => {}
+            })
+            .log_err();
    }

    fn render_match(
@@ -109,13 +186,13 @@ impl PickerDelegate for ContextPickerDelegate {
        selected: bool,
        _cx: &mut ViewContext<Picker<Self>>,
    ) -> Option<Self::ListItem> {
-        let entry = self.filtered_entries.get(ix)?;
+        let entry = &self.entries[ix];

        Some(
            ListItem::new(ix)
                .inset(true)
                .spacing(ListItemSpacing::Dense)
-                .selected(selected)
+                .toggle_state(selected)
                .tooltip({
                    let description = entry.description.clone();
                    move |cx| cx.new_view(|_cx| Tooltip::new(description.clone())).into()
@@ -148,50 +225,3 @@ impl PickerDelegate for ContextPickerDelegate {
        )
    }
 }
-
-impl<T: PopoverTrigger> RenderOnce for ContextPicker<T> {
-    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
-        let entries = vec![
-            ContextPickerEntry {
-                name: "directory".into(),
-                description: "Insert any directory".into(),
-                icon: IconName::Folder,
-            },
-            ContextPickerEntry {
-                name: "file".into(),
-                description: "Insert any file".into(),
-                icon: IconName::File,
-            },
-            ContextPickerEntry {
-                name: "web".into(),
-                description: "Fetch content from URL".into(),
-                icon: IconName::Globe,
-            },
-        ];
-
-        let delegate = ContextPickerDelegate {
-            all_entries: entries.clone(),
-            message_editor: self.message_editor.clone(),
-            filtered_entries: entries,
-            selected_ix: 0,
-        };
-
-        let picker =
-            cx.new_view(|cx| Picker::uniform_list(delegate, cx).max_height(Some(rems(20.).into())));
-
-        let handle = self
-            .message_editor
-            .update(cx, |this, _| this.context_picker_handle.clone())
-            .ok();
-        PopoverMenu::new("context-picker")
-            .menu(move |_cx| Some(picker.clone()))
-            .trigger(self.trigger)
-            .attach(gpui::AnchorCorner::TopLeft)
-            .anchor(gpui::AnchorCorner::BottomLeft)
-            .offset(gpui::Point {
-                x: px(0.0),
-                y: px(-16.0),
-            })
-            .when_some(handle, |this, handle| this.with_handle(handle))
-    }
-}
--- a/crates/assistant2/src/context_picker/fetch_context_picker.rs
+++ b/crates/assistant2/src/context_picker/fetch_context_picker.rs
@@ -0,0 +1,218 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use anyhow::{bail, Context as _, Result};
+use futures::AsyncReadExt as _;
+use gpui::{AppContext, DismissEvent, FocusHandle, FocusableView, Task, View, WeakView};
+use html_to_markdown::{convert_html_to_markdown, markdown, TagHandler};
+use http_client::{AsyncBody, HttpClientWithUrl};
+use picker::{Picker, PickerDelegate};
+use ui::{prelude::*, ListItem, ListItemSpacing, ViewContext};
+use workspace::Workspace;
+
+use crate::context::ContextKind;
+use crate::context_picker::ContextPicker;
+use crate::message_editor::MessageEditor;
+
+pub struct FetchContextPicker {
+    picker: View<Picker<FetchContextPickerDelegate>>,
+}
+
+impl FetchContextPicker {
+    pub fn new(
+        context_picker: WeakView<ContextPicker>,
+        workspace: WeakView<Workspace>,
+        message_editor: WeakView<MessageEditor>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let delegate = FetchContextPickerDelegate::new(context_picker, workspace, message_editor);
+        let picker = cx.new_view(|cx| Picker::uniform_list(delegate, cx));
+
+        Self { picker }
+    }
+}
+
+impl FocusableView for FetchContextPicker {
+    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for FetchContextPicker {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        self.picker.clone()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+enum ContentType {
+    Html,
+    Plaintext,
+    Json,
+}
+
+pub struct FetchContextPickerDelegate {
+    context_picker: WeakView<ContextPicker>,
+    workspace: WeakView<Workspace>,
+    message_editor: WeakView<MessageEditor>,
+    url: String,
+}
+
+impl FetchContextPickerDelegate {
+    pub fn new(
+        context_picker: WeakView<ContextPicker>,
+        workspace: WeakView<Workspace>,
+        message_editor: WeakView<MessageEditor>,
+    ) -> Self {
+        FetchContextPickerDelegate {
+            context_picker,
+            workspace,
+            message_editor,
+            url: String::new(),
+        }
+    }
+
+    async fn build_message(http_client: Arc<HttpClientWithUrl>, url: &str) -> Result<String> {
+        let mut url = url.to_owned();
+        if !url.starts_with("https://") && !url.starts_with("http://") {
+            url = format!("https://{url}");
+        }
+
+        let mut response = http_client.get(&url, AsyncBody::default(), true).await?;
+
+        let mut body = Vec::new();
+        response
+            .body_mut()
+            .read_to_end(&mut body)
+            .await
+            .context("error reading 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()
+            );
+        }
+
+        let Some(content_type) = response.headers().get("content-type") else {
+            bail!("missing Content-Type header");
+        };
+        let content_type = content_type
+            .to_str()
+            .context("invalid Content-Type header")?;
+        let content_type = match content_type {
+            "text/html" => ContentType::Html,
+            "text/plain" => ContentType::Plaintext,
+            "application/json" => ContentType::Json,
+            _ => ContentType::Html,
+        };
+
+        match content_type {
+            ContentType::Html => {
+                let mut handlers: Vec<TagHandler> = vec![
+                    Rc::new(RefCell::new(markdown::WebpageChromeRemover)),
+                    Rc::new(RefCell::new(markdown::ParagraphHandler)),
+                    Rc::new(RefCell::new(markdown::HeadingHandler)),
+                    Rc::new(RefCell::new(markdown::ListHandler)),
+                    Rc::new(RefCell::new(markdown::TableHandler::new())),
+                    Rc::new(RefCell::new(markdown::StyledTextHandler)),
+                ];
+                if url.contains("wikipedia.org") {
+                    use html_to_markdown::structure::wikipedia;
+
+                    handlers.push(Rc::new(RefCell::new(wikipedia::WikipediaChromeRemover)));
+                    handlers.push(Rc::new(RefCell::new(wikipedia::WikipediaInfoboxHandler)));
+                    handlers.push(Rc::new(
+                        RefCell::new(wikipedia::WikipediaCodeHandler::new()),
+                    ));
+                } else {
+                    handlers.push(Rc::new(RefCell::new(markdown::CodeHandler)));
+                }
+
+                convert_html_to_markdown(&body[..], &mut handlers)
+            }
+            ContentType::Plaintext => Ok(std::str::from_utf8(&body)?.to_owned()),
+            ContentType::Json => {
+                let json: serde_json::Value = serde_json::from_slice(&body)?;
+
+                Ok(format!(
+                    "```json\n{}\n```",
+                    serde_json::to_string_pretty(&json)?
+                ))
+            }
+        }
+    }
+}
+
+impl PickerDelegate for FetchContextPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        1
+    }
+
+    fn selected_index(&self) -> usize {
+        0
+    }
+
+    fn set_selected_index(&mut self, _ix: usize, _cx: &mut ViewContext<Picker<Self>>) {}
+
+    fn placeholder_text(&self, _cx: &mut ui::WindowContext) -> Arc<str> {
+        "Enter a URL…".into()
+    }
+
+    fn update_matches(&mut self, query: String, _cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
+        self.url = query;
+
+        Task::ready(())
+    }
+
+    fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return;
+        };
+
+        let http_client = workspace.read(cx).client().http_client().clone();
+        let url = self.url.clone();
+        cx.spawn(|this, mut cx| async move {
+            let text = Self::build_message(http_client, &url).await?;
+
+            this.update(&mut cx, |this, cx| {
+                this.delegate
+                    .message_editor
+                    .update(cx, |message_editor, _cx| {
+                        message_editor.insert_context(ContextKind::FetchedUrl, url, text);
+                    })
+            })??;
+
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
+        self.context_picker
+            .update(cx, |this, cx| {
+                this.reset_mode();
+                cx.emit(DismissEvent);
+            })
+            .ok();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _cx: &mut ViewContext<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .child(self.url.clone()),
+        )
+    }
+}
--- a/crates/assistant2/src/context_picker/file_context_picker.rs
+++ b/crates/assistant2/src/context_picker/file_context_picker.rs
@@ -0,0 +1,289 @@
+use std::fmt::Write as _;
+use std::ops::RangeInclusive;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use fuzzy::PathMatch;
+use gpui::{AppContext, DismissEvent, FocusHandle, FocusableView, Task, View, WeakView};
+use picker::{Picker, PickerDelegate};
+use project::{PathMatchCandidateSet, WorktreeId};
+use ui::{prelude::*, ListItem, ListItemSpacing};
+use util::ResultExt as _;
+use workspace::Workspace;
+
+use crate::context::ContextKind;
+use crate::context_picker::ContextPicker;
+use crate::message_editor::MessageEditor;
+
+pub struct FileContextPicker {
+    picker: View<Picker<FileContextPickerDelegate>>,
+}
+
+impl FileContextPicker {
+    pub fn new(
+        context_picker: WeakView<ContextPicker>,
+        workspace: WeakView<Workspace>,
+        message_editor: WeakView<MessageEditor>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let delegate = FileContextPickerDelegate::new(context_picker, workspace, message_editor);
+        let picker = cx.new_view(|cx| Picker::uniform_list(delegate, cx));
+
+        Self { picker }
+    }
+}
+
+impl FocusableView for FileContextPicker {
+    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for FileContextPicker {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        self.picker.clone()
+    }
+}
+
+pub struct FileContextPickerDelegate {
+    context_picker: WeakView<ContextPicker>,
+    workspace: WeakView<Workspace>,
+    message_editor: WeakView<MessageEditor>,
+    matches: Vec<PathMatch>,
+    selected_index: usize,
+}
+
+impl FileContextPickerDelegate {
+    pub fn new(
+        context_picker: WeakView<ContextPicker>,
+        workspace: WeakView<Workspace>,
+        message_editor: WeakView<MessageEditor>,
+    ) -> Self {
+        Self {
+            context_picker,
+            workspace,
+            message_editor,
+            matches: Vec::new(),
+            selected_index: 0,
+        }
+    }
+
+    fn search(
+        &mut self,
+        query: String,
+        cancellation_flag: Arc<AtomicBool>,
+        workspace: &View<Workspace>,
+        cx: &mut ViewContext<Picker<Self>>,
+    ) -> Task<Vec<PathMatch>> {
+        if query.is_empty() {
+            let workspace = workspace.read(cx);
+            let project = workspace.project().read(cx);
+            let entries = workspace.recent_navigation_history(Some(10), cx);
+
+            let entries = entries
+                .into_iter()
+                .map(|entries| entries.0)
+                .chain(project.worktrees(cx).flat_map(|worktree| {
+                    let worktree = worktree.read(cx);
+                    let id = worktree.id();
+                    worktree
+                        .child_entries(Path::new(""))
+                        .filter(|entry| entry.kind.is_file())
+                        .map(move |entry| project::ProjectPath {
+                            worktree_id: id,
+                            path: entry.path.clone(),
+                        })
+                }))
+                .collect::<Vec<_>>();
+
+            let path_prefix: Arc<str> = Arc::default();
+            Task::ready(
+                entries
+                    .into_iter()
+                    .filter_map(|entry| {
+                        let worktree = project.worktree_for_id(entry.worktree_id, cx)?;
+                        let mut full_path = PathBuf::from(worktree.read(cx).root_name());
+                        full_path.push(&entry.path);
+                        Some(PathMatch {
+                            score: 0.,
+                            positions: Vec::new(),
+                            worktree_id: entry.worktree_id.to_usize(),
+                            path: full_path.into(),
+                            path_prefix: path_prefix.clone(),
+                            distance_to_relative_ancestor: 0,
+                            is_dir: false,
+                        })
+                    })
+                    .collect(),
+            )
+        } else {
+            let worktrees = workspace.read(cx).visible_worktrees(cx).collect::<Vec<_>>();
+            let candidate_sets = worktrees
+                .into_iter()
+                .map(|worktree| {
+                    let worktree = worktree.read(cx);
+
+                    PathMatchCandidateSet {
+                        snapshot: worktree.snapshot(),
+                        include_ignored: worktree
+                            .root_entry()
+                            .map_or(false, |entry| entry.is_ignored),
+                        include_root_name: true,
+                        candidates: project::Candidates::Files,
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            let executor = cx.background_executor().clone();
+            cx.foreground_executor().spawn(async move {
+                fuzzy::match_path_sets(
+                    candidate_sets.as_slice(),
+                    query.as_str(),
+                    None,
+                    false,
+                    100,
+                    &cancellation_flag,
+                    executor,
+                )
+                .await
+            })
+        }
+    }
+}
+
+impl PickerDelegate for FileContextPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _cx: &mut ViewContext<Picker<Self>>) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _cx: &mut WindowContext) -> Arc<str> {
+        "Search files…".into()
+    }
+
+    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return Task::ready(());
+        };
+
+        let search_task = self.search(query, Arc::<AtomicBool>::default(), &workspace, cx);
+
+        cx.spawn(|this, mut cx| async move {
+            // TODO: This should be probably be run in the background.
+            let paths = search_task.await;
+
+            this.update(&mut cx, |this, _cx| {
+                this.delegate.matches = paths;
+            })
+            .log_err();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
+        let mat = &self.matches[self.selected_index];
+
+        let workspace = self.workspace.clone();
+        let Some(project) = workspace
+            .upgrade()
+            .map(|workspace| workspace.read(cx).project().clone())
+        else {
+            return;
+        };
+        let path = mat.path.clone();
+        let worktree_id = WorktreeId::from_usize(mat.worktree_id);
+        cx.spawn(|this, mut cx| async move {
+            let Some(open_buffer_task) = project
+                .update(&mut cx, |project, cx| {
+                    project.open_buffer((worktree_id, path.clone()), cx)
+                })
+                .ok()
+            else {
+                return anyhow::Ok(());
+            };
+
+            let buffer = open_buffer_task.await?;
+
+            this.update(&mut cx, |this, cx| {
+                this.delegate
+                    .message_editor
+                    .update(cx, |message_editor, cx| {
+                        let mut text = String::new();
+                        text.push_str(&codeblock_fence_for_path(Some(&path), None));
+                        text.push_str(&buffer.read(cx).text());
+                        if !text.ends_with('\n') {
+                            text.push('\n');
+                        }
+
+                        text.push_str("```\n");
+
+                        message_editor.insert_context(
+                            ContextKind::File,
+                            path.to_string_lossy().to_string(),
+                            text,
+                        );
+                    })
+            })??;
+
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
+        self.context_picker
+            .update(cx, |this, cx| {
+                this.reset_mode();
+                cx.emit(DismissEvent);
+            })
+            .ok();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _cx: &mut ViewContext<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let mat = &self.matches[ix];
+
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .child(mat.path.to_string_lossy().to_string()),
+        )
+    }
+}
+
+fn codeblock_fence_for_path(path: Option<&Path>, row_range: Option<RangeInclusive<u32>>) -> String {
+    let mut text = String::new();
+    write!(text, "```").unwrap();
+
+    if let Some(path) = path {
+        if let Some(extension) = path.extension().and_then(|ext| ext.to_str()) {
+            write!(text, "{} ", extension).unwrap();
+        }
+
+        write!(text, "{}", path.display()).unwrap();
+    } else {
+        write!(text, "untitled").unwrap();
+    }
+
+    if let Some(row_range) = row_range {
+        write!(text, ":{}-{}", row_range.start() + 1, row_range.end() + 1).unwrap();
+    }
+
+    text.push('\n');
+    text
+}
--- a/crates/assistant2/src/inline_assistant.rs
+++ b/crates/assistant2/src/inline_assistant.rs
--- a/crates/assistant2/src/message_editor.rs
+++ b/crates/assistant2/src/message_editor.rs
@@ -1,17 +1,19 @@
+use std::rc::Rc;
+
 use editor::{Editor, EditorElement, EditorStyle};
-use gpui::{AppContext, FocusableView, Model, TextStyle, View};
+use gpui::{AppContext, FocusableView, Model, TextStyle, View, WeakView};
 use language_model::{LanguageModelRegistry, LanguageModelRequestTool};
-use language_model_selector::LanguageModelSelector;
-use picker::Picker;
+use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use settings::Settings;
 use theme::ThemeSettings;
 use ui::{
    prelude::*, ButtonLike, CheckboxWithLabel, ElevationIndex, IconButtonShape, KeyBinding,
-    PopoverMenuHandle, Tooltip,
+    PopoverMenu, PopoverMenuHandle, Tooltip,
 };
+use workspace::Workspace;

-use crate::context::{Context, ContextKind};
-use crate::context_picker::{ContextPicker, ContextPickerDelegate};
+use crate::context::{Context, ContextId, ContextKind};
+use crate::context_picker::ContextPicker;
 use crate::thread::{RequestKind, Thread};
 use crate::ui::ContextPill;
 use crate::{Chat, ToggleModelSelector};
@@ -20,18 +22,20 @@ pub struct MessageEditor {
    thread: Model<Thread>,
    editor: View<Editor>,
    context: Vec<Context>,
-    pub(crate) context_picker_handle: PopoverMenuHandle<Picker<ContextPickerDelegate>>,
+    next_context_id: ContextId,
+    context_picker: View<ContextPicker>,
+    pub(crate) context_picker_handle: PopoverMenuHandle<ContextPicker>,
+    language_model_selector: View<LanguageModelSelector>,
    use_tools: bool,
 }

 impl MessageEditor {
-    pub fn new(thread: Model<Thread>, cx: &mut ViewContext<Self>) -> Self {
-        let mocked_context = vec![Context {
-            name: "shape.rs".into(),
-            kind: ContextKind::File,
-            text: "```rs\npub enum Shape {\n    Circle,\n    Square,\n    Triangle,\n}".into(),
-        }];
-
+    pub fn new(
+        workspace: WeakView<Workspace>,
+        thread: Model<Thread>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let weak_self = cx.view().downgrade();
        Self {
            thread,
            editor: cx.new_view(|cx| {
@@ -40,12 +44,36 @@ impl MessageEditor {

                editor
            }),
-            context: mocked_context,
+            context: Vec::new(),
+            next_context_id: ContextId(0),
+            context_picker: cx.new_view(|cx| ContextPicker::new(workspace.clone(), weak_self, cx)),
            context_picker_handle: PopoverMenuHandle::default(),
+            language_model_selector: cx.new_view(|cx| {
+                LanguageModelSelector::new(
+                    |model, _cx| {
+                        println!("Selected {:?}", model.name());
+                    },
+                    cx,
+                )
+            }),
            use_tools: false,
        }
    }

+    pub fn insert_context(
+        &mut self,
+        kind: ContextKind,
+        name: impl Into<SharedString>,
+        text: impl Into<SharedString>,
+    ) {
+        self.context.push(Context {
+            id: self.next_context_id.post_inc(),
+            name: name.into(),
+            kind,
+            text: text.into(),
+        });
+    }
+
    fn chat(&mut self, _: &Chat, cx: &mut ViewContext<Self>) {
        self.send_to_model(RequestKind::Chat, cx);
    }
@@ -101,10 +129,8 @@ impl MessageEditor {
        let active_provider = LanguageModelRegistry::read_global(cx).active_provider();
        let active_model = LanguageModelRegistry::read_global(cx).active_model();

-        LanguageModelSelector::new(
-            |model, _cx| {
-                println!("Selected {:?}", model.name());
-            },
+        LanguageModelSelectorPopoverMenu::new(
+            self.language_model_selector.clone(),
            ButtonLike::new("active-model")
                .style(ButtonStyle::Subtle)
                .child(
@@ -160,6 +186,7 @@ impl Render for MessageEditor {
        let font_size = TextSize::Default.rems(cx);
        let line_height = font_size.to_pixels(cx.rem_size()) * 1.3;
        let focus_handle = self.editor.focus_handle(cx);
+        let context_picker = self.context_picker.clone();

        v_flex()
            .key_context("MessageEditor")
@@ -172,17 +199,31 @@ impl Render for MessageEditor {
                h_flex()
                    .flex_wrap()
                    .gap_2()
-                    .child(ContextPicker::new(
-                        cx.view().downgrade(),
-                        IconButton::new("add-context", IconName::Plus)
-                            .shape(IconButtonShape::Square)
-                            .icon_size(IconSize::Small),
-                    ))
-                    .children(
-                        self.context
-                            .iter()
-                            .map(|context| ContextPill::new(context.clone())),
+                    .child(
+                        PopoverMenu::new("context-picker")
+                            .menu(move |_cx| Some(context_picker.clone()))
+                            .trigger(
+                                IconButton::new("add-context", IconName::Plus)
+                                    .shape(IconButtonShape::Square)
+                                    .icon_size(IconSize::Small),
+                            )
+                            .attach(gpui::AnchorCorner::TopLeft)
+                            .anchor(gpui::AnchorCorner::BottomLeft)
+                            .offset(gpui::Point {
+                                x: px(0.0),
+                                y: px(-16.0),
+                            })
+                            .with_handle(self.context_picker_handle.clone()),
                    )
+                    .children(self.context.iter().map(|context| {
+                        ContextPill::new(context.clone()).on_remove({
+                            let context = context.clone();
+                            Rc::new(cx.listener(move |this, _event, cx| {
+                                this.context.retain(|other| other.id != context.id);
+                                cx.notify();
+                            }))
+                        })
+                    }))
                    .when(!self.context.is_empty(), |parent| {
                        parent.child(
                            IconButton::new("remove-all-context", IconName::Eraser)
@@ -227,8 +268,8 @@ impl Render for MessageEditor {
                        self.use_tools.into(),
                        cx.listener(|this, selection, _cx| {
                            this.use_tools = match selection {
-                                Selection::Selected => true,
-                                Selection::Unselected | Selection::Indeterminate => false,
+                                ToggleState::Selected => true,
+                                ToggleState::Unselected | ToggleState::Indeterminate => false,
                            };
                        }),
                    )))
--- a/crates/assistant2/src/prompts.rs
+++ b/crates/assistant2/src/prompts.rs
@@ -0,0 +1,312 @@
+use anyhow::Result;
+use assets::Assets;
+use fs::Fs;
+use futures::StreamExt;
+use gpui::AssetSource;
+use handlebars::{Handlebars, RenderError};
+use language::{BufferSnapshot, LanguageName, Point};
+use parking_lot::Mutex;
+use serde::Serialize;
+use std::{ops::Range, path::PathBuf, sync::Arc, time::Duration};
+use text::LineEnding;
+use util::ResultExt;
+
+#[derive(Serialize)]
+pub struct ContentPromptDiagnosticContext {
+    pub line_number: usize,
+    pub error_message: String,
+    pub code_content: String,
+}
+
+#[derive(Serialize)]
+pub struct ContentPromptContext {
+    pub content_type: String,
+    pub language_name: Option<String>,
+    pub is_insert: bool,
+    pub is_truncated: bool,
+    pub document_content: String,
+    pub user_prompt: String,
+    pub rewrite_section: Option<String>,
+    pub diagnostic_errors: Vec<ContentPromptDiagnosticContext>,
+}
+
+#[derive(Serialize)]
+pub struct TerminalAssistantPromptContext {
+    pub os: String,
+    pub arch: String,
+    pub shell: Option<String>,
+    pub working_directory: Option<String>,
+    pub latest_output: Vec<String>,
+    pub user_prompt: String,
+}
+
+#[derive(Serialize)]
+pub struct ProjectSlashCommandPromptContext {
+    pub context_buffer: String,
+}
+
+pub struct PromptLoadingParams<'a> {
+    pub fs: Arc<dyn Fs>,
+    pub repo_path: Option<PathBuf>,
+    pub cx: &'a gpui::AppContext,
+}
+
+pub struct PromptBuilder {
+    handlebars: Arc<Mutex<Handlebars<'static>>>,
+}
+
+impl PromptBuilder {
+    pub fn new(loading_params: Option<PromptLoadingParams>) -> Result<Self> {
+        let mut handlebars = Handlebars::new();
+        Self::register_built_in_templates(&mut handlebars)?;
+
+        let handlebars = Arc::new(Mutex::new(handlebars));
+
+        if let Some(params) = loading_params {
+            Self::watch_fs_for_template_overrides(params, handlebars.clone());
+        }
+
+        Ok(Self { handlebars })
+    }
+
+    /// Watches the filesystem for changes to prompt template overrides.
+    ///
+    /// This function sets up a file watcher on the prompt templates directory. It performs
+    /// an initial scan of the directory and registers any existing template overrides.
+    /// Then it continuously monitors for changes, reloading templates as they are
+    /// modified or added.
+    ///
+    /// If the templates directory doesn't exist initially, it waits for it to be created.
+    /// If the directory is removed, it restores the built-in templates and waits for the
+    /// directory to be recreated.
+    ///
+    /// # Arguments
+    ///
+    /// * `params` - A `PromptLoadingParams` struct containing the filesystem, repository path,
+    ///   and application context.
+    /// * `handlebars` - An `Arc<Mutex<Handlebars>>` for registering and updating templates.
+    fn watch_fs_for_template_overrides(
+        params: PromptLoadingParams,
+        handlebars: Arc<Mutex<Handlebars<'static>>>,
+    ) {
+        let templates_dir = paths::prompt_overrides_dir(params.repo_path.as_deref());
+        params.cx.background_executor()
+            .spawn(async move {
+                let Some(parent_dir) = templates_dir.parent() else {
+                    return;
+                };
+
+                let mut found_dir_once = false;
+                loop {
+                    // Check if the templates directory exists and handle its status
+                    // If it exists, log its presence and check if it's a symlink
+                    // If it doesn't exist:
+                    //   - Log that we're using built-in prompts
+                    //   - Check if it's a broken symlink and log if so
+                    //   - Set up a watcher to detect when it's created
+                    // After the first check, set the `found_dir_once` flag
+                    // This allows us to avoid logging when looping back around after deleting the prompt overrides directory.
+                    let dir_status = params.fs.is_dir(&templates_dir).await;
+                    let symlink_status = params.fs.read_link(&templates_dir).await.ok();
+                    if dir_status {
+                        let mut log_message = format!("Prompt template overrides directory found at {}", templates_dir.display());
+                        if let Some(target) = symlink_status {
+                            log_message.push_str(" -> ");
+                            log_message.push_str(&target.display().to_string());
+                        }
+                        log::info!("{}.", log_message);
+                    } else {
+                        if !found_dir_once {
+                            log::info!("No prompt template overrides directory found at {}. Using built-in prompts.", templates_dir.display());
+                            if let Some(target) = symlink_status {
+                                log::info!("Symlink found pointing to {}, but target is invalid.", target.display());
+                            }
+                        }
+
+                        if params.fs.is_dir(parent_dir).await {
+                            let (mut changes, _watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;
+                            while let Some(changed_paths) = changes.next().await {
+                                if changed_paths.iter().any(|p| &p.path == &templates_dir) {
+                                    let mut log_message = format!("Prompt template overrides directory detected at {}", templates_dir.display());
+                                    if let Ok(target) = params.fs.read_link(&templates_dir).await {
+                                        log_message.push_str(" -> ");
+                                        log_message.push_str(&target.display().to_string());
+                                    }
+                                    log::info!("{}.", log_message);
+                                    break;
+                                }
+                            }
+                        } else {
+                            return;
+                        }
+                    }
+
+                    found_dir_once = true;
+
+                    // Initial scan of the prompt overrides directory
+                    if let Ok(mut entries) = params.fs.read_dir(&templates_dir).await {
+                        while let Some(Ok(file_path)) = entries.next().await {
+                            if file_path.to_string_lossy().ends_with(".hbs") {
+                                if let Ok(content) = params.fs.load(&file_path).await {
+                                    let file_name = file_path.file_stem().unwrap().to_string_lossy();
+                                    log::debug!("Registering prompt template override: {}", file_name);
+                                    handlebars.lock().register_template_string(&file_name, content).log_err();
+                                }
+                            }
+                        }
+                    }
+
+                    // Watch both the parent directory and the template overrides directory:
+                    // - Monitor the parent directory to detect if the template overrides directory is deleted.
+                    // - Monitor the template overrides directory to re-register templates when they change.
+                    // Combine both watch streams into a single stream.
+                    let (parent_changes, parent_watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;
+                    let (changes, watcher) = params.fs.watch(&templates_dir, Duration::from_secs(1)).await;
+                    let mut combined_changes = futures::stream::select(changes, parent_changes);
+
+                    while let Some(changed_paths) = combined_changes.next().await {
+                        if changed_paths.iter().any(|p| &p.path == &templates_dir) {
+                            if !params.fs.is_dir(&templates_dir).await {
+                                log::info!("Prompt template overrides directory removed. Restoring built-in prompt templates.");
+                                Self::register_built_in_templates(&mut handlebars.lock()).log_err();
+                                break;
+                            }
+                        }
+                        for event in changed_paths {
+                            if event.path.starts_with(&templates_dir) && event.path.extension().map_or(false, |ext| ext == "hbs") {
+                                log::info!("Reloading prompt template override: {}", event.path.display());
+                                if let Some(content) = params.fs.load(&event.path).await.log_err() {
+                                    let file_name = event.path.file_stem().unwrap().to_string_lossy();
+                                    handlebars.lock().register_template_string(&file_name, content).log_err();
+                                }
+                            }
+                        }
+                    }
+
+                    drop(watcher);
+                    drop(parent_watcher);
+                }
+            })
+            .detach();
+    }
+
+    fn register_built_in_templates(handlebars: &mut Handlebars) -> Result<()> {
+        for path in Assets.list("prompts")? {
+            if let Some(id) = path.split('/').last().and_then(|s| s.strip_suffix(".hbs")) {
+                if let Some(prompt) = Assets.load(path.as_ref()).log_err().flatten() {
+                    log::debug!("Registering built-in prompt template: {}", id);
+                    let prompt = String::from_utf8_lossy(prompt.as_ref());
+                    handlebars.register_template_string(id, LineEnding::normalize_cow(prompt))?
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn generate_inline_transformation_prompt(
+        &self,
+        user_prompt: String,
+        language_name: Option<&LanguageName>,
+        buffer: BufferSnapshot,
+        range: Range<usize>,
+    ) -> Result<String, RenderError> {
+        let content_type = match language_name.as_ref().map(|l| l.0.as_ref()) {
+            None | Some("Markdown" | "Plain Text") => "text",
+            Some(_) => "code",
+        };
+
+        const MAX_CTX: usize = 50000;
+        let is_insert = range.is_empty();
+        let mut is_truncated = false;
+
+        let before_range = 0..range.start;
+        let truncated_before = if before_range.len() > MAX_CTX {
+            is_truncated = true;
+            let start = buffer.clip_offset(range.start - MAX_CTX, text::Bias::Right);
+            start..range.start
+        } else {
+            before_range
+        };
+
+        let after_range = range.end..buffer.len();
+        let truncated_after = if after_range.len() > MAX_CTX {
+            is_truncated = true;
+            let end = buffer.clip_offset(range.end + MAX_CTX, text::Bias::Left);
+            range.end..end
+        } else {
+            after_range
+        };
+
+        let mut document_content = String::new();
+        for chunk in buffer.text_for_range(truncated_before) {
+            document_content.push_str(chunk);
+        }
+        if is_insert {
+            document_content.push_str("<insert_here></insert_here>");
+        } else {
+            document_content.push_str("<rewrite_this>\n");
+            for chunk in buffer.text_for_range(range.clone()) {
+                document_content.push_str(chunk);
+            }
+            document_content.push_str("\n</rewrite_this>");
+        }
+        for chunk in buffer.text_for_range(truncated_after) {
+            document_content.push_str(chunk);
+        }
+
+        let rewrite_section = if !is_insert {
+            let mut section = String::new();
+            for chunk in buffer.text_for_range(range.clone()) {
+                section.push_str(chunk);
+            }
+            Some(section)
+        } else {
+            None
+        };
+        let diagnostics = buffer.diagnostics_in_range::<_, Point>(range, false);
+        let diagnostic_errors: Vec<ContentPromptDiagnosticContext> = diagnostics
+            .map(|entry| {
+                let start = entry.range.start;
+                ContentPromptDiagnosticContext {
+                    line_number: (start.row + 1) as usize,
+                    error_message: entry.diagnostic.message.clone(),
+                    code_content: buffer.text_for_range(entry.range.clone()).collect(),
+                }
+            })
+            .collect();
+
+        let context = ContentPromptContext {
+            content_type: content_type.to_string(),
+            language_name: language_name.map(|s| s.to_string()),
+            is_insert,
+            is_truncated,
+            document_content,
+            user_prompt,
+            rewrite_section,
+            diagnostic_errors,
+        };
+        self.handlebars.lock().render("content_prompt", &context)
+    }
+
+    pub fn generate_terminal_assistant_prompt(
+        &self,
+        user_prompt: &str,
+        shell: Option<&str>,
+        working_directory: Option<&str>,
+        latest_output: &[String],
+    ) -> Result<String, RenderError> {
+        let context = TerminalAssistantPromptContext {
+            os: std::env::consts::OS.to_string(),
+            arch: std::env::consts::ARCH.to_string(),
+            shell: shell.map(|s| s.to_string()),
+            working_directory: working_directory.map(|s| s.to_string()),
+            latest_output: latest_output.to_vec(),
+            user_prompt: user_prompt.to_string(),
+        };
+
+        self.handlebars
+            .lock()
+            .render("terminal_assistant_prompt", &context)
+    }
+}
--- a/crates/assistant2/src/streaming_diff.rs
+++ b/crates/assistant2/src/streaming_diff.rs
--- a/crates/assistant2/src/terminal_inline_assistant.rs
+++ b/crates/assistant2/src/terminal_inline_assistant.rs
--- a/crates/assistant2/src/thread.rs
+++ b/crates/assistant2/src/thread.rs
@@ -193,12 +193,19 @@ impl Thread {

            if let Some(context) = self.context_for_message(message.id) {
                let mut file_context = String::new();
+                let mut fetch_context = String::new();

                for context in context.iter() {
                    match context.kind {
                        ContextKind::File => {
                            file_context.push_str(&context.text);
-                            file_context.push_str("\n");
+                            file_context.push('\n');
+                        }
+                        ContextKind::FetchedUrl => {
+                            fetch_context.push_str(&context.name);
+                            fetch_context.push('\n');
+                            fetch_context.push_str(&context.text);
+                            fetch_context.push('\n');
                        }
                    }
                }
@@ -209,6 +216,11 @@ impl Thread {
                    context_text.push_str(&file_context);
                }

+                if !fetch_context.is_empty() {
+                    context_text.push_str("The following fetched results are available\n");
+                    context_text.push_str(&fetch_context);
+                }
+
                request_message
                    .content
                    .push(MessageContent::Text(context_text))
--- a/crates/assistant2/src/ui/context_pill.rs
+++ b/crates/assistant2/src/ui/context_pill.rs
@@ -1,25 +1,49 @@
-use ui::prelude::*;
+use std::rc::Rc;
+
+use gpui::ClickEvent;
+use ui::{prelude::*, IconButtonShape};

 use crate::context::Context;

 #[derive(IntoElement)]
 pub struct ContextPill {
    context: Context,
+    on_remove: Option<Rc<dyn Fn(&ClickEvent, &mut WindowContext)>>,
 }

 impl ContextPill {
    pub fn new(context: Context) -> Self {
-        Self { context }
+        Self {
+            context,
+            on_remove: None,
+        }
+    }
+
+    pub fn on_remove(mut self, on_remove: Rc<dyn Fn(&ClickEvent, &mut WindowContext)>) -> Self {
+        self.on_remove = Some(on_remove);
+        self
    }
 }

 impl RenderOnce for ContextPill {
    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
-        div()
+        h_flex()
+            .gap_1()
            .px_1()
            .border_1()
            .border_color(cx.theme().colors().border)
            .rounded_md()
            .child(Label::new(self.context.name.clone()).size(LabelSize::Small))
+            .when_some(self.on_remove, |parent, on_remove| {
+                parent.child(
+                    IconButton::new("remove", IconName::Close)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::XSmall)
+                        .on_click({
+                            let on_remove = on_remove.clone();
+                            move |event, cx| on_remove(event, cx)
+                        }),
+                )
+            })
    }
 }
--- a/crates/call/src/call_settings.rs
+++ b/crates/call/src/call_settings.rs
@@ -20,7 +20,7 @@ pub struct CallSettingsContent {

    /// Whether your current project should be shared when joining an empty channel.
    ///
-    /// Default: true
+    /// Default: false
    pub share_on_join: Option<bool>,
 }

--- a/crates/call/src/cross_platform/room.rs
+++ b/crates/call/src/cross_platform/room.rs
@@ -1288,6 +1288,12 @@ impl Room {
        })
    }

+    pub fn muted_by_user(&self) -> bool {
+        self.live_kit
+            .as_ref()
+            .map_or(false, |live_kit| live_kit.muted_by_user)
+    }
+
    pub fn is_speaking(&self) -> bool {
        self.live_kit
            .as_ref()
--- a/crates/call/src/macos/room.rs
+++ b/crates/call/src/macos/room.rs
@@ -1307,6 +1307,12 @@ impl Room {
        })
    }

+    pub fn muted_by_user(&self) -> bool {
+        self.live_kit
+            .as_ref()
+            .map_or(false, |live_kit| live_kit.muted_by_user)
+    }
+
    pub fn is_speaking(&self) -> bool {
        self.live_kit
            .as_ref()
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -310,6 +310,9 @@ impl Server {
            .add_request_handler(forward_read_only_project_request::<proto::OpenBufferByPath>)
            .add_request_handler(forward_read_only_project_request::<proto::GitBranches>)
            .add_request_handler(forward_read_only_project_request::<proto::GetStagedText>)
+            .add_request_handler(
+                forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
+            )
            .add_request_handler(forward_mutating_project_request::<proto::UpdateGitBranch>)
            .add_request_handler(forward_mutating_project_request::<proto::GetCompletions>)
            .add_request_handler(
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -994,10 +994,12 @@ async fn test_language_server_statuses(cx_a: &mut TestAppContext, cx_b: &mut Tes
            }),
        )
        .await;
-    let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
+    let (project_a, _) = client_a.build_local_project("/dir", cx_a).await;

    let _buffer_a = project_a
-        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx))
+        .update(cx_a, |p, cx| {
+            p.open_local_buffer_with_lsp("/dir/main.rs", cx)
+        })
        .await
        .unwrap();

@@ -1587,7 +1589,6 @@ async fn test_mutual_editor_inlay_hint_cache_update(
        })
        .await
        .unwrap();
-    let fake_language_server = fake_language_servers.next().await.unwrap();
    let editor_a = workspace_a
        .update(cx_a, |workspace, cx| {
            workspace.open_path((worktree_id, "main.rs"), None, true, cx)
@@ -1597,6 +1598,8 @@ async fn test_mutual_editor_inlay_hint_cache_update(
        .downcast::<Editor>()
        .unwrap();

+    let fake_language_server = fake_language_servers.next().await.unwrap();
+
    // Set up the language server to return an additional inlay hint on each request.
    let edits_made = Arc::new(AtomicUsize::new(0));
    let closure_edits_made = Arc::clone(&edits_made);
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -3891,13 +3891,7 @@ async fn test_collaborating_with_diagnostics(
    // Cause the language server to start.
    let _buffer = project_a
        .update(cx_a, |project, cx| {
-            project.open_buffer(
-                ProjectPath {
-                    worktree_id,
-                    path: Path::new("other.rs").into(),
-                },
-                cx,
-            )
+            project.open_local_buffer_with_lsp("/a/other.rs", cx)
        })
        .await
        .unwrap();
@@ -4176,7 +4170,9 @@ async fn test_collaborating_with_lsp_progress_updates_and_diagnostics_ordering(
    // Join the project as client B and open all three files.
    let project_b = client_b.join_remote_project(project_id, cx_b).await;
    let guest_buffers = futures::future::try_join_all(file_names.iter().map(|file_name| {
-        project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, file_name), cx))
+        project_b.update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, file_name), cx)
+        })
    }))
    .await
    .unwrap();
@@ -4230,7 +4226,7 @@ async fn test_collaborating_with_lsp_progress_updates_and_diagnostics_ordering(
            cx.subscribe(&project_b, move |_, _, event, cx| {
                if let project::Event::DiskBasedDiagnosticsFinished { .. } = event {
                    disk_based_diagnostics_finished.store(true, SeqCst);
-                    for buffer in &guest_buffers {
+                    for (buffer, _) in &guest_buffers {
                        assert_eq!(
                            buffer
                                .read(cx)
@@ -4351,7 +4347,6 @@ async fn test_formatting_buffer(
    cx_a: &mut TestAppContext,
    cx_b: &mut TestAppContext,
 ) {
-    executor.allow_parking();
    let mut server = TestServer::start(executor.clone()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -4379,10 +4374,16 @@ async fn test_formatting_buffer(
        .await
        .unwrap();
    let project_b = client_b.join_remote_project(project_id, cx_b).await;
+    let lsp_store_b = project_b.update(cx_b, |p, _| p.lsp_store());

-    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
-    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
+    let buffer_b = project_b
+        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx))
+        .await
+        .unwrap();

+    let _handle = lsp_store_b.update(cx_b, |lsp_store, cx| {
+        lsp_store.register_buffer_with_language_servers(&buffer_b, cx)
+    });
    let fake_language_server = fake_language_servers.next().await.unwrap();
    fake_language_server.handle_request::<lsp::request::Formatting, _, _>(|_, _| async move {
        Ok(Some(vec![
@@ -4431,6 +4432,8 @@ async fn test_formatting_buffer(
            });
        });
    });
+
+    executor.allow_parking();
    project_b
        .update(cx_b, |project, cx| {
            project.format(
@@ -4503,8 +4506,12 @@ async fn test_prettier_formatting_buffer(
        .await
        .unwrap();
    let project_b = client_b.join_remote_project(project_id, cx_b).await;
-    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.ts"), cx));
-    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
+    let (buffer_b, _) = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "a.ts"), cx)
+        })
+        .await
+        .unwrap();

    cx_a.update(|cx| {
        SettingsStore::update_global(cx, |store, cx| {
@@ -4620,8 +4627,12 @@ async fn test_definition(
    let project_b = client_b.join_remote_project(project_id, cx_b).await;

    // Open the file on client B.
-    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
-    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
+    let (buffer_b, _handle) = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "a.rs"), cx)
+        })
+        .await
+        .unwrap();

    // Request the definition of a symbol as the guest.
    let fake_language_server = fake_language_servers.next().await.unwrap();
@@ -4765,8 +4776,12 @@ async fn test_references(
    let project_b = client_b.join_remote_project(project_id, cx_b).await;

    // Open the file on client B.
-    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "one.rs"), cx));
-    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
+    let (buffer_b, _handle) = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "one.rs"), cx)
+        })
+        .await
+        .unwrap();

    // Request references to a symbol as the guest.
    let fake_language_server = fake_language_servers.next().await.unwrap();
@@ -5012,8 +5027,12 @@ async fn test_document_highlights(
    let project_b = client_b.join_remote_project(project_id, cx_b).await;

    // Open the file on client B.
-    let open_b = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx));
-    let buffer_b = cx_b.executor().spawn(open_b).await.unwrap();
+    let (buffer_b, _handle) = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "main.rs"), cx)
+        })
+        .await
+        .unwrap();

    // Request document highlights as the guest.
    let fake_language_server = fake_language_servers.next().await.unwrap();
@@ -5130,8 +5149,12 @@ async fn test_lsp_hover(
    let project_b = client_b.join_remote_project(project_id, cx_b).await;

    // Open the file as the guest
-    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx));
-    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
+    let (buffer_b, _handle) = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "main.rs"), cx)
+        })
+        .await
+        .unwrap();

    let mut servers_with_hover_requests = HashMap::default();
    for i in 0..language_server_names.len() {
@@ -5306,9 +5329,12 @@ async fn test_project_symbols(
    let project_b = client_b.join_remote_project(project_id, cx_b).await;

    // Cause the language server to start.
-    let open_buffer_task =
-        project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "one.rs"), cx));
-    let _buffer = cx_b.executor().spawn(open_buffer_task).await.unwrap();
+    let _buffer = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "one.rs"), cx)
+        })
+        .await
+        .unwrap();

    let fake_language_server = fake_language_servers.next().await.unwrap();
    fake_language_server.handle_request::<lsp::WorkspaceSymbolRequest, _, _>(|_, _| async move {
@@ -5400,8 +5426,12 @@ async fn test_open_buffer_while_getting_definition_pointing_to_it(
        .unwrap();
    let project_b = client_b.join_remote_project(project_id, cx_b).await;

-    let open_buffer_task = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
-    let buffer_b1 = cx_b.executor().spawn(open_buffer_task).await.unwrap();
+    let (buffer_b1, _lsp) = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "a.rs"), cx)
+        })
+        .await
+        .unwrap();

    let fake_language_server = fake_language_servers.next().await.unwrap();
    fake_language_server.handle_request::<lsp::request::GotoDefinition, _, _>(|_, _| async move {
@@ -5417,13 +5447,22 @@ async fn test_open_buffer_while_getting_definition_pointing_to_it(
    let buffer_b2;
    if rng.gen() {
        definitions = project_b.update(cx_b, |p, cx| p.definition(&buffer_b1, 23, cx));
-        buffer_b2 = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "b.rs"), cx));
+        (buffer_b2, _) = project_b
+            .update(cx_b, |p, cx| {
+                p.open_buffer_with_lsp((worktree_id, "b.rs"), cx)
+            })
+            .await
+            .unwrap();
    } else {
-        buffer_b2 = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "b.rs"), cx));
+        (buffer_b2, _) = project_b
+            .update(cx_b, |p, cx| {
+                p.open_buffer_with_lsp((worktree_id, "b.rs"), cx)
+            })
+            .await
+            .unwrap();
        definitions = project_b.update(cx_b, |p, cx| p.definition(&buffer_b1, 23, cx));
    }

-    let buffer_b2 = buffer_b2.await.unwrap();
    let definitions = definitions.await.unwrap();
    assert_eq!(definitions.len(), 1);
    assert_eq!(definitions[0].target.buffer, buffer_b2);
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -426,8 +426,10 @@ async fn test_ssh_collaboration_formatting_with_prettier(
    executor.run_until_parked();

    // Opens the buffer and formats it
-    let buffer_b = project_b
-        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.ts"), cx))
+    let (buffer_b, _handle) = project_b
+        .update(cx_b, |p, cx| {
+            p.open_buffer_with_lsp((worktree_id, "a.ts"), cx)
+        })
        .await
        .expect("user B opens buffer for formatting");

--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -841,7 +841,7 @@ impl CollabPanel {
        ListItem::new(SharedString::from(user.github_login.clone()))
            .start_slot(Avatar::new(user.avatar_uri.clone()))
            .child(Label::new(user.github_login.clone()))
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .end_slot(if is_pending {
                Label::new("Calling").color(Color::Muted).into_any_element()
            } else if is_current_user {
@@ -894,7 +894,7 @@ impl CollabPanel {
        .into();

        ListItem::new(project_id as usize)
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .on_click(cx.listener(move |this, _, cx| {
                this.workspace
                    .update(cx, |workspace, cx| {
@@ -924,7 +924,7 @@ impl CollabPanel {
        let id = peer_id.map_or(usize::MAX, |id| id.as_u64() as usize);

        ListItem::new(("screen", id))
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .start_slot(
                h_flex()
                    .gap_1()
@@ -964,7 +964,7 @@ impl CollabPanel {
        let channel_store = self.channel_store.read(cx);
        let has_channel_buffer_changed = channel_store.has_channel_buffer_changed(channel_id);
        ListItem::new("channel-notes")
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .on_click(cx.listener(move |this, _, cx| {
                this.open_channel_notes(channel_id, cx);
            }))
@@ -996,7 +996,7 @@ impl CollabPanel {
        let channel_store = self.channel_store.read(cx);
        let has_messages_notification = channel_store.has_new_messages(channel_id);
        ListItem::new("channel-chat")
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .on_click(cx.listener(move |this, _, cx| {
                this.join_channel_chat(channel_id, cx);
            }))
@@ -2253,7 +2253,7 @@ impl CollabPanel {
                })
                .inset(true)
                .end_slot::<AnyElement>(button)
-                .selected(is_selected),
+                .toggle_state(is_selected),
        )
    }

@@ -2270,7 +2270,7 @@ impl CollabPanel {
        let item = ListItem::new(github_login.clone())
            .indent_level(1)
            .indent_step_size(px(20.))
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .child(
                h_flex()
                    .w_full()
@@ -2381,7 +2381,7 @@ impl CollabPanel {
        ListItem::new(github_login.clone())
            .indent_level(1)
            .indent_step_size(px(20.))
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .child(
                h_flex()
                    .w_full()
@@ -2425,7 +2425,7 @@ impl CollabPanel {
        ];

        ListItem::new(("channel-invite", channel.id.0 as usize))
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .child(
                h_flex()
                    .w_full()
@@ -2448,7 +2448,7 @@ impl CollabPanel {
        ListItem::new("contact-placeholder")
            .child(Icon::new(IconName::Plus))
            .child(Label::new("Add a Contact"))
-            .selected(is_selected)
+            .toggle_state(is_selected)
            .on_click(cx.listener(|this, _, cx| this.toggle_contact_finder(cx)))
    }

@@ -2547,7 +2547,7 @@ impl CollabPanel {
                    // Add one level of depth for the disclosure arrow.
                    .indent_level(depth + 1)
                    .indent_step_size(px(20.))
-                    .selected(is_selected || is_active)
+                    .toggle_state(is_selected || is_active)
                    .toggle(disclosed)
                    .on_toggle(
                        cx.listener(move |this, _, cx| {
--- a/crates/collab_ui/src/collab_panel/channel_modal.rs
+++ b/crates/collab_ui/src/collab_panel/channel_modal.rs
@@ -89,15 +89,15 @@ impl ChannelModal {
        cx.notify()
    }

-    fn set_channel_visibility(&mut self, selection: &Selection, cx: &mut ViewContext<Self>) {
+    fn set_channel_visibility(&mut self, selection: &ToggleState, cx: &mut ViewContext<Self>) {
        self.channel_store.update(cx, |channel_store, cx| {
            channel_store
                .set_channel_visibility(
                    self.channel_id,
                    match selection {
-                        Selection::Unselected => ChannelVisibility::Members,
-                        Selection::Selected => ChannelVisibility::Public,
-                        Selection::Indeterminate => return,
+                        ToggleState::Unselected => ChannelVisibility::Members,
+                        ToggleState::Selected => ChannelVisibility::Public,
+                        ToggleState::Indeterminate => return,
                    },
                    cx,
                )
@@ -159,9 +159,9 @@ impl Render for ChannelModal {
                                "is-public",
                                Label::new("Public").size(LabelSize::Small),
                                if visibility == ChannelVisibility::Public {
-                                    ui::Selection::Selected
+                                    ui::ToggleState::Selected
                                } else {
-                                    ui::Selection::Unselected
+                                    ui::ToggleState::Unselected
                                },
                                cx.listener(Self::set_channel_visibility),
                            ))
@@ -386,7 +386,7 @@ impl PickerDelegate for ChannelModalDelegate {
            ListItem::new(ix)
                .inset(true)
                .spacing(ListItemSpacing::Sparse)
-                .selected(selected)
+                .toggle_state(selected)
                .start_slot(Avatar::new(user.avatar_uri.clone()))
                .child(Label::new(user.github_login.clone()))
                .end_slot(h_flex().gap_2().map(|slot| {
--- a/crates/collab_ui/src/collab_panel/contact_finder.rs
+++ b/crates/collab_ui/src/collab_panel/contact_finder.rs
@@ -151,7 +151,7 @@ impl PickerDelegate for ContactFinderDelegate {
            ListItem::new(ix)
                .inset(true)
                .spacing(ListItemSpacing::Sparse)
-                .selected(selected)
+                .toggle_state(selected)
                .start_slot(Avatar::new(user.avatar_uri.clone()))
                .child(Label::new(user.github_login.clone()))
                .end_slot::<Icon>(icon_path.map(Icon::from_path)),
--- a/crates/command_palette/src/command_palette.rs
+++ b/crates/command_palette/src/command_palette.rs
@@ -397,7 +397,7 @@ impl PickerDelegate for CommandPaletteDelegate {
            ListItem::new(ix)
                .inset(true)
                .spacing(ListItemSpacing::Sparse)
-                .selected(selected)
+                .toggle_state(selected)
                .child(
                    h_flex()
                        .w_full()
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -6,13 +6,12 @@ use anyhow::{anyhow, Result};
 use chrono::DateTime;
 use fs::Fs;
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, StreamExt};
-use gpui::{AppContext, AsyncAppContext, Global};
+use gpui::{prelude::*, AppContext, AsyncAppContext, Global};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use paths::home_dir;
 use serde::{Deserialize, Serialize};
 use settings::watch_config_file;
 use strum::EnumIter;
-use ui::Context;

 pub const COPILOT_CHAT_COMPLETION_URL: &str = "https://api.githubcopilot.com/chat/completions";
 pub const COPILOT_CHAT_AUTH_URL: &str = "https://api.github.com/copilot_internal/v2/token";
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -296,7 +296,6 @@ mod tests {
            editor.set_inline_completion_provider(Some(copilot_provider), cx)
        });

-        // When inserting, ensure autocompletion is favored over Copilot suggestions.
        cx.set_state(indoc! {"
            oneˇ
            two
@@ -323,8 +322,9 @@ mod tests {
        );
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, cx| {
+            // We want to show both: the inline completion and the completion menu
            assert!(editor.context_menu_visible());
-            assert!(!editor.has_active_inline_completion());
+            assert!(editor.has_active_inline_completion());

            // Confirming a completion inserts it and hides the context menu, without showing
            // the copilot suggestion afterwards.
@@ -338,40 +338,7 @@ mod tests {
            assert_eq!(editor.display_text(cx), "one.completion_a\ntwo\nthree\n");
        });

-        // Ensure Copilot suggestions are shown right away if no autocompletion is available.
-        cx.set_state(indoc! {"
-            oneˇ
-            two
-            three
-        "});
-        cx.simulate_keystroke(".");
-        drop(handle_completion_request(
-            &mut cx,
-            indoc! {"
-                one.|<>
-                two
-                three
-            "},
-            vec![],
-        ));
-        handle_copilot_completion_request(
-            &copilot_lsp,
-            vec![crate::request::Completion {
-                text: "one.copilot1".into(),
-                range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 4)),
-                ..Default::default()
-            }],
-            vec![],
-        );
-        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
-        cx.update_editor(|editor, cx| {
-            assert!(!editor.context_menu_visible());
-            assert!(editor.has_active_inline_completion());
-            assert_eq!(editor.display_text(cx), "one.copilot1\ntwo\nthree\n");
-            assert_eq!(editor.text(cx), "one.\ntwo\nthree\n");
-        });
-
-        // Reset editor, and ensure autocompletion is still favored over Copilot suggestions.
+        // Reset editor and test that accepting completions works
        cx.set_state(indoc! {"
            oneˇ
            two
@@ -399,17 +366,12 @@ mod tests {
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, cx| {
            assert!(editor.context_menu_visible());
-            assert!(!editor.has_active_inline_completion());
-
-            // When hiding the context menu, the Copilot suggestion becomes visible.
-            editor.cancel(&Default::default(), cx);
-            assert!(!editor.context_menu_visible());
            assert!(editor.has_active_inline_completion());
            assert_eq!(editor.display_text(cx), "one.copilot1\ntwo\nthree\n");
            assert_eq!(editor.text(cx), "one.\ntwo\nthree\n");
        });

-        // Ensure existing completion is interpolated when inserting again.
+        // Ensure existing inline completion is interpolated when inserting again.
        cx.simulate_keystroke("c");
        executor.run_until_parked();
        cx.update_editor(|editor, cx| {
@@ -880,7 +842,7 @@ mod tests {
        cx.update_editor(|editor, cx| editor.next_inline_completion(&Default::default(), cx));
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, cx| {
-            assert!(!editor.context_menu_visible(), "Even there are some completions available, those are not triggered when active copilot suggestion is present");
+            assert!(!editor.context_menu_visible());
            assert!(editor.has_active_inline_completion());
            assert_eq!(editor.display_text(cx), "one\ntwo.foo()\nthree\n");
            assert_eq!(editor.text(cx), "one\ntw\nthree\n");
@@ -934,15 +896,9 @@ mod tests {
        );
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, cx| {
-            assert!(
-                editor.context_menu_visible(),
-                "On completion trigger input, the completions should be fetched and visible"
-            );
-            assert!(
-                !editor.has_active_inline_completion(),
-                "On completion trigger input, copilot suggestion should be dismissed"
-            );
-            assert_eq!(editor.display_text(cx), "one\ntwo.\nthree\n");
+            assert!(editor.context_menu_visible());
+            assert!(editor.has_active_inline_completion(),);
+            assert_eq!(editor.display_text(cx), "one\ntwo.foo()\nthree\n");
            assert_eq!(editor.text(cx), "one\ntwo.\nthree\n");
        });
    }
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -251,6 +251,7 @@ gpui::actions!(
        DisplayCursorNames,
        DuplicateLineDown,
        DuplicateLineUp,
+        DuplicateSelection,
        ExpandAllHunkDiffs,
        ExpandMacroRecursively,
        FindAllReferences,
--- a/crates/editor/src/code_context_menus.rs
+++ b/crates/editor/src/code_context_menus.rs
@@ -1,9 +1,4 @@
-use std::{
-    cell::Cell,
-    cmp::{min, Reverse},
-    ops::Range,
-    sync::Arc,
-};
+use std::{cell::Cell, cmp::Reverse, ops::Range, sync::Arc};

 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
@@ -16,14 +11,13 @@ use language::{CodeLabel, Documentation};
 use lsp::LanguageServerId;
 use multi_buffer::{Anchor, ExcerptId};
 use ordered_float::OrderedFloat;
-use parking_lot::{Mutex, RwLock};
+use parking_lot::RwLock;
 use project::{CodeAction, Completion, TaskSourceKind};
-use std::iter;
 use task::ResolvedTask;
 use ui::{
    h_flex, ActiveTheme as _, Color, FluentBuilder as _, InteractiveElement as _, IntoElement,
-    Label, LabelCommon as _, LabelSize, ListItem, ParentElement as _, Popover, Selectable as _,
-    StatefulInteractiveElement as _, Styled, StyledExt as _,
+    Label, LabelCommon as _, LabelSize, ListItem, ParentElement as _, Popover,
+    StatefulInteractiveElement as _, Styled, StyledExt as _, Toggleable as _,
 };
 use util::ResultExt as _;
 use workspace::Workspace;
@@ -151,7 +145,6 @@ pub struct CompletionsMenu {
    resolve_completions: bool,
    pub aside_was_displayed: Cell<bool>,
    show_completion_documentation: bool,
-    last_rendered_range: Arc<Mutex<Option<Range<usize>>>>,
 }

 impl CompletionsMenu {
@@ -180,6 +173,7 @@ impl CompletionsMenu {
            sort_completions,
            initial_position,
            buffer,
+            show_completion_documentation,
            completions: Arc::new(RwLock::new(completions)),
            match_candidates,
            matches: Vec::new().into(),
@@ -187,8 +181,6 @@ impl CompletionsMenu {
            scroll_handle: UniformListScrollHandle::new(),
            resolve_completions: true,
            aside_was_displayed: Cell::new(aside_was_displayed),
-            show_completion_documentation,
-            last_rendered_range: Arc::new(Mutex::new(None)),
        }
    }

@@ -244,7 +236,6 @@ impl CompletionsMenu {
            resolve_completions: false,
            aside_was_displayed: Cell::new(false),
            show_completion_documentation: false,
-            last_rendered_range: Arc::new(Mutex::new(None)),
        }
    }

@@ -253,7 +244,11 @@ impl CompletionsMenu {
        provider: Option<&dyn CompletionProvider>,
        cx: &mut ViewContext<Editor>,
    ) {
-        self.update_selection_index(0, provider, cx);
+        self.selected_item = 0;
+        self.scroll_handle
+            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.resolve_selected_completion(provider, cx);
+        cx.notify();
    }

    fn select_prev(
@@ -261,7 +256,15 @@ impl CompletionsMenu {
        provider: Option<&dyn CompletionProvider>,
        cx: &mut ViewContext<Editor>,
    ) {
-        self.update_selection_index(self.prev_match_index(), provider, cx);
+        if self.selected_item > 0 {
+            self.selected_item -= 1;
+        } else {
+            self.selected_item = self.matches.len() - 1;
+        }
+        self.scroll_handle
+            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.resolve_selected_completion(provider, cx);
+        cx.notify();
    }

    fn select_next(
@@ -269,7 +272,15 @@ impl CompletionsMenu {
        provider: Option<&dyn CompletionProvider>,
        cx: &mut ViewContext<Editor>,
    ) {
-        self.update_selection_index(self.next_match_index(), provider, cx);
+        if self.selected_item + 1 < self.matches.len() {
+            self.selected_item += 1;
+        } else {
+            self.selected_item = 0;
+        }
+        self.scroll_handle
+            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.resolve_selected_completion(provider, cx);
+        cx.notify();
    }

    fn select_last(
@@ -277,41 +288,14 @@ impl CompletionsMenu {
        provider: Option<&dyn CompletionProvider>,
        cx: &mut ViewContext<Editor>,
    ) {
-        self.update_selection_index(self.matches.len() - 1, provider, cx);
+        self.selected_item = self.matches.len() - 1;
+        self.scroll_handle
+            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.resolve_selected_completion(provider, cx);
+        cx.notify();
    }

-    fn update_selection_index(
-        &mut self,
-        match_index: usize,
-        provider: Option<&dyn CompletionProvider>,
-        cx: &mut ViewContext<Editor>,
-    ) {
-        if self.selected_item != match_index {
-            self.selected_item = match_index;
-            self.scroll_handle
-                .scroll_to_item(self.selected_item, ScrollStrategy::Top);
-            self.resolve_visible_completions(provider, cx);
-            cx.notify();
-        }
-    }
-
-    fn prev_match_index(&self) -> usize {
-        if self.selected_item > 0 {
-            self.selected_item - 1
-        } else {
-            self.matches.len() - 1
-        }
-    }
-
-    fn next_match_index(&self) -> usize {
-        if self.selected_item + 1 < self.matches.len() {
-            self.selected_item + 1
-        } else {
-            0
-        }
-    }
-
-    pub fn resolve_visible_completions(
+    pub fn resolve_selected_completion(
        &mut self,
        provider: Option<&dyn CompletionProvider>,
        cx: &mut ViewContext<Editor>,
@@ -323,59 +307,10 @@ impl CompletionsMenu {
            return;
        };

-        // Attempt to resolve completions for every item that will be displayed. This matters
-        // because single line documentation may be displayed inline with the completion.
-        //
-        // When navigating to the very beginning or end of completions, `last_rendered_range` may
-        // have no overlap with the completions that will be displayed, so instead use a range based
-        // on the last rendered count.
-        const APPROXIMATE_VISIBLE_COUNT: usize = 12;
-        let last_rendered_range = self.last_rendered_range.lock().clone();
-        let visible_count = last_rendered_range
-            .clone()
-            .map_or(APPROXIMATE_VISIBLE_COUNT, |range| range.count());
-        let matches_range = if self.selected_item == 0 {
-            0..min(visible_count, self.matches.len())
-        } else if self.selected_item == self.matches.len() - 1 {
-            self.matches.len().saturating_sub(visible_count)..self.matches.len()
-        } else {
-            last_rendered_range.unwrap_or_else(|| self.selected_item..self.selected_item + 1)
-        };
-
-        // Expand the range to resolve more completions than are predicted to be visible, to reduce
-        // jank on navigation.
-        const EXTRA_TO_RESOLVE: usize = 4;
-        let matches_indices = util::iterate_expanded_and_wrapped_usize_range(
-            matches_range.clone(),
-            EXTRA_TO_RESOLVE,
-            EXTRA_TO_RESOLVE,
-            self.matches.len(),
-        );
-
-        // Avoid work by sometimes filtering out completions that already have documentation.
-        // This filtering doesn't happen if the completions are currently being updated.
-        let candidate_ids = matches_indices.map(|i| self.matches[i].candidate_id);
-        let candidate_ids = match self.completions.try_read() {
-            None => candidate_ids.collect::<Vec<usize>>(),
-            Some(completions) => candidate_ids
-                .filter(|i| completions[*i].documentation.is_none())
-                .collect::<Vec<usize>>(),
-        };
-
-        // Current selection is always resolved even if it already has documentation, to handle
-        // out-of-spec language servers that return more results later.
-        let selected_candidate_id = self.matches[self.selected_item].candidate_id;
-        let candidate_ids = iter::once(selected_candidate_id)
-            .chain(
-                candidate_ids
-                    .into_iter()
-                    .filter(|id| *id != selected_candidate_id),
-            )
-            .collect::<Vec<usize>>();
-
+        let completion_index = self.matches[self.selected_item].candidate_id;
        let resolve_task = provider.resolve_completions(
            self.buffer.clone(),
-            candidate_ids,
+            vec![completion_index],
            self.completions.clone(),
            cx,
        );
@@ -471,14 +406,11 @@ impl CompletionsMenu {
                .occlude()
        });

-        let last_rendered_range = self.last_rendered_range.clone();
-
        let list = uniform_list(
            cx.view().clone(),
            "completions",
            matches.len(),
            move |_editor, range, cx| {
-                last_rendered_range.lock().replace(range.clone());
                let start_ix = range.start;
                let completions_guard = completions.read();

@@ -541,7 +473,7 @@ impl CompletionsMenu {
                        div().min_w(px(220.)).max_w(px(540.)).child(
                            ListItem::new(mat.candidate_id)
                                .inset(true)
-                                .selected(item_ix == selected_item)
+                                .toggle_state(item_ix == selected_item)
                                .on_click(cx.listener(move |editor, _event, cx| {
                                    cx.stop_propagation();
                                    if let Some(task) = editor.confirm_completion(
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -535,10 +535,16 @@ pub(crate) struct Highlights<'a> {
    pub styles: HighlightStyles,
 }

+#[derive(Clone, Copy, Debug)]
+pub struct InlineCompletionStyles {
+    pub insertion: HighlightStyle,
+    pub whitespace: HighlightStyle,
+}
+
 #[derive(Default, Debug, Clone, Copy)]
 pub struct HighlightStyles {
    pub inlay_hint: Option<HighlightStyle>,
-    pub suggestion: Option<HighlightStyle>,
+    pub inline_completion: Option<InlineCompletionStyles>,
 }

 #[derive(Clone)]
@@ -859,7 +865,7 @@ impl DisplaySnapshot {
            language_aware,
            HighlightStyles {
                inlay_hint: Some(editor_style.inlay_hints_style),
-                suggestion: Some(editor_style.suggestions_style),
+                inline_completion: Some(editor_style.inline_completion_styles),
            },
        )
        .flat_map(|chunk| {
--- a/crates/editor/src/display_map/inlay_map.rs
+++ b/crates/editor/src/display_map/inlay_map.rs
@@ -62,9 +62,9 @@ impl Inlay {
        }
    }

-    pub fn suggestion<T: Into<Rope>>(id: usize, position: Anchor, text: T) -> Self {
+    pub fn inline_completion<T: Into<Rope>>(id: usize, position: Anchor, text: T) -> Self {
        Self {
-            id: InlayId::Suggestion(id),
+            id: InlayId::InlineCompletion(id),
            position,
            text: text.into(),
        }
@@ -346,7 +346,15 @@ impl<'a> Iterator for InlayChunks<'a> {
                }

                let mut highlight_style = match inlay.id {
-                    InlayId::Suggestion(_) => self.highlight_styles.suggestion,
+                    InlayId::InlineCompletion(_) => {
+                        self.highlight_styles.inline_completion.map(|s| {
+                            if inlay.text.chars().all(|c| c.is_whitespace()) {
+                                s.whitespace
+                            } else {
+                                s.insertion
+                            }
+                        })
+                    }
                    InlayId::Hint(_) => self.highlight_styles.inlay_hint,
                };
                let next_inlay_highlight_endpoint;
@@ -693,7 +701,7 @@ impl InlayMap {
                let inlay_id = if i % 2 == 0 {
                    InlayId::Hint(post_inc(next_inlay_id))
                } else {
-                    InlayId::Suggestion(post_inc(next_inlay_id))
+                    InlayId::InlineCompletion(post_inc(next_inlay_id))
                };
                log::info!(
                    "creating inlay {:?} at buffer offset {} with bias {:?} and text {:?}",
@@ -1389,7 +1397,7 @@ mod tests {
                    text: "|123|".into(),
                },
                Inlay {
-                    id: InlayId::Suggestion(post_inc(&mut next_inlay_id)),
+                    id: InlayId::InlineCompletion(post_inc(&mut next_inlay_id)),
                    position: buffer.read(cx).snapshot(cx).anchor_after(3),
                    text: "|456|".into(),
                },
@@ -1605,7 +1613,7 @@ mod tests {
                    text: "|456|".into(),
                },
                Inlay {
-                    id: InlayId::Suggestion(post_inc(&mut next_inlay_id)),
+                    id: InlayId::InlineCompletion(post_inc(&mut next_inlay_id)),
                    position: buffer.read(cx).snapshot(cx).anchor_before(7),
                    text: "\n|567|\n".into(),
                },
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -129,10 +129,10 @@ use multi_buffer::{
 };
 use parking_lot::RwLock;
 use project::{
-    lsp_store::{FormatTarget, FormatTrigger},
+    lsp_store::{FormatTarget, FormatTrigger, OpenLspBufferHandle},
    project_settings::{GitGutterSetting, ProjectSettings},
    CodeAction, Completion, CompletionIntent, DocumentHighlight, InlayHint, Location, LocationLink,
-    Project, ProjectItem, ProjectTransaction, TaskSourceKind,
+    LspStore, Project, ProjectItem, ProjectTransaction, TaskSourceKind,
 };
 use rand::prelude::*;
 use rpc::{proto::*, ErrorExt};
@@ -176,7 +176,7 @@ use workspace::{
 };
 use workspace::{Item as WorkspaceItem, OpenInTerminal, OpenTerminal, TabBarSettings, Toast};

-use crate::hover_links::find_url;
+use crate::hover_links::{find_url, find_url_from_range};
 use crate::signature_help::{SignatureHelpHiddenBy, SignatureHelpState};

 pub const FILE_HEADER_HEIGHT: u32 = 2;
@@ -190,8 +190,6 @@ const MAX_SELECTION_HISTORY_LEN: usize = 1024;
 pub(crate) const CURSORS_VISIBLE_FOR: Duration = Duration::from_millis(2000);
 #[doc(hidden)]
 pub const CODE_ACTIONS_DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(250);
-#[doc(hidden)]
-pub const DOCUMENT_HIGHLIGHTS_DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(75);

 pub(crate) const FORMAT_TIMEOUT: Duration = Duration::from_secs(2);
 pub(crate) const SCROLL_CENTER_TOP_BOTTOM_DEBOUNCE_TIMEOUT: Duration = Duration::from_secs(1);
@@ -261,14 +259,14 @@ pub fn render_parsed_markdown(

 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub(crate) enum InlayId {
-    Suggestion(usize),
+    InlineCompletion(usize),
    Hint(usize),
 }

 impl InlayId {
    fn id(&self) -> usize {
        match self {
-            Self::Suggestion(id) => *id,
+            Self::InlineCompletion(id) => *id,
            Self::Hint(id) => *id,
        }
    }
@@ -407,7 +405,7 @@ pub struct EditorStyle {
    pub syntax: Arc<SyntaxTheme>,
    pub status: StatusColors,
    pub inlay_hints_style: HighlightStyle,
-    pub suggestions_style: HighlightStyle,
+    pub inline_completion_styles: InlineCompletionStyles,
    pub unnecessary_code_fade: f32,
 }

@@ -424,7 +422,10 @@ impl Default for EditorStyle {
            // style and retrieve them directly from the theme.
            status: StatusColors::dark(),
            inlay_hints_style: HighlightStyle::default(),
-            suggestions_style: HighlightStyle::default(),
+            inline_completion_styles: InlineCompletionStyles {
+                insertion: HighlightStyle::default(),
+                whitespace: HighlightStyle::default(),
+            },
            unnecessary_code_fade: Default::default(),
        }
    }
@@ -442,6 +443,19 @@ pub fn make_inlay_hints_style(cx: &WindowContext) -> HighlightStyle {
    }
 }

+pub fn make_suggestion_styles(cx: &WindowContext) -> InlineCompletionStyles {
+    InlineCompletionStyles {
+        insertion: HighlightStyle {
+            color: Some(cx.theme().status().predictive),
+            ..HighlightStyle::default()
+        },
+        whitespace: HighlightStyle {
+            background_color: Some(cx.theme().status().created_background),
+            ..HighlightStyle::default()
+        },
+    }
+}
+
 type CompletionId = usize;

 enum InlineCompletion {
@@ -663,6 +677,7 @@ pub struct Editor {
    focused_block: Option<FocusedBlock>,
    next_scroll_position: NextScrollCursorCenterTopBottom,
    addons: HashMap<TypeId, Box<dyn Addon>>,
+    registered_buffers: HashMap<BufferId, OpenLspBufferHandle>,
    _scroll_cursor_center_top_bottom_task: Task<()>,
 }

@@ -1308,6 +1323,7 @@ impl Editor {
            focused_block: None,
            next_scroll_position: NextScrollCursorCenterTopBottom::default(),
            addons: HashMap::default(),
+            registered_buffers: HashMap::default(),
            _scroll_cursor_center_top_bottom_task: Task::ready(()),
            text_style_refinement: None,
        };
@@ -1325,6 +1341,17 @@ impl Editor {
                this.git_blame_inline_enabled = true;
                this.start_git_blame_inline(false, cx);
            }
+
+            if let Some(buffer) = buffer.read(cx).as_singleton() {
+                if let Some(project) = this.project.as_ref() {
+                    let lsp_store = project.read(cx).lsp_store();
+                    let handle = lsp_store.update(cx, |lsp_store, cx| {
+                        lsp_store.register_buffer_with_language_servers(&buffer, cx)
+                    });
+                    this.registered_buffers
+                        .insert(buffer.read(cx).remote_id(), handle);
+                }
+            }
        }

        this.report_editor_event("open", None, cx);
@@ -1391,6 +1418,15 @@ impl Editor {
            key_context.add("inline_completion");
        }

+        if !self
+            .selections
+            .disjoint
+            .iter()
+            .all(|selection| selection.start == selection.end)
+        {
+            key_context.add("selection");
+        }
+
        key_context
    }

@@ -1635,6 +1671,22 @@ impl Editor {
        self.collapse_matches = collapse_matches;
    }

+    pub fn register_buffers_with_language_servers(&mut self, cx: &mut ViewContext<Self>) {
+        let buffers = self.buffer.read(cx).all_buffers();
+        let Some(lsp_store) = self.lsp_store(cx) else {
+            return;
+        };
+        lsp_store.update(cx, |lsp_store, cx| {
+            for buffer in buffers {
+                self.registered_buffers
+                    .entry(buffer.read(cx).remote_id())
+                    .or_insert_with(|| {
+                        lsp_store.register_buffer_with_language_servers(&buffer, cx)
+                    });
+            }
+        })
+    }
+
    pub fn range_for_match<T: std::marker::Copy>(&self, range: &Range<T>) -> Range<T> {
        if self.collapse_matches {
            return range.start..range.start;
@@ -3684,19 +3736,16 @@ impl Editor {

                    if editor.focus_handle.is_focused(cx) && menu.is_some() {
                        let mut menu = menu.unwrap();
-                        menu.resolve_visible_completions(editor.completion_provider.as_deref(), cx);
+                        menu.resolve_selected_completion(editor.completion_provider.as_deref(), cx);
                        *context_menu = Some(CodeContextMenu::Completions(menu));
                        drop(context_menu);
-                        editor.discard_inline_completion(false, cx);
                        cx.notify();
                    } else if editor.completion_tasks.len() <= 1 {
                        // If there are no more completion tasks and the last menu was
                        // empty, we should hide it. If it was already hidden, we should
                        // also show the copilot completion when available.
                        drop(context_menu);
-                        if editor.hide_context_menu(cx).is_none() {
-                            editor.update_visible_inline_completion(cx);
-                        }
+                        editor.hide_context_menu(cx);
                    }
                })?;

@@ -3732,6 +3781,7 @@ impl Editor {
    ) -> Option<Task<std::result::Result<(), anyhow::Error>>> {
        use language::ToOffset as _;

+        self.discard_inline_completion(true, cx);
        let completions_menu =
            if let CodeContextMenu::Completions(menu) = self.hide_context_menu(cx)? {
                menu
@@ -4284,10 +4334,10 @@ impl Editor {
        if cursor_buffer != tail_buffer {
            return None;
        }
-
+        let debounce = EditorSettings::get_global(cx).lsp_highlight_debounce;
        self.document_highlights_task = Some(cx.spawn(|this, mut cx| async move {
            cx.background_executor()
-                .timer(DOCUMENT_HIGHLIGHTS_DEBOUNCE_TIMEOUT)
+                .timer(Duration::from_millis(debounce))
                .await;

            let highlights = if let Some(highlights) = cx
@@ -4475,6 +4525,8 @@ impl Editor {
        _: &AcceptInlineCompletion,
        cx: &mut ViewContext<Self>,
    ) {
+        self.hide_context_menu(cx);
+
        let Some(active_inline_completion) = self.active_inline_completion.as_ref() else {
            return;
        };
@@ -4629,9 +4681,7 @@ impl Editor {
        let offset_selection = selection.map(|endpoint| endpoint.to_offset(&multibuffer));
        let excerpt_id = cursor.excerpt_id;

-        if self.context_menu.read().is_some()
-            || (!self.completion_tasks.is_empty() && !self.has_active_inline_completion())
-            || !offset_selection.is_empty()
+        if !offset_selection.is_empty()
            || self
                .active_inline_completion
                .as_ref()
@@ -4701,7 +4751,7 @@ impl Editor {
            {
                let mut inlays = Vec::new();
                for (range, new_text) in &edits {
-                    let inlay = Inlay::suggestion(
+                    let inlay = Inlay::inline_completion(
                        post_inc(&mut self.next_inlay_id),
                        range.start,
                        new_text.as_str(),
@@ -4761,7 +4811,7 @@ impl Editor {
                    .shape(ui::IconButtonShape::Square)
                    .icon_size(IconSize::XSmall)
                    .icon_color(Color::Muted)
-                    .selected(is_active)
+                    .toggle_state(is_active)
                    .tooltip({
                        let focus_handle = self.focus_handle.clone();
                        move |cx| {
@@ -4938,7 +4988,7 @@ impl Editor {
            .shape(ui::IconButtonShape::Square)
            .icon_size(IconSize::XSmall)
            .icon_color(Color::Muted)
-            .selected(is_active)
+            .toggle_state(is_active)
            .on_click(cx.listener(move |editor, _e, cx| {
                editor.focus(cx);
                editor.toggle_code_actions(
@@ -4978,11 +5028,7 @@ impl Editor {
    fn hide_context_menu(&mut self, cx: &mut ViewContext<Self>) -> Option<CodeContextMenu> {
        cx.notify();
        self.completion_tasks.clear();
-        let context_menu = self.context_menu.write().take();
-        if context_menu.is_some() {
-            self.update_visible_inline_completion(cx);
-        }
-        context_menu
+        self.context_menu.write().take()
    }

    fn show_snippet_choices(
@@ -6089,7 +6135,7 @@ impl Editor {
        });
    }

-    pub fn duplicate_line(&mut self, upwards: bool, cx: &mut ViewContext<Self>) {
+    pub fn duplicate(&mut self, upwards: bool, whole_lines: bool, cx: &mut ViewContext<Self>) {
        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
        let buffer = &display_map.buffer_snapshot;
        let selections = self.selections.all::<Point>(cx);
@@ -6097,36 +6143,44 @@ impl Editor {
        let mut edits = Vec::new();
        let mut selections_iter = selections.iter().peekable();
        while let Some(selection) = selections_iter.next() {
-            // Avoid duplicating the same lines twice.
            let mut rows = selection.spanned_rows(false, &display_map);
-
-            while let Some(next_selection) = selections_iter.peek() {
-                let next_rows = next_selection.spanned_rows(false, &display_map);
-                if next_rows.start < rows.end {
-                    rows.end = next_rows.end;
-                    selections_iter.next().unwrap();
-                } else {
-                    break;
+            // duplicate line-wise
+            if whole_lines || selection.start == selection.end {
+                // Avoid duplicating the same lines twice.
+                while let Some(next_selection) = selections_iter.peek() {
+                    let next_rows = next_selection.spanned_rows(false, &display_map);
+                    if next_rows.start < rows.end {
+                        rows.end = next_rows.end;
+                        selections_iter.next().unwrap();
+                    } else {
+                        break;
+                    }
                }
-            }

-            // Copy the text from the selected row region and splice it either at the start
-            // or end of the region.
-            let start = Point::new(rows.start.0, 0);
-            let end = Point::new(
-                rows.end.previous_row().0,
-                buffer.line_len(rows.end.previous_row()),
-            );
-            let text = buffer
-                .text_for_range(start..end)
-                .chain(Some("\n"))
-                .collect::<String>();
-            let insert_location = if upwards {
-                Point::new(rows.end.0, 0)
+                // Copy the text from the selected row region and splice it either at the start
+                // or end of the region.
+                let start = Point::new(rows.start.0, 0);
+                let end = Point::new(
+                    rows.end.previous_row().0,
+                    buffer.line_len(rows.end.previous_row()),
+                );
+                let text = buffer
+                    .text_for_range(start..end)
+                    .chain(Some("\n"))
+                    .collect::<String>();
+                let insert_location = if upwards {
+                    Point::new(rows.end.0, 0)
+                } else {
+                    start
+                };
+                edits.push((insert_location..insert_location, text));
            } else {
-                start
-            };
-            edits.push((insert_location..insert_location, text));
+                // duplicate character-wise
+                let start = selection.start;
+                let end = selection.end;
+                let text = buffer.text_for_range(start..end).collect::<String>();
+                edits.push((selection.end..selection.end, text));
+            }
        }

        self.transact(cx, |this, cx| {
@@ -6139,11 +6193,15 @@ impl Editor {
    }

    pub fn duplicate_line_up(&mut self, _: &DuplicateLineUp, cx: &mut ViewContext<Self>) {
-        self.duplicate_line(true, cx);
+        self.duplicate(true, true, cx);
    }

    pub fn duplicate_line_down(&mut self, _: &DuplicateLineDown, cx: &mut ViewContext<Self>) {
-        self.duplicate_line(false, cx);
+        self.duplicate(false, true, cx);
+    }
+
+    pub fn duplicate_selection(&mut self, _: &DuplicateSelection, cx: &mut ViewContext<Self>) {
+        self.duplicate(false, false, cx);
    }

    pub fn move_line_up(&mut self, _: &MoveLineUp, cx: &mut ViewContext<Self>) {
@@ -9241,23 +9299,42 @@ impl Editor {
    }

    pub fn open_url(&mut self, _: &OpenUrl, cx: &mut ViewContext<Self>) {
-        let position = self.selections.newest_anchor().head();
-        let Some((buffer, buffer_position)) =
-            self.buffer.read(cx).text_anchor_for_position(position, cx)
+        let selection = self.selections.newest_anchor();
+        let head = selection.head();
+        let tail = selection.tail();
+
+        let Some((buffer, start_position)) =
+            self.buffer.read(cx).text_anchor_for_position(head, cx)
        else {
            return;
        };

-        cx.spawn(|editor, mut cx| async move {
-            if let Some((_, url)) = find_url(&buffer, buffer_position, cx.clone()) {
+        let end_position = if head != tail {
+            let Some((_, pos)) = self.buffer.read(cx).text_anchor_for_position(tail, cx) else {
+                return;
+            };
+            Some(pos)
+        } else {
+            None
+        };
+
+        let url_finder = cx.spawn(|editor, mut cx| async move {
+            let url = if let Some(end_pos) = end_position {
+                find_url_from_range(&buffer, start_position..end_pos, cx.clone())
+            } else {
+                find_url(&buffer, start_position, cx.clone()).map(|(_, url)| url)
+            };
+
+            if let Some(url) = url {
                editor.update(&mut cx, |_, cx| {
                    cx.open_url(&url);
                })
            } else {
                Ok(())
            }
-        })
-        .detach();
+        });
+
+        url_finder.detach();
    }

    pub fn open_file(&mut self, _: &OpenFile, cx: &mut ViewContext<Self>) {
@@ -9648,6 +9725,7 @@ impl Editor {
                |theme| theme.editor_highlighted_line_background,
                cx,
            );
+            editor.register_buffers_with_language_servers(cx);
        });

        let item = Box::new(editor);
@@ -9829,10 +9907,9 @@ impl Editor {
                                                    font_weight: Some(FontWeight::BOLD),
                                                    ..make_inlay_hints_style(cx)
                                                },
-                                                suggestions_style: HighlightStyle {
-                                                    color: Some(cx.theme().status().predictive),
-                                                    ..HighlightStyle::default()
-                                                },
+                                                inline_completion_styles: make_suggestion_styles(
+                                                    cx,
+                                                ),
                                                ..EditorStyle::default()
                                            },
                                        ))
@@ -11844,6 +11921,12 @@ impl Editor {
        cx.notify();
    }

+    pub fn lsp_store(&self, cx: &AppContext) -> Option<Model<LspStore>> {
+        self.project
+            .as_ref()
+            .map(|project| project.read(cx).lsp_store())
+    }
+
    fn on_buffer_changed(&mut self, _: Model<MultiBuffer>, cx: &mut ViewContext<Self>) {
        cx.notify();
    }
@@ -11857,6 +11940,7 @@ impl Editor {
        match event {
            multi_buffer::Event::Edited {
                singleton_buffer_edited,
+                edited_buffer: buffer_edited,
            } => {
                self.scrollbar_marker_state.dirty = true;
                self.active_indent_guides_state.dirty = true;
@@ -11865,6 +11949,19 @@ impl Editor {
                if self.has_active_inline_completion() {
                    self.update_visible_inline_completion(cx);
                }
+                if let Some(buffer) = buffer_edited {
+                    let buffer_id = buffer.read(cx).remote_id();
+                    if !self.registered_buffers.contains_key(&buffer_id) {
+                        if let Some(lsp_store) = self.lsp_store(cx) {
+                            lsp_store.update(cx, |lsp_store, cx| {
+                                self.registered_buffers.insert(
+                                    buffer_id,
+                                    lsp_store.register_buffer_with_language_servers(&buffer, cx),
+                                );
+                            })
+                        }
+                    }
+                }
                cx.emit(EditorEvent::BufferEdited);
                cx.emit(SearchEvent::MatchesInvalidated);
                if *singleton_buffer_edited {
@@ -11931,6 +12028,9 @@ impl Editor {
            }
            multi_buffer::Event::ExcerptsRemoved { ids } => {
                self.refresh_inlay_hints(InlayHintRefreshReason::ExcerptsRemoved(ids.clone()), cx);
+                let buffer = self.buffer.read(cx);
+                self.registered_buffers
+                    .retain(|buffer_id, _| buffer.buffer(*buffer_id).is_some());
                cx.emit(EditorEvent::ExcerptsRemoved { ids: ids.clone() })
            }
            multi_buffer::Event::ExcerptsEdited { ids } => {
@@ -13662,7 +13762,7 @@ impl EditorSnapshot {
        if folded || (is_foldable && (row_contains_cursor || self.gutter_hovered)) {
            Some(
                Disclosure::new(("gutter_crease", buffer_row.0), !folded)
-                    .selected(folded)
+                    .toggle_state(folded)
                    .on_click(cx.listener_for(&editor, move |this, _e, cx| {
                        if folded {
                            this.unfold_at(&UnfoldAt { buffer_row }, cx);
@@ -13810,10 +13910,7 @@ impl Render for Editor {
                syntax: cx.theme().syntax().clone(),
                status: cx.theme().status().clone(),
                inlay_hints_style: make_inlay_hints_style(cx),
-                suggestions_style: HighlightStyle {
-                    color: Some(cx.theme().status().predictive),
-                    ..HighlightStyle::default()
-                },
+                inline_completion_styles: make_suggestion_styles(cx),
                unnecessary_code_fade: ThemeSettings::get_global(cx).unnecessary_code_fade,
            },
        )
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -9,6 +9,7 @@ pub struct EditorSettings {
    pub cursor_blink: bool,
    pub cursor_shape: Option<CursorShape>,
    pub current_line_highlight: CurrentLineHighlight,
+    pub lsp_highlight_debounce: u64,
    pub hover_popover_enabled: bool,
    pub toolbar: Toolbar,
    pub scrollbar: Scrollbar,
@@ -185,6 +186,11 @@ pub struct EditorSettingsContent {
    ///
    /// Default: all
    pub current_line_highlight: Option<CurrentLineHighlight>,
+    /// The debounce delay before querying highlights from the language
+    /// server based on the current cursor location.
+    ///
+    /// Default: 75
+    pub lsp_highlight_debounce: Option<u64>,
    /// Whether to show the informational hover box when moving the mouse
    /// over symbols in the editor.
    ///
--- a/crates/editor/src/editor_settings_controls.rs
+++ b/crates/editor/src/editor_settings_controls.rs
@@ -265,8 +265,8 @@ impl RenderOnce for BufferFontLigaturesControl {
            |selection, cx| {
                Self::write(
                    match selection {
-                        Selection::Selected => true,
-                        Selection::Unselected | Selection::Indeterminate => false,
+                        ToggleState::Selected => true,
+                        ToggleState::Unselected | ToggleState::Indeterminate => false,
                    },
                    cx,
                );
@@ -318,8 +318,8 @@ impl RenderOnce for InlineGitBlameControl {
            |selection, cx| {
                Self::write(
                    match selection {
-                        Selection::Selected => true,
-                        Selection::Unselected | Selection::Indeterminate => false,
+                        ToggleState::Selected => true,
+                        ToggleState::Unselected | ToggleState::Indeterminate => false,
                    },
                    cx,
                );
@@ -371,8 +371,8 @@ impl RenderOnce for LineNumbersControl {
            |selection, cx| {
                Self::write(
                    match selection {
-                        Selection::Selected => true,
-                        Selection::Unselected | Selection::Indeterminate => false,
+                        ToggleState::Selected => true,
+                        ToggleState::Unselected | ToggleState::Indeterminate => false,
                    },
                    cx,
                );
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -25,16 +25,15 @@ use language::{
 use language_settings::{Formatter, FormatterList, IndentGuideSettings};
 use multi_buffer::MultiBufferIndentGuide;
 use parking_lot::Mutex;
-use pretty_assertions::{assert_eq, assert_ne};
 use project::{buffer_store::BufferChangeSet, FakeFs};
 use project::{
    lsp_command::SIGNATURE_HELP_HIGHLIGHT_CURRENT,
    project_settings::{LspSettings, ProjectSettings},
 };
 use serde_json::{self, json};
-use std::sync::atomic::{self, AtomicUsize};
-use std::{cell::RefCell, future::Future, iter, rc::Rc, time::Instant};
-use test::editor_lsp_test_context::rust_lang;
+use std::sync::atomic::{self, AtomicBool, AtomicUsize};
+use std::{cell::RefCell, future::Future, rc::Rc, time::Instant};
+use test::{build_editor_with_project, editor_lsp_test_context::rust_lang};
 use unindent::Unindent;
 use util::{
    assert_set_eq,
@@ -3892,6 +3891,28 @@ fn test_duplicate_line(cx: &mut TestAppContext) {
            ]
        );
    });
+
+    let view = cx.add_window(|cx| {
+        let buffer = MultiBuffer::build_simple("abc\ndef\nghi\n", cx);
+        build_editor(buffer, cx)
+    });
+    _ = view.update(cx, |view, cx| {
+        view.change_selections(None, cx, |s| {
+            s.select_display_ranges([
+                DisplayPoint::new(DisplayRow(0), 1)..DisplayPoint::new(DisplayRow(1), 1),
+                DisplayPoint::new(DisplayRow(1), 2)..DisplayPoint::new(DisplayRow(2), 1),
+            ])
+        });
+        view.duplicate_selection(&DuplicateSelection, cx);
+        assert_eq!(view.display_text(cx), "abc\ndbc\ndef\ngf\nghi\n");
+        assert_eq!(
+            view.selections.display_ranges(cx),
+            vec![
+                DisplayPoint::new(DisplayRow(0), 1)..DisplayPoint::new(DisplayRow(1), 1),
+                DisplayPoint::new(DisplayRow(2), 2)..DisplayPoint::new(DisplayRow(3), 1),
+            ]
+        );
+    });
 }

 #[gpui::test]
@@ -6836,14 +6857,15 @@ async fn test_document_format_during_save(cx: &mut gpui::TestAppContext) {
        .await
        .unwrap();

-    cx.executor().start_waiting();
-    let fake_server = fake_servers.next().await.unwrap();
-
    let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-    let (editor, cx) = cx.add_window_view(|cx| build_editor(buffer, cx));
+    let (editor, cx) =
+        cx.add_window_view(|cx| build_editor_with_project(project.clone(), buffer, cx));
    editor.update(cx, |editor, cx| editor.set_text("one\ntwo\nthree\n", cx));
    assert!(cx.read(|cx| editor.is_dirty(cx)));

+    cx.executor().start_waiting();
+    let fake_server = fake_servers.next().await.unwrap();
+
    let save = editor
        .update(cx, |editor, cx| editor.save(true, project.clone(), cx))
        .unwrap();
@@ -7117,6 +7139,7 @@ async fn test_multibuffer_format_during_save(cx: &mut gpui::TestAppContext) {
        assert!(!buffer.is_dirty());
        assert_eq!(buffer.text(), sample_text_3,)
    });
+    cx.executor().run_until_parked();

    cx.executor().start_waiting();
    let save = multi_buffer_editor
@@ -7188,14 +7211,15 @@ async fn test_range_format_during_save(cx: &mut gpui::TestAppContext) {
        .await
        .unwrap();

-    cx.executor().start_waiting();
-    let fake_server = fake_servers.next().await.unwrap();
-
    let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-    let (editor, cx) = cx.add_window_view(|cx| build_editor(buffer, cx));
+    let (editor, cx) =
+        cx.add_window_view(|cx| build_editor_with_project(project.clone(), buffer, cx));
    editor.update(cx, |editor, cx| editor.set_text("one\ntwo\nthree\n", cx));
    assert!(cx.read(|cx| editor.is_dirty(cx)));

+    cx.executor().start_waiting();
+    let fake_server = fake_servers.next().await.unwrap();
+
    let save = editor
        .update(cx, |editor, cx| editor.save(true, project.clone(), cx))
        .unwrap();
@@ -7339,13 +7363,14 @@ async fn test_document_format_manual_trigger(cx: &mut gpui::TestAppContext) {
        .await
        .unwrap();

+    let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
+    let (editor, cx) =
+        cx.add_window_view(|cx| build_editor_with_project(project.clone(), buffer, cx));
+    editor.update(cx, |editor, cx| editor.set_text("one\ntwo\nthree\n", cx));
+
    cx.executor().start_waiting();
    let fake_server = fake_servers.next().await.unwrap();

-    let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-    let (editor, cx) = cx.add_window_view(|cx| build_editor(buffer, cx));
-    editor.update(cx, |editor, cx| editor.set_text("one\ntwo\nthree\n", cx));
-
    let format = editor
        .update(cx, |editor, cx| {
            editor.perform_format(
@@ -10332,9 +10357,6 @@ async fn test_on_type_formatting_not_triggered(cx: &mut gpui::TestAppContext) {
        })
        .await
        .unwrap();
-    cx.executor().run_until_parked();
-    cx.executor().start_waiting();
-    let fake_server = fake_servers.next().await.unwrap();
    let editor_handle = workspace
        .update(cx, |workspace, cx| {
            workspace.open_path((worktree_id, "main.rs"), None, true, cx)
@@ -10345,6 +10367,9 @@ async fn test_on_type_formatting_not_triggered(cx: &mut gpui::TestAppContext) {
        .downcast::<Editor>()
        .unwrap();

+    cx.executor().start_waiting();
+    let fake_server = fake_servers.next().await.unwrap();
+
    fake_server.handle_request::<lsp::request::OnTypeFormatting, _, _>(|params, _| async move {
        assert_eq!(
            params.text_document_position.text_document.uri,
@@ -10434,7 +10459,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut gpui::Test
    let _window = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
    let _buffer = project
        .update(cx, |project, cx| {
-            project.open_local_buffer("/a/main.rs", cx)
+            project.open_local_buffer_with_lsp("/a/main.rs", cx)
        })
        .await
        .unwrap();
@@ -10717,62 +10742,6 @@ async fn test_completions_resolve_updates_labels(cx: &mut gpui::TestAppContext)
 async fn test_completions_default_resolve_data_handling(cx: &mut gpui::TestAppContext) {
    init_test(cx, |_| {});

-    let item_0 = lsp::CompletionItem {
-        label: "abs".into(),
-        insert_text: Some("abs".into()),
-        data: Some(json!({ "very": "special"})),
-        insert_text_mode: Some(lsp::InsertTextMode::ADJUST_INDENTATION),
-        text_edit: Some(lsp::CompletionTextEdit::InsertAndReplace(
-            lsp::InsertReplaceEdit {
-                new_text: "abs".to_string(),
-                insert: lsp::Range::default(),
-                replace: lsp::Range::default(),
-            },
-        )),
-        ..lsp::CompletionItem::default()
-    };
-    let items = iter::once(item_0.clone())
-        .chain((11..51).map(|i| lsp::CompletionItem {
-            label: format!("item_{}", i),
-            insert_text: Some(format!("item_{}", i)),
-            insert_text_format: Some(lsp::InsertTextFormat::PLAIN_TEXT),
-            ..lsp::CompletionItem::default()
-        }))
-        .collect::<Vec<_>>();
-
-    let default_commit_characters = vec!["?".to_string()];
-    let default_data = json!({ "default": "data"});
-    let default_insert_text_format = lsp::InsertTextFormat::SNIPPET;
-    let default_insert_text_mode = lsp::InsertTextMode::AS_IS;
-    let default_edit_range = lsp::Range {
-        start: lsp::Position {
-            line: 0,
-            character: 5,
-        },
-        end: lsp::Position {
-            line: 0,
-            character: 5,
-        },
-    };
-
-    let item_0_out = lsp::CompletionItem {
-        commit_characters: Some(default_commit_characters.clone()),
-        insert_text_format: Some(default_insert_text_format),
-        ..item_0
-    };
-    let items_out = iter::once(item_0_out)
-        .chain(items[1..].iter().map(|item| lsp::CompletionItem {
-            commit_characters: Some(default_commit_characters.clone()),
-            data: Some(default_data.clone()),
-            insert_text_mode: Some(default_insert_text_mode),
-            text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
-                range: default_edit_range,
-                new_text: item.label.clone(),
-            })),
-            ..item.clone()
-        }))
-        .collect::<Vec<lsp::CompletionItem>>();
-
    let mut cx = EditorLspTestContext::new_rust(
        lsp::ServerCapabilities {
            completion_provider: Some(lsp::CompletionOptions {
@@ -10789,15 +10758,138 @@ async fn test_completions_default_resolve_data_handling(cx: &mut gpui::TestAppCo
    cx.set_state(indoc! {"fn main() { let a = 2ˇ; }"});
    cx.simulate_keystroke(".");

+    let default_commit_characters = vec!["?".to_string()];
+    let default_data = json!({ "very": "special"});
+    let default_insert_text_format = lsp::InsertTextFormat::SNIPPET;
+    let default_insert_text_mode = lsp::InsertTextMode::AS_IS;
+    let default_edit_range = lsp::Range {
+        start: lsp::Position {
+            line: 0,
+            character: 5,
+        },
+        end: lsp::Position {
+            line: 0,
+            character: 5,
+        },
+    };
+
+    let resolve_requests_number = Arc::new(AtomicUsize::new(0));
+    let expect_first_item = Arc::new(AtomicBool::new(true));
+    cx.lsp
+        .server
+        .on_request::<lsp::request::ResolveCompletionItem, _, _>({
+            let closure_default_data = default_data.clone();
+            let closure_resolve_requests_number = resolve_requests_number.clone();
+            let closure_expect_first_item = expect_first_item.clone();
+            let closure_default_commit_characters = default_commit_characters.clone();
+            move |item_to_resolve, _| {
+                closure_resolve_requests_number.fetch_add(1, atomic::Ordering::Release);
+                let default_data = closure_default_data.clone();
+                let default_commit_characters = closure_default_commit_characters.clone();
+                let expect_first_item = closure_expect_first_item.clone();
+                async move {
+                    if expect_first_item.load(atomic::Ordering::Acquire) {
+                        assert_eq!(
+                            item_to_resolve.label, "Some(2)",
+                            "Should have selected the first item"
+                        );
+                        assert_eq!(
+                            item_to_resolve.data,
+                            Some(json!({ "very": "special"})),
+                            "First item should bring its own data for resolving"
+                        );
+                        assert_eq!(
+                            item_to_resolve.commit_characters,
+                            Some(default_commit_characters),
+                            "First item had no own commit characters and should inherit the default ones"
+                        );
+                        assert!(
+                            matches!(
+                                item_to_resolve.text_edit,
+                                Some(lsp::CompletionTextEdit::InsertAndReplace { .. })
+                            ),
+                            "First item should bring its own edit range for resolving"
+                        );
+                        assert_eq!(
+                            item_to_resolve.insert_text_format,
+                            Some(default_insert_text_format),
+                            "First item had no own insert text format and should inherit the default one"
+                        );
+                        assert_eq!(
+                            item_to_resolve.insert_text_mode,
+                            Some(lsp::InsertTextMode::ADJUST_INDENTATION),
+                            "First item should bring its own insert text mode for resolving"
+                        );
+                        Ok(item_to_resolve)
+                    } else {
+                        assert_eq!(
+                            item_to_resolve.label, "vec![2]",
+                            "Should have selected the last item"
+                        );
+                        assert_eq!(
+                            item_to_resolve.data,
+                            Some(default_data),
+                            "Last item has no own resolve data and should inherit the default one"
+                        );
+                        assert_eq!(
+                            item_to_resolve.commit_characters,
+                            Some(default_commit_characters),
+                            "Last item had no own commit characters and should inherit the default ones"
+                        );
+                        assert_eq!(
+                            item_to_resolve.text_edit,
+                            Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
+                                range: default_edit_range,
+                                new_text: "vec![2]".to_string()
+                            })),
+                            "Last item had no own edit range and should inherit the default one"
+                        );
+                        assert_eq!(
+                            item_to_resolve.insert_text_format,
+                            Some(lsp::InsertTextFormat::PLAIN_TEXT),
+                            "Last item should bring its own insert text format for resolving"
+                        );
+                        assert_eq!(
+                            item_to_resolve.insert_text_mode,
+                            Some(default_insert_text_mode),
+                            "Last item had no own insert text mode and should inherit the default one"
+                        );
+
+                        Ok(item_to_resolve)
+                    }
+                }
+            }
+        }).detach();
+
    let completion_data = default_data.clone();
    let completion_characters = default_commit_characters.clone();
    cx.handle_request::<lsp::request::Completion, _, _>(move |_, _, _| {
        let default_data = completion_data.clone();
        let default_commit_characters = completion_characters.clone();
-        let items = items.clone();
        async move {
            Ok(Some(lsp::CompletionResponse::List(lsp::CompletionList {
-                items,
+                items: vec![
+                    lsp::CompletionItem {
+                        label: "Some(2)".into(),
+                        insert_text: Some("Some(2)".into()),
+                        data: Some(json!({ "very": "special"})),
+                        insert_text_mode: Some(lsp::InsertTextMode::ADJUST_INDENTATION),
+                        text_edit: Some(lsp::CompletionTextEdit::InsertAndReplace(
+                            lsp::InsertReplaceEdit {
+                                new_text: "Some(2)".to_string(),
+                                insert: lsp::Range::default(),
+                                replace: lsp::Range::default(),
+                            },
+                        )),
+                        ..lsp::CompletionItem::default()
+                    },
+                    lsp::CompletionItem {
+                        label: "vec![2]".into(),
+                        insert_text: Some("vec![2]".into()),
+                        insert_text_format: Some(lsp::InsertTextFormat::PLAIN_TEXT),
+                        ..lsp::CompletionItem::default()
+                    },
+                ],
                item_defaults: Some(lsp::CompletionListItemDefaults {
                    data: Some(default_data.clone()),
                    commit_characters: Some(default_commit_characters.clone()),
@@ -10814,21 +10906,6 @@ async fn test_completions_default_resolve_data_handling(cx: &mut gpui::TestAppCo
    .next()
    .await;

-    let resolved_items = Arc::new(Mutex::new(Vec::new()));
-    cx.lsp
-        .server
-        .on_request::<lsp::request::ResolveCompletionItem, _, _>({
-            let closure_resolved_items = resolved_items.clone();
-            move |item_to_resolve, _| {
-                let closure_resolved_items = closure_resolved_items.clone();
-                async move {
-                    closure_resolved_items.lock().push(item_to_resolve.clone());
-                    Ok(item_to_resolve)
-                }
-            }
-        })
-        .detach();
-
    cx.condition(|editor, _| editor.context_menu_visible())
        .await;
    cx.run_until_parked();
@@ -10840,50 +10917,40 @@ async fn test_completions_default_resolve_data_handling(cx: &mut gpui::TestAppCo
                    completions_menu
                        .matches
                        .iter()
-                        .map(|c| c.string.clone())
-                        .collect::<Vec<String>>(),
-                    items_out
-                        .iter()
-                        .map(|completion| completion.label.clone())
-                        .collect::<Vec<String>>()
+                        .map(|c| c.string.as_str())
+                        .collect::<Vec<_>>(),
+                    vec!["Some(2)", "vec![2]"]
                );
            }
            CodeContextMenu::CodeActions(_) => panic!("Expected to have the completions menu"),
        }
    });
-    // Approximate initial displayed interval is 0..12. With extra item padding of 4 this is 0..16
-    // with 4 from the end.
    assert_eq!(
-        *resolved_items.lock(),
-        [
-            &items_out[0..16],
-            &items_out[items_out.len() - 4..items_out.len()]
-        ]
-        .concat()
-        .iter()
-        .cloned()
-        .collect::<Vec<lsp::CompletionItem>>()
+        resolve_requests_number.load(atomic::Ordering::Acquire),
+        1,
+        "While there are 2 items in the completion list, only 1 resolve request should have been sent, for the selected item"
    );
-    resolved_items.lock().clear();

    cx.update_editor(|editor, cx| {
-        editor.context_menu_prev(&ContextMenuPrev, cx);
+        editor.context_menu_first(&ContextMenuFirst, cx);
    });
    cx.run_until_parked();
-    // Completions that have already been resolved are skipped.
    assert_eq!(
-        *resolved_items.lock(),
-        [
-            // Selected item is always resolved even if it was resolved before.
-            &items_out[items_out.len() - 1..items_out.len()],
-            &items_out[items_out.len() - 16..items_out.len() - 4]
-        ]
-        .concat()
-        .iter()
-        .cloned()
-        .collect::<Vec<lsp::CompletionItem>>()
+        resolve_requests_number.load(atomic::Ordering::Acquire),
+        2,
+        "After re-selecting the first item, another resolve request should have been sent"
+    );
+
+    expect_first_item.store(false, atomic::Ordering::Release);
+    cx.update_editor(|editor, cx| {
+        editor.context_menu_last(&ContextMenuLast, cx);
+    });
+    cx.run_until_parked();
+    assert_eq!(
+        resolve_requests_number.load(atomic::Ordering::Acquire),
+        3,
+        "After selecting the other item, another resolve request should have been sent"
    );
-    resolved_items.lock().clear();
 }

 #[gpui::test]
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -50,7 +50,7 @@ use language::{
 use lsp::DiagnosticSeverity;
 use multi_buffer::{
    Anchor, AnchorRangeExt, ExcerptId, ExpandExcerptDirection, MultiBufferPoint, MultiBufferRow,
-    MultiBufferSnapshot,
+    MultiBufferSnapshot, ToOffset,
 };
 use project::{
    project_settings::{GitGutterSetting, ProjectSettings},
@@ -218,6 +218,7 @@ impl EditorElement {
        register_action(view, cx, Editor::cut_to_end_of_line);
        register_action(view, cx, Editor::duplicate_line_up);
        register_action(view, cx, Editor::duplicate_line_down);
+        register_action(view, cx, Editor::duplicate_selection);
        register_action(view, cx, Editor::move_line_up);
        register_action(view, cx, Editor::move_line_down);
        register_action(view, cx, Editor::transpose);
@@ -1696,16 +1697,23 @@ impl EditorElement {
                    None
                };

+            let offset_range_start = snapshot
+                .display_point_to_anchor(DisplayPoint::new(range.start, 0), Bias::Left)
+                .to_offset(&snapshot.buffer_snapshot);
+            let offset_range_end = snapshot
+                .display_point_to_anchor(DisplayPoint::new(range.end, 0), Bias::Right)
+                .to_offset(&snapshot.buffer_snapshot);
+
            editor
                .tasks
                .iter()
                .filter_map(|(_, tasks)| {
-                    let multibuffer_point = tasks.offset.0.to_point(&snapshot.buffer_snapshot);
-                    let multibuffer_row = MultiBufferRow(multibuffer_point.row);
-                    let display_row = multibuffer_point.to_display_point(snapshot).row();
-                    if range.start > display_row || range.end < display_row {
+                    if tasks.offset.0 < offset_range_start || tasks.offset.0 >= offset_range_end {
                        return None;
                    }
+                    let multibuffer_point = tasks.offset.0.to_point(&snapshot.buffer_snapshot);
+                    let multibuffer_row = MultiBufferRow(multibuffer_point.row);
+
                    if snapshot.is_line_folded(multibuffer_row) {
                        // Skip folded indicators, unless it's the starting line of a fold.
                        if multibuffer_row
@@ -1718,6 +1726,7 @@ impl EditorElement {
                            return None;
                        }
                    }
+                    let display_row = multibuffer_point.to_display_point(snapshot).row();
                    let button = editor.render_run_indicator(
                        &self.style,
                        Some(display_row) == active_task_indicator_row,
@@ -2746,22 +2755,34 @@ impl EditorElement {

        match &active_inline_completion.completion {
            InlineCompletion::Move(target_position) => {
-                let container_element = div()
-                    .bg(cx.theme().colors().editor_background)
+                let tab_kbd = h_flex()
+                    .px_0p5()
+                    .font(theme::ThemeSettings::get_global(cx).buffer_font.clone())
+                    .text_size(TextSize::XSmall.rems(cx))
+                    .text_color(cx.theme().colors().text.opacity(0.8))
+                    .child("tab");
+
+                let icon_container = div().mt(px(2.5)); // For optical alignment
+
+                let container_element = h_flex()
+                    .items_center()
+                    .py_0p5()
+                    .px_1()
+                    .gap_1()
+                    .bg(cx.theme().colors().editor_subheader_background)
                    .border_1()
-                    .border_color(cx.theme().colors().border)
+                    .border_color(cx.theme().colors().text_accent.opacity(0.2))
                    .rounded_md()
-                    .px_1();
+                    .shadow_sm();

                let target_display_point = target_position.to_display_point(editor_snapshot);
                if target_display_point.row().as_f32() < scroll_top {
                    let mut element = container_element
+                        .child(tab_kbd)
+                        .child(Label::new("Jump to Edit").size(LabelSize::Small))
                        .child(
-                            h_flex()
-                                .gap_1()
-                                .child(Icon::new(IconName::Tab))
-                                .child(Label::new("Jump to Edit"))
-                                .child(Icon::new(IconName::ArrowUp)),
+                            icon_container
+                                .child(Icon::new(IconName::ArrowUp).size(IconSize::Small)),
                        )
                        .into_any();
                    let size = element.layout_as_root(AvailableSpace::min_size(), cx);
@@ -2770,12 +2791,11 @@ impl EditorElement {
                    Some(element)
                } else if (target_display_point.row().as_f32() + 1.) > scroll_bottom {
                    let mut element = container_element
+                        .child(tab_kbd)
+                        .child(Label::new("Jump to Edit").size(LabelSize::Small))
                        .child(
-                            h_flex()
-                                .gap_1()
-                                .child(Icon::new(IconName::Tab))
-                                .child(Label::new("Jump to Edit"))
-                                .child(Icon::new(IconName::ArrowDown)),
+                            icon_container
+                                .child(Icon::new(IconName::ArrowDown).size(IconSize::Small)),
                        )
                        .into_any();
                    let size = element.layout_as_root(AvailableSpace::min_size(), cx);
@@ -2787,12 +2807,8 @@ impl EditorElement {
                    Some(element)
                } else {
                    let mut element = container_element
-                        .child(
-                            h_flex()
-                                .gap_1()
-                                .child(Icon::new(IconName::Tab))
-                                .child(Label::new("Jump to Edit")),
-                        )
+                        .child(tab_kbd)
+                        .child(Label::new("Jump to Edit").size(LabelSize::Small))
                        .into_any();

                    let target_line_end = DisplayPoint::new(
@@ -6653,7 +6669,6 @@ mod tests {
    use language::language_settings;
    use log::info;
    use std::num::NonZeroU32;
-    use ui::Context;
    use util::test::sample_text;

    #[gpui::test]
--- a/crates/editor/src/git/project_diff.rs
+++ b/crates/editor/src/git/project_diff.rs
@@ -22,10 +22,7 @@ use multi_buffer::{ExcerptId, ExcerptRange, ExpandExcerptDirection, MultiBuffer}
 use project::{Project, ProjectEntryId, ProjectPath, WorktreeId};
 use text::{OffsetRangeExt, ToPoint};
 use theme::ActiveTheme;
-use ui::{
-    div, h_flex, Color, Context, FluentBuilder, Icon, IconName, IntoElement, Label, LabelCommon,
-    ParentElement, SharedString, Styled, ViewContext, VisualContext, WindowContext,
-};
+use ui::prelude::*;
 use util::{paths::compare_paths, ResultExt};
 use workspace::{
    item::{BreadcrumbText, Item, ItemEvent, ItemHandle, TabContentParams},
--- a/crates/editor/src/hover_links.rs
+++ b/crates/editor/src/hover_links.rs
@@ -694,6 +694,65 @@ pub(crate) fn find_url(
    None
 }

+pub(crate) fn find_url_from_range(
+    buffer: &Model<language::Buffer>,
+    range: Range<text::Anchor>,
+    mut cx: AsyncWindowContext,
+) -> Option<String> {
+    const LIMIT: usize = 2048;
+
+    let Ok(snapshot) = buffer.update(&mut cx, |buffer, _| buffer.snapshot()) else {
+        return None;
+    };
+
+    let start_offset = range.start.to_offset(&snapshot);
+    let end_offset = range.end.to_offset(&snapshot);
+
+    let mut token_start = start_offset.min(end_offset);
+    let mut token_end = start_offset.max(end_offset);
+
+    let range_len = token_end - token_start;
+
+    if range_len >= LIMIT {
+        return None;
+    }
+
+    // Skip leading whitespace
+    for ch in snapshot.chars_at(token_start).take(range_len) {
+        if !ch.is_whitespace() {
+            break;
+        }
+        token_start += ch.len_utf8();
+    }
+
+    // Skip trailing whitespace
+    for ch in snapshot.reversed_chars_at(token_end).take(range_len) {
+        if !ch.is_whitespace() {
+            break;
+        }
+        token_end -= ch.len_utf8();
+    }
+
+    if token_start >= token_end {
+        return None;
+    }
+
+    let text = snapshot
+        .text_for_range(token_start..token_end)
+        .collect::<String>();
+
+    let mut finder = LinkFinder::new();
+    finder.kinds(&[LinkKind::Url]);
+
+    if let Some(link) = finder.links(&text).next() {
+        if link.start() == 0 && link.end() == text.len() {
+            return Some(link.as_str().to_string());
+        }
+    }
+
+    None
+}
+
 pub(crate) async fn find_file(
    buffer: &Model<language::Buffer>,
    project: Option<Model<Project>>,
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -359,6 +359,7 @@ fn show_hover(
                        let mut base_text_style = cx.text_style();
                        base_text_style.refine(&TextStyleRefinement {
                            font_family: Some(settings.ui_font.family.clone()),
+                            font_fallbacks: settings.ui_font.fallbacks.clone(),
                            font_size: Some(settings.ui_font_size.into()),
                            color: Some(cx.theme().colors().editor_foreground),
                            background_color: Some(gpui::transparent_black()),
@@ -547,11 +548,14 @@ async fn parse_blocks(
        .new_view(|cx| {
            let settings = ThemeSettings::get_global(cx);
            let ui_font_family = settings.ui_font.family.clone();
+            let ui_font_fallbacks = settings.ui_font.fallbacks.clone();
            let buffer_font_family = settings.buffer_font.family.clone();
+            let buffer_font_fallbacks = settings.buffer_font.fallbacks.clone();

            let mut base_text_style = cx.text_style();
            base_text_style.refine(&TextStyleRefinement {
                font_family: Some(ui_font_family.clone()),
+                font_fallbacks: ui_font_fallbacks,
                color: Some(cx.theme().colors().editor_foreground),
                ..Default::default()
            });
@@ -562,6 +566,7 @@ async fn parse_blocks(
                inline_code: TextStyleRefinement {
                    background_color: Some(cx.theme().colors().background),
                    font_family: Some(buffer_font_family),
+                    font_fallbacks: buffer_font_fallbacks,
                    ..Default::default()
                },
                rule_color: cx.theme().colors().border,
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -726,7 +726,7 @@ impl Editor {
                                                            .shape(IconButtonShape::Square)
                                                            .icon_size(IconSize::Small)
                                                            .style(ButtonStyle::Subtle)
-                                                            .selected(
+                                                            .toggle_state(
                                                                hunk_controls_menu_handle
                                                                    .is_deployed(),
                                                            )
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
--- a/crates/editor/src/inline_completion_tests.rs
+++ b/crates/editor/src/inline_completion_tests.rs
@@ -1,10 +1,9 @@
-use gpui::Model;
+use gpui::{prelude::*, Model};
 use indoc::indoc;
 use inline_completion::InlineCompletionProvider;
 use multi_buffer::{Anchor, MultiBufferSnapshot, ToPoint};
 use std::ops::Range;
 use text::{Point, ToOffset};
-use ui::Context;

 use crate::{
    editor_tests::init_test, test::editor_test_context::EditorTestContext, InlineCompletion,
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -841,12 +841,12 @@ mod tests {
            .flat_map(|offset| {
                [
                    Inlay {
-                        id: InlayId::Suggestion(post_inc(&mut id)),
+                        id: InlayId::InlineCompletion(post_inc(&mut id)),
                        position: buffer_snapshot.anchor_at(offset, Bias::Left),
                        text: "test".into(),
                    },
                    Inlay {
-                        id: InlayId::Suggestion(post_inc(&mut id)),
+                        id: InlayId::InlineCompletion(post_inc(&mut id)),
                        position: buffer_snapshot.anchor_at(offset, Bias::Right),
                        text: "test".into(),
                    },
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -6,8 +6,8 @@ use collections::BTreeMap;
 use futures::Future;
 use git::diff::DiffHunkStatus;
 use gpui::{
-    AnyWindowHandle, AppContext, Keystroke, ModelContext, Pixels, Point, View, ViewContext,
-    VisualTestContext, WindowHandle,
+    prelude::*, AnyWindowHandle, AppContext, Keystroke, ModelContext, Pixels, Point, View,
+    ViewContext, VisualTestContext, WindowHandle,
 };
 use itertools::Itertools;
 use language::{Buffer, BufferSnapshot, LanguageRegistry};
@@ -23,8 +23,6 @@ use std::{
        Arc,
    },
 };
-
-use ui::Context;
 use util::{
    assert_set_eq,
    test::{generate_marked_text, marked_text_ranges},
--- a/crates/extension_host/src/extension_store_test.rs
+++ b/crates/extension_host/src/extension_store_test.rs
@@ -623,9 +623,9 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
        None,
    );

-    let buffer = project
+    let (buffer, _handle) = project
        .update(cx, |project, cx| {
-            project.open_local_buffer(project_dir.join("test.gleam"), cx)
+            project.open_local_buffer_with_lsp(project_dir.join("test.gleam"), cx)
        })
        .await
        .unwrap();
--- a/crates/extensions_ui/src/extension_version_selector.rs
+++ b/crates/extensions_ui/src/extension_version_selector.rs
@@ -210,7 +210,7 @@ impl PickerDelegate for ExtensionVersionSelectorDelegate {
            ListItem::new(ix)
                .inset(true)
                .spacing(ListItemSpacing::Sparse)
-                .selected(selected)
+                .toggle_state(selected)
                .disabled(disabled)
                .child(
                    HighlightedLabel::new(
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -933,7 +933,7 @@ impl ExtensionsPage {

    fn update_settings<T: Settings>(
        &mut self,
-        selection: &Selection,
+        selection: &ToggleState,
        cx: &mut ViewContext<Self>,
        callback: impl 'static + Send + Fn(&mut T::FileContent, bool),
    ) {
@@ -942,8 +942,8 @@ impl ExtensionsPage {
            let selection = *selection;
            settings::update_settings_file::<T>(fs, cx, move |settings, _| {
                let value = match selection {
-                    Selection::Unselected => false,
-                    Selection::Selected => true,
+                    ToggleState::Unselected => false,
+                    ToggleState::Selected => true,
                    _ => return,
                };

@@ -998,9 +998,9 @@ impl ExtensionsPage {
                        "enable-vim",
                        Label::new("Enable vim mode"),
                        if VimModeSetting::get_global(cx).0 {
-                            ui::Selection::Selected
+                            ui::ToggleState::Selected
                        } else {
-                            ui::Selection::Unselected
+                            ui::ToggleState::Unselected
                        },
                        cx.listener(move |this, selection, cx| {
                            this.telemetry
@@ -1090,7 +1090,7 @@ impl Render for ExtensionsPage {
                                        ToggleButton::new("filter-all", "All")
                                            .style(ButtonStyle::Filled)
                                            .size(ButtonSize::Large)
-                                            .selected(self.filter == ExtensionFilter::All)
+                                            .toggle_state(self.filter == ExtensionFilter::All)
                                            .on_click(cx.listener(|this, _event, cx| {
                                                this.filter = ExtensionFilter::All;
                                                this.filter_extension_entries(cx);
@@ -1104,7 +1104,7 @@ impl Render for ExtensionsPage {
                                        ToggleButton::new("filter-installed", "Installed")
                                            .style(ButtonStyle::Filled)
                                            .size(ButtonSize::Large)
-                                            .selected(self.filter == ExtensionFilter::Installed)
+                                            .toggle_state(self.filter == ExtensionFilter::Installed)
                                            .on_click(cx.listener(|this, _event, cx| {
                                                this.filter = ExtensionFilter::Installed;
                                                this.filter_extension_entries(cx);
@@ -1118,7 +1118,9 @@ impl Render for ExtensionsPage {
                                        ToggleButton::new("filter-not-installed", "Not Installed")
                                            .style(ButtonStyle::Filled)
                                            .size(ButtonSize::Large)
-                                            .selected(self.filter == ExtensionFilter::NotInstalled)
+                                            .toggle_state(
+                                                self.filter == ExtensionFilter::NotInstalled,
+                                            )
                                            .on_click(cx.listener(|this, _event, cx| {
                                                this.filter = ExtensionFilter::NotInstalled;
                                                this.filter_extension_entries(cx);
--- a/crates/feature_flags/src/feature_flags.rs
+++ b/crates/feature_flags/src/feature_flags.rs
@@ -64,6 +64,11 @@ impl FeatureFlag for ZetaFeatureFlag {
    const NAME: &'static str = "zeta";
 }

+pub struct GitUiFeatureFlag;
+impl FeatureFlag for GitUiFeatureFlag {
+    const NAME: &'static str = "git-ui";
+}
+
 pub struct Remoting {}
 impl FeatureFlag for Remoting {
    const NAME: &'static str = "remoting";
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -1228,7 +1228,7 @@ impl PickerDelegate for FileFinderDelegate {
                .start_slot::<Icon>(file_icon)
                .end_slot::<AnyElement>(history_icon)
                .inset(true)
-                .selected(selected)
+                .toggle_state(selected)
                .child(
                    h_flex()
                        .gap_2()
--- a/crates/file_finder/src/new_path_prompt.rs
+++ b/crates/file_finder/src/new_path_prompt.rs
@@ -414,7 +414,7 @@ impl PickerDelegate for NewPathDelegate {
            ListItem::new(ix)
                .spacing(ListItemSpacing::Sparse)
                .inset(true)
-                .selected(selected)
+                .toggle_state(selected)
                .child(LabelLike::new().child(m.styled_text(self.project.read(cx), cx))),
        )
    }
--- a/crates/file_finder/src/open_path_prompt.rs
+++ b/crates/file_finder/src/open_path_prompt.rs
@@ -283,7 +283,7 @@ impl PickerDelegate for OpenPathDelegate {
            ListItem::new(ix)
                .spacing(ListItemSpacing::Sparse)
                .inset(true)
-                .selected(selected)
+                .toggle_state(selected)
                .child(LabelLike::new().child(candidate.string.clone())),
        )
    }
--- a/crates/fs/Cargo.toml
+++ b/crates/fs/Cargo.toml
@@ -21,6 +21,7 @@ git.workspace = true
 git2.workspace = true
 gpui.workspace = true
 libc.workspace = true
+log.workspace = true
 parking_lot.workspace = true
 paths.workspace = true
 rope.workspace = true
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -695,10 +695,13 @@ impl Fs for RealFs {
        let pending_paths: Arc<Mutex<Vec<PathEvent>>> = Default::default();
        let watcher = Arc::new(linux_watcher::LinuxWatcher::new(tx, pending_paths.clone()));

-        watcher.add(&path).ok(); // Ignore "file doesn't exist error" and rely on parent watcher.
-        if let Some(parent) = path.parent() {
-            // watch the parent dir so we can tell when settings.json is created
-            watcher.add(parent).log_err();
+        if watcher.add(path).is_err() {
+            // If the path doesn't exist yet (e.g. settings.json), watch the parent dir to learn when it's created.
+            if let Some(parent) = path.parent() {
+                if let Err(e) = watcher.add(parent) {
+                    log::warn!("Failed to watch: {e}");
+                }
+            }
        }

        // Check if path is a symlink and follow the target parent
@@ -777,7 +780,10 @@ impl Fs for RealFs {
    }

    fn open_repo(&self, dotgit_path: &Path) -> Option<Arc<dyn GitRepository>> {
-        let repo = git2::Repository::open(dotgit_path).log_err()?;
+        // with libgit2, we can open git repo from an existing work dir
+        // https://libgit2.org/docs/reference/main/repository/git_repository_open.html
+        let workdir_root = dotgit_path.parent()?;
+        let repo = git2::Repository::open(workdir_root).log_err()?;
        Some(Arc::new(RealGitRepository::new(
            repo,
            self.git_binary_path.clone(),
--- a/crates/fuzzy/Cargo.toml
+++ b/crates/fuzzy/Cargo.toml
@@ -15,3 +15,4 @@ doctest = false
 [dependencies]
 gpui.workspace = true
 util.workspace = true
+log.workspace = true
--- a/crates/fuzzy/src/strings.rs
+++ b/crates/fuzzy/src/strings.rs
@@ -61,9 +61,23 @@ impl StringMatch {
        let mut positions = self.positions.iter().peekable();
        iter::from_fn(move || {
            if let Some(start) = positions.next().copied() {
+                if start >= self.string.len() {
+                    log::error!(
+                        "Invariant violation: Index {start} out of range in string {:?}",
+                        self.string
+                    );
+                    return None;
+                }
                let mut end = start + self.char_len_at_index(start);
                while let Some(next_start) = positions.peek() {
                    if end == **next_start {
+                        if end >= self.string.len() {
+                            log::error!(
+                                "Invariant violation: Index {end} out of range in string {:?}",
+                                self.string
+                            );
+                            return None;
+                        }
                        end += self.char_len_at_index(end);
                        positions.next();
                    } else {
--- a/crates/git_ui/Cargo.toml
+++ b/crates/git_ui/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+name = "git_ui"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+name = "git_ui"
+path = "src/git_ui.rs"
+
+[dependencies]
+anyhow.workspace = true
+collections.workspace = true
+db.workspace = true
+editor.workspace = true
+git.workspace = true
+gpui.workspace = true
+language.workspace = true
+project.workspace = true
+schemars.workspace = true
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+theme.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace.workspace = true
+
+[target.'cfg(windows)'.dependencies]
+windows.workspace = true
+
+[features]
+default = []
--- a/crates/git_ui/LICENSE-GPL
+++ b/crates/git_ui/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
--- a/crates/git_ui/TODO.md
+++ b/crates/git_ui/TODO.md
@@ -0,0 +1,45 @@
+### General
+
+- [x] Disable staging and committing actions for read-only projects
+
+### List
+
+- [x] Add uniform list
+- [x] Git status item
+- [ ] Directory item
+- [x] Scrollbar
+- [ ] Add indent size setting
+- [ ] Add tree settings
+
+### List Items
+
+- [x] Checkbox for staging
+- [x] Git status icon
+- [ ] Context menu
+  - [ ] Discard Changes
+  - ---
+  - [ ] Ignore
+  - [ ] Ignore directory
+  - ---
+  - [ ] Copy path
+  - [ ] Copy relative path
+  - ---
+  - [ ] Reveal in Finder
+
+### Commit Editor
+
+- [ ] Add commit editor
+- [ ] Add commit message placeholder & add commit message to store
+- [ ] Add a way to get the current collaborators & automatically add them to the commit message as co-authors
+- [ ] Add action to clear commit message
+- [x] Swap commit button between "Commit" and "Commit All" based on modifier key
+
+### Component Updates
+
+- [ ] ChangedLineCount (new)
+  - takes `lines_added: usize, lines_removed: usize`, returns a added/removed badge
+- [x] GitStatusIcon (new)
+- [ ] Checkbox
+  - update checkbox design
+- [ ] ScrollIndicator
+  - shows a gradient overlay when more content is available to be scrolled
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -0,0 +1,884 @@
+use anyhow::Context;
+use collections::HashMap;
+use editor::Editor;
+use language::Buffer;
+use std::{
+    cell::OnceCell,
+    collections::HashSet,
+    ffi::OsStr,
+    ops::Range,
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::Duration,
+};
+use theme::ThemeSettings;
+
+use git::repository::GitFileStatus;
+
+use util::{ResultExt, TryFutureExt};
+
+use db::kvp::KEY_VALUE_STORE;
+use gpui::*;
+use project::{Entry, EntryKind, Fs, Project, ProjectEntryId, WorktreeId};
+use serde::{Deserialize, Serialize};
+use settings::Settings as _;
+use ui::{
+    prelude::*, Checkbox, Divider, DividerColor, ElevationIndex, Scrollbar, ScrollbarState, Tooltip,
+};
+use workspace::dock::{DockPosition, Panel, PanelEvent};
+use workspace::Workspace;
+
+use crate::{git_status_icon, settings::GitPanelSettings, GitState};
+use crate::{CommitAllChanges, CommitStagedChanges, DiscardAll, StageAll, UnstageAll};
+
+actions!(git_panel, [ToggleFocus]);
+
+const GIT_PANEL_KEY: &str = "GitPanel";
+
+pub fn init(cx: &mut AppContext) {
+    cx.observe_new_views(
+        |workspace: &mut Workspace, _cx: &mut ViewContext<Workspace>| {
+            workspace.register_action(|workspace, _: &ToggleFocus, cx| {
+                workspace.toggle_panel_focus::<GitPanel>(cx);
+            });
+        },
+    )
+    .detach();
+}
+
+#[derive(Debug)]
+pub enum Event {
+    Focus,
+}
+
+pub struct GitStatusEntry {}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+struct EntryDetails {
+    filename: String,
+    display_name: String,
+    path: Arc<Path>,
+    kind: EntryKind,
+    depth: usize,
+    is_expanded: bool,
+    status: Option<GitFileStatus>,
+}
+
+impl EntryDetails {
+    pub fn is_dir(&self) -> bool {
+        self.kind.is_dir()
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+struct SerializedGitPanel {
+    width: Option<Pixels>,
+}
+
+pub struct GitPanel {
+    _workspace: WeakView<Workspace>,
+    current_modifiers: Modifiers,
+    focus_handle: FocusHandle,
+    fs: Arc<dyn Fs>,
+    hide_scrollbar_task: Option<Task<()>>,
+    pending_serialization: Task<Option<()>>,
+    project: Model<Project>,
+    scroll_handle: UniformListScrollHandle,
+    scrollbar_state: ScrollbarState,
+    selected_item: Option<usize>,
+    show_scrollbar: bool,
+    expanded_dir_ids: HashMap<WorktreeId, Vec<ProjectEntryId>>,
+    git_state: Model<GitState>,
+    editor: View<Editor>,
+
+    // The entries that are currently shown in the panel, aka
+    // not hidden by folding or such
+    visible_entries: Vec<(WorktreeId, Vec<Entry>, OnceCell<HashSet<Arc<Path>>>)>,
+    width: Option<Pixels>,
+}
+
+impl GitPanel {
+    pub fn load(
+        workspace: WeakView<Workspace>,
+        cx: AsyncWindowContext,
+    ) -> Task<Result<View<Self>>> {
+        cx.spawn(|mut cx| async move {
+            // Clippy incorrectly classifies this as a redundant closure
+            #[allow(clippy::redundant_closure)]
+            workspace.update(&mut cx, |workspace, cx| Self::new(workspace, cx))
+        })
+    }
+
+    pub fn new(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) -> View<Self> {
+        let git_state = GitState::get_global(cx);
+
+        let fs = workspace.app_state().fs.clone();
+        let weak_workspace = workspace.weak_handle();
+        let project = workspace.project().clone();
+        let language_registry = workspace.app_state().languages.clone();
+
+        let git_panel = cx.new_view(|cx: &mut ViewContext<Self>| {
+            let state = git_state.read(cx);
+            let current_commit_message = state.commit_message.clone();
+
+            let focus_handle = cx.focus_handle();
+            cx.on_focus(&focus_handle, Self::focus_in).detach();
+            cx.on_focus_out(&focus_handle, |this, _, cx| {
+                this.hide_scrollbar(cx);
+            })
+            .detach();
+            cx.subscribe(&project, |this, _project, event, cx| match event {
+                project::Event::WorktreeRemoved(id) => {
+                    this.expanded_dir_ids.remove(id);
+                    this.update_visible_entries(None, cx);
+                    cx.notify();
+                }
+                project::Event::WorktreeUpdatedEntries(_, _)
+                | project::Event::WorktreeAdded(_)
+                | project::Event::WorktreeOrderChanged => {
+                    this.update_visible_entries(None, cx);
+                    cx.notify();
+                }
+                _ => {}
+            })
+            .detach();
+
+            let editor = cx.new_view(|cx| {
+                let theme = ThemeSettings::get_global(cx);
+
+                let mut text_style = cx.text_style();
+                let refinement = TextStyleRefinement {
+                    font_family: Some(theme.buffer_font.family.clone()),
+                    font_features: Some(FontFeatures::disable_ligatures()),
+                    font_size: Some(px(12.).into()),
+                    color: Some(cx.theme().colors().editor_foreground),
+                    background_color: Some(gpui::transparent_black()),
+                    ..Default::default()
+                };
+
+                text_style.refine(&refinement);
+
+                let mut editor = Editor::auto_height(10, cx);
+                if let Some(message) = current_commit_message {
+                    editor.set_text(message, cx);
+                } else {
+                    editor.set_text("", cx);
+                }
+                // editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
+                editor.set_use_autoclose(false);
+                editor.set_show_gutter(false, cx);
+                editor.set_show_wrap_guides(false, cx);
+                editor.set_show_indent_guides(false, cx);
+                editor.set_text_style_refinement(refinement);
+                editor.set_placeholder_text("Enter commit message", cx);
+                editor
+            });
+
+            let buffer = editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .expect("commit editor must be singleton");
+
+            cx.subscribe(&buffer, Self::on_buffer_event).detach();
+
+            let markdown = language_registry.language_for_name("Markdown");
+            cx.spawn(|_, mut cx| async move {
+                let markdown = markdown.await.context("failed to load Markdown language")?;
+                buffer.update(&mut cx, |buffer, cx| {
+                    buffer.set_language(Some(markdown), cx)
+                })
+            })
+            .detach_and_log_err(cx);
+
+            let scroll_handle = UniformListScrollHandle::new();
+
+            let mut this = Self {
+                _workspace: weak_workspace,
+                focus_handle: cx.focus_handle(),
+                fs,
+                pending_serialization: Task::ready(None),
+                project,
+                visible_entries: Vec::new(),
+                current_modifiers: cx.modifiers(),
+                expanded_dir_ids: Default::default(),
+                git_state,
+                editor,
+
+                width: Some(px(360.)),
+                scrollbar_state: ScrollbarState::new(scroll_handle.clone()).parent_view(cx.view()),
+                scroll_handle,
+                selected_item: None,
+                show_scrollbar: !Self::should_autohide_scrollbar(cx),
+                hide_scrollbar_task: None,
+            };
+            this.update_visible_entries(None, cx);
+            this
+        });
+
+        git_panel
+    }
+
+    fn serialize(&mut self, cx: &mut ViewContext<Self>) {
+        let width = self.width;
+        self.pending_serialization = cx.background_executor().spawn(
+            async move {
+                KEY_VALUE_STORE
+                    .write_kvp(
+                        GIT_PANEL_KEY.into(),
+                        serde_json::to_string(&SerializedGitPanel { width })?,
+                    )
+                    .await?;
+                anyhow::Ok(())
+            }
+            .log_err(),
+        );
+    }
+
+    fn dispatch_context(&self) -> KeyContext {
+        let mut dispatch_context = KeyContext::new_with_defaults();
+        dispatch_context.add("GitPanel");
+        dispatch_context.add("menu");
+
+        dispatch_context
+    }
+
+    fn focus_in(&mut self, cx: &mut ViewContext<Self>) {
+        if !self.focus_handle.contains_focused(cx) {
+            cx.emit(Event::Focus);
+        }
+    }
+
+    fn should_show_scrollbar(_cx: &AppContext) -> bool {
+        // TODO: plug into settings
+        true
+    }
+
+    fn should_autohide_scrollbar(_cx: &AppContext) -> bool {
+        // TODO: plug into settings
+        true
+    }
+
+    fn hide_scrollbar(&mut self, cx: &mut ViewContext<Self>) {
+        const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);
+        if !Self::should_autohide_scrollbar(cx) {
+            return;
+        }
+        self.hide_scrollbar_task = Some(cx.spawn(|panel, mut cx| async move {
+            cx.background_executor()
+                .timer(SCROLLBAR_SHOW_INTERVAL)
+                .await;
+            panel
+                .update(&mut cx, |panel, cx| {
+                    panel.show_scrollbar = false;
+                    cx.notify();
+                })
+                .log_err();
+        }))
+    }
+
+    fn handle_modifiers_changed(
+        &mut self,
+        event: &ModifiersChangedEvent,
+        cx: &mut ViewContext<Self>,
+    ) {
+        self.current_modifiers = event.modifiers;
+        cx.notify();
+    }
+
+    fn calculate_depth_and_difference(
+        entry: &Entry,
+        visible_worktree_entries: &HashSet<Arc<Path>>,
+    ) -> (usize, usize) {
+        let (depth, difference) = entry
+            .path
+            .ancestors()
+            .skip(1) // Skip the entry itself
+            .find_map(|ancestor| {
+                if let Some(parent_entry) = visible_worktree_entries.get(ancestor) {
+                    let entry_path_components_count = entry.path.components().count();
+                    let parent_path_components_count = parent_entry.components().count();
+                    let difference = entry_path_components_count - parent_path_components_count;
+                    let depth = parent_entry
+                        .ancestors()
+                        .skip(1)
+                        .filter(|ancestor| visible_worktree_entries.contains(*ancestor))
+                        .count();
+                    Some((depth + 1, difference))
+                } else {
+                    None
+                }
+            })
+            .unwrap_or((0, 0));
+
+        (depth, difference)
+    }
+}
+
+impl GitPanel {
+    fn stage_all(&mut self, _: &StageAll, _cx: &mut ViewContext<Self>) {
+        // TODO: Implement stage all
+        println!("Stage all triggered");
+    }
+
+    fn unstage_all(&mut self, _: &UnstageAll, _cx: &mut ViewContext<Self>) {
+        // TODO: Implement unstage all
+        println!("Unstage all triggered");
+    }
+
+    fn discard_all(&mut self, _: &DiscardAll, _cx: &mut ViewContext<Self>) {
+        // TODO: Implement discard all
+        println!("Discard all triggered");
+    }
+
+    fn clear_message(&mut self, cx: &mut ViewContext<Self>) {
+        let git_state = self.git_state.clone();
+        git_state.update(cx, |state, _cx| state.clear_message());
+        self.editor.update(cx, |editor, cx| editor.set_text("", cx));
+    }
+
+    /// Commit all staged changes
+    fn commit_staged_changes(&mut self, _: &CommitStagedChanges, cx: &mut ViewContext<Self>) {
+        self.clear_message(cx);
+
+        // TODO: Implement commit all staged
+        println!("Commit staged changes triggered");
+    }
+
+    /// Commit all changes, regardless of whether they are staged or not
+    fn commit_all_changes(&mut self, _: &CommitAllChanges, cx: &mut ViewContext<Self>) {
+        self.clear_message(cx);
+
+        // TODO: Implement commit all changes
+        println!("Commit all changes triggered");
+    }
+
+    fn all_staged(&self) -> bool {
+        // TODO: Implement all_staged
+        true
+    }
+
+    fn no_entries(&self) -> bool {
+        self.visible_entries.is_empty()
+    }
+
+    fn entry_count(&self) -> usize {
+        self.visible_entries
+            .iter()
+            .map(|(_, entries, _)| {
+                entries
+                    .iter()
+                    .filter(|entry| entry.git_status.is_some())
+                    .count()
+            })
+            .sum()
+    }
+
+    fn for_each_visible_entry(
+        &self,
+        range: Range<usize>,
+        cx: &mut ViewContext<Self>,
+        mut callback: impl FnMut(ProjectEntryId, EntryDetails, &mut ViewContext<Self>),
+    ) {
+        let mut ix = 0;
+        for (worktree_id, visible_worktree_entries, entries_paths) in &self.visible_entries {
+            if ix >= range.end {
+                return;
+            }
+
+            if ix + visible_worktree_entries.len() <= range.start {
+                ix += visible_worktree_entries.len();
+                continue;
+            }
+
+            let end_ix = range.end.min(ix + visible_worktree_entries.len());
+            // let entry_range = range.start.saturating_sub(ix)..end_ix - ix;
+            if let Some(worktree) = self.project.read(cx).worktree_for_id(*worktree_id, cx) {
+                let snapshot = worktree.read(cx).snapshot();
+                let root_name = OsStr::new(snapshot.root_name());
+                let expanded_entry_ids = self
+                    .expanded_dir_ids
+                    .get(&snapshot.id())
+                    .map(Vec::as_slice)
+                    .unwrap_or(&[]);
+
+                let entry_range = range.start.saturating_sub(ix)..end_ix - ix;
+                let entries = entries_paths.get_or_init(|| {
+                    visible_worktree_entries
+                        .iter()
+                        .map(|e| (e.path.clone()))
+                        .collect()
+                });
+
+                for entry in visible_worktree_entries[entry_range].iter() {
+                    let status = entry.git_status;
+                    let is_expanded = expanded_entry_ids.binary_search(&entry.id).is_ok();
+
+                    let (depth, difference) = Self::calculate_depth_and_difference(entry, entries);
+
+                    let filename = match difference {
+                        diff if diff > 1 => entry
+                            .path
+                            .iter()
+                            .skip(entry.path.components().count() - diff)
+                            .collect::<PathBuf>()
+                            .to_str()
+                            .unwrap_or_default()
+                            .to_string(),
+                        _ => entry
+                            .path
+                            .file_name()
+                            .map(|name| name.to_string_lossy().into_owned())
+                            .unwrap_or_else(|| root_name.to_string_lossy().to_string()),
+                    };
+
+                    let display_name = entry.path.to_string_lossy().into_owned();
+
+                    let details = EntryDetails {
+                        filename,
+                        display_name,
+                        kind: entry.kind,
+                        is_expanded,
+                        path: entry.path.clone(),
+                        status,
+                        depth,
+                    };
+                    callback(entry.id, details, cx);
+                }
+            }
+            ix = end_ix;
+        }
+    }
+
+    // TODO: Update expanded directory state
+    fn update_visible_entries(
+        &mut self,
+        new_selected_entry: Option<(WorktreeId, ProjectEntryId)>,
+        cx: &mut ViewContext<Self>,
+    ) {
+        let project = self.project.read(cx);
+        self.visible_entries.clear();
+        for worktree in project.visible_worktrees(cx) {
+            let snapshot = worktree.read(cx).snapshot();
+            let worktree_id = snapshot.id();
+
+            let mut visible_worktree_entries = Vec::new();
+            let mut entry_iter = snapshot.entries(true, 0);
+            while let Some(entry) = entry_iter.entry() {
+                // Only include entries with a git status
+                if entry.git_status.is_some() {
+                    visible_worktree_entries.push(entry.clone());
+                }
+                entry_iter.advance();
+            }
+
+            snapshot.propagate_git_statuses(&mut visible_worktree_entries);
+            project::sort_worktree_entries(&mut visible_worktree_entries);
+
+            if !visible_worktree_entries.is_empty() {
+                self.visible_entries
+                    .push((worktree_id, visible_worktree_entries, OnceCell::new()));
+            }
+        }
+
+        if let Some((worktree_id, entry_id)) = new_selected_entry {
+            self.selected_item = self.visible_entries.iter().enumerate().find_map(
+                |(worktree_index, (id, entries, _))| {
+                    if *id == worktree_id {
+                        entries
+                            .iter()
+                            .position(|entry| entry.id == entry_id)
+                            .map(|entry_index| worktree_index * entries.len() + entry_index)
+                    } else {
+                        None
+                    }
+                },
+            );
+        }
+
+        cx.notify();
+    }
+
+    fn on_buffer_event(
+        &mut self,
+        _buffer: Model<Buffer>,
+        event: &language::BufferEvent,
+        cx: &mut ViewContext<Self>,
+    ) {
+        if let language::BufferEvent::Reparsed | language::BufferEvent::Edited = event {
+            let commit_message = self.editor.update(cx, |editor, cx| editor.text(cx));
+
+            self.git_state.update(cx, |state, _cx| {
+                state.commit_message = Some(commit_message.into());
+            });
+
+            cx.notify();
+        }
+    }
+}
+
+impl GitPanel {
+    pub fn panel_button(
+        &self,
+        id: impl Into<SharedString>,
+        label: impl Into<SharedString>,
+    ) -> Button {
+        let id = id.into().clone();
+        let label = label.into().clone();
+
+        Button::new(id, label)
+            .label_size(LabelSize::Small)
+            .layer(ElevationIndex::ElevatedSurface)
+            .size(ButtonSize::Compact)
+            .style(ButtonStyle::Filled)
+    }
+
+    pub fn render_divider(&self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        h_flex()
+            .items_center()
+            .h(px(8.))
+            .child(Divider::horizontal_dashed().color(DividerColor::Border))
+    }
+
+    pub fn render_panel_header(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let focus_handle = self.focus_handle(cx).clone();
+
+        let changes_string = format!("{} changes", self.entry_count());
+
+        h_flex()
+            .h(px(32.))
+            .items_center()
+            .px_3()
+            .bg(ElevationIndex::Surface.bg(cx))
+            .child(
+                h_flex()
+                    .gap_2()
+                    .child(Checkbox::new("all-changes", true.into()).disabled(true))
+                    .child(div().text_buffer(cx).text_ui_sm(cx).child(changes_string)),
+            )
+            .child(div().flex_grow())
+            .child(
+                h_flex()
+                    .gap_2()
+                    .child(
+                        IconButton::new("discard-changes", IconName::Undo)
+                            .tooltip(move |cx| {
+                                let focus_handle = focus_handle.clone();
+
+                                Tooltip::for_action_in(
+                                    "Discard all changes",
+                                    &DiscardAll,
+                                    &focus_handle,
+                                    cx,
+                                )
+                            })
+                            .icon_size(IconSize::Small)
+                            .disabled(true),
+                    )
+                    .child(if self.all_staged() {
+                        self.panel_button("unstage-all", "Unstage All").on_click(
+                            cx.listener(move |_, _, cx| cx.dispatch_action(Box::new(DiscardAll))),
+                        )
+                    } else {
+                        self.panel_button("stage-all", "Stage All").on_click(
+                            cx.listener(move |_, _, cx| cx.dispatch_action(Box::new(StageAll))),
+                        )
+                    }),
+            )
+    }
+
+    pub fn render_commit_editor(&self, cx: &ViewContext<Self>) -> impl IntoElement {
+        let git_state = self.git_state.clone();
+        let commit_message = git_state.read(cx).commit_message.clone();
+        let editor = self.editor.clone();
+        let editor_focus_handle = editor.read(cx).focus_handle(cx).clone();
+
+        println!("{:?}", commit_message);
+
+        let focus_handle_1 = self.focus_handle(cx).clone();
+        let focus_handle_2 = self.focus_handle(cx).clone();
+
+        let commit_staged_button = self
+            .panel_button("commit-staged-changes", "Commit")
+            .tooltip(move |cx| {
+                let focus_handle = focus_handle_1.clone();
+                Tooltip::for_action_in(
+                    "Commit all staged changes",
+                    &CommitStagedChanges,
+                    &focus_handle,
+                    cx,
+                )
+            })
+            .on_click(cx.listener(|this, _: &ClickEvent, cx| {
+                this.commit_staged_changes(&CommitStagedChanges, cx)
+            }));
+
+        let commit_all_button = self
+            .panel_button("commit-all-changes", "Commit All")
+            .tooltip(move |cx| {
+                let focus_handle = focus_handle_2.clone();
+                Tooltip::for_action_in(
+                    "Commit all changes, including unstaged changes",
+                    &CommitAllChanges,
+                    &focus_handle,
+                    cx,
+                )
+            })
+            .on_click(cx.listener(|this, _: &ClickEvent, cx| {
+                this.commit_all_changes(&CommitAllChanges, cx)
+            }));
+
+        div().w_full().h(px(140.)).px_2().pt_1().pb_2().child(
+            v_flex()
+                .id("commit-editor-container")
+                .relative()
+                .h_full()
+                .py_2p5()
+                .px_3()
+                .bg(cx.theme().colors().editor_background)
+                .on_click(cx.listener(move |_, _: &ClickEvent, cx| cx.focus(&editor_focus_handle)))
+                .child(self.editor.clone())
+                .child(
+                    h_flex()
+                        .absolute()
+                        .bottom_2p5()
+                        .right_3()
+                        .child(div().gap_1().flex_grow())
+                        .child(if self.current_modifiers.alt {
+                            commit_all_button
+                        } else {
+                            commit_staged_button
+                        }),
+                ),
+        )
+    }
+
+    fn render_empty_state(&self, cx: &ViewContext<Self>) -> impl IntoElement {
+        h_flex()
+            .h_full()
+            .flex_1()
+            .justify_center()
+            .items_center()
+            .child(
+                v_flex()
+                    .gap_3()
+                    .child("No changes to commit")
+                    .text_ui_sm(cx)
+                    .mx_auto()
+                    .text_color(Color::Placeholder.color(cx)),
+            )
+    }
+
+    fn render_scrollbar(&self, cx: &mut ViewContext<Self>) -> Option<Stateful<Div>> {
+        if !Self::should_show_scrollbar(cx)
+            || !(self.show_scrollbar || self.scrollbar_state.is_dragging())
+        {
+            return None;
+        }
+        Some(
+            div()
+                .occlude()
+                .id("project-panel-vertical-scroll")
+                .on_mouse_move(cx.listener(|_, _, cx| {
+                    cx.notify();
+                    cx.stop_propagation()
+                }))
+                .on_hover(|_, cx| {
+                    cx.stop_propagation();
+                })
+                .on_any_mouse_down(|_, cx| {
+                    cx.stop_propagation();
+                })
+                .on_mouse_up(
+                    MouseButton::Left,
+                    cx.listener(|this, _, cx| {
+                        if !this.scrollbar_state.is_dragging()
+                            && !this.focus_handle.contains_focused(cx)
+                        {
+                            this.hide_scrollbar(cx);
+                            cx.notify();
+                        }
+
+                        cx.stop_propagation();
+                    }),
+                )
+                .on_scroll_wheel(cx.listener(|_, _, cx| {
+                    cx.notify();
+                }))
+                .h_full()
+                .absolute()
+                .right_1()
+                .top_1()
+                .bottom_1()
+                .w(px(12.))
+                .cursor_default()
+                .children(Scrollbar::vertical(
+                    // percentage as f32..end_offset as f32,
+                    self.scrollbar_state.clone(),
+                )),
+        )
+    }
+
+    fn render_entries(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let item_count = self
+            .visible_entries
+            .iter()
+            .map(|(_, worktree_entries, _)| worktree_entries.len())
+            .sum();
+        h_flex()
+            .size_full()
+            .overflow_hidden()
+            .child(
+                uniform_list(cx.view().clone(), "entries", item_count, {
+                    |this, range, cx| {
+                        let mut items = Vec::with_capacity(range.end - range.start);
+                        this.for_each_visible_entry(range, cx, |id, details, cx| {
+                            items.push(this.render_entry(id, details, cx));
+                        });
+                        items
+                    }
+                })
+                .size_full()
+                .with_sizing_behavior(ListSizingBehavior::Infer)
+                .with_horizontal_sizing_behavior(ListHorizontalSizingBehavior::Unconstrained)
+                // .with_width_from_item(self.max_width_item_index)
+                .track_scroll(self.scroll_handle.clone()),
+            )
+            .children(self.render_scrollbar(cx))
+    }
+
+    fn render_entry(
+        &self,
+        id: ProjectEntryId,
+        details: EntryDetails,
+        cx: &ViewContext<Self>,
+    ) -> impl IntoElement {
+        let id = id.to_proto() as usize;
+        let checkbox_id = ElementId::Name(format!("checkbox_{}", id).into());
+        let is_staged = ToggleState::Selected;
+
+        h_flex()
+            .id(id)
+            .h(px(28.))
+            .w_full()
+            .pl(px(12. + 12. * details.depth as f32))
+            .pr(px(4.))
+            .items_center()
+            .gap_2()
+            .font_buffer(cx)
+            .text_ui_sm(cx)
+            .when(!details.is_dir(), |this| {
+                this.child(Checkbox::new(checkbox_id, is_staged))
+            })
+            .when_some(details.status, |this, status| {
+                this.child(git_status_icon(status))
+            })
+            .child(h_flex().gap_1p5().child(details.display_name.clone()))
+    }
+}
+
+impl Render for GitPanel {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let project = self.project.read(cx);
+
+        v_flex()
+            .id("git_panel")
+            .key_context(self.dispatch_context())
+            .track_focus(&self.focus_handle)
+            .on_modifiers_changed(cx.listener(Self::handle_modifiers_changed))
+            .when(!project.is_read_only(cx), |this| {
+                this.on_action(cx.listener(|this, &StageAll, cx| this.stage_all(&StageAll, cx)))
+                    .on_action(
+                        cx.listener(|this, &UnstageAll, cx| this.unstage_all(&UnstageAll, cx)),
+                    )
+                    .on_action(
+                        cx.listener(|this, &DiscardAll, cx| this.discard_all(&DiscardAll, cx)),
+                    )
+                    .on_action(cx.listener(|this, &CommitStagedChanges, cx| {
+                        this.commit_staged_changes(&CommitStagedChanges, cx)
+                    }))
+                    .on_action(cx.listener(|this, &CommitAllChanges, cx| {
+                        this.commit_all_changes(&CommitAllChanges, cx)
+                    }))
+            })
+            .on_hover(cx.listener(|this, hovered, cx| {
+                if *hovered {
+                    this.show_scrollbar = true;
+                    this.hide_scrollbar_task.take();
+                    cx.notify();
+                } else if !this.focus_handle.contains_focused(cx) {
+                    this.hide_scrollbar(cx);
+                }
+            }))
+            .size_full()
+            .overflow_hidden()
+            .font_buffer(cx)
+            .py_1()
+            .bg(ElevationIndex::Surface.bg(cx))
+            .child(self.render_panel_header(cx))
+            .child(self.render_divider(cx))
+            .child(if !self.no_entries() {
+                self.render_entries(cx).into_any_element()
+            } else {
+                self.render_empty_state(cx).into_any_element()
+            })
+            .child(self.render_divider(cx))
+            .child(self.render_commit_editor(cx))
+    }
+}
+
+impl FocusableView for GitPanel {
+    fn focus_handle(&self, _: &AppContext) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl EventEmitter<Event> for GitPanel {}
+
+impl EventEmitter<PanelEvent> for GitPanel {}
+
+impl Panel for GitPanel {
+    fn persistent_name() -> &'static str {
+        "GitPanel"
+    }
+
+    fn position(&self, cx: &gpui::WindowContext) -> DockPosition {
+        GitPanelSettings::get_global(cx).dock
+    }
+
+    fn position_is_valid(&self, position: DockPosition) -> bool {
+        matches!(position, DockPosition::Left | DockPosition::Right)
+    }
+
+    fn set_position(&mut self, position: DockPosition, cx: &mut ViewContext<Self>) {
+        settings::update_settings_file::<GitPanelSettings>(
+            self.fs.clone(),
+            cx,
+            move |settings, _| settings.dock = Some(position),
+        );
+    }
+
+    fn size(&self, cx: &gpui::WindowContext) -> Pixels {
+        self.width
+            .unwrap_or_else(|| GitPanelSettings::get_global(cx).default_width)
+    }
+
+    fn set_size(&mut self, size: Option<Pixels>, cx: &mut ViewContext<Self>) {
+        self.width = size;
+        self.serialize(cx);
+        cx.notify();
+    }
+
+    fn icon(&self, cx: &WindowContext) -> Option<ui::IconName> {
+        Some(ui::IconName::GitBranch).filter(|_| GitPanelSettings::get_global(cx).button)
+    }
+
+    fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
+        Some("Git Panel")
+    }
+
+    fn toggle_action(&self) -> Box<dyn Action> {
+        Box::new(ToggleFocus)
+    }
+}
--- a/crates/git_ui/src/git_ui.rs
+++ b/crates/git_ui/src/git_ui.rs
@@ -0,0 +1,89 @@
+use ::settings::Settings;
+use git::repository::GitFileStatus;
+use gpui::{actions, prelude::*, AppContext, Global, Hsla, Model};
+use settings::GitPanelSettings;
+use ui::{Color, Icon, IconName, IntoElement, SharedString};
+
+pub mod git_panel;
+mod settings;
+
+actions!(
+    git_ui,
+    [
+        StageAll,
+        UnstageAll,
+        DiscardAll,
+        CommitStagedChanges,
+        CommitAllChanges,
+        ClearMessage
+    ]
+);
+
+pub fn init(cx: &mut AppContext) {
+    GitPanelSettings::register(cx);
+    let git_state = cx.new_model(|_cx| GitState::new());
+    cx.set_global(GlobalGitState(git_state));
+}
+
+struct GlobalGitState(Model<GitState>);
+
+impl Global for GlobalGitState {}
+
+pub struct GitState {
+    commit_message: Option<SharedString>,
+}
+
+impl GitState {
+    pub fn new() -> Self {
+        GitState {
+            commit_message: None,
+        }
+    }
+
+    pub fn set_message(&mut self, message: Option<SharedString>) {
+        self.commit_message = message;
+    }
+
+    pub fn clear_message(&mut self) {
+        self.commit_message = None;
+    }
+
+    pub fn get_global(cx: &mut AppContext) -> Model<GitState> {
+        cx.global::<GlobalGitState>().0.clone()
+    }
+}
+
+// impl EventEmitter<Event> for GitState {}
+
+// #[derive(Clone, Debug, PartialEq, Eq)]
+// pub enum Event {}
+
+const ADDED_COLOR: Hsla = Hsla {
+    h: 142. / 360.,
+    s: 0.68,
+    l: 0.45,
+    a: 1.0,
+};
+const MODIFIED_COLOR: Hsla = Hsla {
+    h: 48. / 360.,
+    s: 0.76,
+    l: 0.47,
+    a: 1.0,
+};
+const REMOVED_COLOR: Hsla = Hsla {
+    h: 355. / 360.,
+    s: 0.65,
+    l: 0.65,
+    a: 1.0,
+};
+
+// TODO: Add updated status colors to theme
+pub fn git_status_icon(status: GitFileStatus) -> impl IntoElement {
+    match status {
+        GitFileStatus::Added => Icon::new(IconName::SquarePlus).color(Color::Custom(ADDED_COLOR)),
+        GitFileStatus::Modified => {
+            Icon::new(IconName::SquareDot).color(Color::Custom(MODIFIED_COLOR))
+        }
+        GitFileStatus::Conflict => Icon::new(IconName::Warning).color(Color::Custom(REMOVED_COLOR)),
+    }
+}
--- a/crates/git_ui/src/settings.rs
+++ b/crates/git_ui/src/settings.rs
@@ -0,0 +1,41 @@
+use gpui::Pixels;
+use schemars::JsonSchema;
+use serde_derive::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources};
+use workspace::dock::DockPosition;
+
+#[derive(Deserialize, Debug)]
+pub struct GitPanelSettings {
+    pub button: bool,
+    pub dock: DockPosition,
+    pub default_width: Pixels,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct PanelSettingsContent {
+    /// Whether to show the panel button in the status bar.
+    ///
+    /// Default: true
+    pub button: Option<bool>,
+    /// Where to dock the panel.
+    ///
+    /// Default: left
+    pub dock: Option<DockPosition>,
+    /// Default width of the panel in pixels.
+    ///
+    /// Default: 360
+    pub default_width: Option<f32>,
+}
+
+impl Settings for GitPanelSettings {
+    const KEY: Option<&'static str> = Some("git_panel");
+
+    type FileContent = PanelSettingsContent;
+
+    fn load(
+        sources: SettingsSources<Self::FileContent>,
+        _: &mut gpui::AppContext,
+    ) -> anyhow::Result<Self> {
+        sources.json_merge()
+    }
+}
--- a/crates/go_to_line/src/cursor_position.rs
+++ b/crates/go_to_line/src/cursor_position.rs
@@ -48,8 +48,17 @@ impl CursorPosition {
    ) {
        let editor = editor.downgrade();
        self.update_position = cx.spawn(|cursor_position, mut cx| async move {
-            if let Some(debounce) = debounce {
-                cx.background_executor().timer(debounce).await;
+            let is_singleton = editor
+                .update(&mut cx, |editor, cx| {
+                    editor.buffer().read(cx).is_singleton()
+                })
+                .ok()
+                .unwrap_or(true);
+
+            if !is_singleton {
+                if let Some(debounce) = debounce {
+                    cx.background_executor().timer(debounce).await;
+                }
            }

            editor
--- a/crates/gpui/examples/gradient.rs
+++ b/crates/gpui/examples/gradient.rs
@@ -0,0 +1,254 @@
+use gpui::{
+    canvas, div, linear_color_stop, linear_gradient, point, prelude::*, px, size, App, AppContext,
+    Bounds, ColorSpace, Half, Render, ViewContext, WindowOptions,
+};
+
+struct GradientViewer {
+    color_space: ColorSpace,
+}
+
+impl GradientViewer {
+    fn new() -> Self {
+        Self {
+            color_space: ColorSpace::default(),
+        }
+    }
+}
+
+impl Render for GradientViewer {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let color_space = self.color_space;
+
+        div()
+            .font_family(".SystemUIFont")
+            .bg(gpui::white())
+            .size_full()
+            .p_4()
+            .flex()
+            .flex_col()
+            .gap_3()
+            .child(
+                div()
+                    .flex()
+                    .gap_2()
+                    .justify_between()
+                    .items_center()
+                    .child("Gradient Examples")
+                    .child(
+                        div().flex().gap_2().items_center().child(
+                            div()
+                                .id("method")
+                                .flex()
+                                .px_3()
+                                .py_1()
+                                .text_sm()
+                                .bg(gpui::black())
+                                .text_color(gpui::white())
+                                .child(format!("{}", color_space))
+                                .active(|this| this.opacity(0.8))
+                                .on_click(cx.listener(move |this, _, cx| {
+                                    this.color_space = match this.color_space {
+                                        ColorSpace::Oklab => ColorSpace::Srgb,
+                                        ColorSpace::Srgb => ColorSpace::Oklab,
+                                    };
+                                    cx.notify();
+                                })),
+                        ),
+                    ),
+            )
+            .child(
+                div()
+                    .flex()
+                    .flex_1()
+                    .gap_3()
+                    .child(
+                        div()
+                            .size_full()
+                            .rounded_xl()
+                            .flex()
+                            .items_center()
+                            .justify_center()
+                            .bg(gpui::red())
+                            .text_color(gpui::white())
+                            .child("Solid Color"),
+                    )
+                    .child(
+                        div()
+                            .size_full()
+                            .rounded_xl()
+                            .flex()
+                            .items_center()
+                            .justify_center()
+                            .bg(gpui::blue())
+                            .text_color(gpui::white())
+                            .child("Solid Color"),
+                    ),
+            )
+            .child(
+                div()
+                    .flex()
+                    .flex_1()
+                    .gap_3()
+                    .h_24()
+                    .text_color(gpui::white())
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            45.,
+                            linear_color_stop(gpui::red(), 0.),
+                            linear_color_stop(gpui::blue(), 1.),
+                        )
+                        .color_space(color_space)),
+                    )
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            135.,
+                            linear_color_stop(gpui::red(), 0.),
+                            linear_color_stop(gpui::green(), 1.),
+                        )
+                        .color_space(color_space)),
+                    )
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            225.,
+                            linear_color_stop(gpui::green(), 0.),
+                            linear_color_stop(gpui::blue(), 1.),
+                        )
+                        .color_space(color_space)),
+                    )
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            315.,
+                            linear_color_stop(gpui::green(), 0.),
+                            linear_color_stop(gpui::yellow(), 1.),
+                        )
+                        .color_space(color_space)),
+                    ),
+            )
+            .child(
+                div()
+                    .flex()
+                    .flex_1()
+                    .gap_3()
+                    .h_24()
+                    .text_color(gpui::white())
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            0.,
+                            linear_color_stop(gpui::red(), 0.),
+                            linear_color_stop(gpui::white(), 1.),
+                        )
+                        .color_space(color_space)),
+                    )
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            90.,
+                            linear_color_stop(gpui::blue(), 0.),
+                            linear_color_stop(gpui::white(), 1.),
+                        )
+                        .color_space(color_space)),
+                    )
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            180.,
+                            linear_color_stop(gpui::green(), 0.),
+                            linear_color_stop(gpui::white(), 1.),
+                        )
+                        .color_space(color_space)),
+                    )
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            360.,
+                            linear_color_stop(gpui::yellow(), 0.),
+                            linear_color_stop(gpui::white(), 1.),
+                        )
+                        .color_space(color_space)),
+                    ),
+            )
+            .child(
+                div().flex_1().rounded_xl().bg(linear_gradient(
+                    0.,
+                    linear_color_stop(gpui::green(), 0.05),
+                    linear_color_stop(gpui::yellow(), 0.95),
+                )
+                .color_space(color_space)),
+            )
+            .child(
+                div().flex_1().rounded_xl().bg(linear_gradient(
+                    90.,
+                    linear_color_stop(gpui::blue(), 0.05),
+                    linear_color_stop(gpui::red(), 0.95),
+                )
+                .color_space(color_space)),
+            )
+            .child(
+                div()
+                    .flex()
+                    .flex_1()
+                    .gap_3()
+                    .child(
+                        div().flex().flex_1().gap_3().child(
+                            div().flex_1().rounded_xl().bg(linear_gradient(
+                                90.,
+                                linear_color_stop(gpui::blue(), 0.5),
+                                linear_color_stop(gpui::red(), 0.5),
+                            )
+                            .color_space(color_space)),
+                        ),
+                    )
+                    .child(
+                        div().flex_1().rounded_xl().bg(linear_gradient(
+                            180.,
+                            linear_color_stop(gpui::green(), 0.),
+                            linear_color_stop(gpui::blue(), 0.5),
+                        )
+                        .color_space(color_space)),
+                    ),
+            )
+            .child(div().h_24().child(canvas(
+                move |_, _| {},
+                move |bounds, _, cx| {
+                    let size = size(bounds.size.width * 0.8, px(80.));
+                    let square_bounds = Bounds {
+                        origin: point(
+                            bounds.size.width.half() - size.width.half(),
+                            bounds.origin.y,
+                        ),
+                        size,
+                    };
+                    let height = square_bounds.size.height;
+                    let horizontal_offset = height;
+                    let vertical_offset = px(30.);
+                    let mut path = gpui::Path::new(square_bounds.lower_left());
+                    path.line_to(square_bounds.origin + point(horizontal_offset, vertical_offset));
+                    path.line_to(
+                        square_bounds.upper_right() + point(-horizontal_offset, vertical_offset),
+                    );
+                    path.line_to(square_bounds.lower_right());
+                    path.line_to(square_bounds.lower_left());
+                    cx.paint_path(
+                        path,
+                        linear_gradient(
+                            180.,
+                            linear_color_stop(gpui::red(), 0.),
+                            linear_color_stop(gpui::blue(), 1.),
+                        )
+                        .color_space(color_space),
+                    );
+                },
+            )))
+    }
+}
+
+fn main() {
+    App::new().run(|cx: &mut AppContext| {
+        cx.open_window(
+            WindowOptions {
+                focus: true,
+                ..Default::default()
+            },
+            |cx| cx.new_view(|_| GradientViewer::new()),
+        )
+        .unwrap();
+        cx.activate(true);
+    });
+}
--- a/crates/gpui/src/color.rs
+++ b/crates/gpui/src/color.rs
@@ -548,6 +548,164 @@ impl<'de> Deserialize<'de> for Hsla {
    }
 }

+#[derive(Debug, Clone, Copy, PartialEq)]
+#[repr(C)]
+pub(crate) enum BackgroundTag {
+    Solid = 0,
+    LinearGradient = 1,
+}
+
+/// A color space for color interpolation.
+///
+/// References:
+/// - https://developer.mozilla.org/en-US/docs/Web/CSS/color-interpolation-method
+/// - https://www.w3.org/TR/css-color-4/#typedef-color-space
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+#[repr(C)]
+pub enum ColorSpace {
+    #[default]
+    /// The sRGB color space.
+    Srgb = 0,
+    /// The Oklab color space.
+    Oklab = 1,
+}
+
+impl Display for ColorSpace {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            ColorSpace::Srgb => write!(f, "sRGB"),
+            ColorSpace::Oklab => write!(f, "Oklab"),
+        }
+    }
+}
+
+/// A background color, which can be either a solid color or a linear gradient.
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[repr(C)]
+pub struct Background {
+    pub(crate) tag: BackgroundTag,
+    pub(crate) color_space: ColorSpace,
+    pub(crate) solid: Hsla,
+    pub(crate) angle: f32,
+    pub(crate) colors: [LinearColorStop; 2],
+    /// Padding for alignment for repr(C) layout.
+    pad: u32,
+}
+
+impl Eq for Background {}
+impl Default for Background {
+    fn default() -> Self {
+        Self {
+            tag: BackgroundTag::Solid,
+            solid: Hsla::default(),
+            color_space: ColorSpace::default(),
+            angle: 0.0,
+            colors: [LinearColorStop::default(), LinearColorStop::default()],
+            pad: 0,
+        }
+    }
+}
+
+/// Creates a LinearGradient background color.
+///
+/// The gradient line's angle of direction. A value of `0.` is equivalent to to top; increasing values rotate clockwise from there.
+///
+/// The `angle` is in degrees value in the range 0.0 to 360.0.
+///
+/// https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/linear-gradient
+pub fn linear_gradient(
+    angle: f32,
+    from: impl Into<LinearColorStop>,
+    to: impl Into<LinearColorStop>,
+) -> Background {
+    Background {
+        tag: BackgroundTag::LinearGradient,
+        angle,
+        colors: [from.into(), to.into()],
+        ..Default::default()
+    }
+}
+
+/// A color stop in a linear gradient.
+///
+/// https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/linear-gradient#linear-color-stop
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
+#[repr(C)]
+pub struct LinearColorStop {
+    /// The color of the color stop.
+    pub color: Hsla,
+    /// The percentage of the gradient, in the range 0.0 to 1.0.
+    pub percentage: f32,
+}
+
+/// Creates a new linear color stop.
+///
+/// The percentage of the gradient, in the range 0.0 to 1.0.
+pub fn linear_color_stop(color: impl Into<Hsla>, percentage: f32) -> LinearColorStop {
+    LinearColorStop {
+        color: color.into(),
+        percentage,
+    }
+}
+
+impl LinearColorStop {
+    /// Returns a new color stop with the same color, but with a modified alpha value.
+    pub fn opacity(&self, factor: f32) -> Self {
+        Self {
+            percentage: self.percentage,
+            color: self.color.opacity(factor),
+        }
+    }
+}
+
+impl Background {
+    /// Use specified color space for color interpolation.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/CSS/color-interpolation-method
+    pub fn color_space(mut self, color_space: ColorSpace) -> Self {
+        self.color_space = color_space;
+        self
+    }
+
+    /// Returns a new background color with the same hue, saturation, and lightness, but with a modified alpha value.
+    pub fn opacity(&self, factor: f32) -> Self {
+        let mut background = *self;
+        background.solid = background.solid.opacity(factor);
+        background.colors = [
+            self.colors[0].opacity(factor),
+            self.colors[1].opacity(factor),
+        ];
+        background
+    }
+
+    /// Returns whether the background color is transparent.
+    pub fn is_transparent(&self) -> bool {
+        match self.tag {
+            BackgroundTag::Solid => self.solid.is_transparent(),
+            BackgroundTag::LinearGradient => self.colors.iter().all(|c| c.color.is_transparent()),
+        }
+    }
+}
+
+impl From<Hsla> for Background {
+    fn from(value: Hsla) -> Self {
+        Background {
+            tag: BackgroundTag::Solid,
+            solid: value,
+            ..Default::default()
+        }
+    }
+}
+impl From<Rgba> for Background {
+    fn from(value: Rgba) -> Self {
+        Background {
+            tag: BackgroundTag::Solid,
+            solid: Hsla::from(value),
+            ..Default::default()
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use serde_json::json;
@@ -595,4 +753,32 @@ mod tests {

        assert_eq!(actual, rgba(0xdeadbeef))
    }
+
+    #[test]
+    fn test_background_solid() {
+        let color = Hsla::from(rgba(0xff0099ff));
+        let mut background = Background::from(color);
+        assert_eq!(background.tag, BackgroundTag::Solid);
+        assert_eq!(background.solid, color);
+
+        assert_eq!(background.opacity(0.5).solid, color.opacity(0.5));
+        assert_eq!(background.is_transparent(), false);
+        background.solid = hsla(0.0, 0.0, 0.0, 0.0);
+        assert_eq!(background.is_transparent(), true);
+    }
+
+    #[test]
+    fn test_background_linear_gradient() {
+        let from = linear_color_stop(rgba(0xff0099ff), 0.0);
+        let to = linear_color_stop(rgba(0x00ff99ff), 1.0);
+        let background = linear_gradient(90.0, from, to);
+        assert_eq!(background.tag, BackgroundTag::LinearGradient);
+        assert_eq!(background.colors[0], from);
+        assert_eq!(background.colors[1], to);
+
+        assert_eq!(background.opacity(0.5).colors[0], from.opacity(0.5));
+        assert_eq!(background.opacity(0.5).colors[1], to.opacity(0.5));
+        assert_eq!(background.is_transparent(), false);
+        assert_eq!(background.opacity(0.0).is_transparent(), true);
+    }
 }
--- a/crates/gpui/src/platform/blade/blade_renderer.rs
+++ b/crates/gpui/src/platform/blade/blade_renderer.rs
@@ -3,7 +3,7 @@

 use super::{BladeAtlas, PATH_TEXTURE_FORMAT};
 use crate::{
-    AtlasTextureKind, AtlasTile, Bounds, ContentMask, DevicePixels, GPUSpecs, Hsla,
+    AtlasTextureKind, AtlasTile, Background, Bounds, ContentMask, DevicePixels, GPUSpecs,
    MonochromeSprite, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad,
    ScaledPixels, Scene, Shadow, Size, Underline,
 };
@@ -174,7 +174,7 @@ struct ShaderSurfacesData {
 #[repr(C)]
 struct PathSprite {
    bounds: Bounds<ScaledPixels>,
-    color: Hsla,
+    color: Background,
    tile: AtlasTile,
 }

--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-file-diff"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M9 10h6"/><path d="M12 13V7"/><path d="M9 17h6"/></svg>`
				`@@ -0,0 +1 @@`
				`<svg width="16" height="16" fill="none" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd" clip-rule="evenodd" d="M4.56 4.502 3.25 3.027V11.5h1.5V6.973l2.69 3.025 1.31 1.475V7.918l3.306 3.582h2.042L8.55 5.491 7.25 4.081V7.528L4.56 4.502Z" fill="#000"/></svg>`