linux: add profling annotations & extend example

Fixed keymap for toggling right dock in linux (#14041 )
Release Notes: - N/A
2024-07-10 13:08:51 +02:00 · 2024-07-10 10:49:28 +02:00 · 2024-07-10 09:40:50 +02:00 · 2024-07-10 10:12:09 +03:00 · 2024-07-09 19:49:25 -04:00 · 2024-07-09 17:41:54 -04:00
125 changed files with 5909 additions and 6449 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,6 +1,13 @@
+.git
+.github
+**/.gitignore
+**/.gitkeep
+.gitattributes
+.mailmap
 **/target
 zed.xcworkspace
 .DS_Store
+compose.yml
 plugins/bin
 script/node_modules
 styles/node_modules
--- a/.github/ISSUE_TEMPLATE/1_bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/1_bug_report.yml
@@ -32,9 +32,10 @@ body:
      required: false
  - type: textarea
    attributes:
-      label: If applicable, attach your `~/Library/Logs/Zed/Zed.log` file to this issue.
+      label: If applicable, attach your Zed.log file to this issue.
      description: |
-        Drag Zed.log into the text input below.
+        macOS: `~/Library/Logs/Zed/Zed.log`
+        Linux: `~/.local/share/zed/logs/Zed.log` or $XDG_DATA_HOME
        If you only need the most recent lines, you can run the `zed: open log` command palette action to see the last 1000.
      value: |
        <details><summary>Zed.log</summary><pre>
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -2,7 +2,7 @@

 Release Notes:

- Added/Fixed/Improved ... ([#<public_issue_number_if_exists>](https://github.com/zed-industries/zed/issues/<public_issue_number_if_exists>)).
+- Added/Fixed/Improved ... ([#NNNNN](https://github.com/zed-industries/zed/issues/NNNNN)).

 Optionally, include screenshots / media showcasing your addition that can be included in the release notes.

--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+/.direnv
 .idea
 **/target
 **/cargo-target
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -341,9 +341,8 @@ dependencies = [

 [[package]]
 name = "ashpd"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd884d7c72877a94102c3715f3b1cd09ff4fac28221add3e57cfbe25c236d093"
+version = "0.9.0"
+source = "git+https://github.com/bilelmoussaoui/ashpd?rev=29f2e1a#29f2e1a6f4b0911f504658f5f4630c02e01b13f2"
 dependencies = [
 "async-fs 2.1.1",
 "async-net 2.0.0",
@@ -3933,6 +3932,7 @@ dependencies = [
 "serde_json",
 "serde_json_lenient",
 "settings",
+ "snippet_provider",
 "task",
 "theme",
 "toml 0.8.10",
@@ -4889,11 +4889,9 @@ dependencies = [
 "log",
 "media",
 "metal",
- "mio 1.0.0",
 "num_cpus",
 "objc",
 "oo7",
- "open",
 "parking",
 "parking_lot",
 "pathfinder_geometry",
@@ -5691,7 +5689,7 @@ dependencies = [
 "fnv",
 "lazy_static",
 "libc",
- "mio 0.8.11",
+ "mio",
 "rand 0.8.5",
 "serde",
 "tempfile",
@@ -5705,25 +5703,6 @@ version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6"

-[[package]]
-name = "is-docker"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
-dependencies = [
- "once_cell",
-]
-
-[[package]]
-name = "is-wsl"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
-dependencies = [
- "is-docker",
- "once_cell",
-]
-
 [[package]]
 name = "isahc"
 version = "1.7.2"
@@ -6640,19 +6619,6 @@ dependencies = [
 "windows-sys 0.48.0",
 ]

-[[package]]
-name = "mio"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4929e1f84c5e54c3ec6141cd5d8b5a5c055f031f80cf78f2072920173cb4d880"
-dependencies = [
- "hermit-abi 0.3.9",
- "libc",
- "log",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "miow"
 version = "0.6.0"
@@ -6891,7 +6857,7 @@ dependencies = [
 "kqueue",
 "libc",
 "log",
- "mio 0.8.11",
+ "mio",
 "walkdir",
 "windows-sys 0.48.0",
 ]
@@ -7225,17 +7191,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"

-[[package]]
-name = "open"
-version = "5.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "449f0ff855d85ddbf1edd5b646d65249ead3f5e422aaa86b7d2d0b049b103e32"
-dependencies = [
- "is-wsl",
- "libc",
- "pathdiff",
-]
-
 [[package]]
 name = "open_ai"
 version = "0.1.0"
@@ -7401,6 +7356,7 @@ dependencies = [
 "db",
 "editor",
 "file_icons",
+ "fuzzy",
 "gpui",
 "itertools 0.11.0",
 "language",
@@ -8086,6 +8042,7 @@ dependencies = [
 "similar",
 "smol",
 "snippet",
+ "snippet_provider",
 "task",
 "tempfile",
 "terminal",
@@ -8539,7 +8496,7 @@ dependencies = [
 "task",
 "terminal_view",
 "ui",
- "ui_text_field",
+ "ui_input",
 "util",
 "workspace",
 ]
@@ -9902,6 +9859,22 @@ dependencies = [
 "smallvec",
 ]

+[[package]]
+name = "snippet_provider"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "collections",
+ "fs",
+ "futures 0.3.28",
+ "gpui",
+ "parking_lot",
+ "serde",
+ "serde_json",
+ "snippet",
+ "util",
+]
+
 [[package]]
 name = "socket2"
 version = "0.4.9"
@@ -10282,6 +10255,7 @@ dependencies = [
 "story",
 "strum",
 "theme",
+ "title_bar",
 "ui",
 ]

@@ -11112,7 +11086,7 @@ dependencies = [
 "backtrace",
 "bytes 1.5.0",
 "libc",
- "mio 0.8.11",
+ "mio",
 "num_cpus",
 "parking_lot",
 "pin-project-lite",
@@ -11737,7 +11711,7 @@ dependencies = [
 ]

 [[package]]
-name = "ui_text_field"
+name = "ui_input"
 version = "0.1.0"
 dependencies = [
 "editor",
@@ -13682,6 +13656,7 @@ dependencies = [
 "settings",
 "simplelog",
 "smol",
+ "snippet_provider",
 "supermaven",
 "tab_switcher",
 "task",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -88,6 +88,7 @@ members = [
    "crates/semantic_version",
    "crates/settings",
    "crates/snippet",
+    "crates/snippet_provider",
    "crates/sqlez",
    "crates/sqlez_macros",
    "crates/story",
@@ -108,7 +109,7 @@ members = [
    "crates/time_format",
    "crates/title_bar",
    "crates/ui",
-    "crates/ui_text_field",
+    "crates/ui_input",
    "crates/util",
    "crates/vcs_menu",
    "crates/vim",
@@ -239,6 +240,7 @@ semantic_index = { path = "crates/semantic_index" }
 semantic_version = { path = "crates/semantic_version" }
 settings = { path = "crates/settings" }
 snippet = { path = "crates/snippet" }
+snippet_provider = { path = "crates/snippet_provider" }
 sqlez = { path = "crates/sqlez" }
 sqlez_macros = { path = "crates/sqlez_macros" }
 story = { path = "crates/story" }
@@ -259,7 +261,7 @@ theme_selector = { path = "crates/theme_selector" }
 time_format = { path = "crates/time_format" }
 title_bar = { path = "crates/title_bar" }
 ui = { path = "crates/ui" }
-ui_text_field = { path = "crates/ui_text_field" }
+ui_input = { path = "crates/ui_input" }
 util = { path = "crates/util" }
 vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
@@ -272,9 +274,9 @@ zed_actions = { path = "crates/zed_actions" }
 alacritty_terminal = "0.23"
 any_vec = "0.13"
 anyhow = "1.0.57"
-ashpd = "0.8.0"
+ashpd = { git = "https://github.com/bilelmoussaoui/ashpd", rev = "29f2e1a" }
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
-async-dispatcher = { version = "0.1"}
+async-dispatcher = { version = "0.1" }
 async-fs = "1.6"
 async-recursion = "1.0.0"
 async-tar = "0.4.2"
@@ -315,7 +317,9 @@ image = "0.25.1"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "1"
 # We explicitly disable http2 support in isahc.
-isahc = { version = "1.7.2", default-features = false, features = [ "text-decoding" ] }
+isahc = { version = "1.7.2", default-features = false, features = [
+    "text-decoding",
+] }
 itertools = "0.11.0"
 lazy_static = "1.4.0"
 libc = "0.2"
@@ -341,7 +345,9 @@ rand = "0.8.5"
 refineable = { path = "./crates/refineable" }
 regex = "1.5"
 repair_json = "0.1.0"
-runtimelib = { version="0.12", default-features = false, features = ["async-dispatcher-runtime"] }
+runtimelib = { version = "0.12", default-features = false, features = [
+    "async-dispatcher-runtime",
+] }
 rusqlite = { version = "0.29.0", features = ["blob", "array", "modern_sqlite"] }
 rust-embed = { version = "8.4", features = ["include-exclude"] }
 schemars = "0.8"
--- a/README.md
+++ b/README.md
@@ -4,42 +4,36 @@

 Welcome to Zed, a high-performance, multiplayer code editor from the creators of [Atom](https://github.com/atom/atom) and [Tree-sitter](https://github.com/tree-sitter/tree-sitter).

-## Installation
+--------

-You can [download](https://zed.dev/download) Zed today for macOS (v10.15+).
+### Installation

-Support for additional platforms is on our [roadmap](https://zed.dev/roadmap):

- Linux ([tracking issue](https://github.com/zed-industries/zed/issues/7015))
+<a href="https://repology.org/project/zed-editor/versions">
+    <img src="https://repology.org/badge/vertical-allrepos/zed-editor.svg?minversion=0.143.5" alt="Packaging status" align="right">
+</a>
+
+On macOS and Linux you can [download Zed directly](https://zed.dev/download) or [install Zed via your local package manager](https://zed.dev/docs/linux#installing-via-a-package-manager).
+
+Other platforms are not yet available:
+
 - Windows ([tracking issue](https://github.com/zed-industries/zed/issues/5394))
 - Web ([tracking issue](https://github.com/zed-industries/zed/issues/5396))

-For macOS users, you can also install Zed using [Homebrew](https://brew.sh/):
-
-```sh
-brew install --cask zed
-```
-
-Alternatively, to install the Preview release:
-
-```sh
-brew install --cask zed@preview
-```
-
-## Developing Zed
+### Developing Zed

 - [Building Zed for macOS](./docs/src/development/macos.md)
 - [Building Zed for Linux](./docs/src/development/linux.md)
 - [Building Zed for Windows](./docs/src/development/windows.md)
 - [Running Collaboration Locally](./docs/src/development/local-collaboration.md)

-## Contributing
+### Contributing

 See [CONTRIBUTING.md](./CONTRIBUTING.md) for ways you can contribute to Zed.

 Also... we're hiring! Check out our [jobs](https://zed.dev/jobs) page for open roles.

-## Licensing
+### Licensing

 License information for third party dependencies must be correctly provided for CI to pass.

--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -3,10 +3,14 @@
  {
    "bindings": {
      "up": "menu::SelectPrev",
+      "shift-tab": "menu::SelectPrev",
+      "home": "menu::SelectFirst",
      "pageup": "menu::SelectFirst",
      "shift-pageup": "menu::SelectFirst",
      "ctrl-p": "menu::SelectPrev",
      "down": "menu::SelectNext",
+      "tab": "menu::SelectNext",
+      "end": "menu::SelectLast",
      "pagedown": "menu::SelectLast",
      "shift-pagedown": "menu::SelectFirst",
      "ctrl-n": "menu::SelectNext",
@@ -41,7 +45,7 @@
      "tab": "editor::Tab",
      "shift-tab": "editor::TabPrev",
      "ctrl-k": "editor::CutToEndOfLine",
-      "ctrl-t": "editor::Transpose",
+      // "ctrl-t": "editor::Transpose",
      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
      "ctrl-delete": "editor::DeleteToNextWordEnd",
      "shift-delete": "editor::Cut",
@@ -96,7 +100,7 @@
      "ctrl-k ctrl-r": "editor::RevertSelectedHunks",
      "ctrl-'": "editor::ToggleHunkDiff",
      "ctrl-\"": "editor::ExpandAllHunkDiffs",
-      "ctrl-alt-g b": "editor::ToggleGitBlame"
+      "alt-g b": "editor::ToggleGitBlame"
    }
  },
  {
@@ -108,12 +112,7 @@
      "ctrl-enter": "editor::NewlineAbove",
      "alt-z": "editor::ToggleSoftWrap",
      "ctrl-f": "buffer_search::Deploy",
-      "ctrl-h": [
-        "buffer_search::Deploy",
-        {
-          "replace_enabled": true
-        }
-      ],
+      "ctrl-h": ["buffer_search::Deploy", { "replace_enabled": true }],
      // "cmd-e": ["buffer_search::Deploy", { "focus": false }],
      "ctrl->": "assistant::QuoteSelection",
      "ctrl-<": "assistant::InsertIntoEditor",
@@ -229,6 +228,7 @@
      "ctrl-pageup": "pane::ActivatePrevItem",
      "ctrl-pagedown": "pane::ActivateNextItem",
      "ctrl-w": "pane::CloseActiveItem",
+      "ctrl-f4": "pane::CloseActiveItem",
      "alt-ctrl-t": "pane::CloseInactiveItems",
      "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-k u": "pane::CloseCleanItems",
@@ -285,16 +285,23 @@
      "f2": "editor::Rename",
      "f12": "editor::GoToDefinition",
      "alt-f12": "editor::GoToDefinitionSplit",
+      "ctrl-shift-f10": "editor::GoToDefinitionSplit",
      "ctrl-f12": "editor::GoToTypeDefinition",
      "shift-f12": "editor::GoToImplementation",
      "alt-ctrl-f12": "editor::GoToTypeDefinitionSplit",
      "alt-shift-f12": "editor::FindAllReferences",
      "ctrl-m": "editor::MoveToEnclosingBracket",
+      "ctrl-shift-\\": "editor::MoveToEnclosingBracket",
      "ctrl-shift-[": "editor::Fold",
      "ctrl-shift-]": "editor::UnfoldLines",
      "ctrl-space": "editor::ShowCompletions",
      "ctrl-.": "editor::ToggleCodeActions",
-      "alt-ctrl-r": "editor::RevealInFinder",
+      "alt-ctrl-r": "editor::RevealInFileManager",
+      "ctrl-k r": "editor::RevealInFileManager",
+      "ctrl-k p": "editor::CopyPath",
+      "ctrl-\\": "pane::SplitRight",
+      "ctrl-k v": "markdown::OpenPreviewToTheSide",
+      "ctrl-shift-v": "markdown::OpenPreview",
      "ctrl-alt-shift-c": "editor::DisplayCursorNames"
    }
  },
@@ -319,8 +326,10 @@
      "alt-9": ["pane::ActivateItem", 8],
      "alt-0": "pane::ActivateLastItem",
      "ctrl-alt--": "pane::GoBack",
-      "ctrl-alt-_": "pane::GoForward",
+      "ctrl-alt-shift--": "pane::GoForward",
      "ctrl-shift-t": "pane::ReopenClosedItem",
+      "f3": "search::SelectNextMatch",
+      "shift-f3": "search::SelectPrevMatch",
      "ctrl-shift-f": "project_search::ToggleFocus"
    }
  },
@@ -328,7 +337,7 @@
    "context": "Workspace",
    "bindings": {
      // Change the default action on `menu::Confirm` by setting the parameter
-      // "alt-cmd-o": ["projects::OpenRecent", { "create_new_window": true }],
+      // "alt-ctrl-o": ["projects::OpenRecent", { "create_new_window": true }],
      "alt-ctrl-o": "projects::OpenRecent",
      "alt-ctrl-shift-b": "branches::OpenRecent",
      "ctrl-~": "workspace::NewTerminal",
@@ -347,7 +356,7 @@
      "alt-7": ["workspace::ActivatePane", 6],
      "alt-8": ["workspace::ActivatePane", 7],
      "alt-9": ["workspace::ActivatePane", 8],
-      "ctrl-alt-b": "workspace::ToggleLeftDock",
+      "ctrl-alt-b": "workspace::ToggleRightDock",
      "ctrl-b": "workspace::ToggleLeftDock",
      "ctrl-j": "workspace::ToggleBottomDock",
      "ctrl-alt-y": "workspace::CloseAllDocks",
@@ -355,12 +364,13 @@
      "ctrl-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
      "ctrl-k ctrl-s": "zed::OpenKeymap",
      "ctrl-k ctrl-t": "theme_selector::Toggle",
-      "ctrl-shift-t": "project_symbols::Toggle",
+      "ctrl-t": "project_symbols::Toggle",
      "ctrl-p": "file_finder::Toggle",
      "ctrl-tab": "tab_switcher::Toggle",
      "ctrl-shift-tab": ["tab_switcher::Toggle", { "select_last": true }],
      "ctrl-e": "file_finder::Toggle",
      "ctrl-shift-p": "command_palette::Toggle",
+      "f1": "command_palette::Toggle",
      "ctrl-shift-m": "diagnostics::Deploy",
      "ctrl-shift-e": "project_panel::ToggleFocus",
      "ctrl-shift-b": "outline_panel::ToggleFocus",
@@ -376,6 +386,7 @@
      "ctrl-k shift-right": ["workspace::SwapPaneInDirection", "Right"],
      "ctrl-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
      "ctrl-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
+      "ctrl-shift-x": "zed::Extensions",
      "alt-t": "task::Rerun",
      "alt-shift-t": "task::Spawn"
    }
@@ -392,7 +403,7 @@
      "ctrl-alt-delete": "editor::DeleteToNextSubwordEnd",
      "ctrl-alt-d": "editor::DeleteToNextSubwordEnd",
      "ctrl-alt-left": "editor::MoveToPreviousSubwordStart",
-      "ctrl-alt-b": "editor::MoveToPreviousSubwordStart",
+      // "ctrl-alt-b": "editor::MoveToPreviousSubwordStart",
      "ctrl-alt-right": "editor::MoveToNextSubwordEnd",
      "ctrl-alt-f": "editor::MoveToNextSubwordEnd",
      "ctrl-alt-shift-left": "editor::SelectToPreviousSubwordStart",
@@ -491,11 +502,12 @@
  {
    "context": "OutlinePanel",
    "bindings": {
+      "escape": "menu::Cancel",
      "left": "outline_panel::CollapseSelectedEntry",
      "right": "outline_panel::ExpandSelectedEntry",
      "ctrl-alt-c": "outline_panel::CopyPath",
      "alt-ctrl-shift-c": "outline_panel::CopyRelativePath",
-      "alt-ctrl-r": "outline_panel::RevealInFinder",
+      "alt-ctrl-r": "outline_panel::RevealInFileManager",
      "space": "outline_panel::Open",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrev"
@@ -522,7 +534,7 @@
      "delete": ["project_panel::Trash", { "skip_prompt": false }],
      "ctrl-backspace": ["project_panel::Delete", { "skip_prompt": false }],
      "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
-      "alt-ctrl-r": "project_panel::RevealInFinder",
+      "alt-ctrl-r": "project_panel::RevealInFileManager",
      "alt-shift-f": "project_panel::NewSearchInDirectory",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrev",
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -3,10 +3,14 @@
  {
    "bindings": {
      "up": "menu::SelectPrev",
+      "shift-tab": "menu::SelectPrev",
+      "home": "menu::SelectFirst",
      "pageup": "menu::SelectFirst",
      "shift-pageup": "menu::SelectFirst",
      "ctrl-p": "menu::SelectPrev",
      "down": "menu::SelectNext",
+      "tab": "menu::SelectNext",
+      "end": "menu::SelectLast",
      "pagedown": "menu::SelectLast",
      "shift-pagedown": "menu::SelectFirst",
      "ctrl-n": "menu::SelectNext",
@@ -235,6 +239,7 @@
    "context": "ProjectSearchBar",
    "bindings": {
      "escape": "project_search::ToggleFocus",
+      "cmd-shift-j": "project_search::ToggleFilters",
      "cmd-shift-f": "search::FocusSearch",
      "cmd-shift-h": "search::ToggleReplace",
      "alt-cmd-g": "search::ToggleRegex",
@@ -259,6 +264,7 @@
    "context": "ProjectSearchView",
    "bindings": {
      "escape": "project_search::ToggleFocus",
+      "cmd-shift-j": "project_search::ToggleFilters",
      "cmd-shift-h": "search::ToggleReplace",
      "alt-cmd-g": "search::ToggleRegex",
      "alt-cmd-x": "search::ToggleRegex"
@@ -325,11 +331,17 @@
      "alt-cmd-f12": "editor::GoToTypeDefinitionSplit",
      "alt-shift-f12": "editor::FindAllReferences",
      "ctrl-m": "editor::MoveToEnclosingBracket",
+      "cmd-shift-\\": "editor::MoveToEnclosingBracket",
      "alt-cmd-[": "editor::Fold",
      "alt-cmd-]": "editor::UnfoldLines",
      "ctrl-space": "editor::ShowCompletions",
      "cmd-.": "editor::ToggleCodeActions",
-      "alt-cmd-r": "editor::RevealInFinder",
+      "alt-cmd-r": "editor::RevealInFileManager",
+      "cmd-k r": "editor::RevealInFileManager",
+      "cmd-k p": "editor::CopyPath",
+      "cmd-\\": "pane::SplitRight",
+      "cmd-k v": "markdown::OpenPreviewToTheSide",
+      "cmd-shift-v": "markdown::OpenPreview",
      "ctrl-cmd-c": "editor::DisplayCursorNames"
    }
  },
@@ -354,7 +366,7 @@
      "ctrl-9": ["pane::ActivateItem", 8],
      "ctrl-0": "pane::ActivateLastItem",
      "ctrl--": "pane::GoBack",
-      "ctrl-_": "pane::GoForward",
+      "ctrl-shift--": "pane::GoForward",
      "cmd-shift-t": "pane::ReopenClosedItem",
      "cmd-shift-f": "project_search::ToggleFocus"
    }
@@ -410,6 +422,7 @@
      "cmd-k shift-right": ["workspace::SwapPaneInDirection", "Right"],
      "cmd-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
      "cmd-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
+      "cmd-shift-x": "zed::Extensions",
      "alt-t": "task::Rerun",
      "alt-shift-t": "task::Spawn"
    }
@@ -510,11 +523,12 @@
  {
    "context": "OutlinePanel",
    "bindings": {
+      "escape": "menu::Cancel",
      "left": "outline_panel::CollapseSelectedEntry",
      "right": "outline_panel::ExpandSelectedEntry",
      "cmd-alt-c": "outline_panel::CopyPath",
      "alt-cmd-shift-c": "outline_panel::CopyRelativePath",
-      "alt-cmd-r": "outline_panel::RevealInFinder",
+      "alt-cmd-r": "outline_panel::RevealInFileManager",
      "space": "outline_panel::Open",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrev"
@@ -534,12 +548,14 @@
      "cmd-alt-c": "project_panel::CopyPath",
      "alt-cmd-shift-c": "project_panel::CopyRelativePath",
      "enter": "project_panel::Rename",
+      "f2": "project_panel::Rename",
      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
      "delete": ["project_panel::Trash", { "skip_prompt": false }],
      "cmd-backspace": ["project_panel::Trash", { "skip_prompt": true }],
      "cmd-delete": ["project_panel::Delete", { "skip_prompt": false }],
+      "alt-cmd-r": "project_panel::RevealInFileManager",
      "cmd-alt-backspace": ["project_panel::Delete", { "skip_prompt": false }],
-      "alt-cmd-r": "project_panel::RevealInFinder",
+
      "alt-shift-f": "project_panel::NewSearchInDirectory",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrev",
@@ -628,10 +644,14 @@
      "escape": ["terminal::SendKeystroke", "escape"],
      "enter": ["terminal::SendKeystroke", "enter"],
      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],
+      "cmd-up": "terminal::ScrollPageUp",
+      "cmd-down": "terminal::ScrollPageDown",
      "shift-pageup": "terminal::ScrollPageUp",
      "shift-pagedown": "terminal::ScrollPageDown",
      "shift-up": "terminal::ScrollLineUp",
      "shift-down": "terminal::ScrollLineDown",
+      "cmd-home": "terminal::ScrollToTop",
+      "cmd-end": "terminal::ScrollToBottom",
      "shift-home": "terminal::ScrollToTop",
      "shift-end": "terminal::ScrollToBottom"
    }
--- a/assets/keymaps/linux/atom.json
+++ b/assets/keymaps/linux/atom.json
@@ -0,0 +1,93 @@
+// Default Keymap (Atom) for Zed on Linux
+[
+  {
+    "bindings": {
+      "ctrl-shift-f5": "workspace::Reload", // window:reload
+      "ctrl-k ctrl-n": "workspace::ActivatePreviousPane", // window:focus-next-pane
+      "ctrl-k ctrl-p": "workspace::ActivateNextPane" // window:focus-previous-pane
+    }
+  },
+  {
+    "context": "Editor",
+    "bindings": {
+      "ctrl-shift-l": "language_selector::Toggle", // grammar-selector:show
+      "ctrl-|": "pane::RevealInProjectPanel", // tree-view:reveal-active-file
+      "ctrl-b": "editor::GoToDefinition", // fuzzy-finder:toggle-buffer-finder
+      "ctrl-alt-b": "editor::GoToDefinitionSplit", // N/A: From JetBrains
+      "ctrl-<": "editor::ScrollCursorCenter", // editor:scroll-to-cursor
+      "f3": ["editor::SelectNext", { "replace_newest": true }], // find-and-replace:find-next
+      "shift-f3": ["editor::SelectPrevious", { "replace_newest": true }], //find-and-replace:find-previous
+      "alt-shift-down": "editor::AddSelectionBelow", // editor:add-selection-below
+      "alt-shift-up": "editor::AddSelectionAbove", // editor:add-selection-above
+      "ctrl-k ctrl-u": "editor::ConvertToUpperCase", // editor:upper-case
+      "ctrl-k ctrl-l": "editor::ConvertToLowerCase", // editor:lower-case
+      "ctrl-j": "editor::JoinLines", // editor:join-lines
+      "ctrl-shift-d": "editor::DuplicateLineDown", // editor:duplicate-lines
+      "ctrl-up": "editor::MoveLineUp", // editor:move-line-up
+      "ctrl-down": "editor::MoveLineDown", // editor:move-line-down
+      "ctrl-shift-m": "markdown::OpenPreviewToTheSide" // markdown-preview:toggle
+    }
+  },
+  {
+    "context": "Editor && mode == full",
+    "bindings": {
+      "ctrl-r": "outline::Toggle" // symbols-view:toggle-project-symbols
+    }
+  },
+  {
+    "context": "BufferSearchBar",
+    "bindings": {
+      "ctrl-f3": "search::SelectNextMatch", // find-and-replace:find-next-selected
+      "ctrl-shift-f3": "search::SelectPrevMatch" // find-and-replace:find-previous-selected
+    }
+  },
+  {
+    "context": "Workspace",
+    "bindings": {
+      "ctrl-\\": "workspace::ToggleLeftDock", // tree-view:toggle
+      "ctrl-k ctrl-b": "workspace::ToggleLeftDock", // tree-view:toggle
+      "ctrl-t": "file_finder::Toggle", // fuzzy-finder:toggle-file-finder
+      "ctrl-r": "project_symbols::Toggle" // symbols-view:toggle-project-symbols
+    }
+  },
+  {
+    "context": "Pane",
+    "bindings": {
+      // "ctrl-0": "project_panel::ToggleFocus", // tree-view:toggle-focus
+      "ctrl-1": ["pane::ActivateItem", 0], // tree-view:open-selected-entry-in-pane-1
+      "ctrl-2": ["pane::ActivateItem", 1], // tree-view:open-selected-entry-in-pane-2
+      "ctrl-3": ["pane::ActivateItem", 2], // tree-view:open-selected-entry-in-pane-3
+      "ctrl-4": ["pane::ActivateItem", 3], // tree-view:open-selected-entry-in-pane-4
+      "ctrl-5": ["pane::ActivateItem", 4], // tree-view:open-selected-entry-in-pane-5
+      "ctrl-6": ["pane::ActivateItem", 5], // tree-view:open-selected-entry-in-pane-6
+      "ctrl-7": ["pane::ActivateItem", 6], // tree-view:open-selected-entry-in-pane-7
+      "ctrl-8": ["pane::ActivateItem", 7], // tree-view:open-selected-entry-in-pane-8
+      "ctrl-9": ["pane::ActivateItem", 8] // tree-view:open-selected-entry-in-pane-9
+    }
+  },
+  {
+    "context": "ProjectPanel",
+    "bindings": {
+      "f2": "project_panel::Rename", // tree-view:rename
+      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
+      "ctrl-x": "project_panel::Cut", // tree-view:cut
+      "ctrl-c": "project_panel::Copy", // tree-view:copy
+      "ctrl-v": "project_panel::Paste" // tree-view:paste
+    }
+  },
+  {
+    "context": "ProjectPanel && not_editing",
+    "bindings": {
+      "ctrl-shift-c": "project_panel::CopyPath", // tree-view:copy-full-path
+      "ctrl-[": "project_panel::CollapseSelectedEntry", // tree-view:collapse-directory
+      "ctrl-b": "project_panel::CollapseSelectedEntry", // tree-view:collapse-directory
+      "ctrl-]": "project_panel::ExpandSelectedEntry", // tree-view:expand-item
+      "ctrl-f": "project_panel::ExpandSelectedEntry", // tree-view:expand-item
+      "a": "project_panel::NewFile", // tree-view:add-file
+      "d": "project_panel::Duplicate", // tree-view:duplicate
+      "home": "menu::SelectFirst", // core:move-to-top
+      "end": "menu::SelectLast", // core:move-to-bottom
+      "shift-a": "project_panel::NewDirectory" // tree-view:add-folder
+    }
+  }
+]
--- a/assets/keymaps/linux/jetbrains.json
+++ b/assets/keymaps/linux/jetbrains.json
@@ -0,0 +1,90 @@
+[
+  {
+    "bindings": {
+      "ctrl-shift-[": "pane::ActivatePrevItem",
+      "ctrl-shift-]": "pane::ActivateNextItem"
+    }
+  },
+  {
+    "context": "Editor",
+    "bindings": {
+      "ctrl->": "zed::IncreaseBufferFontSize",
+      "ctrl-<": "zed::DecreaseBufferFontSize",
+      "ctrl-shift-j": "editor::JoinLines",
+      "ctrl-d": "editor::DuplicateLineDown",
+      "ctrl-y": "editor::DeleteLine",
+      "ctrl-pagedown": "editor::MovePageDown",
+      "ctrl-pageup": "editor::MovePageUp",
+      // "ctrl-alt-shift-b": "editor::SelectToPreviousWordStart",
+      "ctrl-alt-enter": "editor::NewlineAbove",
+      "shift-enter": "editor::NewlineBelow",
+      // "ctrl--": "editor::Fold", // TODO: `ctrl-numpad--` (numpad not implemented)
+      // "ctrl-+": "editor::UnfoldLines", // TODO: `ctrl-numpad+` (numpad not implemented)
+      "alt-shift-g": "editor::SplitSelectionIntoLines",
+      "alt-j": ["editor::SelectNext", { "replace_newest": false }],
+      "alt-shift-j": ["editor::SelectPrevious", { "replace_newest": false }],
+      "ctrl-/": ["editor::ToggleComments", { "advance_downwards": true }],
+      "alt-up": "editor::SelectLargerSyntaxNode",
+      "alt-down": "editor::SelectSmallerSyntaxNode",
+      "shift-alt-up": "editor::MoveLineUp",
+      "shift-alt-down": "editor::MoveLineDown",
+      "ctrl-alt-l": "editor::Format",
+      "shift-f6": "editor::Rename",
+      "ctrl-alt-left": "pane::GoBack",
+      "ctrl-alt-right": "pane::GoForward",
+      "alt-f7": "editor::FindAllReferences",
+      "ctrl-alt-f7": "editor::FindAllReferences",
+      // "ctrl-b": "editor::GoToDefinition", // Conflicts with workspace::ToggleLeftDock
+      // "ctrl-alt-b": "editor::GoToDefinitionSplit", // Conflicts with workspace::ToggleLeftDock
+      "ctrl-shift-b": "editor::GoToTypeDefinition",
+      "ctrl-alt-shift-b": "editor::GoToTypeDefinitionSplit",
+      "f2": "editor::GoToDiagnostic",
+      "shift-f2": "editor::GoToPrevDiagnostic",
+      "ctrl-alt-shift-down": "editor::GoToHunk",
+      "ctrl-alt-shift-up": "editor::GoToPrevHunk",
+      "ctrl-home": "editor::MoveToBeginning",
+      "ctrl-end": "editor::MoveToEnd",
+      "ctrl-shift-home": "editor::SelectToBeginning",
+      "ctrl-shift-end": "editor::SelectToEnd"
+    }
+  },
+  {
+    "context": "Editor && mode == full",
+    "bindings": {
+      "ctrl-f12": "outline::Toggle",
+      "alt-7": "outline::Toggle",
+      "ctrl-shift-n": "file_finder::Toggle",
+      "ctrl-g": "go_to_line::Toggle",
+      "alt-enter": "editor::ToggleCodeActions"
+    }
+  },
+  {
+    "context": "Workspace",
+    "bindings": {
+      "ctrl-shift-n": "file_finder::Toggle",
+      "ctrl-shift-a": "command_palette::Toggle",
+      "shift shift": "command_palette::Toggle",
+      "ctrl-alt-shift-n": "project_symbols::Toggle",
+      "alt-1": "workspace::ToggleLeftDock",
+      "ctrl-e": "tab_switcher::Toggle",
+      "alt-6": "diagnostics::Deploy"
+    }
+  },
+  {
+    "context": "Pane",
+    "bindings": {
+      "ctrl-alt-left": "pane::GoBack",
+      "ctrl-alt-right": "pane::GoForward"
+    }
+  },
+  {
+    "context": "ProjectPanel",
+    "bindings": {
+      "enter": "project_panel::Open",
+      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
+      "delete": ["project_panel::Trash", { "skip_prompt": false }],
+      "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
+      "shift-f6": "project_panel::Rename"
+    }
+  }
+]
--- a/assets/keymaps/linux/sublime_text.json
+++ b/assets/keymaps/linux/sublime_text.json
@@ -0,0 +1,53 @@
+[
+  {
+    "bindings": {
+      "ctrl-shift-[": "pane::ActivatePrevItem",
+      "ctrl-shift-]": "pane::ActivateNextItem",
+      "ctrl-pagedown": "pane::ActivatePrevItem",
+      "ctrl-pageup": "pane::ActivateNextItem",
+      "ctrl-shift-tab": "pane::ActivateNextItem",
+      "ctrl-tab": "pane::ActivatePrevItem"
+    }
+  },
+  {
+    "context": "Editor",
+    "bindings": {
+      "ctrl-shift-up": "editor::AddSelectionAbove",
+      "ctrl-shift-down": "editor::AddSelectionBelow",
+      "ctrl-shift-m": "editor::SelectLargerSyntaxNode",
+      "ctrl-shift-l": "editor::SplitSelectionIntoLines",
+      "ctrl-shift-a": "editor::SelectLargerSyntaxNode",
+      "ctrl-shift-d": "editor::DuplicateLineDown",
+      "f12": "editor::GoToDefinition",
+      "ctrl-f12": "editor::GoToDefinitionSplit",
+      "shift-f12": "editor::FindAllReferences",
+      "ctrl-shift-f12": "editor::FindAllReferences",
+      "ctrl-.": "editor::GoToHunk",
+      "ctrl-,": "editor::GoToPrevHunk",
+      "shift-alt-m": "markdown::OpenPreviewToTheSide",
+      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
+      "ctrl-delete": "editor::DeleteToNextWordEnd"
+    }
+  },
+  {
+    "context": "Editor && mode == full",
+    "bindings": {
+      "ctrl-r": "outline::Toggle"
+    }
+  },
+  {
+    "context": "Pane",
+    "bindings": {
+      "f4": "search::SelectNextMatch",
+      "shift-f4": "search::SelectPrevMatch"
+    }
+  },
+  {
+    "context": "Workspace",
+    "bindings": {
+      "ctrl-k ctrl-b": "workspace::ToggleLeftDock",
+      // "ctrl-0": "project_panel::ToggleFocus", // normally resets zoom
+      "shift-ctrl-r": "project_symbols::Toggle"
+    }
+  }
+]
--- a/assets/keymaps/macos/atom.json
+++ b/assets/keymaps/macos/atom.json
@@ -1,6 +1,8 @@
+// Default Keymap (Atom) for Zed on MacOS
 [
  {
    "bindings": {
+      "ctrl-alt-cmd-l": "workspace::Reload",
      "cmd-k cmd-p": "workspace::ActivatePreviousPane",
      "cmd-k cmd-n": "workspace::ActivateNextPane"
    }
@@ -8,14 +10,22 @@
  {
    "context": "Editor",
    "bindings": {
+      "ctrl-shift-l": "language_selector::Toggle",
+      "cmd-|": "pane::RevealInProjectPanel",
      "cmd-b": "editor::GoToDefinition",
      "alt-cmd-b": "editor::GoToDefinitionSplit",
      "cmd-<": "editor::ScrollCursorCenter",
      "cmd-g": ["editor::SelectNext", { "replace_newest": true }],
-      "ctrl-cmd-g": ["editor::SelectPrevious", { "replace_newest": true }],
+      "cmd-shift-g": ["editor::SelectPrevious", { "replace_newest": true }],
      "ctrl-shift-down": "editor::AddSelectionBelow",
      "ctrl-shift-up": "editor::AddSelectionAbove",
      "cmd-shift-backspace": "editor::DeleteToBeginningOfLine",
+      "cmd-k cmd-u": "editor::ConvertToUpperCase",
+      "cmd-k cmd-l": "editor::ConvertToLowerCase",
+      "alt-enter": "editor::Newline",
+      "cmd-shift-d": "editor::DuplicateLineDown",
+      "ctrl-cmd-up": "editor::MoveLineUp",
+      "ctrl-cmd-down": "editor::MoveLineDown",
      "ctrl-shift-m": "markdown::OpenPreviewToTheSide"
    }
  },
@@ -64,21 +74,22 @@
      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
      "cmd-x": "project_panel::Cut",
      "cmd-c": "project_panel::Copy",
-      "cmd-v": "project_panel::Paste",
-      "ctrl-[": "project_panel::CollapseSelectedEntry",
-      "ctrl-b": "project_panel::CollapseSelectedEntry",
-      "alt-b": "project_panel::CollapseSelectedEntry",
-      "ctrl-]": "project_panel::ExpandSelectedEntry",
-      "ctrl-f": "project_panel::ExpandSelectedEntry",
-      "ctrl-shift-c": "project_panel::CopyPath"
+      "cmd-v": "project_panel::Paste"
    }
  },
  {
    "context": "ProjectPanel && not_editing",
    "bindings": {
+      "ctrl-shift-c": "project_panel::CopyPath",
+      "ctrl-[": "project_panel::CollapseSelectedEntry",
+      "ctrl-b": "project_panel::CollapseSelectedEntry",
+      "ctrl-]": "project_panel::ExpandSelectedEntry",
+      "ctrl-f": "project_panel::ExpandSelectedEntry",
      "a": "project_panel::NewFile",
-      "shift-a": "project_panel::NewDirectory",
-      "shift-d": "project_panel::Duplicate"
+      "d": "project_panel::Duplicate",
+      "home": "menu::SelectFirst",
+      "end": "menu::SelectLast",
+      "shift-a": "project_panel::NewDirectory"
    }
  }
 ]
--- a/assets/keymaps/macos/jetbrains.json
+++ b/assets/keymaps/macos/jetbrains.json
@@ -39,7 +39,7 @@
      "cmd-shift-b": "editor::GoToTypeDefinition",
      "cmd-alt-shift-b": "editor::GoToTypeDefinitionSplit",
      "f2": "editor::GoToDiagnostic",
-      "cmd-f2": "editor::GoToPrevDiagnostic",
+      "shift-f2": "editor::GoToPrevDiagnostic",
      "ctrl-alt-shift-down": "editor::GoToHunk",
      "ctrl-alt-shift-up": "editor::GoToPrevHunk",
      "cmd-home": "editor::MoveToBeginning",
--- a/assets/keymaps/macos/sublime_text.json
+++ b/assets/keymaps/macos/sublime_text.json
@@ -6,8 +6,7 @@
      "ctrl-pagedown": "pane::ActivatePrevItem",
      "ctrl-pageup": "pane::ActivateNextItem",
      "ctrl-shift-tab": "pane::ActivateNextItem",
-      "ctrl-tab": "pane::ActivatePrevItem",
-      "cmd-+": "zed::IncreaseBufferFontSize"
+      "ctrl-tab": "pane::ActivatePrevItem"
    }
  },
  {
@@ -26,6 +25,9 @@
      "alt-shift-cmd-down": "editor::FindAllReferences",
      "ctrl-.": "editor::GoToHunk",
      "ctrl-,": "editor::GoToPrevHunk",
+      "cmd-k cmd-u": "editor::ConvertToUpperCase",
+      "cmd-k cmd-l": "editor::ConvertToLowerCase",
+      "shift-alt-m": "markdown::OpenPreviewToTheSide",
      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
      "ctrl-delete": "editor::DeleteToNextWordEnd"
    }
--- a/assets/keymaps/macos/textmate.json
+++ b/assets/keymaps/macos/textmate.json
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -147,6 +147,7 @@
      "8": ["vim::Number", 8],
      "9": ["vim::Number", 9],
      // window related commands (ctrl-w X)
+      "ctrl-w": null,
      "ctrl-w left": ["workspace::ActivatePaneInDirection", "Left"],
      "ctrl-w right": ["workspace::ActivatePaneInDirection", "Right"],
      "ctrl-w up": ["workspace::ActivatePaneInDirection", "Up"],
@@ -231,8 +232,8 @@
      "ctrl-x": "vim::Decrement",
      "p": "vim::Paste",
      "shift-p": ["vim::Paste", { "before": true }],
-      "u": "editor::Undo",
-      "ctrl-r": "editor::Redo",
+      "u": "vim::Undo",
+      "ctrl-r": "vim::Redo",
      "r": ["vim::PushOperator", "Replace"],
      "s": "vim::Substitute",
      "shift-s": "vim::SubstituteLine",
@@ -429,6 +430,7 @@
      "escape": "vim::NormalBefore",
      "ctrl-c": "vim::NormalBefore",
      "ctrl-[": "vim::NormalBefore",
+      "ctrl-x": null,
      "ctrl-x ctrl-o": "editor::ShowCompletions",
      "ctrl-x ctrl-a": "assistant::InlineAssist", // zed specific
      "ctrl-x ctrl-c": "editor::ShowInlineCompletion", // zed specific
@@ -502,7 +504,7 @@
      "t": "project_panel::OpenPermanent",
      "v": "project_panel::OpenPermanent",
      "p": "project_panel::Open",
-      "x": "project_panel::RevealInFinder",
+      "x": "project_panel::RevealInFileManager",
      "shift-g": "menu::SelectLast",
      "g g": "menu::SelectFirst",
      "-": "project_panel::SelectParent"
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -15,25 +15,25 @@
        "elevated_surface.background": "#2f343eff",
        "surface.background": "#2f343eff",
        "background": "#3b414dff",
-        "element.background": "#2f343eff",
+        "element.background": "#2e343eff",
        "element.hover": "#363c46ff",
        "element.active": "#454a56ff",
        "element.selected": "#454a56ff",
-        "element.disabled": "#2f343eff",
+        "element.disabled": "#2e343eff",
        "drop_target.background": "#83899480",
        "ghost_element.background": "#00000000",
        "ghost_element.hover": "#363c46ff",
        "ghost_element.active": "#454a56ff",
        "ghost_element.selected": "#454a56ff",
-        "ghost_element.disabled": "#2f343eff",
+        "ghost_element.disabled": "#2e343eff",
        "text": "#c8ccd4ff",
        "text.muted": "#838994ff",
-        "text.placeholder": "#555a63ff",
-        "text.disabled": "#555a63ff",
+        "text.placeholder": "#696B77ff",
+        "text.disabled": "#696B77ff",
        "text.accent": "#74ade8ff",
        "icon": "#c8ccd4ff",
        "icon.muted": "#838994ff",
-        "icon.disabled": "#555a63ff",
+        "icon.disabled": "#696B77ff",
        "icon.placeholder": "#838994ff",
        "icon.accent": "#74ade8ff",
        "status_bar.background": "#3b414dff",
@@ -59,7 +59,7 @@
        "editor.highlighted_line.background": "#2f343eff",
        "editor.line_number": "#c8ccd459",
        "editor.active_line_number": "#c8ccd4ff",
-        "editor.invisible": "#555a63ff",
+        "editor.invisible": "#696B77ff",
        "editor.wrap_guide": "#c8ccd40d",
        "editor.active_wrap_guide": "#c8ccd41a",
        "editor.document_highlight.read_background": "#74ade81a",
@@ -94,46 +94,46 @@
        "terminal.ansi.dim_white": "#575d65ff",
        "link_text.hover": "#74ade8ff",
        "conflict": "#dec184ff",
-        "conflict.background": "#41321dff",
+        "conflict.background": "#dec1841a",
        "conflict.border": "#5d4c2fff",
        "created": "#a1c181ff",
-        "created.background": "#222e1dff",
+        "created.background": "#a1c1811a",
        "created.border": "#38482fff",
        "deleted": "#d07277ff",
-        "deleted.background": "#301b1bff",
+        "deleted.background": "#d072771a",
        "deleted.border": "#4c2b2cff",
        "error": "#d07277ff",
-        "error.background": "#301b1bff",
+        "error.background": "#d072771a",
        "error.border": "#4c2b2cff",
-        "hidden": "#555a63ff",
-        "hidden.background": "#3b414dff",
+        "hidden": "#696B77ff",
+        "hidden.background": "#696B771a",
        "hidden.border": "#414754ff",
        "hint": "#5a6f89ff",
-        "hint.background": "#18243dff",
+        "hint.background": "#5a6f891a",
        "hint.border": "#293b5bff",
-        "ignored": "#555a63ff",
-        "ignored.background": "#3b414dff",
+        "ignored": "#696B77ff",
+        "ignored.background": "#696B771a",
        "ignored.border": "#464b57ff",
        "info": "#74ade8ff",
-        "info.background": "#18243dff",
+        "info.background": "#74ade81a",
        "info.border": "#293b5bff",
        "modified": "#dec184ff",
-        "modified.background": "#41321dff",
+        "modified.background": "#dec1841a",
        "modified.border": "#5d4c2fff",
        "predictive": "#5a6a87ff",
-        "predictive.background": "#222e1dff",
+        "predictive.background": "#5a6a871a",
        "predictive.border": "#38482fff",
        "renamed": "#74ade8ff",
-        "renamed.background": "#18243dff",
+        "renamed.background": "#74ade81a",
        "renamed.border": "#293b5bff",
        "success": "#a1c181ff",
-        "success.background": "#222e1dff",
+        "success.background": "#a1c1811a",
        "success.border": "#38482fff",
        "unreachable": "#838994ff",
-        "unreachable.background": "#3b414dff",
+        "unreachable.background": "#8389941a",
        "unreachable.border": "#464b57ff",
        "warning": "#dec184ff",
-        "warning.background": "#41321dff",
+        "warning.background": "#dec1841a",
        "warning.border": "#5d4c2fff",
        "players": [
          {
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -616,8 +616,9 @@ impl AssistantPanel {
                .filter(|editor| editor.read(cx).context.read(cx).path.as_ref() == Some(&path))
        });
        if let Some(existing_context) = existing_context {
-            self.show_context(existing_context, cx);
-            return Task::ready(Ok(()));
+            return cx.spawn(|this, mut cx| async move {
+                this.update(&mut cx, |this, cx| this.show_context(existing_context, cx))
+            });
        }

        let saved_context = self.context_store.read(cx).load(path.clone(), cx);
@@ -3303,14 +3304,13 @@ impl ContextEditorToolbarItem {
                                    let command_name = command_name.clone();
                                    move |_cx| {
                                        h_flex()
+                                            .gap_4()
                                            .w_full()
                                            .justify_between()
                                            .child(Label::new(menu_text.clone()))
                                            .child(
-                                                div().ml_4().child(
-                                                    Label::new(format!("/{command_name}"))
-                                                        .color(Color::Muted),
-                                                ),
+                                                Label::new(format!("/{command_name}"))
+                                                    .color(Color::Muted),
                                            )
                                            .into_any()
                                    }
--- a/crates/assistant/src/model_selector.rs
+++ b/crates/assistant/src/model_selector.rs
@@ -49,6 +49,7 @@ impl RenderOnce for ModelSelector {
            })
            .trigger(
                ButtonLike::new("active-model")
+                    .style(ButtonStyle::Subtle)
                    .child(
                        h_flex()
                            .w_full()
@@ -67,14 +68,11 @@ impl RenderOnce for ModelSelector {
                                    ),
                            )
                            .child(
-                                div().child(
-                                    Icon::new(IconName::ChevronDown)
-                                        .color(Color::Muted)
-                                        .size(IconSize::XSmall),
-                                ),
+                                Icon::new(IconName::ChevronDown)
+                                    .color(Color::Muted)
+                                    .size(IconSize::XSmall),
                            ),
                    )
-                    .style(ButtonStyle::Subtle)
                    .tooltip(move |cx| {
                        Tooltip::for_action("Change Model", &ToggleModelSelector, cx)
                    }),
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -227,7 +227,7 @@ impl Telemetry {
                let state = state.clone();
                async move {
                    if let Some(tempfile) =
-                        NamedTempFile::new_in(paths::config_dir().as_path()).log_err()
+                        NamedTempFile::new_in(paths::logs_dir().as_path()).log_err()
                    {
                        state.lock().log_file = Some(tempfile);
                    }
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -355,11 +355,10 @@ impl ChatPanel {
                .child(Icon::new(IconName::ReplyArrowRight).color(Color::Muted))
                .child(Avatar::new(user_being_replied_to.avatar_uri.clone()).size(rems(0.7)))
                .child(
-                    div().font_weight(FontWeight::SEMIBOLD).child(
-                        Label::new(format!("@{}", user_being_replied_to.github_login))
-                            .size(LabelSize::XSmall)
-                            .color(Color::Muted),
-                    ),
+                    Label::new(format!("@{}", user_being_replied_to.github_login))
+                        .size(LabelSize::XSmall)
+                        .weight(FontWeight::SEMIBOLD)
+                        .color(Color::Muted),
                )
                .child(
                    div().overflow_y_hidden().child(
@@ -490,22 +489,16 @@ impl ChatPanel {
                        |this| {
                            this.child(
                                h_flex()
+                                    .gap_2()
                                    .text_ui_sm(cx)
                                    .child(
-                                        div().absolute().child(
-                                            Avatar::new(message.sender.avatar_uri.clone())
-                                                .size(rems(1.)),
-                                        ),
+                                        Avatar::new(message.sender.avatar_uri.clone())
+                                            .size(rems(1.)),
                                    )
                                    .child(
-                                        div()
-                                            .pl(cx.rem_size() + px(6.0))
-                                            .pr(px(8.0))
-                                            .font_weight(FontWeight::BOLD)
-                                            .child(
-                                                Label::new(message.sender.github_login.clone())
-                                                    .size(LabelSize::Small),
-                                            ),
+                                        Label::new(message.sender.github_login.clone())
+                                            .size(LabelSize::Small)
+                                            .weight(FontWeight::BOLD),
                                    )
                                    .child(
                                        Label::new(time_format::format_localized_timestamp(
@@ -1044,13 +1037,12 @@ impl Render for ChatPanel {
                                        .id(("reply-preview", reply_to_message_id))
                                        .child(Label::new("Replying to ").size(LabelSize::Small))
                                        .child(
-                                            div().font_weight(FontWeight::BOLD).child(
-                                                Label::new(format!(
-                                                    "@{}",
-                                                    user_being_replied_to.github_login.clone()
-                                                ))
-                                                .size(LabelSize::Small),
-                                            ),
+                                            Label::new(format!(
+                                                "@{}",
+                                                user_being_replied_to.github_login.clone()
+                                            ))
+                                            .size(LabelSize::Small)
+                                            .weight(FontWeight::BOLD),
                                        )
                                        .when_some(channel_id, |this, channel_id| {
                                            this.cursor_pointer().on_click(cx.listener(
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2547,9 +2547,8 @@ impl CollabPanel {
                    .take(FACEPILE_LIMIT)
                    .chain(if extra_count > 0 {
                        Some(
-                            div()
+                            Label::new(format!("+{extra_count}"))
                                .ml_2()
-                                .child(Label::new(format!("+{extra_count}")))
                                .into_any_element(),
                        )
                    } else {
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -258,7 +258,7 @@ gpui::actions!(
        RedoSelection,
        Rename,
        RestartLanguageServer,
-        RevealInFinder,
+        RevealInFileManager,
        ReverseLines,
        RevertSelectedHunks,
        ScrollCursorBottom,
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -89,13 +89,16 @@ use language::{
    CursorShape, Diagnostic, Documentation, IndentKind, IndentSize, Language, OffsetRangeExt,
    Point, Selection, SelectionGoal, TransactionId,
 };
-use language::{BufferRow, Runnable, RunnableRange};
+use language::{point_to_lsp, BufferRow, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
 use task::{ResolvedTask, TaskTemplate, TaskVariables};

 use hover_links::{HoverLink, HoveredLinkState, InlayHighlight};
 pub use lsp::CompletionContext;
-use lsp::{CompletionTriggerKind, DiagnosticSeverity, LanguageServerId};
+use lsp::{
+    CompletionItemKind, CompletionTriggerKind, DiagnosticSeverity, InsertTextFormat,
+    LanguageServerId,
+};
 use mouse_context_menu::MouseContextMenu;
 use movement::TextLayoutDetails;
 pub use multi_buffer::{
@@ -1126,11 +1129,10 @@ impl CompletionsMenu {
                                    None
                                } else {
                                    Some(
-                                        h_flex().ml_4().child(
-                                            Label::new(text.clone())
-                                                .size(LabelSize::Small)
-                                                .color(Color::Muted),
-                                        ),
+                                        Label::new(text.clone())
+                                            .ml_4()
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted),
                                    )
                                }
                            } else {
@@ -1153,7 +1155,7 @@ impl CompletionsMenu {
                                    }
                                }))
                                .child(h_flex().overflow_hidden().child(completion_label))
-                                .end_slot::<Div>(documentation_label),
+                                .end_slot::<Label>(documentation_label),
                        )
                    })
                    .collect()
@@ -5157,7 +5159,6 @@ impl Editor {
                })
                .collect::<Vec<_>>()
        });
-
        if let Some(tabstop) = tabstops.first() {
            self.change_selections(Some(Autoscroll::fit()), cx, |s| {
                s.select_ranges(tabstop.ranges.iter().cloned());
@@ -10331,7 +10332,7 @@ impl Editor {
        cx.notify();
    }

-    pub fn reveal_in_finder(&mut self, _: &RevealInFinder, cx: &mut ViewContext<Self>) {
+    pub fn reveal_in_finder(&mut self, _: &RevealInFileManager, cx: &mut ViewContext<Self>) {
        if let Some(buffer) = self.buffer().read(cx).as_singleton() {
            if let Some(file) = buffer.read(cx).file().and_then(|f| f.as_local()) {
                cx.reveal_path(&file.abs_path(cx));
@@ -11757,6 +11758,97 @@ pub trait CompletionProvider {
    ) -> bool;
 }

+fn snippet_completions(
+    project: &Project,
+    buffer: &Model<Buffer>,
+    buffer_position: text::Anchor,
+    cx: &mut AppContext,
+) -> Vec<Completion> {
+    let language = buffer.read(cx).language_at(buffer_position);
+    let language_name = language.as_ref().map(|language| language.lsp_id());
+    let snippet_store = project.snippets().read(cx);
+    let snippets = snippet_store.snippets_for(language_name, cx);
+
+    if snippets.is_empty() {
+        return vec![];
+    }
+    let snapshot = buffer.read(cx).text_snapshot();
+    let chunks = snapshot.reversed_chunks_in_range(text::Anchor::MIN..buffer_position);
+
+    let mut lines = chunks.lines();
+    let Some(line_at) = lines.next().filter(|line| !line.is_empty()) else {
+        return vec![];
+    };
+
+    let scope = language.map(|language| language.default_scope());
+    let mut last_word = line_at
+        .chars()
+        .rev()
+        .take_while(|c| char_kind(&scope, *c) == CharKind::Word)
+        .collect::<String>();
+    last_word = last_word.chars().rev().collect();
+    let as_offset = text::ToOffset::to_offset(&buffer_position, &snapshot);
+    let to_lsp = |point: &text::Anchor| {
+        let end = text::ToPointUtf16::to_point_utf16(point, &snapshot);
+        point_to_lsp(end)
+    };
+    let lsp_end = to_lsp(&buffer_position);
+    snippets
+        .into_iter()
+        .filter_map(|snippet| {
+            let matching_prefix = snippet
+                .prefix
+                .iter()
+                .find(|prefix| prefix.starts_with(&last_word))?;
+            let start = as_offset - last_word.len();
+            let start = snapshot.anchor_before(start);
+            let range = start..buffer_position;
+            let lsp_start = to_lsp(&start);
+            let lsp_range = lsp::Range {
+                start: lsp_start,
+                end: lsp_end,
+            };
+            Some(Completion {
+                old_range: range,
+                new_text: snippet.body.clone(),
+                label: CodeLabel {
+                    text: matching_prefix.clone(),
+                    runs: vec![],
+                    filter_range: 0..matching_prefix.len(),
+                },
+                server_id: LanguageServerId(usize::MAX),
+                documentation: snippet
+                    .description
+                    .clone()
+                    .map(|description| Documentation::SingleLine(description)),
+                lsp_completion: lsp::CompletionItem {
+                    label: snippet.prefix.first().unwrap().clone(),
+                    kind: Some(CompletionItemKind::SNIPPET),
+                    label_details: snippet.description.as_ref().map(|description| {
+                        lsp::CompletionItemLabelDetails {
+                            detail: Some(description.clone()),
+                            description: None,
+                        }
+                    }),
+                    insert_text_format: Some(InsertTextFormat::SNIPPET),
+                    text_edit: Some(lsp::CompletionTextEdit::InsertAndReplace(
+                        lsp::InsertReplaceEdit {
+                            new_text: snippet.body.clone(),
+                            insert: lsp_range,
+                            replace: lsp_range,
+                        },
+                    )),
+                    filter_text: Some(snippet.body.clone()),
+                    sort_text: Some(char::MAX.to_string()),
+                    ..Default::default()
+                },
+                confirm: None,
+                show_new_completions_on_confirm: false,
+            })
+        })
+        .collect()
+}
+
 impl CompletionProvider for Model<Project> {
    fn completions(
        &self,
@@ -11766,7 +11858,14 @@ impl CompletionProvider for Model<Project> {
        cx: &mut ViewContext<Editor>,
    ) -> Task<Result<Vec<Completion>>> {
        self.update(cx, |project, cx| {
-            project.completions(&buffer, buffer_position, options, cx)
+            let snippets = snippet_completions(project, buffer, buffer_position, cx);
+            let project_completions = project.completions(&buffer, buffer_position, options, cx);
+            cx.background_executor().spawn(async move {
+                let mut completions = project_completions.await?;
+                //let snippets = snippets.into_iter().;
+                completions.extend(snippets);
+                Ok(completions)
+            })
        })
    }

--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -3660,6 +3660,11 @@ impl EditorElement {
                        if scroll_position != current_scroll_position {
                            editor.scroll(scroll_position, axis, cx);
                            cx.stop_propagation();
+                        } else if y < 0. {
+                            // Due to clamping, we may fail to detect cases of overscroll to the top;
+                            // We want the scroll manager to get an update in such cases and detect the change of direction
+                            // on the next frame.
+                            cx.notify();
                        }
                    });
                }
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -19,7 +19,7 @@ use project::{HoverBlock, HoverBlockKind, InlayHintLabelPart};
 use settings::Settings;
 use smol::stream::StreamExt;
 use std::{ops::Range, sync::Arc, time::Duration};
-use ui::{prelude::*, Tooltip};
+use ui::{prelude::*, window_is_transparent, Tooltip};
 use util::TryFutureExt;
 use workspace::Workspace;

@@ -587,15 +587,12 @@ impl DiagnosticPopover {
        div()
            .id("diagnostic")
            .block()
-            .elevation_2(cx)
-            .overflow_y_scroll()
-            .px_2()
-            .py_1()
-            .bg(diagnostic_colors.background)
-            .text_color(style.text.color)
-            .border_1()
-            .border_color(diagnostic_colors.border)
-            .rounded_md()
+            .elevation_2_borderless(cx)
+            // Don't draw the background color if the theme
+            // allows transparent surfaces.
+            .when(window_is_transparent(cx), |this| {
+                this.bg(gpui::transparent_black())
+            })
            .max_w(max_size.width)
            .max_h(max_size.height)
            .cursor(CursorStyle::PointingHand)
@@ -607,7 +604,19 @@ impl DiagnosticPopover {
            // because that would move the cursor.
            .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
            .on_click(cx.listener(|editor, _, cx| editor.go_to_diagnostic(&Default::default(), cx)))
-            .child(SharedString::from(text))
+            .child(
+                div()
+                    .id("diagnostic-inner")
+                    .overflow_y_scroll()
+                    .px_2()
+                    .py_1()
+                    .bg(diagnostic_colors.background)
+                    .text_color(style.text.color)
+                    .border_1()
+                    .border_color(diagnostic_colors.border)
+                    .rounded_lg()
+                    .child(SharedString::from(text)),
+            )
            .into_any_element()
    }

--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -1,8 +1,12 @@
+use std::ops::Range;
+
 use crate::{
-    Copy, CopyPermalinkToLine, Cut, DisplayPoint, Editor, EditorMode, FindAllReferences,
-    GoToDefinition, GoToImplementation, GoToTypeDefinition, Paste, Rename, RevealInFinder,
-    SelectMode, ToggleCodeActions,
+    selections_collection::SelectionsCollection, Copy, CopyPermalinkToLine, Cut, DisplayPoint,
+    DisplaySnapshot, Editor, EditorMode, FindAllReferences, GoToDefinition, GoToImplementation,
+    GoToTypeDefinition, Paste, Rename, RevealInFileManager, SelectMode, ToDisplayPoint,
+    ToggleCodeActions,
 };
+use gpui::prelude::FluentBuilder;
 use gpui::{DismissEvent, Pixels, Point, Subscription, View, ViewContext};
 use workspace::OpenInTerminal;

@@ -37,6 +41,23 @@ impl MouseContextMenu {
    }
 }

+fn display_ranges<'a>(
+    display_map: &'a DisplaySnapshot,
+    selections: &'a SelectionsCollection,
+) -> impl Iterator<Item = Range<DisplayPoint>> + 'a {
+    let pending = selections
+        .pending
+        .as_ref()
+        .map(|pending| &pending.selection);
+    selections.disjoint.iter().chain(pending).map(move |s| {
+        if s.reversed {
+            s.end.to_display_point(&display_map)..s.start.to_display_point(&display_map)
+        } else {
+            s.start.to_display_point(&display_map)..s.end.to_display_point(&display_map)
+        }
+    })
+}
+
 pub fn deploy_context_menu(
    editor: &mut Editor,
    position: Point<Pixels>,
@@ -65,11 +86,14 @@ pub fn deploy_context_menu(
            return;
        }

-        // Move the cursor to the clicked location so that dispatched actions make sense
-        editor.change_selections(None, cx, |s| {
-            s.clear_disjoint();
-            s.set_pending_display_range(point..point, SelectMode::Character);
-        });
+        let display_map = editor.selections.display_map(cx);
+        if !display_ranges(&display_map, &editor.selections).any(|r| r.contains(&point)) {
+            // Move the cursor to the clicked location so that dispatched actions make sense
+            editor.change_selections(None, cx, |s| {
+                s.clear_disjoint();
+                s.set_pending_display_range(point..point, SelectMode::Character);
+            });
+        }

        let focus = cx.focused();
        ui::ContextMenu::build(cx, |menu, _cx| {
@@ -90,7 +114,12 @@ pub fn deploy_context_menu(
                .action("Copy", Box::new(Copy))
                .action("Paste", Box::new(Paste))
                .separator()
-                .action("Reveal in Finder", Box::new(RevealInFinder))
+                .when(cfg!(target_os = "macos"), |builder| {
+                    builder.action("Reveal in Finder", Box::new(RevealInFileManager))
+                })
+                .when(cfg!(not(target_os = "macos")), |builder| {
+                    builder.action("Reveal in File Manager", Box::new(RevealInFileManager))
+                })
                .action("Open in Terminal", Box::new(OpenInTerminal))
                .action("Copy Permalink", Box::new(CopyPermalinkToLine));
            match focus {
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -42,6 +42,7 @@ semantic_version.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
+snippet_provider.workspace = true
 theme.workspace = true
 toml.workspace = true
 ui.workspace = true
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -526,6 +526,11 @@ fn populate_defaults(manifest: &mut ExtensionManifest, extension_path: &Path) ->
        }
    }

+    let snippets_json_path = extension_path.join("snippets.json");
+    if snippets_json_path.exists() {
+        manifest.snippets = Some(snippets_json_path);
+    }
+
    // For legacy extensions on the v0 schema (aka, using `extension.json`), we want to populate the grammars in
    // the manifest using the contents of the `grammars` directory.
    if manifest.schema_version.is_v0() {
--- a/crates/extension/src/extension_manifest.rs
+++ b/crates/extension/src/extension_manifest.rs
@@ -78,6 +78,8 @@ pub struct ExtensionManifest {
    pub slash_commands: BTreeMap<Arc<str>, SlashCommandManifestEntry>,
    #[serde(default)]
    pub indexed_docs_providers: BTreeMap<Arc<str>, IndexedDocsProviderEntry>,
+    #[serde(default)]
+    pub snippets: Option<PathBuf>,
 }

 #[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
@@ -206,5 +208,6 @@ fn manifest_from_old_manifest(
        language_servers: Default::default(),
        slash_commands: BTreeMap::default(),
        indexed_docs_providers: BTreeMap::default(),
+        snippets: None,
    }
 }
--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -44,6 +44,7 @@ use release_channel::ReleaseChannel;
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
+use snippet_provider::SnippetRegistry;
 use std::ops::RangeInclusive;
 use std::str::FromStr;
 use std::{
@@ -115,6 +116,7 @@ pub struct ExtensionStore {
    theme_registry: Arc<ThemeRegistry>,
    slash_command_registry: Arc<SlashCommandRegistry>,
    indexed_docs_registry: Arc<IndexedDocsRegistry>,
+    snippet_registry: Arc<SnippetRegistry>,
    modified_extensions: HashSet<Arc<str>>,
    wasm_host: Arc<WasmHost>,
    wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
@@ -193,6 +195,7 @@ pub fn init(
            theme_registry,
            SlashCommandRegistry::global(cx),
            IndexedDocsRegistry::global(cx),
+            SnippetRegistry::global(cx),
            cx,
        )
    });
@@ -227,6 +230,7 @@ impl ExtensionStore {
        theme_registry: Arc<ThemeRegistry>,
        slash_command_registry: Arc<SlashCommandRegistry>,
        indexed_docs_registry: Arc<IndexedDocsRegistry>,
+        snippet_registry: Arc<SnippetRegistry>,
        cx: &mut ModelContext<Self>,
    ) -> Self {
        let work_dir = extensions_dir.join("work");
@@ -259,6 +263,7 @@ impl ExtensionStore {
            theme_registry,
            slash_command_registry,
            indexed_docs_registry,
+            snippet_registry,
            reload_tx,
            tasks: Vec::new(),
        };
@@ -1045,6 +1050,7 @@ impl ExtensionStore {
            .collect::<Vec<_>>();
        let mut grammars_to_add = Vec::new();
        let mut themes_to_add = Vec::new();
+        let mut snippets_to_add = Vec::new();
        for extension_id in &extensions_to_load {
            let Some(extension) = new_index.extensions.get(extension_id) else {
                continue;
@@ -1062,6 +1068,11 @@ impl ExtensionStore {
                path.extend([Path::new(extension_id.as_ref()), theme_path.as_path()]);
                path
            }));
+            snippets_to_add.extend(extension.manifest.snippets.iter().map(|snippets_path| {
+                let mut path = self.installed_dir.clone();
+                path.extend([Path::new(extension_id.as_ref()), snippets_path.as_path()]);
+                path
+            }));
        }

        self.language_registry
@@ -1097,6 +1108,7 @@ impl ExtensionStore {
        let wasm_host = self.wasm_host.clone();
        let root_dir = self.installed_dir.clone();
        let theme_registry = self.theme_registry.clone();
+        let snippet_registry = self.snippet_registry.clone();
        let extension_entries = extensions_to_load
            .iter()
            .filter_map(|name| new_index.extensions.get(name).cloned())
@@ -1117,6 +1129,15 @@ impl ExtensionStore {
                                .await
                                .log_err();
                        }
+
+                        for snippets_path in &snippets_to_add {
+                            if let Some(snippets_contents) = fs.load(snippets_path).await.log_err()
+                            {
+                                snippet_registry
+                                    .register_snippets(snippets_path, &snippets_contents)
+                                    .log_err();
+                            }
+                        }
                    }
                })
                .await;
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -19,6 +19,7 @@ use parking_lot::Mutex;
 use project::{Project, DEFAULT_COMPLETION_CONTEXT};
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
+use snippet_provider::SnippetRegistry;
 use std::{
    ffi::OsString,
    path::{Path, PathBuf},
@@ -160,6 +161,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                        language_servers: BTreeMap::default(),
                        slash_commands: BTreeMap::default(),
                        indexed_docs_providers: BTreeMap::default(),
+                        snippets: None,
                    }),
                    dev: false,
                },
@@ -185,6 +187,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                        language_servers: BTreeMap::default(),
                        slash_commands: BTreeMap::default(),
                        indexed_docs_providers: BTreeMap::default(),
+                        snippets: None,
                    }),
                    dev: false,
                },
@@ -258,6 +261,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
    let slash_command_registry = SlashCommandRegistry::new();
    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
+    let snippet_registry = Arc::new(SnippetRegistry::new());
    let node_runtime = FakeNodeRuntime::new();

    let store = cx.new_model(|cx| {
@@ -272,6 +276,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
            theme_registry.clone(),
            slash_command_registry.clone(),
            indexed_docs_registry.clone(),
+            snippet_registry.clone(),
            cx,
        )
    });
@@ -345,6 +350,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                language_servers: BTreeMap::default(),
                slash_commands: BTreeMap::default(),
                indexed_docs_providers: BTreeMap::default(),
+                snippets: None,
            }),
            dev: false,
        },
@@ -396,6 +402,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
            theme_registry.clone(),
            slash_command_registry,
            indexed_docs_registry,
+            snippet_registry,
            cx,
        )
    });
@@ -477,6 +484,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
    let slash_command_registry = SlashCommandRegistry::new();
    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
+    let snippet_registry = Arc::new(SnippetRegistry::new());
    let node_runtime = FakeNodeRuntime::new();

    let mut status_updates = language_registry.language_server_binary_statuses();
@@ -568,6 +576,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
            theme_registry.clone(),
            slash_command_registry,
            indexed_docs_registry,
+            snippet_registry,
            cx,
        )
    });
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -124,7 +124,6 @@ wayland-protocols = { version = "0.31.2", features = [
 ] }
 wayland-protocols-plasma = { version = "0.2.0", features = ["client"] }
 oo7 = "0.3.0"
-open = "5.1.2"
 filedescriptor = "0.8.2"
 x11rb = { version = "0.13.0", features = [
    "allow-unsafe-code",
@@ -142,7 +141,6 @@ xim = { git = "https://github.com/npmania/xim-rs", rev = "27132caffc5b9bc9c432ca
 ] }
 font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "5a5c4d4", features = ["source-fontconfig-dlopen"] }
 x11-clipboard = "0.9.2"
-mio = { version = "1.0.0", features = ["os-poll", "os-ext"] }

 [target.'cfg(windows)'.dependencies]
 windows.workspace = true
--- a/crates/gpui/examples/input.rs
+++ b/crates/gpui/examples/input.rs
@@ -26,6 +26,8 @@ struct TextInput {
    selection_reversed: bool,
    marked_range: Option<Range<usize>>,
    last_layout: Option<ShapedLine>,
+    last_bounds: Option<Bounds<Pixels>>,
+    is_selecting: bool,
 }

 impl TextInput {
@@ -80,6 +82,21 @@ impl TextInput {
        self.replace_text_in_range(None, "", cx)
    }

+    fn on_mouse_down(&mut self, event: &MouseDownEvent, cx: &mut ViewContext<Self>) {
+        self.is_selecting = true;
+        self.move_to(self.index_for_mouse_position(event.position), cx)
+    }
+
+    fn on_mouse_up(&mut self, _: &MouseUpEvent, _: &mut ViewContext<Self>) {
+        self.is_selecting = false;
+    }
+
+    fn on_mouse_move(&mut self, event: &MouseMoveEvent, cx: &mut ViewContext<Self>) {
+        if self.is_selecting {
+            self.select_to(self.index_for_mouse_position(event.position), cx);
+        }
+    }
+
    fn show_character_palette(&mut self, _: &ShowCharacterPalette, cx: &mut ViewContext<Self>) {
        cx.show_character_palette();
    }
@@ -97,6 +114,20 @@ impl TextInput {
        }
    }

+    fn index_for_mouse_position(&self, position: Point<Pixels>) -> usize {
+        let (Some(bounds), Some(line)) = (self.last_bounds.as_ref(), self.last_layout.as_ref())
+        else {
+            return 0;
+        };
+        if position.y < bounds.top() {
+            return 0;
+        }
+        if position.y > bounds.bottom() {
+            return self.content.len();
+        }
+        line.closest_index_for_x(position.x - bounds.left())
+    }
+
    fn select_to(&mut self, offset: usize, cx: &mut ViewContext<Self>) {
        if self.selection_reversed {
            self.selected_range.start = offset
@@ -162,6 +193,16 @@ impl TextInput {
            .find_map(|(idx, _)| (idx > offset).then_some(idx))
            .unwrap_or(self.content.len())
    }
+
+    fn reset(&mut self) {
+        self.content = "".into();
+        self.selected_range = 0..0;
+        self.selection_reversed = false;
+        self.marked_range = None;
+        self.last_layout = None;
+        self.last_bounds = None;
+        self.is_selecting = false;
+    }
 }

 impl ViewInputHandler for TextInput {
@@ -284,6 +325,7 @@ impl Element for TextElement {
        None
    }

+    #[profiling::function]
    fn request_layout(
        &mut self,
        _id: Option<&GlobalElementId>,
@@ -295,6 +337,7 @@ impl Element for TextElement {
        (cx.request_layout(style, []), ())
    }

+    #[profiling::function]
    fn prepaint(
        &mut self,
        _id: Option<&GlobalElementId>,
@@ -385,6 +428,7 @@ impl Element for TextElement {
        }
    }

+    #[profiling::function]
    fn paint(
        &mut self,
        _id: Option<&GlobalElementId>,
@@ -399,26 +443,31 @@ impl Element for TextElement {
            ElementInputHandler::new(bounds, self.input.clone()),
        );
        if let Some(selection) = prepaint.selection.take() {
+            profiling::scope!("paint_quad selection");
            cx.paint_quad(selection)
        }
        let line = prepaint.line.take().unwrap();
        line.paint(bounds.origin, cx.line_height(), cx).unwrap();

        if let Some(cursor) = prepaint.cursor.take() {
+            profiling::scope!("paint_quad cursor");
            cx.paint_quad(cursor);
        }
        self.input.update(cx, |input, _cx| {
            input.last_layout = Some(line);
+            input.last_bounds = Some(bounds);
        });
    }
 }

 impl Render for TextInput {
+    #[profiling::function]
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        div()
            .flex()
            .key_context("TextInput")
            .track_focus(&self.focus_handle)
+            .cursor(CursorStyle::IBeam)
            .on_action(cx.listener(Self::backspace))
            .on_action(cx.listener(Self::delete))
            .on_action(cx.listener(Self::left))
@@ -429,6 +478,10 @@ impl Render for TextInput {
            .on_action(cx.listener(Self::home))
            .on_action(cx.listener(Self::end))
            .on_action(cx.listener(Self::show_character_palette))
+            .on_mouse_down(MouseButton::Left, cx.listener(Self::on_mouse_down))
+            .on_mouse_up(MouseButton::Left, cx.listener(Self::on_mouse_up))
+            .on_mouse_up_out(MouseButton::Left, cx.listener(Self::on_mouse_up))
+            .on_mouse_move(cx.listener(Self::on_mouse_move))
            .bg(rgb(0xeeeeee))
            .size_full()
            .line_height(px(30.))
@@ -446,6 +499,74 @@ impl Render for TextInput {
    }
 }

+impl FocusableView for TextInput {
+    fn focus_handle(&self, _: &AppContext) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+struct InputExample {
+    text_input: View<TextInput>,
+    recent_keystrokes: Vec<Keystroke>,
+}
+
+impl InputExample {
+    fn on_reset_click(&mut self, _: &MouseUpEvent, cx: &mut ViewContext<Self>) {
+        self.recent_keystrokes.clear();
+        self.text_input
+            .update(cx, |text_input, _cx| text_input.reset());
+        cx.notify();
+    }
+}
+
+impl Render for InputExample {
+    #[profiling::function]
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let num_keystrokes = self.recent_keystrokes.len();
+        div()
+            .bg(rgb(0xaaaaaa))
+            .flex()
+            .flex_col()
+            .size_full()
+            .child(
+                div()
+                    .bg(white())
+                    .border_b_1()
+                    .border_color(black())
+                    .flex()
+                    .flex_row()
+                    .justify_between()
+                    .child(format!("Keystrokes: {}", num_keystrokes))
+                    .child(
+                        div()
+                            .border_1()
+                            .border_color(black())
+                            .px_2()
+                            .bg(yellow())
+                            .child("Reset")
+                            .hover(|style| {
+                                style
+                                    .bg(yellow().blend(opaque_grey(0.5, 0.5)))
+                                    .cursor_pointer()
+                            })
+                            .on_mouse_up(MouseButton::Left, cx.listener(Self::on_reset_click)),
+                    ),
+            )
+            .child(self.text_input.clone())
+            .children(self.recent_keystrokes.iter().rev().map(|ks| {
+                format!(
+                    "{:} {}",
+                    ks,
+                    if let Some(ime_key) = ks.ime_key.as_ref() {
+                        format!("-> {}", ime_key)
+                    } else {
+                        "".to_owned()
+                    }
+                )
+            }))
+    }
+}
+
 fn main() {
    App::new().run(|cx: &mut AppContext| {
        let bounds = Bounds::centered(None, size(px(300.0), px(300.0)), cx);
@@ -468,21 +589,36 @@ fn main() {
                    ..Default::default()
                },
                |cx| {
-                    cx.new_view(|cx| TextInput {
+                    let text_input = cx.new_view(|cx| TextInput {
                        focus_handle: cx.focus_handle(),
                        content: "".into(),
                        selected_range: 0..0,
                        selection_reversed: false,
                        marked_range: None,
                        last_layout: None,
+                        last_bounds: None,
+                        is_selecting: false,
+                    });
+                    cx.new_view(|_| InputExample {
+                        text_input,
+                        recent_keystrokes: vec![],
                    })
                },
            )
            .unwrap();
+        cx.observe_keystrokes(move |ev, cx| {
+            window
+                .update(cx, |view, cx| {
+                    view.recent_keystrokes.push(ev.keystroke.clone());
+                    cx.notify();
+                })
+                .unwrap();
+        })
+        .detach();
        window
            .update(cx, |view, cx| {
-                view.focus_handle.focus(cx);
-                cx.activate(true)
+                cx.focus_view(&view.text_input);
+                cx.activate(true);
            })
            .unwrap();
    });
--- a/crates/gpui/src/element.rs
+++ b/crates/gpui/src/element.rs
@@ -387,6 +387,7 @@ impl<E: Element> Drawable<E> {
        }
    }

+    #[profiling::function]
    pub(crate) fn layout_as_root(
        &mut self,
        available_space: Size<AvailableSpace>,
@@ -503,6 +504,7 @@ impl AnyElement {
    }

    /// Performs layout for this element within the given available space and returns its size.
+    #[profiling::function]
    pub fn layout_as_root(
        &mut self,
        available_space: Size<AvailableSpace>,
@@ -517,6 +519,7 @@ impl AnyElement {
    }

    /// Performs layout on this element in the available space, then prepaints it at the given absolute origin.
+    #[profiling::function]
    pub fn prepaint_as_root(
        &mut self,
        origin: Point<Pixels>,
@@ -524,7 +527,10 @@ impl AnyElement {
        cx: &mut WindowContext,
    ) {
        self.layout_as_root(available_space, cx);
-        cx.with_absolute_element_offset(origin, |cx| self.0.prepaint(cx));
+        cx.with_absolute_element_offset(origin, |cx| {
+            profiling::scope!("with_absolute_element_offset prepaint");
+            self.0.prepaint(cx)
+        });
    }
 }

--- a/crates/gpui/src/platform/blade/blade_renderer.rs
+++ b/crates/gpui/src/platform/blade/blade_renderer.rs
@@ -524,6 +524,7 @@ impl BladeRenderer {
        self.gpu.destroy_command_encoder(&mut self.command_encoder);
    }

+    #[profiling::function]
    pub fn draw(&mut self, scene: &Scene) {
        self.command_encoder.start();
        self.atlas.before_frame(&mut self.command_encoder);
--- a/crates/gpui/src/platform/linux/dispatcher.rs
+++ b/crates/gpui/src/platform/linux/dispatcher.rs
@@ -5,11 +5,9 @@ use calloop::{
    timer::TimeoutAction,
    EventLoop,
 };
-use mio::Waker;
 use parking::{Parker, Unparker};
 use parking_lot::Mutex;
 use std::{
-    sync::Arc,
    thread,
    time::{Duration, Instant},
 };
@@ -23,7 +21,6 @@ struct TimerAfter {
 pub(crate) struct LinuxDispatcher {
    parker: Mutex<Parker>,
    main_sender: Sender<Runnable>,
-    main_waker: Option<Arc<Waker>>,
    timer_sender: Sender<TimerAfter>,
    background_sender: flume::Sender<Runnable>,
    _background_threads: Vec<thread::JoinHandle<()>>,
@@ -31,7 +28,7 @@ pub(crate) struct LinuxDispatcher {
 }

 impl LinuxDispatcher {
-    pub fn new(main_sender: Sender<Runnable>, main_waker: Option<Arc<Waker>>) -> Self {
+    pub fn new(main_sender: Sender<Runnable>) -> Self {
        let (background_sender, background_receiver) = flume::unbounded::<Runnable>();
        let thread_count = std::thread::available_parallelism()
            .map(|i| i.get())
@@ -41,6 +38,8 @@ impl LinuxDispatcher {
            .map(|i| {
                let receiver = background_receiver.clone();
                std::thread::spawn(move || {
+                    let thread_name = format!("background-{}", i);
+                    profiling::register_thread!(&thread_name);
                    for runnable in receiver {
                        let start = Instant::now();

@@ -58,6 +57,8 @@ impl LinuxDispatcher {

        let (timer_sender, timer_channel) = calloop::channel::channel::<TimerAfter>();
        let timer_thread = std::thread::spawn(|| {
+            profiling::register_thread!("timer-thread");
+
            let mut event_loop: EventLoop<()> =
                EventLoop::try_new().expect("Failed to initialize timer loop!");

@@ -91,7 +92,6 @@ impl LinuxDispatcher {
        Self {
            parker: Mutex::new(Parker::new()),
            main_sender,
-            main_waker,
            timer_sender,
            background_sender,
            _background_threads: background_threads,
@@ -111,9 +111,6 @@ impl PlatformDispatcher for LinuxDispatcher {

    fn dispatch_on_main_thread(&self, runnable: Runnable) {
        self.main_sender.send(runnable).ok();
-        if let Some(main_waker) = self.main_waker.as_ref() {
-            main_waker.wake().ok();
-        }
    }

    fn dispatch_after(&self, duration: Duration, runnable: Runnable) {
--- a/crates/gpui/src/platform/linux/headless/client.rs
+++ b/crates/gpui/src/platform/linux/headless/client.rs
@@ -22,7 +22,7 @@ impl HeadlessClient {
    pub(crate) fn new() -> Self {
        let event_loop = EventLoop::try_new().unwrap();

-        let (common, main_receiver) = LinuxCommon::new(Box::new(event_loop.get_signal()), None);
+        let (common, main_receiver) = LinuxCommon::new(event_loop.get_signal());

        let handle = event_loop.handle();

@@ -81,6 +81,8 @@ impl LinuxClient for HeadlessClient {

    fn open_uri(&self, _uri: &str) {}

+    fn reveal_path(&self, _path: std::path::PathBuf) {}
+
    fn write_to_primary(&self, _item: crate::ClipboardItem) {}

    fn write_to_clipboard(&self, _item: crate::ClipboardItem) {}
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -7,7 +7,7 @@ use std::ffi::OsString;
 use std::fs::File;
 use std::io::Read;
 use std::ops::{Deref, DerefMut};
-use std::os::fd::{AsRawFd, FromRawFd};
+use std::os::fd::{AsFd, AsRawFd, FromRawFd};
 use std::panic::Location;
 use std::rc::Weak;
 use std::{
@@ -20,13 +20,14 @@ use std::{

 use anyhow::anyhow;
 use ashpd::desktop::file_chooser::{OpenFileRequest, SaveFileRequest};
+use ashpd::desktop::open_uri::{OpenDirectoryRequest, OpenFileRequest as OpenUriRequest};
+use ashpd::{url, ActivationToken};
 use async_task::Runnable;
 use calloop::channel::Channel;
 use calloop::{EventLoop, LoopHandle, LoopSignal};
 use filedescriptor::FileDescriptor;
 use flume::{Receiver, Sender};
 use futures::channel::oneshot;
-use mio::Waker;
 use parking_lot::Mutex;
 use time::UtcOffset;
 use util::ResultExt;
@@ -67,6 +68,7 @@ pub trait LinuxClient {
    ) -> anyhow::Result<Box<dyn PlatformWindow>>;
    fn set_cursor_style(&self, style: CursorStyle);
    fn open_uri(&self, uri: &str);
+    fn reveal_path(&self, path: PathBuf);
    fn write_to_primary(&self, item: ClipboardItem);
    fn write_to_clipboard(&self, item: ClipboardItem);
    fn read_from_primary(&self) -> Option<ClipboardItem>;
@@ -85,16 +87,6 @@ pub(crate) struct PlatformHandlers {
    pub(crate) validate_app_menu_command: Option<Box<dyn FnMut(&dyn Action) -> bool>>,
 }

-pub trait QuitSignal {
-    fn quit(&mut self);
-}
-
-impl QuitSignal for LoopSignal {
-    fn quit(&mut self) {
-        self.stop();
-    }
-}
-
 pub(crate) struct LinuxCommon {
    pub(crate) background_executor: BackgroundExecutor,
    pub(crate) foreground_executor: ForegroundExecutor,
@@ -102,20 +94,17 @@ pub(crate) struct LinuxCommon {
    pub(crate) appearance: WindowAppearance,
    pub(crate) auto_hide_scrollbars: bool,
    pub(crate) callbacks: PlatformHandlers,
-    pub(crate) quit_signal: Box<dyn QuitSignal>,
+    pub(crate) signal: LoopSignal,
    pub(crate) menus: Vec<OwnedMenu>,
 }

 impl LinuxCommon {
-    pub fn new(
-        quit_signal: Box<dyn QuitSignal>,
-        main_waker: Option<Arc<Waker>>,
-    ) -> (Self, Channel<Runnable>) {
+    pub fn new(signal: LoopSignal) -> (Self, Channel<Runnable>) {
        let (main_sender, main_receiver) = calloop::channel::channel::<Runnable>();
        let text_system = Arc::new(CosmicTextSystem::new());
        let callbacks = PlatformHandlers::default();

-        let dispatcher = Arc::new(LinuxDispatcher::new(main_sender.clone(), main_waker));
+        let dispatcher = Arc::new(LinuxDispatcher::new(main_sender.clone()));

        let background_executor = BackgroundExecutor::new(dispatcher.clone());

@@ -126,7 +115,7 @@ impl LinuxCommon {
            appearance: WindowAppearance::Light,
            auto_hide_scrollbars: false,
            callbacks,
-            quit_signal,
+            signal,
            menus: Vec::new(),
        };

@@ -160,7 +149,7 @@ impl<P: LinuxClient + 'static> Platform for P {
    }

    fn quit(&self) {
-        self.with_common(|common| common.quit_signal.quit());
+        self.with_common(|common| common.signal.stop());
    }

    fn compositor_name(&self) -> &'static str {
@@ -344,13 +333,7 @@ impl<P: LinuxClient + 'static> Platform for P {
    }

    fn reveal_path(&self, path: &Path) {
-        if path.is_dir() {
-            open::that_detached(path);
-            return;
-        }
-        // If `path` is a file, the system may try to open it in a text editor
-        let dir = path.parent().unwrap_or(Path::new(""));
-        open::that_detached(dir);
+        self.reveal_path(path.to_owned());
    }

    fn on_quit(&self, callback: Box<dyn FnMut()>) {
@@ -511,18 +494,40 @@ impl<P: LinuxClient + 'static> Platform for P {
    fn add_recent_document(&self, _path: &Path) {}
 }

-pub(super) fn open_uri_internal(uri: &str, activation_token: Option<&str>) {
-    let mut last_err = None;
-    for mut command in open::commands(uri) {
-        if let Some(token) = activation_token {
-            command.env("XDG_ACTIVATION_TOKEN", token);
-        }
-        match command.spawn() {
-            Ok(_) => return,
-            Err(err) => last_err = Some(err),
-        }
+pub(super) fn open_uri_internal(
+    executor: BackgroundExecutor,
+    uri: &str,
+    activation_token: Option<String>,
+) {
+    if let Some(uri) = url::Url::parse(uri).log_err() {
+        executor
+            .spawn(async move {
+                OpenUriRequest::default()
+                    .activation_token(activation_token.map(ActivationToken::from))
+                    .send_uri(&uri)
+                    .await
+                    .log_err();
+            })
+            .detach();
    }
-    log::error!("failed to open uri: {uri:?}, last error: {last_err:?}");
+}
+
+pub(super) fn reveal_path_internal(
+    executor: BackgroundExecutor,
+    path: PathBuf,
+    activation_token: Option<String>,
+) {
+    executor
+        .spawn(async move {
+            if let Some(dir) = File::open(path).log_err() {
+                OpenDirectoryRequest::default()
+                    .activation_token(activation_token.map(ActivationToken::from))
+                    .send(&dir.as_fd())
+                    .await
+                    .log_err();
+            }
+        })
+        .detach();
 }

 pub(super) fn is_within_click_distance(a: Point<Pixels>, b: Point<Pixels>) -> bool {
@@ -635,6 +640,8 @@ impl Keystroke {
            Keysym::Prior => "pageup".to_owned(),
            Keysym::Next => "pagedown".to_owned(),
            Keysym::ISO_Left_Tab => "tab".to_owned(),
+            Keysym::KP_Prior => "pageup".to_owned(),
+            Keysym::KP_Next => "pagedown".to_owned(),

            Keysym::comma => ",".to_owned(),
            Keysym::period => ".".to_owned(),
@@ -672,7 +679,14 @@ impl Keystroke {
            Keysym::equal => "=".to_owned(),
            Keysym::plus => "+".to_owned(),

-            _ => xkb::keysym_get_name(key_sym).to_lowercase(),
+            _ => {
+                let name = xkb::keysym_get_name(key_sym).to_lowercase();
+                if key_sym.is_keypad_key() {
+                    name.replace("kp_", "")
+                } else {
+                    name
+                }
+            }
        };

        if modifiers.shift {
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -61,7 +61,6 @@ use wayland_protocols_plasma::blur::client::{org_kde_kwin_blur, org_kde_kwin_blu
 use xkbcommon::xkb::ffi::XKB_KEYMAP_FORMAT_TEXT_V1;
 use xkbcommon::xkb::{self, Keycode, KEYMAP_COMPILE_NO_FLAGS};

-use super::super::{open_uri_internal, read_fd, DOUBLE_CLICK_INTERVAL};
 use super::display::WaylandDisplay;
 use super::window::{ImeInput, WaylandWindowStatePtr};
 use crate::platform::linux::wayland::clipboard::{
@@ -72,11 +71,14 @@ use crate::platform::linux::wayland::serial::{SerialKind, SerialTracker};
 use crate::platform::linux::wayland::window::WaylandWindow;
 use crate::platform::linux::xdg_desktop_portal::{Event as XDPEvent, XDPEventSource};
 use crate::platform::linux::LinuxClient;
-use crate::platform::linux::{get_xkb_compose_state, is_within_click_distance};
+use crate::platform::linux::{
+    get_xkb_compose_state, is_within_click_distance, open_uri_internal, read_fd,
+    reveal_path_internal,
+};
 use crate::platform::PlatformWindow;
 use crate::{
    point, px, size, Bounds, DevicePixels, FileDropEvent, ForegroundExecutor, MouseExitEvent, Size,
-    SCROLL_LINES,
+    DOUBLE_CLICK_INTERVAL, SCROLL_LINES,
 };
 use crate::{
    AnyWindowHandle, CursorStyle, DisplayId, KeyDownEvent, KeyUpEvent, Keystroke, Modifiers,
@@ -220,7 +222,7 @@ pub(crate) struct WaylandClientState {
    data_offers: Vec<DataOffer<WlDataOffer>>,
    primary_data_offer: Option<DataOffer<ZwpPrimarySelectionOfferV1>>,
    cursor: Cursor,
-    pending_open_uri: Option<String>,
+    pending_activation: Option<PendingActivation>,
    event_loop: Option<EventLoop<'static, WaylandClientStatePtr>>,
    common: LinuxCommon,
 }
@@ -244,6 +246,15 @@ pub(crate) struct KeyRepeat {
    current_keycode: Option<xkb::Keycode>,
 }

+pub(crate) enum PendingActivation {
+    /// URI to open in the web browser.
+    Uri(String),
+    /// Path to open in the file explorer.
+    Path(PathBuf),
+    /// A window from ourselves to raise.
+    Window(ObjectId),
+}
+
 /// This struct is required to conform to Rust's orphan rules, so we can dispatch on the state but hand the
 /// window to GPUI.
 #[derive(Clone)]
@@ -260,6 +271,11 @@ impl WaylandClientStatePtr {
        self.0.upgrade().unwrap().borrow().serial_tracker.get(kind)
    }

+    pub fn set_pending_activation(&self, window: ObjectId) {
+        self.0.upgrade().unwrap().borrow_mut().pending_activation =
+            Some(PendingActivation::Window(window));
+    }
+
    pub fn enable_ime(&self) {
        let client = self.get_client();
        let mut state = client.borrow_mut();
@@ -310,7 +326,7 @@ impl WaylandClientStatePtr {
            }
        }
        if state.windows.is_empty() {
-            state.common.quit_signal.quit();
+            state.common.signal.stop();
        }
    }
 }
@@ -406,7 +422,7 @@ impl WaylandClient {

        let event_loop = EventLoop::<WaylandClientStatePtr>::try_new().unwrap();

-        let (common, main_receiver) = LinuxCommon::new(Box::new(event_loop.get_signal()), None);
+        let (common, main_receiver) = LinuxCommon::new(event_loop.get_signal());

        let handle = event_loop.handle();
        handle
@@ -443,7 +459,7 @@ impl WaylandClient {
        let mut cursor = Cursor::new(&conn, &globals, 24);

        handle
-            .insert_source(XDPEventSource::new(&common.background_executor, None), {
+            .insert_source(XDPEventSource::new(&common.background_executor), {
                move |event, _, client| match event {
                    XDPEvent::WindowAppearance(appearance) => {
                        if let Some(client) = client.0.upgrade() {
@@ -530,7 +546,7 @@ impl WaylandClient {
            data_offers: Vec::new(),
            primary_data_offer: None,
            cursor,
-            pending_open_uri: None,
+            pending_activation: None,
            event_loop: Some(event_loop),
        }));

@@ -629,14 +645,33 @@ impl LinuxClient for WaylandClient {
            state.globals.activation.clone(),
            state.mouse_focused_window.clone(),
        ) {
-            state.pending_open_uri = Some(uri.to_owned());
+            state.pending_activation = Some(PendingActivation::Uri(uri.to_string()));
            let token = activation.get_activation_token(&state.globals.qh, ());
            let serial = state.serial_tracker.get(SerialKind::MousePress);
            token.set_serial(serial, &state.wl_seat);
            token.set_surface(&window.surface());
            token.commit();
        } else {
-            open_uri_internal(uri, None);
+            let executor = state.common.background_executor.clone();
+            open_uri_internal(executor, uri, None);
+        }
+    }
+
+    fn reveal_path(&self, path: PathBuf) {
+        let mut state = self.0.borrow_mut();
+        if let (Some(activation), Some(window)) = (
+            state.globals.activation.clone(),
+            state.mouse_focused_window.clone(),
+        ) {
+            state.pending_activation = Some(PendingActivation::Path(path));
+            let token = activation.get_activation_token(&state.globals.qh, ());
+            let serial = state.serial_tracker.get(SerialKind::MousePress);
+            token.set_serial(serial, &state.wl_seat);
+            token.set_surface(&window.surface());
+            token.commit();
+        } else {
+            let executor = state.common.background_executor.clone();
+            reveal_path_internal(executor, path, None);
        }
    }

@@ -954,13 +989,25 @@ impl Dispatch<xdg_activation_token_v1::XdgActivationTokenV1, ()> for WaylandClie
    ) {
        let client = this.get_client();
        let mut state = client.borrow_mut();
+
        if let xdg_activation_token_v1::Event::Done { token } = event {
-            if let Some(uri) = state.pending_open_uri.take() {
-                open_uri_internal(&uri, Some(&token));
-            } else {
-                log::error!("called while pending_open_uri is None");
+            let executor = state.common.background_executor.clone();
+            match state.pending_activation.take() {
+                Some(PendingActivation::Uri(uri)) => open_uri_internal(executor, &uri, Some(token)),
+                Some(PendingActivation::Path(path)) => {
+                    reveal_path_internal(executor, path, Some(token))
+                }
+                Some(PendingActivation::Window(window)) => {
+                    let Some(window) = get_window(&mut state, &window) else {
+                        return;
+                    };
+                    let activation = state.globals.activation.as_ref().unwrap();
+                    activation.activate(token, &window.surface());
+                }
+                None => log::error!("activation token received with no pending activation"),
            }
        }
+
        token.destroy();
    }
 }
--- a/crates/gpui/src/platform/linux/wayland/window.rs
+++ b/crates/gpui/src/platform/linux/wayland/window.rs
@@ -76,6 +76,7 @@ pub struct WaylandWindowState {
    acknowledged_first_configure: bool,
    pub surface: wl_surface::WlSurface,
    decoration: Option<zxdg_toplevel_decoration_v1::ZxdgToplevelDecorationV1>,
+    app_id: Option<String>,
    appearance: WindowAppearance,
    blur: Option<org_kde_kwin_blur::OrgKdeKwinBlur>,
    toplevel: xdg_toplevel::XdgToplevel,
@@ -158,6 +159,7 @@ impl WaylandWindowState {
            acknowledged_first_configure: false,
            surface,
            decoration,
+            app_id: None,
            blur: None,
            toplevel,
            viewport,
@@ -823,7 +825,20 @@ impl PlatformWindow for WaylandWindow {
    }

    fn activate(&self) {
-        log::info!("Wayland does not support this API");
+        // Try to request an activation token. Even though the activation is likely going to be rejected,
+        // KWin and Mutter can use the app_id to visually indicate we're requesting attention.
+        let state = self.borrow();
+        if let (Some(activation), Some(app_id)) = (&state.globals.activation, state.app_id.clone())
+        {
+            state.client.set_pending_activation(state.surface.id());
+            let token = activation.get_activation_token(&state.globals.qh, ());
+            // The serial isn't exactly important here, since the activation is probably going to be rejected anyway.
+            let serial = state.client.get_serial(SerialKind::MousePress);
+            token.set_app_id(app_id);
+            token.set_serial(serial, &state.globals.seat);
+            token.set_surface(&state.surface);
+            token.commit();
+        }
    }

    fn is_active(&self) -> bool {
@@ -835,7 +850,9 @@ impl PlatformWindow for WaylandWindow {
    }

    fn set_app_id(&mut self, app_id: &str) {
-        self.borrow().toplevel.set_app_id(app_id.to_owned());
+        let mut state = self.borrow_mut();
+        state.toplevel.set_app_id(app_id.to_owned());
+        state.app_id = Some(app_id.to_owned());
    }

    fn set_background_appearance(&self, background_appearance: WindowBackgroundAppearance) {
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -1,26 +1,23 @@
 use std::cell::RefCell;
 use std::collections::HashSet;
 use std::ops::Deref;
-use std::os::fd::AsRawFd;
+use std::path::PathBuf;
 use std::rc::{Rc, Weak};
-use std::sync::Arc;
 use std::time::{Duration, Instant};

-use anyhow::Context;
-use async_task::Runnable;
-use calloop::channel::Channel;
+use calloop::generic::{FdWrapper, Generic};
+use calloop::{EventLoop, LoopHandle, RegistrationToken};

 use collections::HashMap;
-
-use futures::channel::oneshot;
-use mio::{Interest, Token, Waker};
 use util::ResultExt;
+
 use x11rb::connection::{Connection, RequestConnection};
 use x11rb::cursor;
 use x11rb::errors::ConnectionError;
+use x11rb::protocol::randr::ConnectionExt as _;
 use x11rb::protocol::xinput::ConnectionExt;
 use x11rb::protocol::xkb::ConnectionExt as _;
-use x11rb::protocol::xproto::{ChangeWindowAttributesAux, ConnectionExt as _};
+use x11rb::protocol::xproto::{ChangeWindowAttributesAux, ConnectionExt as _, KeyPressEvent};
 use x11rb::protocol::{randr, render, xinput, xkb, xproto, Event};
 use x11rb::resource_manager::Database;
 use x11rb::xcb_ffi::XCBConnection;
@@ -33,24 +30,24 @@ use crate::platform::linux::LinuxClient;
 use crate::platform::{LinuxCommon, PlatformWindow};
 use crate::{
    modifiers_from_xinput_info, point, px, AnyWindowHandle, Bounds, ClipboardItem, CursorStyle,
-    DisplayId, Keystroke, Modifiers, ModifiersChangedEvent, Pixels, PlatformDisplay, PlatformInput,
-    Point, QuitSignal, ScrollDelta, Size, TouchPhase, WindowParams, X11Window,
+    DisplayId, Keystroke, Modifiers, ModifiersChangedEvent, Pixels, Platform, PlatformDisplay,
+    PlatformInput, Point, ScrollDelta, Size, TouchPhase, WindowParams, X11Window,
 };

-use super::{
-    super::{get_xkb_compose_state, open_uri_internal, SCROLL_LINES},
-    X11Display, X11WindowStatePtr, XcbAtoms,
-};
 use super::{button_of_key, modifiers_from_state, pressed_button_from_mask};
+use super::{X11Display, X11WindowStatePtr, XcbAtoms};
 use super::{XimCallbackEvent, XimHandler};
-use crate::platform::linux::is_within_click_distance;
-use crate::platform::linux::platform::DOUBLE_CLICK_INTERVAL;
+use crate::platform::linux::platform::{DOUBLE_CLICK_INTERVAL, SCROLL_LINES};
 use crate::platform::linux::xdg_desktop_portal::{Event as XDPEvent, XDPEventSource};
+use crate::platform::linux::{
+    get_xkb_compose_state, is_within_click_distance, open_uri_internal, reveal_path_internal,
+};

 pub(super) const XINPUT_MASTER_DEVICE: u16 = 1;

 pub(crate) struct WindowRef {
    window: X11WindowStatePtr,
+    refresh_event_token: RegistrationToken,
 }

 impl WindowRef {
@@ -98,20 +95,17 @@ impl From<xim::ClientError> for EventHandlerError {
 }

 pub struct X11ClientState {
-    /// poll is in an Option so we can take it out in `run()` without
-    /// mutating self.
-    poll: Option<mio::Poll>,
-    quit_signal_rx: oneshot::Receiver<()>,
-    runnables: Channel<Runnable>,
-    xdp_event_source: XDPEventSource,
-    last_emptied_runnables: Instant,
+    pub(crate) loop_handle: LoopHandle<'static, X11Client>,
+    pub(crate) event_loop: Option<calloop::EventLoop<'static, X11Client>>,

    pub(crate) last_click: Instant,
    pub(crate) last_location: Point<Pixels>,
    pub(crate) current_count: usize,

    pub(crate) scale_factor: f32,
+
    pub(crate) xcb_connection: Rc<XCBConnection>,
+    client_side_decorations_supported: bool,
    pub(crate) x_root_index: usize,
    pub(crate) _resource_database: Database,
    pub(crate) atoms: XcbAtoms,
@@ -125,6 +119,7 @@ pub struct X11ClientState {
    pub(crate) compose_state: Option<xkbc::compose::State>,
    pub(crate) pre_edit_text: Option<String>,
    pub(crate) composing: bool,
+    pub(crate) pre_ime_key_down: Option<Keystroke>,
    pub(crate) cursor_handle: cursor::Handle,
    pub(crate) cursor_styles: HashMap<xproto::Window, CursorStyle>,
    pub(crate) cursor_cache: HashMap<CursorStyle, xproto::Cursor>,
@@ -146,46 +141,14 @@ impl X11ClientStatePtr {
        let client = X11Client(self.0.upgrade().expect("client already dropped"));
        let mut state = client.0.borrow_mut();

-        if state.windows.remove(&x_window).is_none() {
-            log::warn!(
-                "failed to remove X window {} from client state, does not exist",
-                x_window
-            );
+        if let Some(window_ref) = state.windows.remove(&x_window) {
+            state.loop_handle.remove(window_ref.refresh_event_token);
        }

        state.cursor_styles.remove(&x_window);

        if state.windows.is_empty() {
-            state.common.quit_signal.quit();
-        }
-    }
-}
-
-struct ChannelQuitSignal {
-    tx: Option<oneshot::Sender<()>>,
-    waker: Option<Arc<Waker>>,
-}
-
-impl ChannelQuitSignal {
-    fn new(waker: Option<Arc<Waker>>) -> (Self, oneshot::Receiver<()>) {
-        let (tx, rx) = oneshot::channel::<()>();
-
-        let quit_signal = ChannelQuitSignal {
-            tx: Some(tx),
-            waker,
-        };
-
-        (quit_signal, rx)
-    }
-}
-
-impl QuitSignal for ChannelQuitSignal {
-    fn quit(&mut self) {
-        if let Some(tx) = self.tx.take() {
-            tx.send(()).log_err();
-            if let Some(waker) = self.waker.as_ref() {
-                waker.wake().ok();
-            }
+            state.common.signal.stop();
        }
    }
 }
@@ -195,12 +158,27 @@ pub(crate) struct X11Client(Rc<RefCell<X11ClientState>>);

 impl X11Client {
    pub(crate) fn new() -> Self {
-        let mut poll = mio::Poll::new().unwrap();
+        let event_loop = EventLoop::try_new().unwrap();

-        let waker = Arc::new(Waker::new(poll.registry(), WAKER_TOKEN).unwrap());
+        let (common, main_receiver) = LinuxCommon::new(event_loop.get_signal());

-        let (quit_signal, quit_signal_rx) = ChannelQuitSignal::new(Some(waker.clone()));
-        let (common, runnables) = LinuxCommon::new(Box::new(quit_signal), Some(waker.clone()));
+        let handle = event_loop.handle();
+
+        handle
+            .insert_source(main_receiver, {
+                let handle = handle.clone();
+                move |event, _, _: &mut X11Client| {
+                    if let calloop::channel::Event::Msg(runnable) = event {
+                        // Insert the runnables as idle callbacks, so we make sure that user-input and X11
+                        // events have higher priority and runnables are only worked off after the event
+                        // callbacks.
+                        handle.insert_idle(|_| {
+                            runnable.run();
+                        });
+                    }
+                }
+            })
+            .unwrap();

        let (xcb_connection, x_root_index) = XCBConnection::connect(None).unwrap();
        xcb_connection
@@ -242,13 +220,25 @@ impl X11Client {
            .map(|class| *class)
            .collect::<Vec<_>>();

-        let atoms = XcbAtoms::new(&xcb_connection).unwrap();
+        let atoms = XcbAtoms::new(&xcb_connection).unwrap().reply().unwrap();
+
+        let root = xcb_connection.setup().roots[0].root;
+        let compositor_present = check_compositor_present(&xcb_connection, root);
+        let gtk_frame_extents_supported =
+            check_gtk_frame_extents_supported(&xcb_connection, &atoms, root);
+        let client_side_decorations_supported = compositor_present && gtk_frame_extents_supported;
+        log::info!(
+            "x11: compositor present: {}, gtk_frame_extents_supported: {}",
+            compositor_present,
+            gtk_frame_extents_supported
+        );
+
        let xkb = xcb_connection
            .xkb_use_extension(XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION)
+            .unwrap()
+            .reply()
            .unwrap();

-        let atoms = atoms.reply().unwrap();
-        let xkb = xkb.reply().unwrap();
        let events = xkb::EventType::STATE_NOTIFY;
        xcb_connection
            .xkb_select_events(
@@ -299,25 +289,54 @@ impl X11Client {
            None
        };

-        let xdp_event_source =
-            XDPEventSource::new(&common.background_executor, Some(waker.clone()));
+        // Safety: Safe if xcb::Connection always returns a valid fd
+        let fd = unsafe { FdWrapper::new(Rc::clone(&xcb_connection)) };
+
+        handle
+            .insert_source(
+                Generic::new_with_error::<EventHandlerError>(
+                    fd,
+                    calloop::Interest::READ,
+                    calloop::Mode::Level,
+                ),
+                {
+                    let xcb_connection = xcb_connection.clone();
+                    move |_readiness, _, client| {
+                        client.process_x11_events(&xcb_connection)?;
+                        Ok(calloop::PostAction::Continue)
+                    }
+                },
+            )
+            .expect("Failed to initialize x11 event source");
+
+        handle
+            .insert_source(XDPEventSource::new(&common.background_executor), {
+                move |event, _, client| match event {
+                    XDPEvent::WindowAppearance(appearance) => {
+                        client.with_common(|common| common.appearance = appearance);
+                        for (_, window) in &mut client.0.borrow_mut().windows {
+                            window.window.set_appearance(appearance);
+                        }
+                    }
+                    XDPEvent::CursorTheme(_) | XDPEvent::CursorSize(_) => {
+                        // noop, X11 manages this for us.
+                    }
+                }
+            })
+            .unwrap();

        X11Client(Rc::new(RefCell::new(X11ClientState {
-            poll: Some(poll),
-            runnables,
-
-            xdp_event_source,
-            quit_signal_rx,
-            common,
-
            modifiers: Modifiers::default(),
+            event_loop: Some(event_loop),
+            loop_handle: handle,
+            common,
            last_click: Instant::now(),
-            last_emptied_runnables: Instant::now(),
            last_location: Point::new(px(0.0), px(0.0)),
            current_count: 0,
            scale_factor,

            xcb_connection,
+            client_side_decorations_supported,
            x_root_index,
            _resource_database: resource_database,
            atoms,
@@ -329,6 +348,7 @@ impl X11Client {

            compose_state,
            pre_edit_text: None,
+            pre_ime_key_down: None,
            composing: false,

            cursor_handle,
@@ -344,6 +364,125 @@ impl X11Client {
        })))
    }

+    pub fn process_x11_events(
+        &self,
+        xcb_connection: &XCBConnection,
+    ) -> Result<(), EventHandlerError> {
+        loop {
+            let mut events = Vec::new();
+            let mut windows_to_refresh = HashSet::new();
+
+            let mut last_key_release = None;
+            let mut last_key_press: Option<KeyPressEvent> = None;
+
+            loop {
+                match xcb_connection.poll_for_event() {
+                    Ok(Some(event)) => {
+                        match event {
+                            Event::Expose(expose_event) => {
+                                windows_to_refresh.insert(expose_event.window);
+                            }
+                            Event::KeyRelease(_) => {
+                                last_key_release = Some(event);
+                            }
+                            Event::KeyPress(key_press) => {
+                                if let Some(last_press) = last_key_press.as_ref() {
+                                    if last_press.detail == key_press.detail {
+                                        continue;
+                                    }
+                                }
+
+                                if let Some(Event::KeyRelease(key_release)) =
+                                    last_key_release.take()
+                                {
+                                    // We ignore that last KeyRelease if it's too close to this KeyPress,
+                                    // suggesting that it's auto-generated by X11 as a key-repeat event.
+                                    if key_release.detail != key_press.detail
+                                        || key_press.time.saturating_sub(key_release.time) > 20
+                                    {
+                                        events.push(Event::KeyRelease(key_release));
+                                    }
+                                }
+                                events.push(Event::KeyPress(key_press));
+                                last_key_press = Some(key_press);
+                            }
+                            _ => {
+                                if let Some(release_event) = last_key_release.take() {
+                                    events.push(release_event);
+                                }
+                                events.push(event);
+                            }
+                        }
+                    }
+                    Ok(None) => {
+                        // Add any remaining stored KeyRelease event
+                        if let Some(release_event) = last_key_release.take() {
+                            events.push(release_event);
+                        }
+                        break;
+                    }
+                    Err(e) => {
+                        log::warn!("error polling for X11 events: {e:?}");
+                        break;
+                    }
+                }
+            }
+
+            if events.is_empty() && windows_to_refresh.is_empty() {
+                break;
+            }
+
+            for window in windows_to_refresh.into_iter() {
+                if let Some(window) = self.get_window(window) {
+                    window.refresh();
+                }
+            }
+
+            for event in events.into_iter() {
+                let mut state = self.0.borrow_mut();
+                if state.ximc.is_none() || state.xim_handler.is_none() {
+                    drop(state);
+                    self.handle_event(event);
+                    continue;
+                }
+
+                let mut ximc = state.ximc.take().unwrap();
+                let mut xim_handler = state.xim_handler.take().unwrap();
+                let xim_connected = xim_handler.connected;
+                drop(state);
+
+                let xim_filtered = match ximc.filter_event(&event, &mut xim_handler) {
+                    Ok(handled) => handled,
+                    Err(err) => {
+                        log::error!("XIMClientError: {}", err);
+                        false
+                    }
+                };
+                let xim_callback_event = xim_handler.last_callback_event.take();
+
+                let mut state = self.0.borrow_mut();
+                state.ximc = Some(ximc);
+                state.xim_handler = Some(xim_handler);
+                drop(state);
+
+                if let Some(event) = xim_callback_event {
+                    self.handle_xim_callback_event(event);
+                }
+
+                if xim_filtered {
+                    continue;
+                }
+
+                if xim_connected {
+                    self.xim_handle_event(event);
+                } else {
+                    self.handle_event(event);
+                }
+            }
+        }
+        Ok(())
+    }
+
    pub fn enable_ime(&self) {
        let mut state = self.0.borrow_mut();
        if state.ximc.is_none() {
@@ -406,117 +545,6 @@ impl X11Client {
            .map(|window_reference| window_reference.window.clone())
    }

-    fn read_x11_events(&self) -> (HashSet<u32>, Vec<Event>) {
-        let mut events = Vec::new();
-        let mut windows_to_refresh = HashSet::new();
-        let mut state = self.0.borrow_mut();
-
-        let mut last_key_release: Option<Event> = None;
-
-        loop {
-            match state.xcb_connection.poll_for_event() {
-                Ok(Some(event)) => {
-                    if let Event::Expose(expose_event) = event {
-                        windows_to_refresh.insert(expose_event.window);
-                    } else {
-                        match event {
-                            Event::KeyRelease(_) => {
-                                last_key_release = Some(event);
-                            }
-                            Event::KeyPress(key_press) => {
-                                if let Some(Event::KeyRelease(key_release)) =
-                                    last_key_release.take()
-                                {
-                                    // We ignore that last KeyRelease if it's too close to this KeyPress,
-                                    // suggesting that it's auto-generated by X11 as a key-repeat event.
-                                    if key_release.detail != key_press.detail
-                                        || key_press.time.wrapping_sub(key_release.time) > 20
-                                    {
-                                        events.push(Event::KeyRelease(key_release));
-                                    }
-                                }
-                                events.push(Event::KeyPress(key_press));
-                            }
-                            _ => {
-                                if let Some(release_event) = last_key_release.take() {
-                                    events.push(release_event);
-                                }
-                                events.push(event);
-                            }
-                        }
-                    }
-                }
-                Ok(None) => {
-                    // Add any remaining stored KeyRelease event
-                    if let Some(release_event) = last_key_release.take() {
-                        events.push(release_event);
-                    }
-                    break;
-                }
-                Err(e) => {
-                    log::warn!("error polling for X11 events: {e:?}");
-                    break;
-                }
-            }
-        }
-
-        (windows_to_refresh, events)
-    }
-
-    fn process_x11_events(&self, events: Vec<Event>) {
-        log::trace!(
-            "main thread: processing X11 events. events: {}",
-            events.len()
-        );
-
-        for event in events.into_iter() {
-            log::trace!("main thread: processing X11 event: {:?}", event);
-
-            let mut state = self.0.borrow_mut();
-            if state.ximc.is_none() || state.xim_handler.is_none() {
-                drop(state);
-                self.handle_event(event);
-                continue;
-            }
-
-            let mut ximc = state.ximc.take().unwrap();
-            let mut xim_handler = state.xim_handler.take().unwrap();
-            let xim_connected = xim_handler.connected;
-            drop(state);
-
-            // let xim_filtered = false;
-            let xim_filtered = match ximc.filter_event(&event, &mut xim_handler) {
-                Ok(handled) => handled,
-                Err(err) => {
-                    log::error!("XIMClientError: {}", err);
-                    false
-                }
-            };
-            let xim_callback_event = xim_handler.last_callback_event.take();
-
-            let mut state = self.0.borrow_mut();
-            state.ximc = Some(ximc);
-            state.xim_handler = Some(xim_handler);
-
-            if let Some(event) = xim_callback_event {
-                drop(state);
-                self.handle_xim_callback_event(event);
-            } else {
-                drop(state);
-            }
-
-            if xim_filtered {
-                continue;
-            }
-
-            if xim_connected {
-                self.xim_handle_event(event);
-            } else {
-                self.handle_event(event);
-            }
-        }
-    }
-
    fn handle_event(&self, event: Event) -> Option<()> {
        match event {
            Event::ClientMessage(event) => {
@@ -556,10 +584,6 @@ impl X11Client {
                let window = self.get_window(event.window)?;
                window.property_notify(event);
            }
-            Event::Expose(event) => {
-                let window = self.get_window(event.window)?;
-                window.refresh();
-            }
            Event::FocusIn(event) => {
                let window = self.get_window(event.event)?;
                window.set_focused(true);
@@ -612,6 +636,7 @@ impl X11Client {

                let modifiers = modifiers_from_state(event.state);
                state.modifiers = modifiers;
+                state.pre_ime_key_down.take();

                let keystroke = {
                    let code = event.detail.into();
@@ -891,6 +916,11 @@ impl X11Client {
        match event {
            Event::KeyPress(event) | Event::KeyRelease(event) => {
                let mut state = self.0.borrow_mut();
+                state.pre_ime_key_down = Some(Keystroke::from_xkb(
+                    &state.xkb,
+                    state.modifiers,
+                    event.detail.into(),
+                ));
                let mut ximc = state.ximc.take().unwrap();
                let mut xim_handler = state.xim_handler.take().unwrap();
                drop(state);
@@ -917,6 +947,16 @@ impl X11Client {
    fn xim_handle_commit(&self, window: xproto::Window, text: String) -> Option<()> {
        let window = self.get_window(window).unwrap();
        let mut state = self.0.borrow_mut();
+        if !state.composing {
+            if let Some(keystroke) = state.pre_ime_key_down.take() {
+                drop(state);
+                window.handle_input(PlatformInput::KeyDown(crate::KeyDownEvent {
+                    keystroke,
+                    is_held: false,
+                }));
+                return Some(());
+            }
+        }
        state.composing = false;
        drop(state);

@@ -966,13 +1006,11 @@ impl X11Client {
    }
 }

-const XCB_CONNECTION_TOKEN: Token = Token(0);
-const WAKER_TOKEN: Token = Token(1);
-
 impl LinuxClient for X11Client {
    fn compositor_name(&self) -> &'static str {
        "X11"
    }
+
    fn with_common<R>(&self, f: impl FnOnce(&mut LinuxCommon) -> R) -> R {
        f(&mut self.0.borrow_mut().common)
    }
@@ -1031,6 +1069,7 @@ impl LinuxClient for X11Client {
            state.common.foreground_executor.clone(),
            params,
            &state.xcb_connection,
+            state.client_side_decorations_supported,
            state.x_root_index,
            x_window,
            &state.atoms,
@@ -1038,8 +1077,61 @@ impl LinuxClient for X11Client {
            state.common.appearance,
        )?;

+        let screen_resources = state
+            .xcb_connection
+            .randr_get_screen_resources(x_window)
+            .unwrap()
+            .reply()
+            .expect("Could not find available screens");
+
+        let mode = screen_resources
+            .crtcs
+            .iter()
+            .find_map(|crtc| {
+                let crtc_info = state
+                    .xcb_connection
+                    .randr_get_crtc_info(*crtc, x11rb::CURRENT_TIME)
+                    .ok()?
+                    .reply()
+                    .ok()?;
+
+                screen_resources
+                    .modes
+                    .iter()
+                    .find(|m| m.id == crtc_info.mode)
+            })
+            .expect("Unable to find screen refresh rate");
+
+        let refresh_event_token = state
+            .loop_handle
+            .insert_source(calloop::timer::Timer::immediate(), {
+                let refresh_duration = mode_refresh_rate(mode);
+                move |mut instant, (), client| {
+                    let xcb_connection = {
+                        let state = client.0.borrow_mut();
+                        let xcb_connection = state.xcb_connection.clone();
+                        if let Some(window) = state.windows.get(&x_window) {
+                            let window = window.window.clone();
+                            drop(state);
+                            window.refresh();
+                        }
+                        xcb_connection
+                    };
+                    client.process_x11_events(&xcb_connection).log_err();
+
+                    // Take into account that some frames have been skipped
+                    let now = Instant::now();
+                    while instant < now {
+                        instant += refresh_duration;
+                    }
+                    calloop::timer::TimeoutAction::ToInstant(instant)
+                }
+            })
+            .expect("Failed to initialize refresh timer");
+
        let window_ref = WindowRef {
            window: window.0.clone(),
+            refresh_event_token,
        };

        state.windows.insert(x_window, window_ref);
@@ -1087,7 +1179,11 @@ impl LinuxClient for X11Client {
    }

    fn open_uri(&self, uri: &str) {
-        open_uri_internal(uri, None);
+        open_uri_internal(self.background_executor(), uri, None);
+    }
+
+    fn reveal_path(&self, path: PathBuf) {
+        reveal_path_internal(self.background_executor(), path, None);
    }

    fn write_to_primary(&self, item: crate::ClipboardItem) {
@@ -1164,140 +1260,14 @@ impl LinuxClient for X11Client {
    }

    fn run(&self) {
-        let mut poll = self
+        let mut event_loop = self
            .0
            .borrow_mut()
-            .poll
+            .event_loop
            .take()
-            .context("no poll set on X11Client. calling run more than once is not possible")
-            .unwrap();
+            .expect("App is already running");

-        let xcb_fd = self.0.borrow().xcb_connection.as_raw_fd();
-        let mut xcb_source = mio::unix::SourceFd(&xcb_fd);
-        poll.registry()
-            .register(&mut xcb_source, XCB_CONNECTION_TOKEN, Interest::READABLE)
-            .unwrap();
-
-        let mut events = mio::Events::with_capacity(1024);
-        let mut next_refresh_needed = Instant::now();
-
-        'run_loop: loop {
-            let poll_timeout = next_refresh_needed - Instant::now();
-            // We rounding the poll_timeout down so `mio` doesn't round it up to the next higher milliseconds
-            let poll_timeout = Duration::from_millis(poll_timeout.as_millis() as u64);
-
-            if poll_timeout >= Duration::from_millis(1) {
-                let _ = poll.poll(&mut events, Some(poll_timeout));
-            };
-
-            let mut state = self.0.borrow_mut();
-
-            // Check if we need to quit
-            if let Ok(Some(())) = state.quit_signal_rx.try_recv() {
-                return;
-            }
-
-            // Redraw windows
-            let now = Instant::now();
-            if now > next_refresh_needed {
-                // This will be pulled down to 16ms (or less) if a window is open
-                let mut frame_length = Duration::from_millis(100);
-
-                let mut windows = vec![];
-                for (_, window_ref) in state.windows.iter() {
-                    if !window_ref.window.state.borrow().destroyed {
-                        frame_length = frame_length.min(window_ref.window.refresh_rate());
-                        windows.push(window_ref.window.clone());
-                    }
-                }
-
-                drop(state);
-
-                for window in windows {
-                    window.refresh();
-                }
-
-                state = self.0.borrow_mut();
-
-                // In the case that we're looping a bit too fast, slow down
-                next_refresh_needed = now.max(next_refresh_needed) + frame_length;
-            }
-
-            // X11 events
-            drop(state);
-
-            loop {
-                let (x_windows, events) = self.read_x11_events();
-                for x_window in x_windows {
-                    if let Some(window) = self.get_window(x_window) {
-                        log::trace!(
-                            "main thread: refreshing window {} due expose event",
-                            window.x_window
-                        );
-                        window.refresh();
-                    }
-                }
-
-                if events.len() == 0 {
-                    break;
-                }
-                self.process_x11_events(events);
-
-                // When X11 is sending us events faster than we can handle we'll
-                // let the frame rate drop to 10fps to try and avoid getting too behind.
-                if Instant::now() > next_refresh_needed + Duration::from_millis(80) {
-                    continue 'run_loop;
-                }
-            }
-
-            state = self.0.borrow_mut();
-
-            // Runnables
-            loop {
-                let Ok(runnable) = state.runnables.try_recv() else {
-                    state.last_emptied_runnables = Instant::now();
-                    break;
-                };
-                drop(state);
-
-                let start = Instant::now();
-
-                runnable.run();
-
-                log::trace!("main thread: ran runnable. took: {:?}", start.elapsed());
-
-                state = self.0.borrow_mut();
-
-                if Instant::now() + Duration::from_millis(1) >= next_refresh_needed
-                    && state.last_emptied_runnables.elapsed() < Duration::from_millis(100)
-                {
-                    continue 'run_loop;
-                }
-            }
-
-            // XDG events
-            if let Ok(event) = state.xdp_event_source.try_recv() {
-                log::trace!("main thread: XDG event");
-                match event {
-                    XDPEvent::WindowAppearance(appearance) => {
-                        let mut windows = state
-                            .windows
-                            .values()
-                            .map(|window| window.window.clone())
-                            .collect::<Vec<_>>();
-                        drop(state);
-
-                        self.with_common(|common| common.appearance = appearance);
-                        for mut window in windows {
-                            window.set_appearance(appearance);
-                        }
-                    }
-                    XDPEvent::CursorTheme(_) | XDPEvent::CursorSize(_) => {
-                        // noop, X11 manages this for us.
-                    }
-                };
-            };
-        }
+        event_loop.run(None, &mut self.clone(), |_| {}).log_err();
    }

    fn active_window(&self) -> Option<AnyWindowHandle> {
@@ -1311,6 +1281,120 @@ impl LinuxClient for X11Client {
    }
 }

+// Adatpted from:
+// https://docs.rs/winit/0.29.11/src/winit/platform_impl/linux/x11/monitor.rs.html#103-111
+pub fn mode_refresh_rate(mode: &randr::ModeInfo) -> Duration {
+    if mode.dot_clock == 0 || mode.htotal == 0 || mode.vtotal == 0 {
+        return Duration::from_millis(16);
+    }
+
+    let millihertz = mode.dot_clock as u64 * 1_000 / (mode.htotal as u64 * mode.vtotal as u64);
+    let micros = 1_000_000_000 / millihertz;
+    log::info!("Refreshing at {} micros", micros);
+    Duration::from_micros(micros)
+}
+
 fn fp3232_to_f32(value: xinput::Fp3232) -> f32 {
    value.integral as f32 + value.frac as f32 / u32::MAX as f32
 }
+
+fn check_compositor_present(xcb_connection: &XCBConnection, root: u32) -> bool {
+    // Method 1: Check for _NET_WM_CM_S{root}
+    let atom_name = format!("_NET_WM_CM_S{}", root);
+    let atom = xcb_connection
+        .intern_atom(false, atom_name.as_bytes())
+        .unwrap()
+        .reply()
+        .map(|reply| reply.atom)
+        .unwrap_or(0);
+
+    let method1 = if atom != 0 {
+        xcb_connection
+            .get_selection_owner(atom)
+            .unwrap()
+            .reply()
+            .map(|reply| reply.owner != 0)
+            .unwrap_or(false)
+    } else {
+        false
+    };
+
+    // Method 2: Check for _NET_WM_CM_OWNER
+    let atom_name = "_NET_WM_CM_OWNER";
+    let atom = xcb_connection
+        .intern_atom(false, atom_name.as_bytes())
+        .unwrap()
+        .reply()
+        .map(|reply| reply.atom)
+        .unwrap_or(0);
+
+    let method2 = if atom != 0 {
+        xcb_connection
+            .get_property(false, root, atom, xproto::AtomEnum::WINDOW, 0, 1)
+            .unwrap()
+            .reply()
+            .map(|reply| reply.value_len > 0)
+            .unwrap_or(false)
+    } else {
+        false
+    };
+
+    // Method 3: Check for _NET_SUPPORTING_WM_CHECK
+    let atom_name = "_NET_SUPPORTING_WM_CHECK";
+    let atom = xcb_connection
+        .intern_atom(false, atom_name.as_bytes())
+        .unwrap()
+        .reply()
+        .map(|reply| reply.atom)
+        .unwrap_or(0);
+
+    let method3 = if atom != 0 {
+        xcb_connection
+            .get_property(false, root, atom, xproto::AtomEnum::WINDOW, 0, 1)
+            .unwrap()
+            .reply()
+            .map(|reply| reply.value_len > 0)
+            .unwrap_or(false)
+    } else {
+        false
+    };
+
+    // TODO: Remove this
+    log::info!(
+        "Compositor detection: _NET_WM_CM_S?={}, _NET_WM_CM_OWNER={}, _NET_SUPPORTING_WM_CHECK={}",
+        method1,
+        method2,
+        method3
+    );
+
+    method1 || method2 || method3
+}
+
+fn check_gtk_frame_extents_supported(
+    xcb_connection: &XCBConnection,
+    atoms: &XcbAtoms,
+    root: xproto::Window,
+) -> bool {
+    let supported_atoms = xcb_connection
+        .get_property(
+            false,
+            root,
+            atoms._NET_SUPPORTED,
+            xproto::AtomEnum::ATOM,
+            0,
+            1024,
+        )
+        .unwrap()
+        .reply()
+        .map(|reply| {
+            // Convert Vec<u8> to Vec<u32>
+            reply
+                .value
+                .chunks_exact(4)
+                .map(|chunk| u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]))
+                .collect::<Vec<u32>>()
+        })
+        .unwrap_or_default();
+
+    supported_atoms.contains(&atoms._GTK_FRAME_EXTENTS)
+}
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -15,7 +15,6 @@ use util::{maybe, ResultExt};
 use x11rb::{
    connection::Connection,
    protocol::{
-        randr::{self, ConnectionExt as _},
        sync,
        xinput::{self, ConnectionExt as _},
        xproto::{self, ClientMessageEvent, ConnectionExt, EventMask, TranslateCoordinatesReply},
@@ -26,7 +25,7 @@ use x11rb::{

 use std::{
    cell::RefCell, ffi::c_void, mem::size_of, num::NonZeroU32, ops::Div, ptr::NonNull, rc::Rc,
-    sync::Arc, time::Duration,
+    sync::Arc,
 };

 use super::{X11Display, XINPUT_MASTER_DEVICE};
@@ -51,6 +50,7 @@ x11rb::atom_manager! {
        _NET_WM_WINDOW_TYPE,
        _NET_WM_WINDOW_TYPE_NOTIFICATION,
        _NET_WM_SYNC,
+        _NET_SUPPORTED,
        _MOTIF_WM_HINTS,
        _GTK_SHOW_WINDOW_MENU,
        _GTK_FRAME_EXTENTS,
@@ -220,7 +220,6 @@ pub struct Callbacks {

 pub struct X11WindowState {
    pub destroyed: bool,
-    refresh_rate: Duration,
    client: X11ClientStatePtr,
    executor: ForegroundExecutor,
    atoms: XcbAtoms,
@@ -240,6 +239,7 @@ pub struct X11WindowState {
    hidden: bool,
    active: bool,
    fullscreen: bool,
+    client_side_decorations_supported: bool,
    decorations: WindowDecorations,
    edge_constraints: Option<EdgeConstraints>,
    pub handle: AnyWindowHandle,
@@ -257,7 +257,7 @@ pub(crate) struct X11WindowStatePtr {
    pub state: Rc<RefCell<X11WindowState>>,
    pub(crate) callbacks: Rc<RefCell<Callbacks>>,
    xcb_connection: Rc<XCBConnection>,
-    pub x_window: xproto::Window,
+    x_window: xproto::Window,
 }

 impl rwh::HasWindowHandle for RawWindow {
@@ -295,6 +295,7 @@ impl X11WindowState {
        executor: ForegroundExecutor,
        params: WindowParams,
        xcb_connection: &Rc<XCBConnection>,
+        client_side_decorations_supported: bool,
        x_main_screen_index: usize,
        x_window: xproto::Window,
        atoms: &XcbAtoms,
@@ -492,31 +493,6 @@ impl X11WindowState {
        };
        xcb_connection.map_window(x_window).unwrap();

-        let screen_resources = xcb_connection
-            .randr_get_screen_resources(x_window)
-            .unwrap()
-            .reply()
-            .expect("Could not find available screens");
-
-        let mode = screen_resources
-            .crtcs
-            .iter()
-            .find_map(|crtc| {
-                let crtc_info = xcb_connection
-                    .randr_get_crtc_info(*crtc, x11rb::CURRENT_TIME)
-                    .ok()?
-                    .reply()
-                    .ok()?;
-
-                screen_resources
-                    .modes
-                    .iter()
-                    .find(|m| m.id == crtc_info.mode)
-            })
-            .expect("Unable to find screen refresh rate");
-
-        let refresh_rate = mode_refresh_rate(&mode);
-
        Ok(Self {
            client,
            executor,
@@ -539,12 +515,12 @@ impl X11WindowState {
            handle,
            background_appearance: WindowBackgroundAppearance::Opaque,
            destroyed: false,
+            client_side_decorations_supported,
            decorations: WindowDecorations::Server,
            last_insets: [0, 0, 0, 0],
            edge_constraints: None,
            counter_id: sync_request_counter,
            last_sync_counter: None,
-            refresh_rate,
        })
    }

@@ -608,6 +584,7 @@ impl X11Window {
        executor: ForegroundExecutor,
        params: WindowParams,
        xcb_connection: &Rc<XCBConnection>,
+        client_side_decorations_supported: bool,
        x_main_screen_index: usize,
        x_window: xproto::Window,
        atoms: &XcbAtoms,
@@ -621,6 +598,7 @@ impl X11Window {
                executor,
                params,
                xcb_connection,
+                client_side_decorations_supported,
                x_main_screen_index,
                x_window,
                atoms,
@@ -952,10 +930,6 @@ impl X11WindowStatePtr {
            (fun)()
        }
    }
-
-    pub fn refresh_rate(&self) -> Duration {
-        self.state.borrow().refresh_rate
-    }
 }

 impl PlatformWindow for X11Window {
@@ -1208,6 +1182,7 @@ impl PlatformWindow for X11Window {
        self.0.callbacks.borrow_mut().appearance_changed = Some(callback);
    }

+    #[profiling::function]
    fn draw(&self, scene: &Scene) {
        let mut inner = self.0.state.borrow_mut();
        inner.renderer.draw(scene);
@@ -1258,10 +1233,17 @@ impl PlatformWindow for X11Window {
    fn window_decorations(&self) -> crate::Decorations {
        let state = self.0.state.borrow();

+        // Client window decorations require compositor support
+        if !state.client_side_decorations_supported {
+            return Decorations::Server;
+        }
+
        match state.decorations {
            WindowDecorations::Server => Decorations::Server,
            WindowDecorations::Client => {
-                let tiling = if let Some(edge_constraints) = &state.edge_constraints {
+                let tiling = if state.fullscreen {
+                    Tiling::tiled()
+                } else if let Some(edge_constraints) = &state.edge_constraints {
                    edge_constraints.to_tiling()
                } else {
                    // https://source.chromium.org/chromium/chromium/src/+/main:ui/ozone/platform/x11/x11_window.cc;l=2519;drc=1f14cc876cc5bf899d13284a12c451498219bb2d
@@ -1272,7 +1254,6 @@ impl PlatformWindow for X11Window {
                        right: state.maximized_horizontal,
                    }
                };
-
                Decorations::Client { tiling }
            }
        }
@@ -1283,7 +1264,9 @@ impl PlatformWindow for X11Window {

        let dp = (inset.0 * state.scale_factor) as u32;

-        let insets = if let Some(edge_constraints) = &state.edge_constraints {
+        let insets = if state.fullscreen {
+            [0, 0, 0, 0]
+        } else if let Some(edge_constraints) = &state.edge_constraints {
            let left = if edge_constraints.left_tiled { 0 } else { dp };
            let top = if edge_constraints.top_tiled { 0 } else { dp };
            let right = if edge_constraints.right_tiled { 0 } else { dp };
@@ -1324,15 +1307,24 @@ impl PlatformWindow for X11Window {
        }
    }

-    fn request_decorations(&self, decorations: crate::WindowDecorations) {
+    fn request_decorations(&self, mut decorations: crate::WindowDecorations) {
+        let mut state = self.0.state.borrow_mut();
+
+        if matches!(decorations, crate::WindowDecorations::Client)
+            && !state.client_side_decorations_supported
+        {
+            log::info!(
+                "x11: no compositor present, falling back to server-side window decorations"
+            );
+            decorations = crate::WindowDecorations::Server;
+        }
+
        // https://github.com/rust-windowing/winit/blob/master/src/platform_impl/linux/x11/util/hint.rs#L53-L87
        let hints_data: [u32; 5] = match decorations {
            WindowDecorations::Server => [1 << 1, 0, 1, 0, 0],
            WindowDecorations::Client => [1 << 1, 0, 0, 0, 0],
        };

-        let mut state = self.0.state.borrow_mut();
-
        self.0
            .xcb_connection
            .change_property(
@@ -1368,16 +1360,3 @@ impl PlatformWindow for X11Window {
        }
    }
 }
-
-// Adapted from:
-// https://docs.rs/winit/0.29.11/src/winit/platform_impl/linux/x11/monitor.rs.html#103-111
-pub fn mode_refresh_rate(mode: &randr::ModeInfo) -> Duration {
-    if mode.dot_clock == 0 || mode.htotal == 0 || mode.vtotal == 0 {
-        return Duration::from_millis(16);
-    }
-
-    let millihertz = mode.dot_clock as u64 * 1_000 / (mode.htotal as u64 * mode.vtotal as u64);
-    let micros = 1_000_000_000 / millihertz;
-    log::info!("Refreshing at {} micros", micros);
-    Duration::from_micros(micros)
-}
--- a/crates/gpui/src/platform/linux/xdg_desktop_portal.rs
+++ b/crates/gpui/src/platform/linux/xdg_desktop_portal.rs
@@ -2,13 +2,9 @@
 //!
 //! This module uses the [ashpd] crate

-use std::sync::Arc;
-
-use anyhow::anyhow;
 use ashpd::desktop::settings::{ColorScheme, Settings};
-use calloop::channel::{Channel, Sender};
+use calloop::channel::Channel;
 use calloop::{EventSource, Poll, PostAction, Readiness, Token, TokenFactory};
-use mio::Waker;
 use smol::stream::StreamExt;

 use crate::{BackgroundExecutor, WindowAppearance};
@@ -24,45 +20,31 @@ pub struct XDPEventSource {
 }

 impl XDPEventSource {
-    pub fn new(executor: &BackgroundExecutor, waker: Option<Arc<Waker>>) -> Self {
+    pub fn new(executor: &BackgroundExecutor) -> Self {
        let (sender, channel) = calloop::channel::channel();

        let background = executor.clone();

        executor
            .spawn(async move {
-                fn send_event<T>(
-                    sender: &Sender<T>,
-                    waker: &Option<Arc<Waker>>,
-                    event: T,
-                ) -> Result<(), std::sync::mpsc::SendError<T>> {
-                    sender.send(event)?;
-                    if let Some(waker) = waker {
-                        waker.wake().ok();
-                    };
-                    Ok(())
-                }
-
                let settings = Settings::new().await?;

                if let Ok(initial_appearance) = settings.color_scheme().await {
-                    send_event(
-                        &sender,
-                        &waker,
-                        Event::WindowAppearance(WindowAppearance::from_native(initial_appearance)),
-                    )?;
+                    sender.send(Event::WindowAppearance(WindowAppearance::from_native(
+                        initial_appearance,
+                    )))?;
                }
                if let Ok(initial_theme) = settings
                    .read::<String>("org.gnome.desktop.interface", "cursor-theme")
                    .await
                {
-                    send_event(&sender, &waker, Event::CursorTheme(initial_theme))?;
+                    sender.send(Event::CursorTheme(initial_theme))?;
                }
                if let Ok(initial_size) = settings
                    .read::<u32>("org.gnome.desktop.interface", "cursor-size")
                    .await
                {
-                    send_event(&sender, &waker, Event::CursorSize(initial_size))?;
+                    sender.send(Event::CursorSize(initial_size))?;
                }

                if let Ok(mut cursor_theme_changed) = settings
@@ -73,12 +55,11 @@ impl XDPEventSource {
                    .await
                {
                    let sender = sender.clone();
-                    let waker = waker.clone();
                    background
                        .spawn(async move {
                            while let Some(theme) = cursor_theme_changed.next().await {
                                let theme = theme?;
-                                send_event(&sender, &waker, Event::CursorTheme(theme))?;
+                                sender.send(Event::CursorTheme(theme))?;
                            }
                            anyhow::Ok(())
                        })
@@ -93,12 +74,11 @@ impl XDPEventSource {
                    .await
                {
                    let sender = sender.clone();
-                    let waker = waker.clone();
                    background
                        .spawn(async move {
                            while let Some(size) = cursor_size_changed.next().await {
                                let size = size?;
-                                send_event(&sender, &waker, Event::CursorSize(size))?;
+                                sender.send(Event::CursorSize(size))?;
                            }
                            anyhow::Ok(())
                        })
@@ -107,11 +87,9 @@ impl XDPEventSource {

                let mut appearance_changed = settings.receive_color_scheme_changed().await?;
                while let Some(scheme) = appearance_changed.next().await {
-                    send_event(
-                        &sender,
-                        &waker,
-                        Event::WindowAppearance(WindowAppearance::from_native(scheme)),
-                    )?;
+                    sender.send(Event::WindowAppearance(WindowAppearance::from_native(
+                        scheme,
+                    )))?;
                }

                anyhow::Ok(())
@@ -120,12 +98,6 @@ impl XDPEventSource {

        Self { channel }
    }
-
-    pub fn try_recv(&self) -> anyhow::Result<Event> {
-        self.channel
-            .try_recv()
-            .map_err(|error| anyhow!("{}", error))
-    }
 }

 impl EventSource for XDPEventSource {
--- a/crates/gpui/src/platform/windows/direct_write.rs
+++ b/crates/gpui/src/platform/windows/direct_write.rs
@@ -49,7 +49,8 @@ struct DirectWriteComponent {

 struct GlyphRenderContext {
    params: IDWriteRenderingParams3,
-    dc_target: ID2D1DeviceContext4,
+    normal_dc_target: ID2D1DeviceContext4,
+    emoji_dc_target: ID2D1DeviceContext4,
 }

 // All use of the IUnknown methods should be "thread-safe".
@@ -127,7 +128,16 @@ impl GlyphRenderContext {
                DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC,
                grid_fit_mode,
            )?;
-            let dc_target = {
+            let normal_dc_target = {
+                let target = d2d1_factory.CreateDCRenderTarget(&get_render_target_property(
+                    DXGI_FORMAT_A8_UNORM,
+                    D2D1_ALPHA_MODE_STRAIGHT,
+                ))?;
+                let target = target.cast::<ID2D1DeviceContext4>()?;
+                target.SetTextRenderingParams(&params);
+                target
+            };
+            let emoji_dc_target = {
                let target = d2d1_factory.CreateDCRenderTarget(&get_render_target_property(
                    DXGI_FORMAT_B8G8R8A8_UNORM,
                    D2D1_ALPHA_MODE_PREMULTIPLIED,
@@ -137,7 +147,11 @@ impl GlyphRenderContext {
                target
            };

-            Ok(Self { params, dc_target })
+            Ok(Self {
+                params,
+                normal_dc_target,
+                emoji_dc_target,
+            })
        }
    }
 }
@@ -557,7 +571,11 @@ impl DirectWriteState {
    }

    fn raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
-        let render_target = &self.components.render_context.dc_target;
+        let render_target = if params.is_emoji {
+            &self.components.render_context.emoji_dc_target
+        } else {
+            &self.components.render_context.normal_dc_target
+        };
        unsafe {
            render_target.SetUnitMode(D2D1_UNIT_MODE_DIPS);
            render_target.SetDpi(96.0 * params.scale_factor, 96.0 * params.scale_factor);
--- a/crates/gpui/src/platform/windows/events.rs
+++ b/crates/gpui/src/platform/windows/events.rs
@@ -659,6 +659,13 @@ fn handle_calc_client_size(
    requested_client_rect[0].left += frame_x + padding;
    requested_client_rect[0].bottom -= frame_y + padding;

+    if state_ptr.state.borrow().is_maximized() {
+        requested_client_rect[0].top += frame_y + padding;
+    } else {
+        // Magic number that calculates the width of the border
+        requested_client_rect[0].top += frame_y - 3;
+    }
+
    Some(0)
 }

@@ -821,14 +828,14 @@ fn handle_hit_test_msg(

    let dpi = unsafe { GetDpiForWindow(handle) };
    let frame_y = unsafe { GetSystemMetricsForDpi(SM_CYFRAME, dpi) };
-    let padding = unsafe { GetSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi) };

    let mut cursor_point = POINT {
        x: lparam.signed_loword().into(),
        y: lparam.signed_hiword().into(),
    };
    unsafe { ScreenToClient(handle, &mut cursor_point).ok().log_err() };
-    if cursor_point.y > 0 && cursor_point.y < frame_y + padding {
+    if !state_ptr.state.borrow().is_maximized() && cursor_point.y >= 0 && cursor_point.y <= frame_y
+    {
        return Some(HTTOP as _);
    }

@@ -1044,6 +1051,8 @@ fn handle_system_settings_changed(state_ptr: Rc<WindowsWindowStatePtr>) -> Optio
    let mut lock = state_ptr.state.borrow_mut();
    // mouse wheel
    lock.system_settings.mouse_wheel_settings.update();
+    // mouse double click
+    lock.click_state.system_update();
    Some(0)
 }

@@ -1259,7 +1268,7 @@ fn is_modifier(virtual_key: VIRTUAL_KEY) -> bool {
 }

 #[inline]
-fn current_modifiers() -> Modifiers {
+pub(crate) fn current_modifiers() -> Modifiers {
    Modifiers {
        control: is_virtual_key_pressed(VK_CONTROL),
        alt: is_virtual_key_pressed(VK_MENU),
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -27,10 +27,7 @@ use windows::{
        System::{Com::*, LibraryLoader::*, Ole::*, SystemInformation::*, Threading::*, Time::*},
        UI::{Input::KeyboardAndMouse::*, Shell::*, WindowsAndMessaging::*},
    },
-    UI::{
-        Color,
-        ViewManagement::{UIColorType, UISettings},
-    },
+    UI::ViewManagement::UISettings,
 };

 use crate::*;
@@ -678,25 +675,6 @@ fn load_icon() -> Result<HICON> {
    Ok(HICON(handle.0))
 }

-// https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/apply-windows-themes
-#[inline]
-fn system_appearance() -> Result<WindowAppearance> {
-    let ui_settings = UISettings::new()?;
-    let foreground_color = ui_settings.GetColorValue(UIColorType::Foreground)?;
-    // If the foreground is light, then is_color_light will evaluate to true,
-    // meaning Dark mode is enabled.
-    if is_color_light(&foreground_color) {
-        Ok(WindowAppearance::Dark)
-    } else {
-        Ok(WindowAppearance::Light)
-    }
-}
-
-#[inline(always)]
-fn is_color_light(color: &Color) -> bool {
-    ((5 * color.G as u32) + (2 * color.R as u32) + color.B as u32) > (8 * 128)
-}
-
 #[inline]
 fn should_auto_hide_scrollbars() -> Result<bool> {
    let ui_settings = UISettings::new()?;
--- a/crates/gpui/src/platform/windows/util.rs
+++ b/crates/gpui/src/platform/windows/util.rs
@@ -1,7 +1,13 @@
 use std::sync::OnceLock;

 use ::util::ResultExt;
-use windows::Win32::{Foundation::*, UI::WindowsAndMessaging::*};
+use windows::{
+    Win32::{Foundation::*, UI::WindowsAndMessaging::*},
+    UI::{
+        Color,
+        ViewManagement::{UIColorType, UISettings},
+    },
+};

 use crate::*;

@@ -118,3 +124,22 @@ pub(crate) fn logical_point(x: f32, y: f32, scale_factor: f32) -> Point<Pixels>
        y: px(y / scale_factor),
    }
 }
+
+// https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/apply-windows-themes
+#[inline]
+pub(crate) fn system_appearance() -> Result<WindowAppearance> {
+    let ui_settings = UISettings::new()?;
+    let foreground_color = ui_settings.GetColorValue(UIColorType::Foreground)?;
+    // If the foreground is light, then is_color_light will evaluate to true,
+    // meaning Dark mode is enabled.
+    if is_color_light(&foreground_color) {
+        Ok(WindowAppearance::Dark)
+    } else {
+        Ok(WindowAppearance::Light)
+    }
+}
+
+#[inline(always)]
+fn is_color_light(color: &Color) -> bool {
+    ((5 * color.G as u32) + (2 * color.R as u32) + color.B as u32) > (8 * 128)
+}
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -252,7 +252,7 @@ impl WindowsWindow {
            .titlebar
            .as_ref()
            .map(|titlebar| titlebar.appears_transparent)
-            .unwrap_or(false);
+            .unwrap_or(true);
        let windowname = HSTRING::from(
            params
                .titlebar
@@ -383,9 +383,8 @@ impl PlatformWindow for WindowsWindow {
        self.0.state.borrow().scale_factor
    }

-    // todo(windows)
    fn appearance(&self) -> WindowAppearance {
-        WindowAppearance::Dark
+        system_appearance().log_err().unwrap_or_default()
    }

    fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {
@@ -405,9 +404,8 @@ impl PlatformWindow for WindowsWindow {
        logical_point(point.x as f32, point.y as f32, scale_factor)
    }

-    // todo(windows)
    fn modifiers(&self) -> Modifiers {
-        Modifiers::none()
+        current_modifiers()
    }

    fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
@@ -787,15 +785,25 @@ pub(crate) struct ClickState {
    button: MouseButton,
    last_click: Instant,
    last_position: Point<DevicePixels>,
+    double_click_spatial_tolerance_width: i32,
+    double_click_spatial_tolerance_height: i32,
+    double_click_interval: Duration,
    pub(crate) current_count: usize,
 }

 impl ClickState {
    pub fn new() -> Self {
+        let double_click_spatial_tolerance_width = unsafe { GetSystemMetrics(SM_CXDOUBLECLK) };
+        let double_click_spatial_tolerance_height = unsafe { GetSystemMetrics(SM_CYDOUBLECLK) };
+        let double_click_interval = Duration::from_millis(unsafe { GetDoubleClickTime() } as u64);
+
        ClickState {
            button: MouseButton::Left,
            last_click: Instant::now(),
            last_position: Point::default(),
+            double_click_spatial_tolerance_width,
+            double_click_spatial_tolerance_height,
+            double_click_interval,
            current_count: 0,
        }
    }
@@ -814,13 +822,19 @@ impl ClickState {
        self.current_count
    }

+    pub fn system_update(&mut self) {
+        self.double_click_spatial_tolerance_width = unsafe { GetSystemMetrics(SM_CXDOUBLECLK) };
+        self.double_click_spatial_tolerance_height = unsafe { GetSystemMetrics(SM_CYDOUBLECLK) };
+        self.double_click_interval = Duration::from_millis(unsafe { GetDoubleClickTime() } as u64);
+    }
+
    #[inline]
    fn is_double_click(&self, new_position: Point<DevicePixels>) -> bool {
        let diff = self.last_position - new_position;

-        self.last_click.elapsed() < DOUBLE_CLICK_INTERVAL
-            && diff.x.0.abs() <= DOUBLE_CLICK_SPATIAL_TOLERANCE
-            && diff.y.0.abs() <= DOUBLE_CLICK_SPATIAL_TOLERANCE
+        self.last_click.elapsed() < self.double_click_interval
+            && diff.x.0.abs() <= self.double_click_spatial_tolerance_width
+            && diff.y.0.abs() <= self.double_click_spatial_tolerance_height
    }
 }

@@ -928,10 +942,6 @@ fn register_drag_drop(state_ptr: Rc<WindowsWindowStatePtr>) {

 // https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-dragqueryfilew
 const DRAGDROP_GET_FILES_COUNT: u32 = 0xFFFFFFFF;
-// https://learn.microsoft.com/en-us/windows/win32/controls/ttm-setdelaytime?redirectedfrom=MSDN
-const DOUBLE_CLICK_INTERVAL: Duration = Duration::from_millis(500);
-// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getsystemmetrics
-const DOUBLE_CLICK_SPATIAL_TOLERANCE: i32 = 4;

 mod windows_renderer {
    use std::{num::NonZeroIsize, sync::Arc};
--- a/crates/gpui/src/styled.rs
+++ b/crates/gpui/src/styled.rs
@@ -1,11 +1,14 @@
+use crate::TextStyleRefinement;
 use crate::{
-    self as gpui, hsla, point, px, relative, rems, AbsoluteLength, AlignItems, CursorStyle,
-    DefiniteLength, Fill, FlexDirection, FlexWrap, Font, FontStyle, FontWeight, Hsla,
-    JustifyContent, Length, Position, SharedString, StyleRefinement, Visibility, WhiteSpace,
+    self as gpui, px, relative, rems, AbsoluteLength, AlignItems, CursorStyle, DefiniteLength,
+    Fill, FlexDirection, FlexWrap, Font, FontStyle, FontWeight, Hsla, JustifyContent, Length,
+    SharedString, StyleRefinement, WhiteSpace,
 };
-use crate::{BoxShadow, TextStyleRefinement};
-use smallvec::{smallvec, SmallVec};
-use taffy::style::{AlignContent, Display, Overflow};
+pub use gpui_macros::{
+    box_shadow_style_methods, cursor_style_methods, margin_style_methods, overflow_style_methods,
+    padding_style_methods, position_style_methods, visibility_style_methods,
+};
+use taffy::style::{AlignContent, Display};

 /// A trait for elements that can be styled.
 /// Use this to opt-in to a CSS-like styling API.
@@ -14,20 +17,13 @@ pub trait Styled: Sized {
    fn style(&mut self) -> &mut StyleRefinement;

    gpui_macros::style_helpers!();
-
-    /// Sets the position of the element to `relative`.
-    /// [Docs](https://tailwindcss.com/docs/position)
-    fn relative(mut self) -> Self {
-        self.style().position = Some(Position::Relative);
-        self
-    }
-
-    /// Sets the position of the element to `absolute`.
-    /// [Docs](https://tailwindcss.com/docs/position)
-    fn absolute(mut self) -> Self {
-        self.style().position = Some(Position::Absolute);
-        self
-    }
+    gpui_macros::visibility_style_methods!();
+    gpui_macros::margin_style_methods!();
+    gpui_macros::padding_style_methods!();
+    gpui_macros::position_style_methods!();
+    gpui_macros::overflow_style_methods!();
+    gpui_macros::cursor_style_methods!();
+    gpui_macros::box_shadow_style_methods!();

    /// Sets the display type of the element to `block`.
    /// [Docs](https://tailwindcss.com/docs/display)
@@ -43,195 +39,6 @@ pub trait Styled: Sized {
        self
    }

-    /// Sets the visibility of the element to `visible`.
-    /// [Docs](https://tailwindcss.com/docs/visibility)
-    fn visible(mut self) -> Self {
-        self.style().visibility = Some(Visibility::Visible);
-        self
-    }
-
-    /// Sets the visibility of the element to `hidden`.
-    /// [Docs](https://tailwindcss.com/docs/visibility)
-    fn invisible(mut self) -> Self {
-        self.style().visibility = Some(Visibility::Hidden);
-        self
-    }
-
-    /// Sets the behavior of content that overflows the container to be hidden.
-    /// [Docs](https://tailwindcss.com/docs/overflow#hiding-content-that-overflows)
-    fn overflow_hidden(mut self) -> Self {
-        self.style().overflow.x = Some(Overflow::Hidden);
-        self.style().overflow.y = Some(Overflow::Hidden);
-        self
-    }
-
-    /// Sets the behavior of content that overflows the container on the X axis to be hidden.
-    /// [Docs](https://tailwindcss.com/docs/overflow#hiding-content-that-overflows)
-    fn overflow_x_hidden(mut self) -> Self {
-        self.style().overflow.x = Some(Overflow::Hidden);
-        self
-    }
-
-    /// Sets the behavior of content that overflows the container on the Y axis to be hidden.
-    /// [Docs](https://tailwindcss.com/docs/overflow#hiding-content-that-overflows)
-    fn overflow_y_hidden(mut self) -> Self {
-        self.style().overflow.y = Some(Overflow::Hidden);
-        self
-    }
-
-    /// Set the cursor style when hovering over this element
-    fn cursor(mut self, cursor: CursorStyle) -> Self {
-        self.style().mouse_cursor = Some(cursor);
-        self
-    }
-
-    /// Sets the cursor style when hovering an element to `default`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_default(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::Arrow);
-        self
-    }
-
-    /// Sets the cursor style when hovering an element to `pointer`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_pointer(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::PointingHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `text`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_text(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::IBeam);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `move`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_move(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ClosedHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `not-allowed`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_not_allowed(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::OperationNotAllowed);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `context-menu`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_context_menu(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ContextualMenu);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `crosshair`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_crosshair(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::Crosshair);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `vertical-text`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_vertical_text(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::IBeamCursorForVerticalLayout);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `alias`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_alias(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::DragLink);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `copy`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_copy(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::DragCopy);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `no-drop`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_no_drop(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::OperationNotAllowed);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `grab`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_grab(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::OpenHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `grabbing`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_grabbing(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ClosedHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `ew-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_ew_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeLeftRight);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `ns-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_ns_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeUpDown);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `col-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_col_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeColumn);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `row-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_row_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeRow);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `n-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_n_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeUp);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `e-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_e_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeRight);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `s-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_s_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeDown);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `w-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_w_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeLeft);
-        self
-    }
-
    /// Sets the whitespace of the element to `normal`.
    /// [Docs](https://tailwindcss.com/docs/whitespace#normal)
    fn whitespace_normal(mut self) -> Self {
@@ -499,104 +306,6 @@ pub trait Styled: Sized {
        self
    }

-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow(mut self, shadows: SmallVec<[BoxShadow; 2]>) -> Self {
-        self.style().box_shadow = Some(shadows);
-        self
-    }
-
-    /// Clears the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_none(mut self) -> Self {
-        self.style().box_shadow = Some(Default::default());
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_sm(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec::smallvec![BoxShadow {
-            color: hsla(0., 0., 0., 0.05),
-            offset: point(px(0.), px(1.)),
-            blur_radius: px(2.),
-            spread_radius: px(0.),
-        }]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_md(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![
-            BoxShadow {
-                color: hsla(0.5, 0., 0., 0.1),
-                offset: point(px(0.), px(4.)),
-                blur_radius: px(6.),
-                spread_radius: px(-1.),
-            },
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(2.)),
-                blur_radius: px(4.),
-                spread_radius: px(-2.),
-            }
-        ]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_lg(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(10.)),
-                blur_radius: px(15.),
-                spread_radius: px(-3.),
-            },
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(4.)),
-                blur_radius: px(6.),
-                spread_radius: px(-4.),
-            }
-        ]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_xl(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(20.)),
-                blur_radius: px(25.),
-                spread_radius: px(-5.),
-            },
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(8.)),
-                blur_radius: px(10.),
-                spread_radius: px(-6.),
-            }
-        ]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_2xl(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![BoxShadow {
-            color: hsla(0., 0., 0., 0.25),
-            offset: point(px(0.), px(25.)),
-            blur_radius: px(50.),
-            spread_radius: px(-12.),
-        }]);
-        self
-    }
-
    /// Get the text style that has been configured on this element.
    fn text_style(&mut self) -> &mut Option<TextStyleRefinement> {
        let style: &mut StyleRefinement = self.style();
--- a/crates/gpui/src/taffy.rs
+++ b/crates/gpui/src/taffy.rs
@@ -142,6 +142,7 @@ impl TaffyLayoutEngine {
        Ok(edges)
    }

+    #[profiling::function]
    pub fn compute_layout(
        &mut self,
        id: LayoutId,
@@ -161,6 +162,7 @@ impl TaffyLayoutEngine {
        //

        if !self.computed_layouts.insert(id) {
+            profiling::scope!("compute layout stack extension");
            let mut stack = SmallVec::<[LayoutId; 64]>::new();
            stack.push(id);
            while let Some(id) = stack.pop() {
@@ -181,6 +183,8 @@ impl TaffyLayoutEngine {
                id.into(),
                available_space.into(),
                |known_dimensions, available_space, node_id, _context| {
+                    profiling::scope!("measure function");
+
                    let Some(measure) = self.nodes_to_measure.get_mut(&node_id.into()) else {
                        return taffy::geometry::Size::default();
                    };
@@ -190,7 +194,10 @@ impl TaffyLayoutEngine {
                        height: known_dimensions.height.map(Pixels),
                    };

-                    measure(known_dimensions, available_space.into(), cx).into()
+                    {
+                        profiling::scope!("calling measure");
+                        measure(known_dimensions, available_space.into(), cx).into()
+                    }
                },
            )
            .expect(EXPECT_MESSAGE);
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -453,17 +453,48 @@ impl Frame {
        }
    }

+    #[profiling::function]
    pub(crate) fn clear(&mut self) {
-        self.element_states.clear();
-        self.accessed_element_states.clear();
-        self.mouse_listeners.clear();
-        self.dispatch_tree.clear();
-        self.scene.clear();
-        self.input_handlers.clear();
-        self.tooltip_requests.clear();
-        self.cursor_styles.clear();
-        self.hitboxes.clear();
-        self.deferred_draws.clear();
+        {
+            profiling::scope!("element_states clear");
+            self.element_states.clear();
+        }
+        {
+            profiling::scope!("accessed_element_states clear");
+            self.accessed_element_states.clear();
+        }
+        {
+            profiling::scope!("mouse_listeners clear");
+            self.mouse_listeners.clear();
+        }
+        {
+            profiling::scope!("dispatch_tree clear");
+            self.dispatch_tree.clear();
+        }
+        {
+            profiling::scope!("scene clear");
+            self.scene.clear();
+        }
+        {
+            profiling::scope!("input handlers clear");
+            self.input_handlers.clear();
+        }
+        {
+            profiling::scope!("tooltip_requests clear");
+            self.tooltip_requests.clear();
+        }
+        {
+            profiling::scope!("cursor styles clear");
+            self.cursor_styles.clear();
+        }
+        {
+            profiling::scope!("hitboxes clear");
+            self.hitboxes.clear();
+        }
+        {
+            profiling::scope!("deferred draws clear");
+            self.deferred_draws.clear();
+        }
    }

    pub(crate) fn hit_test(&self, position: Point<Pixels>) -> HitTest {
@@ -695,6 +726,7 @@ impl Window {
            }
        }));
        platform_window.on_request_frame(Box::new({
+            profiling::scope!("on_request_frame");
            let mut cx = cx.to_async();
            let dirty = dirty.clone();
            let active = active.clone();
@@ -1429,6 +1461,7 @@ impl<'a> WindowContext<'a> {
            .next_frame
            .finish(&mut self.window.rendered_frame);
        ELEMENT_ARENA.with_borrow_mut(|element_arena| {
+            profiling::scope!("element area clear");
            let percentage = (element_arena.len() as f32 / element_arena.capacity() as f32) * 100.;
            if percentage >= 80. {
                log::warn!("elevated element arena occupation: {}.", percentage);
@@ -1439,37 +1472,47 @@ impl<'a> WindowContext<'a> {
        self.window.draw_phase = DrawPhase::Focus;
        let previous_focus_path = self.window.rendered_frame.focus_path();
        let previous_window_active = self.window.rendered_frame.window_active;
-        mem::swap(&mut self.window.rendered_frame, &mut self.window.next_frame);
-        self.window.next_frame.clear();
-        let current_focus_path = self.window.rendered_frame.focus_path();
-        let current_window_active = self.window.rendered_frame.window_active;
-
-        if previous_focus_path != current_focus_path
-            || previous_window_active != current_window_active
        {
-            if !previous_focus_path.is_empty() && current_focus_path.is_empty() {
-                self.window
-                    .focus_lost_listeners
-                    .clone()
-                    .retain(&(), |listener| listener(self));
-            }
+            profiling::scope!("swapping frames");
+            mem::swap(&mut self.window.rendered_frame, &mut self.window.next_frame);
+        }
+        {
+            profiling::scope!("clearing next frame");
+            self.window.next_frame.clear();
+        }

-            let event = WindowFocusEvent {
-                previous_focus_path: if previous_window_active {
-                    previous_focus_path
-                } else {
-                    Default::default()
-                },
-                current_focus_path: if current_window_active {
-                    current_focus_path
-                } else {
-                    Default::default()
-                },
-            };
-            self.window
-                .focus_listeners
-                .clone()
-                .retain(&(), |listener| listener(&event, self));
+        {
+            profiling::scope!("updating focus path");
+            let current_focus_path = self.window.rendered_frame.focus_path();
+            let current_window_active = self.window.rendered_frame.window_active;
+
+            if previous_focus_path != current_focus_path
+                || previous_window_active != current_window_active
+            {
+                if !previous_focus_path.is_empty() && current_focus_path.is_empty() {
+                    self.window
+                        .focus_lost_listeners
+                        .clone()
+                        .retain(&(), |listener| listener(self));
+                }
+
+                let event = WindowFocusEvent {
+                    previous_focus_path: if previous_window_active {
+                        previous_focus_path
+                    } else {
+                        Default::default()
+                    },
+                    current_focus_path: if current_window_active {
+                        current_focus_path
+                    } else {
+                        Default::default()
+                    },
+                };
+                self.window
+                    .focus_listeners
+                    .clone()
+                    .retain(&(), |listener| listener(&event, self));
+            }
        }

        self.reset_cursor_style();
@@ -1487,6 +1530,7 @@ impl<'a> WindowContext<'a> {
        profiling::finish_frame!();
    }

+    #[profiling::function]
    fn draw_roots(&mut self) {
        self.window.draw_phase = DrawPhase::Prepaint;
        self.window.tooltip_bounds.take();
@@ -1854,6 +1898,7 @@ impl<'a> WindowContext<'a> {
    /// Updates the global element offset based on the given offset. This is used to implement
    /// drag handles and other manual painting of elements. This method should only be called during
    /// the prepaint phase of element drawing.
+    #[profiling::function]
    pub fn with_absolute_element_offset<R>(
        &mut self,
        offset: Point<Pixels>,
@@ -2719,6 +2764,7 @@ impl<'a> WindowContext<'a> {
    /// After calling it, you can request the bounds of the given layout node id or any descendant.
    ///
    /// This method should only be called as part of the prepaint phase of element drawing.
+    #[profiling::function]
    pub fn compute_layout(&mut self, layout_id: LayoutId, available_space: Size<AvailableSpace>) {
        debug_assert_eq!(
            self.window.draw_phase,
@@ -2727,7 +2773,10 @@ impl<'a> WindowContext<'a> {
        );

        let mut layout_engine = self.window.layout_engine.take().unwrap();
-        layout_engine.compute_layout(layout_id, available_space, self);
+        {
+            profiling::scope!("layout_engine compute_layout");
+            layout_engine.compute_layout(layout_id, available_space, self);
+        }
        self.window.layout_engine = Some(layout_engine);
    }

--- a/crates/gpui_macros/src/gpui_macros.rs
+++ b/crates/gpui_macros/src/gpui_macros.rs
@@ -1,7 +1,7 @@
 mod derive_into_element;
 mod derive_render;
 mod register_action;
-mod style_helpers;
+mod styles;
 mod test;

 use proc_macro::TokenStream;
@@ -27,11 +27,53 @@ pub fn derive_render(input: TokenStream) -> TokenStream {
    derive_render::derive_render(input)
 }

-/// Used by gpui to generate the style helpers.
+/// Used by GPUI to generate the style helpers.
 #[proc_macro]
 #[doc(hidden)]
 pub fn style_helpers(input: TokenStream) -> TokenStream {
-    style_helpers::style_helpers(input)
+    styles::style_helpers(input)
+}
+
+/// Generates methods for visibility styles.
+#[proc_macro]
+pub fn visibility_style_methods(input: TokenStream) -> TokenStream {
+    styles::visibility_style_methods(input)
+}
+
+/// Generates methods for margin styles.
+#[proc_macro]
+pub fn margin_style_methods(input: TokenStream) -> TokenStream {
+    styles::margin_style_methods(input)
+}
+
+/// Generates methods for padding styles.
+#[proc_macro]
+pub fn padding_style_methods(input: TokenStream) -> TokenStream {
+    styles::padding_style_methods(input)
+}
+
+/// Generates methods for position styles.
+#[proc_macro]
+pub fn position_style_methods(input: TokenStream) -> TokenStream {
+    styles::position_style_methods(input)
+}
+
+/// Generates methods for overflow styles.
+#[proc_macro]
+pub fn overflow_style_methods(input: TokenStream) -> TokenStream {
+    styles::overflow_style_methods(input)
+}
+
+/// Generates methods for cursor styles.
+#[proc_macro]
+pub fn cursor_style_methods(input: TokenStream) -> TokenStream {
+    styles::cursor_style_methods(input)
+}
+
+/// Generates methods for box shadow styles.
+#[proc_macro]
+pub fn box_shadow_style_methods(input: TokenStream) -> TokenStream {
+    styles::box_shadow_style_methods(input)
 }

 /// #[gpui::test] can be used to annotate test functions that run with GPUI support.
--- a/crates/gpui_macros/src/style_helpers.rs
+++ b/crates/gpui_macros/src/style_helpers.rs
@@ -1,569 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::{format_ident, quote};
-use syn::{
-    parse::{Parse, ParseStream, Result},
-    parse_macro_input,
-};
-
-struct StyleableMacroInput;
-
-impl Parse for StyleableMacroInput {
-    fn parse(_input: ParseStream) -> Result<Self> {
-        Ok(StyleableMacroInput)
-    }
-}
-
-pub fn style_helpers(input: TokenStream) -> TokenStream {
-    let _ = parse_macro_input!(input as StyleableMacroInput);
-    let methods = generate_methods();
-    let output = quote! {
-        #(#methods)*
-    };
-
-    output.into()
-}
-
-fn generate_methods() -> Vec<TokenStream2> {
-    let mut methods = Vec::new();
-
-    for (prefix, auto_allowed, fields, prefix_doc_string) in box_prefixes() {
-        methods.push(generate_custom_value_setter(
-            prefix,
-            if auto_allowed {
-                quote! { Length }
-            } else {
-                quote! { DefiniteLength }
-            },
-            &fields,
-            prefix_doc_string,
-        ));
-
-        for (suffix, length_tokens, suffix_doc_string) in box_suffixes() {
-            if suffix != "auto" || auto_allowed {
-                methods.push(generate_predefined_setter(
-                    prefix,
-                    suffix,
-                    &fields,
-                    &length_tokens,
-                    false,
-                    &format!("{prefix_doc_string}\n\n{suffix_doc_string}"),
-                ));
-            }
-
-            if suffix != "auto" {
-                methods.push(generate_predefined_setter(
-                    prefix,
-                    suffix,
-                    &fields,
-                    &length_tokens,
-                    true,
-                    &format!("{prefix_doc_string}\n\n{suffix_doc_string}"),
-                ));
-            }
-        }
-    }
-
-    for (prefix, fields, prefix_doc_string) in corner_prefixes() {
-        methods.push(generate_custom_value_setter(
-            prefix,
-            quote! { AbsoluteLength },
-            &fields,
-            prefix_doc_string,
-        ));
-
-        for (suffix, radius_tokens, suffix_doc_string) in corner_suffixes() {
-            methods.push(generate_predefined_setter(
-                prefix,
-                suffix,
-                &fields,
-                &radius_tokens,
-                false,
-                &format!("{prefix_doc_string}\n\n{suffix_doc_string}"),
-            ));
-        }
-    }
-
-    for (prefix, fields, prefix_doc_string) in border_prefixes() {
-        methods.push(generate_custom_value_setter(
-            prefix,
-            quote! { AbsoluteLength },
-            &fields,
-            prefix_doc_string,
-        ));
-
-        for (suffix, width_tokens, suffix_doc_string) in border_suffixes() {
-            methods.push(generate_predefined_setter(
-                prefix,
-                suffix,
-                &fields,
-                &width_tokens,
-                false,
-                &format!("{prefix_doc_string}\n\n{suffix_doc_string}"),
-            ));
-        }
-    }
-    methods
-}
-
-fn generate_predefined_setter(
-    name: &'static str,
-    length: &'static str,
-    fields: &[TokenStream2],
-    length_tokens: &TokenStream2,
-    negate: bool,
-    doc_string: &str,
-) -> TokenStream2 {
-    let (negation_qualifier, negation_token) = if negate {
-        ("_neg", quote! { - })
-    } else {
-        ("", quote! {})
-    };
-
-    let method_name = if length.is_empty() {
-        format_ident!("{name}{negation_qualifier}")
-    } else {
-        format_ident!("{name}{negation_qualifier}_{length}")
-    };
-
-    let field_assignments = fields
-        .iter()
-        .map(|field_tokens| {
-            quote! {
-                style.#field_tokens = Some((#negation_token gpui::#length_tokens).into());
-            }
-        })
-        .collect::<Vec<_>>();
-
-    let method = quote! {
-        #[doc = #doc_string]
-        fn #method_name(mut self) -> Self {
-            let style = self.style();
-            #(#field_assignments)*
-            self
-        }
-    };
-
-    method
-}
-
-fn generate_custom_value_setter(
-    prefix: &str,
-    length_type: TokenStream2,
-    fields: &[TokenStream2],
-    doc_string: &str,
-) -> TokenStream2 {
-    let method_name = format_ident!("{}", prefix);
-
-    let mut iter = fields.iter();
-    let last = iter.next_back().unwrap();
-    let field_assignments = iter
-        .map(|field_tokens| {
-            quote! {
-                style.#field_tokens = Some(length.clone().into());
-            }
-        })
-        .chain(std::iter::once(quote! {
-            style.#last = Some(length.into());
-        }))
-        .collect::<Vec<_>>();
-
-    let method = quote! {
-        #[doc = #doc_string]
-        fn #method_name(mut self, length: impl std::clone::Clone + Into<gpui::#length_type>) -> Self {
-            let style = self.style();
-            #(#field_assignments)*
-            self
-        }
-    };
-
-    method
-}
-
-/// Returns a vec of (Property name, has 'auto' suffix, tokens for accessing the property, documentation)
-fn box_prefixes() -> Vec<(&'static str, bool, Vec<TokenStream2>, &'static str)> {
-    vec![
-        (
-            "w",
-            true,
-            vec![quote! { size.width }],
-            "Sets the width of the element. [Docs](https://tailwindcss.com/docs/width)",
-        ),
-        ("h", true, vec![quote! { size.height }], "Sets the height of the element. [Docs](https://tailwindcss.com/docs/height)"),
-        (
-            "size",
-            true,
-            vec![quote! {size.width}, quote! {size.height}],
-            "Sets the width and height of the element."
-        ),
-        // TODO: These don't use the same size ramp as the others
-        // see https://tailwindcss.com/docs/max-width
-        (
-            "min_w",
-            true,
-            vec![quote! { min_size.width }],
-            "Sets the minimum width of the element. [Docs](https://tailwindcss.com/docs/min-width)",
-        ),
-        // TODO: These don't use the same size ramp as the others
-        // see https://tailwindcss.com/docs/max-width
-        (
-            "min_h",
-            true,
-            vec![quote! { min_size.height }],
-            "Sets the minimum height of the element. [Docs](https://tailwindcss.com/docs/min-height)",
-        ),
-        // TODO: These don't use the same size ramp as the others
-        // see https://tailwindcss.com/docs/max-width
-        (
-            "max_w",
-            true,
-            vec![quote! { max_size.width }],
-            "Sets the maximum width of the element. [Docs](https://tailwindcss.com/docs/max-width)",
-        ),
-        // TODO: These don't use the same size ramp as the others
-        // see https://tailwindcss.com/docs/max-width
-        (
-            "max_h",
-            true,
-            vec![quote! { max_size.height }],
-            "Sets the maximum height of the element. [Docs](https://tailwindcss.com/docs/max-height)",
-        ),
-        (
-            "m",
-            true,
-            vec![
-                quote! { margin.top },
-                quote! { margin.bottom },
-                quote! { margin.left },
-                quote! { margin.right },
-            ],
-            "Sets the margin of the element. [Docs](https://tailwindcss.com/docs/margin)"
-        ),
-        ("mt", true, vec![quote! { margin.top }], "Sets the top margin of the element. [Docs](https://tailwindcss.com/docs/margin#add-margin-to-a-single-side)"),
-        (
-            "mb",
-            true,
-            vec![quote! { margin.bottom }],
-            "Sets the bottom margin of the element. [Docs](https://tailwindcss.com/docs/margin#add-margin-to-a-single-side)"
-        ),
-        (
-            "my",
-            true,
-            vec![quote! { margin.top }, quote! { margin.bottom }],
-            "Sets the vertical margin of the element. [Docs](https://tailwindcss.com/docs/margin#add-vertical-margin)"
-        ),
-        (
-            "mx",
-            true,
-            vec![quote! { margin.left }, quote! { margin.right }],
-            "Sets the horizontal margin of the element. [Docs](https://tailwindcss.com/docs/margin#add-horizontal-margin)"
-        ),
-        ("ml", true, vec![quote! { margin.left }], "Sets the left margin of the element. [Docs](https://tailwindcss.com/docs/margin#add-margin-to-a-single-side)"),
-        (
-            "mr",
-            true,
-            vec![quote! { margin.right }],
-            "Sets the right margin of the element. [Docs](https://tailwindcss.com/docs/margin#add-margin-to-a-single-side)"
-        ),
-        (
-            "p",
-            false,
-            vec![
-                quote! { padding.top },
-                quote! { padding.bottom },
-                quote! { padding.left },
-                quote! { padding.right },
-            ],
-            "Sets the padding of the element. [Docs](https://tailwindcss.com/docs/padding)"
-        ),
-        (
-            "pt",
-            false,
-            vec![quote! { padding.top }],
-            "Sets the top padding of the element. [Docs](https://tailwindcss.com/docs/padding#add-padding-to-a-single-side)"
-        ),
-        (
-            "pb",
-            false,
-            vec![quote! { padding.bottom }],
-            "Sets the bottom padding of the element. [Docs](https://tailwindcss.com/docs/padding#add-padding-to-a-single-side)"
-        ),
-        (
-            "px",
-            false,
-            vec![quote! { padding.left }, quote! { padding.right }],
-            "Sets the horizontal padding of the element. [Docs](https://tailwindcss.com/docs/padding#add-horizontal-padding)"
-        ),
-        (
-            "py",
-            false,
-            vec![quote! { padding.top }, quote! { padding.bottom }],
-            "Sets the vertical padding of the element. [Docs](https://tailwindcss.com/docs/padding#add-vertical-padding)"
-        ),
-        (
-            "pl",
-            false,
-            vec![quote! { padding.left }],
-            "Sets the left padding of the element. [Docs](https://tailwindcss.com/docs/padding#add-padding-to-a-single-side)"
-        ),
-        (
-            "pr",
-            false,
-            vec![quote! { padding.right }],
-            "Sets the right padding of the element. [Docs](https://tailwindcss.com/docs/padding#add-padding-to-a-single-side)"
-        ),
-        (
-            "inset",
-            true,
-            vec![quote! { inset.top }, quote! { inset.right }, quote! { inset.bottom }, quote! { inset.left }],
-            "Sets the top, right, bottom, and left values of a positioned element. [Docs](https://tailwindcss.com/docs/top-right-bottom-left)",
-        ),
-        (
-            "top",
-            true,
-            vec![quote! { inset.top }],
-            "Sets the top value of a positioned element. [Docs](https://tailwindcss.com/docs/top-right-bottom-left)",
-        ),
-        (
-            "bottom",
-            true,
-            vec![quote! { inset.bottom }],
-            "Sets the bottom value of a positioned element. [Docs](https://tailwindcss.com/docs/top-right-bottom-left)",
-        ),
-        (
-            "left",
-            true,
-            vec![quote! { inset.left }],
-            "Sets the left value of a positioned element. [Docs](https://tailwindcss.com/docs/top-right-bottom-left)",
-        ),
-        (
-            "right",
-            true,
-            vec![quote! { inset.right }],
-            "Sets the right value of a positioned element. [Docs](https://tailwindcss.com/docs/top-right-bottom-left)",
-        ),
-        (
-            "gap",
-            false,
-            vec![quote! { gap.width }, quote! { gap.height }],
-            "Sets the gap between rows and columns in flex layouts. [Docs](https://tailwindcss.com/docs/gap)"
-        ),
-        (
-            "gap_x",
-            false,
-            vec![quote! { gap.width }],
-            "Sets the gap between columns in flex layouts. [Docs](https://tailwindcss.com/docs/gap#changing-row-and-column-gaps-independently)"
-        ),
-        (
-            "gap_y",
-            false,
-            vec![quote! { gap.height }],
-            "Sets the gap between rows in flex layouts. [Docs](https://tailwindcss.com/docs/gap#changing-row-and-column-gaps-independently)"
-        ),
-    ]
-}
-
-/// Returns a vec of (Suffix size, tokens that correspond to this size, documentation)
-fn box_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
-    vec![
-        ("0", quote! { px(0.) }, "0px"),
-        ("0p5", quote! { rems(0.125) }, "2px (0.125rem)"),
-        ("1", quote! { rems(0.25) }, "4px (0.25rem)"),
-        ("1p5", quote! { rems(0.375) }, "6px (0.375rem)"),
-        ("2", quote! { rems(0.5) }, "8px (0.5rem)"),
-        ("2p5", quote! { rems(0.625) }, "10px (0.625rem)"),
-        ("3", quote! { rems(0.75) }, "12px (0.75rem)"),
-        ("3p5", quote! { rems(0.875) }, "14px (0.875rem)"),
-        ("4", quote! { rems(1.) }, "16px (1rem)"),
-        ("5", quote! { rems(1.25) }, "20px (1.25rem)"),
-        ("6", quote! { rems(1.5) }, "24px (1.5rem)"),
-        ("7", quote! { rems(1.75) }, "28px (1.75rem)"),
-        ("8", quote! { rems(2.0) }, "32px (2rem)"),
-        ("9", quote! { rems(2.25) }, "36px (2.25rem)"),
-        ("10", quote! { rems(2.5) }, "40px (2.5rem)"),
-        ("11", quote! { rems(2.75) }, "44px (2.75rem)"),
-        ("12", quote! { rems(3.) }, "48px (3rem)"),
-        ("16", quote! { rems(4.) }, "64px (4rem)"),
-        ("20", quote! { rems(5.) }, "80px (5rem)"),
-        ("24", quote! { rems(6.) }, "96px (6rem)"),
-        ("32", quote! { rems(8.) }, "128px (8rem)"),
-        ("40", quote! { rems(10.) }, "160px (10rem)"),
-        ("48", quote! { rems(12.) }, "192px (12rem)"),
-        ("56", quote! { rems(14.) }, "224px (14rem)"),
-        ("64", quote! { rems(16.) }, "256px (16rem)"),
-        ("72", quote! { rems(18.) }, "288px (18rem)"),
-        ("80", quote! { rems(20.) }, "320px (20rem)"),
-        ("96", quote! { rems(24.) }, "384px (24rem)"),
-        ("112", quote! { rems(28.) }, "448px (28rem)"),
-        ("128", quote! { rems(32.) }, "512px (32rem)"),
-        ("auto", quote! { auto() }, "Auto"),
-        ("px", quote! { px(1.) }, "1px"),
-        ("full", quote! { relative(1.) }, "100%"),
-        ("1_2", quote! { relative(0.5) }, "50% (1/2)"),
-        ("1_3", quote! { relative(1./3.) }, "33% (1/3)"),
-        ("2_3", quote! { relative(2./3.) }, "66% (2/3)"),
-        ("1_4", quote! { relative(0.25) }, "25% (1/4)"),
-        ("2_4", quote! { relative(0.5) }, "50% (2/4)"),
-        ("3_4", quote! { relative(0.75) }, "75% (3/4)"),
-        ("1_5", quote! { relative(0.2) }, "20% (1/5)"),
-        ("2_5", quote! { relative(0.4) }, "40% (2/5)"),
-        ("3_5", quote! { relative(0.6) }, "60% (3/5)"),
-        ("4_5", quote! { relative(0.8) }, "80% (4/5)"),
-        ("1_6", quote! { relative(1./6.) }, "16% (1/6)"),
-        ("5_6", quote! { relative(5./6.) }, "80% (5/6)"),
-        ("1_12", quote! { relative(1./12.) }, "8% (1/12)"),
-    ]
-}
-
-fn corner_prefixes() -> Vec<(&'static str, Vec<TokenStream2>, &'static str)> {
-    vec![
-        (
-            "rounded",
-            vec![
-                quote! { corner_radii.top_left },
-                quote! { corner_radii.top_right },
-                quote! { corner_radii.bottom_right },
-                quote! { corner_radii.bottom_left },
-            ],
-            "Sets the border radius of the element. [Docs](https://tailwindcss.com/docs/border-radius)"
-        ),
-        (
-            "rounded_t",
-            vec![
-                quote! { corner_radii.top_left },
-                quote! { corner_radii.top_right },
-            ],
-            "Sets the border radius of the top side of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-sides-separately)"
-        ),
-        (
-            "rounded_b",
-            vec![
-                quote! { corner_radii.bottom_left },
-                quote! { corner_radii.bottom_right },
-            ],
-            "Sets the border radius of the bottom side of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-sides-separately)"
-        ),
-        (
-            "rounded_r",
-            vec![
-                quote! { corner_radii.top_right },
-                quote! { corner_radii.bottom_right },
-            ],
-            "Sets the border radius of the right side of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-sides-separately)"
-        ),
-        (
-            "rounded_l",
-            vec![
-                quote! { corner_radii.top_left },
-                quote! { corner_radii.bottom_left },
-            ],
-            "Sets the border radius of the left side of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-sides-separately)"
-        ),
-        (
-            "rounded_tl",
-            vec![quote! { corner_radii.top_left }],
-            "Sets the border radius of the top left corner of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-corners-separately)"
-        ),
-        (
-            "rounded_tr",
-            vec![quote! { corner_radii.top_right }],
-            "Sets the border radius of the top right corner of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-corners-separately)"
-        ),
-        (
-            "rounded_bl",
-            vec![quote! { corner_radii.bottom_left }],
-            "Sets the border radius of the bottom left corner of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-corners-separately)"
-        ),
-        (
-            "rounded_br",
-            vec![quote! { corner_radii.bottom_right }],
-            "Sets the border radius of the bottom right corner of the element. [Docs](https://tailwindcss.com/docs/border-radius#rounding-corners-separately)"
-        ),
-    ]
-}
-
-fn corner_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
-    vec![
-        ("none", quote! { px(0.) }, "0px"),
-        ("sm", quote! { rems(0.125) }, "2px (0.125rem)"),
-        ("md", quote! { rems(0.25) }, "4px (0.25rem)"),
-        ("lg", quote! { rems(0.5) }, "8px (0.5rem)"),
-        ("xl", quote! { rems(0.75) }, "12px (0.75rem)"),
-        ("2xl", quote! { rems(1.) }, "16px (1rem)"),
-        ("3xl", quote! { rems(1.5) }, "24px (1.5rem)"),
-        ("full", quote! {  px(9999.) }, "9999px"),
-    ]
-}
-
-fn border_prefixes() -> Vec<(&'static str, Vec<TokenStream2>, &'static str)> {
-    vec![
-        (
-            "border",
-            vec![
-                quote! { border_widths.top },
-                quote! { border_widths.right },
-                quote! { border_widths.bottom },
-                quote! { border_widths.left },
-            ],
-            "Sets the border width of the element. [Docs](https://tailwindcss.com/docs/border-width)"
-        ),
-        (
-            "border_t",
-            vec![quote! { border_widths.top }],
-            "Sets the border width of the top side of the element. [Docs](https://tailwindcss.com/docs/border-width#individual-sides)"
-        ),
-        (
-            "border_b",
-            vec![quote! { border_widths.bottom }],
-            "Sets the border width of the bottom side of the element. [Docs](https://tailwindcss.com/docs/border-width#individual-sides)"
-        ),
-        (
-            "border_r",
-            vec![quote! { border_widths.right }],
-            "Sets the border width of the right side of the element. [Docs](https://tailwindcss.com/docs/border-width#individual-sides)"
-        ),
-        (
-            "border_l",
-            vec![quote! { border_widths.left }],
-            "Sets the border width of the left side of the element. [Docs](https://tailwindcss.com/docs/border-width#individual-sides)"
-        ),
-        (
-            "border_x",
-            vec![
-                quote! { border_widths.left },
-                quote! { border_widths.right },
-            ],
-            "Sets the border width of the vertical sides of the element. [Docs](https://tailwindcss.com/docs/border-width#horizontal-and-vertical-sides)"
-        ),
-        (
-            "border_y",
-            vec![
-                quote! { border_widths.top },
-                quote! { border_widths.bottom },
-            ],
-            "Sets the border width of the horizontal sides of the element. [Docs](https://tailwindcss.com/docs/border-width#horizontal-and-vertical-sides)"
-        ),
-    ]
-}
-
-fn border_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
-    vec![
-        ("0", quote! { px(0.)}, "0px"),
-        ("1", quote! { px(1.) }, "1px"),
-        ("2", quote! { px(2.) }, "2px"),
-        ("3", quote! { px(3.) }, "3px"),
-        ("4", quote! { px(4.) }, "4px"),
-        ("5", quote! { px(5.) }, "5px"),
-        ("6", quote! { px(6.) }, "6px"),
-        ("7", quote! { px(7.) }, "7px"),
-        ("8", quote! { px(8.) }, "8px"),
-        ("9", quote! { px(9.) }, "9px"),
-        ("10", quote! { px(10.) }, "10px"),
-        ("11", quote! { px(11.) }, "11px"),
-        ("12", quote! { px(12.) }, "12px"),
-        ("16", quote! { px(16.) }, "16px"),
-        ("20", quote! { px(20.) }, "20px"),
-        ("24", quote! { px(24.) }, "24px"),
-        ("32", quote! { px(32.) }, "32px"),
-    ]
-}
--- a/crates/gpui_macros/src/styles.rs
+++ b/crates/gpui_macros/src/styles.rs
--- a/crates/language/src/outline.rs
+++ b/crates/language/src/outline.rs
@@ -5,7 +5,7 @@ use gpui::{
 };
 use settings::Settings;
 use std::ops::Range;
-use theme::{ActiveTheme, ThemeSettings};
+use theme::{color_alpha, ActiveTheme, ThemeSettings};

 /// An outline of all the symbols contained in a buffer.
 #[derive(Debug)]
@@ -146,9 +146,15 @@ impl<T> Outline<T> {

 pub fn render_item<T>(
    outline_item: &OutlineItem<T>,
-    custom_highlights: impl IntoIterator<Item = (Range<usize>, HighlightStyle)>,
+    match_ranges: impl IntoIterator<Item = Range<usize>>,
    cx: &AppContext,
 ) -> StyledText {
+    let mut highlight_style = HighlightStyle::default();
+    highlight_style.background_color = Some(color_alpha(cx.theme().colors().text_accent, 0.3));
+    let custom_highlights = match_ranges
+        .into_iter()
+        .map(|range| (range, highlight_style));
+
    let settings = ThemeSettings::get_global(cx);

    // TODO: We probably shouldn't need to build a whole new text style here
--- a/crates/languages/src/python/config.toml
+++ b/crates/languages/src/python/config.toml
@@ -9,7 +9,7 @@ brackets = [
    { start = "[", end = "]", close = true, newline = true },
    { start = "(", end = ")", close = true, newline = true },
    { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] },
-    { start = "'", end = "'", close = false, newline = false, not_in = ["string"] },
+    { start = "'", end = "'", close = true, newline = false, not_in = ["string"] },
 ]

 auto_indent_using_last_non_empty_line = false
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -18,6 +18,9 @@ use std::{
 };
 use util::{maybe, ResultExt};

+#[cfg(target_os = "windows")]
+const SERVER_PATH: &str = "node_modules/.bin/tailwindcss-language-server.ps1";
+#[cfg(not(target_os = "windows"))]
 const SERVER_PATH: &str = "node_modules/.bin/tailwindcss-language-server";

 fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
@@ -108,11 +111,39 @@ impl LspAdapter for TailwindLspAdapter {
                .await?;
        }

-        Ok(LanguageServerBinary {
-            path: self.node.binary_path().await?,
-            env: None,
-            arguments: server_binary_arguments(&server_path),
-        })
+        #[cfg(target_os = "windows")]
+        {
+            let mut env_path = vec![self
+                .node
+                .binary_path()
+                .await?
+                .parent()
+                .expect("invalid node binary path")
+                .to_path_buf()];
+
+            if let Some(existing_path) = std::env::var_os("PATH") {
+                let mut paths = std::env::split_paths(&existing_path).collect::<Vec<_>>();
+                env_path.append(&mut paths);
+            }
+
+            let env_path = std::env::join_paths(env_path)?;
+            let mut env = HashMap::default();
+            env.insert("PATH".to_string(), env_path.to_string_lossy().to_string());
+
+            Ok(LanguageServerBinary {
+                path: "powershell.exe".into(),
+                env: Some(env),
+                arguments: server_binary_arguments(&server_path),
+            })
+        }
+        #[cfg(not(target_os = "windows"))]
+        {
+            Ok(LanguageServerBinary {
+                path: self.node.binary_path().await?,
+                env: None,
+                arguments: server_binary_arguments(&server_path),
+            })
+        }
    }

    async fn cached_server_binary(
--- a/crates/outline/src/outline.rs
+++ b/crates/outline/src/outline.rs
@@ -3,9 +3,8 @@ use editor::{
 };
 use fuzzy::StringMatch;
 use gpui::{
-    div, rems, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView, HighlightStyle,
-    ParentElement, Point, Render, Styled, Task, View, ViewContext, VisualContext, WeakView,
-    WindowContext,
+    div, rems, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView, ParentElement,
+    Point, Render, Styled, Task, View, ViewContext, VisualContext, WeakView, WindowContext,
 };
 use language::Outline;
 use ordered_float::OrderedFloat;
@@ -15,7 +14,7 @@ use std::{
    sync::Arc,
 };

-use theme::{color_alpha, ActiveTheme};
+use theme::ActiveTheme;
 use ui::{prelude::*, ListItem, ListItemSpacing};
 use util::ResultExt;
 use workspace::{DismissDecision, ModalView};
@@ -272,10 +271,6 @@ impl PickerDelegate for OutlineViewDelegate {
        let mat = self.matches.get(ix)?;
        let outline_item = self.outline.items.get(mat.candidate_id)?;

-        let mut highlight_style = HighlightStyle::default();
-        highlight_style.background_color = Some(color_alpha(cx.theme().colors().text_accent, 0.3));
-        let custom_highlights = mat.ranges().map(|range| (range, highlight_style));
-
        Some(
            ListItem::new(ix)
                .inset(true)
@@ -285,7 +280,7 @@ impl PickerDelegate for OutlineViewDelegate {
                    div()
                        .text_ui(cx)
                        .pl(rems(outline_item.depth as f32))
-                        .child(language::render_item(outline_item, custom_highlights, cx)),
+                        .child(language::render_item(outline_item, mat.ranges(), cx)),
                ),
        )
    }
--- a/crates/outline_panel/Cargo.toml
+++ b/crates/outline_panel/Cargo.toml
@@ -18,6 +18,7 @@ collections.workspace = true
 db.workspace = true
 editor.workspace = true
 file_icons.workspace = true
+fuzzy.workspace = true
 itertools.workspace = true
 gpui.workspace = true
 language.workspace = true
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -63,6 +63,7 @@ shlex.workspace = true
 similar = "1.3"
 smol.workspace = true
 snippet.workspace = true
+snippet_provider.workspace = true
 terminal.workspace = true
 text.workspace = true
 util.workspace = true
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -19,7 +19,7 @@ use client::{
    TypedEnvelope, UserStore,
 };
 use clock::ReplicaId;
-use collections::{btree_map, hash_map, BTreeMap, HashMap, HashSet, VecDeque};
+use collections::{btree_map, hash_map, BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
 use debounced_delay::DebouncedDelay;
 use futures::{
    channel::{
@@ -84,6 +84,7 @@ use similar::{ChangeTag, TextDiff};
 use smol::channel::{Receiver, Sender};
 use smol::lock::Semaphore;
 use snippet::Snippet;
+use snippet_provider::SnippetProvider;
 use std::{
    borrow::Cow,
    cmp::{self, Ordering},
@@ -229,6 +230,7 @@ pub struct Project {
    hosted_project_id: Option<ProjectId>,
    dev_server_project_id: Option<client::DevServerProjectId>,
    search_history: SearchHistory,
+    snippets: Model<SnippetProvider>,
 }

 pub enum LanguageServerToQuery {
@@ -719,7 +721,9 @@ impl Project {
            cx.spawn(move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx))
                .detach();
            let tasks = Inventory::new(cx);
-
+            let global_snippets_dir = paths::config_dir().join("snippets");
+            let snippets =
+                SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
            Self {
                worktrees: Vec::new(),
                worktrees_reordered: false,
@@ -745,6 +749,7 @@ impl Project {
                _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
                _maintain_workspace_config: Self::maintain_workspace_config(cx),
                active_entry: None,
+                snippets,
                languages,
                client,
                user_store,
@@ -841,6 +846,9 @@ impl Project {
        let this = cx.new_model(|cx| {
            let replica_id = response.payload.replica_id as ReplicaId;
            let tasks = Inventory::new(cx);
+            let global_snippets_dir = paths::config_dir().join("snippets");
+            let snippets =
+                SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
            // BIG CAUTION NOTE: The order in which we initialize fields here matters and it should match what's done in Self::local.
            // Otherwise, you might run into issues where worktree id on remote is different than what's on local host.
            // That's because Worktree's identifier is entity id, which should probably be changed.
@@ -859,6 +867,7 @@ impl Project {
            let (tx, rx) = mpsc::unbounded();
            cx.spawn(move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx))
                .detach();
+
            let mut this = Self {
                worktrees: Vec::new(),
                worktrees_reordered: false,
@@ -877,6 +886,7 @@ impl Project {
                _maintain_workspace_config: Self::maintain_workspace_config(cx),
                languages,
                user_store: user_store.clone(),
+                snippets,
                fs,
                next_entry_id: Default::default(),
                next_diagnostic_group_id: Default::default(),
@@ -1336,6 +1346,10 @@ impl Project {
        &self.tasks
    }

+    pub fn snippets(&self) -> &Model<SnippetProvider> {
+        &self.snippets
+    }
+
    pub fn search_history(&self) -> &SearchHistory {
        &self.search_history
    }
@@ -3662,29 +3676,26 @@ impl Project {
                    let this = this.clone();
                    let name = name.to_string();
                    async move {
-                        if let Some(actions) = params.actions {
-                            let (tx, mut rx) = smol::channel::bounded(1);
-                            let request = LanguageServerPromptRequest {
-                                level: match params.typ {
-                                    lsp::MessageType::ERROR => PromptLevel::Critical,
-                                    lsp::MessageType::WARNING => PromptLevel::Warning,
-                                    _ => PromptLevel::Info,
-                                },
-                                message: params.message,
-                                actions,
-                                response_channel: tx,
-                                lsp_name: name.clone(),
-                            };
+                        let actions = params.actions.unwrap_or_default();
+                        let (tx, mut rx) = smol::channel::bounded(1);
+                        let request = LanguageServerPromptRequest {
+                            level: match params.typ {
+                                lsp::MessageType::ERROR => PromptLevel::Critical,
+                                lsp::MessageType::WARNING => PromptLevel::Warning,
+                                _ => PromptLevel::Info,
+                            },
+                            message: params.message,
+                            actions,
+                            response_channel: tx,
+                            lsp_name: name.clone(),
+                        };

-                            if let Ok(_) = this.update(&mut cx, |_, cx| {
-                                cx.emit(Event::LanguageServerPrompt(request));
-                            }) {
-                                let response = rx.next().await;
+                        if let Ok(_) = this.update(&mut cx, |_, cx| {
+                            cx.emit(Event::LanguageServerPrompt(request));
+                        }) {
+                            let response = rx.next().await;

-                                Ok(response)
-                            } else {
-                                Ok(None)
-                            }
+                            Ok(response)
                        } else {
                            Ok(None)
                        }
@@ -3739,7 +3750,33 @@ impl Project {
                }
            })
            .detach();
+        language_server
+            .on_notification::<lsp::notification::ShowMessage, _>({
+                let this = this.clone();
+                let name = name.to_string();
+                move |params, mut cx| {
+                    let this = this.clone();
+                    let name = name.to_string();

+                    let (tx, _) = smol::channel::bounded(1);
+                    let request = LanguageServerPromptRequest {
+                        level: match params.typ {
+                            lsp::MessageType::ERROR => PromptLevel::Critical,
+                            lsp::MessageType::WARNING => PromptLevel::Warning,
+                            _ => PromptLevel::Info,
+                        },
+                        message: params.message,
+                        actions: vec![],
+                        response_channel: tx,
+                        lsp_name: name.clone(),
+                    };
+
+                    let _ = this.update(&mut cx, |_, cx| {
+                        cx.emit(Event::LanguageServerPrompt(request));
+                    });
+                }
+            })
+            .detach();
        language_server
            .on_notification::<lsp::notification::Progress, _>(move |params, mut cx| {
                if let Some(this) = this.upgrade() {
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -137,7 +137,7 @@ actions!(
        CopyPath,
        CopyRelativePath,
        Duplicate,
-        RevealInFinder,
+        RevealInFileManager,
        Cut,
        Paste,
        Rename,
@@ -477,7 +477,12 @@ impl ProjectPanel {
                        menu.action("New File", Box::new(NewFile))
                            .action("New Folder", Box::new(NewDirectory))
                            .separator()
-                            .action("Reveal in Finder", Box::new(RevealInFinder))
+                            .when(cfg!(target_os = "macos"), |menu| {
+                                menu.action("Reveal in Finder", Box::new(RevealInFileManager))
+                            })
+                            .when(cfg!(not(target_os = "macos")), |menu| {
+                                menu.action("Reveal in File Manager", Box::new(RevealInFileManager))
+                            })
                            .action("Open in Terminal", Box::new(OpenInTerminal))
                            .when(is_dir, |menu| {
                                menu.separator()
@@ -1353,7 +1358,7 @@ impl ProjectPanel {
        }
    }

-    fn reveal_in_finder(&mut self, _: &RevealInFinder, cx: &mut ViewContext<Self>) {
+    fn reveal_in_finder(&mut self, _: &RevealInFileManager, cx: &mut ViewContext<Self>) {
        if let Some((worktree, entry)) = self.selected_entry(cx) {
            cx.reveal_path(&worktree.abs_path().join(&entry.path));
        }
--- a/crates/recent_projects/Cargo.toml
+++ b/crates/recent_projects/Cargo.toml
@@ -31,7 +31,7 @@ smol.workspace = true
 task.workspace = true
 terminal_view.workspace = true
 ui.workspace = true
-ui_text_field.workspace = true
+ui_input.workspace = true
 util.workspace = true
 workspace.workspace = true

--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -31,7 +31,7 @@ use ui::{
    prelude::*, Indicator, List, ListHeader, ListItem, Modal, ModalFooter, ModalHeader,
    RadioWithLabel, Tooltip,
 };
-use ui_text_field::{FieldLabelLayout, TextField};
+use ui_input::{FieldLabelLayout, TextField};
 use util::ResultExt;
 use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspace, WORKSPACE_DB};

--- a/crates/repl/src/outputs.rs
+++ b/crates/repl/src/outputs.rs
@@ -2,11 +2,13 @@ use std::sync::Arc;

 use crate::stdio::TerminalOutput;
 use anyhow::Result;
-use gpui::{img, AnyElement, FontWeight, ImageData, Render, View};
+use gpui::{img, AnyElement, FontWeight, ImageData, Render, TextRun, View};
 use runtimelib::datatable::TableSchema;
 use runtimelib::media::datatable::TabularDataResource;
 use runtimelib::{ExecutionState, JupyterMessageContent, MimeBundle, MimeType};
 use serde_json::Value;
+use settings::Settings;
+use theme::ThemeSettings;
 use ui::{div, prelude::*, v_flex, IntoElement, Styled, ViewContext};

 // Given these outputs are destined for the editor with the block decorations API, all of them must report
@@ -97,9 +99,67 @@ impl LineHeight for ImageView {
 /// It uses the https://specs.frictionlessdata.io/tabular-data-resource/ specification for data interchange.
 pub struct TableView {
    pub table: TabularDataResource,
+    pub widths: Vec<Pixels>,
+}
+
+fn cell_content(row: &Value, field: &str) -> String {
+    match row.get(&field) {
+        Some(Value::String(s)) => s.clone(),
+        Some(Value::Number(n)) => n.to_string(),
+        Some(Value::Bool(b)) => b.to_string(),
+        Some(Value::Array(arr)) => format!("{:?}", arr),
+        Some(Value::Object(obj)) => format!("{:?}", obj),
+        Some(Value::Null) | None => String::new(),
+    }
 }

 impl TableView {
+    pub fn new(table: TabularDataResource, cx: &mut WindowContext) -> Self {
+        let mut widths = Vec::with_capacity(table.schema.fields.len());
+
+        let text_system = cx.text_system();
+        let text_style = cx.text_style();
+        let text_font = ThemeSettings::get_global(cx).buffer_font.clone();
+        let font_size = ThemeSettings::get_global(cx).buffer_font_size;
+        let mut runs = [TextRun {
+            len: 0,
+            font: text_font,
+            color: text_style.color,
+            background_color: None,
+            underline: None,
+            strikethrough: None,
+        }];
+
+        for field in table.schema.fields.iter() {
+            runs[0].len = field.name.len();
+            let mut width = text_system
+                .layout_line(&field.name, font_size, &runs)
+                .map(|layout| layout.width)
+                .unwrap_or(px(0.));
+
+            let Some(data) = table.data.as_ref() else {
+                widths.push(width);
+                continue;
+            };
+
+            for row in data {
+                let content = cell_content(&row, &field.name);
+                runs[0].len = content.len();
+                let cell_width = cx
+                    .text_system()
+                    .layout_line(&content, font_size, &runs)
+                    .map(|layout| layout.width)
+                    .unwrap_or(px(0.));
+
+                width = width.max(cell_width)
+            }
+
+            widths.push(width)
+        }
+
+        Self { table, widths }
+    }
+
    pub fn render(&self, cx: &ViewContext<ExecutionView>) -> AnyElement {
        let data = match &self.table.data {
            Some(data) => data,
@@ -119,6 +179,8 @@ impl TableView {
            .map(|row| self.render_row(&self.table.schema, false, &row, cx));

        v_flex()
+            .id("table")
+            .overflow_x_scroll()
            .w_full()
            .child(header)
            .children(body)
@@ -137,7 +199,8 @@ impl TableView {
        let row_cells = schema
            .fields
            .iter()
-            .map(|field| {
+            .zip(self.widths.iter())
+            .map(|(field, width)| {
                let container = match field.field_type {
                    runtimelib::datatable::FieldType::String => div(),

@@ -153,17 +216,11 @@ impl TableView {
                    _ => div(),
                };

-                let value = match row.get(&field.name) {
-                    Some(Value::String(s)) => s.clone(),
-                    Some(Value::Number(n)) => n.to_string(),
-                    Some(Value::Bool(b)) => b.to_string(),
-                    Some(Value::Array(arr)) => format!("{:?}", arr),
-                    Some(Value::Object(obj)) => format!("{:?}", obj),
-                    Some(Value::Null) | None => String::new(),
-                };
+                let value = cell_content(row, &field.name);

                let mut cell = container
-                    .w_full()
+                    .min_w(*width + px(22.))
+                    .w(*width + px(22.))
                    .child(value)
                    .px_2()
                    .py_1()
@@ -178,7 +235,16 @@ impl TableView {
            })
            .collect::<Vec<_>>();

-        h_flex().children(row_cells).into_any_element()
+        let mut total_width = px(0.);
+        for width in self.widths.iter() {
+            // Width fudge factor: border + 2 (heading), padding
+            total_width += *width + px(22.);
+        }
+
+        h_flex()
+            .w(total_width)
+            .children(row_cells)
+            .into_any_element()
    }
 }

@@ -266,6 +332,20 @@ impl OutputType {

        el
    }
+
+    pub fn new(data: &MimeBundle, cx: &mut WindowContext) -> Self {
+        match data.richest(rank_mime_type) {
+            Some(MimeType::Plain(text)) => OutputType::Plain(TerminalOutput::from(text)),
+            Some(MimeType::Markdown(text)) => OutputType::Plain(TerminalOutput::from(text)),
+            Some(MimeType::Png(data)) | Some(MimeType::Jpeg(data)) => match ImageView::from(data) {
+                Ok(view) => OutputType::Image(view),
+                Err(error) => OutputType::Message(format!("Failed to load image: {}", error)),
+            },
+            Some(MimeType::DataTable(data)) => OutputType::Table(TableView::new(data.clone(), cx)),
+            // Any other media types are not supported
+            _ => OutputType::Message("Unsupported media type".to_string()),
+        }
+    }
 }

 impl LineHeight for OutputType {
@@ -283,24 +363,6 @@ impl LineHeight for OutputType {
    }
 }

-impl From<&MimeBundle> for OutputType {
-    fn from(data: &MimeBundle) -> Self {
-        match data.richest(rank_mime_type) {
-            Some(MimeType::Plain(text)) => OutputType::Plain(TerminalOutput::from(text)),
-            Some(MimeType::Markdown(text)) => OutputType::Plain(TerminalOutput::from(text)),
-            Some(MimeType::Png(data)) | Some(MimeType::Jpeg(data)) => match ImageView::from(data) {
-                Ok(view) => OutputType::Image(view),
-                Err(error) => OutputType::Message(format!("Failed to load image: {}", error)),
-            },
-            Some(MimeType::DataTable(data)) => OutputType::Table(TableView {
-                table: data.clone(),
-            }),
-            // Any other media types are not supported
-            _ => OutputType::Message("Unsupported media type".to_string()),
-        }
-    }
-}
-
 #[derive(Default, Clone)]
 pub enum ExecutionStatus {
    #[default]
@@ -330,8 +392,8 @@ impl ExecutionView {
    /// Accept a Jupyter message belonging to this execution
    pub fn push_message(&mut self, message: &JupyterMessageContent, cx: &mut ViewContext<Self>) {
        let output: OutputType = match message {
-            JupyterMessageContent::ExecuteResult(result) => (&result.data).into(),
-            JupyterMessageContent::DisplayData(result) => (&result.data).into(),
+            JupyterMessageContent::ExecuteResult(result) => OutputType::new(&result.data, cx),
+            JupyterMessageContent::DisplayData(result) => OutputType::new(&result.data, cx),
            JupyterMessageContent::StreamContent(result) => {
                // Previous stream data will combine together, handling colors, carriage returns, etc
                if let Some(new_terminal) = self.apply_terminal_text(&result.text) {
@@ -357,7 +419,7 @@ impl ExecutionView {
                        // Pager data comes in via `?` at the end of a statement in Python, used for showing documentation.
                        // Some UI will show this as a popup. For ease of implementation, it's included as an output here.
                        runtimelib::Payload::Page { data, .. } => {
-                            let output: OutputType = (data).into();
+                            let output = OutputType::new(data, cx);
                            self.outputs.push(output);
                        }

--- a/crates/repl/src/session.rs
+++ b/crates/repl/src/session.rs
@@ -89,6 +89,7 @@ impl EditorBlock {
        let render = move |cx: &mut BlockContext| {
            let execution_view = execution_view.clone();
            let text_font = ThemeSettings::get_global(cx).buffer_font.family.clone();
+            let text_font_size = ThemeSettings::get_global(cx).buffer_font_size;
            // Note: we'll want to use `cx.anchor_x` when someone runs something with no output -- just show a checkmark and not make the full block below the line

            let gutter_width = cx.gutter_dimensions.width;
@@ -101,6 +102,7 @@ impl EditorBlock {
                .pl(gutter_width)
                .child(
                    div()
+                        .text_size(text_font_size)
                        .font_family(text_font)
                        // .ml(gutter_width)
                        .mx_1()
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -1458,9 +1458,9 @@ impl Render for ProjectSearchBar {
            )
            .when(limit_reached, |this| {
                this.child(
-                    div()
-                        .child(Label::new("Search limit reached").color(Color::Warning))
-                        .ml_2(),
+                    Label::new("Search limit reached")
+                        .ml_2()
+                        .color(Color::Warning),
                )
            });

--- a/crates/snippet_provider/Cargo.toml
+++ b/crates/snippet_provider/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "snippet_provider"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow.workspace = true
+collections.workspace = true
+fs.workspace = true
+futures.workspace = true
+gpui.workspace = true
+parking_lot.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+snippet.workspace = true
+util.workspace = true
--- a/crates/snippet_provider/LICENSE-GPL
+++ b/crates/snippet_provider/LICENSE-GPL
--- a/crates/snippet_provider/src/format.rs
+++ b/crates/snippet_provider/src/format.rs
@@ -0,0 +1,44 @@
+use collections::HashMap;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub(crate) struct VSSnippetsFile {
+    #[serde(flatten)]
+    pub(crate) snippets: HashMap<String, VSCodeSnippet>,
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub(crate) enum ListOrDirect {
+    Single(String),
+    List(Vec<String>),
+}
+
+impl From<ListOrDirect> for Vec<String> {
+    fn from(list: ListOrDirect) -> Self {
+        match list {
+            ListOrDirect::Single(entry) => vec![entry],
+            ListOrDirect::List(entries) => entries,
+        }
+    }
+}
+
+impl std::fmt::Display for ListOrDirect {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Single(v) => v.to_owned(),
+                Self::List(v) => v.join("\n"),
+            }
+        )
+    }
+}
+
+#[derive(Deserialize)]
+pub(crate) struct VSCodeSnippet {
+    pub(crate) prefix: Option<ListOrDirect>,
+    pub(crate) body: ListOrDirect,
+    pub(crate) description: Option<ListOrDirect>,
+}
--- a/crates/snippet_provider/src/lib.rs
+++ b/crates/snippet_provider/src/lib.rs
@@ -0,0 +1,211 @@
+mod format;
+mod registry;
+
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::Duration,
+};
+
+use anyhow::Result;
+use collections::{BTreeMap, BTreeSet, HashMap};
+use format::VSSnippetsFile;
+use fs::Fs;
+use futures::stream::StreamExt;
+use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext, Task, WeakModel};
+pub use registry::*;
+use util::ResultExt;
+
+pub fn init(cx: &mut AppContext) {
+    SnippetRegistry::init_global(cx);
+}
+
+// Is `None` if the snippet file is global.
+type SnippetKind = Option<String>;
+fn file_stem_to_key(stem: &str) -> SnippetKind {
+    if stem == "snippets" {
+        None
+    } else {
+        Some(stem.to_owned())
+    }
+}
+
+fn file_to_snippets(file_contents: VSSnippetsFile) -> Vec<Arc<Snippet>> {
+    let mut snippets = vec![];
+    for (prefix, snippet) in file_contents.snippets {
+        let prefixes = snippet
+            .prefix
+            .map_or_else(move || vec![prefix], |prefixes| prefixes.into());
+        let description = snippet
+            .description
+            .map(|description| description.to_string());
+        let body = snippet.body.to_string();
+        if snippet::Snippet::parse(&body).log_err().is_none() {
+            continue;
+        };
+        snippets.push(Arc::new(Snippet {
+            body,
+            prefix: prefixes,
+            description,
+        }));
+    }
+    snippets
+}
+// Snippet with all of the metadata
+#[derive(Debug)]
+pub struct Snippet {
+    pub prefix: Vec<String>,
+    pub body: String,
+    pub description: Option<String>,
+}
+
+async fn process_updates(
+    this: WeakModel<SnippetProvider>,
+    entries: Vec<PathBuf>,
+    mut cx: AsyncAppContext,
+) -> Result<()> {
+    let fs = this.update(&mut cx, |this, _| this.fs.clone())?;
+    for entry_path in entries {
+        if !entry_path
+            .extension()
+            .map_or(false, |extension| extension == "json")
+        {
+            continue;
+        }
+        let entry_metadata = fs.metadata(&entry_path).await;
+        // Entry could have been removed, in which case we should no longer show completions for it.
+        let entry_exists = entry_metadata.is_ok();
+        if entry_metadata.map_or(false, |entry| entry.map_or(false, |e| e.is_dir)) {
+            // Don't process dirs.
+            continue;
+        }
+        let Some(stem) = entry_path.file_stem().and_then(|s| s.to_str()) else {
+            continue;
+        };
+        let key = file_stem_to_key(stem);
+
+        let contents = if entry_exists {
+            fs.load(&entry_path).await.ok()
+        } else {
+            None
+        };
+
+        this.update(&mut cx, move |this, _| {
+            let snippets_of_kind = this.snippets.entry(key).or_default();
+            if entry_exists {
+                let Some(file_contents) = contents else {
+                    return;
+                };
+                let Ok(as_json) = serde_json::from_str::<VSSnippetsFile>(&file_contents) else {
+                    return;
+                };
+                let snippets = file_to_snippets(as_json);
+                *snippets_of_kind.entry(entry_path).or_default() = snippets;
+            } else {
+                snippets_of_kind.remove(&entry_path);
+            }
+        })?;
+    }
+    Ok(())
+}
+
+async fn initial_scan(
+    this: WeakModel<SnippetProvider>,
+    path: Arc<Path>,
+    mut cx: AsyncAppContext,
+) -> Result<()> {
+    let fs = this.update(&mut cx, |this, _| this.fs.clone())?;
+    let entries = fs.read_dir(&path).await;
+    if let Ok(entries) = entries {
+        let entries = entries
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>>>()?;
+        process_updates(this, entries, cx).await?;
+    }
+    Ok(())
+}
+
+pub struct SnippetProvider {
+    fs: Arc<dyn Fs>,
+    snippets: HashMap<SnippetKind, BTreeMap<PathBuf, Vec<Arc<Snippet>>>>,
+}
+
+impl SnippetProvider {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        dirs_to_watch: BTreeSet<PathBuf>,
+        cx: &mut AppContext,
+    ) -> Model<Self> {
+        cx.new_model(move |cx| {
+            let mut this = Self {
+                fs,
+                snippets: Default::default(),
+            };
+
+            let mut task_handles = vec![];
+            for dir in dirs_to_watch {
+                task_handles.push(this.watch_directory(&dir, cx));
+            }
+            cx.spawn(|_, _| async move {
+                futures::future::join_all(task_handles).await;
+            })
+            .detach();
+
+            this
+        })
+    }
+
+    /// Add directory to be watched for content changes
+    fn watch_directory(&mut self, path: &Path, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        let path: Arc<Path> = Arc::from(path);
+
+        cx.spawn(|this, mut cx| async move {
+            let fs = this.update(&mut cx, |this, _| this.fs.clone())?;
+            let watched_path = path.clone();
+            let watcher = fs.watch(&watched_path, Duration::from_secs(1));
+            initial_scan(this.clone(), path, cx.clone()).await?;
+
+            let (mut entries, _) = watcher.await;
+            while let Some(entries) = entries.next().await {
+                process_updates(this.clone(), entries, cx.clone()).await?;
+            }
+            Ok(())
+        })
+    }
+
+    fn lookup_snippets<'a>(
+        &'a self,
+        language: &'a SnippetKind,
+        cx: &AppContext,
+    ) -> Vec<Arc<Snippet>> {
+        let mut user_snippets: Vec<_> = self
+            .snippets
+            .get(&language)
+            .cloned()
+            .unwrap_or_default()
+            .into_iter()
+            .flat_map(|(_, snippets)| snippets.into_iter())
+            .collect();
+
+        let Some(registry) = SnippetRegistry::try_global(cx) else {
+            return user_snippets;
+        };
+
+        let registry_snippets = registry.get_snippets(language);
+        user_snippets.extend(registry_snippets);
+
+        user_snippets
+    }
+
+    pub fn snippets_for(&self, language: SnippetKind, cx: &AppContext) -> Vec<Arc<Snippet>> {
+        let mut requested_snippets = self.lookup_snippets(&language, cx);
+
+        if language.is_some() {
+            // Look up global snippets as well.
+            requested_snippets.extend(self.lookup_snippets(&None, cx));
+        }
+        requested_snippets
+    }
+}
--- a/crates/snippet_provider/src/registry.rs
+++ b/crates/snippet_provider/src/registry.rs
@@ -0,0 +1,53 @@
+use std::{path::Path, sync::Arc};
+
+use anyhow::Result;
+use collections::HashMap;
+use gpui::{AppContext, Global, ReadGlobal, UpdateGlobal};
+use parking_lot::RwLock;
+
+use crate::{file_stem_to_key, Snippet, SnippetKind};
+
+struct GlobalSnippetRegistry(Arc<SnippetRegistry>);
+
+impl Global for GlobalSnippetRegistry {}
+
+#[derive(Default)]
+pub struct SnippetRegistry {
+    snippets: RwLock<HashMap<SnippetKind, Vec<Arc<Snippet>>>>,
+}
+
+impl SnippetRegistry {
+    pub fn global(cx: &AppContext) -> Arc<Self> {
+        GlobalSnippetRegistry::global(cx).0.clone()
+    }
+
+    pub fn try_global(cx: &AppContext) -> Option<Arc<Self>> {
+        cx.try_global::<GlobalSnippetRegistry>()
+            .map(|registry| registry.0.clone())
+    }
+
+    pub fn init_global(cx: &mut AppContext) {
+        GlobalSnippetRegistry::set_global(cx, GlobalSnippetRegistry(Arc::new(Self::new())))
+    }
+
+    pub fn new() -> Self {
+        Self {
+            snippets: RwLock::new(HashMap::default()),
+        }
+    }
+
+    pub fn register_snippets(&self, file_path: &Path, contents: &str) -> Result<()> {
+        let snippets_in_file: crate::format::VSSnippetsFile = serde_json::from_str(contents)?;
+        let kind = file_path
+            .file_stem()
+            .and_then(|stem| stem.to_str().and_then(file_stem_to_key));
+        let snippets = crate::file_to_snippets(snippets_in_file);
+        self.snippets.write().insert(kind, snippets);
+
+        Ok(())
+    }
+
+    pub fn get_snippets(&self, kind: &SnippetKind) -> Vec<Arc<Snippet>> {
+        self.snippets.read().get(kind).cloned().unwrap_or_default()
+    }
+}
--- a/crates/sqlez/Cargo.lock
+++ b/crates/sqlez/Cargo.lock
@@ -1,150 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "addr2line"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9ecd88a8c8378ca913a680cd98f0f13ac67383d35993f86c90a70e3f137816b"
-dependencies = [
- "gimli",
-]
-
-[[package]]
-name = "adler"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
-
-[[package]]
-name = "anyhow"
-version = "1.0.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "216261ddc8289130e551ddcd5ce8a064710c0d064a4d2895c67151c92b5443f6"
-dependencies = [
- "backtrace",
-]
-
-[[package]]
-name = "backtrace"
-version = "0.3.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab84319d616cfb654d03394f38ab7e6f0919e181b1b57e1fd15e7fb4077d9a7"
-dependencies = [
- "addr2line",
- "cc",
- "cfg-if",
- "libc",
- "miniz_oxide",
- "object",
- "rustc-demangle",
-]
-
-[[package]]
-name = "cc"
-version = "1.0.73"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "gimli"
-version = "0.26.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
-
-[[package]]
-name = "indoc"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adab1eaa3408fb7f0c777a73e7465fd5656136fc93b670eb6df3c88c2c1344e3"
-
-[[package]]
-name = "libc"
-version = "0.2.137"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
-
-[[package]]
-name = "libsqlite3-sys"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29f835d03d717946d28b1d1ed632eb6f0e24a299388ee623d0c23118d3e8a7fa"
-dependencies = [
- "cc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "memchr"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-
-[[package]]
-name = "miniz_oxide"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
-dependencies = [
- "adler",
-]
-
-[[package]]
-name = "object"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
-
-[[package]]
-name = "pkg-config"
-version = "0.3.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
-
-[[package]]
-name = "rustc-demangle"
-version = "0.1.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
-
-[[package]]
-name = "sqlez"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "indoc",
- "libsqlite3-sys",
- "thread_local",
-]
-
-[[package]]
-name = "thread_local"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
-dependencies = [
- "once_cell",
-]
-
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
--- a/crates/storybook/Cargo.lock
+++ b/crates/storybook/Cargo.lock
--- a/crates/storybook/Cargo.toml
+++ b/crates/storybook/Cargo.toml
@@ -33,6 +33,7 @@ simplelog = "0.9"
 story.workspace = true
 strum = { version = "0.25.0", features = ["derive"] }
 theme.workspace = true
+title_bar = { workspace = true, features = ["stories"] }
 ui = { workspace = true, features = ["stories"] }

 [dev-dependencies]
--- a/crates/storybook/src/story_selector.rs
+++ b/crates/storybook/src/story_selector.rs
@@ -12,6 +12,7 @@ use ui::prelude::*;
 #[derive(Debug, PartialEq, Eq, Clone, Copy, strum::Display, EnumString, EnumIter)]
 #[strum(serialize_all = "snake_case")]
 pub enum ComponentStory {
+    ApplicationMenu,
    AutoHeightEditor,
    Avatar,
    Button,
@@ -35,7 +36,6 @@ pub enum ComponentStory {
    Tab,
    TabBar,
    Text,
-    // TitleBar,
    ToggleButton,
    ToolStrip,
    ViewportUnits,
@@ -45,6 +45,7 @@ pub enum ComponentStory {
 impl ComponentStory {
    pub fn story(&self, cx: &mut WindowContext) -> AnyView {
        match self {
+            Self::ApplicationMenu => cx.new_view(|_| title_bar::ApplicationMenuStory).into(),
            Self::AutoHeightEditor => AutoHeightEditorStory::new(cx).into(),
            Self::Avatar => cx.new_view(|_| ui::AvatarStory).into(),
            Self::Button => cx.new_view(|_| ui::ButtonStory).into(),
@@ -69,7 +70,6 @@ impl ComponentStory {
            Self::Text => TextStory::view(cx).into(),
            Self::Tab => cx.new_view(|_| ui::TabStory).into(),
            Self::TabBar => cx.new_view(|_| ui::TabBarStory).into(),
-            // Self::TitleBar => cx.new_view(|_| title_bar::TitleBarStory).into(),
            Self::ToggleButton => cx.new_view(|_| ui::ToggleButtonStory).into(),
            Self::ToolStrip => cx.new_view(|_| ui::ToolStripStory).into(),
            Self::ViewportUnits => cx.new_view(|_| crate::stories::ViewportUnitsStory).into(),
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -381,6 +381,10 @@ pub fn adjust_buffer_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
    cx.refresh();
 }

+pub fn has_adjusted_buffer_font_size(cx: &mut AppContext) -> bool {
+    cx.has_global::<AdjustedBufferFontSize>()
+}
+
 pub fn reset_buffer_font_size(cx: &mut AppContext) {
    if cx.has_global::<AdjustedBufferFontSize>() {
        cx.remove_global::<AdjustedBufferFontSize>();
@@ -417,6 +421,10 @@ pub fn adjust_ui_font_size(cx: &mut WindowContext, f: fn(&mut Pixels)) {
    cx.refresh();
 }

+pub fn has_adjusted_ui_font_size(cx: &mut AppContext) -> bool {
+    cx.has_global::<AdjustedUiFontSize>()
+}
+
 pub fn reset_ui_font_size(cx: &mut WindowContext) {
    if cx.has_global::<AdjustedUiFontSize>() {
        cx.remove_global::<AdjustedUiFontSize>();
--- a/crates/title_bar/Cargo.toml
+++ b/crates/title_bar/Cargo.toml
@@ -42,7 +42,6 @@ project.workspace = true
 recent_projects.workspace = true
 rpc.workspace = true
 serde.workspace = true
-settings.workspace = true
 smallvec.workspace = true
 story = { workspace = true, optional = true }
 theme.workspace = true
--- a/crates/title_bar/src/application_menu.rs
+++ b/crates/title_bar/src/application_menu.rs
@@ -0,0 +1,128 @@
+use ui::{prelude::*, ContextMenu, NumericStepper, PopoverMenu, Tooltip};
+
+#[derive(IntoElement)]
+pub struct ApplicationMenu;
+
+impl ApplicationMenu {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl RenderOnce for ApplicationMenu {
+    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
+        PopoverMenu::new("application-menu")
+            .menu(move |cx| {
+                ContextMenu::build(cx, move |menu, _cx| {
+                    menu.header("Workspace")
+                        .action("Open Command Palette", Box::new(command_palette::Toggle))
+                        .custom_row(move |cx| {
+                            h_flex()
+                                .gap_2()
+                                .w_full()
+                                .justify_between()
+                                .cursor(gpui::CursorStyle::Arrow)
+                                .child(Label::new("Buffer Font Size"))
+                                .child(
+                                    NumericStepper::new(
+                                        theme::get_buffer_font_size(cx).to_string(),
+                                        |_, cx| {
+                                            cx.dispatch_action(Box::new(
+                                                zed_actions::DecreaseBufferFontSize,
+                                            ))
+                                        },
+                                        |_, cx| {
+                                            cx.dispatch_action(Box::new(
+                                                zed_actions::IncreaseBufferFontSize,
+                                            ))
+                                        },
+                                    )
+                                    .when(
+                                        theme::has_adjusted_buffer_font_size(cx),
+                                        |stepper| {
+                                            stepper.on_reset(|_, cx| {
+                                                cx.dispatch_action(Box::new(
+                                                    zed_actions::ResetBufferFontSize,
+                                                ))
+                                            })
+                                        },
+                                    ),
+                                )
+                                .into_any_element()
+                        })
+                        .custom_row(move |cx| {
+                            h_flex()
+                                .gap_2()
+                                .w_full()
+                                .justify_between()
+                                .cursor(gpui::CursorStyle::Arrow)
+                                .child(Label::new("UI Font Size"))
+                                .child(
+                                    NumericStepper::new(
+                                        theme::get_ui_font_size(cx).to_string(),
+                                        |_, cx| {
+                                            cx.dispatch_action(Box::new(
+                                                zed_actions::DecreaseUiFontSize,
+                                            ))
+                                        },
+                                        |_, cx| {
+                                            cx.dispatch_action(Box::new(
+                                                zed_actions::IncreaseUiFontSize,
+                                            ))
+                                        },
+                                    )
+                                    .when(
+                                        theme::has_adjusted_ui_font_size(cx),
+                                        |stepper| {
+                                            stepper.on_reset(|_, cx| {
+                                                cx.dispatch_action(Box::new(
+                                                    zed_actions::ResetUiFontSize,
+                                                ))
+                                            })
+                                        },
+                                    ),
+                                )
+                                .into_any_element()
+                        })
+                        .header("Project")
+                        .action(
+                            "Add Folder to Project...",
+                            Box::new(workspace::AddFolderToProject),
+                        )
+                        .action("Open a new Project...", Box::new(workspace::Open))
+                        .action(
+                            "Open Recent Projects...",
+                            Box::new(recent_projects::OpenRecent {
+                                create_new_window: false,
+                            }),
+                        )
+                        .header("Help")
+                        .action("About Zed", Box::new(zed_actions::About))
+                        .action("Welcome", Box::new(workspace::Welcome))
+                        .link(
+                            "Documentation",
+                            Box::new(zed_actions::OpenBrowser {
+                                url: "https://zed.dev/docs".into(),
+                            }),
+                        )
+                        .action("Give Feedback", Box::new(feedback::GiveFeedback))
+                        .action("Check for Updates", Box::new(auto_update::Check))
+                        .action("View Telemetry", Box::new(zed_actions::OpenTelemetryLog))
+                        .action(
+                            "View Dependency Licenses",
+                            Box::new(zed_actions::OpenLicenses),
+                        )
+                        .separator()
+                        .action("Quit", Box::new(zed_actions::Quit))
+                })
+                .into()
+            })
+            .trigger(
+                IconButton::new("application-menu", ui::IconName::Menu)
+                    .style(ButtonStyle::Subtle)
+                    .tooltip(|cx| Tooltip::text("Open Application Menu", cx))
+                    .icon_size(IconSize::Small),
+            )
+            .into_any_element()
+    }
+}
--- a/crates/title_bar/src/call_controls.rs
+++ b/crates/title_bar/src/call_controls.rs
@@ -1,58 +0,0 @@
-use call::{report_call_event_for_room, ActiveCall};
-use gpui::{actions, AppContext, Task, WindowContext};
-use workspace::notifications::DetachAndPromptErr;
-
-actions!(
-    collab,
-    [ToggleScreenSharing, ToggleMute, ToggleDeafen, LeaveCall]
-);
-
-pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut WindowContext) {
-    let call = ActiveCall::global(cx).read(cx);
-    if let Some(room) = call.room().cloned() {
-        let client = call.client();
-        let toggle_screen_sharing = room.update(cx, |room, cx| {
-            if room.is_screen_sharing() {
-                report_call_event_for_room(
-                    "disable screen share",
-                    room.id(),
-                    room.channel_id(),
-                    &client,
-                );
-                Task::ready(room.unshare_screen(cx))
-            } else {
-                report_call_event_for_room(
-                    "enable screen share",
-                    room.id(),
-                    room.channel_id(),
-                    &client,
-                );
-                room.share_screen(cx)
-            }
-        });
-        toggle_screen_sharing.detach_and_prompt_err("Sharing Screen Failed", cx, |e, _| Some(format!("{:?}\n\nPlease check that you have given Zed permissions to record your screen in Settings.", e)));
-    }
-}
-
-pub fn toggle_mute(_: &ToggleMute, cx: &mut AppContext) {
-    let call = ActiveCall::global(cx).read(cx);
-    if let Some(room) = call.room().cloned() {
-        let client = call.client();
-        room.update(cx, |room, cx| {
-            let operation = if room.is_muted() {
-                "enable microphone"
-            } else {
-                "disable microphone"
-            };
-            report_call_event_for_room(operation, room.id(), room.channel_id(), &client);
-
-            room.toggle_mute(cx)
-        });
-    }
-}
-
-pub fn toggle_deafen(_: &ToggleDeafen, cx: &mut AppContext) {
-    if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
-        room.update(cx, |room, cx| room.toggle_deafen(cx));
-    }
-}
--- a/crates/title_bar/src/collab.rs
+++ b/crates/title_bar/src/collab.rs
@@ -1,13 +1,72 @@
-use crate::TitleBar;
-use call::Room;
-use client::{proto::PeerId, User};
-use gpui::{canvas, point, Hsla, IntoElement, Path, Styled};
-use rpc::proto::{self};
 use std::sync::Arc;
-use theme::ActiveTheme;
-use ui::{prelude::*, Avatar, AvatarAudioStatusIndicator, Facepile, Tooltip};

-pub(crate) fn render_color_ribbon(color: Hsla) -> impl Element {
+use call::{report_call_event_for_room, ActiveCall, ParticipantLocation, Room};
+use client::{proto::PeerId, User};
+use gpui::{actions, AppContext, Task, WindowContext};
+use gpui::{canvas, point, AnyElement, Hsla, IntoElement, MouseButton, Path, Styled};
+use rpc::proto::{self};
+use theme::ActiveTheme;
+use ui::{prelude::*, Avatar, AvatarAudioStatusIndicator, Facepile, TintColor, Tooltip};
+use workspace::notifications::DetachAndPromptErr;
+
+use crate::TitleBar;
+
+actions!(
+    collab,
+    [ToggleScreenSharing, ToggleMute, ToggleDeafen, LeaveCall]
+);
+
+fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut WindowContext) {
+    let call = ActiveCall::global(cx).read(cx);
+    if let Some(room) = call.room().cloned() {
+        let client = call.client();
+        let toggle_screen_sharing = room.update(cx, |room, cx| {
+            if room.is_screen_sharing() {
+                report_call_event_for_room(
+                    "disable screen share",
+                    room.id(),
+                    room.channel_id(),
+                    &client,
+                );
+                Task::ready(room.unshare_screen(cx))
+            } else {
+                report_call_event_for_room(
+                    "enable screen share",
+                    room.id(),
+                    room.channel_id(),
+                    &client,
+                );
+                room.share_screen(cx)
+            }
+        });
+        toggle_screen_sharing.detach_and_prompt_err("Sharing Screen Failed", cx, |e, _| Some(format!("{:?}\n\nPlease check that you have given Zed permissions to record your screen in Settings.", e)));
+    }
+}
+
+fn toggle_mute(_: &ToggleMute, cx: &mut AppContext) {
+    let call = ActiveCall::global(cx).read(cx);
+    if let Some(room) = call.room().cloned() {
+        let client = call.client();
+        room.update(cx, |room, cx| {
+            let operation = if room.is_muted() {
+                "enable microphone"
+            } else {
+                "disable microphone"
+            };
+            report_call_event_for_room(operation, room.id(), room.channel_id(), &client);
+
+            room.toggle_mute(cx)
+        });
+    }
+}
+
+fn toggle_deafen(_: &ToggleDeafen, cx: &mut AppContext) {
+    if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
+        room.update(cx, |room, cx| room.toggle_deafen(cx));
+    }
+}
+
+fn render_color_ribbon(color: Hsla) -> impl Element {
    canvas(
        move |_, _| {},
        move |bounds, _, cx| {
@@ -33,8 +92,99 @@ pub(crate) fn render_color_ribbon(color: Hsla) -> impl Element {
 }

 impl TitleBar {
+    pub(crate) fn render_collaborator_list(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let room = ActiveCall::global(cx).read(cx).room().cloned();
+        let current_user = self.user_store.read(cx).current_user();
+        let client = self.client.clone();
+        let project_id = self.project.read(cx).remote_id();
+        let workspace = self.workspace.upgrade();
+
+        h_flex()
+            .id("collaborator-list")
+            .w_full()
+            .gap_1()
+            .overflow_x_scroll()
+            .when_some(
+                current_user.clone().zip(client.peer_id()).zip(room.clone()),
+                |this, ((current_user, peer_id), room)| {
+                    let player_colors = cx.theme().players();
+                    let room = room.read(cx);
+                    let mut remote_participants =
+                        room.remote_participants().values().collect::<Vec<_>>();
+                    remote_participants.sort_by_key(|p| p.participant_index.0);
+
+                    let current_user_face_pile = self.render_collaborator(
+                        &current_user,
+                        peer_id,
+                        true,
+                        room.is_speaking(),
+                        room.is_muted(),
+                        None,
+                        &room,
+                        project_id,
+                        &current_user,
+                        cx,
+                    );
+
+                    this.children(current_user_face_pile.map(|face_pile| {
+                        v_flex()
+                            .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
+                            .child(face_pile)
+                            .child(render_color_ribbon(player_colors.local().cursor))
+                    }))
+                    .children(remote_participants.iter().filter_map(|collaborator| {
+                        let player_color =
+                            player_colors.color_for_participant(collaborator.participant_index.0);
+                        let is_following = workspace
+                            .as_ref()?
+                            .read(cx)
+                            .is_being_followed(collaborator.peer_id);
+                        let is_present = project_id.map_or(false, |project_id| {
+                            collaborator.location
+                                == ParticipantLocation::SharedProject { project_id }
+                        });
+
+                        let facepile = self.render_collaborator(
+                            &collaborator.user,
+                            collaborator.peer_id,
+                            is_present,
+                            collaborator.speaking,
+                            collaborator.muted,
+                            is_following.then_some(player_color.selection),
+                            &room,
+                            project_id,
+                            &current_user,
+                            cx,
+                        )?;
+
+                        Some(
+                            v_flex()
+                                .id(("collaborator", collaborator.user.id))
+                                .child(facepile)
+                                .child(render_color_ribbon(player_color.cursor))
+                                .cursor_pointer()
+                                .on_click({
+                                    let peer_id = collaborator.peer_id;
+                                    cx.listener(move |this, _, cx| {
+                                        this.workspace
+                                            .update(cx, |workspace, cx| {
+                                                workspace.follow(peer_id, cx);
+                                            })
+                                            .ok();
+                                    })
+                                })
+                                .tooltip({
+                                    let login = collaborator.user.github_login.clone();
+                                    move |cx| Tooltip::text(format!("Follow {login}"), cx)
+                                }),
+                        )
+                    }))
+                },
+            )
+    }
+
    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn render_collaborator(
+    fn render_collaborator(
        &self,
        user: &Arc<User>,
        peer_id: PeerId,
@@ -112,9 +262,8 @@ impl TitleBar {
                        ))
                        .children(if extra_count > 0 {
                            Some(
-                                div()
+                                Label::new(format!("+{extra_count}"))
                                    .ml_1()
-                                    .child(Label::new(format!("+{extra_count}")))
                                    .into_any_element(),
                            )
                        } else {
@@ -123,4 +272,165 @@ impl TitleBar {
                ),
        )
    }
+
+    pub(crate) fn render_call_controls(&self, cx: &mut ViewContext<Self>) -> Vec<AnyElement> {
+        let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() else {
+            return Vec::new();
+        };
+
+        let room = room.read(cx);
+        let project = self.project.read(cx);
+        let is_local = project.is_local();
+        let is_dev_server_project = project.dev_server_project_id().is_some();
+        let is_shared = (is_local || is_dev_server_project) && project.is_shared();
+        let is_muted = room.is_muted();
+        let is_deafened = room.is_deafened().unwrap_or(false);
+        let is_screen_sharing = room.is_screen_sharing();
+        let can_use_microphone = room.can_use_microphone();
+        let can_share_projects = room.can_share_projects();
+        let platform_supported = match self.platform_style {
+            PlatformStyle::Mac => true,
+            PlatformStyle::Linux | PlatformStyle::Windows => false,
+        };
+
+        let mut children = Vec::new();
+
+        if (is_local || is_dev_server_project) && can_share_projects {
+            children.push(
+                Button::new(
+                    "toggle_sharing",
+                    if is_shared { "Unshare" } else { "Share" },
+                )
+                .tooltip(move |cx| {
+                    Tooltip::text(
+                        if is_shared {
+                            "Stop sharing project with call participants"
+                        } else {
+                            "Share project with call participants"
+                        },
+                        cx,
+                    )
+                })
+                .style(ButtonStyle::Subtle)
+                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
+                .selected(is_shared)
+                .label_size(LabelSize::Small)
+                .on_click(cx.listener(move |this, _, cx| {
+                    if is_shared {
+                        this.unshare_project(&Default::default(), cx);
+                    } else {
+                        this.share_project(&Default::default(), cx);
+                    }
+                }))
+                .into_any_element(),
+            );
+        }
+
+        children.push(
+            div()
+                .pr_2()
+                .child(
+                    IconButton::new("leave-call", ui::IconName::Exit)
+                        .style(ButtonStyle::Subtle)
+                        .tooltip(|cx| Tooltip::text("Leave call", cx))
+                        .icon_size(IconSize::Small)
+                        .on_click(move |_, cx| {
+                            ActiveCall::global(cx)
+                                .update(cx, |call, cx| call.hang_up(cx))
+                                .detach_and_log_err(cx);
+                        }),
+                )
+                .into_any_element(),
+        );
+
+        if can_use_microphone {
+            children.push(
+                IconButton::new(
+                    "mute-microphone",
+                    if is_muted {
+                        ui::IconName::MicMute
+                    } else {
+                        ui::IconName::Mic
+                    },
+                )
+                .tooltip(move |cx| {
+                    Tooltip::text(
+                        if !platform_supported {
+                            "Cannot share microphone"
+                        } else if is_muted {
+                            "Unmute microphone"
+                        } else {
+                            "Mute microphone"
+                        },
+                        cx,
+                    )
+                })
+                .style(ButtonStyle::Subtle)
+                .icon_size(IconSize::Small)
+                .selected(platform_supported && is_muted)
+                .disabled(!platform_supported)
+                .selected_style(ButtonStyle::Tinted(TintColor::Negative))
+                .on_click(move |_, cx| {
+                    toggle_mute(&Default::default(), cx);
+                })
+                .into_any_element(),
+            );
+        }
+
+        children.push(
+            IconButton::new(
+                "mute-sound",
+                if is_deafened {
+                    ui::IconName::AudioOff
+                } else {
+                    ui::IconName::AudioOn
+                },
+            )
+            .style(ButtonStyle::Subtle)
+            .selected_style(ButtonStyle::Tinted(TintColor::Negative))
+            .icon_size(IconSize::Small)
+            .selected(is_deafened)
+            .disabled(!platform_supported)
+            .tooltip(move |cx| {
+                if !platform_supported {
+                    Tooltip::text("Cannot share microphone", cx)
+                } else if can_use_microphone {
+                    Tooltip::with_meta("Deafen Audio", None, "Mic will be muted", cx)
+                } else {
+                    Tooltip::text("Deafen Audio", cx)
+                }
+            })
+            .on_click(move |_, cx| toggle_deafen(&Default::default(), cx))
+            .into_any_element(),
+        );
+
+        if can_share_projects {
+            children.push(
+                IconButton::new("screen-share", ui::IconName::Screen)
+                    .style(ButtonStyle::Subtle)
+                    .icon_size(IconSize::Small)
+                    .selected(is_screen_sharing)
+                    .disabled(!platform_supported)
+                    .selected_style(ButtonStyle::Tinted(TintColor::Accent))
+                    .tooltip(move |cx| {
+                        Tooltip::text(
+                            if !platform_supported {
+                                "Cannot share screen"
+                            } else if is_screen_sharing {
+                                "Stop Sharing Screen"
+                            } else {
+                                "Share Screen"
+                            },
+                            cx,
+                        )
+                    })
+                    .on_click(move |_, cx| toggle_screen_sharing(&Default::default(), cx))
+                    .into_any_element(),
+            );
+        }
+
+        children.push(div().pr_2().into_any_element());
+
+        children
+    }
 }
--- a/crates/title_bar/src/stories.rs
+++ b/crates/title_bar/src/stories.rs
@@ -0,0 +1,3 @@
+mod application_menu;
+
+pub use application_menu::*;
--- a/crates/title_bar/src/stories/application_menu.rs
+++ b/crates/title_bar/src/stories/application_menu.rs
@@ -0,0 +1,21 @@
+use gpui::Render;
+use story::{StoryContainer, StoryItem, StorySection};
+
+use ui::prelude::*;
+
+use crate::application_menu::ApplicationMenu;
+
+pub struct ApplicationMenuStory;
+
+impl Render for ApplicationMenuStory {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        StoryContainer::new(
+            "ApplicationMenu Story",
+            "crates/title_bar/src/stories/application_menu.rs",
+        )
+        .child(StorySection::new().child(StoryItem::new(
+            "Application Menu",
+            h_flex().child(ApplicationMenu::new()),
+        )))
+    }
+}
--- a/crates/title_bar/src/stories/title_bar.rs
+++ b/crates/title_bar/src/stories/title_bar.rs
@@ -1,56 +0,0 @@
-use gpui::{NoAction, Render};
-use story::{StoryContainer, StoryItem, StorySection};
-
-use crate::{prelude::*, PlatformStyle, UiTitleBar};
-
-pub struct TitleBarStory;
-
-impl Render for TitleBarStory {
-    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
-        fn add_sample_children(titlebar: UiTitleBar) -> UiTitleBar {
-            titlebar
-                .child(div().size_2().bg(gpui::red()))
-                .child(div().size_2().bg(gpui::blue()))
-                .child(div().size_2().bg(gpui::green()))
-        }
-
-        StoryContainer::new("TitleBar", "crates/ui/src/components/stories/title_bar.rs")
-            .child(
-                StorySection::new().child(
-                    StoryItem::new(
-                        "Default (macOS)",
-                        UiTitleBar::new("macos", Box::new(NoAction))
-                            .platform_style(PlatformStyle::Mac)
-                            .map(add_sample_children),
-                    )
-                    .description("")
-                    .usage(""),
-                ),
-            )
-            .child(
-                StorySection::new().child(
-                    StoryItem::new(
-                        "Default (Linux)",
-                        UiTitleBar::new("linux", Box::new(NoAction))
-                            .platform_style(PlatformStyle::Linux)
-                            .map(add_sample_children),
-                    )
-                    .description("")
-                    .usage(""),
-                ),
-            )
-            .child(
-                StorySection::new().child(
-                    StoryItem::new(
-                        "Default (Windows)",
-                        UiTitleBar::new("windows", Box::new(NoAction))
-                            .platform_style(PlatformStyle::Windows)
-                            .map(add_sample_children),
-                    )
-                    .description("")
-                    .usage(""),
-                ),
-            )
-            .into_element()
-    }
-}
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -1,13 +1,16 @@
-mod call_controls;
+mod application_menu;
 mod collab;
 mod platforms;
 mod window_controls;

+#[cfg(feature = "stories")]
+mod stories;
+
+use crate::application_menu::ApplicationMenu;
 use crate::platforms::{platform_linux, platform_mac, platform_windows};
 use auto_update::AutoUpdateStatus;
-use call::{ActiveCall, ParticipantLocation};
+use call::ActiveCall;
 use client::{Client, UserStore};
-use collab::render_color_ribbon;
 use gpui::{
    actions, div, px, Action, AnyElement, AppContext, Decorations, Element, InteractiveElement,
    Interactivity, IntoElement, Model, MouseButton, ParentElement, Render, Stateful,
@@ -16,18 +19,20 @@ use gpui::{
 use project::{Project, RepositoryEntry};
 use recent_projects::RecentProjects;
 use rpc::proto::DevServerStatus;
-use settings::Settings;
 use smallvec::SmallVec;
 use std::sync::Arc;
-use theme::{ActiveTheme, ThemeSettings};
+use theme::ActiveTheme;
 use ui::{
-    h_flex, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon, IconButton,
-    IconName, Indicator, PopoverMenu, TintColor, Tooltip,
+    h_flex, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon, IconName,
+    Indicator, PopoverMenu, Tooltip,
 };
 use util::ResultExt;
 use vcs_menu::{BranchList, OpenRecent as ToggleVcsMenu};
 use workspace::{notifications::NotifyResultExt, Workspace};

+#[cfg(feature = "stories")]
+pub use stories::*;
+
 const MAX_PROJECT_NAME_LENGTH: usize = 40;
 const MAX_BRANCH_NAME_LENGTH: usize = 40;

@@ -64,15 +69,7 @@ pub struct TitleBar {

 impl Render for TitleBar {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let room = ActiveCall::global(cx).read(cx).room().cloned();
-        let current_user = self.user_store.read(cx).current_user();
-        let client = self.client.clone();
-        let project_id = self.project.read(cx).remote_id();
-        let workspace = self.workspace.upgrade();
        let close_action = Box::new(workspace::CloseWindow);
-
-        let platform_supported = cfg!(target_os = "macos");
-
        let height = Self::height(cx);
        let supported_controls = cx.window_controls();
        let decorations = cx.window_decorations();
@@ -80,8 +77,7 @@ impl Render for TitleBar {
        h_flex()
            .id("titlebar")
            .w_full()
-            .pt(Self::top_padding(cx))
-            .h(height + Self::top_padding(cx))
+            .h(height)
            .map(|this| {
                if cx.is_fullscreen() {
                    this.pl_2()
@@ -91,15 +87,19 @@ impl Render for TitleBar {
                    this.pl_2()
                }
            })
-            .map(|el| {
-                match decorations {
-                    Decorations::Server => el,
-                    Decorations::Client { tiling, .. } => el
-                        .when(!(tiling.top || tiling.right), |el| {
-                            el.rounded_tr(theme::CLIENT_SIDE_DECORATION_ROUNDING)
-                        })
-                        .when(!(tiling.top || tiling.left), |el| el.rounded_tl(theme::CLIENT_SIDE_DECORATION_ROUNDING))
-                }
+            .map(|el| match decorations {
+                Decorations::Server => el,
+                Decorations::Client { tiling, .. } => el
+                    .when(!(tiling.top || tiling.right), |el| {
+                        el.rounded_tr(theme::CLIENT_SIDE_DECORATION_ROUNDING)
+                    })
+                    .when(!(tiling.top || tiling.left), |el| {
+                        el.rounded_tl(theme::CLIENT_SIDE_DECORATION_ROUNDING)
+                    })
+                    // this border is to avoid a transparent gap in the rounded corners
+                    .mt(px(-1.))
+                    .border(px(1.))
+                    .border_color(cx.theme().colors().title_bar_background),
            })
            .bg(cx.theme().colors().title_bar_background)
            .content_stretch()
@@ -110,314 +110,82 @@ impl Render for TitleBar {
                    .flex_row()
                    .justify_between()
                    .w_full()
-                    // note: on windows titlebar behaviour is handled by the platform implementation
-                    .when(cfg!(not(windows)), |this| {
+                    // Note: On Windows the title bar behavior is handled by the platform implementation.
+                    .when(self.platform_style != PlatformStyle::Windows, |this| {
                        this.on_click(|event, cx| {
                            if event.up.click_count == 2 {
                                cx.zoom_window();
                            }
                        })
                    })
-                        // left side
-                        .child(
-                            h_flex()
-                                .gap_1()
-                                .children(self.render_application_menu(cx))
-                                .children(self.render_project_host(cx))
-                                .child(self.render_project_name(cx))
-                                .children(self.render_project_branch(cx))
-                                .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
-                        )
-                        .child(
-                            h_flex()
-                                .id("collaborator-list")
-                                .w_full()
-                                .gap_1()
-                                .overflow_x_scroll()
-                                .when_some(
-                                    current_user.clone().zip(client.peer_id()).zip(room.clone()),
-                                    |this, ((current_user, peer_id), room)| {
-                                        let player_colors = cx.theme().players();
-                                        let room = room.read(cx);
-                                        let mut remote_participants =
-                                            room.remote_participants().values().collect::<Vec<_>>();
-                                        remote_participants.sort_by_key(|p| p.participant_index.0);
-
-                                        let current_user_face_pile = self.render_collaborator(
-                                            &current_user,
-                                            peer_id,
-                                            true,
-                                            room.is_speaking(),
-                                            room.is_muted(),
-                                            None,
-                                            &room,
-                                            project_id,
-                                            &current_user,
-                                            cx,
-                                        );
-
-                                        this.children(current_user_face_pile.map(|face_pile| {
-                                            v_flex()
-                                                .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
-                                                .child(face_pile)
-                                                .child(render_color_ribbon(player_colors.local().cursor))
-                                        }))
-                                        .children(
-                                            remote_participants.iter().filter_map(|collaborator| {
-                                                let player_color = player_colors
-                                                    .color_for_participant(collaborator.participant_index.0);
-                                                let is_following = workspace
-                                                    .as_ref()?
-                                                    .read(cx)
-                                                    .is_being_followed(collaborator.peer_id);
-                                                let is_present = project_id.map_or(false, |project_id| {
-                                                    collaborator.location
-                                                        == ParticipantLocation::SharedProject { project_id }
-                                                });
-
-                                                let facepile = self.render_collaborator(
-                                                    &collaborator.user,
-                                                    collaborator.peer_id,
-                                                    is_present,
-                                                    collaborator.speaking,
-                                                    collaborator.muted,
-                                                    is_following.then_some(player_color.selection),
-                                                    &room,
-                                                    project_id,
-                                                    &current_user,
-                                                    cx,
-                                                )?;
-
-                                                Some(
-                                                    v_flex()
-                                                        .id(("collaborator", collaborator.user.id))
-                                                        .child(facepile)
-                                                        .child(render_color_ribbon(player_color.cursor))
-                                                        .cursor_pointer()
-                                                        .on_click({
-                                                            let peer_id = collaborator.peer_id;
-                                                            cx.listener(move |this, _, cx| {
-                                                                this.workspace
-                                                                    .update(cx, |workspace, cx| {
-                                                                        workspace.follow(peer_id, cx);
-                                                                    })
-                                                                    .ok();
-                                                            })
-                                                        })
-                                                        .tooltip({
-                                                            let login = collaborator.user.github_login.clone();
-                                                            move |cx| {
-                                                                Tooltip::text(format!("Follow {login}"), cx)
-                                                            }
-                                                        }),
-                                                )
-                                            }),
-                                        )
-                                    },
-                                ),
-                        )
-                        // right side
-                        .child(
-                            h_flex()
-                                .gap_1()
-                                .pr_1()
-                                .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
-                                .when_some(room, |this, room| {
-                                    let room = room.read(cx);
-                                    let project = self.project.read(cx);
-                                    let is_local = project.is_local();
-                                    let is_dev_server_project = project.dev_server_project_id().is_some();
-                                    let is_shared = (is_local || is_dev_server_project) && project.is_shared();
-                                    let is_muted = room.is_muted();
-                                    let is_deafened = room.is_deafened().unwrap_or(false);
-                                    let is_screen_sharing = room.is_screen_sharing();
-                                    let can_use_microphone = room.can_use_microphone();
-                                    let can_share_projects = room.can_share_projects();
-
-                                    this.when(
-                                        (is_local || is_dev_server_project) && can_share_projects,
-                                        |this| {
-                                            this.child(
-                                                Button::new(
-                                                    "toggle_sharing",
-                                                    if is_shared { "Unshare" } else { "Share" },
-                                                )
-                                                .tooltip(move |cx| {
-                                                    Tooltip::text(
-                                                        if is_shared {
-                                                            "Stop sharing project with call participants"
-                                                        } else {
-                                                            "Share project with call participants"
-                                                        },
-                                                        cx,
-                                                    )
-                                                })
-                                                .style(ButtonStyle::Subtle)
-                                                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
-                                                .selected(is_shared)
-                                                .label_size(LabelSize::Small)
-                                                .on_click(cx.listener(
-                                                    move |this, _, cx| {
-                                                        if is_shared {
-                                                            this.unshare_project(&Default::default(), cx);
-                                                        } else {
-                                                            this.share_project(&Default::default(), cx);
-                                                        }
-                                                    },
-                                                )),
-                                            )
-                                        },
-                                    )
-                                    .child(
-                                        div()
-                                            .child(
-                                                IconButton::new("leave-call", ui::IconName::Exit)
-                                                    .style(ButtonStyle::Subtle)
-                                                    .tooltip(|cx| Tooltip::text("Leave call", cx))
-                                                    .icon_size(IconSize::Small)
-                                                    .on_click(move |_, cx| {
-                                                        ActiveCall::global(cx)
-                                                            .update(cx, |call, cx| call.hang_up(cx))
-                                                            .detach_and_log_err(cx);
-                                                    }),
-                                            )
-                                            .pr_2(),
-                                    )
-                                    .when(can_use_microphone, |this| {
-                                        this.child(
-                                            IconButton::new(
-                                                "mute-microphone",
-                                                if is_muted {
-                                                    ui::IconName::MicMute
-                                                } else {
-                                                    ui::IconName::Mic
-                                                },
-                                            )
-                                            .tooltip(move |cx| {
-                                                Tooltip::text(
-                                                    if !platform_supported {
-                                                        "Cannot share microphone"
-                                                    } else if is_muted {
-                                                        "Unmute microphone"
-                                                    } else {
-                                                        "Mute microphone"
-                                                    },
-                                                    cx,
-                                                )
-                                            })
-                                            .style(ButtonStyle::Subtle)
-                                            .icon_size(IconSize::Small)
-                                            .selected(platform_supported && is_muted)
-                                            .disabled(!platform_supported)
-                                            .selected_style(ButtonStyle::Tinted(TintColor::Negative))
-                                            .on_click(move |_, cx| {
-                                                call_controls::toggle_mute(&Default::default(), cx);
-                                            }),
-                                        )
-                                    })
-                                    .child(
-                                        IconButton::new(
-                                            "mute-sound",
-                                            if is_deafened {
-                                                ui::IconName::AudioOff
-                                            } else {
-                                                ui::IconName::AudioOn
-                                            },
-                                        )
-                                        .style(ButtonStyle::Subtle)
-                                        .selected_style(ButtonStyle::Tinted(TintColor::Negative))
-                                        .icon_size(IconSize::Small)
-                                        .selected(is_deafened)
-                                        .disabled(!platform_supported)
-                                        .tooltip(move |cx| {
-                                            if !platform_supported {
-                                                Tooltip::text("Cannot share microphone", cx)
-                                            } else if can_use_microphone {
-                                                Tooltip::with_meta(
-                                                    "Deafen Audio",
-                                                    None,
-                                                    "Mic will be muted",
-                                                    cx,
-                                                )
-                                            } else {
-                                                Tooltip::text("Deafen Audio", cx)
-                                            }
-                                        })
-                                        .on_click(move |_, cx| {
-                                            call_controls::toggle_deafen(&Default::default(), cx)
-                                        }),
-                                    )
-                                    .when(can_share_projects, |this| {
-                                        this.child(
-                                            IconButton::new("screen-share", ui::IconName::Screen)
-                                                .style(ButtonStyle::Subtle)
-                                                .icon_size(IconSize::Small)
-                                                .selected(is_screen_sharing)
-                                                .disabled(!platform_supported)
-                                                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
-                                                .tooltip(move |cx| {
-                                                    Tooltip::text(
-                                                        if !platform_supported {
-                                                            "Cannot share screen"
-                                                        } else if is_screen_sharing {
-                                                            "Stop Sharing Screen"
-                                                        } else {
-                                                            "Share Screen"
-                                                        },
-                                                        cx,
-                                                    )
-                                                })
-                                                .on_click(move |_, cx| {
-                                                    call_controls::toggle_screen_sharing(&Default::default(), cx)
-                                                }),
-                                        )
-                                    })
-                                    .child(div().pr_2())
+                    .child(
+                        h_flex()
+                            .gap_1()
+                            .children(match self.platform_style {
+                                PlatformStyle::Mac => None,
+                                PlatformStyle::Linux | PlatformStyle::Windows => {
+                                    Some(ApplicationMenu::new())
+                                }
+                            })
+                            .children(self.render_project_host(cx))
+                            .child(self.render_project_name(cx))
+                            .children(self.render_project_branch(cx))
+                            .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation()),
+                    )
+                    .child(self.render_collaborator_list(cx))
+                    .child(
+                        h_flex()
+                            .gap_1()
+                            .pr_1()
+                            .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
+                            .children(self.render_call_controls(cx))
+                            .map(|el| {
+                                let status = self.client.status();
+                                let status = &*status.borrow();
+                                if matches!(status, client::Status::Connected { .. }) {
+                                    el.child(self.render_user_menu_button(cx))
+                                } else {
+                                    el.children(self.render_connection_status(status, cx))
+                                        .child(self.render_sign_in_button(cx))
+                                        .child(self.render_user_menu_button(cx))
+                                }
+                            }),
+                    ),
+            )
+            .when(!cx.is_fullscreen(), |title_bar| match self.platform_style {
+                PlatformStyle::Mac => title_bar,
+                PlatformStyle::Linux => {
+                    if matches!(decorations, Decorations::Client { .. }) {
+                        title_bar
+                            .child(platform_linux::LinuxWindowControls::new(close_action))
+                            .when(supported_controls.window_menu, |titlebar| {
+                                titlebar.on_mouse_down(gpui::MouseButton::Right, move |ev, cx| {
+                                    cx.show_window_menu(ev.position)
                                })
-                                .map(|el| {
-                                    let status = self.client.status();
-                                    let status = &*status.borrow();
-                                    if matches!(status, client::Status::Connected { .. }) {
-                                        el.child(self.render_user_menu_button(cx))
-                                    } else {
-                                        el.children(self.render_connection_status(status, cx))
-                                            .child(self.render_sign_in_button(cx))
-                                            .child(self.render_user_menu_button(cx))
-                                    }
+                            })
+                            .on_mouse_move(cx.listener(move |this, _ev, cx| {
+                                if this.should_move {
+                                    this.should_move = false;
+                                    cx.start_window_move();
+                                }
+                            }))
+                            .on_mouse_down_out(cx.listener(move |this, _ev, _cx| {
+                                this.should_move = false;
+                            }))
+                            .on_mouse_down(
+                                gpui::MouseButton::Left,
+                                cx.listener(move |this, _ev, _cx| {
+                                    this.should_move = true;
                                }),
-                        )
-
-            ).when(
-            self.platform_style == PlatformStyle::Windows && !cx.is_fullscreen(),
-            |title_bar| title_bar.child(platform_windows::WindowsWindowControls::new(height)),
-        ).when(
-            self.platform_style == PlatformStyle::Linux
-                && !cx.is_fullscreen()
-                && matches!(decorations, Decorations::Client { .. }),
-            |title_bar| {
-                title_bar
-                    .child(platform_linux::LinuxWindowControls::new(close_action))
-                    .when(supported_controls.window_menu, |titlebar| {
-                        titlebar.on_mouse_down(gpui::MouseButton::Right, move |ev, cx| {
-                            cx.show_window_menu(ev.position)
-                        })
-                    })
-
-                                        .on_mouse_move(cx.listener(move |this, _ev, cx| {
-                                            if this.should_move {
-                                                this.should_move = false;
-                                                cx.start_window_move();
-                                            }
-                                        }))
-                                        .on_mouse_down_out(cx.listener(move |this, _ev, _cx| {
-                                            this.should_move = false;
-                                        }))
-                                        .on_mouse_down(gpui::MouseButton::Left, cx.listener(move |this, _ev, _cx| {
-                                            this.should_move = true;
-                                    }))
-
-            },
-        )
+                            )
+                    } else {
+                        title_bar
+                    }
+                }
+                PlatformStyle::Windows => {
+                    title_bar.child(platform_windows::WindowsWindowControls::new(height))
+                }
+            })
    }
 }

@@ -466,202 +234,12 @@ impl TitleBar {
        px(32.)
    }

-    #[cfg(not(target_os = "windows"))]
-    fn top_padding(_cx: &WindowContext) -> Pixels {
-        px(0.)
-    }
-
-    #[cfg(target_os = "windows")]
-    fn top_padding(cx: &WindowContext) -> Pixels {
-        use windows::Win32::UI::{
-            HiDpi::GetSystemMetricsForDpi,
-            WindowsAndMessaging::{SM_CXPADDEDBORDER, USER_DEFAULT_SCREEN_DPI},
-        };
-
-        // This top padding is not dependent on the title bar style and is instead a quirk of maximized windows on Windows:
-        // https://devblogs.microsoft.com/oldnewthing/20150304-00/?p=44543
-        let padding = unsafe { GetSystemMetricsForDpi(SM_CXPADDEDBORDER, USER_DEFAULT_SCREEN_DPI) };
-        if cx.is_maximized() {
-            px((padding * 2) as f32)
-        } else {
-            px(0.)
-        }
-    }
-
    /// Sets the platform style.
    pub fn platform_style(mut self, style: PlatformStyle) -> Self {
        self.platform_style = style;
        self
    }

-    pub fn render_application_menu(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
-        cfg!(not(target_os = "macos")).then(|| {
-            let ui_font_size = ThemeSettings::get_global(cx).ui_font_size;
-            let font = cx.text_style().font();
-            let font_id = cx.text_system().resolve_font(&font);
-            let width = cx
-                .text_system()
-                .typographic_bounds(font_id, ui_font_size, 'm')
-                .unwrap()
-                .size
-                .width
-                * 3.0;
-
-            PopoverMenu::new("application-menu")
-                .menu(move |cx| {
-                    let width = width;
-                    ContextMenu::build(cx, move |menu, _cx| {
-                        let width = width;
-                        menu.header("Workspace")
-                            .action("Open Command Palette", Box::new(command_palette::Toggle))
-                            .custom_row(move |cx| {
-                                div()
-                                    .w_full()
-                                    .flex()
-                                    .flex_row()
-                                    .justify_between()
-                                    .cursor(gpui::CursorStyle::Arrow)
-                                    .child(Label::new("Buffer Font Size"))
-                                    .child(
-                                        div()
-                                            .flex()
-                                            .flex_row()
-                                            .child(div().w(px(16.0)))
-                                            .child(
-                                                IconButton::new(
-                                                    "reset-buffer-zoom",
-                                                    IconName::RotateCcw,
-                                                )
-                                                .on_click(|_, cx| {
-                                                    cx.dispatch_action(Box::new(
-                                                        zed_actions::ResetBufferFontSize,
-                                                    ))
-                                                }),
-                                            )
-                                            .child(
-                                                IconButton::new("--buffer-zoom", IconName::Dash)
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(
-                                                            zed_actions::DecreaseBufferFontSize,
-                                                        ))
-                                                    }),
-                                            )
-                                            .child(
-                                                div()
-                                                    .w(width)
-                                                    .flex()
-                                                    .flex_row()
-                                                    .justify_around()
-                                                    .child(Label::new(
-                                                        theme::get_buffer_font_size(cx).to_string(),
-                                                    )),
-                                            )
-                                            .child(
-                                                IconButton::new("+-buffer-zoom", IconName::Plus)
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(
-                                                            zed_actions::IncreaseBufferFontSize,
-                                                        ))
-                                                    }),
-                                            ),
-                                    )
-                                    .into_any_element()
-                            })
-                            .custom_row(move |cx| {
-                                div()
-                                    .w_full()
-                                    .flex()
-                                    .flex_row()
-                                    .justify_between()
-                                    .cursor(gpui::CursorStyle::Arrow)
-                                    .child(Label::new("UI Font Size"))
-                                    .child(
-                                        div()
-                                            .flex()
-                                            .flex_row()
-                                            .child(
-                                                IconButton::new(
-                                                    "reset-ui-zoom",
-                                                    IconName::RotateCcw,
-                                                )
-                                                .on_click(|_, cx| {
-                                                    cx.dispatch_action(Box::new(
-                                                        zed_actions::ResetUiFontSize,
-                                                    ))
-                                                }),
-                                            )
-                                            .child(
-                                                IconButton::new("--ui-zoom", IconName::Dash)
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(
-                                                            zed_actions::DecreaseUiFontSize,
-                                                        ))
-                                                    }),
-                                            )
-                                            .child(
-                                                div()
-                                                    .w(width)
-                                                    .flex()
-                                                    .flex_row()
-                                                    .justify_around()
-                                                    .child(Label::new(
-                                                        theme::get_ui_font_size(cx).to_string(),
-                                                    )),
-                                            )
-                                            .child(
-                                                IconButton::new("+-ui-zoom", IconName::Plus)
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(
-                                                            zed_actions::IncreaseUiFontSize,
-                                                        ))
-                                                    }),
-                                            ),
-                                    )
-                                    .into_any_element()
-                            })
-                            .header("Project")
-                            .action(
-                                "Add Folder to Project...",
-                                Box::new(workspace::AddFolderToProject),
-                            )
-                            .action("Open a new Project...", Box::new(workspace::Open))
-                            .action(
-                                "Open Recent Projects...",
-                                Box::new(recent_projects::OpenRecent {
-                                    create_new_window: false,
-                                }),
-                            )
-                            .header("Help")
-                            .action("About Zed", Box::new(zed_actions::About))
-                            .action("Welcome", Box::new(workspace::Welcome))
-                            .link(
-                                "Documentation",
-                                Box::new(zed_actions::OpenBrowser {
-                                    url: "https://zed.dev/docs".into(),
-                                }),
-                            )
-                            .action("Give Feedback", Box::new(feedback::GiveFeedback))
-                            .action("Check for Updates", Box::new(auto_update::Check))
-                            .action("View Telemetry", Box::new(zed_actions::OpenTelemetryLog))
-                            .action(
-                                "View Dependency Licenses",
-                                Box::new(zed_actions::OpenLicenses),
-                            )
-                            .separator()
-                            .action("Quit", Box::new(zed_actions::Quit))
-                    })
-                    .into()
-                })
-                .trigger(
-                    IconButton::new("application-menu", ui::IconName::Menu)
-                        .style(ButtonStyle::Subtle)
-                        .tooltip(|cx| Tooltip::text("Open Application Menu", cx))
-                        .icon_size(IconSize::Small),
-                )
-                .into_any_element()
-        })
-    }
-
    pub fn render_project_host(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
        if let Some(dev_server) =
            self.project
--- a/crates/ui/src/components.rs
+++ b/crates/ui/src/components.rs
@@ -12,6 +12,7 @@ mod keybinding;
 mod label;
 mod list;
 mod modal;
+mod numeric_stepper;
 mod popover;
 mod popover_menu;
 mod radio;
@@ -40,6 +41,7 @@ pub use keybinding::*;
 pub use label::*;
 pub use list::*;
 pub use modal::*;
+pub use numeric_stepper::*;
 pub use popover::*;
 pub use popover_menu::*;
 pub use radio::*;
--- a/crates/ui/src/components/button/button_like.rs
+++ b/crates/ui/src/components/button/button_like.rs
@@ -332,7 +332,7 @@ impl ButtonSize {
 /// This is also used to build the prebuilt buttons.
 #[derive(IntoElement)]
 pub struct ButtonLike {
-    pub base: Div,
+    pub(super) base: Div,
    id: ElementId,
    pub(super) style: ButtonStyle,
    pub(super) disabled: bool,
--- a/crates/ui/src/components/button/icon_button.rs
+++ b/crates/ui/src/components/button/icon_button.rs
@@ -1,6 +1,6 @@
 use gpui::{AnyView, DefiniteLength};

-use crate::{prelude::*, ElevationIndex, SelectableButton, Spacing};
+use crate::{prelude::*, ElevationIndex, SelectableButton};
 use crate::{ButtonCommon, ButtonLike, ButtonSize, ButtonStyle, IconName, IconSize};

 use super::button_icon::ButtonIcon;
@@ -147,16 +147,8 @@ impl RenderOnce for IconButton {
        self.base
            .map(|this| match self.shape {
                IconButtonShape::Square => {
-                    let icon_size = self.icon_size.rems() * cx.rem_size();
-                    let padding = match self.icon_size {
-                        IconSize::Indicator => Spacing::None.px(cx),
-                        IconSize::XSmall => Spacing::XSmall.px(cx),
-                        IconSize::Small => Spacing::XSmall.px(cx),
-                        IconSize::Medium => Spacing::XSmall.px(cx),
-                    };
-
-                    this.width((icon_size + padding * 2.).into())
-                        .height((icon_size + padding * 2.).into())
+                    let size = self.icon_size.square(cx);
+                    this.width(size.into()).height(size.into())
                }
                IconButtonShape::Wide => this,
            })
--- a/crates/ui/src/components/facepile.rs
+++ b/crates/ui/src/components/facepile.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use gpui::AnyElement;
+use gpui::{AnyElement, StyleRefinement};
 use smallvec::SmallVec;

 /// A facepile is a collection of faces stacked horizontally–
@@ -23,6 +23,23 @@ impl Facepile {
    }
 }

+impl ParentElement for Facepile {
+    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
+        self.faces.extend(elements);
+    }
+}
+
+// Style methods.
+impl Facepile {
+    fn style(&mut self) -> &mut StyleRefinement {
+        self.base.style()
+    }
+
+    gpui::padding_style_methods!({
+        visibility: pub
+    });
+}
+
 impl RenderOnce for Facepile {
    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
        // Lay the faces out in reverse so they overlap in the desired order (left to right, front to back)
@@ -40,15 +57,3 @@ impl RenderOnce for Facepile {
            )
    }
 }
-
-impl ParentElement for Facepile {
-    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
-        self.faces.extend(elements);
-    }
-}
-
-impl Styled for Facepile {
-    fn style(&mut self) -> &mut gpui::StyleRefinement {
-        self.base.style()
-    }
-}
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -75,6 +75,19 @@ impl IconSize {
            IconSize::Medium => rems_from_px(16.),
        }
    }
+
+    /// Returns the length of a side of the square that contains this [`IconSize`], with padding.
+    pub(crate) fn square(&self, cx: &mut WindowContext) -> Pixels {
+        let icon_size = self.rems() * cx.rem_size();
+        let padding = match self {
+            IconSize::Indicator => Spacing::None.px(cx),
+            IconSize::XSmall => Spacing::XSmall.px(cx),
+            IconSize::Small => Spacing::XSmall.px(cx),
+            IconSize::Medium => Spacing::XSmall.px(cx),
+        };
+
+        icon_size + padding * 2.
+    }
 }

 #[derive(Debug, PartialEq, Copy, Clone, EnumIter, Serialize, Deserialize)]
--- a/crates/ui/src/components/label/highlighted_label.rs
+++ b/crates/ui/src/components/label/highlighted_label.rs
@@ -1,6 +1,6 @@
 use std::ops::Range;

-use gpui::{HighlightStyle, StyledText};
+use gpui::{FontWeight, HighlightStyle, StyledText};

 use crate::{prelude::*, LabelCommon, LabelLike, LabelSize, LineHeightStyle};

@@ -29,6 +29,11 @@ impl LabelCommon for HighlightedLabel {
        self
    }

+    fn weight(mut self, weight: FontWeight) -> Self {
+        self.base = self.base.weight(weight);
+        self
+    }
+
    fn line_height_style(mut self, line_height_style: LineHeightStyle) -> Self {
        self.base = self.base.line_height_style(line_height_style);
        self
--- a/crates/ui/src/components/label/label.rs
+++ b/crates/ui/src/components/label/label.rs
@@ -1,4 +1,4 @@
-use gpui::WindowContext;
+use gpui::{StyleRefinement, WindowContext};

 use crate::{prelude::*, LabelCommon, LabelLike, LabelSize, LineHeightStyle};

@@ -70,6 +70,17 @@ impl Label {
    }
 }

+// Style methods.
+impl Label {
+    fn style(&mut self) -> &mut StyleRefinement {
+        self.base.base.style()
+    }
+
+    gpui::margin_style_methods!({
+        visibility: pub
+    });
+}
+
 impl LabelCommon for Label {
    /// Sets the size of the label using a [`LabelSize`].
    ///
@@ -85,6 +96,11 @@ impl LabelCommon for Label {
        self
    }

+    fn weight(mut self, weight: gpui::FontWeight) -> Self {
+        self.base = self.base.weight(weight);
+        self
+    }
+
    /// Sets the line height style of the label using a [`LineHeightStyle`].
    ///
    /// # Examples
--- a/crates/ui/src/components/label/label_like.rs
+++ b/crates/ui/src/components/label/label_like.rs
@@ -1,4 +1,4 @@
-use gpui::{relative, AnyElement, Styled};
+use gpui::{relative, AnyElement, FontWeight, StyleRefinement, Styled};
 use smallvec::SmallVec;

 use crate::prelude::*;
@@ -25,6 +25,9 @@ pub trait LabelCommon {
    /// Sets the size of the label using a [`LabelSize`].
    fn size(self, size: LabelSize) -> Self;

+    /// Sets the font weight of the label.
+    fn weight(self, weight: FontWeight) -> Self;
+
    /// Sets the line height style of the label using a [`LineHeightStyle`].
    fn line_height_style(self, line_height_style: LineHeightStyle) -> Self;

@@ -40,7 +43,9 @@ pub trait LabelCommon {

 #[derive(IntoElement)]
 pub struct LabelLike {
+    pub(super) base: Div,
    size: LabelSize,
+    weight: FontWeight,
    line_height_style: LineHeightStyle,
    pub(crate) color: Color,
    strikethrough: bool,
@@ -51,7 +56,9 @@ pub struct LabelLike {
 impl LabelLike {
    pub fn new() -> Self {
        Self {
+            base: div(),
            size: LabelSize::Default,
+            weight: FontWeight::default(),
            line_height_style: LineHeightStyle::default(),
            color: Color::Default,
            strikethrough: false,
@@ -61,12 +68,28 @@ impl LabelLike {
    }
 }

+// Style methods.
+impl LabelLike {
+    fn style(&mut self) -> &mut StyleRefinement {
+        self.base.style()
+    }
+
+    gpui::margin_style_methods!({
+        visibility: pub
+    });
+}
+
 impl LabelCommon for LabelLike {
    fn size(mut self, size: LabelSize) -> Self {
        self.size = size;
        self
    }

+    fn weight(mut self, weight: FontWeight) -> Self {
+        self.weight = weight;
+        self
+    }
+
    fn line_height_style(mut self, line_height_style: LineHeightStyle) -> Self {
        self.line_height_style = line_height_style;
        self
@@ -96,7 +119,7 @@ impl ParentElement for LabelLike {

 impl RenderOnce for LabelLike {
    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
-        div()
+        self.base
            .when(self.strikethrough, |this| {
                this.relative().child(
                    div()
@@ -118,6 +141,7 @@ impl RenderOnce for LabelLike {
            })
            .when(self.italic, |this| this.italic())
            .text_color(self.color.color(cx))
+            .font_weight(self.weight)
            .children(self.children)
    }
 }
--- a/crates/ui/src/components/numeric_stepper.rs
+++ b/crates/ui/src/components/numeric_stepper.rs
@@ -0,0 +1,81 @@
+use gpui::ClickEvent;
+
+use crate::{prelude::*, IconButtonShape};
+
+#[derive(IntoElement)]
+pub struct NumericStepper {
+    value: SharedString,
+    on_decrement: Box<dyn Fn(&ClickEvent, &mut WindowContext) + 'static>,
+    on_increment: Box<dyn Fn(&ClickEvent, &mut WindowContext) + 'static>,
+    on_reset: Option<Box<dyn Fn(&ClickEvent, &mut WindowContext) + 'static>>,
+}
+
+impl NumericStepper {
+    pub fn new(
+        value: impl Into<SharedString>,
+        on_decrement: impl Fn(&ClickEvent, &mut WindowContext) + 'static,
+        on_increment: impl Fn(&ClickEvent, &mut WindowContext) + 'static,
+    ) -> Self {
+        Self {
+            value: value.into(),
+            on_decrement: Box::new(on_decrement),
+            on_increment: Box::new(on_increment),
+            on_reset: None,
+        }
+    }
+
+    pub fn on_reset(
+        mut self,
+        on_reset: impl Fn(&ClickEvent, &mut WindowContext) + 'static,
+    ) -> Self {
+        self.on_reset = Some(Box::new(on_reset));
+        self
+    }
+}
+
+impl RenderOnce for NumericStepper {
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        let shape = IconButtonShape::Square;
+        let icon_size = IconSize::Small;
+
+        h_flex()
+            .gap_1()
+            .map(|element| {
+                if let Some(on_reset) = self.on_reset {
+                    element.child(
+                        IconButton::new("reset", IconName::RotateCcw)
+                            .shape(shape)
+                            .icon_size(icon_size)
+                            .on_click(on_reset),
+                    )
+                } else {
+                    element.child(
+                        h_flex()
+                            .size(icon_size.square(cx))
+                            .flex_none()
+                            .into_any_element(),
+                    )
+                }
+            })
+            .child(
+                h_flex()
+                    .gap_1()
+                    .px_1()
+                    .rounded_sm()
+                    .bg(cx.theme().colors().editor_background)
+                    .child(
+                        IconButton::new("decrement", IconName::Dash)
+                            .shape(shape)
+                            .icon_size(icon_size)
+                            .on_click(self.on_decrement),
+                    )
+                    .child(Label::new(self.value))
+                    .child(
+                        IconButton::new("increment", IconName::Plus)
+                            .shape(shape)
+                            .icon_size(icon_size)
+                            .on_click(self.on_increment),
+                    ),
+            )
+    }
+}
--- a/crates/ui/src/components/title_bar.rs
+++ b/crates/ui/src/components/title_bar.rs
@@ -1,5 +0,0 @@
-mod linux_window_controls;
-mod title_bar;
-mod windows_window_controls;
-
-pub use title_bar::*;
--- a/crates/ui/src/styled_ext.rs
+++ b/crates/ui/src/styled_ext.rs
@@ -1,16 +1,22 @@
-use gpui::{hsla, px, Styled, WindowContext};
+use gpui::{hsla, Styled, WindowContext};

 use crate::prelude::*;
 use crate::ElevationIndex;

 fn elevated<E: Styled>(this: E, cx: &mut WindowContext, index: ElevationIndex) -> E {
    this.bg(cx.theme().colors().elevated_surface_background)
-        .rounded(px(8.))
+        .rounded_lg()
        .border_1()
        .border_color(cx.theme().colors().border_variant)
        .shadow(index.shadow())
 }

+fn elevated_borderless<E: Styled>(this: E, cx: &mut WindowContext, index: ElevationIndex) -> E {
+    this.bg(cx.theme().colors().elevated_surface_background)
+        .rounded_lg()
+        .shadow(index.shadow())
+}
+
 /// Extends [`gpui::Styled`] with Zed-specific styling methods.
 pub trait StyledExt: Styled + Sized {
    /// Horizontally stacks elements.
@@ -36,6 +42,13 @@ pub trait StyledExt: Styled + Sized {
        elevated(self, cx, ElevationIndex::Surface)
    }

+    /// See [`elevation_1`].
+    ///
+    /// Renders a borderless version [`elevation_1`].
+    fn elevation_1_borderless(self, cx: &mut WindowContext) -> Self {
+        elevated_borderless(self, cx, ElevationIndex::Surface)
+    }
+
    /// Non-Modal Elevated Surfaces appear above the [`Surface`](ElevationIndex::Surface) layer and is used for things that should appear above most UI elements like an editor or panel, but not elements like popovers, context menus, modals, etc.
    ///
    /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
@@ -45,6 +58,13 @@ pub trait StyledExt: Styled + Sized {
        elevated(self, cx, ElevationIndex::ElevatedSurface)
    }

+    /// See [`elevation_2`].
+    ///
+    /// Renders a borderless version [`elevation_2`].
+    fn elevation_2_borderless(self, cx: &mut WindowContext) -> Self {
+        elevated_borderless(self, cx, ElevationIndex::ElevatedSurface)
+    }
+
    /// Modal Surfaces are used for elements that should appear above all other UI elements and are located above the wash layer. This is the maximum elevation at which UI elements can be rendered in their default state.
    ///
    /// Elements rendered at this layer should have an enforced behavior: Any interaction outside of the modal will either dismiss the modal or prompt an action (Save your progress, etc) then dismiss the modal.
@@ -58,6 +78,13 @@ pub trait StyledExt: Styled + Sized {
        elevated(self, cx, ElevationIndex::ModalSurface)
    }

+    /// See [`elevation_3`].
+    ///
+    /// Renders a borderless version [`elevation_3`].
+    fn elevation_3_borderless(self, cx: &mut WindowContext) -> Self {
+        elevated_borderless(self, cx, ElevationIndex::ModalSurface)
+    }
+
    /// The theme's primary border color.
    fn border_primary(self, cx: &mut WindowContext) -> Self {
        self.border_color(cx.theme().colors().border)
--- a/crates/ui/src/styles.rs
+++ b/crates/ui/src/styles.rs
@@ -1,3 +1,4 @@
+mod appearance;
 mod color;
 mod elevation;
 mod platform;
@@ -5,6 +6,7 @@ mod spacing;
 mod typography;
 mod units;

+pub use appearance::*;
 pub use color::*;
 pub use elevation::*;
 pub use platform::*;
--- a/Show More
+++ b/Show More