Add tooltips for edit icon and exact match toggle icon

keymap_ui: Open Keymap editor from settings dropdown (#34576 )
@probably-neb I guess we should be opening the keymap editor from title bar and menu as well. I believe this got missed in this: #34568. Release Notes: - Open Keymap editor from settings from menu and title bar.
2025-07-16 18:09:39 -04:00 · 2025-07-16 17:30:08 -04:00 · 2025-07-16 20:55:54 +00:00 · 2025-07-16 16:31:31 -04:00 · 2025-07-16 19:57:02 +00:00 · 2025-07-16 19:50:53 +00:00
63 changed files with 1405 additions and 3661 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -748,7 +748,7 @@ jobs:
    timeout-minutes: 120
    name: Create a Windows installer
    runs-on: [self-hosted, Windows, X64]
-    if: false && (startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling'))
+    if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
    needs: [windows_tests]
    env:
      AZURE_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
@@ -787,7 +787,7 @@ jobs:
      - name: Upload Artifacts to release
        uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
        # Re-enable when we are ready to publish windows preview releases
-        if: ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) && env.RELEASE_CHANNEL == 'preview' }} # upload only preview
+        if: false && ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) && env.RELEASE_CHANNEL == 'preview' }} # upload only preview
        with:
          draft: true
          prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2148,7 +2148,7 @@ dependencies = [
 [[package]]
 name = "blade-graphics"
 version = "0.6.0"
-source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
+source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
 dependencies = [
 "ash",
 "ash-window",
@@ -2181,7 +2181,7 @@ dependencies = [
 [[package]]
 name = "blade-macros"
 version = "0.3.0"
-source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
+source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2191,7 +2191,7 @@ dependencies = [
 [[package]]
 name = "blade-util"
 version = "0.2.0"
-source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
+source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
 dependencies = [
 "blade-graphics",
 "bytemuck",
@@ -14709,7 +14709,6 @@ dependencies = [
 "fs",
 "fuzzy",
 "gpui",
- "itertools 0.14.0",
 "language",
 "log",
 "menu",
@@ -14722,7 +14721,6 @@ dependencies = [
 "serde_json",
 "settings",
 "telemetry",
- "tempfile",
 "theme",
 "tree-sitter-json",
 "tree-sitter-rust",
@@ -20099,7 +20097,7 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.196.5"
+version = "0.197.0"
 dependencies = [
 "activity_indicator",
 "agent",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -434,9 +434,9 @@ aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
 aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
 base64 = "0.22"
 bitflags = "2.6.0"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
+blade-graphics = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
+blade-macros = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
 blake3 = "1.5.3"
 bytes = "1.0"
 cargo_metadata = "0.19"
@@ -489,7 +489,7 @@ json_dotpath = "1.1"
 jsonschema = "0.30.0"
 jsonwebtoken = "9.3"
 jupyter-protocol = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
-jupyter-websocket-client = {  git = "https://github.com/ConradIrwin/runtimed" ,rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+jupyter-websocket-client = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
@@ -500,7 +500,7 @@ metal = "0.29"
 moka = { version = "0.12.10", features = ["sync"] }
 naga = { version = "25.0", features = ["wgsl-in"] }
 nanoid = "0.4"
-nbformat = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+nbformat = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 nix = "0.29"
 num-format = "0.4.4"
 objc = "0.2"
@@ -541,7 +541,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "951c77
    "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
+runtimelib = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
    "async-dispatcher-runtime",
 ] }
 rust-embed = { version = "8.4", features = ["include-exclude"] }
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -1118,12 +1118,7 @@
      "ctrl-f": "search::FocusSearch",
      "alt-find": "keymap_editor::ToggleKeystrokeSearch",
      "alt-ctrl-f": "keymap_editor::ToggleKeystrokeSearch",
-      "alt-c": "keymap_editor::ToggleConflictFilter",
-      "enter": "keymap_editor::EditBinding",
-      "alt-enter": "keymap_editor::CreateBinding",
-      "ctrl-c": "keymap_editor::CopyAction",
-      "ctrl-shift-c": "keymap_editor::CopyContext",
-      "ctrl-t": "keymap_editor::ShowMatchingKeybinds"
+      "alt-c": "keymap_editor::ToggleConflictFilter"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -1216,14 +1216,8 @@
    "context": "KeymapEditor",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-f": "search::FocusSearch",
      "cmd-alt-f": "keymap_editor::ToggleKeystrokeSearch",
-      "cmd-alt-c": "keymap_editor::ToggleConflictFilter",
-      "enter": "keymap_editor::EditBinding",
-      "alt-enter": "keymap_editor::CreateBinding",
-      "cmd-c": "keymap_editor::CopyAction",
-      "cmd-shift-c": "keymap_editor::CopyContext",
-      "cmd-t": "keymap_editor::ShowMatchingKeybinds"
+      "cmd-alt-c": "keymap_editor::ToggleConflictFilter"
    }
  },
  {
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -817,7 +817,7 @@
          "edit_file": true,
          "fetch": true,
          "list_directory": true,
-          "project_notifications": false,
+          "project_notifications": true,
          "move_path": true,
          "now": true,
          "find_path": true,
@@ -837,7 +837,7 @@
          "diagnostics": true,
          "fetch": true,
          "list_directory": true,
-          "project_notifications": false,
+          "project_notifications": true,
          "now": true,
          "find_path": true,
          "read_file": true,
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -396,7 +396,6 @@ pub struct Thread {
    remaining_turns: u32,
    configured_model: Option<ConfiguredModel>,
    profile: AgentProfile,
-    last_error_context: Option<(Arc<dyn LanguageModel>, CompletionIntent)>,
 }

 #[derive(Clone, Debug)]
@@ -490,11 +489,10 @@ impl Thread {
            retry_state: None,
            message_feedback: HashMap::default(),
            last_auto_capture_at: None,
-            last_error_context: None,
            last_received_chunk_at: None,
            request_callback: None,
            remaining_turns: u32::MAX,
-            configured_model: configured_model.clone(),
+            configured_model,
            profile: AgentProfile::new(profile_id, tools),
        }
    }
@@ -615,7 +613,6 @@ impl Thread {
            feedback: None,
            message_feedback: HashMap::default(),
            last_auto_capture_at: None,
-            last_error_context: None,
            last_received_chunk_at: None,
            request_callback: None,
            remaining_turns: u32::MAX,
@@ -1267,58 +1264,9 @@ impl Thread {

        self.flush_notifications(model.clone(), intent, cx);

-        let _checkpoint = self.finalize_pending_checkpoint(cx);
-        self.stream_completion(
-            self.to_completion_request(model.clone(), intent, cx),
-            model,
-            intent,
-            window,
-            cx,
-        );
-    }
+        let request = self.to_completion_request(model.clone(), intent, cx);

-    pub fn retry_last_completion(
-        &mut self,
-        window: Option<AnyWindowHandle>,
-        cx: &mut Context<Self>,
-    ) {
-        // Clear any existing error state
-        self.retry_state = None;
-
-        // Use the last error context if available, otherwise fall back to configured model
-        let (model, intent) = if let Some((model, intent)) = self.last_error_context.take() {
-            (model, intent)
-        } else if let Some(configured_model) = self.configured_model.as_ref() {
-            let model = configured_model.model.clone();
-            let intent = if self.has_pending_tool_uses() {
-                CompletionIntent::ToolResults
-            } else {
-                CompletionIntent::UserPrompt
-            };
-            (model, intent)
-        } else if let Some(configured_model) = self.get_or_init_configured_model(cx) {
-            let model = configured_model.model.clone();
-            let intent = if self.has_pending_tool_uses() {
-                CompletionIntent::ToolResults
-            } else {
-                CompletionIntent::UserPrompt
-            };
-            (model, intent)
-        } else {
-            return;
-        };
-
-        self.send_to_model(model, intent, window, cx);
-    }
-
-    pub fn enable_burn_mode_and_retry(
-        &mut self,
-        window: Option<AnyWindowHandle>,
-        cx: &mut Context<Self>,
-    ) {
-        self.completion_mode = CompletionMode::Burn;
-        cx.emit(ThreadEvent::ProfileChanged);
-        self.retry_last_completion(window, cx);
+        self.stream_completion(request, model, intent, window, cx);
    }

    pub fn used_tools_since_last_user_message(&self) -> bool {
@@ -2198,35 +2146,6 @@ impl Thread {
                    max_attempts: MAX_RETRY_ATTEMPTS,
                })
            }
-            UpstreamProviderError {
-                status,
-                retry_after,
-                ..
-            } => match *status {
-                StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE => {
-                    Some(RetryStrategy::Fixed {
-                        delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
-                        max_attempts: MAX_RETRY_ATTEMPTS,
-                    })
-                }
-                StatusCode::INTERNAL_SERVER_ERROR => Some(RetryStrategy::Fixed {
-                    delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
-                    // Internal Server Error could be anything, so only retry once.
-                    max_attempts: 1,
-                }),
-                status => {
-                    // There is no StatusCode variant for the unofficial HTTP 529 ("The service is overloaded"),
-                    // but we frequently get them in practice. See https://http.dev/529
-                    if status.as_u16() == 529 {
-                        Some(RetryStrategy::Fixed {
-                            delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
-                            max_attempts: MAX_RETRY_ATTEMPTS,
-                        })
-                    } else {
-                        None
-                    }
-                }
-            },
            ApiInternalServerError { .. } => Some(RetryStrategy::Fixed {
                delay: BASE_RETRY_DELAY,
                max_attempts: 1,
@@ -2274,23 +2193,6 @@ impl Thread {
        window: Option<AnyWindowHandle>,
        cx: &mut Context<Self>,
    ) -> bool {
-        // Store context for the Retry button
-        self.last_error_context = Some((model.clone(), intent));
-
-        // Only auto-retry if Burn Mode is enabled
-        if self.completion_mode != CompletionMode::Burn {
-            // Show error with retry options
-            cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError {
-                message: format!(
-                    "{}\n\nTo automatically retry when similar errors happen, enable Burn Mode.",
-                    error
-                )
-                .into(),
-                can_enable_burn_mode: true,
-            }));
-            return false;
-        }
-
        let Some(strategy) = strategy.or_else(|| Self::get_retry_strategy(error)) else {
            return false;
        };
@@ -2371,13 +2273,6 @@ impl Thread {
            // Stop generating since we're giving up on retrying.
            self.pending_completions.clear();

-            // Show error alongside a Retry button, but no
-            // Enable Burn Mode button (since it's already enabled)
-            cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError {
-                message: format!("Failed after retrying: {}", error).into(),
-                can_enable_burn_mode: false,
-            }));
-
            false
        }
    }
@@ -3288,11 +3183,6 @@ pub enum ThreadError {
        header: SharedString,
        message: SharedString,
    },
-    #[error("Retryable error: {message}")]
-    RetryableError {
-        message: SharedString,
-        can_enable_burn_mode: bool,
-    },
 }

 #[derive(Debug, Clone)]
@@ -3693,7 +3583,6 @@ fn main() {{
    }

    #[gpui::test]
-    #[ignore] // turn this test on when project_notifications tool is re-enabled
    async fn test_stale_buffer_notification(cx: &mut TestAppContext) {
        init_test_settings(cx);

@@ -4248,11 +4137,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // Create model that returns overloaded error
        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));

@@ -4326,11 +4210,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // Create model that returns internal server error
        let model = Arc::new(ErrorInjector::new(TestError::InternalServerError));

@@ -4407,11 +4286,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // Create model that returns internal server error
        let model = Arc::new(ErrorInjector::new(TestError::InternalServerError));

@@ -4519,11 +4393,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // Create model that returns overloaded error
        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));

@@ -4610,11 +4479,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // We'll use a wrapper to switch behavior after first failure
        struct RetryTestModel {
            inner: Arc<FakeLanguageModel>,
@@ -4783,11 +4647,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // Create a model that fails once then succeeds
        struct FailOnceModel {
            inner: Arc<FakeLanguageModel>,
@@ -4949,11 +4808,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // Create a model that returns rate limit error with retry_after
        struct RateLimitModel {
            inner: Arc<FakeLanguageModel>,
@@ -5227,79 +5081,6 @@ fn main() {{
        );
    }

-    #[gpui::test]
-    async fn test_no_retry_without_burn_mode(cx: &mut TestAppContext) {
-        init_test_settings(cx);
-
-        let project = create_test_project(cx, json!({})).await;
-        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
-
-        // Ensure we're in Normal mode (not Burn mode)
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Normal);
-        });
-
-        // Track error events
-        let error_events = Arc::new(Mutex::new(Vec::new()));
-        let error_events_clone = error_events.clone();
-
-        let _subscription = thread.update(cx, |_, cx| {
-            cx.subscribe(&thread, move |_, _, event: &ThreadEvent, _| {
-                if let ThreadEvent::ShowError(error) = event {
-                    error_events_clone.lock().push(error.clone());
-                }
-            })
-        });
-
-        // Create model that returns overloaded error
-        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));
-
-        // Insert a user message
-        thread.update(cx, |thread, cx| {
-            thread.insert_user_message("Hello!", ContextLoadResult::default(), None, vec![], cx);
-        });
-
-        // Start completion
-        thread.update(cx, |thread, cx| {
-            thread.send_to_model(model.clone(), CompletionIntent::UserPrompt, None, cx);
-        });
-
-        cx.run_until_parked();
-
-        // Verify no retry state was created
-        thread.read_with(cx, |thread, _| {
-            assert!(
-                thread.retry_state.is_none(),
-                "Should not have retry state in Normal mode"
-            );
-        });
-
-        // Check that a retryable error was reported
-        let errors = error_events.lock();
-        assert!(!errors.is_empty(), "Should have received an error event");
-
-        if let ThreadError::RetryableError {
-            message: _,
-            can_enable_burn_mode,
-        } = &errors[0]
-        {
-            assert!(
-                *can_enable_burn_mode,
-                "Error should indicate burn mode can be enabled"
-            );
-        } else {
-            panic!("Expected RetryableError, got {:?}", errors[0]);
-        }
-
-        // Verify the thread is no longer generating
-        thread.read_with(cx, |thread, _| {
-            assert!(
-                !thread.is_generating(),
-                "Should not be generating after error without retry"
-            );
-        });
-    }
-
    #[gpui::test]
    async fn test_retry_cancelled_on_stop(cx: &mut TestAppContext) {
        init_test_settings(cx);
@@ -5307,11 +5088,6 @@ fn main() {{
        let project = create_test_project(cx, json!({})).await;
        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;

-        // Enable Burn Mode to allow retries
-        thread.update(cx, |thread, _| {
-            thread.set_completion_mode(CompletionMode::Burn);
-        });
-
        // Create model that returns overloaded error
        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));

--- a/crates/agent_ui/src/active_thread.rs
+++ b/crates/agent_ui/src/active_thread.rs
@@ -1036,7 +1036,7 @@ impl ActiveThread {
                            .collect::<Vec<_>>()
                            .join("\n");
                        self.last_error = Some(ThreadError::Message {
-                            header: "Error".into(),
+                            header: "Error interacting with language model".into(),
                            message: error_message.into(),
                        });
                    }
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -64,9 +64,8 @@ use theme::ThemeSettings;
 use time::UtcOffset;
 use ui::utils::WithRemSize;
 use ui::{
-    Banner, Button, Callout, CheckboxWithLabel, ContextMenu, ElevationIndex, IconPosition,
-    KeyBinding, PopoverMenu, PopoverMenuHandle, ProgressBar, Tab, Tooltip, Vector, VectorName,
-    prelude::*,
+    Banner, Callout, CheckboxWithLabel, ContextMenu, ElevationIndex, KeyBinding, PopoverMenu,
+    PopoverMenuHandle, ProgressBar, Tab, Tooltip, Vector, VectorName, prelude::*,
 };
 use util::ResultExt as _;
 use workspace::{
@@ -2914,21 +2913,6 @@ impl AgentPanel {
            .size(IconSize::Small)
            .color(Color::Error);

-        let retry_button = Button::new("retry", "Retry")
-            .icon(IconName::RotateCw)
-            .icon_position(IconPosition::Start)
-            .on_click({
-                let thread = thread.clone();
-                move |_, window, cx| {
-                    thread.update(cx, |thread, cx| {
-                        thread.clear_last_error();
-                        thread.thread().update(cx, |thread, cx| {
-                            thread.retry_last_completion(Some(window.window_handle()), cx);
-                        });
-                    });
-                }
-            });
-
        div()
            .border_t_1()
            .border_color(cx.theme().colors().border)
@@ -2937,72 +2921,13 @@ impl AgentPanel {
                    .icon(icon)
                    .title(header)
                    .description(message.clone())
-                    .primary_action(retry_button)
-                    .secondary_action(self.dismiss_error_button(thread, cx))
-                    .tertiary_action(self.create_copy_button(message_with_header))
+                    .primary_action(self.dismiss_error_button(thread, cx))
+                    .secondary_action(self.create_copy_button(message_with_header))
                    .bg_color(self.error_callout_bg(cx)),
            )
            .into_any_element()
    }

-    fn render_retryable_error(
-        &self,
-        message: SharedString,
-        can_enable_burn_mode: bool,
-        thread: &Entity<ActiveThread>,
-        cx: &mut Context<Self>,
-    ) -> AnyElement {
-        let icon = Icon::new(IconName::XCircle)
-            .size(IconSize::Small)
-            .color(Color::Error);
-
-        let retry_button = Button::new("retry", "Retry")
-            .icon(IconName::RotateCw)
-            .icon_position(IconPosition::Start)
-            .on_click({
-                let thread = thread.clone();
-                move |_, window, cx| {
-                    thread.update(cx, |thread, cx| {
-                        thread.clear_last_error();
-                        thread.thread().update(cx, |thread, cx| {
-                            thread.retry_last_completion(Some(window.window_handle()), cx);
-                        });
-                    });
-                }
-            });
-
-        let mut callout = Callout::new()
-            .icon(icon)
-            .title("Error")
-            .description(message.clone())
-            .bg_color(self.error_callout_bg(cx))
-            .primary_action(retry_button);
-
-        if can_enable_burn_mode {
-            let burn_mode_button = Button::new("enable_burn_retry", "Enable Burn Mode and Retry")
-                .icon(IconName::ZedBurnMode)
-                .icon_position(IconPosition::Start)
-                .on_click({
-                    let thread = thread.clone();
-                    move |_, window, cx| {
-                        thread.update(cx, |thread, cx| {
-                            thread.clear_last_error();
-                            thread.thread().update(cx, |thread, cx| {
-                                thread.enable_burn_mode_and_retry(Some(window.window_handle()), cx);
-                            });
-                        });
-                    }
-                });
-            callout = callout.secondary_action(burn_mode_button);
-        }
-
-        div()
-            .border_t_1()
-            .border_color(cx.theme().colors().border)
-            .child(callout)
-            .into_any_element()
-    }
-
    fn render_prompt_editor(
        &self,
        context_editor: &Entity<TextThreadEditor>,
@@ -3244,15 +3169,6 @@ impl Render for AgentPanel {
                                    ThreadError::Message { header, message } => {
                                        self.render_error_message(header, message, thread, cx)
                                    }
-                                    ThreadError::RetryableError {
-                                        message,
-                                        can_enable_burn_mode,
-                                    } => self.render_retryable_error(
-                                        message,
-                                        can_enable_burn_mode,
-                                        thread,
-                                        cx,
-                                    ),
                                })
                                .into_any(),
                        )
--- a/crates/assistant_tools/src/edit_agent/evals.rs
+++ b/crates/assistant_tools/src/edit_agent/evals.rs
@@ -12,7 +12,6 @@ use collections::HashMap;
 use fs::FakeFs;
 use futures::{FutureExt, future::LocalBoxFuture};
 use gpui::{AppContext, TestAppContext, Timer};
-use http_client::StatusCode;
 use indoc::{formatdoc, indoc};
 use language_model::{
    LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult,
@@ -1676,30 +1675,6 @@ async fn retry_on_rate_limit<R>(mut request: impl AsyncFnMut() -> Result<R>) ->
                        Timer::after(retry_after + jitter).await;
                        continue;
                    }
-                    LanguageModelCompletionError::UpstreamProviderError {
-                        status,
-                        retry_after,
-                        ..
-                    } => {
-                        // Only retry for specific status codes
-                        let should_retry = matches!(
-                            *status,
-                            StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE
-                        ) || status.as_u16() == 529;
-
-                        if !should_retry {
-                            return Err(err.into());
-                        }
-
-                        // Use server-provided retry_after if available, otherwise use default
-                        let retry_after = retry_after.unwrap_or(Duration::from_secs(5));
-                        let jitter = retry_after.mul_f64(rand::thread_rng().gen_range(0.0..1.0));
-                        eprintln!(
-                            "Attempt #{attempt}: {err}. Retry after {retry_after:?} + jitter of {jitter:?}"
-                        );
-                        Timer::after(retry_after + jitter).await;
-                        continue;
-                    }
                    _ => return Err(err.into()),
                },
                Err(err) => return Err(err),
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -9570,74 +9570,6 @@ async fn test_document_format_during_save(cx: &mut TestAppContext) {
    }
 }

-#[gpui::test]
-async fn test_redo_after_noop_format(cx: &mut TestAppContext) {
-    init_test(cx, |settings| {
-        settings.defaults.ensure_final_newline_on_save = Some(false);
-    });
-
-    let fs = FakeFs::new(cx.executor());
-    fs.insert_file(path!("/file.txt"), "foo".into()).await;
-
-    let project = Project::test(fs, [path!("/file.txt").as_ref()], cx).await;
-
-    let buffer = project
-        .update(cx, |project, cx| {
-            project.open_local_buffer(path!("/file.txt"), cx)
-        })
-        .await
-        .unwrap();
-
-    let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
-    let (editor, cx) = cx.add_window_view(|window, cx| {
-        build_editor_with_project(project.clone(), buffer, window, cx)
-    });
-    editor.update_in(cx, |editor, window, cx| {
-        editor.change_selections(SelectionEffects::default(), window, cx, |s| {
-            s.select_ranges([0..0])
-        });
-    });
-    assert!(!cx.read(|cx| editor.is_dirty(cx)));
-
-    editor.update_in(cx, |editor, window, cx| {
-        editor.handle_input("\n", window, cx)
-    });
-    cx.run_until_parked();
-    save(&editor, &project, cx).await;
-    assert_eq!("\nfoo", editor.read_with(cx, |editor, cx| editor.text(cx)));
-
-    editor.update_in(cx, |editor, window, cx| {
-        editor.undo(&Default::default(), window, cx);
-    });
-    save(&editor, &project, cx).await;
-    assert_eq!("foo", editor.read_with(cx, |editor, cx| editor.text(cx)));
-
-    editor.update_in(cx, |editor, window, cx| {
-        editor.redo(&Default::default(), window, cx);
-    });
-    cx.run_until_parked();
-    assert_eq!("\nfoo", editor.read_with(cx, |editor, cx| editor.text(cx)));
-
-    async fn save(editor: &Entity<Editor>, project: &Entity<Project>, cx: &mut VisualTestContext) {
-        let save = editor
-            .update_in(cx, |editor, window, cx| {
-                editor.save(
-                    SaveOptions {
-                        format: true,
-                        autosave: false,
-                    },
-                    project.clone(),
-                    window,
-                    cx,
-                )
-            })
-            .unwrap();
-        cx.executor().start_waiting();
-        save.await;
-        assert!(!cx.read(|cx| editor.is_dirty(cx)));
-    }
-}
-
 #[gpui::test]
 async fn test_multibuffer_format_during_save(cx: &mut TestAppContext) {
    init_test(cx, |_| {});
@@ -22776,7 +22708,7 @@ pub(crate) fn init_test(cx: &mut TestAppContext, f: fn(&mut AllLanguageSettingsC
        workspace::init_settings(cx);
        crate::init(cx);
    });
-    zlog::init_test();
+
    update_test_language_settings(cx, f);
 }

--- a/crates/editor/src/scroll.rs
+++ b/crates/editor/src/scroll.rs
@@ -12,7 +12,7 @@ use crate::{
 };
 pub use autoscroll::{Autoscroll, AutoscrollStrategy};
 use core::fmt::Debug;
-use gpui::{Along, App, Axis, Context, Global, Pixels, Task, Window, point, px};
+use gpui::{App, Axis, Context, Global, Pixels, Task, Window, point, px};
 use language::language_settings::{AllLanguageSettings, SoftWrap};
 use language::{Bias, Point};
 pub use scroll_amount::ScrollAmount;
@@ -49,14 +49,14 @@ impl ScrollAnchor {
    }

    pub fn scroll_position(&self, snapshot: &DisplaySnapshot) -> gpui::Point<f32> {
-        self.offset.apply_along(Axis::Vertical, |offset| {
-            if self.anchor == Anchor::min() {
-                0.
-            } else {
-                let scroll_top = self.anchor.to_display_point(snapshot).row().as_f32();
-                (offset + scroll_top).max(0.)
-            }
-        })
+        let mut scroll_position = self.offset;
+        if self.anchor == Anchor::min() {
+            scroll_position.y = 0.;
+        } else {
+            let scroll_top = self.anchor.to_display_point(snapshot).row().as_f32();
+            scroll_position.y += scroll_top;
+        }
+        scroll_position
    }

    pub fn top_row(&self, buffer: &MultiBufferSnapshot) -> u32 {
--- a/crates/eval/src/example.rs
+++ b/crates/eval/src/example.rs
@@ -422,13 +422,6 @@ impl AppContext for ExampleContext {
        self.app.update_entity(handle, update)
    }

-    fn as_mut<'a, T>(&'a mut self, handle: &Entity<T>) -> Self::Result<gpui::GpuiBorrow<'a, T>>
-    where
-        T: 'static,
-    {
-        self.app.as_mut(handle)
-    }
-
    fn read_entity<T, R>(
        &self,
        handle: &Entity<T>,
--- a/crates/gpui/build.rs
+++ b/crates/gpui/build.rs
@@ -126,7 +126,7 @@ mod macos {
            "ContentMask".into(),
            "Uniforms".into(),
            "AtlasTile".into(),
-            "PathRasterizationInputIndex".into(),
+            "PathInputIndex".into(),
            "PathVertex_ScaledPixels".into(),
            "ShadowInputIndex".into(),
            "Shadow".into(),
--- a/crates/gpui/examples/painting.rs
+++ b/crates/gpui/examples/painting.rs
@@ -1,9 +1,13 @@
 use gpui::{
    Application, Background, Bounds, ColorSpace, Context, MouseDownEvent, Path, PathBuilder,
-    PathStyle, Pixels, Point, Render, SharedString, StrokeOptions, Window, WindowOptions, canvas,
-    div, linear_color_stop, linear_gradient, point, prelude::*, px, rgb, size,
+    PathStyle, Pixels, Point, Render, SharedString, StrokeOptions, Window, WindowBounds,
+    WindowOptions, canvas, div, linear_color_stop, linear_gradient, point, prelude::*, px, rgb,
+    size,
 };

+const DEFAULT_WINDOW_WIDTH: Pixels = px(1024.0);
+const DEFAULT_WINDOW_HEIGHT: Pixels = px(768.0);
+
 struct PaintingViewer {
    default_lines: Vec<(Path<Pixels>, Background)>,
    lines: Vec<Vec<Point<Pixels>>>,
@@ -147,8 +151,6 @@ impl PaintingViewer {
                px(320.0 + (i as f32 * 10.0).sin() * 40.0),
            ));
        }
-        let path = builder.build().unwrap();
-        lines.push((path, gpui::green().into()));

        Self {
            default_lines: lines.clone(),
@@ -183,9 +185,13 @@ fn button(
 }

 impl Render for PaintingViewer {
-    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        window.request_animation_frame();
+
        let default_lines = self.default_lines.clone();
        let lines = self.lines.clone();
+        let window_size = window.bounds().size;
+        let scale = window_size.width / DEFAULT_WINDOW_WIDTH;
        let dashed = self.dashed;

        div()
@@ -222,7 +228,7 @@ impl Render for PaintingViewer {
                            move |_, _, _| {},
                            move |_, _, window, _| {
                                for (path, color) in default_lines {
-                                    window.paint_path(path, color);
+                                    window.paint_path(path.clone().scale(scale), color);
                                }

                                for points in lines {
@@ -298,6 +304,11 @@ fn main() {
        cx.open_window(
            WindowOptions {
                focus: true,
+                window_bounds: Some(WindowBounds::Windowed(Bounds::centered(
+                    None,
+                    size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT),
+                    cx,
+                ))),
                ..Default::default()
            },
            |window, cx| cx.new(|cx| PaintingViewer::new(window, cx)),
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -448,23 +448,15 @@ impl App {
    }

    pub(crate) fn update<R>(&mut self, update: impl FnOnce(&mut Self) -> R) -> R {
-        self.start_update();
-        let result = update(self);
-        self.finish_update();
-        result
-    }
-
-    pub(crate) fn start_update(&mut self) {
        self.pending_updates += 1;
-    }
-
-    pub(crate) fn finish_update(&mut self) {
+        let result = update(self);
        if !self.flushing_effects && self.pending_updates == 1 {
            self.flushing_effects = true;
            self.flush_effects();
            self.flushing_effects = false;
        }
        self.pending_updates -= 1;
+        result
    }

    /// Arrange a callback to be invoked when the given entity calls `notify` on its respective context.
@@ -876,6 +868,7 @@ impl App {
        loop {
            self.release_dropped_entities();
            self.release_dropped_focus_handles();
+
            if let Some(effect) = self.pending_effects.pop_front() {
                match effect {
                    Effect::Notify { emitter } => {
@@ -1826,13 +1819,6 @@ impl AppContext for App {
        })
    }

-    fn as_mut<'a, T>(&'a mut self, handle: &Entity<T>) -> GpuiBorrow<'a, T>
-    where
-        T: 'static,
-    {
-        GpuiBorrow::new(handle.clone(), self)
-    }
-
    fn read_entity<T, R>(
        &self,
        handle: &Entity<T>,
@@ -2029,79 +2015,3 @@ impl HttpClient for NullHttpClient {
        type_name::<Self>()
    }
 }
-
-/// A mutable reference to an entity owned by GPUI
-pub struct GpuiBorrow<'a, T> {
-    inner: Option<Lease<T>>,
-    app: &'a mut App,
-}
-
-impl<'a, T: 'static> GpuiBorrow<'a, T> {
-    fn new(inner: Entity<T>, app: &'a mut App) -> Self {
-        app.start_update();
-        let lease = app.entities.lease(&inner);
-        Self {
-            inner: Some(lease),
-            app,
-        }
-    }
-}
-
-impl<'a, T: 'static> std::borrow::Borrow<T> for GpuiBorrow<'a, T> {
-    fn borrow(&self) -> &T {
-        self.inner.as_ref().unwrap().borrow()
-    }
-}
-
-impl<'a, T: 'static> std::borrow::BorrowMut<T> for GpuiBorrow<'a, T> {
-    fn borrow_mut(&mut self) -> &mut T {
-        self.inner.as_mut().unwrap().borrow_mut()
-    }
-}
-
-impl<'a, T> Drop for GpuiBorrow<'a, T> {
-    fn drop(&mut self) {
-        let lease = self.inner.take().unwrap();
-        self.app.notify(lease.id);
-        self.app.entities.end_lease(lease);
-        self.app.finish_update();
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::{cell::RefCell, rc::Rc};
-
-    use crate::{AppContext, TestAppContext};
-
-    #[test]
-    fn test_gpui_borrow() {
-        let cx = TestAppContext::single();
-        let observation_count = Rc::new(RefCell::new(0));
-
-        let state = cx.update(|cx| {
-            let state = cx.new(|_| false);
-            cx.observe(&state, {
-                let observation_count = observation_count.clone();
-                move |_, _| {
-                    let mut count = observation_count.borrow_mut();
-                    *count += 1;
-                }
-            })
-            .detach();
-
-            state
-        });
-
-        cx.update(|cx| {
-            // Calling this like this so that we don't clobber the borrow_mut above
-            *std::borrow::BorrowMut::borrow_mut(&mut state.as_mut(cx)) = true;
-        });
-
-        cx.update(|cx| {
-            state.write(cx, false);
-        });
-
-        assert_eq!(*observation_count.borrow(), 2);
-    }
-}
--- a/crates/gpui/src/app/async_context.rs
+++ b/crates/gpui/src/app/async_context.rs
@@ -3,7 +3,7 @@ use crate::{
    Entity, EventEmitter, Focusable, ForegroundExecutor, Global, PromptButton, PromptLevel, Render,
    Reservation, Result, Subscription, Task, VisualContext, Window, WindowHandle,
 };
-use anyhow::{Context as _, anyhow};
+use anyhow::Context as _;
 use derive_more::{Deref, DerefMut};
 use futures::channel::oneshot;
 use std::{future::Future, rc::Weak};
@@ -58,15 +58,6 @@ impl AppContext for AsyncApp {
        Ok(app.update_entity(handle, update))
    }

-    fn as_mut<'a, T>(&'a mut self, _handle: &Entity<T>) -> Self::Result<super::GpuiBorrow<'a, T>>
-    where
-        T: 'static,
-    {
-        Err(anyhow!(
-            "Cannot as_mut with an async context. Try calling update() first"
-        ))
-    }
-
    fn read_entity<T, R>(
        &self,
        handle: &Entity<T>,
@@ -373,15 +364,6 @@ impl AppContext for AsyncWindowContext {
            .update(self, |_, _, cx| cx.update_entity(handle, update))
    }

-    fn as_mut<'a, T>(&'a mut self, _: &Entity<T>) -> Self::Result<super::GpuiBorrow<'a, T>>
-    where
-        T: 'static,
-    {
-        Err(anyhow!(
-            "Cannot use as_mut() from an async context, call `update`"
-        ))
-    }
-
    fn read_entity<T, R>(
        &self,
        handle: &Entity<T>,
--- a/crates/gpui/src/app/context.rs
+++ b/crates/gpui/src/app/context.rs
@@ -726,13 +726,6 @@ impl<T> AppContext for Context<'_, T> {
        self.app.update_entity(handle, update)
    }

-    fn as_mut<'a, E>(&'a mut self, handle: &Entity<E>) -> Self::Result<super::GpuiBorrow<'a, E>>
-    where
-        E: 'static,
-    {
-        self.app.as_mut(handle)
-    }
-
    fn read_entity<U, R>(
        &self,
        handle: &Entity<U>,
--- a/crates/gpui/src/app/entity_map.rs
+++ b/crates/gpui/src/app/entity_map.rs
@@ -1,4 +1,4 @@
-use crate::{App, AppContext, GpuiBorrow, VisualContext, Window, seal::Sealed};
+use crate::{App, AppContext, VisualContext, Window, seal::Sealed};
 use anyhow::{Context as _, Result};
 use collections::FxHashSet;
 use derive_more::{Deref, DerefMut};
@@ -105,7 +105,7 @@ impl EntityMap {

    /// Move an entity to the stack.
    #[track_caller]
-    pub fn lease<T>(&mut self, pointer: &Entity<T>) -> Lease<T> {
+    pub fn lease<'a, T>(&mut self, pointer: &'a Entity<T>) -> Lease<'a, T> {
        self.assert_valid_context(pointer);
        let mut accessed_entities = self.accessed_entities.borrow_mut();
        accessed_entities.insert(pointer.entity_id);
@@ -117,14 +117,15 @@ impl EntityMap {
        );
        Lease {
            entity,
-            id: pointer.entity_id,
+            pointer,
            entity_type: PhantomData,
        }
    }

    /// Returns an entity after moving it to the stack.
    pub fn end_lease<T>(&mut self, mut lease: Lease<T>) {
-        self.entities.insert(lease.id, lease.entity.take().unwrap());
+        self.entities
+            .insert(lease.pointer.entity_id, lease.entity.take().unwrap());
    }

    pub fn read<T: 'static>(&self, entity: &Entity<T>) -> &T {
@@ -186,13 +187,13 @@ fn double_lease_panic<T>(operation: &str) -> ! {
    )
 }

-pub(crate) struct Lease<T> {
+pub(crate) struct Lease<'a, T> {
    entity: Option<Box<dyn Any>>,
-    pub id: EntityId,
+    pub pointer: &'a Entity<T>,
    entity_type: PhantomData<T>,
 }

-impl<T: 'static> core::ops::Deref for Lease<T> {
+impl<T: 'static> core::ops::Deref for Lease<'_, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
@@ -200,13 +201,13 @@ impl<T: 'static> core::ops::Deref for Lease<T> {
    }
 }

-impl<T: 'static> core::ops::DerefMut for Lease<T> {
+impl<T: 'static> core::ops::DerefMut for Lease<'_, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.entity.as_mut().unwrap().downcast_mut().unwrap()
    }
 }

-impl<T> Drop for Lease<T> {
+impl<T> Drop for Lease<'_, T> {
    fn drop(&mut self) {
        if self.entity.is_some() && !panicking() {
            panic!("Leases must be ended with EntityMap::end_lease")
@@ -436,19 +437,6 @@ impl<T: 'static> Entity<T> {
        cx.update_entity(self, update)
    }

-    /// Updates the entity referenced by this handle with the given function.
-    pub fn as_mut<'a, C: AppContext>(&self, cx: &'a mut C) -> C::Result<GpuiBorrow<'a, T>> {
-        cx.as_mut(self)
-    }
-
-    /// Updates the entity referenced by this handle with the given function.
-    pub fn write<C: AppContext>(&self, cx: &mut C, value: T) -> C::Result<()> {
-        self.update(cx, |entity, cx| {
-            *entity = value;
-            cx.notify();
-        })
-    }
-
    /// Updates the entity referenced by this handle with the given function if
    /// the referenced entity still exists, within a visual context that has a window.
    /// Returns an error if the entity has been released.
--- a/crates/gpui/src/app/test_context.rs
+++ b/crates/gpui/src/app/test_context.rs
@@ -9,7 +9,6 @@ use crate::{
 };
 use anyhow::{anyhow, bail};
 use futures::{Stream, StreamExt, channel::oneshot};
-use rand::{SeedableRng, rngs::StdRng};
 use std::{cell::RefCell, future::Future, ops::Deref, rc::Rc, sync::Arc, time::Duration};

 /// A TestAppContext is provided to tests created with `#[gpui::test]`, it provides
@@ -64,13 +63,6 @@ impl AppContext for TestAppContext {
        app.update_entity(handle, update)
    }

-    fn as_mut<'a, T>(&'a mut self, _: &Entity<T>) -> Self::Result<super::GpuiBorrow<'a, T>>
-    where
-        T: 'static,
-    {
-        panic!("Cannot use as_mut with a test app context. Try calling update() first")
-    }
-
    fn read_entity<T, R>(
        &self,
        handle: &Entity<T>,
@@ -142,12 +134,6 @@ impl TestAppContext {
        }
    }

-    /// Create a single TestAppContext, for non-multi-client tests
-    pub fn single() -> Self {
-        let dispatcher = TestDispatcher::new(StdRng::from_entropy());
-        Self::build(dispatcher, None)
-    }
-
    /// The name of the test function that created this `TestAppContext`
    pub fn test_function_name(&self) -> Option<&'static str> {
        self.fn_name
@@ -928,13 +914,6 @@ impl AppContext for VisualTestContext {
        self.cx.update_entity(handle, update)
    }

-    fn as_mut<'a, T>(&'a mut self, handle: &Entity<T>) -> Self::Result<super::GpuiBorrow<'a, T>>
-    where
-        T: 'static,
-    {
-        self.cx.as_mut(handle)
-    }
-
    fn read_entity<T, R>(
        &self,
        handle: &Entity<T>,
--- a/crates/gpui/src/element.rs
+++ b/crates/gpui/src/element.rs
@@ -39,7 +39,7 @@ use crate::{
 use derive_more::{Deref, DerefMut};
 pub(crate) use smallvec::SmallVec;
 use std::{
-    any::{Any, type_name},
+    any::Any,
    fmt::{self, Debug, Display},
    mem, panic,
 };
@@ -220,17 +220,14 @@ impl<C: RenderOnce> Element for Component<C> {
        window: &mut Window,
        cx: &mut App,
    ) -> (LayoutId, Self::RequestLayoutState) {
-        window.with_global_id(ElementId::Name(type_name::<C>().into()), |_, window| {
-            let mut element = self
-                .component
-                .take()
-                .unwrap()
-                .render(window, cx)
-                .into_any_element();
-
-            let layout_id = element.request_layout(window, cx);
-            (layout_id, element)
-        })
+        let mut element = self
+            .component
+            .take()
+            .unwrap()
+            .render(window, cx)
+            .into_any_element();
+        let layout_id = element.request_layout(window, cx);
+        (layout_id, element)
    }

    fn prepaint(
@@ -242,9 +239,7 @@ impl<C: RenderOnce> Element for Component<C> {
        window: &mut Window,
        cx: &mut App,
    ) {
-        window.with_global_id(ElementId::Name(type_name::<C>().into()), |_, window| {
-            element.prepaint(window, cx);
-        })
+        element.prepaint(window, cx);
    }

    fn paint(
@@ -257,9 +252,7 @@ impl<C: RenderOnce> Element for Component<C> {
        window: &mut Window,
        cx: &mut App,
    ) {
-        window.with_global_id(ElementId::Name(type_name::<C>().into()), |_, window| {
-            element.paint(window, cx);
-        })
+        element.paint(window, cx);
    }
 }

--- a/crates/gpui/src/gpui.rs
+++ b/crates/gpui/src/gpui.rs
@@ -197,11 +197,6 @@ pub trait AppContext {
    where
        T: 'static;

-    /// Update a entity in the app context.
-    fn as_mut<'a, T>(&'a mut self, handle: &Entity<T>) -> Self::Result<GpuiBorrow<'a, T>>
-    where
-        T: 'static;
-
    /// Read a entity from the app context.
    fn read_entity<T, R>(
        &self,
--- a/crates/gpui/src/path_builder.rs
+++ b/crates/gpui/src/path_builder.rs
@@ -336,10 +336,7 @@ impl PathBuilder {
            let v1 = buf.vertices[i1];
            let v2 = buf.vertices[i2];

-            path.push_triangle(
-                (v0.into(), v1.into(), v2.into()),
-                (point(0., 1.), point(0., 1.), point(0., 1.)),
-            );
+            path.push_triangle((v0.into(), v1.into(), v2.into()));
        }

        path
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -794,7 +794,6 @@ pub(crate) struct AtlasTextureId {
 pub(crate) enum AtlasTextureKind {
    Monochrome = 0,
    Polychrome = 1,
-    Path = 2,
 }

 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
--- a/crates/gpui/src/platform/blade/blade_atlas.rs
+++ b/crates/gpui/src/platform/blade/blade_atlas.rs
@@ -10,8 +10,6 @@ use etagere::BucketedAtlasAllocator;
 use parking_lot::Mutex;
 use std::{borrow::Cow, ops, sync::Arc};

-pub(crate) const PATH_TEXTURE_FORMAT: gpu::TextureFormat = gpu::TextureFormat::R16Float;
-
 pub(crate) struct BladeAtlas(Mutex<BladeAtlasState>);

 struct PendingUpload {
@@ -27,7 +25,6 @@ struct BladeAtlasState {
    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
    initializations: Vec<AtlasTextureId>,
    uploads: Vec<PendingUpload>,
-    path_sample_count: u32,
 }

 #[cfg(gles)]
@@ -41,13 +38,13 @@ impl BladeAtlasState {
 }

 pub struct BladeTextureInfo {
+    #[allow(dead_code)]
    pub size: gpu::Extent,
    pub raw_view: gpu::TextureView,
-    pub msaa_view: Option<gpu::TextureView>,
 }

 impl BladeAtlas {
-    pub(crate) fn new(gpu: &Arc<gpu::Context>, path_sample_count: u32) -> Self {
+    pub(crate) fn new(gpu: &Arc<gpu::Context>) -> Self {
        BladeAtlas(Mutex::new(BladeAtlasState {
            gpu: Arc::clone(gpu),
            upload_belt: BufferBelt::new(BufferBeltDescriptor {
@@ -59,7 +56,6 @@ impl BladeAtlas {
            tiles_by_key: Default::default(),
            initializations: Vec::new(),
            uploads: Vec::new(),
-            path_sample_count,
        }))
    }

@@ -67,6 +63,7 @@ impl BladeAtlas {
        self.0.lock().destroy();
    }

+    #[allow(dead_code)]
    pub(crate) fn clear_textures(&self, texture_kind: AtlasTextureKind) {
        let mut lock = self.0.lock();
        let textures = &mut lock.storage[texture_kind];
@@ -75,19 +72,6 @@ impl BladeAtlas {
        }
    }

-    /// Allocate a rectangle and make it available for rendering immediately (without waiting for `before_frame`)
-    pub fn allocate_for_rendering(
-        &self,
-        size: Size<DevicePixels>,
-        texture_kind: AtlasTextureKind,
-        gpu_encoder: &mut gpu::CommandEncoder,
-    ) -> AtlasTile {
-        let mut lock = self.0.lock();
-        let tile = lock.allocate(size, texture_kind);
-        lock.flush_initializations(gpu_encoder);
-        tile
-    }
-
    pub fn before_frame(&self, gpu_encoder: &mut gpu::CommandEncoder) {
        let mut lock = self.0.lock();
        lock.flush(gpu_encoder);
@@ -109,7 +93,6 @@ impl BladeAtlas {
                depth: 1,
            },
            raw_view: texture.raw_view,
-            msaa_view: texture.msaa_view,
        }
    }
 }
@@ -200,48 +183,8 @@ impl BladeAtlasState {
                format = gpu::TextureFormat::Bgra8UnormSrgb;
                usage = gpu::TextureUsage::COPY | gpu::TextureUsage::RESOURCE;
            }
-            AtlasTextureKind::Path => {
-                format = PATH_TEXTURE_FORMAT;
-                usage = gpu::TextureUsage::COPY
-                    | gpu::TextureUsage::RESOURCE
-                    | gpu::TextureUsage::TARGET;
-            }
        }

-        // We currently only enable MSAA for path textures.
-        let (msaa, msaa_view) = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path {
-            let msaa = self.gpu.create_texture(gpu::TextureDesc {
-                name: "msaa path texture",
-                format,
-                size: gpu::Extent {
-                    width: size.width.into(),
-                    height: size.height.into(),
-                    depth: 1,
-                },
-                array_layer_count: 1,
-                mip_level_count: 1,
-                sample_count: self.path_sample_count,
-                dimension: gpu::TextureDimension::D2,
-                usage: gpu::TextureUsage::TARGET,
-                external: None,
-            });
-
-            (
-                Some(msaa),
-                Some(self.gpu.create_texture_view(
-                    msaa,
-                    gpu::TextureViewDesc {
-                        name: "msaa texture view",
-                        format,
-                        dimension: gpu::ViewDimension::D2,
-                        subresources: &Default::default(),
-                    },
-                )),
-            )
-        } else {
-            (None, None)
-        };
-
        let raw = self.gpu.create_texture(gpu::TextureDesc {
            name: "atlas",
            format,
@@ -279,8 +222,6 @@ impl BladeAtlasState {
            format,
            raw,
            raw_view,
-            msaa,
-            msaa_view,
            live_atlas_keys: 0,
        };

@@ -340,7 +281,6 @@ impl BladeAtlasState {
 struct BladeAtlasStorage {
    monochrome_textures: AtlasTextureList<BladeAtlasTexture>,
    polychrome_textures: AtlasTextureList<BladeAtlasTexture>,
-    path_textures: AtlasTextureList<BladeAtlasTexture>,
 }

 impl ops::Index<AtlasTextureKind> for BladeAtlasStorage {
@@ -349,7 +289,6 @@ impl ops::Index<AtlasTextureKind> for BladeAtlasStorage {
        match kind {
            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
-            crate::AtlasTextureKind::Path => &self.path_textures,
        }
    }
 }
@@ -359,7 +298,6 @@ impl ops::IndexMut<AtlasTextureKind> for BladeAtlasStorage {
        match kind {
            crate::AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
-            crate::AtlasTextureKind::Path => &mut self.path_textures,
        }
    }
 }
@@ -370,7 +308,6 @@ impl ops::Index<AtlasTextureId> for BladeAtlasStorage {
        let textures = match id.kind {
            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
-            crate::AtlasTextureKind::Path => &self.path_textures,
        };
        textures[id.index as usize].as_ref().unwrap()
    }
@@ -384,9 +321,6 @@ impl BladeAtlasStorage {
        for mut texture in self.polychrome_textures.drain().flatten() {
            texture.destroy(gpu);
        }
-        for mut texture in self.path_textures.drain().flatten() {
-            texture.destroy(gpu);
-        }
    }
 }

@@ -395,8 +329,6 @@ struct BladeAtlasTexture {
    allocator: BucketedAtlasAllocator,
    raw: gpu::Texture,
    raw_view: gpu::TextureView,
-    msaa: Option<gpu::Texture>,
-    msaa_view: Option<gpu::TextureView>,
    format: gpu::TextureFormat,
    live_atlas_keys: u32,
 }
@@ -424,12 +356,6 @@ impl BladeAtlasTexture {
    fn destroy(&mut self, gpu: &gpu::Context) {
        gpu.destroy_texture(self.raw);
        gpu.destroy_texture_view(self.raw_view);
-        if let Some(msaa) = self.msaa {
-            gpu.destroy_texture(msaa);
-        }
-        if let Some(msaa_view) = self.msaa_view {
-            gpu.destroy_texture_view(msaa_view);
-        }
    }

    fn bytes_per_pixel(&self) -> u8 {
--- a/crates/gpui/src/platform/blade/blade_renderer.rs
+++ b/crates/gpui/src/platform/blade/blade_renderer.rs
@@ -1,24 +1,19 @@
 // Doing `if let` gives you nice scoping with passes/encoders
 #![allow(irrefutable_let_patterns)]

-use super::{BladeAtlas, BladeContext, PATH_TEXTURE_FORMAT};
+use super::{BladeAtlas, BladeContext};
 use crate::{
-    AtlasTextureKind, AtlasTile, Background, Bounds, ContentMask, DevicePixels, GpuSpecs,
-    MonochromeSprite, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad,
-    ScaledPixels, Scene, Shadow, Size, Underline,
+    Background, Bounds, ContentMask, DevicePixels, GpuSpecs, MonochromeSprite, PathVertex,
+    PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, Underline,
 };
-use blade_graphics as gpu;
+use blade_graphics::{self as gpu};
 use blade_util::{BufferBelt, BufferBeltDescriptor};
 use bytemuck::{Pod, Zeroable};
-use collections::HashMap;
 #[cfg(target_os = "macos")]
 use media::core_video::CVMetalTextureCache;
 use std::{mem, sync::Arc};

 const MAX_FRAME_TIME_MS: u32 = 10000;
-// Use 4x MSAA, all devices support it.
-// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount
-const DEFAULT_PATH_SAMPLE_COUNT: u32 = 4;

 #[repr(C)]
 #[derive(Clone, Copy, Pod, Zeroable)]
@@ -65,17 +60,10 @@ struct ShaderShadowsData {
    b_shadows: gpu::BufferPiece,
 }

-#[derive(blade_macros::ShaderData)]
-struct ShaderPathRasterizationData {
-    globals: GlobalParams,
-    b_path_vertices: gpu::BufferPiece,
-}
-
 #[derive(blade_macros::ShaderData)]
 struct ShaderPathsData {
    globals: GlobalParams,
-    t_sprite: gpu::TextureView,
-    s_sprite: gpu::Sampler,
+    b_path_vertices: gpu::BufferPiece,
    b_path_sprites: gpu::BufferPiece,
 }

@@ -115,13 +103,27 @@ struct ShaderSurfacesData {
 struct PathSprite {
    bounds: Bounds<ScaledPixels>,
    color: Background,
-    tile: AtlasTile,
+}
+
+/// Argument buffer layout for `draw_indirect` commands.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Pod, Zeroable)]
+pub struct DrawIndirectArgs {
+    /// The number of vertices to draw.
+    pub vertex_count: u32,
+    /// The number of instances to draw.
+    pub instance_count: u32,
+    /// The Index of the first vertex to draw.
+    pub first_vertex: u32,
+    /// The instance ID of the first instance to draw.
+    ///
+    /// Has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`](crate::Features::INDIRECT_FIRST_INSTANCE) is enabled.
+    pub first_instance: u32,
 }

 struct BladePipelines {
    quads: gpu::RenderPipeline,
    shadows: gpu::RenderPipeline,
-    path_rasterization: gpu::RenderPipeline,
    paths: gpu::RenderPipeline,
    underlines: gpu::RenderPipeline,
    mono_sprites: gpu::RenderPipeline,
@@ -130,7 +132,7 @@ struct BladePipelines {
 }

 impl BladePipelines {
-    fn new(gpu: &gpu::Context, surface_info: gpu::SurfaceInfo, path_sample_count: u32) -> Self {
+    fn new(gpu: &gpu::Context, surface_info: gpu::SurfaceInfo, sample_count: u32) -> Self {
        use gpu::ShaderData as _;

        log::info!(
@@ -178,7 +180,10 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_quad")),
                color_targets,
-                multisample_state: gpu::MultisampleState::default(),
+                multisample_state: gpu::MultisampleState {
+                    sample_count,
+                    ..Default::default()
+                },
            }),
            shadows: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "shadows",
@@ -192,26 +197,8 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_shadow")),
                color_targets,
-                multisample_state: gpu::MultisampleState::default(),
-            }),
-            path_rasterization: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
-                name: "path_rasterization",
-                data_layouts: &[&ShaderPathRasterizationData::layout()],
-                vertex: shader.at("vs_path_rasterization"),
-                vertex_fetches: &[],
-                primitive: gpu::PrimitiveState {
-                    topology: gpu::PrimitiveTopology::TriangleList,
-                    ..Default::default()
-                },
-                depth_stencil: None,
-                fragment: Some(shader.at("fs_path_rasterization")),
-                color_targets: &[gpu::ColorTargetState {
-                    format: PATH_TEXTURE_FORMAT,
-                    blend: Some(gpu::BlendState::ADDITIVE),
-                    write_mask: gpu::ColorWrites::default(),
-                }],
                multisample_state: gpu::MultisampleState {
-                    sample_count: path_sample_count,
+                    sample_count,
                    ..Default::default()
                },
            }),
@@ -221,13 +208,16 @@ impl BladePipelines {
                vertex: shader.at("vs_path"),
                vertex_fetches: &[],
                primitive: gpu::PrimitiveState {
-                    topology: gpu::PrimitiveTopology::TriangleStrip,
+                    topology: gpu::PrimitiveTopology::TriangleList,
                    ..Default::default()
                },
                depth_stencil: None,
                fragment: Some(shader.at("fs_path")),
                color_targets,
-                multisample_state: gpu::MultisampleState::default(),
+                multisample_state: gpu::MultisampleState {
+                    sample_count,
+                    ..Default::default()
+                },
            }),
            underlines: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "underlines",
@@ -241,7 +231,10 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_underline")),
                color_targets,
-                multisample_state: gpu::MultisampleState::default(),
+                multisample_state: gpu::MultisampleState {
+                    sample_count,
+                    ..Default::default()
+                },
            }),
            mono_sprites: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "mono-sprites",
@@ -255,7 +248,10 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_mono_sprite")),
                color_targets,
-                multisample_state: gpu::MultisampleState::default(),
+                multisample_state: gpu::MultisampleState {
+                    sample_count,
+                    ..Default::default()
+                },
            }),
            poly_sprites: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "poly-sprites",
@@ -269,7 +265,10 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_poly_sprite")),
                color_targets,
-                multisample_state: gpu::MultisampleState::default(),
+                multisample_state: gpu::MultisampleState {
+                    sample_count,
+                    ..Default::default()
+                },
            }),
            surfaces: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
                name: "surfaces",
@@ -283,7 +282,10 @@ impl BladePipelines {
                depth_stencil: None,
                fragment: Some(shader.at("fs_surface")),
                color_targets,
-                multisample_state: gpu::MultisampleState::default(),
+                multisample_state: gpu::MultisampleState {
+                    sample_count,
+                    ..Default::default()
+                },
            }),
        }
    }
@@ -291,7 +293,6 @@ impl BladePipelines {
    fn destroy(&mut self, gpu: &gpu::Context) {
        gpu.destroy_render_pipeline(&mut self.quads);
        gpu.destroy_render_pipeline(&mut self.shadows);
-        gpu.destroy_render_pipeline(&mut self.path_rasterization);
        gpu.destroy_render_pipeline(&mut self.paths);
        gpu.destroy_render_pipeline(&mut self.underlines);
        gpu.destroy_render_pipeline(&mut self.mono_sprites);
@@ -317,12 +318,13 @@ pub struct BladeRenderer {
    last_sync_point: Option<gpu::SyncPoint>,
    pipelines: BladePipelines,
    instance_belt: BufferBelt,
-    path_tiles: HashMap<PathId, AtlasTile>,
    atlas: Arc<BladeAtlas>,
    atlas_sampler: gpu::Sampler,
    #[cfg(target_os = "macos")]
    core_video_texture_cache: CVMetalTextureCache,
-    path_sample_count: u32,
+    sample_count: u32,
+    texture_msaa: Option<gpu::Texture>,
+    texture_view_msaa: Option<gpu::TextureView>,
 }

 impl BladeRenderer {
@@ -331,6 +333,18 @@ impl BladeRenderer {
        window: &I,
        config: BladeSurfaceConfig,
    ) -> anyhow::Result<Self> {
+        // workaround for https://github.com/zed-industries/zed/issues/26143
+        let sample_count = std::env::var("ZED_SAMPLE_COUNT")
+            .ok()
+            .or_else(|| std::env::var("ZED_PATH_SAMPLE_COUNT").ok())
+            .and_then(|v| v.parse().ok())
+            .or_else(|| {
+                [4, 2, 1]
+                    .into_iter()
+                    .find(|count| context.gpu.supports_texture_sample_count(*count))
+            })
+            .unwrap_or(1);
+
        let surface_config = gpu::SurfaceConfig {
            size: config.size,
            usage: gpu::TextureUsage::TARGET,
@@ -344,22 +358,27 @@ impl BladeRenderer {
            .create_surface_configured(window, surface_config)
            .map_err(|err| anyhow::anyhow!("Failed to create surface: {err:?}"))?;

+        let (texture_msaa, texture_view_msaa) = create_msaa_texture_if_needed(
+            &context.gpu,
+            surface.info().format,
+            config.size.width,
+            config.size.height,
+            sample_count,
+        )
+        .unzip();
+
        let command_encoder = context.gpu.create_command_encoder(gpu::CommandEncoderDesc {
            name: "main",
            buffer_count: 2,
        });
-        // workaround for https://github.com/zed-industries/zed/issues/26143
-        let path_sample_count = std::env::var("ZED_PATH_SAMPLE_COUNT")
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(DEFAULT_PATH_SAMPLE_COUNT);
-        let pipelines = BladePipelines::new(&context.gpu, surface.info(), path_sample_count);
+
+        let pipelines = BladePipelines::new(&context.gpu, surface.info(), sample_count);
        let instance_belt = BufferBelt::new(BufferBeltDescriptor {
            memory: gpu::Memory::Shared,
            min_chunk_size: 0x1000,
            alignment: 0x40, // Vulkan `minStorageBufferOffsetAlignment` on Intel Xe
        });
-        let atlas = Arc::new(BladeAtlas::new(&context.gpu, path_sample_count));
+        let atlas = Arc::new(BladeAtlas::new(&context.gpu));
        let atlas_sampler = context.gpu.create_sampler(gpu::SamplerDesc {
            name: "atlas",
            mag_filter: gpu::FilterMode::Linear,
@@ -383,12 +402,13 @@ impl BladeRenderer {
            last_sync_point: None,
            pipelines,
            instance_belt,
-            path_tiles: HashMap::default(),
            atlas,
            atlas_sampler,
            #[cfg(target_os = "macos")]
            core_video_texture_cache,
-            path_sample_count,
+            sample_count,
+            texture_msaa,
+            texture_view_msaa,
        })
    }

@@ -441,6 +461,24 @@ impl BladeRenderer {
            self.surface_config.size = gpu_size;
            self.gpu
                .reconfigure_surface(&mut self.surface, self.surface_config);
+
+            if let Some(texture_msaa) = self.texture_msaa {
+                self.gpu.destroy_texture(texture_msaa);
+            }
+            if let Some(texture_view_msaa) = self.texture_view_msaa {
+                self.gpu.destroy_texture_view(texture_view_msaa);
+            }
+
+            let (texture_msaa, texture_view_msaa) = create_msaa_texture_if_needed(
+                &self.gpu,
+                self.surface.info().format,
+                gpu_size.width,
+                gpu_size.height,
+                self.sample_count,
+            )
+            .unzip();
+            self.texture_msaa = texture_msaa;
+            self.texture_view_msaa = texture_view_msaa;
        }
    }

@@ -451,8 +489,7 @@ impl BladeRenderer {
            self.gpu
                .reconfigure_surface(&mut self.surface, self.surface_config);
            self.pipelines.destroy(&self.gpu);
-            self.pipelines =
-                BladePipelines::new(&self.gpu, self.surface.info(), self.path_sample_count);
+            self.pipelines = BladePipelines::new(&self.gpu, self.surface.info(), self.sample_count);
        }
    }

@@ -490,80 +527,6 @@ impl BladeRenderer {
        objc2::rc::Retained::as_ptr(&self.surface.metal_layer()) as *mut _
    }

-    #[profiling::function]
-    fn rasterize_paths(&mut self, paths: &[Path<ScaledPixels>]) {
-        self.path_tiles.clear();
-        let mut vertices_by_texture_id = HashMap::default();
-
-        for path in paths {
-            let clipped_bounds = path
-                .bounds
-                .intersect(&path.content_mask.bounds)
-                .map_origin(|origin| origin.floor())
-                .map_size(|size| size.ceil());
-            let tile = self.atlas.allocate_for_rendering(
-                clipped_bounds.size.map(Into::into),
-                AtlasTextureKind::Path,
-                &mut self.command_encoder,
-            );
-            vertices_by_texture_id
-                .entry(tile.texture_id)
-                .or_insert(Vec::new())
-                .extend(path.vertices.iter().map(|vertex| PathVertex {
-                    xy_position: vertex.xy_position - clipped_bounds.origin
-                        + tile.bounds.origin.map(Into::into),
-                    st_position: vertex.st_position,
-                    content_mask: ContentMask {
-                        bounds: tile.bounds.map(Into::into),
-                    },
-                }));
-            self.path_tiles.insert(path.id, tile);
-        }
-
-        for (texture_id, vertices) in vertices_by_texture_id {
-            let tex_info = self.atlas.get_texture_info(texture_id);
-            let globals = GlobalParams {
-                viewport_size: [tex_info.size.width as f32, tex_info.size.height as f32],
-                premultiplied_alpha: 0,
-                pad: 0,
-            };
-
-            let vertex_buf = unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) };
-            let frame_view = tex_info.raw_view;
-            let color_target = if let Some(msaa_view) = tex_info.msaa_view {
-                gpu::RenderTarget {
-                    view: msaa_view,
-                    init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack),
-                    finish_op: gpu::FinishOp::ResolveTo(frame_view),
-                }
-            } else {
-                gpu::RenderTarget {
-                    view: frame_view,
-                    init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack),
-                    finish_op: gpu::FinishOp::Store,
-                }
-            };
-
-            if let mut pass = self.command_encoder.render(
-                "paths",
-                gpu::RenderTargetSet {
-                    colors: &[color_target],
-                    depth_stencil: None,
-                },
-            ) {
-                let mut encoder = pass.with(&self.pipelines.path_rasterization);
-                encoder.bind(
-                    0,
-                    &ShaderPathRasterizationData {
-                        globals,
-                        b_path_vertices: vertex_buf,
-                    },
-                );
-                encoder.draw(0, vertices.len() as u32, 0, 1);
-            }
-        }
-    }
-
    pub fn destroy(&mut self) {
        self.wait_for_gpu();
        self.atlas.destroy();
@@ -572,17 +535,26 @@ impl BladeRenderer {
        self.gpu.destroy_command_encoder(&mut self.command_encoder);
        self.pipelines.destroy(&self.gpu);
        self.gpu.destroy_surface(&mut self.surface);
+        if let Some(texture_msaa) = self.texture_msaa {
+            self.gpu.destroy_texture(texture_msaa);
+        }
+        if let Some(texture_view_msaa) = self.texture_view_msaa {
+            self.gpu.destroy_texture_view(texture_view_msaa);
+        }
    }

    pub fn draw(&mut self, scene: &Scene) {
        self.command_encoder.start();
        self.atlas.before_frame(&mut self.command_encoder);
-        self.rasterize_paths(scene.paths());

        let frame = {
            profiling::scope!("acquire frame");
            self.surface.acquire_frame()
        };
+        let frame_view = frame.texture_view();
+        if let Some(texture_msaa) = self.texture_msaa {
+            self.command_encoder.init_texture(texture_msaa);
+        }
        self.command_encoder.init_texture(frame.texture());

        let globals = GlobalParams {
@@ -597,14 +569,25 @@ impl BladeRenderer {
            pad: 0,
        };

+        let target = if let Some(texture_view_msaa) = self.texture_view_msaa {
+            gpu::RenderTarget {
+                view: texture_view_msaa,
+                init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack),
+                finish_op: gpu::FinishOp::ResolveTo(frame_view),
+            }
+        } else {
+            gpu::RenderTarget {
+                view: frame_view,
+                init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack),
+                finish_op: gpu::FinishOp::Store,
+            }
+        };
+
+        // draw to the target texture
        if let mut pass = self.command_encoder.render(
            "main",
            gpu::RenderTargetSet {
-                colors: &[gpu::RenderTarget {
-                    view: frame.texture_view(),
-                    init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack),
-                    finish_op: gpu::FinishOp::Store,
-                }],
+                colors: &[target],
                depth_stencil: None,
            },
        ) {
@@ -639,32 +622,55 @@ impl BladeRenderer {
                    }
                    PrimitiveBatch::Paths(paths) => {
                        let mut encoder = pass.with(&self.pipelines.paths);
-                        // todo(linux): group by texture ID
-                        for path in paths {
-                            let tile = &self.path_tiles[&path.id];
-                            let tex_info = self.atlas.get_texture_info(tile.texture_id);
-                            let origin = path.bounds.intersect(&path.content_mask.bounds).origin;
-                            let sprites = [PathSprite {
-                                bounds: Bounds {
-                                    origin: origin.map(|p| p.floor()),
-                                    size: tile.bounds.size.map(Into::into),
-                                },
-                                color: path.color,
-                                tile: (*tile).clone(),
-                            }];

-                            let instance_buf =
-                                unsafe { self.instance_belt.alloc_typed(&sprites, &self.gpu) };
-                            encoder.bind(
-                                0,
-                                &ShaderPathsData {
-                                    globals,
-                                    t_sprite: tex_info.raw_view,
-                                    s_sprite: self.atlas_sampler,
-                                    b_path_sprites: instance_buf,
+                        let mut vertices = Vec::new();
+                        let mut sprites = Vec::with_capacity(paths.len());
+                        let mut draw_indirect_commands = Vec::with_capacity(paths.len());
+                        let mut first_vertex = 0;
+
+                        for (i, path) in paths.iter().enumerate() {
+                            draw_indirect_commands.push(DrawIndirectArgs {
+                                vertex_count: path.vertices.len() as u32,
+                                instance_count: 1,
+                                first_vertex,
+                                first_instance: i as u32,
+                            });
+                            first_vertex += path.vertices.len() as u32;
+
+                            vertices.extend(path.vertices.iter().map(|v| PathVertex {
+                                xy_position: v.xy_position,
+                                content_mask: ContentMask {
+                                    bounds: path.content_mask.bounds,
                                },
-                            );
-                            encoder.draw(0, 4, 0, sprites.len() as u32);
+                            }));
+
+                            sprites.push(PathSprite {
+                                bounds: path.bounds,
+                                color: path.color,
+                            });
+                        }
+
+                        let b_path_vertices =
+                            unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) };
+                        let instance_buf =
+                            unsafe { self.instance_belt.alloc_typed(&sprites, &self.gpu) };
+                        let indirect_buf = unsafe {
+                            self.instance_belt
+                                .alloc_typed(&draw_indirect_commands, &self.gpu)
+                        };
+
+                        encoder.bind(
+                            0,
+                            &ShaderPathsData {
+                                globals,
+                                b_path_vertices,
+                                b_path_sprites: instance_buf,
+                            },
+                        );
+
+                        for i in 0..paths.len() {
+                            encoder.draw_indirect(indirect_buf.buffer.at(indirect_buf.offset
+                                + (i * mem::size_of::<DrawIndirectArgs>()) as u64));
                        }
                    }
                    PrimitiveBatch::Underlines(underlines) => {
@@ -817,9 +823,47 @@ impl BladeRenderer {
        profiling::scope!("finish");
        self.instance_belt.flush(&sync_point);
        self.atlas.after_frame(&sync_point);
-        self.atlas.clear_textures(AtlasTextureKind::Path);

        self.wait_for_gpu();
        self.last_sync_point = Some(sync_point);
    }
 }
+
+fn create_msaa_texture_if_needed(
+    gpu: &gpu::Context,
+    format: gpu::TextureFormat,
+    width: u32,
+    height: u32,
+    sample_count: u32,
+) -> Option<(gpu::Texture, gpu::TextureView)> {
+    if sample_count <= 1 {
+        return None;
+    }
+
+    let texture_msaa = gpu.create_texture(gpu::TextureDesc {
+        name: "msaa",
+        format,
+        size: gpu::Extent {
+            width,
+            height,
+            depth: 1,
+        },
+        array_layer_count: 1,
+        mip_level_count: 1,
+        sample_count,
+        dimension: gpu::TextureDimension::D2,
+        usage: gpu::TextureUsage::TARGET,
+        external: None,
+    });
+    let texture_view_msaa = gpu.create_texture_view(
+        texture_msaa,
+        gpu::TextureViewDesc {
+            name: "msaa view",
+            format,
+            dimension: gpu::ViewDimension::D2,
+            subresources: &Default::default(),
+        },
+    );
+
+    Some((texture_msaa, texture_view_msaa))
+}
--- a/crates/gpui/src/platform/blade/shaders.wgsl
+++ b/crates/gpui/src/platform/blade/shaders.wgsl
@@ -922,59 +922,23 @@ fn fs_shadow(input: ShadowVarying) -> @location(0) vec4<f32> {
    return blend_color(input.color, alpha);
 }

-// --- path rasterization --- //
+// --- paths --- //

 struct PathVertex {
    xy_position: vec2<f32>,
-    st_position: vec2<f32>,
    content_mask: Bounds,
 }
-var<storage, read> b_path_vertices: array<PathVertex>;
-
-struct PathRasterizationVarying {
-    @builtin(position) position: vec4<f32>,
-    @location(0) st_position: vec2<f32>,
-    //TODO: use `clip_distance` once Naga supports it
-    @location(3) clip_distances: vec4<f32>,
-}
-
-@vertex
-fn vs_path_rasterization(@builtin(vertex_index) vertex_id: u32) -> PathRasterizationVarying {
-    let v = b_path_vertices[vertex_id];
-
-    var out = PathRasterizationVarying();
-    out.position = to_device_position_impl(v.xy_position);
-    out.st_position = v.st_position;
-    out.clip_distances = distance_from_clip_rect_impl(v.xy_position, v.content_mask);
-    return out;
-}
-
-@fragment
-fn fs_path_rasterization(input: PathRasterizationVarying) -> @location(0) f32 {
-    let dx = dpdx(input.st_position);
-    let dy = dpdy(input.st_position);
-    if (any(input.clip_distances < vec4<f32>(0.0))) {
-        return 0.0;
-    }
-
-    let gradient = 2.0 * input.st_position.xx * vec2<f32>(dx.x, dy.x) - vec2<f32>(dx.y, dy.y);
-    let f = input.st_position.x * input.st_position.x - input.st_position.y;
-    let distance = f / length(gradient);
-    return saturate(0.5 - distance);
-}
-
-// --- paths --- //

 struct PathSprite {
    bounds: Bounds,
    color: Background,
-    tile: AtlasTile,
 }
+var<storage, read> b_path_vertices: array<PathVertex>;
 var<storage, read> b_path_sprites: array<PathSprite>;

 struct PathVarying {
    @builtin(position) position: vec4<f32>,
-    @location(0) tile_position: vec2<f32>,
+    @location(0) clip_distances: vec4<f32>,
    @location(1) @interpolate(flat) instance_id: u32,
    @location(2) @interpolate(flat) color_solid: vec4<f32>,
    @location(3) @interpolate(flat) color0: vec4<f32>,
@@ -983,13 +947,12 @@ struct PathVarying {

@vertex
 fn vs_path(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> PathVarying {
-    let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));
+    let v = b_path_vertices[vertex_id];
    let sprite = b_path_sprites[instance_id];
-    // Don't apply content mask because it was already accounted for when rasterizing the path.

    var out = PathVarying();
-    out.position = to_device_position(unit_vertex, sprite.bounds);
-    out.tile_position = to_tile_position(unit_vertex, sprite.tile);
+    out.position = to_device_position_impl(v.xy_position);
+    out.clip_distances = distance_from_clip_rect_impl(v.xy_position, v.content_mask);
    out.instance_id = instance_id;

    let gradient = prepare_gradient_color(
@@ -1006,13 +969,15 @@ fn vs_path(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) insta

@fragment
 fn fs_path(input: PathVarying) -> @location(0) vec4<f32> {
-    let sample = textureSample(t_sprite, s_sprite, input.tile_position).r;
-    let mask = 1.0 - abs(1.0 - sample % 2.0);
+    if any(input.clip_distances < vec4<f32>(0.0)) {
+        return vec4<f32>(0.0);
+    }
+
    let sprite = b_path_sprites[input.instance_id];
    let background = sprite.color;
    let color = gradient_color(background, input.position.xy, sprite.bounds,
        input.color_solid, input.color0, input.color1);
-    return blend_color(color, mask);
+    return blend_color(color, 1.0);
 }

 // --- underlines --- //
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -822,35 +822,11 @@ impl crate::Keystroke {
            Keysym::underscore => "_".to_owned(),
            Keysym::equal => "=".to_owned(),
            Keysym::plus => "+".to_owned(),
-            Keysym::space => "space".to_owned(),
-            Keysym::BackSpace => "backspace".to_owned(),
-            Keysym::Tab => "tab".to_owned(),
-            Keysym::Delete => "delete".to_owned(),
-            Keysym::Escape => "escape".to_owned(),
-
-            Keysym::Left => "left".to_owned(),
-            Keysym::Right => "right".to_owned(),
-            Keysym::Up => "up".to_owned(),
-            Keysym::Down => "down".to_owned(),
-            Keysym::Home => "home".to_owned(),
-            Keysym::End => "end".to_owned(),

            _ => {
                let name = xkb::keysym_get_name(key_sym).to_lowercase();
                if key_sym.is_keypad_key() {
                    name.replace("kp_", "")
-                } else if let Some(key) = key_utf8.chars().next()
-                    && key_utf8.len() == 1
-                    && key.is_ascii()
-                {
-                    if key.is_ascii_graphic() {
-                        key_utf8.to_lowercase()
-                    // map ctrl-a to a
-                    } else if key_utf32 <= 0x1f {
-                        ((key_utf32 as u8 + 0x60) as char).to_string()
-                    } else {
-                        name
-                    }
                } else if let Some(key_en) = guess_ascii(keycode, modifiers.shift) {
                    String::from(key_en)
                } else {
--- a/crates/gpui/src/platform/mac/metal_atlas.rs
+++ b/crates/gpui/src/platform/mac/metal_atlas.rs
@@ -13,14 +13,12 @@ use std::borrow::Cow;
 pub(crate) struct MetalAtlas(Mutex<MetalAtlasState>);

 impl MetalAtlas {
-    pub(crate) fn new(device: Device, path_sample_count: u32) -> Self {
+    pub(crate) fn new(device: Device) -> Self {
        MetalAtlas(Mutex::new(MetalAtlasState {
            device: AssertSend(device),
            monochrome_textures: Default::default(),
            polychrome_textures: Default::default(),
-            path_textures: Default::default(),
            tiles_by_key: Default::default(),
-            path_sample_count,
        }))
    }

@@ -28,10 +26,7 @@ impl MetalAtlas {
        self.0.lock().texture(id).metal_texture.clone()
    }

-    pub(crate) fn msaa_texture(&self, id: AtlasTextureId) -> Option<metal::Texture> {
-        self.0.lock().texture(id).msaa_texture.clone()
-    }
-
+    #[allow(dead_code)]
    pub(crate) fn allocate(
        &self,
        size: Size<DevicePixels>,
@@ -40,12 +35,12 @@ impl MetalAtlas {
        self.0.lock().allocate(size, texture_kind)
    }

+    #[allow(dead_code)]
    pub(crate) fn clear_textures(&self, texture_kind: AtlasTextureKind) {
        let mut lock = self.0.lock();
        let textures = match texture_kind {
            AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,
            AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,
-            AtlasTextureKind::Path => &mut lock.path_textures,
        };
        for texture in textures.iter_mut() {
            texture.clear();
@@ -57,9 +52,7 @@ struct MetalAtlasState {
    device: AssertSend<Device>,
    monochrome_textures: AtlasTextureList<MetalAtlasTexture>,
    polychrome_textures: AtlasTextureList<MetalAtlasTexture>,
-    path_textures: AtlasTextureList<MetalAtlasTexture>,
    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
-    path_sample_count: u32,
 }

 impl PlatformAtlas for MetalAtlas {
@@ -94,7 +87,6 @@ impl PlatformAtlas for MetalAtlas {
        let textures = match id.kind {
            AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,
            AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,
-            AtlasTextureKind::Path => &mut lock.polychrome_textures,
        };

        let Some(texture_slot) = textures
@@ -128,7 +120,6 @@ impl MetalAtlasState {
            let textures = match texture_kind {
                AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
                AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
-                AtlasTextureKind::Path => &mut self.path_textures,
            };

            if let Some(tile) = textures
@@ -173,31 +164,14 @@ impl MetalAtlasState {
                pixel_format = metal::MTLPixelFormat::BGRA8Unorm;
                usage = metal::MTLTextureUsage::ShaderRead;
            }
-            AtlasTextureKind::Path => {
-                pixel_format = metal::MTLPixelFormat::R16Float;
-                usage = metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead;
-            }
        }
        texture_descriptor.set_pixel_format(pixel_format);
        texture_descriptor.set_usage(usage);
        let metal_texture = self.device.new_texture(&texture_descriptor);

-        // We currently only enable MSAA for path textures.
-        let msaa_texture = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path {
-            let mut descriptor = texture_descriptor.clone();
-            descriptor.set_texture_type(metal::MTLTextureType::D2Multisample);
-            descriptor.set_storage_mode(metal::MTLStorageMode::Private);
-            descriptor.set_sample_count(self.path_sample_count as _);
-            let msaa_texture = self.device.new_texture(&descriptor);
-            Some(msaa_texture)
-        } else {
-            None
-        };
-
        let texture_list = match kind {
            AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
            AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
-            AtlasTextureKind::Path => &mut self.path_textures,
        };

        let index = texture_list.free_list.pop();
@@ -209,7 +183,6 @@ impl MetalAtlasState {
            },
            allocator: etagere::BucketedAtlasAllocator::new(size.into()),
            metal_texture: AssertSend(metal_texture),
-            msaa_texture: AssertSend(msaa_texture),
            live_atlas_keys: 0,
        };

@@ -226,7 +199,6 @@ impl MetalAtlasState {
        let textures = match id.kind {
            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
-            crate::AtlasTextureKind::Path => &self.path_textures,
        };
        textures[id.index as usize].as_ref().unwrap()
    }
@@ -236,7 +208,6 @@ struct MetalAtlasTexture {
    id: AtlasTextureId,
    allocator: BucketedAtlasAllocator,
    metal_texture: AssertSend<metal::Texture>,
-    msaa_texture: AssertSend<Option<metal::Texture>>,
    live_atlas_keys: u32,
 }

--- a/crates/gpui/src/platform/mac/metal_renderer.rs
+++ b/crates/gpui/src/platform/mac/metal_renderer.rs
@@ -1,27 +1,28 @@
 use super::metal_atlas::MetalAtlas;
 use crate::{
-    AtlasTextureId, AtlasTextureKind, AtlasTile, Background, Bounds, ContentMask, DevicePixels,
-    MonochromeSprite, PaintSurface, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch,
-    Quad, ScaledPixels, Scene, Shadow, Size, Surface, Underline, point, size,
+    AtlasTextureId, Background, Bounds, ContentMask, DevicePixels, MonochromeSprite, PaintSurface,
+    Path, PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,
+    Surface, Underline, point, size,
 };
-use anyhow::{Context as _, Result};
+use anyhow::Result;
 use block::ConcreteBlock;
 use cocoa::{
    base::{NO, YES},
    foundation::{NSSize, NSUInteger},
    quartzcore::AutoresizingMask,
 };
-use collections::HashMap;
 use core_foundation::base::TCFType;
 use core_video::{
    metal_texture::CVMetalTextureGetTexture, metal_texture_cache::CVMetalTextureCache,
    pixel_buffer::kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
 };
 use foreign_types::{ForeignType, ForeignTypeRef};
-use metal::{CAMetalLayer, CommandQueue, MTLPixelFormat, MTLResourceOptions, NSRange};
+use metal::{
+    CAMetalLayer, CommandQueue, MTLDrawPrimitivesIndirectArguments, MTLPixelFormat,
+    MTLResourceOptions, NSRange,
+};
 use objc::{self, msg_send, sel, sel_impl};
 use parking_lot::Mutex;
-use smallvec::SmallVec;
 use std::{cell::Cell, ffi::c_void, mem, ptr, sync::Arc};

 // Exported to metal
@@ -31,9 +32,6 @@ pub(crate) type PointF = crate::Point<f32>;
 const SHADERS_METALLIB: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/shaders.metallib"));
 #[cfg(feature = "runtime_shaders")]
 const SHADERS_SOURCE_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/stitched_shaders.metal"));
-// Use 4x MSAA, all devices support it.
-// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount
-const PATH_SAMPLE_COUNT: u32 = 4;

 pub type Context = Arc<Mutex<InstanceBufferPool>>;
 pub type Renderer = MetalRenderer;
@@ -98,8 +96,7 @@ pub(crate) struct MetalRenderer {
    layer: metal::MetalLayer,
    presents_with_transaction: bool,
    command_queue: CommandQueue,
-    paths_rasterization_pipeline_state: metal::RenderPipelineState,
-    path_sprites_pipeline_state: metal::RenderPipelineState,
+    path_pipeline_state: metal::RenderPipelineState,
    shadows_pipeline_state: metal::RenderPipelineState,
    quads_pipeline_state: metal::RenderPipelineState,
    underlines_pipeline_state: metal::RenderPipelineState,
@@ -111,6 +108,8 @@ pub(crate) struct MetalRenderer {
    instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,
    sprite_atlas: Arc<MetalAtlas>,
    core_video_texture_cache: core_video::metal_texture_cache::CVMetalTextureCache,
+    sample_count: u64,
+    msaa_texture: Option<metal::Texture>,
 }

 impl MetalRenderer {
@@ -169,22 +168,19 @@ impl MetalRenderer {
            MTLResourceOptions::StorageModeManaged,
        );

-        let paths_rasterization_pipeline_state = build_path_rasterization_pipeline_state(
+        let sample_count = [4, 2, 1]
+            .into_iter()
+            .find(|count| device.supports_texture_sample_count(*count))
+            .unwrap_or(1);
+
+        let path_pipeline_state = build_pipeline_state(
            &device,
            &library,
-            "paths_rasterization",
-            "path_rasterization_vertex",
-            "path_rasterization_fragment",
-            MTLPixelFormat::R16Float,
-            PATH_SAMPLE_COUNT,
-        );
-        let path_sprites_pipeline_state = build_pipeline_state(
-            &device,
-            &library,
-            "path_sprites",
-            "path_sprite_vertex",
-            "path_sprite_fragment",
+            "paths",
+            "path_vertex",
+            "path_fragment",
            MTLPixelFormat::BGRA8Unorm,
+            sample_count,
        );
        let shadows_pipeline_state = build_pipeline_state(
            &device,
@@ -193,6 +189,7 @@ impl MetalRenderer {
            "shadow_vertex",
            "shadow_fragment",
            MTLPixelFormat::BGRA8Unorm,
+            sample_count,
        );
        let quads_pipeline_state = build_pipeline_state(
            &device,
@@ -201,6 +198,7 @@ impl MetalRenderer {
            "quad_vertex",
            "quad_fragment",
            MTLPixelFormat::BGRA8Unorm,
+            sample_count,
        );
        let underlines_pipeline_state = build_pipeline_state(
            &device,
@@ -209,6 +207,7 @@ impl MetalRenderer {
            "underline_vertex",
            "underline_fragment",
            MTLPixelFormat::BGRA8Unorm,
+            sample_count,
        );
        let monochrome_sprites_pipeline_state = build_pipeline_state(
            &device,
@@ -217,6 +216,7 @@ impl MetalRenderer {
            "monochrome_sprite_vertex",
            "monochrome_sprite_fragment",
            MTLPixelFormat::BGRA8Unorm,
+            sample_count,
        );
        let polychrome_sprites_pipeline_state = build_pipeline_state(
            &device,
@@ -225,6 +225,7 @@ impl MetalRenderer {
            "polychrome_sprite_vertex",
            "polychrome_sprite_fragment",
            MTLPixelFormat::BGRA8Unorm,
+            sample_count,
        );
        let surfaces_pipeline_state = build_pipeline_state(
            &device,
@@ -233,20 +234,21 @@ impl MetalRenderer {
            "surface_vertex",
            "surface_fragment",
            MTLPixelFormat::BGRA8Unorm,
+            sample_count,
        );

        let command_queue = device.new_command_queue();
-        let sprite_atlas = Arc::new(MetalAtlas::new(device.clone(), PATH_SAMPLE_COUNT));
+        let sprite_atlas = Arc::new(MetalAtlas::new(device.clone()));
        let core_video_texture_cache =
            CVMetalTextureCache::new(None, device.clone(), None).unwrap();
+        let msaa_texture = create_msaa_texture(&device, &layer, sample_count);

        Self {
            device,
            layer,
            presents_with_transaction: false,
            command_queue,
-            paths_rasterization_pipeline_state,
-            path_sprites_pipeline_state,
+            path_pipeline_state,
            shadows_pipeline_state,
            quads_pipeline_state,
            underlines_pipeline_state,
@@ -257,6 +259,8 @@ impl MetalRenderer {
            instance_buffer_pool,
            sprite_atlas,
            core_video_texture_cache,
+            sample_count,
+            msaa_texture,
        }
    }

@@ -289,6 +293,8 @@ impl MetalRenderer {
                setDrawableSize: size
            ];
        }
+
+        self.msaa_texture = create_msaa_texture(&self.device, &self.layer, self.sample_count);
    }

    pub fn update_transparency(&self, _transparent: bool) {
@@ -375,25 +381,23 @@ impl MetalRenderer {
        let command_queue = self.command_queue.clone();
        let command_buffer = command_queue.new_command_buffer();
        let mut instance_offset = 0;
-
-        let path_tiles = self
-            .rasterize_paths(
-                scene.paths(),
-                instance_buffer,
-                &mut instance_offset,
-                command_buffer,
-            )
-            .with_context(|| format!("rasterizing {} paths", scene.paths().len()))?;
-
        let render_pass_descriptor = metal::RenderPassDescriptor::new();
        let color_attachment = render_pass_descriptor
            .color_attachments()
            .object_at(0)
            .unwrap();

-        color_attachment.set_texture(Some(drawable.texture()));
-        color_attachment.set_load_action(metal::MTLLoadAction::Clear);
-        color_attachment.set_store_action(metal::MTLStoreAction::Store);
+        if let Some(msaa_texture_ref) = self.msaa_texture.as_deref() {
+            color_attachment.set_texture(Some(msaa_texture_ref));
+            color_attachment.set_load_action(metal::MTLLoadAction::Clear);
+            color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve);
+            color_attachment.set_resolve_texture(Some(drawable.texture()));
+        } else {
+            color_attachment.set_load_action(metal::MTLLoadAction::Clear);
+            color_attachment.set_texture(Some(drawable.texture()));
+            color_attachment.set_store_action(metal::MTLStoreAction::Store);
+        }
+
        let alpha = if self.layer.is_opaque() { 1. } else { 0. };
        color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., alpha));
        let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
@@ -425,7 +429,6 @@ impl MetalRenderer {
                ),
                PrimitiveBatch::Paths(paths) => self.draw_paths(
                    paths,
-                    &path_tiles,
                    instance_buffer,
                    &mut instance_offset,
                    viewport_size,
@@ -493,106 +496,6 @@ impl MetalRenderer {
        Ok(command_buffer.to_owned())
    }

-    fn rasterize_paths(
-        &self,
-        paths: &[Path<ScaledPixels>],
-        instance_buffer: &mut InstanceBuffer,
-        instance_offset: &mut usize,
-        command_buffer: &metal::CommandBufferRef,
-    ) -> Option<HashMap<PathId, AtlasTile>> {
-        self.sprite_atlas.clear_textures(AtlasTextureKind::Path);
-
-        let mut tiles = HashMap::default();
-        let mut vertices_by_texture_id = HashMap::default();
-        for path in paths {
-            let clipped_bounds = path.bounds.intersect(&path.content_mask.bounds);
-
-            let tile = self
-                .sprite_atlas
-                .allocate(clipped_bounds.size.map(Into::into), AtlasTextureKind::Path)?;
-            vertices_by_texture_id
-                .entry(tile.texture_id)
-                .or_insert(Vec::new())
-                .extend(path.vertices.iter().map(|vertex| PathVertex {
-                    xy_position: vertex.xy_position - clipped_bounds.origin
-                        + tile.bounds.origin.map(Into::into),
-                    st_position: vertex.st_position,
-                    content_mask: ContentMask {
-                        bounds: tile.bounds.map(Into::into),
-                    },
-                }));
-            tiles.insert(path.id, tile);
-        }
-
-        for (texture_id, vertices) in vertices_by_texture_id {
-            align_offset(instance_offset);
-            let vertices_bytes_len = mem::size_of_val(vertices.as_slice());
-            let next_offset = *instance_offset + vertices_bytes_len;
-            if next_offset > instance_buffer.size {
-                return None;
-            }
-
-            let render_pass_descriptor = metal::RenderPassDescriptor::new();
-            let color_attachment = render_pass_descriptor
-                .color_attachments()
-                .object_at(0)
-                .unwrap();
-
-            let texture = self.sprite_atlas.metal_texture(texture_id);
-            let msaa_texture = self.sprite_atlas.msaa_texture(texture_id);
-
-            if let Some(msaa_texture) = msaa_texture {
-                color_attachment.set_texture(Some(&msaa_texture));
-                color_attachment.set_resolve_texture(Some(&texture));
-                color_attachment.set_load_action(metal::MTLLoadAction::Clear);
-                color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve);
-            } else {
-                color_attachment.set_texture(Some(&texture));
-                color_attachment.set_load_action(metal::MTLLoadAction::Clear);
-                color_attachment.set_store_action(metal::MTLStoreAction::Store);
-            }
-            color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., 1.));
-
-            let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
-            command_encoder.set_render_pipeline_state(&self.paths_rasterization_pipeline_state);
-            command_encoder.set_vertex_buffer(
-                PathRasterizationInputIndex::Vertices as u64,
-                Some(&instance_buffer.metal_buffer),
-                *instance_offset as u64,
-            );
-            let texture_size = Size {
-                width: DevicePixels::from(texture.width()),
-                height: DevicePixels::from(texture.height()),
-            };
-            command_encoder.set_vertex_bytes(
-                PathRasterizationInputIndex::AtlasTextureSize as u64,
-                mem::size_of_val(&texture_size) as u64,
-                &texture_size as *const Size<DevicePixels> as *const _,
-            );
-
-            let buffer_contents = unsafe {
-                (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset)
-            };
-            unsafe {
-                ptr::copy_nonoverlapping(
-                    vertices.as_ptr() as *const u8,
-                    buffer_contents,
-                    vertices_bytes_len,
-                );
-            }
-
-            command_encoder.draw_primitives(
-                metal::MTLPrimitiveType::Triangle,
-                0,
-                vertices.len() as u64,
-            );
-            command_encoder.end_encoding();
-            *instance_offset = next_offset;
-        }
-
-        Some(tiles)
-    }
-
    fn draw_shadows(
        &self,
        shadows: &[Shadow],
@@ -718,7 +621,6 @@ impl MetalRenderer {
    fn draw_paths(
        &self,
        paths: &[Path<ScaledPixels>],
-        tiles_by_path_id: &HashMap<PathId, AtlasTile>,
        instance_buffer: &mut InstanceBuffer,
        instance_offset: &mut usize,
        viewport_size: Size<DevicePixels>,
@@ -728,100 +630,108 @@ impl MetalRenderer {
            return true;
        }

-        command_encoder.set_render_pipeline_state(&self.path_sprites_pipeline_state);
-        command_encoder.set_vertex_buffer(
-            SpriteInputIndex::Vertices as u64,
-            Some(&self.unit_vertices),
-            0,
-        );
-        command_encoder.set_vertex_bytes(
-            SpriteInputIndex::ViewportSize as u64,
-            mem::size_of_val(&viewport_size) as u64,
-            &viewport_size as *const Size<DevicePixels> as *const _,
-        );
+        command_encoder.set_render_pipeline_state(&self.path_pipeline_state);

-        let mut prev_texture_id = None;
-        let mut sprites = SmallVec::<[_; 1]>::new();
-        let mut paths_and_tiles = paths
-            .iter()
-            .map(|path| (path, tiles_by_path_id.get(&path.id).unwrap()))
-            .peekable();
+        unsafe {
+            let base_addr = instance_buffer.metal_buffer.contents();
+            let mut p = (base_addr as *mut u8).add(*instance_offset);
+            let mut draw_indirect_commands = Vec::with_capacity(paths.len());

-        loop {
-            if let Some((path, tile)) = paths_and_tiles.peek() {
-                if prev_texture_id.map_or(true, |texture_id| texture_id == tile.texture_id) {
-                    prev_texture_id = Some(tile.texture_id);
-                    let origin = path.bounds.intersect(&path.content_mask.bounds).origin;
-                    sprites.push(PathSprite {
-                        bounds: Bounds {
-                            origin: origin.map(|p| p.floor()),
-                            size: tile.bounds.size.map(Into::into),
-                        },
-                        color: path.color,
-                        tile: (*tile).clone(),
-                    });
-                    paths_and_tiles.next();
-                    continue;
-                }
-            }
-
-            if sprites.is_empty() {
-                break;
-            } else {
-                align_offset(instance_offset);
-                let texture_id = prev_texture_id.take().unwrap();
-                let texture: metal::Texture = self.sprite_atlas.metal_texture(texture_id);
-                let texture_size = size(
-                    DevicePixels(texture.width() as i32),
-                    DevicePixels(texture.height() as i32),
-                );
-
-                command_encoder.set_vertex_buffer(
-                    SpriteInputIndex::Sprites as u64,
-                    Some(&instance_buffer.metal_buffer),
-                    *instance_offset as u64,
-                );
-                command_encoder.set_vertex_bytes(
-                    SpriteInputIndex::AtlasTextureSize as u64,
-                    mem::size_of_val(&texture_size) as u64,
-                    &texture_size as *const Size<DevicePixels> as *const _,
-                );
-                command_encoder.set_fragment_buffer(
-                    SpriteInputIndex::Sprites as u64,
-                    Some(&instance_buffer.metal_buffer),
-                    *instance_offset as u64,
-                );
-                command_encoder
-                    .set_fragment_texture(SpriteInputIndex::AtlasTexture as u64, Some(&texture));
-
-                let sprite_bytes_len = mem::size_of_val(sprites.as_slice());
-                let next_offset = *instance_offset + sprite_bytes_len;
-                if next_offset > instance_buffer.size {
+            // copy vertices
+            let vertices_offset = (p as usize) - (base_addr as usize);
+            let mut first_vertex = 0;
+            for (i, path) in paths.iter().enumerate() {
+                if (p as usize) - (base_addr as usize)
+                    + (mem::size_of::<PathVertex<ScaledPixels>>() * path.vertices.len())
+                    > instance_buffer.size
+                {
                    return false;
                }

-                let buffer_contents = unsafe {
-                    (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset)
-                };
-
-                unsafe {
-                    ptr::copy_nonoverlapping(
-                        sprites.as_ptr() as *const u8,
-                        buffer_contents,
-                        sprite_bytes_len,
-                    );
+                for v in &path.vertices {
+                    *(p as *mut PathVertex<ScaledPixels>) = PathVertex {
+                        xy_position: v.xy_position,
+                        content_mask: ContentMask {
+                            bounds: path.content_mask.bounds,
+                        },
+                    };
+                    p = p.add(mem::size_of::<PathVertex<ScaledPixels>>());
                }

-                command_encoder.draw_primitives_instanced(
-                    metal::MTLPrimitiveType::Triangle,
-                    0,
-                    6,
-                    sprites.len() as u64,
-                );
-                *instance_offset = next_offset;
-                sprites.clear();
+                draw_indirect_commands.push(MTLDrawPrimitivesIndirectArguments {
+                    vertexCount: path.vertices.len() as u32,
+                    instanceCount: 1,
+                    vertexStart: first_vertex,
+                    baseInstance: i as u32,
+                });
+                first_vertex += path.vertices.len() as u32;
            }
+
+            // copy sprites
+            let sprites_offset = (p as u64) - (base_addr as u64);
+            if (p as usize) - (base_addr as usize) + (mem::size_of::<PathSprite>() * paths.len())
+                > instance_buffer.size
+            {
+                return false;
+            }
+            for path in paths {
+                *(p as *mut PathSprite) = PathSprite {
+                    bounds: path.bounds,
+                    color: path.color,
+                };
+                p = p.add(mem::size_of::<PathSprite>());
+            }
+
+            // copy indirect commands
+            let icb_bytes_len = mem::size_of_val(draw_indirect_commands.as_slice());
+            let icb_offset = (p as u64) - (base_addr as u64);
+            if (p as usize) - (base_addr as usize) + icb_bytes_len > instance_buffer.size {
+                return false;
+            }
+            ptr::copy_nonoverlapping(
+                draw_indirect_commands.as_ptr() as *const u8,
+                p,
+                icb_bytes_len,
+            );
+            p = p.add(icb_bytes_len);
+
+            // draw path
+            command_encoder.set_vertex_buffer(
+                PathInputIndex::Vertices as u64,
+                Some(&instance_buffer.metal_buffer),
+                vertices_offset as u64,
+            );
+
+            command_encoder.set_vertex_bytes(
+                PathInputIndex::ViewportSize as u64,
+                mem::size_of_val(&viewport_size) as u64,
+                &viewport_size as *const Size<DevicePixels> as *const _,
+            );
+
+            command_encoder.set_vertex_buffer(
+                PathInputIndex::Sprites as u64,
+                Some(&instance_buffer.metal_buffer),
+                sprites_offset,
+            );
+
+            command_encoder.set_fragment_buffer(
+                PathInputIndex::Sprites as u64,
+                Some(&instance_buffer.metal_buffer),
+                sprites_offset,
+            );
+
+            for i in 0..paths.len() {
+                command_encoder.draw_primitives_indirect(
+                    metal::MTLPrimitiveType::Triangle,
+                    &instance_buffer.metal_buffer,
+                    icb_offset
+                        + (i * std::mem::size_of::<MTLDrawPrimitivesIndirectArguments>()) as u64,
+                );
+            }
+
+            *instance_offset = (p as usize) - (base_addr as usize);
        }
+
        true
    }

@@ -1143,6 +1053,7 @@ fn build_pipeline_state(
    vertex_fn_name: &str,
    fragment_fn_name: &str,
    pixel_format: metal::MTLPixelFormat,
+    sample_count: u64,
 ) -> metal::RenderPipelineState {
    let vertex_fn = library
        .get_function(vertex_fn_name, None)
@@ -1155,6 +1066,7 @@ fn build_pipeline_state(
    descriptor.set_label(label);
    descriptor.set_vertex_function(Some(vertex_fn.as_ref()));
    descriptor.set_fragment_function(Some(fragment_fn.as_ref()));
+    descriptor.set_sample_count(sample_count);
    let color_attachment = descriptor.color_attachments().object_at(0).unwrap();
    color_attachment.set_pixel_format(pixel_format);
    color_attachment.set_blending_enabled(true);
@@ -1170,50 +1082,45 @@ fn build_pipeline_state(
        .expect("could not create render pipeline state")
 }

-fn build_path_rasterization_pipeline_state(
-    device: &metal::DeviceRef,
-    library: &metal::LibraryRef,
-    label: &str,
-    vertex_fn_name: &str,
-    fragment_fn_name: &str,
-    pixel_format: metal::MTLPixelFormat,
-    path_sample_count: u32,
-) -> metal::RenderPipelineState {
-    let vertex_fn = library
-        .get_function(vertex_fn_name, None)
-        .expect("error locating vertex function");
-    let fragment_fn = library
-        .get_function(fragment_fn_name, None)
-        .expect("error locating fragment function");
-
-    let descriptor = metal::RenderPipelineDescriptor::new();
-    descriptor.set_label(label);
-    descriptor.set_vertex_function(Some(vertex_fn.as_ref()));
-    descriptor.set_fragment_function(Some(fragment_fn.as_ref()));
-    if path_sample_count > 1 {
-        descriptor.set_raster_sample_count(path_sample_count as _);
-        descriptor.set_alpha_to_coverage_enabled(true);
-    }
-    let color_attachment = descriptor.color_attachments().object_at(0).unwrap();
-    color_attachment.set_pixel_format(pixel_format);
-    color_attachment.set_blending_enabled(true);
-    color_attachment.set_rgb_blend_operation(metal::MTLBlendOperation::Add);
-    color_attachment.set_alpha_blend_operation(metal::MTLBlendOperation::Add);
-    color_attachment.set_source_rgb_blend_factor(metal::MTLBlendFactor::One);
-    color_attachment.set_source_alpha_blend_factor(metal::MTLBlendFactor::One);
-    color_attachment.set_destination_rgb_blend_factor(metal::MTLBlendFactor::One);
-    color_attachment.set_destination_alpha_blend_factor(metal::MTLBlendFactor::One);
-
-    device
-        .new_render_pipeline_state(&descriptor)
-        .expect("could not create render pipeline state")
-}
-
 // Align to multiples of 256 make Metal happy.
 fn align_offset(offset: &mut usize) {
    *offset = (*offset).div_ceil(256) * 256;
 }

+fn create_msaa_texture(
+    device: &metal::Device,
+    layer: &metal::MetalLayer,
+    sample_count: u64,
+) -> Option<metal::Texture> {
+    let viewport_size = layer.drawable_size();
+    let width = viewport_size.width.ceil() as u64;
+    let height = viewport_size.height.ceil() as u64;
+
+    if width == 0 || height == 0 {
+        return None;
+    }
+
+    if sample_count <= 1 {
+        return None;
+    }
+
+    let texture_descriptor = metal::TextureDescriptor::new();
+    texture_descriptor.set_texture_type(metal::MTLTextureType::D2Multisample);
+
+    // MTLStorageMode default is `shared` only for Apple silicon GPUs. Use `private` for Apple and Intel GPUs both.
+    // Reference: https://developer.apple.com/documentation/metal/choosing-a-resource-storage-mode-for-apple-gpus
+    texture_descriptor.set_storage_mode(metal::MTLStorageMode::Private);
+
+    texture_descriptor.set_width(width);
+    texture_descriptor.set_height(height);
+    texture_descriptor.set_pixel_format(layer.pixel_format());
+    texture_descriptor.set_usage(metal::MTLTextureUsage::RenderTarget);
+    texture_descriptor.set_sample_count(sample_count);
+
+    let metal_texture = device.new_texture(&texture_descriptor);
+    Some(metal_texture)
+}
+
 #[repr(C)]
 enum ShadowInputIndex {
    Vertices = 0,
@@ -1255,9 +1162,10 @@ enum SurfaceInputIndex {
 }

 #[repr(C)]
-enum PathRasterizationInputIndex {
+enum PathInputIndex {
    Vertices = 0,
-    AtlasTextureSize = 1,
+    ViewportSize = 1,
+    Sprites = 2,
 }

 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1265,7 +1173,6 @@ enum PathRasterizationInputIndex {
 pub struct PathSprite {
    pub bounds: Bounds<ScaledPixels>,
    pub color: Background,
-    pub tile: AtlasTile,
 }

 #[derive(Clone, Debug, Eq, PartialEq)]
--- a/crates/gpui/src/platform/mac/shaders.metal
+++ b/crates/gpui/src/platform/mac/shaders.metal
@@ -698,76 +698,27 @@ fragment float4 polychrome_sprite_fragment(
  return color;
 }

-struct PathRasterizationVertexOutput {
+struct PathVertexOutput {
  float4 position [[position]];
-  float2 st_position;
-  float clip_rect_distance [[clip_distance]][4];
-};
-
-struct PathRasterizationFragmentInput {
-  float4 position [[position]];
-  float2 st_position;
-};
-
-vertex PathRasterizationVertexOutput path_rasterization_vertex(
-    uint vertex_id [[vertex_id]],
-    constant PathVertex_ScaledPixels *vertices
-    [[buffer(PathRasterizationInputIndex_Vertices)]],
-    constant Size_DevicePixels *atlas_size
-    [[buffer(PathRasterizationInputIndex_AtlasTextureSize)]]) {
-  PathVertex_ScaledPixels v = vertices[vertex_id];
-  float2 vertex_position = float2(v.xy_position.x, v.xy_position.y);
-  float2 viewport_size = float2(atlas_size->width, atlas_size->height);
-  return PathRasterizationVertexOutput{
-      float4(vertex_position / viewport_size * float2(2., -2.) +
-                 float2(-1., 1.),
-             0., 1.),
-      float2(v.st_position.x, v.st_position.y),
-      {v.xy_position.x - v.content_mask.bounds.origin.x,
-       v.content_mask.bounds.origin.x + v.content_mask.bounds.size.width -
-           v.xy_position.x,
-       v.xy_position.y - v.content_mask.bounds.origin.y,
-       v.content_mask.bounds.origin.y + v.content_mask.bounds.size.height -
-           v.xy_position.y}};
-}
-
-fragment float4 path_rasterization_fragment(PathRasterizationFragmentInput input
-                                            [[stage_in]]) {
-  float2 dx = dfdx(input.st_position);
-  float2 dy = dfdy(input.st_position);
-  float2 gradient = float2((2. * input.st_position.x) * dx.x - dx.y,
-                           (2. * input.st_position.x) * dy.x - dy.y);
-  float f = (input.st_position.x * input.st_position.x) - input.st_position.y;
-  float distance = f / length(gradient);
-  float alpha = saturate(0.5 - distance);
-  return float4(alpha, 0., 0., 1.);
-}
-
-struct PathSpriteVertexOutput {
-  float4 position [[position]];
-  float2 tile_position;
  uint sprite_id [[flat]];
  float4 solid_color [[flat]];
  float4 color0 [[flat]];
  float4 color1 [[flat]];
+  float4 clip_distance;
 };

-vertex PathSpriteVertexOutput path_sprite_vertex(
-    uint unit_vertex_id [[vertex_id]], uint sprite_id [[instance_id]],
-    constant float2 *unit_vertices [[buffer(SpriteInputIndex_Vertices)]],
-    constant PathSprite *sprites [[buffer(SpriteInputIndex_Sprites)]],
-    constant Size_DevicePixels *viewport_size
-    [[buffer(SpriteInputIndex_ViewportSize)]],
-    constant Size_DevicePixels *atlas_size
-    [[buffer(SpriteInputIndex_AtlasTextureSize)]]) {
-
-  float2 unit_vertex = unit_vertices[unit_vertex_id];
+vertex PathVertexOutput path_vertex(
+    uint vertex_id [[vertex_id]],
+    constant PathVertex_ScaledPixels *vertices [[buffer(PathInputIndex_Vertices)]],
+    uint sprite_id [[instance_id]],
+    constant PathSprite *sprites [[buffer(PathInputIndex_Sprites)]],
+    constant Size_DevicePixels *input_viewport_size [[buffer(PathInputIndex_ViewportSize)]]) {
+  PathVertex_ScaledPixels v = vertices[vertex_id];
+  float2 vertex_position = float2(v.xy_position.x, v.xy_position.y);
+  float2 viewport_size = float2((float)input_viewport_size->width,
+                                (float)input_viewport_size->height);
  PathSprite sprite = sprites[sprite_id];
-  // Don't apply content mask because it was already accounted for when
-  // rasterizing the path.
-  float4 device_position =
-      to_device_position(unit_vertex, sprite.bounds, viewport_size);
-  float2 tile_position = to_tile_position(unit_vertex, sprite.tile, atlas_size);
+  float4 device_position = float4(vertex_position / viewport_size * float2(2., -2.) + float2(-1., 1.), 0., 1.);

  GradientColor gradient = prepare_fill_color(
    sprite.color.tag,
@@ -777,30 +728,32 @@ vertex PathSpriteVertexOutput path_sprite_vertex(
    sprite.color.colors[1].color
  );

-  return PathSpriteVertexOutput{
+  return PathVertexOutput{
    device_position,
-    tile_position,
    sprite_id,
    gradient.solid,
    gradient.color0,
-    gradient.color1
+    gradient.color1,
+    {v.xy_position.x - v.content_mask.bounds.origin.x,
+       v.content_mask.bounds.origin.x + v.content_mask.bounds.size.width -
+           v.xy_position.x,
+       v.xy_position.y - v.content_mask.bounds.origin.y,
+       v.content_mask.bounds.origin.y + v.content_mask.bounds.size.height -
+           v.xy_position.y}
  };
 }

-fragment float4 path_sprite_fragment(
-    PathSpriteVertexOutput input [[stage_in]],
-    constant PathSprite *sprites [[buffer(SpriteInputIndex_Sprites)]],
-    texture2d<float> atlas_texture [[texture(SpriteInputIndex_AtlasTexture)]]) {
-  constexpr sampler atlas_texture_sampler(mag_filter::linear,
-                                          min_filter::linear);
-  float4 sample =
-      atlas_texture.sample(atlas_texture_sampler, input.tile_position);
-  float mask = 1. - abs(1. - fmod(sample.r, 2.));
+fragment float4 path_fragment(
+    PathVertexOutput input [[stage_in]],
+    constant PathSprite *sprites [[buffer(PathInputIndex_Sprites)]]) {
+  if (any(input.clip_distance < float4(0.0))) {
+    return float4(0.0);
+  }
+
  PathSprite sprite = sprites[input.sprite_id];
  Background background = sprite.color;
  float4 color = fill_color(background, input.position.xy, sprite.bounds,
    input.solid_color, input.color0, input.color1);
-  color.a *= mask;
  return color;
 }

--- a/crates/gpui/src/platform/test/window.rs
+++ b/crates/gpui/src/platform/test/window.rs
@@ -341,7 +341,7 @@ impl PlatformAtlas for TestAtlas {
            crate::AtlasTile {
                texture_id: AtlasTextureId {
                    index: texture_id,
-                    kind: crate::AtlasTextureKind::Path,
+                    kind: crate::AtlasTextureKind::Polychrome,
                },
                tile_id: TileId(tile_id),
                padding: 0,
--- a/crates/gpui/src/scene.rs
+++ b/crates/gpui/src/scene.rs
@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};

 use crate::{
    AtlasTextureId, AtlasTile, Background, Bounds, ContentMask, Corners, Edges, Hsla, Pixels,
-    Point, Radians, ScaledPixels, Size, bounds_tree::BoundsTree, point,
+    Point, Radians, ScaledPixels, Size, bounds_tree::BoundsTree,
 };
 use std::{fmt::Debug, iter::Peekable, ops::Range, slice};

@@ -43,13 +43,7 @@ impl Scene {
        self.surfaces.clear();
    }

-    #[cfg_attr(
-        all(
-            any(target_os = "linux", target_os = "freebsd"),
-            not(any(feature = "x11", feature = "wayland"))
-        ),
-        allow(dead_code)
-    )]
+    #[allow(dead_code)]
    pub fn paths(&self) -> &[Path<ScaledPixels>] {
        &self.paths
    }
@@ -689,6 +683,7 @@ pub struct Path<P: Clone + Debug + Default + PartialEq> {
    start: Point<P>,
    current: Point<P>,
    contour_count: usize,
+    base_scale: f32,
 }

 impl Path<Pixels> {
@@ -707,25 +702,35 @@ impl Path<Pixels> {
            content_mask: Default::default(),
            color: Default::default(),
            contour_count: 0,
+            base_scale: 1.0,
        }
    }

-    /// Scale this path by the given factor.
-    pub fn scale(&self, factor: f32) -> Path<ScaledPixels> {
+    /// Set the base scale of the path.
+    pub fn scale(mut self, factor: f32) -> Self {
+        self.base_scale = factor;
+        self
+    }
+
+    /// Apply a scale to the path.
+    pub(crate) fn apply_scale(&self, factor: f32) -> Path<ScaledPixels> {
        Path {
            id: self.id,
            order: self.order,
-            bounds: self.bounds.scale(factor),
-            content_mask: self.content_mask.scale(factor),
+            bounds: self.bounds.scale(self.base_scale * factor),
+            content_mask: self.content_mask.scale(self.base_scale * factor),
            vertices: self
                .vertices
                .iter()
-                .map(|vertex| vertex.scale(factor))
+                .map(|vertex| vertex.scale(self.base_scale * factor))
                .collect(),
-            start: self.start.map(|start| start.scale(factor)),
-            current: self.current.scale(factor),
+            start: self
+                .start
+                .map(|start| start.scale(self.base_scale * factor)),
+            current: self.current.scale(self.base_scale * factor),
            contour_count: self.contour_count,
            color: self.color,
+            base_scale: 1.0,
        }
    }

@@ -740,10 +745,7 @@ impl Path<Pixels> {
    pub fn line_to(&mut self, to: Point<Pixels>) {
        self.contour_count += 1;
        if self.contour_count > 1 {
-            self.push_triangle(
-                (self.start, self.current, to),
-                (point(0., 1.), point(0., 1.), point(0., 1.)),
-            );
+            self.push_triangle((self.start, self.current, to));
        }
        self.current = to;
    }
@@ -752,25 +754,15 @@ impl Path<Pixels> {
    pub fn curve_to(&mut self, to: Point<Pixels>, ctrl: Point<Pixels>) {
        self.contour_count += 1;
        if self.contour_count > 1 {
-            self.push_triangle(
-                (self.start, self.current, to),
-                (point(0., 1.), point(0., 1.), point(0., 1.)),
-            );
+            self.push_triangle((self.start, self.current, to));
        }

-        self.push_triangle(
-            (self.current, ctrl, to),
-            (point(0., 0.), point(0.5, 0.), point(1., 1.)),
-        );
+        self.push_triangle((self.current, ctrl, to));
        self.current = to;
    }

    /// Push a triangle to the Path.
-    pub fn push_triangle(
-        &mut self,
-        xy: (Point<Pixels>, Point<Pixels>, Point<Pixels>),
-        st: (Point<f32>, Point<f32>, Point<f32>),
-    ) {
+    pub fn push_triangle(&mut self, xy: (Point<Pixels>, Point<Pixels>, Point<Pixels>)) {
        self.bounds = self
            .bounds
            .union(&Bounds {
@@ -788,17 +780,14 @@ impl Path<Pixels> {

        self.vertices.push(PathVertex {
            xy_position: xy.0,
-            st_position: st.0,
            content_mask: Default::default(),
        });
        self.vertices.push(PathVertex {
            xy_position: xy.1,
-            st_position: st.1,
            content_mask: Default::default(),
        });
        self.vertices.push(PathVertex {
            xy_position: xy.2,
-            st_position: st.2,
            content_mask: Default::default(),
        });
    }
@@ -814,7 +803,6 @@ impl From<Path<ScaledPixels>> for Primitive {
 #[repr(C)]
 pub(crate) struct PathVertex<P: Clone + Debug + Default + PartialEq> {
    pub(crate) xy_position: Point<P>,
-    pub(crate) st_position: Point<f32>,
    pub(crate) content_mask: ContentMask<P>,
 }

@@ -822,7 +810,6 @@ impl PathVertex<Pixels> {
    pub fn scale(&self, factor: f32) -> PathVertex<ScaledPixels> {
        PathVertex {
            xy_position: self.xy_position.scale(factor),
-            st_position: self.st_position,
            content_mask: self.content_mask.scale(factor),
        }
    }
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -2424,53 +2424,6 @@ impl Window {
        result
    }

-    /// Use a piece of state that exists as long this element is being rendered in consecutive frames.
-    pub fn use_keyed_state<S: 'static>(
-        &mut self,
-        key: impl Into<ElementId>,
-        cx: &mut App,
-        init: impl FnOnce(&mut Self, &mut App) -> S,
-    ) -> Entity<S> {
-        let current_view = self.current_view();
-        self.with_global_id(key.into(), |global_id, window| {
-            window.with_element_state(global_id, |state: Option<Entity<S>>, window| {
-                if let Some(state) = state {
-                    (state.clone(), state)
-                } else {
-                    let new_state = cx.new(|cx| init(window, cx));
-                    cx.observe(&new_state, move |_, cx| {
-                        cx.notify(current_view);
-                    })
-                    .detach();
-                    (new_state.clone(), new_state)
-                }
-            })
-        })
-    }
-
-    /// Immediately push an element ID onto the stack. Useful for simplifying IDs in lists
-    pub fn with_id<R>(&mut self, id: impl Into<ElementId>, f: impl FnOnce(&mut Self) -> R) -> R {
-        self.with_global_id(id.into(), |_, window| f(window))
-    }
-
-    /// Use a piece of state that exists as long this element is being rendered in consecutive frames, without needing to specify a key
-    ///
-    /// NOTE: This method uses the location of the caller to generate an ID for this state.
-    ///       If this is not sufficient to identify your state (e.g. you're rendering a list item),
-    ///       you can provide a custom ElementID using the `use_keyed_state` method.
-    #[track_caller]
-    pub fn use_state<S: 'static>(
-        &mut self,
-        cx: &mut App,
-        init: impl FnOnce(&mut Self, &mut App) -> S,
-    ) -> Entity<S> {
-        self.use_keyed_state(
-            ElementId::CodeLocation(*core::panic::Location::caller()),
-            cx,
-            init,
-        )
-    }
-
    /// Updates or initializes state for an element with the given id that lives across multiple
    /// frames. If an element with this ID existed in the rendered frame, its state will be passed
    /// to the given closure. The state returned by the closure will be stored so it can be referenced
@@ -2705,7 +2658,7 @@ impl Window {
        path.color = color.opacity(opacity);
        self.next_frame
            .scene
-            .insert_primitive(path.scale(scale_factor));
+            .insert_primitive(path.apply_scale(scale_factor));
    }

    /// Paint an underline into the scene for the next frame at the current z-index.
@@ -4624,8 +4577,6 @@ pub enum ElementId {
    NamedInteger(SharedString, u64),
    /// A path.
    Path(Arc<std::path::Path>),
-    /// A code location.
-    CodeLocation(core::panic::Location<'static>),
 }

 impl ElementId {
@@ -4645,7 +4596,6 @@ impl Display for ElementId {
            ElementId::NamedInteger(s, i) => write!(f, "{}-{}", s, i)?,
            ElementId::Uuid(uuid) => write!(f, "{}", uuid)?,
            ElementId::Path(path) => write!(f, "{}", path.display())?,
-            ElementId::CodeLocation(location) => write!(f, "{}", location)?,
        }

        Ok(())
--- a/crates/gpui_macros/src/derive_app_context.rs
+++ b/crates/gpui_macros/src/derive_app_context.rs
@@ -53,16 +53,6 @@ pub fn derive_app_context(input: TokenStream) -> TokenStream {
                self.#app_variable.update_entity(handle, update)
            }

-            fn as_mut<'y, 'z, T>(
-                &'y mut self,
-                handle: &'z gpui::Entity<T>,
-            ) -> Self::Result<gpui::GpuiBorrow<'y, T>>
-            where
-                T: 'static,
-            {
-                self.#app_variable.as_mut(handle)
-            }
-
            fn read_entity<T, R>(
                &self,
                handle: &gpui::Entity<T>,
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -2072,21 +2072,6 @@ impl Buffer {
        self.text.push_transaction(transaction, now);
    }

-    /// Differs from `push_transaction` in that it does not clear the redo
-    /// stack. Intended to be used to create a parent transaction to merge
-    /// potential child transactions into.
-    ///
-    /// The caller is responsible for removing it from the undo history using
-    /// `forget_transaction` if no edits are merged into it. Otherwise, if edits
-    /// are merged into this transaction, the caller is responsible for ensuring
-    /// the redo stack is cleared. The easiest way to ensure the redo stack is
-    /// cleared is to create transactions with the usual `start_transaction` and
-    /// `end_transaction` methods and merging the resulting transactions into
-    /// the transaction created by this method
-    pub fn push_empty_transaction(&mut self, now: Instant) -> TransactionId {
-        self.text.push_empty_transaction(now)
-    }
-
    /// Prevent the last transaction from being grouped with any subsequent transactions,
    /// even if they occur with the buffer's undo grouping duration.
    pub fn finalize_last_transaction(&mut self) -> Option<&Transaction> {
--- a/crates/language_model/src/language_model.rs
+++ b/crates/language_model/src/language_model.rs
@@ -116,12 +116,6 @@ pub enum LanguageModelCompletionError {
        provider: LanguageModelProviderName,
        message: String,
    },
-    #[error("{message}")]
-    UpstreamProviderError {
-        message: String,
-        status: StatusCode,
-        retry_after: Option<Duration>,
-    },
    #[error("HTTP response error from {provider}'s API: status {status_code} - {message:?}")]
    HttpResponseError {
        provider: LanguageModelProviderName,
@@ -184,6 +178,21 @@ pub enum LanguageModelCompletionError {
 }

 impl LanguageModelCompletionError {
+    fn parse_upstream_error_json(message: &str) -> Option<(StatusCode, String)> {
+        let error_json = serde_json::from_str::<serde_json::Value>(message).ok()?;
+        let upstream_status = error_json
+            .get("upstream_status")
+            .and_then(|v| v.as_u64())
+            .and_then(|status| u16::try_from(status).ok())
+            .and_then(|status| StatusCode::from_u16(status).ok())?;
+        let inner_message = error_json
+            .get("message")
+            .and_then(|v| v.as_str())
+            .unwrap_or(message)
+            .to_string();
+        Some((upstream_status, inner_message))
+    }
+
    pub fn from_cloud_failure(
        upstream_provider: LanguageModelProviderName,
        code: String,
@@ -197,6 +206,18 @@ impl LanguageModelCompletionError {
            Self::PromptTooLarge {
                tokens: Some(tokens),
            }
+        } else if code == "upstream_http_error" {
+            if let Some((upstream_status, inner_message)) =
+                Self::parse_upstream_error_json(&message)
+            {
+                return Self::from_http_status(
+                    upstream_provider,
+                    upstream_status,
+                    inner_message,
+                    retry_after,
+                );
+            }
+            anyhow!("completion request failed, code: {code}, message: {message}").into()
        } else if let Some(status_code) = code
            .strip_prefix("upstream_http_")
            .and_then(|code| StatusCode::from_str(code).ok())
@@ -707,3 +728,104 @@ impl From<String> for LanguageModelProviderName {
        Self(SharedString::from(value))
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_from_cloud_failure_with_upstream_http_error() {
+        let error = LanguageModelCompletionError::from_cloud_failure(
+            String::from("anthropic").into(),
+            "upstream_http_error".to_string(),
+            r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":503}"#.to_string(),
+            None,
+        );
+
+        match error {
+            LanguageModelCompletionError::ServerOverloaded { provider, .. } => {
+                assert_eq!(provider.0, "anthropic");
+            }
+            _ => panic!(
+                "Expected ServerOverloaded error for 503 status, got: {:?}",
+                error
+            ),
+        }
+
+        let error = LanguageModelCompletionError::from_cloud_failure(
+            String::from("anthropic").into(),
+            "upstream_http_error".to_string(),
+            r#"{"code":"upstream_http_error","message":"Internal server error","upstream_status":500}"#.to_string(),
+            None,
+        );
+
+        match error {
+            LanguageModelCompletionError::ApiInternalServerError { provider, message } => {
+                assert_eq!(provider.0, "anthropic");
+                assert_eq!(message, "Internal server error");
+            }
+            _ => panic!(
+                "Expected ApiInternalServerError for 500 status, got: {:?}",
+                error
+            ),
+        }
+    }
+
+    #[test]
+    fn test_from_cloud_failure_with_standard_format() {
+        let error = LanguageModelCompletionError::from_cloud_failure(
+            String::from("anthropic").into(),
+            "upstream_http_503".to_string(),
+            "Service unavailable".to_string(),
+            None,
+        );
+
+        match error {
+            LanguageModelCompletionError::ServerOverloaded { provider, .. } => {
+                assert_eq!(provider.0, "anthropic");
+            }
+            _ => panic!("Expected ServerOverloaded error for upstream_http_503"),
+        }
+    }
+
+    #[test]
+    fn test_upstream_http_error_connection_timeout() {
+        let error = LanguageModelCompletionError::from_cloud_failure(
+            String::from("anthropic").into(),
+            "upstream_http_error".to_string(),
+            r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":503}"#.to_string(),
+            None,
+        );
+
+        match error {
+            LanguageModelCompletionError::ServerOverloaded { provider, .. } => {
+                assert_eq!(provider.0, "anthropic");
+            }
+            _ => panic!(
+                "Expected ServerOverloaded error for connection timeout with 503 status, got: {:?}",
+                error
+            ),
+        }
+
+        let error = LanguageModelCompletionError::from_cloud_failure(
+            String::from("anthropic").into(),
+            "upstream_http_error".to_string(),
+            r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":500}"#.to_string(),
+            None,
+        );
+
+        match error {
+            LanguageModelCompletionError::ApiInternalServerError { provider, message } => {
+                assert_eq!(provider.0, "anthropic");
+                assert_eq!(
+                    message,
+                    "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout"
+                );
+            }
+            _ => panic!(
+                "Expected ApiInternalServerError for connection timeout with 500 status, got: {:?}",
+                error
+            ),
+        }
+    }
+}
--- a/crates/language_models/src/provider/cloud.rs
+++ b/crates/language_models/src/provider/cloud.rs
@@ -644,62 +644,8 @@ struct ApiError {
    headers: HeaderMap<HeaderValue>,
 }

-/// Represents error responses from Zed's cloud API.
-///
-/// Example JSON for an upstream HTTP error:
-/// ```json
-/// {
-///   "code": "upstream_http_error",
-///   "message": "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout",
-///   "upstream_status": 503
-/// }
-/// ```
-#[derive(Debug, serde::Deserialize)]
-struct CloudApiError {
-    code: String,
-    message: String,
-    #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_status_code")]
-    upstream_status: Option<StatusCode>,
-    #[serde(default)]
-    retry_after: Option<f64>,
-}
-
-fn deserialize_optional_status_code<'de, D>(deserializer: D) -> Result<Option<StatusCode>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let opt: Option<u16> = Option::deserialize(deserializer)?;
-    Ok(opt.and_then(|code| StatusCode::from_u16(code).ok()))
-}
-
 impl From<ApiError> for LanguageModelCompletionError {
    fn from(error: ApiError) -> Self {
-        if let Ok(cloud_error) = serde_json::from_str::<CloudApiError>(&error.body) {
-            if cloud_error.code.starts_with("upstream_http_") {
-                let status = if let Some(status) = cloud_error.upstream_status {
-                    status
-                } else if cloud_error.code.ends_with("_error") {
-                    error.status
-                } else {
-                    // If there's a status code in the code string (e.g. "upstream_http_429")
-                    // then use that; otherwise, see if the JSON contains a status code.
-                    cloud_error
-                        .code
-                        .strip_prefix("upstream_http_")
-                        .and_then(|code_str| code_str.parse::<u16>().ok())
-                        .and_then(|code| StatusCode::from_u16(code).ok())
-                        .unwrap_or(error.status)
-                };
-
-                return LanguageModelCompletionError::UpstreamProviderError {
-                    message: cloud_error.message,
-                    status,
-                    retry_after: cloud_error.retry_after.map(Duration::from_secs_f64),
-                };
-            }
-        }
-
        let retry_after = None;
        LanguageModelCompletionError::from_http_status(
            PROVIDER_NAME,
@@ -1333,155 +1279,3 @@ impl Component for ZedAiConfiguration {
        )
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use http_client::http::{HeaderMap, StatusCode};
-    use language_model::LanguageModelCompletionError;
-
-    #[test]
-    fn test_api_error_conversion_with_upstream_http_error() {
-        // upstream_http_error with 503 status should become ServerOverloaded
-        let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout","upstream_status":503}"#;
-
-        let api_error = ApiError {
-            status: StatusCode::INTERNAL_SERVER_ERROR,
-            body: error_body.to_string(),
-            headers: HeaderMap::new(),
-        };
-
-        let completion_error: LanguageModelCompletionError = api_error.into();
-
-        match completion_error {
-            LanguageModelCompletionError::UpstreamProviderError { message, .. } => {
-                assert_eq!(
-                    message,
-                    "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout"
-                );
-            }
-            _ => panic!(
-                "Expected UpstreamProviderError for upstream 503, got: {:?}",
-                completion_error
-            ),
-        }
-
-        // upstream_http_error with 500 status should become ApiInternalServerError
-        let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the OpenAI API: internal server error","upstream_status":500}"#;
-
-        let api_error = ApiError {
-            status: StatusCode::INTERNAL_SERVER_ERROR,
-            body: error_body.to_string(),
-            headers: HeaderMap::new(),
-        };
-
-        let completion_error: LanguageModelCompletionError = api_error.into();
-
-        match completion_error {
-            LanguageModelCompletionError::UpstreamProviderError { message, .. } => {
-                assert_eq!(
-                    message,
-                    "Received an error from the OpenAI API: internal server error"
-                );
-            }
-            _ => panic!(
-                "Expected UpstreamProviderError for upstream 500, got: {:?}",
-                completion_error
-            ),
-        }
-
-        // upstream_http_error with 429 status should become RateLimitExceeded
-        let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the Google API: rate limit exceeded","upstream_status":429}"#;
-
-        let api_error = ApiError {
-            status: StatusCode::INTERNAL_SERVER_ERROR,
-            body: error_body.to_string(),
-            headers: HeaderMap::new(),
-        };
-
-        let completion_error: LanguageModelCompletionError = api_error.into();
-
-        match completion_error {
-            LanguageModelCompletionError::UpstreamProviderError { message, .. } => {
-                assert_eq!(
-                    message,
-                    "Received an error from the Google API: rate limit exceeded"
-                );
-            }
-            _ => panic!(
-                "Expected UpstreamProviderError for upstream 429, got: {:?}",
-                completion_error
-            ),
-        }
-
-        // Regular 500 error without upstream_http_error should remain ApiInternalServerError for Zed
-        let error_body = "Regular internal server error";
-
-        let api_error = ApiError {
-            status: StatusCode::INTERNAL_SERVER_ERROR,
-            body: error_body.to_string(),
-            headers: HeaderMap::new(),
-        };
-
-        let completion_error: LanguageModelCompletionError = api_error.into();
-
-        match completion_error {
-            LanguageModelCompletionError::ApiInternalServerError { provider, message } => {
-                assert_eq!(provider, PROVIDER_NAME);
-                assert_eq!(message, "Regular internal server error");
-            }
-            _ => panic!(
-                "Expected ApiInternalServerError for regular 500, got: {:?}",
-                completion_error
-            ),
-        }
-
-        // upstream_http_429 format should be converted to UpstreamProviderError
-        let error_body = r#"{"code":"upstream_http_429","message":"Upstream Anthropic rate limit exceeded.","retry_after":30.5}"#;
-
-        let api_error = ApiError {
-            status: StatusCode::INTERNAL_SERVER_ERROR,
-            body: error_body.to_string(),
-            headers: HeaderMap::new(),
-        };
-
-        let completion_error: LanguageModelCompletionError = api_error.into();
-
-        match completion_error {
-            LanguageModelCompletionError::UpstreamProviderError {
-                message,
-                status,
-                retry_after,
-            } => {
-                assert_eq!(message, "Upstream Anthropic rate limit exceeded.");
-                assert_eq!(status, StatusCode::TOO_MANY_REQUESTS);
-                assert_eq!(retry_after, Some(Duration::from_secs_f64(30.5)));
-            }
-            _ => panic!(
-                "Expected UpstreamProviderError for upstream_http_429, got: {:?}",
-                completion_error
-            ),
-        }
-
-        // Invalid JSON in error body should fall back to regular error handling
-        let error_body = "Not JSON at all";
-
-        let api_error = ApiError {
-            status: StatusCode::INTERNAL_SERVER_ERROR,
-            body: error_body.to_string(),
-            headers: HeaderMap::new(),
-        };
-
-        let completion_error: LanguageModelCompletionError = api_error.into();
-
-        match completion_error {
-            LanguageModelCompletionError::ApiInternalServerError { provider, .. } => {
-                assert_eq!(provider, PROVIDER_NAME);
-            }
-            _ => panic!(
-                "Expected ApiInternalServerError for invalid JSON, got: {:?}",
-                completion_error
-            ),
-        }
-    }
-}
--- a/crates/language_models/src/provider/google.rs
+++ b/crates/language_models/src/provider/google.rs
@@ -94,6 +94,7 @@ pub struct State {
    _subscription: Subscription,
 }

+const GEMINI_API_KEY_VAR: &str = "GEMINI_API_KEY";
 const GOOGLE_AI_API_KEY_VAR: &str = "GOOGLE_AI_API_KEY";

 impl State {
@@ -151,6 +152,8 @@ impl State {
        cx.spawn(async move |this, cx| {
            let (api_key, from_env) = if let Ok(api_key) = std::env::var(GOOGLE_AI_API_KEY_VAR) {
                (api_key, true)
+            } else if let Ok(api_key) = std::env::var(GEMINI_API_KEY_VAR) {
+                (api_key, true)
            } else {
                let (_, api_key) = credentials_provider
                    .read_credentials(&api_url, &cx)
@@ -903,7 +906,7 @@ impl Render for ConfigurationView {
                )
                .child(
                    Label::new(
-                        format!("You can also assign the {GOOGLE_AI_API_KEY_VAR} environment variable and restart Zed."),
+                        format!("You can also assign the {GEMINI_API_KEY_VAR} environment variable and restart Zed."),
                    )
                    .size(LabelSize::Small).color(Color::Muted),
                )
@@ -922,7 +925,7 @@ impl Render for ConfigurationView {
                        .gap_1()
                        .child(Icon::new(IconName::Check).color(Color::Success))
                        .child(Label::new(if env_var_set {
-                            format!("API key set in {GOOGLE_AI_API_KEY_VAR} environment variable.")
+                            format!("API key set in {GEMINI_API_KEY_VAR} environment variable.")
                        } else {
                            "API key configured.".to_string()
                        })),
@@ -935,7 +938,7 @@ impl Render for ConfigurationView {
                        .icon_position(IconPosition::Start)
                        .disabled(env_var_set)
                        .when(env_var_set, |this| {
-                            this.tooltip(Tooltip::text(format!("To reset your API key, unset the {GOOGLE_AI_API_KEY_VAR} environment variable.")))
+                            this.tooltip(Tooltip::text(format!("To reset your API key, make sure {GEMINI_API_KEY_VAR} and {GOOGLE_AI_API_KEY_VAR} environment variables are unset.")))
                        })
                        .on_click(cx.listener(|this, _, window, cx| this.reset_api_key(window, cx))),
                )
--- a/crates/language_models/src/provider/mistral.rs
+++ b/crates/language_models/src/provider/mistral.rs
@@ -410,20 +410,8 @@ pub fn into_mistral(
                                .push_part(mistral::MessagePart::Text { text: text.clone() });
                        }
                        MessageContent::RedactedThinking(_) => {}
-                        MessageContent::ToolUse(_) => {
-                            // Tool use is not supported in User messages for Mistral
-                        }
-                        MessageContent::ToolResult(tool_result) => {
-                            let tool_content = match &tool_result.content {
-                                LanguageModelToolResultContent::Text(text) => text.to_string(),
-                                LanguageModelToolResultContent::Image(_) => {
-                                    "[Tool responded with an image, but Zed doesn't support these in Mistral models yet]".to_string()
-                                }
-                            };
-                            messages.push(mistral::RequestMessage::Tool {
-                                content: tool_content,
-                                tool_call_id: tool_result.tool_use_id.to_string(),
-                            });
+                        MessageContent::ToolUse(_) | MessageContent::ToolResult(_) => {
+                            // Tool content is not supported in User messages for Mistral
                        }
                    }
                }
@@ -494,6 +482,24 @@ pub fn into_mistral(
        }
    }

+    for message in &request.messages {
+        for content in &message.content {
+            if let MessageContent::ToolResult(tool_result) = content {
+                let content = match &tool_result.content {
+                    LanguageModelToolResultContent::Text(text) => text.to_string(),
+                    LanguageModelToolResultContent::Image(_) => {
+                        "[Tool responded with an image, but Zed doesn't support these in Mistral models yet]".to_string()
+                    }
+                };
+
+                messages.push(mistral::RequestMessage::Tool {
+                    content,
+                    tool_call_id: tool_result.tool_use_id.to_string(),
+                });
+            }
+        }
+    }
+
    // The Mistral API requires that tool messages be followed by assistant messages,
    // not user messages. When we have a tool->user sequence in the conversation,
    // we need to insert a placeholder assistant message to maintain proper conversation
--- a/crates/languages/src/json.rs
+++ b/crates/languages/src/json.rs
@@ -231,13 +231,6 @@ impl JsonLspAdapter {
            ))
        }

-        schemas
-            .as_array_mut()
-            .unwrap()
-            .extend(cx.all_action_names().into_iter().map(|&name| {
-                project::lsp_store::json_language_server_ext::url_schema_for_action(name)
-            }));
-
        // This can be viewed via `dev: open language server logs` -> `json-language-server` ->
        // `Server Info`
        serde_json::json!({
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -273,7 +273,6 @@ pub fn init(languages: Arc<LanguageRegistry>, node: NodeRuntime, cx: &mut App) {
        "Astro",
        "CSS",
        "ERB",
-        "HTML/ERB",
        "HEEX",
        "HTML",
        "JavaScript",
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -179,7 +179,6 @@ impl LspAdapter for TailwindLspAdapter {
            ("Elixir".to_string(), "phoenix-heex".to_string()),
            ("HEEX".to_string(), "phoenix-heex".to_string()),
            ("ERB".to_string(), "erb".to_string()),
-            ("HTML/ERB".to_string(), "erb".to_string()),
            ("PHP".to_string(), "php".to_string()),
            ("Vue.js".to_string(), "vue".to_string()),
        ])
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -1,5 +1,4 @@
 pub mod clangd_ext;
-pub mod json_language_server_ext;
 pub mod lsp_ext_command;
 pub mod rust_analyzer_ext;

@@ -1035,7 +1034,6 @@ impl LocalLspStore {
            })
            .detach();

-        json_language_server_ext::register_requests(this.clone(), language_server);
        rust_analyzer_ext::register_notifications(this.clone(), language_server);
        clangd_ext::register_notifications(this, language_server, adapter);
    }
@@ -1274,11 +1272,15 @@ impl LocalLspStore {
                // grouped with the previous transaction in the history
                // based on the transaction group interval
                buffer.finalize_last_transaction();
-                buffer
+                let transaction_id = buffer
                    .start_transaction()
                    .context("transaction already open")?;
+                let transaction = buffer
+                    .get_transaction(transaction_id)
+                    .expect("transaction started")
+                    .clone();
                buffer.end_transaction(cx);
-                let transaction_id = buffer.push_empty_transaction(cx.background_executor().now());
+                buffer.push_transaction(transaction, cx.background_executor().now());
                buffer.finalize_last_transaction();
                anyhow::Ok(transaction_id)
            })??;
--- a/crates/project/src/lsp_store/json_language_server_ext.rs
+++ b/crates/project/src/lsp_store/json_language_server_ext.rs
@@ -1,101 +0,0 @@
-use anyhow::Context as _;
-use collections::HashMap;
-use gpui::WeakEntity;
-use lsp::LanguageServer;
-
-use crate::LspStore;
-/// https://github.com/Microsoft/vscode/blob/main/extensions/json-language-features/server/README.md#schema-content-request
-///
-/// Represents a "JSON language server-specific, non-standardized, extension to the LSP" with which the vscode-json-language-server
-/// can request the contents of a schema that is associated with a uri scheme it does not support.
-/// In our case, we provide the uris for actions on server startup under the `zed://schemas/action/{normalize_action_name}` scheme.
-/// We can then respond to this request with the schema content on demand, thereby greatly reducing the total size of the JSON we send to the server on startup
-struct SchemaContentRequest {}
-
-impl lsp::request::Request for SchemaContentRequest {
-    type Params = Vec<String>;
-
-    type Result = String;
-
-    const METHOD: &'static str = "vscode/content";
-}
-
-pub fn register_requests(_lsp_store: WeakEntity<LspStore>, language_server: &LanguageServer) {
-    language_server
-        .on_request::<SchemaContentRequest, _, _>(|params, cx| {
-            // PERF: Use a cache (`OnceLock`?) to avoid recomputing the action schemas
-            let mut generator = settings::KeymapFile::action_schema_generator();
-            let all_schemas = cx.update(|cx| HashMap::from_iter(cx.action_schemas(&mut generator)));
-            async move {
-                let all_schemas = all_schemas?;
-                let Some(uri) = params.get(0) else {
-                    anyhow::bail!("No URI");
-                };
-                let normalized_action_name = uri
-                    .strip_prefix("zed://schemas/action/")
-                    .context("Invalid URI")?;
-                let action_name = denormalize_action_name(normalized_action_name);
-                let schema = root_schema_from_action_schema(
-                    all_schemas
-                        .get(action_name.as_str())
-                        .and_then(Option::as_ref),
-                    &mut generator,
-                )
-                .to_value();
-
-                serde_json::to_string(&schema).context("Failed to serialize schema")
-            }
-        })
-        .detach();
-}
-
-pub fn normalize_action_name(action_name: &str) -> String {
-    action_name.replace("::", "__")
-}
-
-pub fn denormalize_action_name(action_name: &str) -> String {
-    action_name.replace("__", "::")
-}
-
-pub fn normalized_action_file_name(action_name: &str) -> String {
-    normalized_action_name_to_file_name(normalize_action_name(action_name))
-}
-
-pub fn normalized_action_name_to_file_name(mut normalized_action_name: String) -> String {
-    normalized_action_name.push_str(".json");
-    normalized_action_name
-}
-
-pub fn url_schema_for_action(action_name: &str) -> serde_json::Value {
-    let normalized_name = normalize_action_name(action_name);
-    let file_name = normalized_action_name_to_file_name(normalized_name.clone());
-    serde_json::json!({
-        "fileMatch": [file_name],
-        "url": format!("zed://schemas/action/{}", normalized_name)
-    })
-}
-
-fn root_schema_from_action_schema(
-    action_schema: Option<&schemars::Schema>,
-    generator: &mut schemars::SchemaGenerator,
-) -> schemars::Schema {
-    let Some(action_schema) = action_schema else {
-        return schemars::json_schema!(false);
-    };
-    let meta_schema = generator
-        .settings()
-        .meta_schema
-        .as_ref()
-        .expect("meta_schema should be present in schemars settings")
-        .to_string();
-    let defs = generator.definitions();
-    let mut schema = schemars::json_schema!({
-        "$schema": meta_schema,
-        "allowTrailingCommas": true,
-        "$defs": defs,
-    });
-    schema
-        .ensure_object()
-        .extend(std::mem::take(action_schema.clone().ensure_object()));
-    schema
-}
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -384,20 +384,12 @@ struct ItemColors {
    focused: Hsla,
 }

-fn get_item_color(is_sticky: bool, cx: &App) -> ItemColors {
+fn get_item_color(cx: &App) -> ItemColors {
    let colors = cx.theme().colors();

    ItemColors {
-        default: if is_sticky {
-            colors.panel_overlay_background
-        } else {
-            colors.panel_background
-        },
-        hover: if is_sticky {
-            colors.panel_overlay_hover
-        } else {
-            colors.element_hover
-        },
+        default: colors.panel_background,
+        hover: colors.element_hover,
        marked: colors.element_selected,
        focused: colors.panel_focused_border,
        drag_over: colors.drop_target_background,
@@ -3911,7 +3903,7 @@ impl ProjectPanel {

        let filename_text_color = details.filename_text_color;
        let diagnostic_severity = details.diagnostic_severity;
-        let item_colors = get_item_color(is_sticky, cx);
+        let item_colors = get_item_color(cx);

        let canonical_path = details
            .canonical_path
--- a/crates/settings/src/keymap_file.rs
+++ b/crates/settings/src/keymap_file.rs
@@ -959,21 +959,19 @@ impl<'a> KeybindUpdateTarget<'a> {
    }
 }

-#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub enum KeybindSource {
    User,
-    Vim,
-    Base,
-    #[default]
    Default,
-    Unknown,
+    Base,
+    Vim,
 }

 impl KeybindSource {
-    const BASE: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::Base as u32);
-    const DEFAULT: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::Default as u32);
-    const VIM: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::Vim as u32);
-    const USER: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::User as u32);
+    const BASE: KeyBindingMetaIndex = KeyBindingMetaIndex(0);
+    const DEFAULT: KeyBindingMetaIndex = KeyBindingMetaIndex(1);
+    const VIM: KeyBindingMetaIndex = KeyBindingMetaIndex(2);
+    const USER: KeyBindingMetaIndex = KeyBindingMetaIndex(3);

    pub fn name(&self) -> &'static str {
        match self {
@@ -981,7 +979,6 @@ impl KeybindSource {
            KeybindSource::Default => "Default",
            KeybindSource::Base => "Base",
            KeybindSource::Vim => "Vim",
-            KeybindSource::Unknown => "Unknown",
        }
    }

@@ -991,7 +988,6 @@ impl KeybindSource {
            KeybindSource::Default => Self::DEFAULT,
            KeybindSource::Base => Self::BASE,
            KeybindSource::Vim => Self::VIM,
-            KeybindSource::Unknown => KeyBindingMetaIndex(*self as u32),
        }
    }

@@ -1001,7 +997,7 @@ impl KeybindSource {
            Self::BASE => KeybindSource::Base,
            Self::DEFAULT => KeybindSource::Default,
            Self::VIM => KeybindSource::Vim,
-            _ => KeybindSource::Unknown,
+            _ => unreachable!(),
        }
    }
 }
@@ -1014,7 +1010,7 @@ impl From<KeyBindingMetaIndex> for KeybindSource {

 impl From<KeybindSource> for KeyBindingMetaIndex {
    fn from(source: KeybindSource) -> Self {
-        source.meta()
+        return source.meta();
    }
 }

@@ -1623,44 +1619,4 @@ mod tests {
            .unindent(),
        );
    }
-
-    #[test]
-    fn test_keymap_remove() {
-        zlog::init_test();
-
-        check_keymap_update(
-            r#"
-            [
-              {
-                "context": "Editor",
-                "bindings": {
-                  "cmd-k cmd-u": "editor::ConvertToUpperCase",
-                  "cmd-k cmd-l": "editor::ConvertToLowerCase",
-                  "cmd-[": "pane::GoBack",
-                }
-              },
-            ]
-            "#,
-            KeybindUpdateOperation::Remove {
-                target: KeybindUpdateTarget {
-                    context: Some("Editor"),
-                    keystrokes: &parse_keystrokes("cmd-k cmd-l"),
-                    action_name: "editor::ConvertToLowerCase",
-                    action_arguments: None,
-                },
-                target_keybind_source: KeybindSource::User,
-            },
-            r#"
-            [
-              {
-                "context": "Editor",
-                "bindings": {
-                  "cmd-k cmd-u": "editor::ConvertToUpperCase",
-                  "cmd-[": "pane::GoBack",
-                }
-              },
-            ]
-            "#,
-        );
-    }
 }
--- a/crates/settings/src/settings_json.rs
+++ b/crates/settings/src/settings_json.rs
@@ -190,7 +190,6 @@ fn replace_value_in_json_text(
                }
            }

-            let mut removed_comma = false;
            // Look backward for a preceding comma first
            let preceding_text = text.get(0..removal_start).unwrap_or("");
            if let Some(comma_pos) = preceding_text.rfind(',') {
@@ -198,12 +197,10 @@ fn replace_value_in_json_text(
                let between_comma_and_key = text.get(comma_pos + 1..removal_start).unwrap_or("");
                if between_comma_and_key.trim().is_empty() {
                    removal_start = comma_pos;
-                    removed_comma = true;
                }
            }
-            if let Some(remaining_text) = text.get(existing_value_range.end..)
-                && !removed_comma
-            {
+
+            if let Some(remaining_text) = text.get(existing_value_range.end..) {
                let mut chars = remaining_text.char_indices();
                while let Some((offset, ch)) = chars.next() {
                    if ch == ',' {
--- a/crates/settings_ui/Cargo.toml
+++ b/crates/settings_ui/Cargo.toml
@@ -23,7 +23,6 @@ feature_flags.workspace = true
 fs.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
-itertools.workspace = true
 language.workspace = true
 log.workspace = true
 menu.workspace = true
@@ -36,7 +35,6 @@ serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 telemetry.workspace = true
-tempfile.workspace = true
 theme.workspace = true
 tree-sitter-json.workspace = true
 tree-sitter-rust.workspace = true
--- a/crates/settings_ui/src/keybindings.rs
+++ b/crates/settings_ui/src/keybindings.rs
--- a/crates/settings_ui/src/ui_components/table.rs
+++ b/crates/settings_ui/src/ui_components/table.rs
@@ -2,24 +2,19 @@ use std::{ops::Range, rc::Rc, time::Duration};

 use editor::{EditorSettings, ShowScrollbar, scroll::ScrollbarAutoHide};
 use gpui::{
-    AbsoluteLength, AppContext, Axis, Context, DefiniteLength, DragMoveEvent, Entity, FocusHandle,
-    Length, ListHorizontalSizingBehavior, ListSizingBehavior, MouseButton, Point, Stateful, Task,
-    UniformListScrollHandle, WeakEntity, transparent_black, uniform_list,
+    AppContext, Axis, Context, Entity, FocusHandle, Length, ListHorizontalSizingBehavior,
+    ListSizingBehavior, MouseButton, Point, Task, UniformListScrollHandle, WeakEntity,
+    transparent_black, uniform_list,
 };
-
-use itertools::intersperse_with;
 use settings::Settings as _;
 use ui::{
    ActiveTheme as _, AnyElement, App, Button, ButtonCommon as _, ButtonStyle, Color, Component,
    ComponentScope, Div, ElementId, FixedWidth as _, FluentBuilder as _, Indicator,
-    InteractiveElement, IntoElement, ParentElement, Pixels, RegisterComponent, RenderOnce,
-    Scrollbar, ScrollbarState, StatefulInteractiveElement, Styled, StyledExt as _,
+    InteractiveElement as _, IntoElement, ParentElement, Pixels, RegisterComponent, RenderOnce,
+    Scrollbar, ScrollbarState, StatefulInteractiveElement as _, Styled, StyledExt as _,
    StyledTypography, Window, div, example_group_with_title, h_flex, px, single_example, v_flex,
 };

-#[derive(Debug)]
-struct DraggedColumn(usize);
-
 struct UniformListData<const COLS: usize> {
    render_item_fn: Box<dyn Fn(Range<usize>, &mut Window, &mut App) -> Vec<[AnyElement; COLS]>>,
    element_id: ElementId,
@@ -45,10 +40,6 @@ impl<const COLS: usize> TableContents<COLS> {
            TableContents::UniformList(data) => data.row_count,
        }
    }
-
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
 }

 pub struct TableInteractionState {
@@ -196,87 +187,6 @@ impl TableInteractionState {
        }
    }

-    fn render_resize_handles<const COLS: usize>(
-        &self,
-        column_widths: &[Length; COLS],
-        resizable_columns: &[ResizeBehavior; COLS],
-        initial_sizes: [DefiniteLength; COLS],
-        columns: Option<Entity<ColumnWidths<COLS>>>,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> AnyElement {
-        let spacers = column_widths
-            .iter()
-            .map(|width| base_cell_style(Some(*width)).into_any_element());
-
-        let mut column_ix = 0;
-        let resizable_columns_slice = *resizable_columns;
-        let mut resizable_columns = resizable_columns.into_iter();
-        let dividers = intersperse_with(spacers, || {
-            window.with_id(column_ix, |window| {
-                let mut resize_divider = div()
-                    // This is required because this is evaluated at a different time than the use_state call above
-                    .id(column_ix)
-                    .relative()
-                    .top_0()
-                    .w_0p5()
-                    .h_full()
-                    .bg(cx.theme().colors().border.opacity(0.5));
-
-                let mut resize_handle = div()
-                    .id("column-resize-handle")
-                    .absolute()
-                    .left_neg_0p5()
-                    .w(px(5.0))
-                    .h_full();
-
-                if resizable_columns
-                    .next()
-                    .is_some_and(ResizeBehavior::is_resizable)
-                {
-                    let hovered = window.use_state(cx, |_window, _cx| false);
-                    resize_divider = resize_divider.when(*hovered.read(cx), |div| {
-                        div.bg(cx.theme().colors().border_focused)
-                    });
-                    resize_handle = resize_handle
-                        .on_hover(move |&was_hovered, _, cx| hovered.write(cx, was_hovered))
-                        .cursor_col_resize()
-                        .when_some(columns.clone(), |this, columns| {
-                            this.on_click(move |event, window, cx| {
-                                if event.down.click_count >= 2 {
-                                    columns.update(cx, |columns, _| {
-                                        columns.on_double_click(
-                                            column_ix,
-                                            &initial_sizes,
-                                            &resizable_columns_slice,
-                                            window,
-                                        );
-                                    })
-                                }
-
-                                cx.stop_propagation();
-                            })
-                        })
-                        .on_drag(DraggedColumn(column_ix), |_, _offset, _window, cx| {
-                            cx.new(|_cx| gpui::Empty)
-                        })
-                }
-
-                column_ix += 1;
-                resize_divider.child(resize_handle).into_any_element()
-            })
-        });
-
-        div()
-            .id("resize-handles")
-            .h_flex()
-            .absolute()
-            .w_full()
-            .inset_0()
-            .children(dividers)
-            .into_any_element()
-    }
-
    fn render_vertical_scrollbar_track(
        this: &Entity<Self>,
        parent: Div,
@@ -455,242 +365,6 @@ impl TableInteractionState {
    }
 }

-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum ResizeBehavior {
-    None,
-    Resizable,
-    MinSize(f32),
-}
-
-impl ResizeBehavior {
-    pub fn is_resizable(&self) -> bool {
-        *self != ResizeBehavior::None
-    }
-
-    pub fn min_size(&self) -> Option<f32> {
-        match self {
-            ResizeBehavior::None => None,
-            ResizeBehavior::Resizable => Some(0.05),
-            ResizeBehavior::MinSize(min_size) => Some(*min_size),
-        }
-    }
-}
-
-pub struct ColumnWidths<const COLS: usize> {
-    widths: [DefiniteLength; COLS],
-    cached_bounds_width: Pixels,
-    initialized: bool,
-}
-
-impl<const COLS: usize> ColumnWidths<COLS> {
-    pub fn new(_: &mut App) -> Self {
-        Self {
-            widths: [DefiniteLength::default(); COLS],
-            cached_bounds_width: Default::default(),
-            initialized: false,
-        }
-    }
-
-    fn get_fraction(length: &DefiniteLength, bounds_width: Pixels, rem_size: Pixels) -> f32 {
-        match length {
-            DefiniteLength::Absolute(AbsoluteLength::Pixels(pixels)) => *pixels / bounds_width,
-            DefiniteLength::Absolute(AbsoluteLength::Rems(rems_width)) => {
-                rems_width.to_pixels(rem_size) / bounds_width
-            }
-            DefiniteLength::Fraction(fraction) => *fraction,
-        }
-    }
-
-    fn on_double_click(
-        &mut self,
-        double_click_position: usize,
-        initial_sizes: &[DefiniteLength; COLS],
-        resize_behavior: &[ResizeBehavior; COLS],
-        window: &mut Window,
-    ) {
-        let bounds_width = self.cached_bounds_width;
-        let rem_size = window.rem_size();
-        let initial_sizes =
-            initial_sizes.map(|length| Self::get_fraction(&length, bounds_width, rem_size));
-        let mut widths = self
-            .widths
-            .map(|length| Self::get_fraction(&length, bounds_width, rem_size));
-
-        let diff = initial_sizes[double_click_position] - widths[double_click_position];
-
-        if diff > 0.0 {
-            let diff_remaining = self.propagate_resize_diff_right(
-                diff,
-                double_click_position,
-                &mut widths,
-                resize_behavior,
-            );
-
-            if diff_remaining > 0.0 && double_click_position > 0 {
-                self.propagate_resize_diff_left(
-                    -diff_remaining,
-                    double_click_position - 1,
-                    &mut widths,
-                    resize_behavior,
-                );
-            }
-        } else if double_click_position > 0 {
-            let diff_remaining = self.propagate_resize_diff_left(
-                diff,
-                double_click_position,
-                &mut widths,
-                resize_behavior,
-            );
-
-            if diff_remaining < 0.0 {
-                self.propagate_resize_diff_right(
-                    -diff_remaining,
-                    double_click_position,
-                    &mut widths,
-                    resize_behavior,
-                );
-            }
-        }
-        self.widths = widths.map(DefiniteLength::Fraction);
-    }
-
-    fn on_drag_move(
-        &mut self,
-        drag_event: &DragMoveEvent<DraggedColumn>,
-        resize_behavior: &[ResizeBehavior; COLS],
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let drag_position = drag_event.event.position;
-        let bounds = drag_event.bounds;
-
-        let mut col_position = 0.0;
-        let rem_size = window.rem_size();
-        let bounds_width = bounds.right() - bounds.left();
-        let col_idx = drag_event.drag(cx).0;
-
-        let mut widths = self
-            .widths
-            .map(|length| Self::get_fraction(&length, bounds_width, rem_size));
-
-        for length in widths[0..=col_idx].iter() {
-            col_position += length;
-        }
-
-        let mut total_length_ratio = col_position;
-        for length in widths[col_idx + 1..].iter() {
-            total_length_ratio += length;
-        }
-
-        let drag_fraction = (drag_position.x - bounds.left()) / bounds_width;
-        let drag_fraction = drag_fraction * total_length_ratio;
-        let diff = drag_fraction - col_position;
-
-        let is_dragging_right = diff > 0.0;
-
-        if is_dragging_right {
-            self.propagate_resize_diff_right(diff, col_idx, &mut widths, resize_behavior);
-        } else {
-            // Resize behavior should be improved in the future by also seeking to the right column when there's not enough space
-            self.propagate_resize_diff_left(diff, col_idx, &mut widths, resize_behavior);
-        }
-        self.widths = widths.map(DefiniteLength::Fraction);
-    }
-
-    fn propagate_resize_diff_right(
-        &self,
-        diff: f32,
-        col_idx: usize,
-        widths: &mut [f32; COLS],
-        resize_behavior: &[ResizeBehavior; COLS],
-    ) -> f32 {
-        let mut diff_remaining = diff;
-        let mut curr_column = col_idx + 1;
-
-        while diff_remaining > 0.0 && curr_column < COLS {
-            let Some(min_size) = resize_behavior[curr_column - 1].min_size() else {
-                curr_column += 1;
-                continue;
-            };
-
-            let mut curr_width = widths[curr_column] - diff_remaining;
-
-            diff_remaining = 0.0;
-            if min_size > curr_width {
-                diff_remaining += min_size - curr_width;
-                curr_width = min_size;
-            }
-            widths[curr_column] = curr_width;
-            curr_column += 1;
-        }
-
-        widths[col_idx] = widths[col_idx] + (diff - diff_remaining);
-        return diff_remaining;
-    }
-
-    fn propagate_resize_diff_left(
-        &mut self,
-        diff: f32,
-        mut curr_column: usize,
-        widths: &mut [f32; COLS],
-        resize_behavior: &[ResizeBehavior; COLS],
-    ) -> f32 {
-        let mut diff_remaining = diff;
-        let col_idx = curr_column;
-        while diff_remaining < 0.0 {
-            let Some(min_size) = resize_behavior[curr_column].min_size() else {
-                if curr_column == 0 {
-                    break;
-                }
-                curr_column -= 1;
-                continue;
-            };
-
-            let mut curr_width = widths[curr_column] + diff_remaining;
-
-            diff_remaining = 0.0;
-            if curr_width < min_size {
-                diff_remaining = curr_width - min_size;
-                curr_width = min_size
-            }
-
-            widths[curr_column] = curr_width;
-            if curr_column == 0 {
-                break;
-            }
-            curr_column -= 1;
-        }
-        widths[col_idx + 1] = widths[col_idx + 1] - (diff - diff_remaining);
-
-        return diff_remaining;
-    }
-}
-
-pub struct TableWidths<const COLS: usize> {
-    initial: [DefiniteLength; COLS],
-    current: Option<Entity<ColumnWidths<COLS>>>,
-    resizable: [ResizeBehavior; COLS],
-}
-
-impl<const COLS: usize> TableWidths<COLS> {
-    pub fn new(widths: [impl Into<DefiniteLength>; COLS]) -> Self {
-        let widths = widths.map(Into::into);
-
-        TableWidths {
-            initial: widths,
-            current: None,
-            resizable: [ResizeBehavior::None; COLS],
-        }
-    }
-
-    fn lengths(&self, cx: &App) -> [Length; COLS] {
-        self.current
-            .as_ref()
-            .map(|entity| entity.read(cx).widths.map(Length::Definite))
-            .unwrap_or(self.initial.map(Length::Definite))
-    }
-}
-
 /// A table component
 #[derive(RegisterComponent, IntoElement)]
 pub struct Table<const COLS: usize = 3> {
@@ -699,23 +373,21 @@ pub struct Table<const COLS: usize = 3> {
    headers: Option<[AnyElement; COLS]>,
    rows: TableContents<COLS>,
    interaction_state: Option<WeakEntity<TableInteractionState>>,
-    col_widths: Option<TableWidths<COLS>>,
-    map_row: Option<Rc<dyn Fn((usize, Stateful<Div>), &mut Window, &mut App) -> AnyElement>>,
-    empty_table_callback: Option<Rc<dyn Fn(&mut Window, &mut App) -> AnyElement>>,
+    column_widths: Option<[Length; COLS]>,
+    map_row: Option<Rc<dyn Fn((usize, Div), &mut Window, &mut App) -> AnyElement>>,
 }

 impl<const COLS: usize> Table<COLS> {
    /// number of headers provided.
    pub fn new() -> Self {
-        Self {
+        Table {
            striped: false,
            width: None,
            headers: None,
            rows: TableContents::Vec(Vec::new()),
            interaction_state: None,
+            column_widths: None,
            map_row: None,
-            empty_table_callback: None,
-            col_widths: None,
        }
    }

@@ -776,68 +448,32 @@ impl<const COLS: usize> Table<COLS> {
        self
    }

-    pub fn column_widths(mut self, widths: [impl Into<DefiniteLength>; COLS]) -> Self {
-        if self.col_widths.is_none() {
-            self.col_widths = Some(TableWidths::new(widths));
-        }
-        self
-    }
-
-    pub fn resizable_columns(
-        mut self,
-        resizable: [ResizeBehavior; COLS],
-        column_widths: &Entity<ColumnWidths<COLS>>,
-        cx: &mut App,
-    ) -> Self {
-        if let Some(table_widths) = self.col_widths.as_mut() {
-            table_widths.resizable = resizable;
-            let column_widths = table_widths
-                .current
-                .get_or_insert_with(|| column_widths.clone());
-
-            column_widths.update(cx, |widths, _| {
-                if !widths.initialized {
-                    widths.initialized = true;
-                    widths.widths = table_widths.initial;
-                }
-            })
-        }
+    pub fn column_widths(mut self, widths: [impl Into<Length>; COLS]) -> Self {
+        self.column_widths = Some(widths.map(Into::into));
        self
    }

    pub fn map_row(
        mut self,
-        callback: impl Fn((usize, Stateful<Div>), &mut Window, &mut App) -> AnyElement + 'static,
+        callback: impl Fn((usize, Div), &mut Window, &mut App) -> AnyElement + 'static,
    ) -> Self {
        self.map_row = Some(Rc::new(callback));
        self
    }
-
-    /// Provide a callback that is invoked when the table is rendered without any rows
-    pub fn empty_table_callback(
-        mut self,
-        callback: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
-    ) -> Self {
-        self.empty_table_callback = Some(Rc::new(callback));
-        self
-    }
 }

-fn base_cell_style(width: Option<Length>) -> Div {
+fn base_cell_style(width: Option<Length>, cx: &App) -> Div {
    div()
        .px_1p5()
        .when_some(width, |this, width| this.w(width))
        .when(width.is_none(), |this| this.flex_1())
        .justify_start()
+        .text_ui(cx)
        .whitespace_nowrap()
        .text_ellipsis()
        .overflow_hidden()
 }

-fn base_cell_style_text(width: Option<Length>, cx: &App) -> Div {
-    base_cell_style(width).text_ui(cx)
-}
-
 pub fn render_row<const COLS: usize>(
    row_index: usize,
    items: [impl IntoElement; COLS],
@@ -856,33 +492,33 @@ pub fn render_row<const COLS: usize>(
        .column_widths
        .map_or([None; COLS], |widths| widths.map(Some));

-    let mut row = h_flex()
-        .h_full()
-        .id(("table_row", row_index))
-        .w_full()
-        .justify_between()
-        .when_some(bg, |row, bg| row.bg(bg))
-        .when(!is_striped, |row| {
-            row.border_b_1()
-                .border_color(transparent_black())
-                .when(!is_last, |row| row.border_color(cx.theme().colors().border))
-        });
-
-    row = row.children(
-        items
-            .map(IntoElement::into_any_element)
-            .into_iter()
-            .zip(column_widths)
-            .map(|(cell, width)| base_cell_style_text(width, cx).px_1p5().py_1().child(cell)),
+    let row = div().w_full().child(
+        h_flex()
+            .id("table_row")
+            .w_full()
+            .justify_between()
+            .px_1p5()
+            .py_1()
+            .when_some(bg, |row, bg| row.bg(bg))
+            .when(!is_striped, |row| {
+                row.border_b_1()
+                    .border_color(transparent_black())
+                    .when(!is_last, |row| row.border_color(cx.theme().colors().border))
+            })
+            .children(
+                items
+                    .map(IntoElement::into_any_element)
+                    .into_iter()
+                    .zip(column_widths)
+                    .map(|(cell, width)| base_cell_style(width, cx).child(cell)),
+            ),
    );

-    let row = if let Some(map_row) = table_context.map_row {
+    if let Some(map_row) = table_context.map_row {
        map_row((row_index, row), window, cx)
    } else {
        row.into_any_element()
-    };
-
-    div().h_full().w_full().child(row).into_any_element()
+    }
 }

 pub fn render_header<const COLS: usize>(
@@ -906,7 +542,7 @@ pub fn render_header<const COLS: usize>(
            headers
                .into_iter()
                .zip(column_widths)
-                .map(|(h, width)| base_cell_style_text(width, cx).child(h)),
+                .map(|(h, width)| base_cell_style(width, cx).child(h)),
        )
 }

@@ -915,15 +551,15 @@ pub struct TableRenderContext<const COLS: usize> {
    pub striped: bool,
    pub total_row_count: usize,
    pub column_widths: Option<[Length; COLS]>,
-    pub map_row: Option<Rc<dyn Fn((usize, Stateful<Div>), &mut Window, &mut App) -> AnyElement>>,
+    pub map_row: Option<Rc<dyn Fn((usize, Div), &mut Window, &mut App) -> AnyElement>>,
 }

 impl<const COLS: usize> TableRenderContext<COLS> {
-    fn new(table: &Table<COLS>, cx: &App) -> Self {
+    fn new(table: &Table<COLS>) -> Self {
        Self {
            striped: table.striped,
            total_row_count: table.rows.len(),
-            column_widths: table.col_widths.as_ref().map(|widths| widths.lengths(cx)),
+            column_widths: table.column_widths,
            map_row: table.map_row.clone(),
        }
    }
@@ -931,13 +567,8 @@ impl<const COLS: usize> TableRenderContext<COLS> {

 impl<const COLS: usize> RenderOnce for Table<COLS> {
    fn render(mut self, window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let table_context = TableRenderContext::new(&self, cx);
+        let table_context = TableRenderContext::new(&self);
        let interaction_state = self.interaction_state.and_then(|state| state.upgrade());
-        let current_widths = self
-            .col_widths
-            .as_ref()
-            .and_then(|widths| Some((widths.current.as_ref()?, widths.resizable)))
-            .map(|(curr, resize_behavior)| (curr.downgrade(), resize_behavior));

        let scroll_track_size = px(16.);
        let h_scroll_offset = if interaction_state
@@ -951,7 +582,6 @@ impl<const COLS: usize> RenderOnce for Table<COLS> {
        };

        let width = self.width;
-        let no_rows_rendered = self.rows.is_empty();

        let table = div()
            .when_some(width, |this, width| this.w(width))
@@ -960,31 +590,6 @@ impl<const COLS: usize> RenderOnce for Table<COLS> {
            .when_some(self.headers.take(), |this, headers| {
                this.child(render_header(headers, table_context.clone(), cx))
            })
-            .when_some(current_widths, {
-                |this, (widths, resize_behavior)| {
-                    this.on_drag_move::<DraggedColumn>({
-                        let widths = widths.clone();
-                        move |e, window, cx| {
-                            widths
-                                .update(cx, |widths, cx| {
-                                    widths.on_drag_move(e, &resize_behavior, window, cx);
-                                })
-                                .ok();
-                        }
-                    })
-                    .on_children_prepainted(move |bounds, _, cx| {
-                        widths
-                            .update(cx, |widths, _| {
-                                // This works because all children x axis bounds are the same
-                                widths.cached_bounds_width = bounds[0].right() - bounds[0].left();
-                            })
-                            .ok();
-                    })
-                }
-            })
-            .on_drop::<DraggedColumn>(|_, _, _| {
-                // Finish the resize operation
-            })
            .child(
                div()
                    .flex_grow()
@@ -1039,25 +644,6 @@ impl<const COLS: usize> RenderOnce for Table<COLS> {
                            ),
                        ),
                    })
-                    .when_some(
-                        self.col_widths.as_ref().zip(interaction_state.as_ref()),
-                        |parent, (table_widths, state)| {
-                            parent.child(state.update(cx, |state, cx| {
-                                let resizable_columns = table_widths.resizable;
-                                let column_widths = table_widths.lengths(cx);
-                                let columns = table_widths.current.clone();
-                                let initial_sizes = table_widths.initial;
-                                state.render_resize_handles(
-                                    &column_widths,
-                                    &resizable_columns,
-                                    initial_sizes,
-                                    columns,
-                                    window,
-                                    cx,
-                                )
-                            }))
-                        },
-                    )
                    .when_some(interaction_state.as_ref(), |this, interaction_state| {
                        this.map(|this| {
                            TableInteractionState::render_vertical_scrollbar_track(
@@ -1076,21 +662,6 @@ impl<const COLS: usize> RenderOnce for Table<COLS> {
                        })
                    }),
            )
-            .when_some(
-                no_rows_rendered
-                    .then_some(self.empty_table_callback)
-                    .flatten(),
-                |this, callback| {
-                    this.child(
-                        h_flex()
-                            .size_full()
-                            .p_3()
-                            .items_start()
-                            .justify_center()
-                            .child(callback(window, cx)),
-                    )
-                },
-            )
            .when_some(
                width.and(interaction_state.as_ref()),
                |this, interaction_state| {
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -320,39 +320,7 @@ impl History {
            last_edit_at: now,
            suppress_grouping: false,
        });
-    }
-
-    /// Differs from `push_transaction` in that it does not clear the redo
-    /// stack. Intended to be used to create a parent transaction to merge
-    /// potential child transactions into.
-    ///
-    /// The caller is responsible for removing it from the undo history using
-    /// `forget_transaction` if no edits are merged into it. Otherwise, if edits
-    /// are merged into this transaction, the caller is responsible for ensuring
-    /// the redo stack is cleared. The easiest way to ensure the redo stack is
-    /// cleared is to create transactions with the usual `start_transaction` and
-    /// `end_transaction` methods and merging the resulting transactions into
-    /// the transaction created by this method
-    fn push_empty_transaction(
-        &mut self,
-        start: clock::Global,
-        now: Instant,
-        clock: &mut clock::Lamport,
-    ) -> TransactionId {
-        assert_eq!(self.transaction_depth, 0);
-        let id = clock.tick();
-        let transaction = Transaction {
-            id,
-            start,
-            edit_ids: Vec::new(),
-        };
-        self.undo_stack.push(HistoryEntry {
-            transaction,
-            first_edit_at: now,
-            last_edit_at: now,
-            suppress_grouping: false,
-        });
-        id
+        self.redo_stack.clear();
    }

    fn push_undo(&mut self, op_id: clock::Lamport) {
@@ -1527,24 +1495,6 @@ impl Buffer {
        self.history.push_transaction(transaction, now);
    }

-    /// Differs from `push_transaction` in that it does not clear the redo stack.
-    /// The caller responsible for
-    /// Differs from `push_transaction` in that it does not clear the redo
-    /// stack. Intended to be used to create a parent transaction to merge
-    /// potential child transactions into.
-    ///
-    /// The caller is responsible for removing it from the undo history using
-    /// `forget_transaction` if no edits are merged into it. Otherwise, if edits
-    /// are merged into this transaction, the caller is responsible for ensuring
-    /// the redo stack is cleared. The easiest way to ensure the redo stack is
-    /// cleared is to create transactions with the usual `start_transaction` and
-    /// `end_transaction` methods and merging the resulting transactions into
-    /// the transaction created by this method
-    pub fn push_empty_transaction(&mut self, now: Instant) -> TransactionId {
-        self.history
-            .push_empty_transaction(self.version.clone(), now, &mut self.lamport_clock)
-    }
-
    pub fn edited_ranges_for_transaction_id<D>(
        &self,
        transaction_id: TransactionId,
--- a/crates/theme/src/default_colors.rs
+++ b/crates/theme/src/default_colors.rs
@@ -83,8 +83,6 @@ impl ThemeColors {
            panel_indent_guide: neutral().light_alpha().step_5(),
            panel_indent_guide_hover: neutral().light_alpha().step_6(),
            panel_indent_guide_active: neutral().light_alpha().step_6(),
-            panel_overlay_background: neutral().light().step_2(),
-            panel_overlay_hover: neutral().light_alpha().step_4(),
            pane_focused_border: blue().light().step_5(),
            pane_group_border: neutral().light().step_6(),
            scrollbar_thumb_background: neutral().light_alpha().step_3(),
@@ -208,8 +206,6 @@ impl ThemeColors {
            panel_indent_guide: neutral().dark_alpha().step_4(),
            panel_indent_guide_hover: neutral().dark_alpha().step_6(),
            panel_indent_guide_active: neutral().dark_alpha().step_6(),
-            panel_overlay_background: neutral().dark().step_2(),
-            panel_overlay_hover: neutral().dark_alpha().step_4(),
            pane_focused_border: blue().dark().step_5(),
            pane_group_border: neutral().dark().step_6(),
            scrollbar_thumb_background: neutral().dark_alpha().step_3(),
--- a/crates/theme/src/fallback_themes.rs
+++ b/crates/theme/src/fallback_themes.rs
@@ -59,7 +59,6 @@ pub(crate) fn zed_default_dark() -> Theme {
    let bg = hsla(215. / 360., 12. / 100., 15. / 100., 1.);
    let editor = hsla(220. / 360., 12. / 100., 18. / 100., 1.);
    let elevated_surface = hsla(225. / 360., 12. / 100., 17. / 100., 1.);
-    let hover = hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0);

    let blue = hsla(207.8 / 360., 81. / 100., 66. / 100., 1.0);
    let gray = hsla(218.8 / 360., 10. / 100., 40. / 100., 1.0);
@@ -109,14 +108,14 @@ pub(crate) fn zed_default_dark() -> Theme {
                surface_background: bg,
                background: bg,
                element_background: hsla(223.0 / 360., 13. / 100., 21. / 100., 1.0),
-                element_hover: hover,
+                element_hover: hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0),
                element_active: hsla(220.0 / 360., 11.8 / 100., 20.0 / 100., 1.0),
                element_selected: hsla(224.0 / 360., 11.3 / 100., 26.1 / 100., 1.0),
                element_disabled: SystemColors::default().transparent,
                element_selection_background: player.local().selection.alpha(0.25),
                drop_target_background: hsla(220.0 / 360., 8.3 / 100., 21.4 / 100., 1.0),
                ghost_element_background: SystemColors::default().transparent,
-                ghost_element_hover: hover,
+                ghost_element_hover: hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0),
                ghost_element_active: hsla(220.0 / 360., 11.8 / 100., 20.0 / 100., 1.0),
                ghost_element_selected: hsla(224.0 / 360., 11.3 / 100., 26.1 / 100., 1.0),
                ghost_element_disabled: SystemColors::default().transparent,
@@ -203,12 +202,10 @@ pub(crate) fn zed_default_dark() -> Theme {
                panel_indent_guide: hsla(228. / 360., 8. / 100., 25. / 100., 1.),
                panel_indent_guide_hover: hsla(225. / 360., 13. / 100., 12. / 100., 1.),
                panel_indent_guide_active: hsla(225. / 360., 13. / 100., 12. / 100., 1.),
-                panel_overlay_background: bg,
-                panel_overlay_hover: hover,
                pane_focused_border: blue,
                pane_group_border: hsla(225. / 360., 13. / 100., 12. / 100., 1.),
                scrollbar_thumb_background: gpui::transparent_black(),
-                scrollbar_thumb_hover_background: hover,
+                scrollbar_thumb_hover_background: hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0),
                scrollbar_thumb_active_background: hsla(
                    225.0 / 360.,
                    11.8 / 100.,
--- a/crates/theme/src/schema.rs
+++ b/crates/theme/src/schema.rs
@@ -352,12 +352,6 @@ pub struct ThemeColorsContent {
    #[serde(rename = "panel.indent_guide_active")]
    pub panel_indent_guide_active: Option<String>,

-    #[serde(rename = "panel.overlay_background")]
-    pub panel_overlay_background: Option<String>,
-
-    #[serde(rename = "panel.overlay_hover")]
-    pub panel_overlay_hover: Option<String>,
-
    #[serde(rename = "pane.focused_border")]
    pub pane_focused_border: Option<String>,

@@ -681,14 +675,6 @@ impl ThemeColorsContent {
            .scrollbar_thumb_border
            .as_ref()
            .and_then(|color| try_parse_color(color).ok());
-        let element_hover = self
-            .element_hover
-            .as_ref()
-            .and_then(|color| try_parse_color(color).ok());
-        let panel_background = self
-            .panel_background
-            .as_ref()
-            .and_then(|color| try_parse_color(color).ok());
        ThemeColorsRefinement {
            border,
            border_variant: self
@@ -727,7 +713,10 @@ impl ThemeColorsContent {
                .element_background
                .as_ref()
                .and_then(|color| try_parse_color(color).ok()),
-            element_hover,
+            element_hover: self
+                .element_hover
+                .as_ref()
+                .and_then(|color| try_parse_color(color).ok()),
            element_active: self
                .element_active
                .as_ref()
@@ -844,7 +833,10 @@ impl ThemeColorsContent {
                .search_match_background
                .as_ref()
                .and_then(|color| try_parse_color(color).ok()),
-            panel_background,
+            panel_background: self
+                .panel_background
+                .as_ref()
+                .and_then(|color| try_parse_color(color).ok()),
            panel_focused_border: self
                .panel_focused_border
                .as_ref()
@@ -861,16 +853,6 @@ impl ThemeColorsContent {
                .panel_indent_guide_active
                .as_ref()
                .and_then(|color| try_parse_color(color).ok()),
-            panel_overlay_background: self
-                .panel_overlay_background
-                .as_ref()
-                .and_then(|color| try_parse_color(color).ok())
-                .or(panel_background),
-            panel_overlay_hover: self
-                .panel_overlay_hover
-                .as_ref()
-                .and_then(|color| try_parse_color(color).ok())
-                .or(element_hover),
            pane_focused_border: self
                .pane_focused_border
                .as_ref()
--- a/crates/theme/src/styles/colors.rs
+++ b/crates/theme/src/styles/colors.rs
@@ -131,12 +131,6 @@ pub struct ThemeColors {
    pub panel_indent_guide: Hsla,
    pub panel_indent_guide_hover: Hsla,
    pub panel_indent_guide_active: Hsla,
-
-    /// The color of the overlay surface on top of panel.
-    pub panel_overlay_background: Hsla,
-    /// The color of the overlay surface on top of panel when hovered over.
-    pub panel_overlay_hover: Hsla,
-
    pub pane_focused_border: Hsla,
    pub pane_group_border: Hsla,
    /// The color of the scrollbar thumb.
@@ -332,8 +326,6 @@ pub enum ThemeColorField {
    PanelIndentGuide,
    PanelIndentGuideHover,
    PanelIndentGuideActive,
-    PanelOverlayBackground,
-    PanelOverlayHover,
    PaneFocusedBorder,
    PaneGroupBorder,
    ScrollbarThumbBackground,
@@ -446,8 +438,6 @@ impl ThemeColors {
            ThemeColorField::PanelIndentGuide => self.panel_indent_guide,
            ThemeColorField::PanelIndentGuideHover => self.panel_indent_guide_hover,
            ThemeColorField::PanelIndentGuideActive => self.panel_indent_guide_active,
-            ThemeColorField::PanelOverlayBackground => self.panel_overlay_background,
-            ThemeColorField::PanelOverlayHover => self.panel_overlay_hover,
            ThemeColorField::PaneFocusedBorder => self.pane_focused_border,
            ThemeColorField::PaneGroupBorder => self.pane_group_border,
            ThemeColorField::ScrollbarThumbBackground => self.scrollbar_thumb_background,
--- a/crates/ui/src/components/context_menu.rs
+++ b/crates/ui/src/components/context_menu.rs
@@ -972,10 +972,12 @@ impl ContextMenu {
                            .children(action.as_ref().and_then(|action| {
                                self.action_context
                                    .as_ref()
-                                    .and_then(|focus| {
+                                    .map(|focus| {
                                        KeyBinding::for_action_in(&**action, focus, window, cx)
                                    })
-                                    .or_else(|| KeyBinding::for_action(&**action, window, cx))
+                                    .unwrap_or_else(|| {
+                                        KeyBinding::for_action(&**action, window, cx)
+                                    })
                                    .map(|binding| {
                                        div().ml_4().child(binding.disabled(*disabled)).when(
                                            *disabled && documentation_aside.is_some(),
--- a/crates/workspace/src/pane_group.rs
+++ b/crates/workspace/src/pane_group.rs
@@ -943,8 +943,6 @@ mod element {
    pub struct PaneAxisElement {
        axis: Axis,
        basis: usize,
-        /// Equivalent to ColumnWidths (but in terms of flexes instead of percentages)
-        /// For example, flexes "1.33, 1, 1", instead of "40%, 30%, 30%"
        flexes: Arc<Mutex<Vec<f32>>>,
        bounding_boxes: Arc<Mutex<Vec<Option<Bounds<Pixels>>>>>,
        children: SmallVec<[AnyElement; 2]>,
@@ -1000,7 +998,6 @@ mod element {
            let mut flexes = flexes.lock();
            debug_assert!(flex_values_in_bounds(flexes.as_slice()));

-            // Math to convert a flex value to a pixel value
            let size = move |ix, flexes: &[f32]| {
                container_size.along(axis) * (flexes[ix] / flexes.len() as f32)
            };
@@ -1010,13 +1007,9 @@ mod element {
                return;
            }

-            // This is basically a "bucket" of pixel changes that need to be applied in response to this
-            // mouse event. Probably a small, fractional number like 0.5 or 1.5 pixels
            let mut proposed_current_pixel_change =
                (e.position - child_start).along(axis) - size(ix, flexes.as_slice());

-            // This takes a pixel change, and computes the flex changes that correspond to this pixel change
-            // as well as the next one, for some reason
            let flex_changes = |pixel_dx, target_ix, next: isize, flexes: &[f32]| {
                let flex_change = pixel_dx / container_size.along(axis);
                let current_target_flex = flexes[target_ix] + flex_change;
@@ -1024,9 +1017,6 @@ mod element {
                (current_target_flex, next_target_flex)
            };

-            // Generate the list of flex successors, from the current index.
-            // If you're dragging column 3 forward, out of 6 columns, then this code will produce [4, 5, 6]
-            // If you're dragging column 3 backward, out of 6 columns, then this code will produce [2, 1, 0]
            let mut successors = iter::from_fn({
                let forward = proposed_current_pixel_change > px(0.);
                let mut ix_offset = 0;
@@ -1044,7 +1034,6 @@ mod element {
                }
            });

-            // Now actually loop over these, and empty our bucket of pixel changes
            while proposed_current_pixel_change.abs() > px(0.) {
                let Some(current_ix) = successors.next() else {
                    break;
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition.workspace = true
 name = "zed"
-version = "0.196.5"
+version = "0.197.0"
 publish.workspace = true
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]
--- a/crates/zed/RELEASE_CHANNEL
+++ b/crates/zed/RELEASE_CHANNEL
@@ -1 +1 @@
-stable
+dev
--- a/docs/src/ai/configuration.md
+++ b/docs/src/ai/configuration.md
@@ -237,7 +237,7 @@ You can use Gemini models with the Zed agent by choosing it via the model dropdo

 The Google AI API key will be saved in your keychain.

-Zed will also use the `GOOGLE_AI_API_KEY` environment variable if it's defined.
+Zed will also use the `GEMINI_API_KEY` environment variable if it's defined. See [Using Gemini API keys](Using Gemini API keys) in the Gemini docs for more.

 #### Custom Models {#google-ai-custom-models}

--- a/docs/src/git.md
+++ b/docs/src/git.md
@@ -151,3 +151,17 @@ When viewing files with changes, Zed displays diff hunks that can be expanded or
 | {#action editor::ToggleSelectedDiffHunks} | {#kb editor::ToggleSelectedDiffHunks} |

 > Not all actions have default keybindings, but can be bound by [customizing your keymap](./key-bindings.md#user-keymaps).
+
+## Git CLI Configuration
+
+If you would like to also use Zed for your [git commit message editor](https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#_core_editor) when committing from the command line you can use `zed --wait`:
+
+```sh
+git config --global core.editor "zed --wait"
+```
+
+Or add the following to your shell environment (in `~/.zshrc`, `~/.bashrc`, etc):
+
+```sh
+export GIT_EDITOR="zed --wait"
+```
--- a/docs/src/linux.md
+++ b/docs/src/linux.md
@@ -148,7 +148,7 @@ On some systems the file `/etc/prime-discrete` can be used to enforce the use of

 On others, you may be able to the environment variable `DRI_PRIME=1` when running Zed to force the use of the discrete GPU.

-If you're using an AMD GPU and Zed crashes when selecting long lines, try setting the `ZED_PATH_SAMPLE_COUNT=0` environment variable. (See [#26143](https://github.com/zed-industries/zed/issues/26143))
+If you're using an AMD GPU and Zed crashes when selecting long lines, try setting the `ZED_SAMPLE_COUNT=0` environment variable. (See [#26143](https://github.com/zed-industries/zed/issues/26143))

 If you're using an AMD GPU, you might get a 'Broken Pipe' error. Try using the RADV or Mesa drivers. (See [#13880](https://github.com/zed-industries/zed/issues/13880))
Author	SHA1	Message	Date
Anthony	75794eb7c7	Add tooltips for edit icon and exact match toggle icon	2025-07-16 18:09:39 -04:00
Umesh Yadav	e23a4564cc	keymap_ui: Open Keymap editor from settings dropdown (#34576 ) @probably-neb I guess we should be opening the keymap editor from title bar and menu as well. I believe this got missed in this: #34568. Release Notes: - Open Keymap editor from settings from menu and title bar.	2025-07-16 17:30:08 -04:00
Peter Tripp	f82ef1f76f	agent: Support GEMINI_API_KEY environment variable (#34574 ) Google Gemini Docs now recommend usage of `GEMINI_API_KEY` and the legacy `GOOGLE_AI_API_KEY` variable is no longer supported in the modern SDKs. Zed will now accept either. Release Notes: - N/A	2025-07-16 20:55:54 +00:00
Richard Feldman	b4c2ae5196	Handle `upstream_http_error` completion responses (#34573 ) Addresses upstream errors such as: <img width="831" height="100" alt="Screenshot 2025-07-16 at 3 37 03 PM" src="https://github.com/user-attachments/assets/2aeb0257-6761-4148-b687-25fae93c68d8" /> These should now automatically retry like other upstream HTTP error codes. Release Notes: - N/A	2025-07-16 16:31:31 -04:00
Peter Tripp	0023773c68	docs: Add Zed as Git Editor example (#34572 ) Release Notes: - N/A	2025-07-16 19:57:02 +00:00
Anthony Eid	0bde929d54	Add keymap editor UI telemetry events (#34571 ) - Search queries - Keybinding update or removed - Copy action name - Copy context name cc @katie-z-geer Release Notes: - N/A Co-authored-by: Ben Kunkle <ben@zed.dev>	2025-07-16 19:50:53 +00:00
Joseph T. Lyons	6f60939d30	Bump Zed to v0.197 (#34569 ) Release Notes: -N/A	2025-07-16 18:48:50 +00:00