diff --git a/Cargo.lock b/Cargo.lock
index bc11e4d7daa41e3e71df963f2c118b94bf8b589a..b442f8d71613551e843247b849a7a6eeb0a8291e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -705,17 +705,6 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
 
-[[package]]
-name = "bzip2-sys"
-version = "0.1.11+1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
-]
-
 [[package]]
 name = "cache-padded"
 version = "1.2.0"
@@ -866,6 +855,22 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chat_panel"
+version = "0.1.0"
+dependencies = [
+ "client",
+ "editor",
+ "gpui",
+ "menu",
+ "postage",
+ "settings",
+ "theme",
+ "time 0.3.15",
+ "util",
+ "workspace",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.22"
@@ -1586,8 +1591,13 @@ dependencies = [
  "async-trait",
  "collections",
  "gpui",
+ "lazy_static",
+ "log",
  "parking_lot 0.11.2",
- "rocksdb",
+ "rusqlite",
+ "rusqlite_migration",
+ "serde",
+ "serde_rusqlite",
  "tempdir",
 ]
 
@@ -1907,6 +1917,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
 
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
 [[package]]
 name = "fastrand"
 version = "1.8.0"
@@ -3102,17 +3118,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "librocksdb-sys"
-version = "0.7.1+7.3.1"
-source = "git+https://github.com/rust-rocksdb/rust-rocksdb?rev=39dc822dde743b2a26eb160b660e8fbdab079d49#39dc822dde743b2a26eb160b660e8fbdab079d49"
+name = "libsqlite3-sys"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f0455f2c1bc9a7caa792907026e469c1d91761fb0ea37cbb16427c77280cf35"
 dependencies = [
- "bindgen",
- "bzip2-sys",
  "cc",
- "glob",
- "libc",
- "libz-sys",
- "zstd-sys",
+ "pkg-config",
+ "vcpkg",
 ]
 
 [[package]]
@@ -4229,7 +4242,6 @@ dependencies = [
  "pulldown-cmark",
  "rand 0.8.5",
  "regex",
- "rocksdb",
  "rpc",
  "serde",
  "serde_json",
@@ -4728,15 +4740,6 @@ dependencies = [
  "rmp",
 ]
 
-[[package]]
-name = "rocksdb"
-version = "0.18.0"
-source = "git+https://github.com/rust-rocksdb/rust-rocksdb?rev=39dc822dde743b2a26eb160b660e8fbdab079d49#39dc822dde743b2a26eb160b660e8fbdab079d49"
-dependencies = [
- "libc",
- "librocksdb-sys",
-]
-
 [[package]]
 name = "rope"
 version = "0.1.0"
@@ -4808,6 +4811,31 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rusqlite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01e213bc3ecb39ac32e81e51ebe31fd888a940515173e3a18a35f8c6e896422a"
+dependencies = [
+ "bitflags",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "serde_json",
+ "smallvec",
+]
+
+[[package]]
+name = "rusqlite_migration"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eda44233be97aea786691f9f6f7ef230bcf905061f4012e90f4f39e6dcf31163"
+dependencies = [
+ "log",
+ "rusqlite",
+]
+
 [[package]]
 name = "rust-embed"
 version = "6.4.1"
@@ -5203,6 +5231,16 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "serde_rusqlite"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "538b51f10ee271375cbd9caa04fa6e3e50af431a21db97caae48da92a074244a"
+dependencies = [
+ "rusqlite",
+ "serde",
+]
+
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
@@ -5809,6 +5847,7 @@ dependencies = [
  "futures 0.3.24",
  "gpui",
  "itertools",
+ "language",
  "lazy_static",
  "libc",
  "mio-extras",
@@ -7580,7 +7619,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.60.4"
+version = "0.61.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
diff --git a/Cargo.toml b/Cargo.toml
index 8d2a3fcc407aba85766a3be828a4fc394eca3f38..7e3623af98b466ec9f79b9490f2bbd64f8c455cb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,8 +18,6 @@ cocoa-foundation = { git = "https://github.com/servo/core-foundation-rs", rev =
 core-foundation = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
 core-foundation-sys = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
 core-graphics = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
-# TODO - Remove when a new version of RustRocksDB is released
-rocksdb = { git = "https://github.com/rust-rocksdb/rust-rocksdb", rev = "39dc822dde743b2a26eb160b660e8fbdab079d49" }
 
 [profile.dev]
 split-debuginfo = "unpacked"
diff --git a/Procfile b/Procfile
index a64b411ef3224a8b6bbf4596bff109b125462bf4..e1b87dd48b6eea968a4dfa24f468f5c5acb7f3c0 100644
--- a/Procfile
+++ b/Procfile
@@ -1,2 +1,2 @@
-web: cd ../zed.dev && PORT=3000 npx next dev
+web: cd ../zed.dev && PORT=3000 npx vercel dev
 collab: cd crates/collab && cargo run
diff --git a/assets/settings/default.json b/assets/settings/default.json
index 2ccd2c5f973b4578d62b1639c643c75d020f5a60..51aa108cd98a7bd5d16af5882b4293cca112239c 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -10,6 +10,8 @@
     // Whether to show the informational hover box when moving the mouse
     // over symbols in the editor.
     "hover_popover_enabled": true,
+    // Whether the cursor blinks in the editor.
+    "cursor_blink": true,
     // Whether to pop the completions menu while typing in an editor without
     // explicitly requesting it.
     "show_completions_on_input": true,
diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index d32835547c6c1ba5903eb9251fa776d5a7bc5544..efe36ccab8ae913e3b402d1f38e7d883489fd923 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -40,7 +40,7 @@ pub struct AutoUpdater {
     current_version: AppVersion,
     http_client: Arc<dyn HttpClient>,
     pending_poll: Option<Task<()>>,
-    db: Arc<project::Db>,
+    db: project::Db,
     server_url: String,
 }
 
@@ -55,7 +55,7 @@ impl Entity for AutoUpdater {
 }
 
 pub fn init(
-    db: Arc<project::Db>,
+    db: project::Db,
     http_client: Arc<dyn HttpClient>,
     server_url: String,
     cx: &mut MutableAppContext,
@@ -116,7 +116,7 @@ impl AutoUpdater {
 
     fn new(
         current_version: AppVersion,
-        db: Arc<project::Db>,
+        db: project::Db,
         http_client: Arc<dyn HttpClient>,
         server_url: String,
     ) -> Self {
@@ -283,9 +283,9 @@ impl AutoUpdater {
         let db = self.db.clone();
         cx.background().spawn(async move {
             if should_show {
-                db.write([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY, "")])?;
+                db.write_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY, "")?;
             } else {
-                db.delete([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?;
+                db.delete_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?;
             }
             Ok(())
         })
@@ -293,8 +293,7 @@ impl AutoUpdater {
 
     fn should_show_update_notification(&self, cx: &AppContext) -> Task<Result<bool>> {
         let db = self.db.clone();
-        cx.background().spawn(async move {
-            Ok(db.read([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?[0].is_some())
-        })
+        cx.background()
+            .spawn(async move { Ok(db.read_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?.is_some()) })
     }
 }
diff --git a/crates/call/src/room.rs b/crates/call/src/room.rs
index 09b49716e03b69c178ad8b19b5eb8a8fcd72bacd..b2e79f820d3109589a38a1d7baf0ec64bcdce027 100644
--- a/crates/call/src/room.rs
+++ b/crates/call/src/room.rs
@@ -8,7 +8,7 @@ use collections::{BTreeMap, HashSet};
 use futures::StreamExt;
 use gpui::{AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext, Task};
 use project::Project;
-use std::sync::Arc;
+use std::{os::unix::prelude::OsStrExt, sync::Arc};
 use util::ResultExt;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -389,6 +389,7 @@ impl Room {
                         id: worktree.id().to_proto(),
                         root_name: worktree.root_name().into(),
                         visible: worktree.is_visible(),
+                        abs_path: worktree.abs_path().as_os_str().as_bytes().to_vec(),
                     }
                 })
                 .collect(),
diff --git a/crates/chat_panel/Cargo.toml b/crates/chat_panel/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b943757c7aa7cfe1eb0c13175cde5d4172affbc8
--- /dev/null
+++ b/crates/chat_panel/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "chat_panel"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/chat_panel.rs"
+doctest = false
+
+[dependencies]
+client = { path = "../client" }
+editor = { path = "../editor" }
+gpui = { path = "../gpui" }
+menu = { path = "../menu" }
+settings = { path = "../settings" }
+theme = { path = "../theme" }
+util = { path = "../util" }
+workspace = { path = "../workspace" }
+postage = { version = "0.4.1", features = ["futures-traits"] }
+time = { version = "0.3", features = ["serde", "serde-well-known"] }
\ No newline at end of file
diff --git a/crates/chat_panel/src/chat_panel.rs b/crates/chat_panel/src/chat_panel.rs
new file mode 100644
index 0000000000000000000000000000000000000000..595eac5f7a105fe29b6277a6170e79ae50e6d698
--- /dev/null
+++ b/crates/chat_panel/src/chat_panel.rs
@@ -0,0 +1,434 @@
+
+use client::{
+    channel::{Channel, ChannelEvent, ChannelList, ChannelMessage},
+    Client,
+};
+use editor::Editor;
+use gpui::{
+    actions,
+    elements::*,
+    platform::CursorStyle,
+    views::{ItemType, Select, SelectStyle},
+    AnyViewHandle, AppContext, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext,
+    Subscription, Task, View, ViewContext, ViewHandle,
+};
+use menu::Confirm;
+use postage::prelude::Stream;
+use settings::{Settings, SoftWrap};
+use std::sync::Arc;
+use time::{OffsetDateTime, UtcOffset};
+use util::{ResultExt, TryFutureExt};
+
+const MESSAGE_LOADING_THRESHOLD: usize = 50;
+
+pub struct ChatPanel {
+    rpc: Arc<Client>,
+    channel_list: ModelHandle<ChannelList>,
+    active_channel: Option<(ModelHandle<Channel>, Subscription)>,
+    message_list: ListState,
+    input_editor: ViewHandle<Editor>,
+    channel_select: ViewHandle<Select>,
+    local_timezone: UtcOffset,
+    _observe_status: Task<()>,
+}
+
+pub enum Event {}
+
+actions!(chat_panel, [LoadMoreMessages]);
+
+pub fn init(cx: &mut MutableAppContext) {
+    cx.add_action(ChatPanel::send);
+    cx.add_action(ChatPanel::load_more_messages);
+}
+
+impl ChatPanel {
+    pub fn new(
+        rpc: Arc<Client>,
+        channel_list: ModelHandle<ChannelList>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let input_editor = cx.add_view(|cx| {
+            let mut editor =
+                Editor::auto_height(4, Some(|theme| theme.chat_panel.input_editor.clone()), cx);
+            editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
+            editor
+        });
+        let channel_select = cx.add_view(|cx| {
+            let channel_list = channel_list.clone();
+            Select::new(0, cx, {
+                move |ix, item_type, is_hovered, cx| {
+                    Self::render_channel_name(
+                        &channel_list,
+                        ix,
+                        item_type,
+                        is_hovered,
+                        &cx.global::<Settings>().theme.chat_panel.channel_select,
+                        cx,
+                    )
+                }
+            })
+            .with_style(move |cx| {
+                let theme = &cx.global::<Settings>().theme.chat_panel.channel_select;
+                SelectStyle {
+                    header: theme.header.container,
+                    menu: theme.menu,
+                }
+            })
+        });
+        
+        let mut message_list = ListState::new(0, Orientation::Bottom, 1000., cx, {
+            let this = cx.weak_handle();
+            move |_, ix, cx| {
+                let this = this.upgrade(cx).unwrap().read(cx);
+                let message = this.active_channel.as_ref().unwrap().0.read(cx).message(ix);
+                this.render_message(message, cx)
+            }
+        });
+        message_list.set_scroll_handler(|visible_range, cx| {
+            if visible_range.start < MESSAGE_LOADING_THRESHOLD {
+                cx.dispatch_action(LoadMoreMessages);
+            }
+        });
+        let _observe_status = cx.spawn_weak(|this, mut cx| {
+            let mut status = rpc.status();
+            async move {
+                while (status.recv().await).is_some() {
+                    if let Some(this) = this.upgrade(&cx) {
+                        this.update(&mut cx, |_, cx| cx.notify());
+                    } else {
+                        break;
+                    }
+                }
+            }
+        });
+        
+        let mut this = Self {
+            rpc,
+            channel_list,
+            active_channel: Default::default(),
+            message_list,
+            input_editor,
+            channel_select,
+            local_timezone: cx.platform().local_timezone(),
+            _observe_status,
+        };
+        
+        this.init_active_channel(cx);
+        cx.observe(&this.channel_list, |this, _, cx| {
+            this.init_active_channel(cx);
+        })
+        .detach();
+        cx.observe(&this.channel_select, |this, channel_select, cx| {
+            let selected_ix = channel_select.read(cx).selected_index();
+            let selected_channel = this.channel_list.update(cx, |channel_list, cx| {
+                let available_channels = channel_list.available_channels()?;
+                let channel_id = available_channels.get(selected_ix)?.id;
+                channel_list.get_channel(channel_id, cx)
+            });
+            if let Some(selected_channel) = selected_channel {
+                this.set_active_channel(selected_channel, cx);
+            }
+        })
+        .detach();
+        
+        this
+    }
+    
+    fn init_active_channel(&mut self, cx: &mut ViewContext<Self>) {
+        let (active_channel, channel_count) = self.channel_list.update(cx, |list, cx| {
+            let channel_count;
+            let mut active_channel = None;
+            
+            if let Some(available_channels) = list.available_channels() {
+                channel_count = available_channels.len();
+                if self.active_channel.is_none() {
+                    if let Some(channel_id) = available_channels.first().map(|channel| channel.id) {
+                        active_channel = list.get_channel(channel_id, cx);
+                    }
+                }
+            } else {
+                channel_count = 0;
+            }
+            
+            (active_channel, channel_count)
+        });
+        
+        if let Some(active_channel) = active_channel {
+            self.set_active_channel(active_channel, cx);
+        } else {
+            self.message_list.reset(0);
+            self.active_channel = None;
+        }
+        
+        self.channel_select.update(cx, |select, cx| {
+            select.set_item_count(channel_count, cx);
+        });
+    }
+    
+    fn set_active_channel(&mut self, channel: ModelHandle<Channel>, cx: &mut ViewContext<Self>) {
+        if self.active_channel.as_ref().map(|e| &e.0) != Some(&channel) {
+            {
+                let channel = channel.read(cx);
+                self.message_list.reset(channel.message_count());
+                let placeholder = format!("Message #{}", channel.name());
+                self.input_editor.update(cx, move |editor, cx| {
+                    editor.set_placeholder_text(placeholder, cx);
+                });
+            }
+            let subscription = cx.subscribe(&channel, Self::channel_did_change);
+            self.active_channel = Some((channel, subscription));
+        }
+    }
+    
+    fn channel_did_change(
+        &mut self,
+        _: ModelHandle<Channel>,
+        event: &ChannelEvent,
+        cx: &mut ViewContext<Self>,
+    ) {
+        match event {
+            ChannelEvent::MessagesUpdated {
+                old_range,
+                new_count,
+            } => {
+                self.message_list.splice(old_range.clone(), *new_count);
+            }
+        }
+        cx.notify();
+    }
+    
+    fn render_channel(&self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = &cx.global::<Settings>().theme;
+        Flex::column()
+            .with_child(
+                Container::new(ChildView::new(&self.channel_select, cx).boxed())
+                    .with_style(theme.chat_panel.channel_select.container)
+                    .boxed(),
+            )
+            .with_child(self.render_active_channel_messages())
+            .with_child(self.render_input_box(cx))
+            .boxed()
+    }
+    
+    fn render_active_channel_messages(&self) -> ElementBox {
+        let messages = if self.active_channel.is_some() {
+            List::new(self.message_list.clone()).boxed()
+        } else {
+            Empty::new().boxed()
+        };
+        
+        FlexItem::new(messages).flex(1., true).boxed()
+    }
+    
+    fn render_message(&self, message: &ChannelMessage, cx: &AppContext) -> ElementBox {
+        let now = OffsetDateTime::now_utc();
+        let settings = cx.global::<Settings>();
+        let theme = if message.is_pending() {
+            &settings.theme.chat_panel.pending_message
+        } else {
+            &settings.theme.chat_panel.message
+        };
+        
+        Container::new(
+            Flex::column()
+                .with_child(
+                    Flex::row()
+                        .with_child(
+                            Container::new(
+                                Label::new(
+                                    message.sender.github_login.clone(),
+                                    theme.sender.text.clone(),
+                                )
+                                .boxed(),
+                            )
+                            .with_style(theme.sender.container)
+                            .boxed(),
+                        )
+                        .with_child(
+                            Container::new(
+                                Label::new(
+                                    format_timestamp(message.timestamp, now, self.local_timezone),
+                                    theme.timestamp.text.clone(),
+                                )
+                                .boxed(),
+                            )
+                            .with_style(theme.timestamp.container)
+                            .boxed(),
+                        )
+                        .boxed(),
+                )
+                .with_child(Text::new(message.body.clone(), theme.body.clone()).boxed())
+                .boxed(),
+        )
+        .with_style(theme.container)
+        .boxed()
+    }
+    
+    fn render_input_box(&self, cx: &AppContext) -> ElementBox {
+        let theme = &cx.global::<Settings>().theme;
+        Container::new(ChildView::new(&self.input_editor, cx).boxed())
+            .with_style(theme.chat_panel.input_editor.container)
+            .boxed()
+    }
+    
+    fn render_channel_name(
+        channel_list: &ModelHandle<ChannelList>,
+        ix: usize,
+        item_type: ItemType,
+        is_hovered: bool,
+        theme: &theme::ChannelSelect,
+        cx: &AppContext,
+    ) -> ElementBox {
+        let channel = &channel_list.read(cx).available_channels().unwrap()[ix];
+        let theme = match (item_type, is_hovered) {
+            (ItemType::Header, _) => &theme.header,
+            (ItemType::Selected, false) => &theme.active_item,
+            (ItemType::Selected, true) => &theme.hovered_active_item,
+            (ItemType::Unselected, false) => &theme.item,
+            (ItemType::Unselected, true) => &theme.hovered_item,
+        };
+        Container::new(
+            Flex::row()
+                .with_child(
+                    Container::new(Label::new("#".to_string(), theme.hash.text.clone()).boxed())
+                        .with_style(theme.hash.container)
+                        .boxed(),
+                )
+                .with_child(Label::new(channel.name.clone(), theme.name.clone()).boxed())
+                .boxed(),
+        )
+        .with_style(theme.container)
+        .boxed()
+    }
+    
+    fn render_sign_in_prompt(&self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = cx.global::<Settings>().theme.clone();
+        let rpc = self.rpc.clone();
+        let this = cx.handle();
+        
+        enum SignInPromptLabel {}
+        
+        Align::new(
+            MouseEventHandler::<SignInPromptLabel>::new(0, cx, |mouse_state, _| {
+                Label::new(
+                    "Sign in to use chat".to_string(),
+                    if mouse_state.hovered() {
+                        theme.chat_panel.hovered_sign_in_prompt.clone()
+                    } else {
+                        theme.chat_panel.sign_in_prompt.clone()
+                    },
+                )
+                .boxed()
+            })
+            .with_cursor_style(CursorStyle::PointingHand)
+            .on_click(MouseButton::Left, move |_, cx| {
+                let rpc = rpc.clone();
+                let this = this.clone();
+                cx.spawn(|mut cx| async move {
+                    if rpc
+                        .authenticate_and_connect(true, &cx)
+                        .log_err()
+                        .await
+                        .is_some()
+                    {
+                        cx.update(|cx| {
+                            if let Some(this) = this.upgrade(cx) {
+                                if this.is_focused(cx) {
+                                    this.update(cx, |this, cx| cx.focus(&this.input_editor));
+                                }
+                            }
+                        })
+                    }
+                })
+                .detach();
+            })
+            .boxed(),
+        )
+        .boxed()
+    }
+    
+    fn send(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
+        if let Some((channel, _)) = self.active_channel.as_ref() {
+            let body = self.input_editor.update(cx, |editor, cx| {
+                let body = editor.text(cx);
+                editor.clear(cx);
+                body
+            });
+            
+            if let Some(task) = channel
+                .update(cx, |channel, cx| channel.send_message(body, cx))
+                .log_err()
+            {
+                task.detach();
+            }
+        }
+    }
+    
+    fn load_more_messages(&mut self, _: &LoadMoreMessages, cx: &mut ViewContext<Self>) {
+        if let Some((channel, _)) = self.active_channel.as_ref() {
+            channel.update(cx, |channel, cx| {
+                channel.load_more_messages(cx);
+            })
+        }
+    }
+}
+
+impl Entity for ChatPanel {
+    type Event = Event;
+}
+
+impl View for ChatPanel {
+    fn ui_name() -> &'static str {
+        "ChatPanel"
+    }
+    
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let element = if self.rpc.user_id().is_some() {
+            self.render_channel(cx)
+        } else {
+            self.render_sign_in_prompt(cx)
+        };
+        let theme = &cx.global::<Settings>().theme;
+        ConstrainedBox::new(
+            Container::new(element)
+                .with_style(theme.chat_panel.container)
+                .boxed(),
+        )
+        .with_min_width(150.)
+        .boxed()
+    }
+    
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+        if matches!(
+            *self.rpc.status().borrow(),
+            client::Status::Connected { .. }
+        ) {
+            cx.focus(&self.input_editor);
+        }
+    }
+}
+
+fn format_timestamp(
+    mut timestamp: OffsetDateTime,
+    mut now: OffsetDateTime,
+    local_timezone: UtcOffset,
+) -> String {
+    timestamp = timestamp.to_offset(local_timezone);
+    now = now.to_offset(local_timezone);
+    
+    let today = now.date();
+    let date = timestamp.date();
+    let mut hour = timestamp.hour();
+    let mut part = "am";
+    if hour > 12 {
+        hour -= 12;
+        part = "pm";
+    }
+    if date == today {
+        format!("{:02}:{:02}{}", hour, timestamp.minute(), part)
+    } else if date.next_day() == Some(today) {
+        format!("yesterday at {:02}:{:02}{}", hour, timestamp.minute(), part)
+    } else {
+        format!("{:02}/{}/{}", date.month() as u32, date.day(), date.year())
+    }
+}
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index cc6bdf627930c31f6e574e19e5f6dbb6aebdc7f4..01f54c0e146a1796701a495feccf9425ae3a2914 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -143,11 +143,16 @@ pub enum Status {
     Authenticating,
     Connecting,
     ConnectionError,
-    Connected { connection_id: ConnectionId },
+    Connected {
+        peer_id: PeerId,
+        connection_id: ConnectionId,
+    },
     ConnectionLost,
     Reauthenticating,
     Reconnecting,
-    ReconnectionError { next_reconnection: Instant },
+    ReconnectionError {
+        next_reconnection: Instant,
+    },
 }
 
 impl Status {
@@ -314,6 +319,14 @@ impl Client {
             .map(|credentials| credentials.user_id)
     }
 
+    pub fn peer_id(&self) -> Option<PeerId> {
+        if let Status::Connected { peer_id, .. } = &*self.status().borrow() {
+            Some(*peer_id)
+        } else {
+            None
+        }
+    }
+
     pub fn status(&self) -> watch::Receiver<Status> {
         self.state.read().status.1.clone()
     }
@@ -663,6 +676,7 @@ impl Client {
             self.set_status(Status::Reconnecting, cx);
         }
 
+        let mut timeout = cx.background().timer(CONNECTION_TIMEOUT).fuse();
         futures::select_biased! {
             connection = self.establish_connection(&credentials, cx).fuse() => {
                 match connection {
@@ -671,8 +685,14 @@ impl Client {
                         if !read_from_keychain && IMPERSONATE_LOGIN.is_none() {
                             write_credentials_to_keychain(&credentials, cx).log_err();
                         }
-                        self.set_connection(conn, cx);
-                        Ok(())
+
+                        futures::select_biased! {
+                            result = self.set_connection(conn, cx).fuse() => result,
+                            _ = timeout => {
+                                self.set_status(Status::ConnectionError, cx);
+                                Err(anyhow!("timed out waiting on hello message from server"))
+                            }
+                        }
                     }
                     Err(EstablishConnectionError::Unauthorized) => {
                         self.state.write().credentials.take();
@@ -695,21 +715,65 @@ impl Client {
                     }
                 }
             }
-            _ = cx.background().timer(CONNECTION_TIMEOUT).fuse() => {
+            _ = &mut timeout => {
                 self.set_status(Status::ConnectionError, cx);
                 Err(anyhow!("timed out trying to establish connection"))
             }
         }
     }
 
-    fn set_connection(self: &Arc<Self>, conn: Connection, cx: &AsyncAppContext) {
+    async fn set_connection(
+        self: &Arc<Self>,
+        conn: Connection,
+        cx: &AsyncAppContext,
+    ) -> Result<()> {
         let executor = cx.background();
         log::info!("add connection to peer");
         let (connection_id, handle_io, mut incoming) = self
             .peer
             .add_connection(conn, move |duration| executor.timer(duration));
-        log::info!("set status to connected {}", connection_id);
-        self.set_status(Status::Connected { connection_id }, cx);
+        let handle_io = cx.background().spawn(handle_io);
+
+        let peer_id = async {
+            log::info!("waiting for server hello");
+            let message = incoming
+                .next()
+                .await
+                .ok_or_else(|| anyhow!("no hello message received"))?;
+            log::info!("got server hello");
+            let hello_message_type_name = message.payload_type_name().to_string();
+            let hello = message
+                .into_any()
+                .downcast::<TypedEnvelope<proto::Hello>>()
+                .map_err(|_| {
+                    anyhow!(
+                        "invalid hello message received: {:?}",
+                        hello_message_type_name
+                    )
+                })?;
+            Ok(PeerId(hello.payload.peer_id))
+        };
+
+        let peer_id = match peer_id.await {
+            Ok(peer_id) => peer_id,
+            Err(error) => {
+                self.peer.disconnect(connection_id);
+                return Err(error);
+            }
+        };
+
+        log::info!(
+            "set status to connected (connection id: {}, peer id: {})",
+            connection_id,
+            peer_id
+        );
+        self.set_status(
+            Status::Connected {
+                peer_id,
+                connection_id,
+            },
+            cx,
+        );
         cx.foreground()
             .spawn({
                 let cx = cx.clone();
@@ -807,14 +871,18 @@ impl Client {
             })
             .detach();
 
-        let handle_io = cx.background().spawn(handle_io);
         let this = self.clone();
         let cx = cx.clone();
         cx.foreground()
             .spawn(async move {
                 match handle_io.await {
                     Ok(()) => {
-                        if *this.status().borrow() == (Status::Connected { connection_id }) {
+                        if *this.status().borrow()
+                            == (Status::Connected {
+                                connection_id,
+                                peer_id,
+                            })
+                        {
                             this.set_status(Status::SignedOut, &cx);
                         }
                     }
@@ -825,6 +893,8 @@ impl Client {
                 }
             })
             .detach();
+
+        Ok(())
     }
 
     fn authenticate(self: &Arc<Self>, cx: &AsyncAppContext) -> Task<Result<Credentials>> {
@@ -1072,7 +1142,7 @@ impl Client {
         self.peer.respond_with_error(receipt, error)
     }
 
-    pub fn start_telemetry(&self, db: Arc<Db>) {
+    pub fn start_telemetry(&self, db: Db) {
         self.telemetry.start(db);
     }
 
diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 0c162580d41491fb1b54a548639170688aac22c7..6829eab53150901755c1f3d89025f3076acd34f0 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -135,22 +135,16 @@ impl Telemetry {
         Some(self.state.lock().log_file.as_ref()?.path().to_path_buf())
     }
 
-    pub fn start(self: &Arc<Self>, db: Arc<Db>) {
+    pub fn start(self: &Arc<Self>, db: Db) {
         let this = self.clone();
         self.executor
             .spawn(
                 async move {
-                    let device_id = if let Some(device_id) = db
-                        .read(["device_id"])?
-                        .into_iter()
-                        .flatten()
-                        .next()
-                        .and_then(|bytes| String::from_utf8(bytes).ok())
-                    {
+                    let device_id = if let Ok(Some(device_id)) = db.read_kvp("device_id") {
                         device_id
                     } else {
                         let device_id = Uuid::new_v4().to_string();
-                        db.write([("device_id", device_id.as_bytes())])?;
+                        db.write_kvp("device_id", &device_id)?;
                         device_id
                     };
 
diff --git a/crates/client/src/test.rs b/crates/client/src/test.rs
index ade21f02f4a366de62450309c9f5c75160d25370..3cfba3b1847c4af4655ad625840492db59249974 100644
--- a/crates/client/src/test.rs
+++ b/crates/client/src/test.rs
@@ -84,9 +84,19 @@ impl FakeServer {
                         let (connection_id, io, incoming) =
                             peer.add_test_connection(server_conn, cx.background());
                         cx.background().spawn(io).detach();
-                        let mut state = state.lock();
-                        state.connection_id = Some(connection_id);
-                        state.incoming = Some(incoming);
+                        {
+                            let mut state = state.lock();
+                            state.connection_id = Some(connection_id);
+                            state.incoming = Some(incoming);
+                        }
+                        peer.send(
+                            connection_id,
+                            proto::Hello {
+                                peer_id: connection_id.0,
+                            },
+                        )
+                        .unwrap();
+
                         Ok(client_conn)
                     })
                 }
diff --git a/crates/collab/src/integration_tests.rs b/crates/collab/src/integration_tests.rs
index 90d7b6d4b582f7254ba80a132c8fea530ad479dd..9bf4afc5db3b84141f5c6907f8b35632fcfa6af2 100644
--- a/crates/collab/src/integration_tests.rs
+++ b/crates/collab/src/integration_tests.rs
@@ -8,15 +8,18 @@ use anyhow::anyhow;
 use call::{room, ActiveCall, ParticipantLocation, Room};
 use client::{
     self, test::FakeHttpClient, Channel, ChannelDetails, ChannelList, Client, Connection,
-    Credentials, EstablishConnectionError, User, UserStore, RECEIVE_TIMEOUT,
+    Credentials, EstablishConnectionError, PeerId, User, UserStore, RECEIVE_TIMEOUT,
 };
 use collections::{BTreeMap, HashMap, HashSet};
 use editor::{
     self, ConfirmCodeAction, ConfirmCompletion, ConfirmRename, Editor, Redo, Rename, ToOffset,
     ToggleCodeActions, Undo,
 };
-use fs::{FakeFs, Fs as _, LineEnding};
-use futures::{channel::mpsc, Future, StreamExt as _};
+use fs::{FakeFs, Fs as _, HomeDir, LineEnding};
+use futures::{
+    channel::{mpsc, oneshot},
+    Future, StreamExt as _,
+};
 use gpui::{
     executor::{self, Deterministic},
     geometry::vector::vec2f,
@@ -34,7 +37,6 @@ use project::{
     ProjectStore, WorktreeId,
 };
 use rand::prelude::*;
-use rpc::PeerId;
 use serde_json::json;
 use settings::{Formatter, Settings};
 use sqlx::types::time::OffsetDateTime;
@@ -385,7 +387,7 @@ async fn test_leaving_room_on_disconnection(
     );
 
     // When user A disconnects, both client A and B clear their room on the active call.
-    server.disconnect_client(client_a.current_user_id(cx_a));
+    server.disconnect_client(client_a.peer_id().unwrap());
     cx_a.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
     active_call_a.read_with(cx_a, |call, _| assert!(call.room().is_none()));
     active_call_b.read_with(cx_b, |call, _| assert!(call.room().is_none()));
@@ -416,7 +418,7 @@ async fn test_calls_on_multiple_connections(
     let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
     let client_a = server.create_client(cx_a, "user_a").await;
     let client_b1 = server.create_client(cx_b1, "user_b").await;
-    let _client_b2 = server.create_client(cx_b2, "user_b").await;
+    let client_b2 = server.create_client(cx_b2, "user_b").await;
     server
         .make_contacts(&mut [(&client_a, cx_a), (&client_b1, cx_b1)])
         .await;
@@ -468,6 +470,14 @@ async fn test_calls_on_multiple_connections(
     assert!(incoming_call_b1.next().await.unwrap().is_none());
     assert!(incoming_call_b2.next().await.unwrap().is_none());
 
+    // User B disconnects the client that is not on the call. Everything should be fine.
+    client_b1.disconnect(&cx_b1.to_async()).unwrap();
+    deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
+    client_b1
+        .authenticate_and_connect(false, &cx_b1.to_async())
+        .await
+        .unwrap();
+
     // User B hangs up, and user A calls them again.
     active_call_b2.update(cx_b2, |call, cx| call.hang_up(cx).unwrap());
     deterministic.run_until_parked();
@@ -520,11 +530,29 @@ async fn test_calls_on_multiple_connections(
     assert!(incoming_call_b1.next().await.unwrap().is_some());
     assert!(incoming_call_b2.next().await.unwrap().is_some());
 
-    // User A disconnects up, causing both connections to stop ringing.
-    server.disconnect_client(client_a.current_user_id(cx_a));
-    cx_a.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
+    // User A disconnects, causing both connections to stop ringing.
+    server.disconnect_client(client_a.peer_id().unwrap());
+    deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
     assert!(incoming_call_b1.next().await.unwrap().is_none());
     assert!(incoming_call_b2.next().await.unwrap().is_none());
+
+    // User A reconnects automatically, then calls user B again.
+    active_call_a
+        .update(cx_a, |call, cx| {
+            call.invite(client_b1.user_id().unwrap(), None, cx)
+        })
+        .await
+        .unwrap();
+    deterministic.run_until_parked();
+    assert!(incoming_call_b1.next().await.unwrap().is_some());
+    assert!(incoming_call_b2.next().await.unwrap().is_some());
+
+    // User B disconnects all clients, causing user A to no longer see a pending call for them.
+    server.forbid_connections();
+    server.disconnect_client(client_b1.peer_id().unwrap());
+    server.disconnect_client(client_b2.peer_id().unwrap());
+    deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
+    active_call_a.read_with(cx_a, |call, _| assert!(call.room().is_none()));
 }
 
 #[gpui::test(iterations = 10)]
@@ -582,7 +610,7 @@ async fn test_share_project(
         .update(cx_b, |call, cx| call.accept_incoming(cx))
         .await
         .unwrap();
-    let client_b_peer_id = client_b.peer_id;
+    let client_b_peer_id = client_b.peer_id().unwrap();
     let project_b = client_b
         .build_remote_project(initial_project.id, cx_b)
         .await;
@@ -806,7 +834,7 @@ async fn test_host_disconnect(
     assert!(cx_b.is_window_edited(workspace_b.window_id()));
 
     // Drop client A's connection. Collaborators should disappear and the project should not be shown as shared.
-    server.disconnect_client(client_a.current_user_id(cx_a));
+    server.disconnect_client(client_a.peer_id().unwrap());
     deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
     project_a
         .condition(cx_a, |project, _| project.collaborators().is_empty())
@@ -849,7 +877,7 @@ async fn test_host_disconnect(
         .unwrap();
 
     // Drop client A's connection again. We should still unshare it successfully.
-    server.disconnect_client(client_a.current_user_id(cx_a));
+    server.disconnect_client(client_a.peer_id().unwrap());
     deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
     project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
 }
@@ -2150,7 +2178,7 @@ async fn test_leaving_project(
 
     // Simulate connection loss for client C and ensure client A observes client C leaving the project.
     client_c.wait_for_current_user(cx_c).await;
-    server.disconnect_client(client_c.current_user_id(cx_c));
+    server.disconnect_client(client_c.peer_id().unwrap());
     cx_a.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
     deterministic.run_until_parked();
     project_a.read_with(cx_a, |project, _| {
@@ -3038,7 +3066,7 @@ async fn test_references(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
         assert_eq!(references[1].buffer, references[0].buffer);
         assert_eq!(
             three_buffer.file().unwrap().full_path(cx),
-            Path::new("three.rs")
+            Path::new("/root/dir-2/three.rs")
         );
 
         assert_eq!(references[0].range.to_offset(two_buffer), 24..27);
@@ -4313,7 +4341,7 @@ async fn test_chat_reconnection(cx_a: &mut TestAppContext, cx_b: &mut TestAppCon
 
     // Disconnect client B, ensuring we can still access its cached channel data.
     server.forbid_connections();
-    server.disconnect_client(client_b.current_user_id(cx_b));
+    server.disconnect_client(client_b.peer_id().unwrap());
     cx_b.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
     while !matches!(
         status_b.next().await,
@@ -4476,7 +4504,7 @@ async fn test_contacts(
         ]
     );
 
-    server.disconnect_client(client_c.current_user_id(cx_c));
+    server.disconnect_client(client_c.peer_id().unwrap());
     server.forbid_connections();
     deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
     assert_eq!(
@@ -4716,7 +4744,7 @@ async fn test_contacts(
     );
 
     server.forbid_connections();
-    server.disconnect_client(client_a.current_user_id(cx_a));
+    server.disconnect_client(client_a.peer_id().unwrap());
     deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
     assert_eq!(contacts(&client_a, cx_a), []);
     assert_eq!(
@@ -5626,6 +5654,7 @@ async fn test_random_collaboration(
 
     let mut clients = Vec::new();
     let mut user_ids = Vec::new();
+    let mut peer_ids = Vec::new();
     let mut op_start_signals = Vec::new();
 
     let mut next_entity_id = 100000;
@@ -5814,6 +5843,7 @@ async fn test_random_collaboration(
 
     let op_start_signal = futures::channel::mpsc::unbounded();
     user_ids.push(host_user_id);
+    peer_ids.push(host.peer_id().unwrap());
     op_start_signals.push(op_start_signal.0);
     clients.push(host_cx.foreground().spawn(host.simulate_host(
         host_project,
@@ -5831,7 +5861,7 @@ async fn test_random_collaboration(
     let mut operations = 0;
     while operations < max_operations {
         if operations == disconnect_host_at {
-            server.disconnect_client(user_ids[0]);
+            server.disconnect_client(peer_ids[0]);
             deterministic.advance_clock(RECEIVE_TIMEOUT);
             drop(op_start_signals);
 
@@ -5914,6 +5944,7 @@ async fn test_random_collaboration(
 
                 let op_start_signal = futures::channel::mpsc::unbounded();
                 user_ids.push(guest_user_id);
+                peer_ids.push(guest.peer_id().unwrap());
                 op_start_signals.push(op_start_signal.0);
                 clients.push(guest_cx.foreground().spawn(guest.simulate_guest(
                     guest_username.clone(),
@@ -5930,10 +5961,11 @@ async fn test_random_collaboration(
                 let guest_ix = rng.lock().gen_range(1..clients.len());
                 log::info!("Removing guest {}", user_ids[guest_ix]);
                 let removed_guest_id = user_ids.remove(guest_ix);
+                let removed_peer_id = peer_ids.remove(guest_ix);
                 let guest = clients.remove(guest_ix);
                 op_start_signals.remove(guest_ix);
                 server.forbid_connections();
-                server.disconnect_client(removed_guest_id);
+                server.disconnect_client(removed_peer_id);
                 deterministic.advance_clock(RECEIVE_TIMEOUT);
                 deterministic.start_waiting();
                 log::info!("Waiting for guest {} to exit...", removed_guest_id);
@@ -6057,8 +6089,10 @@ async fn test_random_collaboration(
             let host_buffer = host_project.read_with(&host_cx, |project, cx| {
                 project.buffer_for_id(buffer_id, cx).unwrap_or_else(|| {
                     panic!(
-                        "host does not have buffer for guest:{}, peer:{}, id:{}",
-                        guest_client.username, guest_client.peer_id, buffer_id
+                        "host does not have buffer for guest:{}, peer:{:?}, id:{}",
+                        guest_client.username,
+                        guest_client.peer_id(),
+                        buffer_id
                     )
                 })
             });
@@ -6101,7 +6135,7 @@ struct TestServer {
     server: Arc<Server>,
     foreground: Rc<executor::Foreground>,
     notifications: mpsc::UnboundedReceiver<()>,
-    connection_killers: Arc<Mutex<HashMap<UserId, Arc<AtomicBool>>>>,
+    connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,
     forbid_connections: Arc<AtomicBool>,
     _test_db: TestDb,
 }
@@ -6130,6 +6164,8 @@ impl TestServer {
 
     async fn create_client(&mut self, cx: &mut TestAppContext, name: &str) -> TestClient {
         cx.update(|cx| {
+            cx.set_global(HomeDir(Path::new("/tmp/").to_path_buf()));
+
             let mut settings = Settings::test(cx);
             settings.projects_online_by_default = false;
             cx.set_global(settings);
@@ -6165,7 +6201,6 @@ impl TestServer {
         let db = self.app_state.db.clone();
         let connection_killers = self.connection_killers.clone();
         let forbid_connections = self.forbid_connections.clone();
-        let (connection_id_tx, mut connection_id_rx) = mpsc::channel(16);
 
         Arc::get_mut(&mut client)
             .unwrap()
@@ -6188,7 +6223,6 @@ impl TestServer {
                 let connection_killers = connection_killers.clone();
                 let forbid_connections = forbid_connections.clone();
                 let client_name = client_name.clone();
-                let connection_id_tx = connection_id_tx.clone();
                 cx.spawn(move |cx| async move {
                     if forbid_connections.load(SeqCst) {
                         Err(EstablishConnectionError::other(anyhow!(
@@ -6197,7 +6231,7 @@ impl TestServer {
                     } else {
                         let (client_conn, server_conn, killed) =
                             Connection::in_memory(cx.background());
-                        connection_killers.lock().insert(user_id, killed);
+                        let (connection_id_tx, connection_id_rx) = oneshot::channel();
                         let user = db.get_user_by_id(user_id).await.unwrap().unwrap();
                         cx.background()
                             .spawn(server.handle_connection(
@@ -6208,6 +6242,10 @@ impl TestServer {
                                 cx.background(),
                             ))
                             .detach();
+                        let connection_id = connection_id_rx.await.unwrap();
+                        connection_killers
+                            .lock()
+                            .insert(PeerId(connection_id.0), killed);
                         Ok(client_conn)
                     }
                 })
@@ -6239,11 +6277,9 @@ impl TestServer {
             .authenticate_and_connect(false, &cx.to_async())
             .await
             .unwrap();
-        let peer_id = PeerId(connection_id_rx.next().await.unwrap().0);
 
         let client = TestClient {
             client,
-            peer_id,
             username: name.to_string(),
             user_store,
             project_store,
@@ -6255,10 +6291,10 @@ impl TestServer {
         client
     }
 
-    fn disconnect_client(&self, user_id: UserId) {
+    fn disconnect_client(&self, peer_id: PeerId) {
         self.connection_killers
             .lock()
-            .remove(&user_id)
+            .remove(&peer_id)
             .unwrap()
             .store(true, SeqCst);
     }
@@ -6359,7 +6395,6 @@ impl Drop for TestServer {
 struct TestClient {
     client: Arc<Client>,
     username: String,
-    pub peer_id: PeerId,
     pub user_store: ModelHandle<UserStore>,
     pub project_store: ModelHandle<ProjectStore>,
     language_registry: Arc<LanguageRegistry>,
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 564e173fec3430ab27f7d52d2b9e90960cdb76d7..1662802c23693088c01b7f86ea926f496e76a7c3 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -24,7 +24,7 @@ use axum::{
 };
 use collections::{HashMap, HashSet};
 use futures::{
-    channel::mpsc,
+    channel::{mpsc, oneshot},
     future::{self, BoxFuture},
     stream::FuturesUnordered,
     FutureExt, SinkExt, StreamExt, TryStreamExt,
@@ -42,6 +42,7 @@ use std::{
     marker::PhantomData,
     net::SocketAddr,
     ops::{Deref, DerefMut},
+    os::unix::prelude::OsStrExt,
     rc::Rc,
     sync::{
         atomic::{AtomicBool, Ordering::SeqCst},
@@ -347,7 +348,7 @@ impl Server {
         connection: Connection,
         address: String,
         user: User,
-        mut send_connection_id: Option<mpsc::Sender<ConnectionId>>,
+        mut send_connection_id: Option<oneshot::Sender<ConnectionId>>,
         executor: E,
     ) -> impl Future<Output = Result<()>> {
         let mut this = self.clone();
@@ -368,9 +369,11 @@ impl Server {
                 });
 
             tracing::info!(%user_id, %login, %connection_id, %address, "connection opened");
+            this.peer.send(connection_id, proto::Hello { peer_id: connection_id.0 })?;
+            tracing::info!(%user_id, %login, %connection_id, %address, "sent hello message");
 
-            if let Some(send_connection_id) = send_connection_id.as_mut() {
-                let _ = send_connection_id.send(connection_id).await;
+            if let Some(send_connection_id) = send_connection_id.take() {
+                let _ = send_connection_id.send(connection_id);
             }
 
             if !user.connected_once {
@@ -476,6 +479,10 @@ impl Server {
         let mut contacts_to_update = HashSet::default();
         {
             let mut store = self.store().await;
+
+            #[cfg(test)]
+            let removed_connection = store.remove_connection(connection_id).unwrap();
+            #[cfg(not(test))]
             let removed_connection = store.remove_connection(connection_id)?;
 
             for project in removed_connection.hosted_projects {
@@ -941,6 +948,7 @@ impl Server {
                 id: *id,
                 root_name: worktree.root_name.clone(),
                 visible: worktree.visible,
+                abs_path: worktree.abs_path.as_os_str().as_bytes().to_vec(),
             })
             .collect::<Vec<_>>();
 
@@ -989,6 +997,7 @@ impl Server {
             let message = proto::UpdateWorktree {
                 project_id: project_id.to_proto(),
                 worktree_id: *worktree_id,
+                abs_path: worktree.abs_path.as_os_str().as_bytes().to_vec(),
                 root_name: worktree.root_name.clone(),
                 updated_entries: worktree.entries.values().cloned().collect(),
                 removed_entries: Default::default(),
diff --git a/crates/collab/src/rpc/store.rs b/crates/collab/src/rpc/store.rs
index b7dd39cff17528172086faa385c9972858d1f874..f48773518825d911ab999a4722e33ff935d04c75 100644
--- a/crates/collab/src/rpc/store.rs
+++ b/crates/collab/src/rpc/store.rs
@@ -66,6 +66,7 @@ pub struct Collaborator {
 
 #[derive(Default, Serialize)]
 pub struct Worktree {
+    pub abs_path: PathBuf,
     pub root_name: String,
     pub visible: bool,
     #[serde(skip)]
@@ -214,11 +215,16 @@ impl Store {
         let connected_user = self.connected_users.get(&user_id).unwrap();
         if let Some(active_call) = connected_user.active_call.as_ref() {
             let room_id = active_call.room_id;
-            let left_room = self.leave_room(room_id, connection_id)?;
-            result.hosted_projects = left_room.unshared_projects;
-            result.guest_projects = left_room.left_projects;
-            result.room_id = Some(room_id);
-            result.canceled_call_connection_ids = left_room.canceled_call_connection_ids;
+            if active_call.connection_id == Some(connection_id) {
+                let left_room = self.leave_room(room_id, connection_id)?;
+                result.hosted_projects = left_room.unshared_projects;
+                result.guest_projects = left_room.left_projects;
+                result.room_id = Some(room_id);
+                result.canceled_call_connection_ids = left_room.canceled_call_connection_ids;
+            } else if connected_user.connection_ids.len() == 1 {
+                self.decline_call(room_id, connection_id)?;
+                result.room_id = Some(room_id);
+            }
         }
 
         let connected_user = self.connected_users.get_mut(&user_id).unwrap();
diff --git a/crates/collab_ui/src/collab_titlebar_item.rs b/crates/collab_ui/src/collab_titlebar_item.rs
index 702d8a9121e27b8ddaf6da7774807eed86b1b202..1279d3043748e7b8186364f926884faac0a3785b 100644
--- a/crates/collab_ui/src/collab_titlebar_item.rs
+++ b/crates/collab_ui/src/collab_titlebar_item.rs
@@ -526,18 +526,6 @@ impl Element for AvatarRibbon {
         cx.scene.push_path(path.build(self.color, None));
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &gpui::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut gpui::EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/collab_ui/src/contact_finder.rs b/crates/collab_ui/src/contact_finder.rs
index a4ec02d2f00f20631206a3d0a2b868e4f226ae22..5165c3b1f690cc9eeeca491f4ebad7bb897be89e 100644
--- a/crates/collab_ui/src/contact_finder.rs
+++ b/crates/collab_ui/src/contact_finder.rs
@@ -36,7 +36,7 @@ impl View for ContactFinder {
         ChildView::new(self.picker.clone(), cx).boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.picker);
         }
diff --git a/crates/collab_ui/src/contact_list.rs b/crates/collab_ui/src/contact_list.rs
index cf8a8f8223e7ba5a0f06e548a59c4c34d3620ae8..7a51cc83ec5877e9b5485edfcbb5fc78515d6476 100644
--- a/crates/collab_ui/src/contact_list.rs
+++ b/crates/collab_ui/src/contact_list.rs
@@ -1121,13 +1121,13 @@ impl View for ContactList {
             .boxed()
     }
 
-    fn on_focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
         if !self.filter_editor.is_focused(cx) {
             cx.focus(&self.filter_editor);
         }
     }
 
-    fn on_focus_out(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_out(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
         if !self.filter_editor.is_focused(cx) {
             cx.emit(Event::Dismissed);
         }
diff --git a/crates/collab_ui/src/contacts_popover.rs b/crates/collab_ui/src/contacts_popover.rs
index 075255d72750bee57f8372b39570013b15d3a8a2..37280f929e7c9a5536588a4543d26f8fb8214282 100644
--- a/crates/collab_ui/src/contacts_popover.rs
+++ b/crates/collab_ui/src/contacts_popover.rs
@@ -160,7 +160,7 @@ impl View for ContactsPopover {
         .boxed()
     }
 
-    fn on_focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             match &self.child {
                 Child::ContactList(child) => cx.focus(child),
diff --git a/crates/command_palette/src/command_palette.rs b/crates/command_palette/src/command_palette.rs
index 7702aaaf2a414e1c6791131aedafff11d27f099a..51474be1bed9ac13a57e5c05f54561d5a31a040d 100644
--- a/crates/command_palette/src/command_palette.rs
+++ b/crates/command_palette/src/command_palette.rs
@@ -135,7 +135,7 @@ impl View for CommandPalette {
         ChildView::new(self.picker.clone(), cx).boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.picker);
         }
diff --git a/crates/context_menu/src/context_menu.rs b/crates/context_menu/src/context_menu.rs
index c28437596669ea8453a8f714c62a81657015e71a..96d99f5109d927416efe6f8b73b01f8ea09eb003 100644
--- a/crates/context_menu/src/context_menu.rs
+++ b/crates/context_menu/src/context_menu.rs
@@ -107,7 +107,7 @@ impl View for ContextMenu {
             .boxed()
     }
 
-    fn on_focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         self.reset(cx);
     }
 }
@@ -315,13 +315,16 @@ impl ContextMenu {
     fn render_menu(&self, cx: &mut RenderContext<Self>) -> impl Element {
         enum Menu {}
         enum MenuItem {}
+
         let style = cx.global::<Settings>().theme.context_menu.clone();
+
         MouseEventHandler::<Menu>::new(0, cx, |_, cx| {
             Flex::column()
                 .with_children(self.items.iter().enumerate().map(|(ix, item)| {
                     match item {
                         ContextMenuItem::Item { label, action } => {
                             let action = action.boxed_clone();
+
                             MouseEventHandler::<MenuItem>::new(ix, cx, |state, _| {
                                 let style =
                                     style.item.style_for(state, Some(ix) == self.selected_index);
@@ -350,6 +353,7 @@ impl ContextMenu {
                                 cx.dispatch_action(Clicked);
                                 cx.dispatch_any_action(action.boxed_clone());
                             })
+                            .on_drag(MouseButton::Left, |_, _| {})
                             .boxed()
                         }
                         ContextMenuItem::Separator => Empty::new()
diff --git a/crates/db/Cargo.toml b/crates/db/Cargo.toml
index f4ed283b6e63944425857fedc99be7887ce5a7ac..1eeac03375e8cb8b40cc2ea2b710b5e927a9ff2d 100644
--- a/crates/db/Cargo.toml
+++ b/crates/db/Cargo.toml
@@ -14,8 +14,13 @@ test-support = []
 collections = { path = "../collections" }
 anyhow = "1.0.57"
 async-trait = "0.1"
+lazy_static = "1.4.0"
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 parking_lot = "0.11.1"
-rocksdb = "0.18"
+rusqlite = { version = "0.28.0", features = ["bundled", "serde_json"] }
+rusqlite_migration = "1.0.0"
+serde = { workspace = true }
+serde_rusqlite = "0.31.0"
 
 [dev-dependencies]
 gpui = { path = "../gpui", features = ["test-support"] }
diff --git a/crates/db/src/db.rs b/crates/db/src/db.rs
index 0b630bf256147270577703d4d0df3b993d90b234..06776832b57649888b7f114f35948b86a5dee0f0 100644
--- a/crates/db/src/db.rs
+++ b/crates/db/src/db.rs
@@ -1,161 +1,119 @@
-use anyhow::Result;
-use std::path::Path;
+mod kvp;
+mod migrations;
+
+use std::fs;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
-pub struct Db(DbStore);
+use anyhow::Result;
+use log::error;
+use parking_lot::Mutex;
+use rusqlite::Connection;
+
+use migrations::MIGRATIONS;
 
-enum DbStore {
+#[derive(Clone)]
+pub enum Db {
+    Real(Arc<RealDb>),
     Null,
-    Real(rocksdb::DB),
+}
 
-    #[cfg(any(test, feature = "test-support"))]
-    Fake {
-        data: parking_lot::Mutex<collections::HashMap<Vec<u8>, Vec<u8>>>,
-    },
+pub struct RealDb {
+    connection: Mutex<Connection>,
+    path: Option<PathBuf>,
 }
 
 impl Db {
-    /// Open or create a database at the given file path.
-    pub fn open(path: &Path) -> Result<Arc<Self>> {
-        let db = rocksdb::DB::open_default(path)?;
-        Ok(Arc::new(Self(DbStore::Real(db))))
+    /// Open or create a database at the given directory path.
+    pub fn open(db_dir: &Path) -> Self {
+        // Use 0 for now. Will implement incrementing and clearing of old db files soon TM
+        let current_db_dir = db_dir.join(Path::new("0"));
+        fs::create_dir_all(&current_db_dir)
+            .expect("Should be able to create the database directory");
+        let db_path = current_db_dir.join(Path::new("db.sqlite"));
+
+        Connection::open(db_path)
+            .map_err(Into::into)
+            .and_then(|connection| Self::initialize(connection))
+            .map(|connection| {
+                Db::Real(Arc::new(RealDb {
+                    connection,
+                    path: Some(db_dir.to_path_buf()),
+                }))
+            })
+            .unwrap_or_else(|e| {
+                error!(
+                    "Connecting to file backed db failed. Reverting to null db. {}",
+                    e
+                );
+                Self::Null
+            })
     }
 
-    /// Open a null database that stores no data, for use as a fallback
-    /// when there is an error opening the real database.
-    pub fn null() -> Arc<Self> {
-        Arc::new(Self(DbStore::Null))
-    }
-
-    /// Open a fake database for testing.
+    /// Open a in memory database for testing and as a fallback.
     #[cfg(any(test, feature = "test-support"))]
-    pub fn open_fake() -> Arc<Self> {
-        Arc::new(Self(DbStore::Fake {
-            data: Default::default(),
-        }))
+    pub fn open_in_memory() -> Self {
+        Connection::open_in_memory()
+            .map_err(Into::into)
+            .and_then(|connection| Self::initialize(connection))
+            .map(|connection| {
+                Db::Real(Arc::new(RealDb {
+                    connection,
+                    path: None,
+                }))
+            })
+            .unwrap_or_else(|e| {
+                error!(
+                    "Connecting to in memory db failed. Reverting to null db. {}",
+                    e
+                );
+                Self::Null
+            })
     }
 
-    pub fn read<K, I>(&self, keys: I) -> Result<Vec<Option<Vec<u8>>>>
-    where
-        K: AsRef<[u8]>,
-        I: IntoIterator<Item = K>,
-    {
-        match &self.0 {
-            DbStore::Real(db) => db
-                .multi_get(keys)
-                .into_iter()
-                .map(|e| e.map_err(Into::into))
-                .collect(),
-
-            DbStore::Null => Ok(keys.into_iter().map(|_| None).collect()),
-
-            #[cfg(any(test, feature = "test-support"))]
-            DbStore::Fake { data: db } => {
-                let db = db.lock();
-                Ok(keys
-                    .into_iter()
-                    .map(|key| db.get(key.as_ref()).cloned())
-                    .collect())
-            }
-        }
-    }
+    fn initialize(mut conn: Connection) -> Result<Mutex<Connection>> {
+        MIGRATIONS.to_latest(&mut conn)?;
 
-    pub fn delete<K, I>(&self, keys: I) -> Result<()>
-    where
-        K: AsRef<[u8]>,
-        I: IntoIterator<Item = K>,
-    {
-        match &self.0 {
-            DbStore::Real(db) => {
-                let mut batch = rocksdb::WriteBatch::default();
-                for key in keys {
-                    batch.delete(key);
-                }
-                db.write(batch)?;
-            }
+        conn.pragma_update(None, "journal_mode", "WAL")?;
+        conn.pragma_update(None, "synchronous", "NORMAL")?;
+        conn.pragma_update(None, "foreign_keys", true)?;
+        conn.pragma_update(None, "case_sensitive_like", true)?;
 
-            DbStore::Null => {}
+        Ok(Mutex::new(conn))
+    }
 
-            #[cfg(any(test, feature = "test-support"))]
-            DbStore::Fake { data: db } => {
-                let mut db = db.lock();
-                for key in keys {
-                    db.remove(key.as_ref());
-                }
-            }
-        }
-        Ok(())
+    pub fn persisting(&self) -> bool {
+        self.real().and_then(|db| db.path.as_ref()).is_some()
     }
 
-    pub fn write<K, V, I>(&self, entries: I) -> Result<()>
-    where
-        K: AsRef<[u8]>,
-        V: AsRef<[u8]>,
-        I: IntoIterator<Item = (K, V)>,
-    {
-        match &self.0 {
-            DbStore::Real(db) => {
-                let mut batch = rocksdb::WriteBatch::default();
-                for (key, value) in entries {
-                    batch.put(key, value);
-                }
-                db.write(batch)?;
-            }
+    pub fn real(&self) -> Option<&RealDb> {
+        match self {
+            Db::Real(db) => Some(&db),
+            _ => None,
+        }
+    }
+}
 
-            DbStore::Null => {}
+impl Drop for Db {
+    fn drop(&mut self) {
+        match self {
+            Db::Real(real_db) => {
+                let lock = real_db.connection.lock();
 
-            #[cfg(any(test, feature = "test-support"))]
-            DbStore::Fake { data: db } => {
-                let mut db = db.lock();
-                for (key, value) in entries {
-                    db.insert(key.as_ref().into(), value.as_ref().into());
-                }
+                let _ = lock.pragma_update(None, "analysis_limit", "500");
+                let _ = lock.pragma_update(None, "optimize", "");
             }
+            Db::Null => {}
         }
-        Ok(())
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use tempdir::TempDir;
-
-    #[gpui::test]
-    fn test_db() {
-        let dir = TempDir::new("db-test").unwrap();
-        let fake_db = Db::open_fake();
-        let real_db = Db::open(&dir.path().join("test.db")).unwrap();
-
-        for db in [&real_db, &fake_db] {
-            assert_eq!(
-                db.read(["key-1", "key-2", "key-3"]).unwrap(),
-                &[None, None, None]
-            );
-
-            db.write([("key-1", "one"), ("key-3", "three")]).unwrap();
-            assert_eq!(
-                db.read(["key-1", "key-2", "key-3"]).unwrap(),
-                &[
-                    Some("one".as_bytes().to_vec()),
-                    None,
-                    Some("three".as_bytes().to_vec())
-                ]
-            );
-
-            db.delete(["key-3", "key-4"]).unwrap();
-            assert_eq!(
-                db.read(["key-1", "key-2", "key-3"]).unwrap(),
-                &[Some("one".as_bytes().to_vec()), None, None,]
-            );
-        }
-
-        drop(real_db);
+    use crate::migrations::MIGRATIONS;
 
-        let real_db = Db::open(&dir.path().join("test.db")).unwrap();
-        assert_eq!(
-            real_db.read(["key-1", "key-2", "key-3"]).unwrap(),
-            &[Some("one".as_bytes().to_vec()), None, None,]
-        );
+    #[test]
+    fn test_migrations() {
+        assert!(MIGRATIONS.validate().is_ok());
     }
 }
diff --git a/crates/db/src/items.rs b/crates/db/src/items.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ed4a4f85e31ed869980496fd8aa20980faf1847d
--- /dev/null
+++ b/crates/db/src/items.rs
@@ -0,0 +1,311 @@
+use std::{ffi::OsStr, fmt::Display, hash::Hash, os::unix::prelude::OsStrExt, path::PathBuf};
+
+use anyhow::Result;
+use collections::HashSet;
+use rusqlite::{named_params, params};
+
+use super::Db;
+
+pub(crate) const ITEMS_M_1: &str = "
+CREATE TABLE items(
+    id INTEGER PRIMARY KEY,
+    kind TEXT
+) STRICT;
+CREATE TABLE item_path(
+    item_id INTEGER PRIMARY KEY,
+    path BLOB
+) STRICT;
+CREATE TABLE item_query(
+    item_id INTEGER PRIMARY KEY,
+    query TEXT
+) STRICT;
+";
+
+#[derive(PartialEq, Eq, Hash, Debug)]
+pub enum SerializedItemKind {
+    Editor,
+    Terminal,
+    ProjectSearch,
+    Diagnostics,
+}
+
+impl Display for SerializedItemKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!("{:?}", self))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum SerializedItem {
+    Editor(usize, PathBuf),
+    Terminal(usize),
+    ProjectSearch(usize, String),
+    Diagnostics(usize),
+}
+
+impl SerializedItem {
+    fn kind(&self) -> SerializedItemKind {
+        match self {
+            SerializedItem::Editor(_, _) => SerializedItemKind::Editor,
+            SerializedItem::Terminal(_) => SerializedItemKind::Terminal,
+            SerializedItem::ProjectSearch(_, _) => SerializedItemKind::ProjectSearch,
+            SerializedItem::Diagnostics(_) => SerializedItemKind::Diagnostics,
+        }
+    }
+
+    fn id(&self) -> usize {
+        match self {
+            SerializedItem::Editor(id, _)
+            | SerializedItem::Terminal(id)
+            | SerializedItem::ProjectSearch(id, _)
+            | SerializedItem::Diagnostics(id) => *id,
+        }
+    }
+}
+
+impl Db {
+    fn write_item(&self, serialized_item: SerializedItem) -> Result<()> {
+        self.real()
+            .map(|db| {
+                let mut lock = db.connection.lock();
+                let tx = lock.transaction()?;
+
+                // Serialize the item
+                let id = serialized_item.id();
+                {
+                    let mut stmt = tx.prepare_cached(
+                        "INSERT OR REPLACE INTO items(id, kind) VALUES ((?), (?))",
+                    )?;
+
+                    dbg!("inserting item");
+                    stmt.execute(params![id, serialized_item.kind().to_string()])?;
+                }
+
+                // Serialize item data
+                match &serialized_item {
+                    SerializedItem::Editor(_, path) => {
+                        dbg!("inserting path");
+                        let mut stmt = tx.prepare_cached(
+                            "INSERT OR REPLACE INTO item_path(item_id, path) VALUES ((?), (?))",
+                        )?;
+
+                        let path_bytes = path.as_os_str().as_bytes();
+                        stmt.execute(params![id, path_bytes])?;
+                    }
+                    SerializedItem::ProjectSearch(_, query) => {
+                        dbg!("inserting query");
+                        let mut stmt = tx.prepare_cached(
+                            "INSERT OR REPLACE INTO item_query(item_id, query) VALUES ((?), (?))",
+                        )?;
+
+                        stmt.execute(params![id, query])?;
+                    }
+                    _ => {}
+                }
+
+                tx.commit()?;
+
+                let mut stmt = lock.prepare_cached("SELECT id, kind FROM items")?;
+                let _ = stmt
+                    .query_map([], |row| {
+                        let zero: usize = row.get(0)?;
+                        let one: String = row.get(1)?;
+
+                        dbg!(zero, one);
+                        Ok(())
+                    })?
+                    .collect::<Vec<Result<(), _>>>();
+
+                Ok(())
+            })
+            .unwrap_or(Ok(()))
+    }
+
+    fn delete_item(&self, item_id: usize) -> Result<()> {
+        self.real()
+            .map(|db| {
+                let lock = db.connection.lock();
+
+                let mut stmt = lock.prepare_cached(
+                    r#"
+                    DELETE FROM items WHERE id = (:id);
+                    DELETE FROM item_path WHERE id = (:id);
+                    DELETE FROM item_query WHERE id = (:id);
+                    "#,
+                )?;
+
+                stmt.execute(named_params! {":id": item_id})?;
+
+                Ok(())
+            })
+            .unwrap_or(Ok(()))
+    }
+
+    fn take_items(&self) -> Result<HashSet<SerializedItem>> {
+        self.real()
+            .map(|db| {
+                let mut lock = db.connection.lock();
+
+                let tx = lock.transaction()?;
+
+                // When working with transactions in rusqlite, need to make this kind of scope
+                // To make the borrow stuff work correctly. Don't know why, rust is wild.
+                let result = {
+                    let mut editors_stmt = tx.prepare_cached(
+                        r#"
+                        SELECT items.id, item_path.path
+                        FROM items
+                        LEFT JOIN item_path
+                            ON items.id = item_path.item_id
+                        WHERE items.kind = ?;
+                        "#,
+                    )?;
+
+                    let editors_iter = editors_stmt.query_map(
+                        [SerializedItemKind::Editor.to_string()],
+                        |row| {
+                            let id: usize = row.get(0)?;
+
+                            let buf: Vec<u8> = row.get(1)?;
+                            let path: PathBuf = OsStr::from_bytes(&buf).into();
+
+                            Ok(SerializedItem::Editor(id, path))
+                        },
+                    )?;
+
+                    let mut terminals_stmt = tx.prepare_cached(
+                        r#"
+                        SELECT items.id
+                        FROM items
+                        WHERE items.kind = ?;
+                        "#,
+                    )?;
+                    let terminals_iter = terminals_stmt.query_map(
+                        [SerializedItemKind::Terminal.to_string()],
+                        |row| {
+                            let id: usize = row.get(0)?;
+
+                            Ok(SerializedItem::Terminal(id))
+                        },
+                    )?;
+
+                    let mut search_stmt = tx.prepare_cached(
+                        r#"
+                        SELECT items.id, item_query.query
+                        FROM items
+                        LEFT JOIN item_query
+                            ON items.id = item_query.item_id
+                        WHERE items.kind = ?;
+                        "#,
+                    )?;
+                    let searches_iter = search_stmt.query_map(
+                        [SerializedItemKind::ProjectSearch.to_string()],
+                        |row| {
+                            let id: usize = row.get(0)?;
+                            let query = row.get(1)?;
+
+                            Ok(SerializedItem::ProjectSearch(id, query))
+                        },
+                    )?;
+
+                    #[cfg(debug_assertions)]
+                    let tmp =
+                        searches_iter.collect::<Vec<Result<SerializedItem, rusqlite::Error>>>();
+                    #[cfg(debug_assertions)]
+                    debug_assert!(tmp.len() == 0 || tmp.len() == 1);
+                    #[cfg(debug_assertions)]
+                    let searches_iter = tmp.into_iter();
+
+                    let mut diagnostic_stmt = tx.prepare_cached(
+                        r#"
+                        SELECT items.id
+                        FROM items
+                        WHERE items.kind = ?;
+                        "#,
+                    )?;
+
+                    let diagnostics_iter = diagnostic_stmt.query_map(
+                        [SerializedItemKind::Diagnostics.to_string()],
+                        |row| {
+                            let id: usize = row.get(0)?;
+
+                            Ok(SerializedItem::Diagnostics(id))
+                        },
+                    )?;
+
+                    #[cfg(debug_assertions)]
+                    let tmp =
+                        diagnostics_iter.collect::<Vec<Result<SerializedItem, rusqlite::Error>>>();
+                    #[cfg(debug_assertions)]
+                    debug_assert!(tmp.len() == 0 || tmp.len() == 1);
+                    #[cfg(debug_assertions)]
+                    let diagnostics_iter = tmp.into_iter();
+
+                    let res = editors_iter
+                        .chain(terminals_iter)
+                        .chain(diagnostics_iter)
+                        .chain(searches_iter)
+                        .collect::<Result<HashSet<SerializedItem>, rusqlite::Error>>()?;
+
+                    let mut delete_stmt = tx.prepare_cached(
+                        r#"
+                        DELETE FROM items;
+                        DELETE FROM item_path;
+                        DELETE FROM item_query;
+                        "#,
+                    )?;
+
+                    delete_stmt.execute([])?;
+
+                    res
+                };
+
+                tx.commit()?;
+
+                Ok(result)
+            })
+            .unwrap_or(Ok(HashSet::default()))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use anyhow::Result;
+
+    use super::*;
+
+    #[test]
+    fn test_items_round_trip() -> Result<()> {
+        let db = Db::open_in_memory();
+
+        let mut items = vec![
+            SerializedItem::Editor(0, PathBuf::from("/tmp/test.txt")),
+            SerializedItem::Terminal(1),
+            SerializedItem::ProjectSearch(2, "Test query!".to_string()),
+            SerializedItem::Diagnostics(3),
+        ]
+        .into_iter()
+        .collect::<HashSet<_>>();
+
+        for item in items.iter() {
+            dbg!("Inserting... ");
+            db.write_item(item.clone())?;
+        }
+
+        assert_eq!(items, db.take_items()?);
+
+        // Check that it's empty, as expected
+        assert_eq!(HashSet::default(), db.take_items()?);
+
+        for item in items.iter() {
+            db.write_item(item.clone())?;
+        }
+
+        items.remove(&SerializedItem::ProjectSearch(2, "Test query!".to_string()));
+        db.delete_item(2)?;
+
+        assert_eq!(items, db.take_items()?);
+
+        Ok(())
+    }
+}
diff --git a/crates/db/src/kvp.rs b/crates/db/src/kvp.rs
new file mode 100644
index 0000000000000000000000000000000000000000..534577bc79e0187ec359dd7fe43874de9a0cdd6b
--- /dev/null
+++ b/crates/db/src/kvp.rs
@@ -0,0 +1,82 @@
+use anyhow::Result;
+use rusqlite::OptionalExtension;
+
+use super::Db;
+
+pub(crate) const KVP_M_1_UP: &str = "
+CREATE TABLE kv_store(
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+) STRICT;
+";
+
+impl Db {
+    pub fn read_kvp(&self, key: &str) -> Result<Option<String>> {
+        self.real()
+            .map(|db| {
+                let lock = db.connection.lock();
+                let mut stmt = lock.prepare_cached("SELECT value FROM kv_store WHERE key = (?)")?;
+
+                Ok(stmt.query_row([key], |row| row.get(0)).optional()?)
+            })
+            .unwrap_or(Ok(None))
+    }
+
+    pub fn write_kvp(&self, key: &str, value: &str) -> Result<()> {
+        self.real()
+            .map(|db| {
+                let lock = db.connection.lock();
+
+                let mut stmt = lock.prepare_cached(
+                    "INSERT OR REPLACE INTO kv_store(key, value) VALUES ((?), (?))",
+                )?;
+
+                stmt.execute([key, value])?;
+
+                Ok(())
+            })
+            .unwrap_or(Ok(()))
+    }
+
+    pub fn delete_kvp(&self, key: &str) -> Result<()> {
+        self.real()
+            .map(|db| {
+                let lock = db.connection.lock();
+
+                let mut stmt = lock.prepare_cached("DELETE FROM kv_store WHERE key = (?)")?;
+
+                stmt.execute([key])?;
+
+                Ok(())
+            })
+            .unwrap_or(Ok(()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+
+    use super::*;
+
+    #[test]
+    fn test_kvp() -> Result<()> {
+        let db = Db::open_in_memory();
+
+        assert_eq!(db.read_kvp("key-1")?, None);
+
+        db.write_kvp("key-1", "one")?;
+        assert_eq!(db.read_kvp("key-1")?, Some("one".to_string()));
+
+        db.write_kvp("key-1", "one-2")?;
+        assert_eq!(db.read_kvp("key-1")?, Some("one-2".to_string()));
+
+        db.write_kvp("key-2", "two")?;
+        assert_eq!(db.read_kvp("key-2")?, Some("two".to_string()));
+
+        db.delete_kvp("key-1")?;
+        assert_eq!(db.read_kvp("key-1")?, None);
+
+        Ok(())
+    }
+}
diff --git a/crates/db/src/migrations.rs b/crates/db/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1000543d8ddde8829320de1b0c3e4f630635d3e8
--- /dev/null
+++ b/crates/db/src/migrations.rs
@@ -0,0 +1,15 @@
+use rusqlite_migration::{Migrations, M};
+
+// use crate::items::ITEMS_M_1;
+use crate::kvp::KVP_M_1_UP;
+
+// This must be ordered by development time! Only ever add new migrations to the end!!
+// Bad things will probably happen if you don't monotonically edit this vec!!!!
+// And no re-ordering ever!!!!!!!!!! The results of these migrations are on the user's
+// file system and so everything we do here is locked in _f_o_r_e_v_e_r_.
+lazy_static::lazy_static! {
+    pub static ref MIGRATIONS: Migrations<'static> = Migrations::new(vec![
+        M::up(KVP_M_1_UP),
+        // M::up(ITEMS_M_1),
+    ]);
+}
diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs
index 8180a6c9f61169502ac9a7114cee422da68d6329..4409fa17ad3669806ca1556a83a69d6a5e58fd87 100644
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -99,7 +99,7 @@ impl View for ProjectDiagnosticsEditor {
         }
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if !self.path_states.is_empty() {
             cx.focus(&self.editor);
         }
diff --git a/crates/drag_and_drop/src/drag_and_drop.rs b/crates/drag_and_drop/src/drag_and_drop.rs
index 7a16acae07d6dd24dd506736c5fa01861fa17dd1..31265a16972267a57b15bc5683d0e1f47c6bb656 100644
--- a/crates/drag_and_drop/src/drag_and_drop.rs
+++ b/crates/drag_and_drop/src/drag_and_drop.rs
@@ -4,7 +4,7 @@ use collections::HashSet;
 use gpui::{
     elements::{MouseEventHandler, Overlay},
     geometry::vector::Vector2F,
-    scene::DragRegionEvent,
+    scene::MouseDrag,
     CursorStyle, Element, ElementBox, EventContext, MouseButton, MutableAppContext, RenderContext,
     View, WeakViewHandle,
 };
@@ -70,7 +70,7 @@ impl<V: View> DragAndDrop<V> {
     }
 
     pub fn dragging<T: Any>(
-        event: DragRegionEvent,
+        event: MouseDrag,
         payload: Rc<T>,
         cx: &mut EventContext,
         render: Rc<impl 'static + Fn(&T, &mut RenderContext<V>) -> ElementBox>,
diff --git a/crates/editor/src/blink_manager.rs b/crates/editor/src/blink_manager.rs
new file mode 100644
index 0000000000000000000000000000000000000000..77d10534d29a05d3a68b3f872eccc1184d01899b
--- /dev/null
+++ b/crates/editor/src/blink_manager.rs
@@ -0,0 +1,110 @@
+use std::time::Duration;
+
+use gpui::{Entity, ModelContext};
+use settings::Settings;
+use smol::Timer;
+
+pub struct BlinkManager {
+    blink_interval: Duration,
+
+    blink_epoch: usize,
+    blinking_paused: bool,
+    visible: bool,
+    enabled: bool,
+}
+
+impl BlinkManager {
+    pub fn new(blink_interval: Duration, cx: &mut ModelContext<Self>) -> Self {
+        let weak_handle = cx.weak_handle();
+        cx.observe_global::<Settings, _>(move |_, cx| {
+            if let Some(this) = weak_handle.upgrade(cx) {
+                // Make sure we blink the cursors if the setting is re-enabled
+                this.update(cx, |this, cx| this.blink_cursors(this.blink_epoch, cx));
+            }
+        })
+        .detach();
+
+        Self {
+            blink_interval,
+
+            blink_epoch: 0,
+            blinking_paused: false,
+            visible: true,
+            enabled: true,
+        }
+    }
+
+    fn next_blink_epoch(&mut self) -> usize {
+        self.blink_epoch += 1;
+        self.blink_epoch
+    }
+
+    pub fn pause_blinking(&mut self, cx: &mut ModelContext<Self>) {
+        if !self.visible {
+            self.visible = true;
+            cx.notify();
+        }
+
+        let epoch = self.next_blink_epoch();
+        let interval = self.blink_interval;
+        cx.spawn(|this, mut cx| {
+            let this = this.downgrade();
+            async move {
+                Timer::after(interval).await;
+                if let Some(this) = this.upgrade(&cx) {
+                    this.update(&mut cx, |this, cx| this.resume_cursor_blinking(epoch, cx))
+                }
+            }
+        })
+        .detach();
+    }
+
+    fn resume_cursor_blinking(&mut self, epoch: usize, cx: &mut ModelContext<Self>) {
+        if epoch == self.blink_epoch {
+            self.blinking_paused = false;
+            self.blink_cursors(epoch, cx);
+        }
+    }
+
+    fn blink_cursors(&mut self, epoch: usize, cx: &mut ModelContext<Self>) {
+        if cx.global::<Settings>().cursor_blink {
+            if epoch == self.blink_epoch && self.enabled && !self.blinking_paused {
+                self.visible = !self.visible;
+                cx.notify();
+
+                let epoch = self.next_blink_epoch();
+                let interval = self.blink_interval;
+                cx.spawn(|this, mut cx| {
+                    let this = this.downgrade();
+                    async move {
+                        Timer::after(interval).await;
+                        if let Some(this) = this.upgrade(&cx) {
+                            this.update(&mut cx, |this, cx| this.blink_cursors(epoch, cx));
+                        }
+                    }
+                })
+                .detach();
+            }
+        } else if !self.visible {
+            self.visible = true;
+            cx.notify();
+        }
+    }
+
+    pub fn enable(&mut self, cx: &mut ModelContext<Self>) {
+        self.enabled = true;
+        self.blink_cursors(self.blink_epoch, cx);
+    }
+
+    pub fn disable(&mut self, _: &mut ModelContext<Self>) {
+        self.enabled = true;
+    }
+
+    pub fn visible(&self) -> bool {
+        self.visible
+    }
+}
+
+impl Entity for BlinkManager {
+    type Event = ();
+}
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 070fc69f7ebcfe1d974b2db2bccf5d45c19af200..1d660db1fbc1e3910fd38f44bbc3817b1fa2d9b5 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1,3 +1,4 @@
+mod blink_manager;
 pub mod display_map;
 mod element;
 mod highlight_matching_bracket;
@@ -16,6 +17,7 @@ pub mod test;
 
 use aho_corasick::AhoCorasick;
 use anyhow::Result;
+use blink_manager::BlinkManager;
 use clock::ReplicaId;
 use collections::{BTreeMap, Bound, HashMap, HashSet, VecDeque};
 pub use display_map::DisplayPoint;
@@ -33,20 +35,22 @@ use gpui::{
     impl_actions, impl_internal_actions,
     platform::CursorStyle,
     serde_json::json,
-    text_layout, AnyViewHandle, AppContext, AsyncAppContext, ClipboardItem, Element, ElementBox,
-    Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext, Subscription, Task, View,
-    ViewContext, ViewHandle, WeakViewHandle,
+    text_layout, AnyViewHandle, AppContext, AsyncAppContext, Axis, ClipboardItem, Element,
+    ElementBox, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext, Subscription,
+    Task, View, ViewContext, ViewHandle, WeakViewHandle,
 };
 use highlight_matching_bracket::refresh_matching_bracket_highlights;
 use hover_popover::{hide_hover, HoverState};
 pub use items::MAX_TAB_TITLE_LEN;
 pub use language::{char_kind, CharKind};
 use language::{
-    AutoindentMode, BracketPair, Buffer, CodeAction, CodeLabel, Completion, Diagnostic,
-    DiagnosticSeverity, IndentKind, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Point,
-    Selection, SelectionGoal, TransactionId,
+    AutoindentMode, BracketPair, Buffer, CodeAction, CodeLabel, Completion, CursorShape,
+    Diagnostic, DiagnosticSeverity, IndentKind, IndentSize, Language, OffsetRangeExt, OffsetUtf16,
+    Point, Selection, SelectionGoal, TransactionId,
+};
+use link_go_to_definition::{
+    hide_link_definition, show_link_definition, LinkDefinitionKind, LinkGoToDefinitionState,
 };
-use link_go_to_definition::{hide_link_definition, LinkGoToDefinitionState};
 pub use multi_buffer::{
     Anchor, AnchorRangeExt, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, ToOffset,
     ToPoint,
@@ -80,6 +84,7 @@ const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);
 const MAX_LINE_LEN: usize = 1024;
 const MIN_NAVIGATION_HISTORY_ROW_DELTA: i64 = 10;
 const MAX_SELECTION_HISTORY_LEN: usize = 1024;
+pub const SCROLL_EVENT_SEPARATION: Duration = Duration::from_millis(28);
 
 pub const FORMAT_TIMEOUT: Duration = Duration::from_secs(2);
 
@@ -90,7 +95,10 @@ pub struct SelectNext {
 }
 
 #[derive(Clone, PartialEq)]
-pub struct Scroll(pub Vector2F);
+pub struct Scroll {
+    pub scroll_position: Vector2F,
+    pub axis: Option<Axis>,
+}
 
 #[derive(Clone, PartialEq)]
 pub struct Select(pub SelectPhase);
@@ -259,7 +267,7 @@ struct ScrollbarAutoHide(bool);
 
 pub fn init(cx: &mut MutableAppContext) {
     cx.add_action(Editor::new_file);
-    cx.add_action(|this: &mut Editor, action: &Scroll, cx| this.set_scroll_position(action.0, cx));
+    cx.add_action(Editor::scroll);
     cx.add_action(Editor::select);
     cx.add_action(Editor::cancel);
     cx.add_action(Editor::newline);
@@ -425,6 +433,69 @@ pub type GetFieldEditorTheme = fn(&theme::Theme) -> theme::FieldEditor;
 
 type OverrideTextStyle = dyn Fn(&EditorStyle) -> Option<HighlightStyle>;
 
+#[derive(Clone, Copy)]
+pub struct OngoingScroll {
+    last_timestamp: Instant,
+    axis: Option<Axis>,
+}
+
+impl OngoingScroll {
+    fn initial() -> OngoingScroll {
+        OngoingScroll {
+            last_timestamp: Instant::now() - SCROLL_EVENT_SEPARATION,
+            axis: None,
+        }
+    }
+
+    fn update(&mut self, axis: Option<Axis>) {
+        self.last_timestamp = Instant::now();
+        self.axis = axis;
+    }
+
+    pub fn filter(&self, delta: &mut Vector2F) -> Option<Axis> {
+        const UNLOCK_PERCENT: f32 = 1.9;
+        const UNLOCK_LOWER_BOUND: f32 = 6.;
+        let mut axis = self.axis;
+
+        let x = delta.x().abs();
+        let y = delta.y().abs();
+        let duration = Instant::now().duration_since(self.last_timestamp);
+        if duration > SCROLL_EVENT_SEPARATION {
+            //New ongoing scroll will start, determine axis
+            axis = if x <= y {
+                Some(Axis::Vertical)
+            } else {
+                Some(Axis::Horizontal)
+            };
+        } else if x.max(y) >= UNLOCK_LOWER_BOUND {
+            //Check if the current ongoing will need to unlock
+            match axis {
+                Some(Axis::Vertical) => {
+                    if x > y && x >= y * UNLOCK_PERCENT {
+                        axis = None;
+                    }
+                }
+
+                Some(Axis::Horizontal) => {
+                    if y > x && y >= x * UNLOCK_PERCENT {
+                        axis = None;
+                    }
+                }
+
+                None => {}
+            }
+        }
+
+        match axis {
+            Some(Axis::Vertical) => *delta = vec2f(0., delta.y()),
+            Some(Axis::Horizontal) => *delta = vec2f(delta.x(), 0.),
+            None => {}
+        }
+
+        axis
+    }
+}
+
 pub struct Editor {
     handle: WeakViewHandle<Self>,
     buffer: ModelHandle<MultiBuffer>,
@@ -439,6 +510,7 @@ pub struct Editor {
     select_larger_syntax_node_stack: Vec<Box<[Selection<usize>]>>,
     ime_transaction: Option<TransactionId>,
     active_diagnostics: Option<ActiveDiagnosticGroup>,
+    ongoing_scroll: OngoingScroll,
     scroll_position: Vector2F,
     scroll_top_anchor: Anchor,
     autoscroll_request: Option<(Autoscroll, bool)>,
@@ -447,12 +519,10 @@ pub struct Editor {
     override_text_style: Option<Box<OverrideTextStyle>>,
     project: Option<ModelHandle<Project>>,
     focused: bool,
-    show_local_cursors: bool,
+    blink_manager: ModelHandle<BlinkManager>,
     show_local_selections: bool,
     show_scrollbars: bool,
     hide_scrollbar_task: Option<Task<()>>,
-    blink_epoch: usize,
-    blinking_paused: bool,
     mode: EditorMode,
     vertical_scroll_margin: f32,
     placeholder_text: Option<Arc<str>>,
@@ -484,6 +554,7 @@ pub struct EditorSnapshot {
     pub display_snapshot: DisplaySnapshot,
     pub placeholder_text: Option<Arc<str>>,
     is_focused: bool,
+    ongoing_scroll: OngoingScroll,
     scroll_position: Vector2F,
     scroll_top_anchor: Anchor,
 }
@@ -1076,6 +1147,8 @@ impl Editor {
 
         let selections = SelectionsCollection::new(display_map.clone(), buffer.clone());
 
+        let blink_manager = cx.add_model(|cx| BlinkManager::new(CURSOR_BLINK_INTERVAL, cx));
+
         let mut this = Self {
             handle: cx.weak_handle(),
             buffer: buffer.clone(),
@@ -1093,16 +1166,15 @@ impl Editor {
             soft_wrap_mode_override: None,
             get_field_editor_theme,
             project,
+            ongoing_scroll: OngoingScroll::initial(),
             scroll_position: Vector2F::zero(),
             scroll_top_anchor: Anchor::min(),
             autoscroll_request: None,
             focused: false,
-            show_local_cursors: false,
+            blink_manager: blink_manager.clone(),
             show_local_selections: true,
             show_scrollbars: true,
             hide_scrollbar_task: None,
-            blink_epoch: 0,
-            blinking_paused: false,
             mode,
             vertical_scroll_margin: 3.0,
             placeholder_text: None,
@@ -1130,6 +1202,7 @@ impl Editor {
                 cx.observe(&buffer, Self::on_buffer_changed),
                 cx.subscribe(&buffer, Self::on_buffer_event),
                 cx.observe(&display_map, Self::on_display_map_changed),
+                cx.observe(&blink_manager, |_, _, cx| cx.notify()),
             ],
         };
         this.end_selection(cx);
@@ -1186,6 +1259,7 @@ impl Editor {
         EditorSnapshot {
             mode: self.mode,
             display_snapshot: self.display_map.update(cx, |map, cx| map.snapshot(cx)),
+            ongoing_scroll: self.ongoing_scroll,
             scroll_position: self.scroll_position,
             scroll_top_anchor: self.scroll_top_anchor.clone(),
             placeholder_text: self.placeholder_text.clone(),
@@ -1478,6 +1552,7 @@ impl Editor {
                 buffer.set_active_selections(
                     &self.selections.disjoint_anchors(),
                     self.selections.line_mode,
+                    self.cursor_shape,
                     cx,
                 )
             });
@@ -1541,7 +1616,7 @@ impl Editor {
             refresh_matching_bracket_highlights(self, cx);
         }
 
-        self.pause_cursor_blinking(cx);
+        self.blink_manager.update(cx, BlinkManager::pause_blinking);
         cx.emit(Event::SelectionsChanged { local });
         cx.notify();
     }
@@ -1588,6 +1663,11 @@ impl Editor {
         });
     }
 
+    fn scroll(&mut self, action: &Scroll, cx: &mut ViewContext<Self>) {
+        self.ongoing_scroll.update(action.axis);
+        self.set_scroll_position(action.scroll_position, cx);
+    }
+
     fn select(&mut self, Select(phase): &Select, cx: &mut ViewContext<Self>) {
         self.hide_context_menu(cx);
 
@@ -6110,60 +6190,8 @@ impl Editor {
         highlights
     }
 
-    fn next_blink_epoch(&mut self) -> usize {
-        self.blink_epoch += 1;
-        self.blink_epoch
-    }
-
-    fn pause_cursor_blinking(&mut self, cx: &mut ViewContext<Self>) {
-        if !self.focused {
-            return;
-        }
-
-        self.show_local_cursors = true;
-        cx.notify();
-
-        let epoch = self.next_blink_epoch();
-        cx.spawn(|this, mut cx| {
-            let this = this.downgrade();
-            async move {
-                Timer::after(CURSOR_BLINK_INTERVAL).await;
-                if let Some(this) = this.upgrade(&cx) {
-                    this.update(&mut cx, |this, cx| this.resume_cursor_blinking(epoch, cx))
-                }
-            }
-        })
-        .detach();
-    }
-
-    fn resume_cursor_blinking(&mut self, epoch: usize, cx: &mut ViewContext<Self>) {
-        if epoch == self.blink_epoch {
-            self.blinking_paused = false;
-            self.blink_cursors(epoch, cx);
-        }
-    }
-
-    fn blink_cursors(&mut self, epoch: usize, cx: &mut ViewContext<Self>) {
-        if epoch == self.blink_epoch && self.focused && !self.blinking_paused {
-            self.show_local_cursors = !self.show_local_cursors;
-            cx.notify();
-
-            let epoch = self.next_blink_epoch();
-            cx.spawn(|this, mut cx| {
-                let this = this.downgrade();
-                async move {
-                    Timer::after(CURSOR_BLINK_INTERVAL).await;
-                    if let Some(this) = this.upgrade(&cx) {
-                        this.update(&mut cx, |this, cx| this.blink_cursors(epoch, cx));
-                    }
-                }
-            })
-            .detach();
-        }
-    }
-
-    pub fn show_local_cursors(&self) -> bool {
-        self.show_local_cursors && self.focused
+    pub fn show_local_cursors(&self, cx: &AppContext) -> bool {
+        self.blink_manager.read(cx).visible() && self.focused
     }
 
     pub fn show_scrollbars(&self) -> bool {
@@ -6466,9 +6494,7 @@ impl View for Editor {
         }
 
         Stack::new()
-            .with_child(
-                EditorElement::new(self.handle.clone(), style.clone(), self.cursor_shape).boxed(),
-            )
+            .with_child(EditorElement::new(self.handle.clone(), style.clone()).boxed())
             .with_child(ChildView::new(&self.mouse_context_menu, cx).boxed())
             .boxed()
     }
@@ -6477,20 +6503,21 @@ impl View for Editor {
         "Editor"
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         let focused_event = EditorFocused(cx.handle());
         cx.emit_global(focused_event);
         if let Some(rename) = self.pending_rename.as_ref() {
             cx.focus(&rename.editor);
         } else {
             self.focused = true;
-            self.blink_cursors(self.blink_epoch, cx);
+            self.blink_manager.update(cx, BlinkManager::enable);
             self.buffer.update(cx, |buffer, cx| {
                 buffer.finalize_last_transaction(cx);
                 if self.leader_replica_id.is_none() {
                     buffer.set_active_selections(
                         &self.selections.disjoint_anchors(),
                         self.selections.line_mode,
+                        self.cursor_shape,
                         cx,
                     );
                 }
@@ -6498,10 +6525,11 @@ impl View for Editor {
         }
     }
 
-    fn on_focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         let blurred_event = EditorBlurred(cx.handle());
         cx.emit_global(blurred_event);
         self.focused = false;
+        self.blink_manager.update(cx, BlinkManager::disable);
         self.buffer
             .update(cx, |buffer, cx| buffer.remove_active_selections(cx));
         self.hide_context_menu(cx);
@@ -6510,6 +6538,44 @@ impl View for Editor {
         cx.notify();
     }
 
+    fn modifiers_changed(
+        &mut self,
+        event: &gpui::ModifiersChangedEvent,
+        cx: &mut ViewContext<Self>,
+    ) -> bool {
+        let pending_selection = self.has_pending_selection();
+
+        if let Some(point) = self.link_go_to_definition_state.last_mouse_location.clone() {
+            if event.cmd && !pending_selection {
+                let snapshot = self.snapshot(cx);
+                let kind = if event.shift {
+                    LinkDefinitionKind::Type
+                } else {
+                    LinkDefinitionKind::Symbol
+                };
+
+                show_link_definition(kind, self, point, snapshot, cx);
+                return false;
+            }
+        }
+
+        {
+            if self.link_go_to_definition_state.symbol_range.is_some()
+                || !self.link_go_to_definition_state.definitions.is_empty()
+            {
+                self.link_go_to_definition_state.symbol_range.take();
+                self.link_go_to_definition_state.definitions.clear();
+                cx.notify();
+            }
+
+            self.link_go_to_definition_state.task = None;
+
+            self.clear_text_highlights::<LinkGoToDefinitionState>(cx);
+        }
+
+        false
+    }
+
     fn keymap_context(&self, _: &AppContext) -> gpui::keymap::Context {
         let mut context = Self::default_keymap_context();
         let mode = match self.mode {
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 3e68c6766f92d57c33eac323f84ae32c182dfb34..d8f5c83daffd4805ee089a5717229dbb88855e6b 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -9,7 +9,7 @@ use crate::{
         HoverAt, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH, MIN_POPOVER_LINE_HEIGHT,
     },
     link_go_to_definition::{
-        CmdShiftChanged, GoToFetchedDefinition, GoToFetchedTypeDefinition, UpdateGoToDefinitionLink,
+        GoToFetchedDefinition, GoToFetchedTypeDefinition, UpdateGoToDefinitionLink,
     },
     mouse_context_menu::DeployMouseContextMenu,
     AnchorRangeExt, EditorStyle,
@@ -29,13 +29,12 @@ use gpui::{
     json::{self, ToJson},
     platform::CursorStyle,
     text_layout::{self, Line, RunStyle, TextLayoutCache},
-    AppContext, Axis, Border, CursorRegion, Element, ElementBox, Event, EventContext,
-    LayoutContext, ModifiersChangedEvent, MouseButton, MouseButtonEvent, MouseMovedEvent,
-    MouseRegion, MutableAppContext, PaintContext, Quad, Scene, SizeConstraint, ViewContext,
-    WeakViewHandle,
+    AppContext, Axis, Border, CursorRegion, Element, ElementBox, EventContext, LayoutContext,
+    MouseButton, MouseButtonEvent, MouseMovedEvent, MouseRegion, MutableAppContext, PaintContext,
+    Quad, Scene, SizeConstraint, ViewContext, WeakViewHandle,
 };
 use json::json;
-use language::{Bias, DiagnosticSeverity, OffsetUtf16, Point, Selection};
+use language::{Bias, CursorShape, DiagnosticSeverity, OffsetUtf16, Point, Selection};
 use project::ProjectPath;
 use settings::{GitGutter, Settings};
 use smallvec::SmallVec;
@@ -56,6 +55,7 @@ struct DiffHunkLayout {
 
 struct SelectionLayout {
     head: DisplayPoint,
+    cursor_shape: CursorShape,
     range: Range<DisplayPoint>,
 }
 
@@ -63,6 +63,7 @@ impl SelectionLayout {
     fn new<T: ToPoint + ToDisplayPoint + Clone>(
         selection: Selection<T>,
         line_mode: bool,
+        cursor_shape: CursorShape,
         map: &DisplaySnapshot,
     ) -> Self {
         if line_mode {
@@ -70,6 +71,7 @@ impl SelectionLayout {
             let point_range = map.expand_to_line(selection.range());
             Self {
                 head: selection.head().to_display_point(map),
+                cursor_shape,
                 range: point_range.start.to_display_point(map)
                     ..point_range.end.to_display_point(map),
             }
@@ -77,6 +79,7 @@ impl SelectionLayout {
             let selection = selection.map(|p| p.to_display_point(map));
             Self {
                 head: selection.head(),
+                cursor_shape,
                 range: selection.range(),
             }
         }
@@ -87,19 +90,13 @@ impl SelectionLayout {
 pub struct EditorElement {
     view: WeakViewHandle<Editor>,
     style: Arc<EditorStyle>,
-    cursor_shape: CursorShape,
 }
 
 impl EditorElement {
-    pub fn new(
-        view: WeakViewHandle<Editor>,
-        style: EditorStyle,
-        cursor_shape: CursorShape,
-    ) -> Self {
+    pub fn new(view: WeakViewHandle<Editor>, style: EditorStyle) -> Self {
         Self {
             view,
             style: Arc::new(style),
-            cursor_shape,
         }
     }
 
@@ -414,14 +411,6 @@ impl EditorElement {
         true
     }
 
-    fn modifiers_changed(&self, event: ModifiersChangedEvent, cx: &mut EventContext) -> bool {
-        cx.dispatch_action(CmdShiftChanged {
-            cmd_down: event.cmd,
-            shift_down: event.shift,
-        });
-        false
-    }
-
     fn scroll(
         position: Vector2F,
         mut delta: Vector2F,
@@ -434,18 +423,27 @@ impl EditorElement {
             return false;
         }
 
+        let line_height = position_map.line_height;
         let max_glyph_width = position_map.em_width;
-        if !precise {
-            delta *= vec2f(max_glyph_width, position_map.line_height);
-        }
+
+        let axis = if precise {
+            //Trackpad
+            position_map.snapshot.ongoing_scroll.filter(&mut delta)
+        } else {
+            //Not trackpad
+            delta *= vec2f(max_glyph_width, line_height);
+            None //Resets ongoing scroll
+        };
 
         let scroll_position = position_map.snapshot.scroll_position();
         let x = (scroll_position.x() * max_glyph_width - delta.x()) / max_glyph_width;
-        let y =
-            (scroll_position.y() * position_map.line_height - delta.y()) / position_map.line_height;
+        let y = (scroll_position.y() * line_height - delta.y()) / line_height;
         let scroll_position = vec2f(x, y).clamp(Vector2F::zero(), position_map.scroll_max);
 
-        cx.dispatch_action(Scroll(scroll_position));
+        cx.dispatch_action(Scroll {
+            scroll_position,
+            axis,
+        });
 
         true
     }
@@ -707,7 +705,7 @@ impl EditorElement {
                     cx,
                 );
 
-                if view.show_local_cursors() || *replica_id != local_replica_id {
+                if view.show_local_cursors(cx) || *replica_id != local_replica_id {
                     let cursor_position = selection.head;
                     if layout
                         .visible_display_row_range
@@ -723,7 +721,7 @@ impl EditorElement {
                         if block_width == 0.0 {
                             block_width = layout.position_map.em_width;
                         }
-                        let block_text = if let CursorShape::Block = self.cursor_shape {
+                        let block_text = if let CursorShape::Block = selection.cursor_shape {
                             layout
                                 .position_map
                                 .snapshot
@@ -759,7 +757,7 @@ impl EditorElement {
                             block_width,
                             origin: vec2f(x, y),
                             line_height: layout.position_map.line_height,
-                            shape: self.cursor_shape,
+                            shape: selection.cursor_shape,
                             block_text,
                         });
                     }
@@ -1326,6 +1324,7 @@ impl EditorElement {
         line_height: f32,
         style: &EditorStyle,
         line_layouts: &[text_layout::Line],
+        include_root: bool,
         cx: &mut LayoutContext,
     ) -> (f32, Vec<BlockLayout>) {
         let editor = if let Some(editor) = self.view.upgrade(cx) {
@@ -1429,10 +1428,11 @@ impl EditorElement {
                         let font_size =
                             (style.text_scale_factor * self.style.text.font_size).round();
 
+                        let path = buffer.resolve_file_path(cx, include_root);
                         let mut filename = None;
                         let mut parent_path = None;
-                        if let Some(file) = buffer.file() {
-                            let path = file.path();
+                        // Can't use .and_then() because `.file_name()` and `.parent()` return references :(
+                        if let Some(path) = path {
                             filename = path.file_name().map(|f| f.to_string_lossy().to_string());
                             parent_path =
                                 path.parent().map(|p| p.to_string_lossy().to_string() + "/");
@@ -1636,6 +1636,7 @@ impl Element for EditorElement {
         let mut highlighted_rows = None;
         let mut highlighted_ranges = Vec::new();
         let mut show_scrollbars = false;
+        let mut include_root = false;
         self.update_view(cx.app, |view, cx| {
             let display_map = view.display_map.update(cx, |map, cx| map.snapshot(cx));
 
@@ -1648,7 +1649,7 @@ impl Element for EditorElement {
             );
 
             let mut remote_selections = HashMap::default();
-            for (replica_id, line_mode, selection) in display_map
+            for (replica_id, line_mode, cursor_shape, selection) in display_map
                 .buffer_snapshot
                 .remote_selections_in_range(&(start_anchor.clone()..end_anchor.clone()))
             {
@@ -1659,7 +1660,12 @@ impl Element for EditorElement {
                 remote_selections
                     .entry(replica_id)
                     .or_insert(Vec::new())
-                    .push(SelectionLayout::new(selection, line_mode, &display_map));
+                    .push(SelectionLayout::new(
+                        selection,
+                        line_mode,
+                        cursor_shape,
+                        &display_map,
+                    ));
             }
             selections.extend(remote_selections);
 
@@ -1691,13 +1697,23 @@ impl Element for EditorElement {
                     local_selections
                         .into_iter()
                         .map(|selection| {
-                            SelectionLayout::new(selection, view.selections.line_mode, &display_map)
+                            SelectionLayout::new(
+                                selection,
+                                view.selections.line_mode,
+                                view.cursor_shape,
+                                &display_map,
+                            )
                         })
                         .collect(),
                 ));
             }
 
             show_scrollbars = view.show_scrollbars();
+            include_root = view
+                .project
+                .as_ref()
+                .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
+                .unwrap_or_default()
         });
 
         let line_number_layouts =
@@ -1737,6 +1753,7 @@ impl Element for EditorElement {
             line_height,
             &style,
             &line_layouts,
+            include_root,
             cx,
         );
 
@@ -1913,22 +1930,6 @@ impl Element for EditorElement {
         cx.scene.pop_layer();
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut LayoutState,
-        _: &mut (),
-        cx: &mut EventContext,
-    ) -> bool {
-        if let Event::ModifiersChanged(event) = event {
-            self.modifiers_changed(*event, cx);
-        }
-
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -2094,20 +2095,6 @@ fn layout_line(
     )
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum CursorShape {
-    Bar,
-    Block,
-    Underscore,
-    Hollow,
-}
-
-impl Default for CursorShape {
-    fn default() -> Self {
-        CursorShape::Bar
-    }
-}
-
 #[derive(Debug)]
 pub struct Cursor {
     origin: Vector2F,
@@ -2348,11 +2335,7 @@ mod tests {
         let (window_id, editor) = cx.add_window(Default::default(), |cx| {
             Editor::new(EditorMode::Full, buffer, None, None, cx)
         });
-        let element = EditorElement::new(
-            editor.downgrade(),
-            editor.read(cx).style(cx),
-            CursorShape::Bar,
-        );
+        let element = EditorElement::new(editor.downgrade(), editor.read(cx).style(cx));
 
         let layouts = editor.update(cx, |editor, cx| {
             let snapshot = editor.snapshot(cx);
@@ -2388,11 +2371,7 @@ mod tests {
             cx.blur();
         });
 
-        let mut element = EditorElement::new(
-            editor.downgrade(),
-            editor.read(cx).style(cx),
-            CursorShape::Bar,
-        );
+        let mut element = EditorElement::new(editor.downgrade(), editor.read(cx).style(cx));
 
         let mut scene = Scene::new(1.0);
         let mut presenter = cx.build_presenter(window_id, 30., Default::default());
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index e6a4eebffb0cb3587761855028411182fe7aac25..47e06fc545a419e8c2a25af430340e61bd6f6a6c 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -120,6 +120,7 @@ impl FollowableItem for Editor {
                     buffer.set_active_selections(
                         &self.selections.disjoint_anchors(),
                         self.selections.line_mode,
+                        self.cursor_shape,
                         cx,
                     );
                 }
@@ -531,21 +532,17 @@ impl Item for Editor {
         let buffer = multibuffer.buffer(buffer_id)?;
 
         let buffer = buffer.read(cx);
-        let filename = if let Some(file) = buffer.file() {
-            if file.path().file_name().is_none()
-                || self
-                    .project
+        let filename = buffer
+            .snapshot()
+            .resolve_file_path(
+                cx,
+                self.project
                     .as_ref()
                     .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
-                    .unwrap_or_default()
-            {
-                file.full_path(cx).to_string_lossy().to_string()
-            } else {
-                file.path().to_string_lossy().to_string()
-            }
-        } else {
-            "untitled".to_string()
-        };
+                    .unwrap_or_default(),
+            )
+            .map(|path| path.to_string_lossy().to_string())
+            .unwrap_or_else(|| "untitled".to_string());
 
         let mut breadcrumbs = vec![Label::new(filename, theme.breadcrumbs.text.clone()).boxed()];
         breadcrumbs.extend(symbols.into_iter().map(|symbol| {
diff --git a/crates/editor/src/link_go_to_definition.rs b/crates/editor/src/link_go_to_definition.rs
index c8294ddb43744ccf09a016739b8d2277645b4b48..705a1b276075eda3ebbf3f42b7a6e8c0664694cc 100644
--- a/crates/editor/src/link_go_to_definition.rs
+++ b/crates/editor/src/link_go_to_definition.rs
@@ -19,12 +19,6 @@ pub struct UpdateGoToDefinitionLink {
     pub shift_held: bool,
 }
 
-#[derive(Clone, PartialEq)]
-pub struct CmdShiftChanged {
-    pub cmd_down: bool,
-    pub shift_down: bool,
-}
-
 #[derive(Clone, PartialEq)]
 pub struct GoToFetchedDefinition {
     pub point: DisplayPoint,
@@ -39,7 +33,6 @@ impl_internal_actions!(
     editor,
     [
         UpdateGoToDefinitionLink,
-        CmdShiftChanged,
         GoToFetchedDefinition,
         GoToFetchedTypeDefinition
     ]
@@ -47,7 +40,6 @@ impl_internal_actions!(
 
 pub fn init(cx: &mut MutableAppContext) {
     cx.add_action(update_go_to_definition_link);
-    cx.add_action(cmd_shift_changed);
     cx.add_action(go_to_fetched_definition);
     cx.add_action(go_to_fetched_type_definition);
 }
@@ -113,37 +105,6 @@ pub fn update_go_to_definition_link(
     hide_link_definition(editor, cx);
 }
 
-pub fn cmd_shift_changed(
-    editor: &mut Editor,
-    &CmdShiftChanged {
-        cmd_down,
-        shift_down,
-    }: &CmdShiftChanged,
-    cx: &mut ViewContext<Editor>,
-) {
-    let pending_selection = editor.has_pending_selection();
-
-    if let Some(point) = editor
-        .link_go_to_definition_state
-        .last_mouse_location
-        .clone()
-    {
-        if cmd_down && !pending_selection {
-            let snapshot = editor.snapshot(cx);
-            let kind = if shift_down {
-                LinkDefinitionKind::Type
-            } else {
-                LinkDefinitionKind::Symbol
-            };
-
-            show_link_definition(kind, editor, point, snapshot, cx);
-            return;
-        }
-    }
-
-    hide_link_definition(editor, cx)
-}
-
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum LinkDefinitionKind {
     Symbol,
@@ -397,6 +358,7 @@ fn go_to_fetched_definition_of_kind(
 #[cfg(test)]
 mod tests {
     use futures::StreamExt;
+    use gpui::{ModifiersChangedEvent, View};
     use indoc::indoc;
     use lsp::request::{GotoDefinition, GotoTypeDefinition};
 
@@ -467,11 +429,10 @@ mod tests {
 
         // Unpress shift causes highlight to go away (normal goto-definition is not valid here)
         cx.update_editor(|editor, cx| {
-            cmd_shift_changed(
-                editor,
-                &CmdShiftChanged {
-                    cmd_down: true,
-                    shift_down: false,
+            editor.modifiers_changed(
+                &gpui::ModifiersChangedEvent {
+                    cmd: true,
+                    ..Default::default()
                 },
                 cx,
             );
@@ -581,14 +542,7 @@ mod tests {
 
         // Unpress cmd causes highlight to go away
         cx.update_editor(|editor, cx| {
-            cmd_shift_changed(
-                editor,
-                &CmdShiftChanged {
-                    cmd_down: false,
-                    shift_down: false,
-                },
-                cx,
-            );
+            editor.modifiers_changed(&Default::default(), cx);
         });
 
         // Assert no link highlights
@@ -704,11 +658,10 @@ mod tests {
             ])))
         });
         cx.update_editor(|editor, cx| {
-            cmd_shift_changed(
-                editor,
-                &CmdShiftChanged {
-                    cmd_down: true,
-                    shift_down: false,
+            editor.modifiers_changed(
+                &ModifiersChangedEvent {
+                    cmd: true,
+                    ..Default::default()
                 },
                 cx,
             );
diff --git a/crates/editor/src/multi_buffer.rs b/crates/editor/src/multi_buffer.rs
index 448564ed9808e40fcf9e2fa515a881308ce4937f..1cff0038686f88c27816124d850eece8427ae864 100644
--- a/crates/editor/src/multi_buffer.rs
+++ b/crates/editor/src/multi_buffer.rs
@@ -8,7 +8,7 @@ use git::diff::DiffHunk;
 use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
 pub use language::Completion;
 use language::{
-    char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk,
+    char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
     DiagnosticEntry, Event, File, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Outline,
     OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _, ToOffsetUtf16 as _,
     ToPoint as _, ToPointUtf16 as _, TransactionId,
@@ -604,6 +604,7 @@ impl MultiBuffer {
         &mut self,
         selections: &[Selection<Anchor>],
         line_mode: bool,
+        cursor_shape: CursorShape,
         cx: &mut ModelContext<Self>,
     ) {
         let mut selections_by_buffer: HashMap<usize, Vec<Selection<text::Anchor>>> =
@@ -668,7 +669,7 @@ impl MultiBuffer {
                         }
                         Some(selection)
                     }));
-                    buffer.set_active_selections(merged_selections, line_mode, cx);
+                    buffer.set_active_selections(merged_selections, line_mode, cursor_shape, cx);
                 });
         }
     }
@@ -2698,7 +2699,7 @@ impl MultiBufferSnapshot {
     pub fn remote_selections_in_range<'a>(
         &'a self,
         range: &'a Range<Anchor>,
-    ) -> impl 'a + Iterator<Item = (ReplicaId, bool, Selection<Anchor>)> {
+    ) -> impl 'a + Iterator<Item = (ReplicaId, bool, CursorShape, Selection<Anchor>)> {
         let mut cursor = self.excerpts.cursor::<Option<&ExcerptId>>();
         cursor.seek(&Some(&range.start.excerpt_id), Bias::Left, &());
         cursor
@@ -2715,7 +2716,7 @@ impl MultiBufferSnapshot {
                 excerpt
                     .buffer
                     .remote_selections_in_range(query_range)
-                    .flat_map(move |(replica_id, line_mode, selections)| {
+                    .flat_map(move |(replica_id, line_mode, cursor_shape, selections)| {
                         selections.map(move |selection| {
                             let mut start = Anchor {
                                 buffer_id: Some(excerpt.buffer_id),
@@ -2737,6 +2738,7 @@ impl MultiBufferSnapshot {
                             (
                                 replica_id,
                                 line_mode,
+                                cursor_shape,
                                 Selection {
                                     id: selection.id,
                                     start,
diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index e787e3c1a63c882398069c8efc81aa4515e826da..1a82613b84329eea6c214073185e26f886110fd2 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -53,7 +53,7 @@ impl View for FileFinder {
         ChildView::new(self.picker.clone(), cx).boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.picker);
         }
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index 2061d3734bd386901a97441fa34ea71c5b33f5a6..7bd7346b4b30ef2e1a99707e194e575f6cbc2f47 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -13,6 +13,7 @@ use smol::io::{AsyncReadExt, AsyncWriteExt};
 use std::borrow::Cow;
 use std::cmp;
 use std::io::Write;
+use std::ops::Deref;
 use std::sync::Arc;
 use std::{
     io,
@@ -92,6 +93,17 @@ impl LineEnding {
         }
     }
 }
+
+pub struct HomeDir(pub PathBuf);
+
+impl Deref for HomeDir {
+    type Target = PathBuf;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 #[async_trait::async_trait]
 pub trait Fs: Send + Sync {
     async fn create_dir(&self, path: &Path) -> Result<()>;
diff --git a/crates/go_to_line/src/go_to_line.rs b/crates/go_to_line/src/go_to_line.rs
index eddb014b63a4715e6268070ccc9f96897f0e50d5..ad1dacf7434e5bb30e7d4b04170aa0828e911b59 100644
--- a/crates/go_to_line/src/go_to_line.rs
+++ b/crates/go_to_line/src/go_to_line.rs
@@ -183,7 +183,7 @@ impl View for GoToLine {
         .named("go to line")
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         cx.focus(&self.line_editor);
     }
 }
diff --git a/crates/gpui/examples/text.rs b/crates/gpui/examples/text.rs
index d4e873f039c7d907e71887e5b10325fa9ba41e37..4d84fefab62e30e86f25d72f06c7638bf72894f7 100644
--- a/crates/gpui/examples/text.rs
+++ b/crates/gpui/examples/text.rs
@@ -101,18 +101,6 @@ impl gpui::Element for TextElement {
         line.paint(bounds.origin(), visible_bounds, bounds.height(), cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &gpui::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut gpui::EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index a9529f3f9fccb67200aa944dd3509fda67432bc9..a9020cf35088a30488a8fb62ed1d0a547d37227b 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -41,8 +41,8 @@ use crate::{
     platform::{self, KeyDownEvent, Platform, PromptLevel, WindowOptions},
     presenter::Presenter,
     util::post_inc,
-    Appearance, AssetCache, AssetSource, ClipboardItem, FontCache, InputHandler, MouseButton,
-    MouseRegionId, PathPromptOptions, TextLayoutCache,
+    Appearance, AssetCache, AssetSource, ClipboardItem, FontCache, InputHandler, KeyUpEvent,
+    ModifiersChangedEvent, MouseButton, MouseRegionId, PathPromptOptions, TextLayoutCache,
 };
 
 pub trait Entity: 'static {
@@ -60,8 +60,18 @@ pub trait Entity: 'static {
 pub trait View: Entity + Sized {
     fn ui_name() -> &'static str;
     fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox;
-    fn on_focus_in(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
-    fn on_focus_out(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
+    fn focus_in(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
+    fn focus_out(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
+    fn key_down(&mut self, _: &KeyDownEvent, _: &mut ViewContext<Self>) -> bool {
+        false
+    }
+    fn key_up(&mut self, _: &KeyUpEvent, _: &mut ViewContext<Self>) -> bool {
+        false
+    }
+    fn modifiers_changed(&mut self, _: &ModifiersChangedEvent, _: &mut ViewContext<Self>) -> bool {
+        false
+    }
+
     fn keymap_context(&self, _: &AppContext) -> keymap::Context {
         Self::default_keymap_context()
     }
@@ -1297,7 +1307,7 @@ impl MutableAppContext {
     ) -> impl Iterator<Item = (&'static str, Box<dyn Action>, SmallVec<[&Binding; 1]>)> {
         let mut action_types: HashSet<_> = self.global_actions.keys().copied().collect();
 
-        for view_id in self.parents(window_id, view_id) {
+        for view_id in self.ancestors(window_id, view_id) {
             if let Some(view) = self.views.get(&(window_id, view_id)) {
                 let view_type = view.as_any().type_id();
                 if let Some(actions) = self.actions.get(&view_type) {
@@ -1327,7 +1337,7 @@ impl MutableAppContext {
         let action_type = action.as_any().type_id();
         if let Some(window_id) = self.cx.platform.key_window_id() {
             if let Some(focused_view_id) = self.focused_view_id(window_id) {
-                for view_id in self.parents(window_id, focused_view_id) {
+                for view_id in self.ancestors(window_id, focused_view_id) {
                     if let Some(view) = self.views.get(&(window_id, view_id)) {
                         let view_type = view.as_any().type_id();
                         if let Some(actions) = self.actions.get(&view_type) {
@@ -1376,7 +1386,7 @@ impl MutableAppContext {
         mut visit: impl FnMut(usize, bool, &mut MutableAppContext) -> bool,
     ) -> bool {
         // List of view ids from the leaf to the root of the window
-        let path = self.parents(window_id, view_id).collect::<Vec<_>>();
+        let path = self.ancestors(window_id, view_id).collect::<Vec<_>>();
 
         // Walk down from the root to the leaf calling visit with capture_phase = true
         for view_id in path.iter().rev() {
@@ -1397,7 +1407,7 @@ impl MutableAppContext {
 
     // Returns an iterator over all of the view ids from the passed view up to the root of the window
     // Includes the passed view itself
-    fn parents(&self, window_id: usize, mut view_id: usize) -> impl Iterator<Item = usize> + '_ {
+    fn ancestors(&self, window_id: usize, mut view_id: usize) -> impl Iterator<Item = usize> + '_ {
         std::iter::once(view_id)
             .into_iter()
             .chain(std::iter::from_fn(move || {
@@ -1445,11 +1455,81 @@ impl MutableAppContext {
         self.keystroke_matcher.clear_bindings();
     }
 
+    pub fn dispatch_key_down(&mut self, window_id: usize, event: &KeyDownEvent) -> bool {
+        if let Some(focused_view_id) = self.focused_view_id(window_id) {
+            for view_id in self
+                .ancestors(window_id, focused_view_id)
+                .collect::<Vec<_>>()
+            {
+                if let Some(mut view) = self.cx.views.remove(&(window_id, view_id)) {
+                    let handled = view.key_down(event, self, window_id, view_id);
+                    self.cx.views.insert((window_id, view_id), view);
+                    if handled {
+                        return true;
+                    }
+                } else {
+                    log::error!("view {} does not exist", view_id)
+                }
+            }
+        }
+
+        false
+    }
+
+    pub fn dispatch_key_up(&mut self, window_id: usize, event: &KeyUpEvent) -> bool {
+        if let Some(focused_view_id) = self.focused_view_id(window_id) {
+            for view_id in self
+                .ancestors(window_id, focused_view_id)
+                .collect::<Vec<_>>()
+            {
+                if let Some(mut view) = self.cx.views.remove(&(window_id, view_id)) {
+                    let handled = view.key_up(event, self, window_id, view_id);
+                    self.cx.views.insert((window_id, view_id), view);
+                    if handled {
+                        return true;
+                    }
+                } else {
+                    log::error!("view {} does not exist", view_id)
+                }
+            }
+        }
+
+        false
+    }
+
+    pub fn dispatch_modifiers_changed(
+        &mut self,
+        window_id: usize,
+        event: &ModifiersChangedEvent,
+    ) -> bool {
+        if let Some(focused_view_id) = self.focused_view_id(window_id) {
+            for view_id in self
+                .ancestors(window_id, focused_view_id)
+                .collect::<Vec<_>>()
+            {
+                if let Some(mut view) = self.cx.views.remove(&(window_id, view_id)) {
+                    let handled = view.modifiers_changed(event, self, window_id, view_id);
+                    self.cx.views.insert((window_id, view_id), view);
+                    if handled {
+                        return true;
+                    }
+                } else {
+                    log::error!("view {} does not exist", view_id)
+                }
+            }
+        }
+
+        false
+    }
+
     pub fn dispatch_keystroke(&mut self, window_id: usize, keystroke: &Keystroke) -> bool {
         let mut pending = false;
 
         if let Some(focused_view_id) = self.focused_view_id(window_id) {
-            for view_id in self.parents(window_id, focused_view_id).collect::<Vec<_>>() {
+            for view_id in self
+                .ancestors(window_id, focused_view_id)
+                .collect::<Vec<_>>()
+            {
                 let keymap_context = self
                     .cx
                     .views
@@ -1580,7 +1660,7 @@ impl MutableAppContext {
                     is_fullscreen: false,
                 },
             );
-            root_view.update(this, |view, cx| view.on_focus_in(cx.handle().into(), cx));
+            root_view.update(this, |view, cx| view.focus_in(cx.handle().into(), cx));
 
             let window =
                 this.cx
@@ -1612,7 +1692,7 @@ impl MutableAppContext {
                     is_fullscreen: false,
                 },
             );
-            root_view.update(this, |view, cx| view.on_focus_in(cx.handle().into(), cx));
+            root_view.update(this, |view, cx| view.focus_in(cx.handle().into(), cx));
 
             let status_item = this.cx.platform.add_status_item();
             this.register_platform_window(window_id, status_item);
@@ -2235,12 +2315,12 @@ impl MutableAppContext {
 
             //Handle focus
             let focused_id = window.focused_view_id?;
-            for view_id in this.parents(window_id, focused_id).collect::<Vec<_>>() {
+            for view_id in this.ancestors(window_id, focused_id).collect::<Vec<_>>() {
                 if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
                     if active {
-                        view.on_focus_in(this, window_id, view_id, focused_id);
+                        view.focus_in(this, window_id, view_id, focused_id);
                     } else {
-                        view.on_focus_out(this, window_id, view_id, focused_id);
+                        view.focus_out(this, window_id, view_id, focused_id);
                     }
                     this.cx.views.insert((window_id, view_id), view);
                 }
@@ -2272,16 +2352,16 @@ impl MutableAppContext {
             });
 
             let blurred_parents = blurred_id
-                .map(|blurred_id| this.parents(window_id, blurred_id).collect::<Vec<_>>())
+                .map(|blurred_id| this.ancestors(window_id, blurred_id).collect::<Vec<_>>())
                 .unwrap_or_default();
             let focused_parents = focused_id
-                .map(|focused_id| this.parents(window_id, focused_id).collect::<Vec<_>>())
+                .map(|focused_id| this.ancestors(window_id, focused_id).collect::<Vec<_>>())
                 .unwrap_or_default();
 
             if let Some(blurred_id) = blurred_id {
                 for view_id in blurred_parents.iter().copied() {
                     if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
-                        view.on_focus_out(this, window_id, view_id, blurred_id);
+                        view.focus_out(this, window_id, view_id, blurred_id);
                         this.cx.views.insert((window_id, view_id), view);
                     }
                 }
@@ -2294,7 +2374,7 @@ impl MutableAppContext {
             if let Some(focused_id) = focused_id {
                 for view_id in focused_parents {
                     if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
-                        view.on_focus_in(this, window_id, view_id, focused_id);
+                        view.focus_in(this, window_id, view_id, focused_id);
                         this.cx.views.insert((window_id, view_id), view);
                     }
                 }
@@ -2961,20 +3041,41 @@ pub trait AnyView {
     ) -> Option<Pin<Box<dyn 'static + Future<Output = ()>>>>;
     fn ui_name(&self) -> &'static str;
     fn render(&mut self, params: RenderParams, cx: &mut MutableAppContext) -> ElementBox;
-    fn on_focus_in(
+    fn focus_in(
         &mut self,
         cx: &mut MutableAppContext,
         window_id: usize,
         view_id: usize,
         focused_id: usize,
     );
-    fn on_focus_out(
+    fn focus_out(
         &mut self,
         cx: &mut MutableAppContext,
         window_id: usize,
         view_id: usize,
         focused_id: usize,
     );
+    fn key_down(
+        &mut self,
+        event: &KeyDownEvent,
+        cx: &mut MutableAppContext,
+        window_id: usize,
+        view_id: usize,
+    ) -> bool;
+    fn key_up(
+        &mut self,
+        event: &KeyUpEvent,
+        cx: &mut MutableAppContext,
+        window_id: usize,
+        view_id: usize,
+    ) -> bool;
+    fn modifiers_changed(
+        &mut self,
+        event: &ModifiersChangedEvent,
+        cx: &mut MutableAppContext,
+        window_id: usize,
+        view_id: usize,
+    ) -> bool;
     fn keymap_context(&self, cx: &AppContext) -> keymap::Context;
     fn debug_json(&self, cx: &AppContext) -> serde_json::Value;
 
@@ -3040,7 +3141,7 @@ where
         View::render(self, &mut RenderContext::new(params, cx))
     }
 
-    fn on_focus_in(
+    fn focus_in(
         &mut self,
         cx: &mut MutableAppContext,
         window_id: usize,
@@ -3059,10 +3160,10 @@ where
                 .type_id();
             AnyViewHandle::new(window_id, focused_id, focused_type, cx.ref_counts.clone())
         };
-        View::on_focus_in(self, focused_view_handle, &mut cx);
+        View::focus_in(self, focused_view_handle, &mut cx);
     }
 
-    fn on_focus_out(
+    fn focus_out(
         &mut self,
         cx: &mut MutableAppContext,
         window_id: usize,
@@ -3081,7 +3182,40 @@ where
                 .type_id();
             AnyViewHandle::new(window_id, blurred_id, blurred_type, cx.ref_counts.clone())
         };
-        View::on_focus_out(self, blurred_view_handle, &mut cx);
+        View::focus_out(self, blurred_view_handle, &mut cx);
+    }
+
+    fn key_down(
+        &mut self,
+        event: &KeyDownEvent,
+        cx: &mut MutableAppContext,
+        window_id: usize,
+        view_id: usize,
+    ) -> bool {
+        let mut cx = ViewContext::new(cx, window_id, view_id);
+        View::key_down(self, event, &mut cx)
+    }
+
+    fn key_up(
+        &mut self,
+        event: &KeyUpEvent,
+        cx: &mut MutableAppContext,
+        window_id: usize,
+        view_id: usize,
+    ) -> bool {
+        let mut cx = ViewContext::new(cx, window_id, view_id);
+        View::key_up(self, event, &mut cx)
+    }
+
+    fn modifiers_changed(
+        &mut self,
+        event: &ModifiersChangedEvent,
+        cx: &mut MutableAppContext,
+        window_id: usize,
+        view_id: usize,
+    ) -> bool {
+        let mut cx = ViewContext::new(cx, window_id, view_id);
+        View::modifiers_changed(self, event, &mut cx)
     }
 
     fn keymap_context(&self, cx: &AppContext) -> keymap::Context {
@@ -3463,7 +3597,7 @@ impl<'a, T: View> ViewContext<'a, T> {
         if self.window_id != view.window_id {
             return false;
         }
-        self.parents(view.window_id, view.view_id)
+        self.ancestors(view.window_id, view.view_id)
             .any(|parent| parent == self.view_id)
     }
 
@@ -6354,13 +6488,13 @@ mod tests {
                 "View"
             }
 
-            fn on_focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
+            fn focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
                 if cx.handle().id() == focused.id() {
                     self.events.lock().push(format!("{} focused", &self.name));
                 }
             }
 
-            fn on_focus_out(&mut self, blurred: AnyViewHandle, cx: &mut ViewContext<Self>) {
+            fn focus_out(&mut self, blurred: AnyViewHandle, cx: &mut ViewContext<Self>) {
                 if cx.handle().id() == blurred.id() {
                     self.events.lock().push(format!("{} blurred", &self.name));
                 }
diff --git a/crates/gpui/src/elements.rs b/crates/gpui/src/elements.rs
index 59269f8af68ebc2819da7a63be996663e4379982..a648df6095820054ef52ce0a600af13a39ddeac7 100644
--- a/crates/gpui/src/elements.rs
+++ b/crates/gpui/src/elements.rs
@@ -33,8 +33,8 @@ use crate::{
     },
     json,
     presenter::MeasurementContext,
-    Action, DebugContext, Event, EventContext, LayoutContext, PaintContext, RenderContext,
-    SizeConstraint, View,
+    Action, DebugContext, EventContext, LayoutContext, PaintContext, RenderContext, SizeConstraint,
+    View,
 };
 use core::panic;
 use json::ToJson;
@@ -50,7 +50,6 @@ use std::{
 trait AnyElement {
     fn layout(&mut self, constraint: SizeConstraint, cx: &mut LayoutContext) -> Vector2F;
     fn paint(&mut self, origin: Vector2F, visible_bounds: RectF, cx: &mut PaintContext);
-    fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool;
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -80,16 +79,6 @@ pub trait Element {
         cx: &mut PaintContext,
     ) -> Self::PaintState;
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        bounds: RectF,
-        visible_bounds: RectF,
-        layout: &mut Self::LayoutState,
-        paint: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool;
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -303,22 +292,6 @@ impl<T: Element> AnyElement for Lifecycle<T> {
         }
     }
 
-    fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool {
-        if let Lifecycle::PostPaint {
-            element,
-            bounds,
-            visible_bounds,
-            layout,
-            paint,
-            ..
-        } = self
-        {
-            element.dispatch_event(event, *bounds, *visible_bounds, layout, paint, cx)
-        } else {
-            panic!("invalid element lifecycle state");
-        }
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -433,10 +406,6 @@ impl ElementRc {
         self.element.borrow_mut().paint(origin, visible_bounds, cx);
     }
 
-    pub fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool {
-        self.element.borrow_mut().dispatch_event(event, cx)
-    }
-
     pub fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/align.rs b/crates/gpui/src/elements/align.rs
index 5158b7229eda70897290fff516095ac21c7f0b8c..ec1a210f75cc7f810a840dffebd0216bbe304471 100644
--- a/crates/gpui/src/elements/align.rs
+++ b/crates/gpui/src/elements/align.rs
@@ -2,8 +2,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
-    SizeConstraint,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 use json::ToJson;
 
@@ -84,18 +83,6 @@ impl Element for Align {
         );
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: std::ops::Range<usize>,
diff --git a/crates/gpui/src/elements/canvas.rs b/crates/gpui/src/elements/canvas.rs
index 6fec2dd1dc1cfafa84c971487883a60abbc52681..31c56bb9874e9e19e340219a8e967a181dafbf56 100644
--- a/crates/gpui/src/elements/canvas.rs
+++ b/crates/gpui/src/elements/canvas.rs
@@ -56,18 +56,6 @@ where
         self.0(bounds, visible_bounds, cx)
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &crate::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut crate::EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: std::ops::Range<usize>,
diff --git a/crates/gpui/src/elements/constrained_box.rs b/crates/gpui/src/elements/constrained_box.rs
index 012bbe23dd05f5b542a541310b844aafe5ca0975..2e232c6197774861fd14a453e62a8efb5772ee53 100644
--- a/crates/gpui/src/elements/constrained_box.rs
+++ b/crates/gpui/src/elements/constrained_box.rs
@@ -7,8 +7,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
-    SizeConstraint,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 
 pub struct ConstrainedBox {
@@ -157,18 +156,6 @@ impl Element for ConstrainedBox {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/container.rs b/crates/gpui/src/elements/container.rs
index dc0d0bac1bda4044a6b9a3157b6734a6115b9876..8e17fdd60f2c16b50825896fdeac0674a89e8d4f 100644
--- a/crates/gpui/src/elements/container.rs
+++ b/crates/gpui/src/elements/container.rs
@@ -11,7 +11,7 @@ use crate::{
     platform::CursorStyle,
     presenter::MeasurementContext,
     scene::{self, Border, CursorRegion, Quad},
-    Element, ElementBox, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde::Deserialize;
 use serde_json::json;
@@ -285,18 +285,6 @@ impl Element for Container {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/empty.rs b/crates/gpui/src/elements/empty.rs
index a7c2fc1d60ae62b1b2a77f00b14efabfb32c31e1..b0a0481c05caaf29741a0d36a2d37fc59329b6d4 100644
--- a/crates/gpui/src/elements/empty.rs
+++ b/crates/gpui/src/elements/empty.rs
@@ -9,7 +9,7 @@ use crate::{
     presenter::MeasurementContext,
     DebugContext,
 };
-use crate::{Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint};
+use crate::{Element, LayoutContext, PaintContext, SizeConstraint};
 
 #[derive(Default)]
 pub struct Empty {
@@ -59,18 +59,6 @@ impl Element for Empty {
     ) -> Self::PaintState {
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/gpui/src/elements/expanded.rs b/crates/gpui/src/elements/expanded.rs
index d77bbdbfb9c8e33036b6e76b444aef64833bbdbc..89e9c7c7d8997ecdb7b4ddcf0c8c65afc27a3422 100644
--- a/crates/gpui/src/elements/expanded.rs
+++ b/crates/gpui/src/elements/expanded.rs
@@ -4,8 +4,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
-    SizeConstraint,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde_json::json;
 
@@ -66,18 +65,6 @@ impl Element for Expanded {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/flex.rs b/crates/gpui/src/elements/flex.rs
index fd37b001feb7dbc5c209a8f369cc9e24caabf040..95477c75601452f7aa26400d5cc4cb880021deb6 100644
--- a/crates/gpui/src/elements/flex.rs
+++ b/crates/gpui/src/elements/flex.rs
@@ -3,8 +3,8 @@ use std::{any::Any, cell::Cell, f32::INFINITY, ops::Range, rc::Rc};
 use crate::{
     json::{self, ToJson, Value},
     presenter::MeasurementContext,
-    Axis, DebugContext, Element, ElementBox, ElementStateHandle, Event, EventContext,
-    LayoutContext, PaintContext, RenderContext, SizeConstraint, Vector2FExt, View,
+    Axis, DebugContext, Element, ElementBox, ElementStateHandle, LayoutContext, PaintContext,
+    RenderContext, SizeConstraint, Vector2FExt, View,
 };
 use pathfinder_geometry::{
     rect::RectF,
@@ -259,7 +259,7 @@ impl Element for Flex {
                             if remaining_space < 0. {
                                 let mut delta = match axis {
                                     Axis::Horizontal => {
-                                        if e.delta.x() != 0. {
+                                        if e.delta.x().abs() >= e.delta.y().abs() {
                                             e.delta.x()
                                         } else {
                                             e.delta.y()
@@ -318,23 +318,6 @@ impl Element for Flex {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        let mut handled = false;
-        for child in &mut self.children {
-            handled = child.dispatch_event(event, cx) || handled;
-        }
-
-        handled
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -420,18 +403,6 @@ impl Element for FlexItem {
         self.child.paint(bounds.origin(), visible_bounds, cx)
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/hook.rs b/crates/gpui/src/elements/hook.rs
index c620847372bed4963d49412809b4733e9515108e..b77fef4fae3d08abdfa69da2f345ef1a790d84fa 100644
--- a/crates/gpui/src/elements/hook.rs
+++ b/crates/gpui/src/elements/hook.rs
@@ -4,8 +4,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
-    SizeConstraint,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 
 pub struct Hook {
@@ -56,18 +55,6 @@ impl Element for Hook {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/image.rs b/crates/gpui/src/elements/image.rs
index 7e231e5e293f8660b5dc60b9e8a6ebcf32264429..37cb01ace8a6c43e0add3d366d888f06b4b0225e 100644
--- a/crates/gpui/src/elements/image.rs
+++ b/crates/gpui/src/elements/image.rs
@@ -6,8 +6,7 @@ use crate::{
     },
     json::{json, ToJson},
     presenter::MeasurementContext,
-    scene, Border, DebugContext, Element, Event, EventContext, ImageData, LayoutContext,
-    PaintContext, SizeConstraint,
+    scene, Border, DebugContext, Element, ImageData, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde::Deserialize;
 use std::{ops::Range, sync::Arc};
@@ -81,18 +80,6 @@ impl Element for Image {
         });
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/gpui/src/elements/keystroke_label.rs b/crates/gpui/src/elements/keystroke_label.rs
index 9b21a1b8a86e942da7d31dccf52b24d2a71d2bd2..ca317d9e114cdae9987d47e6ab073b08c90dd689 100644
--- a/crates/gpui/src/elements/keystroke_label.rs
+++ b/crates/gpui/src/elements/keystroke_label.rs
@@ -2,7 +2,7 @@ use crate::{
     elements::*,
     fonts::TextStyle,
     geometry::{rect::RectF, vector::Vector2F},
-    Action, ElementBox, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    Action, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde_json::json;
 
@@ -64,18 +64,6 @@ impl Element for KeystrokeLabel {
         element.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        element: &mut ElementBox,
-        _: &mut (),
-        cx: &mut EventContext,
-    ) -> bool {
-        element.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/gpui/src/elements/label.rs b/crates/gpui/src/elements/label.rs
index 18654808682bb181bd6c4557114782a649d9dda1..605a3cb7670444777f0482b59c3a066b7392bb7d 100644
--- a/crates/gpui/src/elements/label.rs
+++ b/crates/gpui/src/elements/label.rs
@@ -9,7 +9,7 @@ use crate::{
     json::{ToJson, Value},
     presenter::MeasurementContext,
     text_layout::{Line, RunStyle},
-    DebugContext, Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    DebugContext, Element, LayoutContext, PaintContext, SizeConstraint,
 };
 use serde::Deserialize;
 use serde_json::json;
@@ -165,18 +165,6 @@ impl Element for Label {
         line.paint(bounds.origin(), visible_bounds, bounds.size().y(), cx)
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs
index d0f87590fc53065a4d27849e947e24def56f28d7..a1b4ef0c796ad3a061916b2b2a871fe26bfe4b1a 100644
--- a/crates/gpui/src/elements/list.rs
+++ b/crates/gpui/src/elements/list.rs
@@ -5,7 +5,7 @@ use crate::{
     },
     json::json,
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, ElementRc, Event, EventContext, LayoutContext, MouseRegion,
+    DebugContext, Element, ElementBox, ElementRc, EventContext, LayoutContext, MouseRegion,
     PaintContext, RenderContext, SizeConstraint, View, ViewContext,
 };
 use std::{cell::RefCell, collections::VecDeque, ops::Range, rc::Rc};
@@ -13,7 +13,6 @@ use sum_tree::{Bias, SumTree};
 
 pub struct List {
     state: ListState,
-    invalidated_elements: Vec<ElementRc>,
 }
 
 #[derive(Clone)]
@@ -82,10 +81,7 @@ struct Height(f32);
 
 impl List {
     pub fn new(state: ListState) -> Self {
-        Self {
-            state,
-            invalidated_elements: Default::default(),
-        }
+        Self { state }
     }
 }
 
@@ -289,50 +285,6 @@ impl Element for List {
         cx.scene.pop_layer();
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        bounds: RectF,
-        _: RectF,
-        scroll_top: &mut ListOffset,
-        _: &mut (),
-        cx: &mut EventContext,
-    ) -> bool {
-        let mut handled = false;
-
-        let mut state = self.state.0.borrow_mut();
-        let mut item_origin = bounds.origin() - vec2f(0., scroll_top.offset_in_item);
-        let mut cursor = state.items.cursor::<Count>();
-        let mut new_items = cursor.slice(&Count(scroll_top.item_ix), Bias::Right, &());
-        while let Some(item) = cursor.item() {
-            if item_origin.y() > bounds.max_y() {
-                break;
-            }
-
-            if let ListItem::Rendered(element) = item {
-                let prev_notify_count = cx.notify_count();
-                let mut element = element.clone();
-                handled = element.dispatch_event(event, cx) || handled;
-                item_origin.set_y(item_origin.y() + element.size().y());
-                if cx.notify_count() > prev_notify_count {
-                    new_items.push(ListItem::Unrendered, &());
-                    self.invalidated_elements.push(element);
-                } else {
-                    new_items.push(item.clone(), &());
-                }
-                cursor.next(&());
-            } else {
-                unreachable!();
-            }
-        }
-
-        new_items.push_tree(cursor.suffix(&()), &());
-        drop(cursor);
-        state.items = new_items;
-
-        handled
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
@@ -964,18 +916,6 @@ mod tests {
             todo!()
         }
 
-        fn dispatch_event(
-            &mut self,
-            _: &Event,
-            _: RectF,
-            _: RectF,
-            _: &mut (),
-            _: &mut (),
-            _: &mut EventContext,
-        ) -> bool {
-            todo!()
-        }
-
         fn rect_for_text_range(
             &self,
             _: Range<usize>,
diff --git a/crates/gpui/src/elements/mouse_event_handler.rs b/crates/gpui/src/elements/mouse_event_handler.rs
index ab5aeb562bbf29bb13862d1f2bc52f2a05b8a8f6..c8ba330e70324fb8c11df4469810f19b38834d2b 100644
--- a/crates/gpui/src/elements/mouse_event_handler.rs
+++ b/crates/gpui/src/elements/mouse_event_handler.rs
@@ -6,11 +6,10 @@ use crate::{
     },
     platform::CursorStyle,
     scene::{
-        ClickRegionEvent, CursorRegion, DownOutRegionEvent, DownRegionEvent, DragRegionEvent,
-        HandlerSet, HoverRegionEvent, MoveRegionEvent, ScrollWheelRegionEvent, UpOutRegionEvent,
-        UpRegionEvent,
+        CursorRegion, HandlerSet, MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseHover,
+        MouseMove, MouseScrollWheel, MouseUp, MouseUpOut,
     },
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, MeasurementContext,
+    DebugContext, Element, ElementBox, EventContext, LayoutContext, MeasurementContext,
     MouseButton, MouseRegion, MouseState, PaintContext, RenderContext, SizeConstraint, View,
 };
 use serde_json::json;
@@ -61,10 +60,7 @@ impl<Tag> MouseEventHandler<Tag> {
         self
     }
 
-    pub fn on_move(
-        mut self,
-        handler: impl Fn(MoveRegionEvent, &mut EventContext) + 'static,
-    ) -> Self {
+    pub fn on_move(mut self, handler: impl Fn(MouseMove, &mut EventContext) + 'static) -> Self {
         self.handlers = self.handlers.on_move(handler);
         self
     }
@@ -72,7 +68,7 @@ impl<Tag> MouseEventHandler<Tag> {
     pub fn on_down(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DownRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDown, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_down(button, handler);
         self
@@ -81,7 +77,7 @@ impl<Tag> MouseEventHandler<Tag> {
     pub fn on_up(
         mut self,
         button: MouseButton,
-        handler: impl Fn(UpRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseUp, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_up(button, handler);
         self
@@ -90,7 +86,7 @@ impl<Tag> MouseEventHandler<Tag> {
     pub fn on_click(
         mut self,
         button: MouseButton,
-        handler: impl Fn(ClickRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseClick, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_click(button, handler);
         self
@@ -99,7 +95,7 @@ impl<Tag> MouseEventHandler<Tag> {
     pub fn on_down_out(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DownOutRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDownOut, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_down_out(button, handler);
         self
@@ -108,7 +104,7 @@ impl<Tag> MouseEventHandler<Tag> {
     pub fn on_up_out(
         mut self,
         button: MouseButton,
-        handler: impl Fn(UpOutRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseUpOut, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_up_out(button, handler);
         self
@@ -117,23 +113,20 @@ impl<Tag> MouseEventHandler<Tag> {
     pub fn on_drag(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DragRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDrag, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_drag(button, handler);
         self
     }
 
-    pub fn on_hover(
-        mut self,
-        handler: impl Fn(HoverRegionEvent, &mut EventContext) + 'static,
-    ) -> Self {
+    pub fn on_hover(mut self, handler: impl Fn(MouseHover, &mut EventContext) + 'static) -> Self {
         self.handlers = self.handlers.on_hover(handler);
         self
     }
 
     pub fn on_scroll(
         mut self,
-        handler: impl Fn(ScrollWheelRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseScrollWheel, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_scroll(handler);
         self
@@ -201,18 +194,6 @@ impl<Tag> Element for MouseEventHandler<Tag> {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/overlay.rs b/crates/gpui/src/elements/overlay.rs
index 07442d1140c2be8f992641bf447e0ede2aa157d3..253c88f703a36abc30162053fa42b3c586738b6d 100644
--- a/crates/gpui/src/elements/overlay.rs
+++ b/crates/gpui/src/elements/overlay.rs
@@ -4,8 +4,8 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::ToJson,
     presenter::MeasurementContext,
-    Axis, DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, MouseRegion,
-    PaintContext, SizeConstraint,
+    Axis, DebugContext, Element, ElementBox, LayoutContext, MouseRegion, PaintContext,
+    SizeConstraint,
 };
 use serde_json::json;
 
@@ -225,18 +225,6 @@ impl Element for Overlay {
         cx.scene.pop_stacking_context();
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/resizable.rs b/crates/gpui/src/elements/resizable.rs
index 802452790300cf94f41b39f4e103382c25a3ea86..fb5bfa4a11643dbb351a9f7138b7fdb683f43ddb 100644
--- a/crates/gpui/src/elements/resizable.rs
+++ b/crates/gpui/src/elements/resizable.rs
@@ -4,7 +4,7 @@ use pathfinder_geometry::vector::{vec2f, Vector2F};
 use serde_json::json;
 
 use crate::{
-    geometry::rect::RectF, scene::DragRegionEvent, Axis, CursorStyle, Element, ElementBox,
+    geometry::rect::RectF, scene::MouseDrag, Axis, CursorStyle, Element, ElementBox,
     ElementStateHandle, MouseButton, MouseRegion, RenderContext, View,
 };
 
@@ -42,7 +42,7 @@ impl Side {
         }
     }
 
-    fn compute_delta(&self, e: DragRegionEvent) -> f32 {
+    fn compute_delta(&self, e: MouseDrag) -> f32 {
         if self.before_content() {
             self.relevant_component(e.prev_mouse_position) - self.relevant_component(e.position)
         } else {
@@ -187,18 +187,6 @@ impl Element for Resizable {
         self.child.paint(bounds.origin(), visible_bounds, cx);
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &crate::Event,
-        _bounds: pathfinder_geometry::rect::RectF,
-        _visible_bounds: pathfinder_geometry::rect::RectF,
-        _layout: &mut Self::LayoutState,
-        _paint: &mut Self::PaintState,
-        cx: &mut crate::EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: std::ops::Range<usize>,
diff --git a/crates/gpui/src/elements/stack.rs b/crates/gpui/src/elements/stack.rs
index 5de53ff9e7f40712c5f36550434c6cce2058ad1a..f08ce04649a4219eba27040c7e9e43dbfebde2f8 100644
--- a/crates/gpui/src/elements/stack.rs
+++ b/crates/gpui/src/elements/stack.rs
@@ -4,8 +4,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::{self, json, ToJson},
     presenter::MeasurementContext,
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
-    SizeConstraint,
+    DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
 };
 
 #[derive(Default)]
@@ -49,23 +48,6 @@ impl Element for Stack {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        for child in self.children.iter_mut().rev() {
-            if child.dispatch_event(event, cx) {
-                return true;
-            }
-        }
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/elements/svg.rs b/crates/gpui/src/elements/svg.rs
index 544abb3314a526b72f674e01a213f5f4b75af334..5bd2759f7a47ecbda0bf5f2df23e5ebf87254c49 100644
--- a/crates/gpui/src/elements/svg.rs
+++ b/crates/gpui/src/elements/svg.rs
@@ -9,7 +9,7 @@ use crate::{
         vector::{vec2f, Vector2F},
     },
     presenter::MeasurementContext,
-    scene, DebugContext, Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+    scene, DebugContext, Element, LayoutContext, PaintContext, SizeConstraint,
 };
 
 pub struct Svg {
@@ -73,18 +73,6 @@ impl Element for Svg {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/gpui/src/elements/text.rs b/crates/gpui/src/elements/text.rs
index 45dc2dbae3343051e8b417fc6a12393757e125f7..073e343b9c3ddeb9a0b6ed7744f33fa5c02b15c3 100644
--- a/crates/gpui/src/elements/text.rs
+++ b/crates/gpui/src/elements/text.rs
@@ -8,8 +8,7 @@ use crate::{
     json::{ToJson, Value},
     presenter::MeasurementContext,
     text_layout::{Line, RunStyle, ShapedBoundary},
-    DebugContext, Element, Event, EventContext, FontCache, LayoutContext, PaintContext,
-    SizeConstraint, TextLayoutCache,
+    DebugContext, Element, FontCache, LayoutContext, PaintContext, SizeConstraint, TextLayoutCache,
 };
 use log::warn;
 use serde_json::json;
@@ -178,18 +177,6 @@ impl Element for Text {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        _: &Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        _: &mut EventContext,
-    ) -> bool {
-        false
-    }
-
     fn rect_for_text_range(
         &self,
         _: Range<usize>,
diff --git a/crates/gpui/src/elements/tooltip.rs b/crates/gpui/src/elements/tooltip.rs
index c86230a5e158f30c5cef1716b67113a664b3a4df..f81b4af70115d71eef9c77f3c3a99ab198777164 100644
--- a/crates/gpui/src/elements/tooltip.rs
+++ b/crates/gpui/src/elements/tooltip.rs
@@ -186,18 +186,6 @@ impl Element for Tooltip {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &crate::Event,
-        _: RectF,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut crate::EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
     fn rect_for_text_range(
         &self,
         range: Range<usize>,
diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs
index c9cdbc1b2c90f76f8ac9ba3c6014d2d68e3e06f6..ca3601491ab2a507bef84fdcbcdd53bd72d209b1 100644
--- a/crates/gpui/src/elements/uniform_list.rs
+++ b/crates/gpui/src/elements/uniform_list.rs
@@ -1,4 +1,4 @@
-use super::{Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint};
+use super::{Element, EventContext, LayoutContext, PaintContext, SizeConstraint};
 use crate::{
     geometry::{
         rect::RectF,
@@ -6,7 +6,7 @@ use crate::{
     },
     json::{self, json},
     presenter::MeasurementContext,
-    scene::ScrollWheelRegionEvent,
+    scene::MouseScrollWheel,
     ElementBox, MouseRegion, RenderContext, ScrollWheelEvent, View,
 };
 use json::ToJson;
@@ -292,7 +292,7 @@ impl Element for UniformList {
             MouseRegion::new::<Self>(self.view_id, 0, visible_bounds).on_scroll({
                 let scroll_max = layout.scroll_max;
                 let state = self.state.clone();
-                move |ScrollWheelRegionEvent {
+                move |MouseScrollWheel {
                           platform_event:
                               ScrollWheelEvent {
                                   position,
@@ -324,23 +324,6 @@ impl Element for UniformList {
         cx.scene.pop_layer();
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        layout: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        let mut handled = false;
-        for item in &mut layout.items {
-            handled = item.dispatch_event(event, cx) || handled;
-        }
-
-        handled
-    }
-
     fn rect_for_text_range(
         &self,
         range: Range<usize>,
diff --git a/crates/gpui/src/platform/event.rs b/crates/gpui/src/platform/event.rs
index 48043ac9186b0701ab7d08fe86de30941ae56dda..7e4b95c9a1385fa3d3e566a8dd5bb8779775d1cd 100644
--- a/crates/gpui/src/platform/event.rs
+++ b/crates/gpui/src/platform/event.rs
@@ -11,7 +11,7 @@ pub struct KeyUpEvent {
     pub keystroke: Keystroke,
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default)]
 pub struct ModifiersChangedEvent {
     pub ctrl: bool,
     pub alt: bool,
diff --git a/crates/gpui/src/presenter.rs b/crates/gpui/src/presenter.rs
index d082ebd095a503e8e312530a94e934d14c0d003a..74c2dddd662c9f733ecc2a456fadc473e52de9c9 100644
--- a/crates/gpui/src/presenter.rs
+++ b/crates/gpui/src/presenter.rs
@@ -7,9 +7,8 @@ use crate::{
     keymap::Keystroke,
     platform::{CursorStyle, Event},
     scene::{
-        ClickRegionEvent, CursorRegion, DownOutRegionEvent, DownRegionEvent, DragRegionEvent,
-        HoverRegionEvent, MouseRegionEvent, MoveRegionEvent, ScrollWheelRegionEvent,
-        UpOutRegionEvent, UpRegionEvent,
+        CursorRegion, MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseEvent, MouseHover,
+        MouseMove, MouseScrollWheel, MouseUp, MouseUpOut,
     },
     text_layout::TextLayoutCache,
     Action, AnyModelHandle, AnyViewHandle, AnyWeakModelHandle, AnyWeakViewHandle, Appearance,
@@ -229,293 +228,283 @@ impl Presenter {
         event_reused: bool,
         cx: &mut MutableAppContext,
     ) -> bool {
-        if let Some(root_view_id) = cx.root_view_id(self.window_id) {
-            let mut events_to_send = Vec::new();
-            let mut notified_views: HashSet<usize> = Default::default();
-
-            // 1. Allocate the correct set of GPUI events generated from the platform events
-            //  -> These are usually small: [Mouse Down] or [Mouse up, Click] or [Mouse Moved, Mouse Dragged?]
-            //  -> Also moves around mouse related state
-            match &event {
-                Event::MouseDown(e) => {
-                    // Click events are weird because they can be fired after a drag event.
-                    // MDN says that browsers handle this by starting from 'the most
-                    // specific ancestor element that contained both [positions]'
-                    // So we need to store the overlapping regions on mouse down.
-
-                    // If there is already clicked_button stored, don't replace it.
-                    if self.clicked_button.is_none() {
-                        self.clicked_region_ids = self
-                            .mouse_regions
-                            .iter()
-                            .filter_map(|(region, _)| {
-                                if region.bounds.contains_point(e.position) {
-                                    Some(region.id())
-                                } else {
-                                    None
-                                }
-                            })
-                            .collect();
-
-                        self.clicked_button = Some(e.button);
-                    }
+        let mut mouse_events = SmallVec::<[_; 2]>::new();
+        let mut notified_views: HashSet<usize> = Default::default();
+
+        // 1. Handle platform event. Keyboard events get dispatched immediately, while mouse events
+        //    get mapped into the mouse-specific MouseEvent type.
+        //  -> These are usually small: [Mouse Down] or [Mouse up, Click] or [Mouse Moved, Mouse Dragged?]
+        //  -> Also updates mouse-related state
+        match &event {
+            Event::KeyDown(e) => return cx.dispatch_key_down(self.window_id, e),
+            Event::KeyUp(e) => return cx.dispatch_key_up(self.window_id, e),
+            Event::ModifiersChanged(e) => return cx.dispatch_modifiers_changed(self.window_id, e),
+            Event::MouseDown(e) => {
+                // Click events are weird because they can be fired after a drag event.
+                // MDN says that browsers handle this by starting from 'the most
+                // specific ancestor element that contained both [positions]'
+                // So we need to store the overlapping regions on mouse down.
+
+                // If there is already clicked_button stored, don't replace it.
+                if self.clicked_button.is_none() {
+                    self.clicked_region_ids = self
+                        .mouse_regions
+                        .iter()
+                        .filter_map(|(region, _)| {
+                            if region.bounds.contains_point(e.position) {
+                                Some(region.id())
+                            } else {
+                                None
+                            }
+                        })
+                        .collect();
 
-                    events_to_send.push(MouseRegionEvent::Down(DownRegionEvent {
-                        region: Default::default(),
-                        platform_event: e.clone(),
-                    }));
-                    events_to_send.push(MouseRegionEvent::DownOut(DownOutRegionEvent {
-                        region: Default::default(),
-                        platform_event: e.clone(),
-                    }));
+                    self.clicked_button = Some(e.button);
                 }
-                Event::MouseUp(e) => {
-                    // NOTE: The order of event pushes is important! MouseUp events MUST be fired
-                    // before click events, and so the UpRegionEvent events need to be pushed before
-                    // ClickRegionEvents
-                    events_to_send.push(MouseRegionEvent::Up(UpRegionEvent {
-                        region: Default::default(),
-                        platform_event: e.clone(),
-                    }));
-                    events_to_send.push(MouseRegionEvent::UpOut(UpOutRegionEvent {
-                        region: Default::default(),
-                        platform_event: e.clone(),
-                    }));
-                    events_to_send.push(MouseRegionEvent::Click(ClickRegionEvent {
-                        region: Default::default(),
-                        platform_event: e.clone(),
-                    }));
-                }
-                Event::MouseMoved(
-                    e @ MouseMovedEvent {
-                        position,
-                        pressed_button,
-                        ..
-                    },
-                ) => {
-                    let mut style_to_assign = CursorStyle::Arrow;
-                    for region in self.cursor_regions.iter().rev() {
-                        if region.bounds.contains_point(*position) {
-                            style_to_assign = region.style;
-                            break;
-                        }
+
+                mouse_events.push(MouseEvent::Down(MouseDown {
+                    region: Default::default(),
+                    platform_event: e.clone(),
+                }));
+                mouse_events.push(MouseEvent::DownOut(MouseDownOut {
+                    region: Default::default(),
+                    platform_event: e.clone(),
+                }));
+            }
+            Event::MouseUp(e) => {
+                // NOTE: The order of event pushes is important! MouseUp events MUST be fired
+                // before click events, and so the MouseUp events need to be pushed before
+                // MouseClick events.
+                mouse_events.push(MouseEvent::Up(MouseUp {
+                    region: Default::default(),
+                    platform_event: e.clone(),
+                }));
+                mouse_events.push(MouseEvent::UpOut(MouseUpOut {
+                    region: Default::default(),
+                    platform_event: e.clone(),
+                }));
+                mouse_events.push(MouseEvent::Click(MouseClick {
+                    region: Default::default(),
+                    platform_event: e.clone(),
+                }));
+            }
+            Event::MouseMoved(
+                e @ MouseMovedEvent {
+                    position,
+                    pressed_button,
+                    ..
+                },
+            ) => {
+                let mut style_to_assign = CursorStyle::Arrow;
+                for region in self.cursor_regions.iter().rev() {
+                    if region.bounds.contains_point(*position) {
+                        style_to_assign = region.style;
+                        break;
                     }
-                    cx.platform().set_cursor_style(style_to_assign);
-
-                    if !event_reused {
-                        if pressed_button.is_some() {
-                            events_to_send.push(MouseRegionEvent::Drag(DragRegionEvent {
-                                region: Default::default(),
-                                prev_mouse_position: self.mouse_position,
-                                platform_event: e.clone(),
-                            }));
-                        } else if let Some(clicked_button) = self.clicked_button {
-                            // Mouse up event happened outside the current window. Simulate mouse up button event
-                            let button_event = e.to_button_event(clicked_button);
-                            events_to_send.push(MouseRegionEvent::Up(UpRegionEvent {
-                                region: Default::default(),
-                                platform_event: button_event.clone(),
-                            }));
-                            events_to_send.push(MouseRegionEvent::UpOut(UpOutRegionEvent {
-                                region: Default::default(),
-                                platform_event: button_event.clone(),
-                            }));
-                            events_to_send.push(MouseRegionEvent::Click(ClickRegionEvent {
-                                region: Default::default(),
-                                platform_event: button_event.clone(),
-                            }));
-                        }
+                }
+                cx.platform().set_cursor_style(style_to_assign);
 
-                        events_to_send.push(MouseRegionEvent::Move(MoveRegionEvent {
+                if !event_reused {
+                    if pressed_button.is_some() {
+                        mouse_events.push(MouseEvent::Drag(MouseDrag {
                             region: Default::default(),
+                            prev_mouse_position: self.mouse_position,
                             platform_event: e.clone(),
                         }));
+                    } else if let Some(clicked_button) = self.clicked_button {
+                        // Mouse up event happened outside the current window. Simulate mouse up button event
+                        let button_event = e.to_button_event(clicked_button);
+                        mouse_events.push(MouseEvent::Up(MouseUp {
+                            region: Default::default(),
+                            platform_event: button_event.clone(),
+                        }));
+                        mouse_events.push(MouseEvent::UpOut(MouseUpOut {
+                            region: Default::default(),
+                            platform_event: button_event.clone(),
+                        }));
+                        mouse_events.push(MouseEvent::Click(MouseClick {
+                            region: Default::default(),
+                            platform_event: button_event.clone(),
+                        }));
                     }
 
-                    events_to_send.push(MouseRegionEvent::Hover(HoverRegionEvent {
+                    mouse_events.push(MouseEvent::Move(MouseMove {
                         region: Default::default(),
                         platform_event: e.clone(),
-                        started: false,
                     }));
-
-                    self.last_mouse_moved_event = Some(event.clone());
-                }
-                Event::ScrollWheel(e) => {
-                    events_to_send.push(MouseRegionEvent::ScrollWheel(ScrollWheelRegionEvent {
-                        region: Default::default(),
-                        platform_event: e.clone(),
-                    }))
                 }
 
-                _ => {}
-            }
+                mouse_events.push(MouseEvent::Hover(MouseHover {
+                    region: Default::default(),
+                    platform_event: e.clone(),
+                    started: false,
+                }));
 
-            if let Some(position) = event.position() {
-                self.mouse_position = position;
+                self.last_mouse_moved_event = Some(event.clone());
             }
+            Event::ScrollWheel(e) => mouse_events.push(MouseEvent::ScrollWheel(MouseScrollWheel {
+                region: Default::default(),
+                platform_event: e.clone(),
+            })),
+        }
 
-            let mut any_event_handled = false;
-            // 2. Process the raw mouse events into region events
-            for mut region_event in events_to_send {
-                let mut valid_regions = Vec::new();
-
-                // GPUI elements are arranged by depth but sibling elements can register overlapping
-                // mouse regions. As such, hover events are only fired on overlapping elements which
-                // are at the same depth as the topmost element which overlaps with the mouse.
-
-                match &region_event {
-                    MouseRegionEvent::Hover(_) => {
-                        let mut top_most_depth = None;
-                        let mouse_position = self.mouse_position.clone();
-                        for (region, depth) in self.mouse_regions.iter().rev() {
-                            // Allow mouse regions to appear transparent to hovers
-                            if !region.hoverable {
-                                continue;
-                            }
+        if let Some(position) = event.position() {
+            self.mouse_position = position;
+        }
 
-                            let contains_mouse = region.bounds.contains_point(mouse_position);
+        // 2. Dispatch mouse events on regions
+        let mut any_event_handled = false;
+        for mut mouse_event in mouse_events {
+            let mut valid_regions = Vec::new();
+
+            // GPUI elements are arranged by depth but sibling elements can register overlapping
+            // mouse regions. As such, hover events are only fired on overlapping elements which
+            // are at the same depth as the topmost element which overlaps with the mouse.
+            match &mouse_event {
+                MouseEvent::Hover(_) => {
+                    let mut top_most_depth = None;
+                    let mouse_position = self.mouse_position.clone();
+                    for (region, depth) in self.mouse_regions.iter().rev() {
+                        // Allow mouse regions to appear transparent to hovers
+                        if !region.hoverable {
+                            continue;
+                        }
 
-                            if contains_mouse && top_most_depth.is_none() {
-                                top_most_depth = Some(depth);
-                            }
+                        let contains_mouse = region.bounds.contains_point(mouse_position);
 
-                            // This unwrap relies on short circuiting boolean expressions
-                            // The right side of the && is only executed when contains_mouse
-                            // is true, and we know above that when contains_mouse is true
-                            // top_most_depth is set
-                            if contains_mouse && depth == top_most_depth.unwrap() {
-                                //Ensure that hover entrance events aren't sent twice
-                                if self.hovered_region_ids.insert(region.id()) {
-                                    valid_regions.push(region.clone());
-                                    if region.notify_on_hover {
-                                        notified_views.insert(region.id().view_id());
-                                    }
-                                }
-                            } else {
-                                // Ensure that hover exit events aren't sent twice
-                                if self.hovered_region_ids.remove(&region.id()) {
-                                    valid_regions.push(region.clone());
-                                    if region.notify_on_hover {
-                                        notified_views.insert(region.id().view_id());
-                                    }
-                                }
-                            }
+                        if contains_mouse && top_most_depth.is_none() {
+                            top_most_depth = Some(depth);
                         }
-                    }
-                    MouseRegionEvent::Down(_) | MouseRegionEvent::Up(_) => {
-                        for (region, _) in self.mouse_regions.iter().rev() {
-                            if region.bounds.contains_point(self.mouse_position) {
-                                if region.notify_on_click {
+
+                        // This unwrap relies on short circuiting boolean expressions
+                        // The right side of the && is only executed when contains_mouse
+                        // is true, and we know above that when contains_mouse is true
+                        // top_most_depth is set
+                        if contains_mouse && depth == top_most_depth.unwrap() {
+                            //Ensure that hover entrance events aren't sent twice
+                            if self.hovered_region_ids.insert(region.id()) {
+                                valid_regions.push(region.clone());
+                                if region.notify_on_hover {
                                     notified_views.insert(region.id().view_id());
                                 }
-                                valid_regions.push(region.clone());
                             }
-                        }
-                    }
-                    MouseRegionEvent::Click(e) => {
-                        // Only raise click events if the released button is the same as the one stored
-                        if self
-                            .clicked_button
-                            .map(|clicked_button| clicked_button == e.button)
-                            .unwrap_or(false)
-                        {
-                            // Clear clicked regions and clicked button
-                            let clicked_region_ids =
-                                std::mem::replace(&mut self.clicked_region_ids, Default::default());
-                            self.clicked_button = None;
-
-                            // Find regions which still overlap with the mouse since the last MouseDown happened
-                            for (mouse_region, _) in self.mouse_regions.iter().rev() {
-                                if clicked_region_ids.contains(&mouse_region.id()) {
-                                    if mouse_region.bounds.contains_point(self.mouse_position) {
-                                        valid_regions.push(mouse_region.clone());
-                                    }
+                        } else {
+                            // Ensure that hover exit events aren't sent twice
+                            if self.hovered_region_ids.remove(&region.id()) {
+                                valid_regions.push(region.clone());
+                                if region.notify_on_hover {
+                                    notified_views.insert(region.id().view_id());
                                 }
                             }
                         }
                     }
-                    MouseRegionEvent::Drag(_) => {
-                        for (mouse_region, _) in self.mouse_regions.iter().rev() {
-                            if self.clicked_region_ids.contains(&mouse_region.id()) {
-                                valid_regions.push(mouse_region.clone());
+                }
+                MouseEvent::Down(_) | MouseEvent::Up(_) => {
+                    for (region, _) in self.mouse_regions.iter().rev() {
+                        if region.bounds.contains_point(self.mouse_position) {
+                            if region.notify_on_click {
+                                notified_views.insert(region.id().view_id());
                             }
+                            valid_regions.push(region.clone());
                         }
                     }
-
-                    MouseRegionEvent::UpOut(_) | MouseRegionEvent::DownOut(_) => {
+                }
+                MouseEvent::Click(e) => {
+                    // Only raise click events if the released button is the same as the one stored
+                    if self
+                        .clicked_button
+                        .map(|clicked_button| clicked_button == e.button)
+                        .unwrap_or(false)
+                    {
+                        // Clear clicked regions and clicked button
+                        let clicked_region_ids =
+                            std::mem::replace(&mut self.clicked_region_ids, Default::default());
+                        self.clicked_button = None;
+
+                        // Find regions which still overlap with the mouse since the last MouseDown happened
                         for (mouse_region, _) in self.mouse_regions.iter().rev() {
-                            // NOT contains
-                            if !mouse_region.bounds.contains_point(self.mouse_position) {
-                                valid_regions.push(mouse_region.clone());
+                            if clicked_region_ids.contains(&mouse_region.id()) {
+                                if mouse_region.bounds.contains_point(self.mouse_position) {
+                                    valid_regions.push(mouse_region.clone());
+                                }
                             }
                         }
                     }
-                    _ => {
-                        for (mouse_region, _) in self.mouse_regions.iter().rev() {
-                            // Contains
-                            if mouse_region.bounds.contains_point(self.mouse_position) {
-                                valid_regions.push(mouse_region.clone());
-                            }
+                }
+                MouseEvent::Drag(_) => {
+                    for (mouse_region, _) in self.mouse_regions.iter().rev() {
+                        if self.clicked_region_ids.contains(&mouse_region.id()) {
+                            valid_regions.push(mouse_region.clone());
                         }
                     }
                 }
 
-                //3. Fire region events
-                let hovered_region_ids = self.hovered_region_ids.clone();
-                for valid_region in valid_regions.into_iter() {
-                    let mut event_cx = self.build_event_context(&mut notified_views, cx);
-
-                    region_event.set_region(valid_region.bounds);
-                    if let MouseRegionEvent::Hover(e) = &mut region_event {
-                        e.started = hovered_region_ids.contains(&valid_region.id())
+                MouseEvent::UpOut(_) | MouseEvent::DownOut(_) => {
+                    for (mouse_region, _) in self.mouse_regions.iter().rev() {
+                        // NOT contains
+                        if !mouse_region.bounds.contains_point(self.mouse_position) {
+                            valid_regions.push(mouse_region.clone());
+                        }
                     }
-                    // Handle Down events if the MouseRegion has a Click or Drag handler. This makes the api more intuitive as you would
-                    // not expect a MouseRegion to be transparent to Down events if it also has a Click handler.
-                    // This behavior can be overridden by adding a Down handler that calls cx.propogate_event
-                    if let MouseRegionEvent::Down(e) = &region_event {
-                        if valid_region
-                            .handlers
-                            .contains_handler(MouseRegionEvent::click_disc(), Some(e.button))
-                            || valid_region
-                                .handlers
-                                .contains_handler(MouseRegionEvent::drag_disc(), Some(e.button))
-                        {
-                            event_cx.handled = true;
+                }
+                _ => {
+                    for (mouse_region, _) in self.mouse_regions.iter().rev() {
+                        // Contains
+                        if mouse_region.bounds.contains_point(self.mouse_position) {
+                            valid_regions.push(mouse_region.clone());
                         }
                     }
+                }
+            }
 
-                    if let Some(callback) = valid_region.handlers.get(&region_event.handler_key()) {
-                        event_cx.handled = true;
-                        event_cx.with_current_view(valid_region.id().view_id(), {
-                            let region_event = region_event.clone();
-                            |cx| {
-                                callback(region_event, cx);
-                            }
-                        });
-                    }
+            //3. Fire region events
+            let hovered_region_ids = self.hovered_region_ids.clone();
+            for valid_region in valid_regions.into_iter() {
+                let mut event_cx = self.build_event_context(&mut notified_views, cx);
 
-                    any_event_handled = any_event_handled || event_cx.handled;
-                    // For bubbling events, if the event was handled, don't continue dispatching
-                    // This only makes sense for local events.
-                    if event_cx.handled && region_event.is_capturable() {
-                        break;
+                mouse_event.set_region(valid_region.bounds);
+                if let MouseEvent::Hover(e) = &mut mouse_event {
+                    e.started = hovered_region_ids.contains(&valid_region.id())
+                }
+                // Handle Down events if the MouseRegion has a Click or Drag handler. This makes the api more intuitive as you would
+                // not expect a MouseRegion to be transparent to Down events if it also has a Click handler.
+                // This behavior can be overridden by adding a Down handler that calls cx.propogate_event
+                if let MouseEvent::Down(e) = &mouse_event {
+                    if valid_region
+                        .handlers
+                        .contains_handler(MouseEvent::click_disc(), Some(e.button))
+                        || valid_region
+                            .handlers
+                            .contains_handler(MouseEvent::drag_disc(), Some(e.button))
+                    {
+                        event_cx.handled = true;
                     }
                 }
-            }
 
-            if !any_event_handled && !event_reused {
-                let mut event_cx = self.build_event_context(&mut notified_views, cx);
-                any_event_handled = event_cx.dispatch_event(root_view_id, &event);
-            }
+                if let Some(callback) = valid_region.handlers.get(&mouse_event.handler_key()) {
+                    event_cx.handled = true;
+                    event_cx.with_current_view(valid_region.id().view_id(), {
+                        let region_event = mouse_event.clone();
+                        |cx| {
+                            callback(region_event, cx);
+                        }
+                    });
+                }
 
-            for view_id in notified_views {
-                cx.notify_view(self.window_id, view_id);
+                any_event_handled = any_event_handled || event_cx.handled;
+                // For bubbling events, if the event was handled, don't continue dispatching
+                // This only makes sense for local events.
+                if event_cx.handled && mouse_event.is_capturable() {
+                    break;
+                }
             }
+        }
 
-            any_event_handled
-        } else {
-            false
+        for view_id in notified_views {
+            cx.notify_view(self.window_id, view_id);
         }
+
+        any_event_handled
     }
 
     pub fn build_event_context<'a>(
@@ -524,7 +513,6 @@ impl Presenter {
         cx: &'a mut MutableAppContext,
     ) -> EventContext<'a> {
         EventContext {
-            rendered_views: &mut self.rendered_views,
             font_cache: &self.font_cache,
             text_layout_cache: &self.text_layout_cache,
             view_stack: Default::default(),
@@ -743,7 +731,6 @@ impl<'a> Deref for PaintContext<'a> {
 }
 
 pub struct EventContext<'a> {
-    rendered_views: &'a mut HashMap<usize, ElementBox>,
     pub font_cache: &'a FontCache,
     pub text_layout_cache: &'a TextLayoutCache,
     pub app: &'a mut MutableAppContext,
@@ -755,17 +742,6 @@ pub struct EventContext<'a> {
 }
 
 impl<'a> EventContext<'a> {
-    fn dispatch_event(&mut self, view_id: usize, event: &Event) -> bool {
-        if let Some(mut element) = self.rendered_views.remove(&view_id) {
-            let result =
-                self.with_current_view(view_id, |this| element.dispatch_event(event, this));
-            self.rendered_views.insert(view_id, element);
-            result
-        } else {
-            false
-        }
-    }
-
     fn with_current_view<F, T>(&mut self, view_id: usize, f: F) -> T
     where
         F: FnOnce(&mut Self) -> T,
@@ -1028,27 +1004,6 @@ impl Element for ChildView {
         }
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: RectF,
-        view_is_valid: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        if *view_is_valid {
-            cx.dispatch_event(self.view.id(), event)
-        } else {
-            log::error!(
-                "dispatch_event called on a ChildView element whose underlying view was dropped (view_id: {}, name: {:?})",
-                self.view.id(),
-                self.view_name
-            );
-            false
-        }
-    }
-
     fn rect_for_text_range(
         &self,
         range_utf16: Range<usize>,
diff --git a/crates/gpui/src/scene.rs b/crates/gpui/src/scene.rs
index 4ef17a3f8f5d384723ed1d94a13019bb495e4d0e..99b38a185277731a389771d531ef5b3ca9fc0187 100644
--- a/crates/gpui/src/scene.rs
+++ b/crates/gpui/src/scene.rs
@@ -1,5 +1,5 @@
+mod mouse_event;
 mod mouse_region;
-mod mouse_region_event;
 
 #[cfg(debug_assertions)]
 use collections::HashSet;
@@ -15,8 +15,8 @@ use crate::{
     platform::{current::Surface, CursorStyle},
     ImageData,
 };
+pub use mouse_event::*;
 pub use mouse_region::*;
-pub use mouse_region_event::*;
 
 pub struct Scene {
     scale_factor: f32,
diff --git a/crates/gpui/src/scene/mouse_event.rs b/crates/gpui/src/scene/mouse_event.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d7370ac75f8b5e332e320ad5cf6a95cc781828af
--- /dev/null
+++ b/crates/gpui/src/scene/mouse_event.rs
@@ -0,0 +1,233 @@
+use std::{
+    mem::{discriminant, Discriminant},
+    ops::Deref,
+};
+
+use pathfinder_geometry::{rect::RectF, vector::Vector2F};
+
+use crate::{MouseButton, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseMove {
+    pub region: RectF,
+    pub platform_event: MouseMovedEvent,
+}
+
+impl Deref for MouseMove {
+    type Target = MouseMovedEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseDrag {
+    pub region: RectF,
+    pub prev_mouse_position: Vector2F,
+    pub platform_event: MouseMovedEvent,
+}
+
+impl Deref for MouseDrag {
+    type Target = MouseMovedEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseHover {
+    pub region: RectF,
+    pub started: bool,
+    pub platform_event: MouseMovedEvent,
+}
+
+impl Deref for MouseHover {
+    type Target = MouseMovedEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseDown {
+    pub region: RectF,
+    pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseDown {
+    type Target = MouseButtonEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseUp {
+    pub region: RectF,
+    pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseUp {
+    type Target = MouseButtonEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseClick {
+    pub region: RectF,
+    pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseClick {
+    type Target = MouseButtonEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseDownOut {
+    pub region: RectF,
+    pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseDownOut {
+    type Target = MouseButtonEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseUpOut {
+    pub region: RectF,
+    pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseUpOut {
+    type Target = MouseButtonEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseScrollWheel {
+    pub region: RectF,
+    pub platform_event: ScrollWheelEvent,
+}
+
+impl Deref for MouseScrollWheel {
+    type Target = ScrollWheelEvent;
+
+    fn deref(&self) -> &Self::Target {
+        &self.platform_event
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum MouseEvent {
+    Move(MouseMove),
+    Drag(MouseDrag),
+    Hover(MouseHover),
+    Down(MouseDown),
+    Up(MouseUp),
+    Click(MouseClick),
+    DownOut(MouseDownOut),
+    UpOut(MouseUpOut),
+    ScrollWheel(MouseScrollWheel),
+}
+
+impl MouseEvent {
+    pub fn set_region(&mut self, region: RectF) {
+        match self {
+            MouseEvent::Move(r) => r.region = region,
+            MouseEvent::Drag(r) => r.region = region,
+            MouseEvent::Hover(r) => r.region = region,
+            MouseEvent::Down(r) => r.region = region,
+            MouseEvent::Up(r) => r.region = region,
+            MouseEvent::Click(r) => r.region = region,
+            MouseEvent::DownOut(r) => r.region = region,
+            MouseEvent::UpOut(r) => r.region = region,
+            MouseEvent::ScrollWheel(r) => r.region = region,
+        }
+    }
+
+    /// When true, mouse event handlers must call cx.propagate_event() to bubble
+    /// the event to handlers they are painted on top of.
+    pub fn is_capturable(&self) -> bool {
+        match self {
+            MouseEvent::Move(_) => true,
+            MouseEvent::Drag(_) => true,
+            MouseEvent::Hover(_) => false,
+            MouseEvent::Down(_) => true,
+            MouseEvent::Up(_) => true,
+            MouseEvent::Click(_) => true,
+            MouseEvent::DownOut(_) => false,
+            MouseEvent::UpOut(_) => false,
+            MouseEvent::ScrollWheel(_) => true,
+        }
+    }
+}
+
+impl MouseEvent {
+    pub fn move_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::Move(Default::default()))
+    }
+
+    pub fn drag_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::Drag(Default::default()))
+    }
+
+    pub fn hover_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::Hover(Default::default()))
+    }
+
+    pub fn down_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::Down(Default::default()))
+    }
+
+    pub fn up_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::Up(Default::default()))
+    }
+
+    pub fn up_out_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::UpOut(Default::default()))
+    }
+
+    pub fn click_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::Click(Default::default()))
+    }
+
+    pub fn down_out_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::DownOut(Default::default()))
+    }
+
+    pub fn scroll_wheel_disc() -> Discriminant<MouseEvent> {
+        discriminant(&MouseEvent::ScrollWheel(Default::default()))
+    }
+
+    pub fn handler_key(&self) -> (Discriminant<MouseEvent>, Option<MouseButton>) {
+        match self {
+            MouseEvent::Move(_) => (Self::move_disc(), None),
+            MouseEvent::Drag(e) => (Self::drag_disc(), e.pressed_button),
+            MouseEvent::Hover(_) => (Self::hover_disc(), None),
+            MouseEvent::Down(e) => (Self::down_disc(), Some(e.button)),
+            MouseEvent::Up(e) => (Self::up_disc(), Some(e.button)),
+            MouseEvent::Click(e) => (Self::click_disc(), Some(e.button)),
+            MouseEvent::UpOut(e) => (Self::up_out_disc(), Some(e.button)),
+            MouseEvent::DownOut(e) => (Self::down_out_disc(), Some(e.button)),
+            MouseEvent::ScrollWheel(_) => (Self::scroll_wheel_disc(), None),
+        }
+    }
+}
diff --git a/crates/gpui/src/scene/mouse_region.rs b/crates/gpui/src/scene/mouse_region.rs
index e84508622b8d7b0130d43ebb9f20a9122f487c92..4b5217cc2dec1355d350f921fa66233d8be39591 100644
--- a/crates/gpui/src/scene/mouse_region.rs
+++ b/crates/gpui/src/scene/mouse_region.rs
@@ -7,11 +7,11 @@ use pathfinder_geometry::rect::RectF;
 use crate::{EventContext, MouseButton};
 
 use super::{
-    mouse_region_event::{
-        ClickRegionEvent, DownOutRegionEvent, DownRegionEvent, DragRegionEvent, HoverRegionEvent,
-        MouseRegionEvent, MoveRegionEvent, UpOutRegionEvent, UpRegionEvent,
+    mouse_event::{
+        MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseEvent, MouseHover, MouseMove, MouseUp,
+        MouseUpOut,
     },
-    ScrollWheelRegionEvent,
+    MouseScrollWheel,
 };
 
 #[derive(Clone)]
@@ -62,7 +62,7 @@ impl MouseRegion {
     pub fn on_down(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DownRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDown, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_down(button, handler);
         self
@@ -71,7 +71,7 @@ impl MouseRegion {
     pub fn on_up(
         mut self,
         button: MouseButton,
-        handler: impl Fn(UpRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseUp, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_up(button, handler);
         self
@@ -80,7 +80,7 @@ impl MouseRegion {
     pub fn on_click(
         mut self,
         button: MouseButton,
-        handler: impl Fn(ClickRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseClick, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_click(button, handler);
         self
@@ -89,7 +89,7 @@ impl MouseRegion {
     pub fn on_down_out(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DownOutRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDownOut, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_down_out(button, handler);
         self
@@ -98,7 +98,7 @@ impl MouseRegion {
     pub fn on_up_out(
         mut self,
         button: MouseButton,
-        handler: impl Fn(UpOutRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseUpOut, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_up_out(button, handler);
         self
@@ -107,31 +107,25 @@ impl MouseRegion {
     pub fn on_drag(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DragRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDrag, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_drag(button, handler);
         self
     }
 
-    pub fn on_hover(
-        mut self,
-        handler: impl Fn(HoverRegionEvent, &mut EventContext) + 'static,
-    ) -> Self {
+    pub fn on_hover(mut self, handler: impl Fn(MouseHover, &mut EventContext) + 'static) -> Self {
         self.handlers = self.handlers.on_hover(handler);
         self
     }
 
-    pub fn on_move(
-        mut self,
-        handler: impl Fn(MoveRegionEvent, &mut EventContext) + 'static,
-    ) -> Self {
+    pub fn on_move(mut self, handler: impl Fn(MouseMove, &mut EventContext) + 'static) -> Self {
         self.handlers = self.handlers.on_move(handler);
         self
     }
 
     pub fn on_scroll(
         mut self,
-        handler: impl Fn(ScrollWheelRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseScrollWheel, &mut EventContext) + 'static,
     ) -> Self {
         self.handlers = self.handlers.on_scroll(handler);
         self
@@ -187,8 +181,8 @@ impl MouseRegionId {
 pub struct HandlerSet {
     #[allow(clippy::type_complexity)]
     pub set: HashMap<
-        (Discriminant<MouseRegionEvent>, Option<MouseButton>),
-        Rc<dyn Fn(MouseRegionEvent, &mut EventContext)>,
+        (Discriminant<MouseEvent>, Option<MouseButton>),
+        Rc<dyn Fn(MouseEvent, &mut EventContext)>,
     >,
 }
 
@@ -196,68 +190,50 @@ impl HandlerSet {
     pub fn capture_all() -> Self {
         #[allow(clippy::type_complexity)]
         let mut set: HashMap<
-            (Discriminant<MouseRegionEvent>, Option<MouseButton>),
-            Rc<dyn Fn(MouseRegionEvent, &mut EventContext)>,
+            (Discriminant<MouseEvent>, Option<MouseButton>),
+            Rc<dyn Fn(MouseEvent, &mut EventContext)>,
         > = Default::default();
 
-        set.insert((MouseRegionEvent::move_disc(), None), Rc::new(|_, _| {}));
-        set.insert((MouseRegionEvent::hover_disc(), None), Rc::new(|_, _| {}));
+        set.insert((MouseEvent::move_disc(), None), Rc::new(|_, _| {}));
+        set.insert((MouseEvent::hover_disc(), None), Rc::new(|_, _| {}));
         for button in MouseButton::all() {
+            set.insert((MouseEvent::drag_disc(), Some(button)), Rc::new(|_, _| {}));
+            set.insert((MouseEvent::down_disc(), Some(button)), Rc::new(|_, _| {}));
+            set.insert((MouseEvent::up_disc(), Some(button)), Rc::new(|_, _| {}));
+            set.insert((MouseEvent::click_disc(), Some(button)), Rc::new(|_, _| {}));
             set.insert(
-                (MouseRegionEvent::drag_disc(), Some(button)),
-                Rc::new(|_, _| {}),
-            );
-            set.insert(
-                (MouseRegionEvent::down_disc(), Some(button)),
-                Rc::new(|_, _| {}),
-            );
-            set.insert(
-                (MouseRegionEvent::up_disc(), Some(button)),
+                (MouseEvent::down_out_disc(), Some(button)),
                 Rc::new(|_, _| {}),
             );
             set.insert(
-                (MouseRegionEvent::click_disc(), Some(button)),
-                Rc::new(|_, _| {}),
-            );
-            set.insert(
-                (MouseRegionEvent::down_out_disc(), Some(button)),
-                Rc::new(|_, _| {}),
-            );
-            set.insert(
-                (MouseRegionEvent::up_out_disc(), Some(button)),
+                (MouseEvent::up_out_disc(), Some(button)),
                 Rc::new(|_, _| {}),
             );
         }
-        set.insert(
-            (MouseRegionEvent::scroll_wheel_disc(), None),
-            Rc::new(|_, _| {}),
-        );
+        set.insert((MouseEvent::scroll_wheel_disc(), None), Rc::new(|_, _| {}));
 
         HandlerSet { set }
     }
 
     pub fn get(
         &self,
-        key: &(Discriminant<MouseRegionEvent>, Option<MouseButton>),
-    ) -> Option<Rc<dyn Fn(MouseRegionEvent, &mut EventContext)>> {
+        key: &(Discriminant<MouseEvent>, Option<MouseButton>),
+    ) -> Option<Rc<dyn Fn(MouseEvent, &mut EventContext)>> {
         self.set.get(key).cloned()
     }
 
     pub fn contains_handler(
         &self,
-        event: Discriminant<MouseRegionEvent>,
+        event: Discriminant<MouseEvent>,
         button: Option<MouseButton>,
     ) -> bool {
         self.set.contains_key(&(event, button))
     }
 
-    pub fn on_move(
-        mut self,
-        handler: impl Fn(MoveRegionEvent, &mut EventContext) + 'static,
-    ) -> Self {
-        self.set.insert((MouseRegionEvent::move_disc(), None),
+    pub fn on_move(mut self, handler: impl Fn(MouseMove, &mut EventContext) + 'static) -> Self {
+        self.set.insert((MouseEvent::move_disc(), None),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::Move(e) = region_event {
+                if let MouseEvent::Move(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -271,11 +247,11 @@ impl HandlerSet {
     pub fn on_down(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DownRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDown, &mut EventContext) + 'static,
     ) -> Self {
-        self.set.insert((MouseRegionEvent::down_disc(), Some(button)),
+        self.set.insert((MouseEvent::down_disc(), Some(button)),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::Down(e) = region_event {
+                if let MouseEvent::Down(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -289,11 +265,11 @@ impl HandlerSet {
     pub fn on_up(
         mut self,
         button: MouseButton,
-        handler: impl Fn(UpRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseUp, &mut EventContext) + 'static,
     ) -> Self {
-        self.set.insert((MouseRegionEvent::up_disc(), Some(button)),
+        self.set.insert((MouseEvent::up_disc(), Some(button)),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::Up(e) = region_event {
+                if let MouseEvent::Up(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -307,11 +283,11 @@ impl HandlerSet {
     pub fn on_click(
         mut self,
         button: MouseButton,
-        handler: impl Fn(ClickRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseClick, &mut EventContext) + 'static,
     ) -> Self {
-        self.set.insert((MouseRegionEvent::click_disc(), Some(button)),
+        self.set.insert((MouseEvent::click_disc(), Some(button)),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::Click(e) = region_event {
+                if let MouseEvent::Click(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -325,11 +301,11 @@ impl HandlerSet {
     pub fn on_down_out(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DownOutRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDownOut, &mut EventContext) + 'static,
     ) -> Self {
-        self.set.insert((MouseRegionEvent::down_out_disc(), Some(button)),
+        self.set.insert((MouseEvent::down_out_disc(), Some(button)),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::DownOut(e) = region_event {
+                if let MouseEvent::DownOut(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -343,11 +319,11 @@ impl HandlerSet {
     pub fn on_up_out(
         mut self,
         button: MouseButton,
-        handler: impl Fn(UpOutRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseUpOut, &mut EventContext) + 'static,
     ) -> Self {
-        self.set.insert((MouseRegionEvent::up_out_disc(), Some(button)),
+        self.set.insert((MouseEvent::up_out_disc(), Some(button)),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::UpOut(e) = region_event {
+                if let MouseEvent::UpOut(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -361,11 +337,11 @@ impl HandlerSet {
     pub fn on_drag(
         mut self,
         button: MouseButton,
-        handler: impl Fn(DragRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseDrag, &mut EventContext) + 'static,
     ) -> Self {
-        self.set.insert((MouseRegionEvent::drag_disc(), Some(button)),
+        self.set.insert((MouseEvent::drag_disc(), Some(button)),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::Drag(e) = region_event {
+                if let MouseEvent::Drag(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -376,13 +352,10 @@ impl HandlerSet {
         self
     }
 
-    pub fn on_hover(
-        mut self,
-        handler: impl Fn(HoverRegionEvent, &mut EventContext) + 'static,
-    ) -> Self {
-        self.set.insert((MouseRegionEvent::hover_disc(), None),
+    pub fn on_hover(mut self, handler: impl Fn(MouseHover, &mut EventContext) + 'static) -> Self {
+        self.set.insert((MouseEvent::hover_disc(), None),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::Hover(e) = region_event {
+                if let MouseEvent::Hover(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
@@ -395,11 +368,11 @@ impl HandlerSet {
 
     pub fn on_scroll(
         mut self,
-        handler: impl Fn(ScrollWheelRegionEvent, &mut EventContext) + 'static,
+        handler: impl Fn(MouseScrollWheel, &mut EventContext) + 'static,
     ) -> Self {
-        self.set.insert((MouseRegionEvent::scroll_wheel_disc(), None),
+        self.set.insert((MouseEvent::scroll_wheel_disc(), None),
             Rc::new(move |region_event, cx| {
-                if let MouseRegionEvent::ScrollWheel(e) = region_event {
+                if let MouseEvent::ScrollWheel(e) = region_event {
                     handler(e, cx);
                 } else {
                     panic!(
diff --git a/crates/gpui/src/scene/mouse_region_event.rs b/crates/gpui/src/scene/mouse_region_event.rs
deleted file mode 100644
index 4d89cd5b6f06a9aafd98d168a0c1defbd55fd801..0000000000000000000000000000000000000000
--- a/crates/gpui/src/scene/mouse_region_event.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-use std::{
-    mem::{discriminant, Discriminant},
-    ops::Deref,
-};
-
-use pathfinder_geometry::{rect::RectF, vector::Vector2F};
-
-use crate::{MouseButton, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
-
-#[derive(Debug, Default, Clone)]
-pub struct MoveRegionEvent {
-    pub region: RectF,
-    pub platform_event: MouseMovedEvent,
-}
-
-impl Deref for MoveRegionEvent {
-    type Target = MouseMovedEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct DragRegionEvent {
-    pub region: RectF,
-    pub prev_mouse_position: Vector2F,
-    pub platform_event: MouseMovedEvent,
-}
-
-impl Deref for DragRegionEvent {
-    type Target = MouseMovedEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct HoverRegionEvent {
-    pub region: RectF,
-    pub started: bool,
-    pub platform_event: MouseMovedEvent,
-}
-
-impl Deref for HoverRegionEvent {
-    type Target = MouseMovedEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct DownRegionEvent {
-    pub region: RectF,
-    pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for DownRegionEvent {
-    type Target = MouseButtonEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct UpRegionEvent {
-    pub region: RectF,
-    pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for UpRegionEvent {
-    type Target = MouseButtonEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct ClickRegionEvent {
-    pub region: RectF,
-    pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for ClickRegionEvent {
-    type Target = MouseButtonEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct DownOutRegionEvent {
-    pub region: RectF,
-    pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for DownOutRegionEvent {
-    type Target = MouseButtonEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct UpOutRegionEvent {
-    pub region: RectF,
-    pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for UpOutRegionEvent {
-    type Target = MouseButtonEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct ScrollWheelRegionEvent {
-    pub region: RectF,
-    pub platform_event: ScrollWheelEvent,
-}
-
-impl Deref for ScrollWheelRegionEvent {
-    type Target = ScrollWheelEvent;
-
-    fn deref(&self) -> &Self::Target {
-        &self.platform_event
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum MouseRegionEvent {
-    Move(MoveRegionEvent),
-    Drag(DragRegionEvent),
-    Hover(HoverRegionEvent),
-    Down(DownRegionEvent),
-    Up(UpRegionEvent),
-    Click(ClickRegionEvent),
-    DownOut(DownOutRegionEvent),
-    UpOut(UpOutRegionEvent),
-    ScrollWheel(ScrollWheelRegionEvent),
-}
-
-impl MouseRegionEvent {
-    pub fn set_region(&mut self, region: RectF) {
-        match self {
-            MouseRegionEvent::Move(r) => r.region = region,
-            MouseRegionEvent::Drag(r) => r.region = region,
-            MouseRegionEvent::Hover(r) => r.region = region,
-            MouseRegionEvent::Down(r) => r.region = region,
-            MouseRegionEvent::Up(r) => r.region = region,
-            MouseRegionEvent::Click(r) => r.region = region,
-            MouseRegionEvent::DownOut(r) => r.region = region,
-            MouseRegionEvent::UpOut(r) => r.region = region,
-            MouseRegionEvent::ScrollWheel(r) => r.region = region,
-        }
-    }
-
-    /// When true, mouse event handlers must call cx.propagate_event() to bubble
-    /// the event to handlers they are painted on top of.
-    pub fn is_capturable(&self) -> bool {
-        match self {
-            MouseRegionEvent::Move(_) => true,
-            MouseRegionEvent::Drag(_) => true,
-            MouseRegionEvent::Hover(_) => false,
-            MouseRegionEvent::Down(_) => true,
-            MouseRegionEvent::Up(_) => true,
-            MouseRegionEvent::Click(_) => true,
-            MouseRegionEvent::DownOut(_) => false,
-            MouseRegionEvent::UpOut(_) => false,
-            MouseRegionEvent::ScrollWheel(_) => true,
-        }
-    }
-}
-
-impl MouseRegionEvent {
-    pub fn move_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::Move(Default::default()))
-    }
-
-    pub fn drag_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::Drag(Default::default()))
-    }
-
-    pub fn hover_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::Hover(Default::default()))
-    }
-
-    pub fn down_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::Down(Default::default()))
-    }
-
-    pub fn up_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::Up(Default::default()))
-    }
-
-    pub fn up_out_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::UpOut(Default::default()))
-    }
-
-    pub fn click_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::Click(Default::default()))
-    }
-
-    pub fn down_out_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::DownOut(Default::default()))
-    }
-
-    pub fn scroll_wheel_disc() -> Discriminant<MouseRegionEvent> {
-        discriminant(&MouseRegionEvent::ScrollWheel(Default::default()))
-    }
-
-    pub fn handler_key(&self) -> (Discriminant<MouseRegionEvent>, Option<MouseButton>) {
-        match self {
-            MouseRegionEvent::Move(_) => (Self::move_disc(), None),
-            MouseRegionEvent::Drag(e) => (Self::drag_disc(), e.pressed_button),
-            MouseRegionEvent::Hover(_) => (Self::hover_disc(), None),
-            MouseRegionEvent::Down(e) => (Self::down_disc(), Some(e.button)),
-            MouseRegionEvent::Up(e) => (Self::up_disc(), Some(e.button)),
-            MouseRegionEvent::Click(e) => (Self::click_disc(), Some(e.button)),
-            MouseRegionEvent::UpOut(e) => (Self::up_out_disc(), Some(e.button)),
-            MouseRegionEvent::DownOut(e) => (Self::down_out_disc(), Some(e.button)),
-            MouseRegionEvent::ScrollWheel(_) => (Self::scroll_wheel_disc(), None),
-        }
-    }
-}
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 274777b81cbf5531288f81e03523f515b53a0eda..5a75f1a56f53c4a621679649ee37fb7fafdb7611 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -111,9 +111,19 @@ pub enum IndentKind {
     Tab,
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+pub enum CursorShape {
+    #[default]
+    Bar,
+    Block,
+    Underscore,
+    Hollow,
+}
+
 #[derive(Clone, Debug)]
 struct SelectionSet {
     line_mode: bool,
+    cursor_shape: CursorShape,
     selections: Arc<[Selection<Anchor>]>,
     lamport_timestamp: clock::Lamport,
 }
@@ -161,6 +171,7 @@ pub enum Operation {
         selections: Arc<[Selection<Anchor>]>,
         lamport_timestamp: clock::Lamport,
         line_mode: bool,
+        cursor_shape: CursorShape,
     },
     UpdateCompletionTriggers {
         triggers: Vec<String>,
@@ -395,6 +406,7 @@ impl Buffer {
                 selections: set.selections.clone(),
                 lamport_timestamp: set.lamport_timestamp,
                 line_mode: set.line_mode,
+                cursor_shape: set.cursor_shape,
             })
         }));
         operations.push(proto::serialize_operation(&Operation::UpdateDiagnostics {
@@ -1227,6 +1239,7 @@ impl Buffer {
         &mut self,
         selections: Arc<[Selection<Anchor>]>,
         line_mode: bool,
+        cursor_shape: CursorShape,
         cx: &mut ModelContext<Self>,
     ) {
         let lamport_timestamp = self.text.lamport_clock.tick();
@@ -1236,6 +1249,7 @@ impl Buffer {
                 selections: selections.clone(),
                 lamport_timestamp,
                 line_mode,
+                cursor_shape,
             },
         );
         self.send_operation(
@@ -1243,13 +1257,14 @@ impl Buffer {
                 selections,
                 line_mode,
                 lamport_timestamp,
+                cursor_shape,
             },
             cx,
         );
     }
 
     pub fn remove_active_selections(&mut self, cx: &mut ModelContext<Self>) {
-        self.set_active_selections(Arc::from([]), false, cx);
+        self.set_active_selections(Arc::from([]), false, Default::default(), cx);
     }
 
     pub fn set_text<T>(&mut self, text: T, cx: &mut ModelContext<Self>) -> Option<clock::Local>
@@ -1474,6 +1489,7 @@ impl Buffer {
                 selections,
                 lamport_timestamp,
                 line_mode,
+                cursor_shape,
             } => {
                 if let Some(set) = self.remote_selections.get(&lamport_timestamp.replica_id) {
                     if set.lamport_timestamp > lamport_timestamp {
@@ -1487,6 +1503,7 @@ impl Buffer {
                         selections,
                         lamport_timestamp,
                         line_mode,
+                        cursor_shape,
                     },
                 );
                 self.text.lamport_clock.observe(lamport_timestamp);
@@ -2236,6 +2253,7 @@ impl BufferSnapshot {
         Item = (
             ReplicaId,
             bool,
+            CursorShape,
             impl Iterator<Item = &Selection<Anchor>> + '_,
         ),
     > + '_ {
@@ -2259,6 +2277,7 @@ impl BufferSnapshot {
                 (
                     *replica_id,
                     set.line_mode,
+                    set.cursor_shape,
                     set.selections[start_ix..end_ix].iter(),
                 )
             })
@@ -2315,6 +2334,18 @@ impl BufferSnapshot {
         self.file.as_deref()
     }
 
+    pub fn resolve_file_path(&self, cx: &AppContext, include_root: bool) -> Option<PathBuf> {
+        if let Some(file) = self.file() {
+            if file.path().file_name().is_none() || include_root {
+                Some(file.full_path(cx))
+            } else {
+                Some(file.path().to_path_buf())
+            }
+        } else {
+            None
+        }
+    }
+
     pub fn file_update_count(&self) -> usize {
         self.file_update_count
     }
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 0f3ab50f4adf2daae6828479cf4cd5879615fddb..f1b51f7e021368d93a99f9addd9d223a7e3934ab 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -1283,7 +1283,7 @@ fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
                         selections
                     );
                     active_selections.insert(replica_id, selections.clone());
-                    buffer.set_active_selections(selections, false, cx);
+                    buffer.set_active_selections(selections, false, Default::default(), cx);
                 });
                 mutation_count -= 1;
             }
@@ -1448,7 +1448,7 @@ fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
         let buffer = buffer.read(cx).snapshot();
         let actual_remote_selections = buffer
             .remote_selections_in_range(Anchor::MIN..Anchor::MAX)
-            .map(|(replica_id, _, selections)| (replica_id, selections.collect::<Vec<_>>()))
+            .map(|(replica_id, _, _, selections)| (replica_id, selections.collect::<Vec<_>>()))
             .collect::<Vec<_>>();
         let expected_remote_selections = active_selections
             .iter()
diff --git a/crates/language/src/proto.rs b/crates/language/src/proto.rs
index 9e3ee7d46b17790cb0af121dade9edea27eb301f..f93d99f76b02a86a0267d2355a7c85cccda60b70 100644
--- a/crates/language/src/proto.rs
+++ b/crates/language/src/proto.rs
@@ -1,5 +1,6 @@
 use crate::{
-    diagnostic_set::DiagnosticEntry, CodeAction, CodeLabel, Completion, Diagnostic, Language,
+    diagnostic_set::DiagnosticEntry, CodeAction, CodeLabel, Completion, CursorShape, Diagnostic,
+    Language,
 };
 use anyhow::{anyhow, Result};
 use clock::ReplicaId;
@@ -52,11 +53,13 @@ pub fn serialize_operation(operation: &crate::Operation) -> proto::Operation {
                 selections,
                 line_mode,
                 lamport_timestamp,
+                cursor_shape,
             } => proto::operation::Variant::UpdateSelections(proto::operation::UpdateSelections {
                 replica_id: lamport_timestamp.replica_id as u32,
                 lamport_timestamp: lamport_timestamp.value,
                 selections: serialize_selections(selections),
                 line_mode: *line_mode,
+                cursor_shape: serialize_cursor_shape(cursor_shape) as i32,
             }),
             crate::Operation::UpdateDiagnostics {
                 diagnostics,
@@ -125,6 +128,24 @@ pub fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
     }
 }
 
+pub fn serialize_cursor_shape(cursor_shape: &CursorShape) -> proto::CursorShape {
+    match cursor_shape {
+        CursorShape::Bar => proto::CursorShape::CursorBar,
+        CursorShape::Block => proto::CursorShape::CursorBlock,
+        CursorShape::Underscore => proto::CursorShape::CursorUnderscore,
+        CursorShape::Hollow => proto::CursorShape::CursorHollow,
+    }
+}
+
+pub fn deserialize_cursor_shape(cursor_shape: proto::CursorShape) -> CursorShape {
+    match cursor_shape {
+        proto::CursorShape::CursorBar => CursorShape::Bar,
+        proto::CursorShape::CursorBlock => CursorShape::Block,
+        proto::CursorShape::CursorUnderscore => CursorShape::Underscore,
+        proto::CursorShape::CursorHollow => CursorShape::Hollow,
+    }
+}
+
 pub fn serialize_diagnostics<'a>(
     diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<Anchor>>,
 ) -> Vec<proto::Diagnostic> {
@@ -223,6 +244,10 @@ pub fn deserialize_operation(message: proto::Operation) -> Result<crate::Operati
                     },
                     selections: Arc::from(selections),
                     line_mode: message.line_mode,
+                    cursor_shape: deserialize_cursor_shape(
+                        proto::CursorShape::from_i32(message.cursor_shape)
+                            .ok_or_else(|| anyhow!("Missing cursor shape"))?,
+                    ),
                 }
             }
             proto::operation::Variant::UpdateDiagnostics(message) => {
diff --git a/crates/outline/src/outline.rs b/crates/outline/src/outline.rs
index a677ab5b675a57bd4731bd760401ccfe1fafb248..cee5388800ab3a84c749dfc96cdbf371b551d61c 100644
--- a/crates/outline/src/outline.rs
+++ b/crates/outline/src/outline.rs
@@ -52,7 +52,7 @@ impl View for OutlineView {
         ChildView::new(self.picker.clone(), cx).boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.picker);
         }
diff --git a/crates/picker/src/picker.rs b/crates/picker/src/picker.rs
index 30ad7827efce472959d3c833fc492bd1d45d8c3a..0945f6771bc6d640fb05a7df6233cbc6d71d71e7 100644
--- a/crates/picker/src/picker.rs
+++ b/crates/picker/src/picker.rs
@@ -116,7 +116,7 @@ impl<D: PickerDelegate> View for Picker<D> {
         cx
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.query_editor);
         }
diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml
index 4e6dc09e4e45cc8528c8382221f8e487e32e9c15..76c60f9556235605e59a62cc5bd8c70aa9aaff1b 100644
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -52,7 +52,6 @@ similar = "1.3"
 smol = "1.2.5"
 thiserror = "1.0.29"
 toml = "0.5"
-rocksdb = "0.18"
 
 [dev-dependencies]
 client = { path = "../client", features = ["test-support"] }
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index f964726c4ceb3e250bd662acca72ecd90d2710dc..f05b7e6728a3273f77705daa69a28941e7d198c1 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -583,7 +583,10 @@ impl Project {
         cx: &mut gpui::TestAppContext,
     ) -> ModelHandle<Project> {
         if !cx.read(|cx| cx.has_global::<Settings>()) {
-            cx.update(|cx| cx.set_global(Settings::test(cx)));
+            cx.update(|cx| {
+                cx.set_global(Settings::test(cx));
+                cx.set_global(HomeDir(Path::new("/tmp/").to_path_buf()))
+            });
         }
 
         let languages = Arc::new(LanguageRegistry::test());
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index 1b0294c4d12ed83ab2586a5ffd5ee3f53089faa0..a9ac5f4411469e6466ded12b6762526dbc783658 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -2164,6 +2164,7 @@ async fn test_rescan_and_remote_updates(
             proto::WorktreeMetadata {
                 id: initial_snapshot.id().to_proto(),
                 root_name: initial_snapshot.root_name().into(),
+                abs_path: initial_snapshot.abs_path().as_os_str().as_bytes().to_vec(),
                 visible: true,
             },
             rpc.clone(),
diff --git a/crates/project/src/worktree.rs b/crates/project/src/worktree.rs
index 383c9ac35b34c38d02e208cef1cb2b2c5a61e45a..9f0ebe32f7a10af0e1b547fd4ae0e51ce2d78134 100644
--- a/crates/project/src/worktree.rs
+++ b/crates/project/src/worktree.rs
@@ -5,8 +5,8 @@ use anyhow::{anyhow, Context, Result};
 use client::{proto, Client};
 use clock::ReplicaId;
 use collections::{HashMap, VecDeque};
-use fs::LineEnding;
 use fs::{repository::GitRepository, Fs};
+use fs::{HomeDir, LineEnding};
 use futures::{
     channel::{
         mpsc::{self, UnboundedSender},
@@ -87,6 +87,7 @@ pub struct RemoteWorktree {
 #[derive(Clone)]
 pub struct Snapshot {
     id: WorktreeId,
+    abs_path: Arc<Path>,
     root_name: String,
     root_char_bag: CharBag,
     entries_by_path: SumTree<Entry>,
@@ -118,7 +119,6 @@ impl std::fmt::Debug for GitRepositoryEntry {
 }
 
 pub struct LocalSnapshot {
-    abs_path: Arc<Path>,
     ignores_by_parent_abs_path: HashMap<Arc<Path>, (Arc<Gitignore>, usize)>,
     git_repositories: Vec<GitRepositoryEntry>,
     removed_entry_ids: HashMap<u64, ProjectEntryId>,
@@ -130,7 +130,6 @@ pub struct LocalSnapshot {
 impl Clone for LocalSnapshot {
     fn clone(&self) -> Self {
         Self {
-            abs_path: self.abs_path.clone(),
             ignores_by_parent_abs_path: self.ignores_by_parent_abs_path.clone(),
             git_repositories: self.git_repositories.iter().cloned().collect(),
             removed_entry_ids: self.removed_entry_ids.clone(),
@@ -221,8 +220,11 @@ impl Worktree {
             .collect();
         let root_name = worktree.root_name.clone();
         let visible = worktree.visible;
+
+        let abs_path = PathBuf::from(OsString::from_vec(worktree.abs_path));
         let snapshot = Snapshot {
             id: WorktreeId(remote_id as usize),
+            abs_path: Arc::from(abs_path.deref()),
             root_name,
             root_char_bag,
             entries_by_path: Default::default(),
@@ -372,6 +374,13 @@ impl Worktree {
             Self::Remote(worktree) => worktree.poll_snapshot(cx),
         };
     }
+
+    pub fn abs_path(&self) -> Arc<Path> {
+        match self {
+            Worktree::Local(worktree) => worktree.abs_path.clone(),
+            Worktree::Remote(worktree) => worktree.abs_path.clone(),
+        }
+    }
 }
 
 impl LocalWorktree {
@@ -402,13 +411,13 @@ impl LocalWorktree {
             watch::channel_with(ScanState::Initializing);
         let tree = cx.add_model(move |cx: &mut ModelContext<Worktree>| {
             let mut snapshot = LocalSnapshot {
-                abs_path,
                 ignores_by_parent_abs_path: Default::default(),
                 git_repositories: Default::default(),
                 removed_entry_ids: Default::default(),
                 next_entry_id,
                 snapshot: Snapshot {
                     id: WorktreeId::from_usize(cx.model_id()),
+                    abs_path,
                     root_name: root_name.clone(),
                     root_char_bag,
                     entries_by_path: Default::default(),
@@ -647,6 +656,7 @@ impl LocalWorktree {
             id: self.id().to_proto(),
             root_name: self.root_name().to_string(),
             visible: self.visible,
+            abs_path: self.abs_path().as_os_str().as_bytes().to_vec(),
         }
     }
 
@@ -980,6 +990,7 @@ impl LocalWorktree {
                             let update = proto::UpdateWorktree {
                                 project_id,
                                 worktree_id,
+                                abs_path: snapshot.abs_path().as_os_str().as_bytes().to_vec(),
                                 root_name: snapshot.root_name().to_string(),
                                 updated_entries: snapshot
                                     .entries_by_path
@@ -1389,6 +1400,7 @@ impl LocalSnapshot {
         proto::UpdateWorktree {
             project_id,
             worktree_id: self.id().to_proto(),
+            abs_path: self.abs_path().as_os_str().as_bytes().to_vec(),
             root_name,
             updated_entries: self.entries_by_path.iter().map(Into::into).collect(),
             removed_entries: Default::default(),
@@ -1456,6 +1468,7 @@ impl LocalSnapshot {
         proto::UpdateWorktree {
             project_id,
             worktree_id,
+            abs_path: self.abs_path().as_os_str().as_bytes().to_vec(),
             root_name: self.root_name().to_string(),
             updated_entries,
             removed_entries,
@@ -1839,10 +1852,25 @@ impl language::File for File {
 
     fn full_path(&self, cx: &AppContext) -> PathBuf {
         let mut full_path = PathBuf::new();
-        full_path.push(self.worktree.read(cx).root_name());
+        let worktree = self.worktree.read(cx);
+
+        if worktree.is_visible() {
+            full_path.push(worktree.root_name());
+        } else {
+            let path = worktree.abs_path();
+
+            if worktree.is_local() && path.starts_with(cx.global::<HomeDir>().as_path()) {
+                full_path.push("~");
+                full_path.push(path.strip_prefix(cx.global::<HomeDir>().as_path()).unwrap());
+            } else {
+                full_path.push(path)
+            }
+        }
+
         if self.path.components().next().is_some() {
             full_path.push(&self.path);
         }
+
         full_path
     }
 
@@ -3455,7 +3483,6 @@ mod tests {
         let fs = Arc::new(RealFs);
         let next_entry_id = Arc::new(AtomicUsize::new(0));
         let mut initial_snapshot = LocalSnapshot {
-            abs_path: root_dir.path().into(),
             removed_entry_ids: Default::default(),
             ignores_by_parent_abs_path: Default::default(),
             git_repositories: Default::default(),
@@ -3464,6 +3491,7 @@ mod tests {
                 id: WorktreeId::from_usize(0),
                 entries_by_path: Default::default(),
                 entries_by_id: Default::default(),
+                abs_path: root_dir.path().into(),
                 root_name: Default::default(),
                 root_char_bag: Default::default(),
                 scan_id: 0,
diff --git a/crates/project_symbols/src/project_symbols.rs b/crates/project_symbols/src/project_symbols.rs
index a81231b98f38395c7ed67cef227fec407807b112..e4a251de00cdfc5de619c6e8d2beb305fadd1ea1 100644
--- a/crates/project_symbols/src/project_symbols.rs
+++ b/crates/project_symbols/src/project_symbols.rs
@@ -51,7 +51,7 @@ impl View for ProjectSymbolsView {
         ChildView::new(self.picker.clone(), cx).boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.picker);
         }
diff --git a/crates/rpc/proto/zed.proto b/crates/rpc/proto/zed.proto
index 1248bb05519788a2d4ac1f198161afae3733a6ab..5af55b12cef82af9772ff03d80dc9f622742999d 100644
--- a/crates/rpc/proto/zed.proto
+++ b/crates/rpc/proto/zed.proto
@@ -6,125 +6,130 @@ message Envelope {
     optional uint32 responding_to = 2;
     optional uint32 original_sender_id = 3;
     oneof payload {
-        Ack ack = 4;
-        Error error = 5;
-        Ping ping = 6;
-        Test test = 7;
+        Hello hello = 4;
+        Ack ack = 5;
+        Error error = 6;
+        Ping ping = 7;
+        Test test = 8;
         
-        CreateRoom create_room = 8;
-        CreateRoomResponse create_room_response = 9;
-        JoinRoom join_room = 10;
-        JoinRoomResponse join_room_response = 11;
-        LeaveRoom leave_room = 12;
-        Call call = 13;
-        IncomingCall incoming_call = 14;
-        CallCanceled call_canceled = 15;
-        CancelCall cancel_call = 16;
-        DeclineCall decline_call = 17;
-        UpdateParticipantLocation update_participant_location = 18;
-        RoomUpdated room_updated = 19;
-
-        ShareProject share_project = 20;
-        ShareProjectResponse share_project_response = 21;
-        UnshareProject unshare_project = 22;
-        JoinProject join_project = 23;
-        JoinProjectResponse join_project_response = 24;
-        LeaveProject leave_project = 25;
-        AddProjectCollaborator add_project_collaborator = 26;
-        RemoveProjectCollaborator remove_project_collaborator = 27;
-
-        GetDefinition get_definition = 28;
-        GetDefinitionResponse get_definition_response = 29;
-        GetTypeDefinition get_type_definition = 30;
-        GetTypeDefinitionResponse get_type_definition_response = 31;
-        GetReferences get_references = 32;
-        GetReferencesResponse get_references_response = 33;
-        GetDocumentHighlights get_document_highlights = 34;
-        GetDocumentHighlightsResponse get_document_highlights_response = 35;
-        GetProjectSymbols get_project_symbols = 36;
-        GetProjectSymbolsResponse get_project_symbols_response = 37;
-        OpenBufferForSymbol open_buffer_for_symbol = 38;
-        OpenBufferForSymbolResponse open_buffer_for_symbol_response = 39;
-
-        UpdateProject update_project = 40;
-        RegisterProjectActivity register_project_activity = 41;
-        UpdateWorktree update_worktree = 42;
-        UpdateWorktreeExtensions update_worktree_extensions = 43;
-
-        CreateProjectEntry create_project_entry = 44;
-        RenameProjectEntry rename_project_entry = 45;
-        CopyProjectEntry copy_project_entry = 46;
-        DeleteProjectEntry delete_project_entry = 47;
-        ProjectEntryResponse project_entry_response = 48;
-
-        UpdateDiagnosticSummary update_diagnostic_summary = 49;
-        StartLanguageServer start_language_server = 50;
-        UpdateLanguageServer update_language_server = 51;
-
-        OpenBufferById open_buffer_by_id = 52;
-        OpenBufferByPath open_buffer_by_path = 53;
-        OpenBufferResponse open_buffer_response = 54;
-        CreateBufferForPeer create_buffer_for_peer = 55;
-        UpdateBuffer update_buffer = 56;
-        UpdateBufferFile update_buffer_file = 57;
-        SaveBuffer save_buffer = 58;
-        BufferSaved buffer_saved = 59;
-        BufferReloaded buffer_reloaded = 60;
-        ReloadBuffers reload_buffers = 61;
-        ReloadBuffersResponse reload_buffers_response = 62;
-        FormatBuffers format_buffers = 63;
-        FormatBuffersResponse format_buffers_response = 64;
-        GetCompletions get_completions = 65;
-        GetCompletionsResponse get_completions_response = 66;
-        ApplyCompletionAdditionalEdits apply_completion_additional_edits = 67;
-        ApplyCompletionAdditionalEditsResponse apply_completion_additional_edits_response = 68;
-        GetCodeActions get_code_actions = 69;
-        GetCodeActionsResponse get_code_actions_response = 70;
-        GetHover get_hover = 71;
-        GetHoverResponse get_hover_response = 72;
-        ApplyCodeAction apply_code_action = 73;
-        ApplyCodeActionResponse apply_code_action_response = 74;
-        PrepareRename prepare_rename = 75;
-        PrepareRenameResponse prepare_rename_response = 76;
-        PerformRename perform_rename = 77;
-        PerformRenameResponse perform_rename_response = 78;
-        SearchProject search_project = 79;
-        SearchProjectResponse search_project_response = 80;
-
-        GetChannels get_channels = 81;
-        GetChannelsResponse get_channels_response = 82;
-        JoinChannel join_channel = 83;
-        JoinChannelResponse join_channel_response = 84;
-        LeaveChannel leave_channel = 85;
-        SendChannelMessage send_channel_message = 86;
-        SendChannelMessageResponse send_channel_message_response = 87;
-        ChannelMessageSent channel_message_sent = 88;
-        GetChannelMessages get_channel_messages = 89;
-        GetChannelMessagesResponse get_channel_messages_response = 90;
-
-        UpdateContacts update_contacts = 91;
-        UpdateInviteInfo update_invite_info = 92;
-        ShowContacts show_contacts = 93;
-
-        GetUsers get_users = 94;
-        FuzzySearchUsers fuzzy_search_users = 95;
-        UsersResponse users_response = 96;
-        RequestContact request_contact = 97;
-        RespondToContactRequest respond_to_contact_request = 98;
-        RemoveContact remove_contact = 99;
-
-        Follow follow = 100;
-        FollowResponse follow_response = 101;
-        UpdateFollowers update_followers = 102;
-        Unfollow unfollow = 103;
-        GetPrivateUserInfo get_private_user_info = 104;
-        GetPrivateUserInfoResponse get_private_user_info_response = 105;
-        UpdateDiffBase update_diff_base = 106;
+        CreateRoom create_room = 9;
+        CreateRoomResponse create_room_response = 10;
+        JoinRoom join_room = 11;
+        JoinRoomResponse join_room_response = 12;
+        LeaveRoom leave_room = 13;
+        Call call = 14;
+        IncomingCall incoming_call = 15;
+        CallCanceled call_canceled = 16;
+        CancelCall cancel_call = 17;
+        DeclineCall decline_call = 18;
+        UpdateParticipantLocation update_participant_location = 19;
+        RoomUpdated room_updated = 20;
+
+        ShareProject share_project = 21;
+        ShareProjectResponse share_project_response = 22;
+        UnshareProject unshare_project = 23;
+        JoinProject join_project = 24;
+        JoinProjectResponse join_project_response = 25;
+        LeaveProject leave_project = 26;
+        AddProjectCollaborator add_project_collaborator = 27;
+        RemoveProjectCollaborator remove_project_collaborator = 28;
+
+        GetDefinition get_definition = 29;
+        GetDefinitionResponse get_definition_response = 30;
+        GetTypeDefinition get_type_definition = 31;
+        GetTypeDefinitionResponse get_type_definition_response = 32;
+        GetReferences get_references = 33;
+        GetReferencesResponse get_references_response = 34;
+        GetDocumentHighlights get_document_highlights = 35;
+        GetDocumentHighlightsResponse get_document_highlights_response = 36;
+        GetProjectSymbols get_project_symbols = 37;
+        GetProjectSymbolsResponse get_project_symbols_response = 38;
+        OpenBufferForSymbol open_buffer_for_symbol = 39;
+        OpenBufferForSymbolResponse open_buffer_for_symbol_response = 40;
+
+        UpdateProject update_project = 41;
+        RegisterProjectActivity register_project_activity = 42;
+        UpdateWorktree update_worktree = 43;
+        UpdateWorktreeExtensions update_worktree_extensions = 44;
+
+        CreateProjectEntry create_project_entry = 45;
+        RenameProjectEntry rename_project_entry = 46;
+        CopyProjectEntry copy_project_entry = 47;
+        DeleteProjectEntry delete_project_entry = 48;
+        ProjectEntryResponse project_entry_response = 49;
+
+        UpdateDiagnosticSummary update_diagnostic_summary = 50;
+        StartLanguageServer start_language_server = 51;
+        UpdateLanguageServer update_language_server = 52;
+
+        OpenBufferById open_buffer_by_id = 53;
+        OpenBufferByPath open_buffer_by_path = 54;
+        OpenBufferResponse open_buffer_response = 55;
+        CreateBufferForPeer create_buffer_for_peer = 56;
+        UpdateBuffer update_buffer = 57;
+        UpdateBufferFile update_buffer_file = 58;
+        SaveBuffer save_buffer = 59;
+        BufferSaved buffer_saved = 60;
+        BufferReloaded buffer_reloaded = 61;
+        ReloadBuffers reload_buffers = 62;
+        ReloadBuffersResponse reload_buffers_response = 63;
+        FormatBuffers format_buffers = 64;
+        FormatBuffersResponse format_buffers_response = 65;
+        GetCompletions get_completions = 66;
+        GetCompletionsResponse get_completions_response = 67;
+        ApplyCompletionAdditionalEdits apply_completion_additional_edits = 68;
+        ApplyCompletionAdditionalEditsResponse apply_completion_additional_edits_response = 69;
+        GetCodeActions get_code_actions = 70;
+        GetCodeActionsResponse get_code_actions_response = 71;
+        GetHover get_hover = 72;
+        GetHoverResponse get_hover_response = 73;
+        ApplyCodeAction apply_code_action = 74;
+        ApplyCodeActionResponse apply_code_action_response = 75;
+        PrepareRename prepare_rename = 76;
+        PrepareRenameResponse prepare_rename_response = 77;
+        PerformRename perform_rename = 78;
+        PerformRenameResponse perform_rename_response = 79;
+        SearchProject search_project = 80;
+        SearchProjectResponse search_project_response = 81;
+
+        GetChannels get_channels = 82;
+        GetChannelsResponse get_channels_response = 83;
+        JoinChannel join_channel = 84;
+        JoinChannelResponse join_channel_response = 85;
+        LeaveChannel leave_channel = 86;
+        SendChannelMessage send_channel_message = 87;
+        SendChannelMessageResponse send_channel_message_response = 88;
+        ChannelMessageSent channel_message_sent = 89;
+        GetChannelMessages get_channel_messages = 90;
+        GetChannelMessagesResponse get_channel_messages_response = 91;
+
+        UpdateContacts update_contacts = 92;
+        UpdateInviteInfo update_invite_info = 93;
+        ShowContacts show_contacts = 94;
+
+        GetUsers get_users = 95;
+        FuzzySearchUsers fuzzy_search_users = 96;
+        UsersResponse users_response = 97;
+        RequestContact request_contact = 98;
+        RespondToContactRequest respond_to_contact_request = 99;
+        RemoveContact remove_contact = 100;
+
+        Follow follow = 101;
+        FollowResponse follow_response = 102;
+        UpdateFollowers update_followers = 103;
+        Unfollow unfollow = 104;
+        GetPrivateUserInfo get_private_user_info = 105;
+        GetPrivateUserInfoResponse get_private_user_info_response = 106;
+        UpdateDiffBase update_diff_base = 107;
     }
 }
 
 // Messages
 
+message Hello {
+    uint32 peer_id = 1;
+}
+
 message Ping {}
 
 message Ack {}
@@ -266,6 +271,7 @@ message UpdateWorktree {
     repeated uint64 removed_entries = 5;
     uint64 scan_id = 6;
     bool is_last_update = 7;
+    bytes abs_path = 8;
 }
 
 message UpdateWorktreeExtensions {
@@ -908,6 +914,7 @@ message SelectionSet {
     repeated Selection selections = 2;
     uint32 lamport_timestamp = 3;
     bool line_mode = 4;
+    CursorShape cursor_shape = 5;
 }
 
 message Selection {
@@ -917,6 +924,13 @@ message Selection {
     bool reversed = 4;
 }
 
+enum CursorShape {
+    CursorBar = 0;
+    CursorBlock = 1;
+    CursorUnderscore = 2;
+    CursorHollow = 3;
+}
+
 message Anchor {
     uint32 replica_id = 1;
     uint32 local_timestamp = 2;
@@ -982,6 +996,7 @@ message Operation {
         uint32 lamport_timestamp = 2;
         repeated Selection selections = 3;
         bool line_mode = 4;
+        CursorShape cursor_shape = 5;
     }
 
     message UpdateCompletionTriggers {
@@ -1052,6 +1067,7 @@ message WorktreeMetadata {
     uint64 id = 1;
     string root_name = 2;
     bool visible = 3;
+    bytes abs_path = 4;
 }
 
 message UpdateDiffBase {
diff --git a/crates/rpc/src/proto.rs b/crates/rpc/src/proto.rs
index 069fde4e59638d25673b6c517c6e9b7c776d8a38..11bbaaf5ffcbdeff96906033b1cacae6f62e48f0 100644
--- a/crates/rpc/src/proto.rs
+++ b/crates/rpc/src/proto.rs
@@ -121,6 +121,7 @@ messages!(
     (GetProjectSymbols, Background),
     (GetProjectSymbolsResponse, Background),
     (GetUsers, Foreground),
+    (Hello, Foreground),
     (IncomingCall, Foreground),
     (UsersResponse, Foreground),
     (JoinChannel, Foreground),
@@ -435,6 +436,7 @@ pub fn split_worktree_update(
             project_id: message.project_id,
             worktree_id: message.worktree_id,
             root_name: message.root_name.clone(),
+            abs_path: message.abs_path.clone(),
             updated_entries,
             removed_entries: mem::take(&mut message.removed_entries),
             scan_id: message.scan_id,
diff --git a/crates/rpc/src/rpc.rs b/crates/rpc/src/rpc.rs
index 5fb9ca79a2c51e7930eb88bdb96d2c949eb3a5f0..c11caab108ea722d5abba800a1c836d05cbfcd4e 100644
--- a/crates/rpc/src/rpc.rs
+++ b/crates/rpc/src/rpc.rs
@@ -6,4 +6,4 @@ pub use conn::Connection;
 pub use peer::*;
 mod macros;
 
-pub const PROTOCOL_VERSION: u32 = 35;
+pub const PROTOCOL_VERSION: u32 = 38;
diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs
index a43f3eb4867c7c9b1e27f1db278009cce26a6fcf..cd7a74ce8e3233f0d5b4404a3bc597ae4271b6a6 100644
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -82,7 +82,7 @@ impl View for BufferSearchBar {
         "BufferSearchBar"
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.query_editor);
         }
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index eb5bf7d699480e9a240f93718f169f1979d0549f..8eb8e110e460972ada29f41f38150d5f8c08785f 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -195,7 +195,7 @@ impl View for ProjectSearchView {
         }
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         let handle = cx.weak_handle();
         cx.update_global(|state: &mut ActiveSearches, cx| {
             state
diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs
index 63bc5962fa0bba24e6cc0875793f96643f17cfe4..ee389c7a0efc3d3f6dc36ef526225dec0e4ec448 100644
--- a/crates/settings/src/settings.rs
+++ b/crates/settings/src/settings.rs
@@ -28,6 +28,7 @@ pub struct Settings {
     pub buffer_font_family: FamilyId,
     pub default_buffer_font_size: f32,
     pub buffer_font_size: f32,
+    pub cursor_blink: bool,
     pub hover_popover_enabled: bool,
     pub show_completions_on_input: bool,
     pub vim_mode: bool,
@@ -234,6 +235,8 @@ pub struct SettingsFileContent {
     #[serde(default)]
     pub buffer_font_size: Option<f32>,
     #[serde(default)]
+    pub cursor_blink: Option<bool>,
+    #[serde(default)]
     pub hover_popover_enabled: Option<bool>,
     #[serde(default)]
     pub show_completions_on_input: Option<bool>,
@@ -292,6 +295,7 @@ impl Settings {
                 .unwrap(),
             buffer_font_size: defaults.buffer_font_size.unwrap(),
             default_buffer_font_size: defaults.buffer_font_size.unwrap(),
+            cursor_blink: defaults.cursor_blink.unwrap(),
             hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
             show_completions_on_input: defaults.show_completions_on_input.unwrap(),
             projects_online_by_default: defaults.projects_online_by_default.unwrap(),
@@ -346,6 +350,7 @@ impl Settings {
         );
         merge(&mut self.buffer_font_size, data.buffer_font_size);
         merge(&mut self.default_buffer_font_size, data.buffer_font_size);
+        merge(&mut self.cursor_blink, data.cursor_blink);
         merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
         merge(
             &mut self.show_completions_on_input,
@@ -436,6 +441,7 @@ impl Settings {
             buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
             buffer_font_size: 14.,
             default_buffer_font_size: 14.,
+            cursor_blink: true,
             hover_popover_enabled: true,
             show_completions_on_input: true,
             vim_mode: false,
diff --git a/crates/terminal/Cargo.toml b/crates/terminal/Cargo.toml
index 61dcc60b60a5e5e54e4e13ed0ace8c576b44dfb2..785cf3365b9e62afbd076147f1f23d947b9757d9 100644
--- a/crates/terminal/Cargo.toml
+++ b/crates/terminal/Cargo.toml
@@ -8,16 +8,17 @@ path = "src/terminal.rs"
 doctest = false
 
 [dependencies]
-alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "a51dbe25d67e84d6ed4261e640d3954fbdd9be45" }
-procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false }
+context_menu = { path = "../context_menu" }
 editor = { path = "../editor" }
-util = { path = "../util" }
+language = { path = "../language" }
 gpui = { path = "../gpui" }
-theme = { path = "../theme" }
+project = { path = "../project" }
 settings = { path = "../settings" }
+theme = { path = "../theme" }
+util = { path = "../util" }
 workspace = { path = "../workspace" }
-project = { path = "../project" }
-context_menu = { path = "../context_menu" }
+alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "a51dbe25d67e84d6ed4261e640d3954fbdd9be45" }
+procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false }
 smallvec = { version = "1.6", features = ["union"] }
 smol = "1.2.5"
 mio-extras = "2.0.6"
diff --git a/crates/terminal/src/mappings/mouse.rs b/crates/terminal/src/mappings/mouse.rs
index 1616540cff65aaa245551ef7a2da37f7da2b4613..2254eea5af0965351c61adc7e0fe1e7baab40097 100644
--- a/crates/terminal/src/mappings/mouse.rs
+++ b/crates/terminal/src/mappings/mouse.rs
@@ -6,7 +6,7 @@ use alacritty_terminal::grid::Dimensions;
 /// with modifications for our circumstances
 use alacritty_terminal::index::{Column as GridCol, Line as GridLine, Point, Side};
 use alacritty_terminal::term::TermMode;
-use gpui::scene::ScrollWheelRegionEvent;
+use gpui::scene::MouseScrollWheel;
 use gpui::{geometry::vector::Vector2F, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
 
 use crate::TerminalSize;
@@ -115,7 +115,7 @@ impl MouseButton {
 pub fn scroll_report(
     point: Point,
     scroll_lines: i32,
-    e: &ScrollWheelRegionEvent,
+    e: &MouseScrollWheel,
     mode: TermMode,
 ) -> Option<impl Iterator<Item = Vec<u8>>> {
     if mode.intersects(TermMode::MOUSE_MODE) {
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index 5715d4b152ad25f8822899d0b12bd1bddc47e5d1..2c9135d3314c8a95ecb8e42da5b8545c24fb66c7 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -53,7 +53,7 @@ use thiserror::Error;
 use gpui::{
     geometry::vector::{vec2f, Vector2F},
     keymap::Keystroke,
-    scene::{DownRegionEvent, DragRegionEvent, ScrollWheelRegionEvent, UpRegionEvent},
+    scene::{MouseDown, MouseDrag, MouseScrollWheel, MouseUp},
     ClipboardItem, Entity, ModelContext, MouseButton, MouseMovedEvent, MutableAppContext, Task,
 };
 
@@ -971,7 +971,7 @@ impl Terminal {
         }
     }
 
-    pub fn mouse_drag(&mut self, e: DragRegionEvent, origin: Vector2F) {
+    pub fn mouse_drag(&mut self, e: MouseDrag, origin: Vector2F) {
         let position = e.position.sub(origin);
         self.last_mouse_position = Some(position);
 
@@ -997,7 +997,7 @@ impl Terminal {
         }
     }
 
-    fn drag_line_delta(&mut self, e: DragRegionEvent) -> Option<f32> {
+    fn drag_line_delta(&mut self, e: MouseDrag) -> Option<f32> {
         //TODO: Why do these need to be doubled? Probably the same problem that the IME has
         let top = e.region.origin_y() + (self.last_content.size.line_height * 2.);
         let bottom = e.region.lower_left().y() - (self.last_content.size.line_height * 2.);
@@ -1011,7 +1011,7 @@ impl Terminal {
         Some(scroll_delta)
     }
 
-    pub fn mouse_down(&mut self, e: &DownRegionEvent, origin: Vector2F) {
+    pub fn mouse_down(&mut self, e: &MouseDown, origin: Vector2F) {
         let position = e.position.sub(origin);
         let point = grid_point(
             position,
@@ -1050,7 +1050,7 @@ impl Terminal {
         }
     }
 
-    pub fn mouse_up(&mut self, e: &UpRegionEvent, origin: Vector2F, cx: &mut ModelContext<Self>) {
+    pub fn mouse_up(&mut self, e: &MouseUp, origin: Vector2F, cx: &mut ModelContext<Self>) {
         let settings = cx.global::<Settings>();
         let copy_on_select = settings
             .terminal_overrides
@@ -1095,7 +1095,7 @@ impl Terminal {
     }
 
     ///Scroll the terminal
-    pub fn scroll_wheel(&mut self, e: ScrollWheelRegionEvent, origin: Vector2F) {
+    pub fn scroll_wheel(&mut self, e: MouseScrollWheel, origin: Vector2F) {
         let mouse_mode = self.mouse_mode(e.shift);
 
         if let Some(scroll_lines) = self.determine_scroll_lines(&e, mouse_mode) {
@@ -1134,11 +1134,7 @@ impl Terminal {
         self.hyperlink_from_position(self.last_mouse_position);
     }
 
-    fn determine_scroll_lines(
-        &mut self,
-        e: &ScrollWheelRegionEvent,
-        mouse_mode: bool,
-    ) -> Option<i32> {
+    fn determine_scroll_lines(&mut self, e: &MouseScrollWheel, mouse_mode: bool) -> Option<i32> {
         let scroll_multiplier = if mouse_mode { 1. } else { SCROLL_MULTIPLIER };
 
         match e.phase {
diff --git a/crates/terminal/src/terminal_container_view.rs b/crates/terminal/src/terminal_container_view.rs
index 66219752851f11178c5959f9502dc9366dbdcb65..6ee8bc78ae18cd68574dbd96bf06e35155a9c668 100644
--- a/crates/terminal/src/terminal_container_view.rs
+++ b/crates/terminal/src/terminal_container_view.rs
@@ -165,7 +165,7 @@ impl View for TerminalContainer {
         .boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(self.content.handle());
         }
diff --git a/crates/terminal/src/terminal_element.rs b/crates/terminal/src/terminal_element.rs
index f14b49b6c4261135077789409adb3036ca79b2b4..adfcb47024c91c79e420edbad98101599745bcfb 100644
--- a/crates/terminal/src/terminal_element.rs
+++ b/crates/terminal/src/terminal_element.rs
@@ -4,7 +4,7 @@ use alacritty_terminal::{
     index::Point,
     term::{cell::Flags, TermMode},
 };
-use editor::{Cursor, CursorShape, HighlightedRange, HighlightedRangeLine};
+use editor::{Cursor, HighlightedRange, HighlightedRangeLine};
 use gpui::{
     color::Color,
     elements::{Empty, Overlay},
@@ -15,11 +15,11 @@ use gpui::{
     },
     serde_json::json,
     text_layout::{Line, RunStyle},
-    Element, ElementBox, Event, EventContext, FontCache, KeyDownEvent, ModelContext, MouseButton,
-    MouseRegion, PaintContext, Quad, SizeConstraint, TextLayoutCache, WeakModelHandle,
-    WeakViewHandle,
+    Element, ElementBox, EventContext, FontCache, ModelContext, MouseButton, MouseRegion,
+    PaintContext, Quad, SizeConstraint, TextLayoutCache, WeakModelHandle, WeakViewHandle,
 };
 use itertools::Itertools;
+use language::CursorShape;
 use ordered_float::OrderedFloat;
 use settings::Settings;
 use theme::TerminalStyle;
@@ -788,46 +788,6 @@ impl Element for TerminalElement {
         });
     }
 
-    fn dispatch_event(
-        &mut self,
-        event: &gpui::Event,
-        _bounds: gpui::geometry::rect::RectF,
-        _visible_bounds: gpui::geometry::rect::RectF,
-        _layout: &mut Self::LayoutState,
-        _paint: &mut Self::PaintState,
-        cx: &mut gpui::EventContext,
-    ) -> bool {
-        if let Event::KeyDown(KeyDownEvent { keystroke, .. }) = event {
-            if !cx.is_parent_view_focused() {
-                return false;
-            }
-
-            if let Some(view) = self.view.upgrade(cx.app) {
-                view.update(cx.app, |view, cx| {
-                    view.clear_bel(cx);
-                    view.pause_cursor_blinking(cx);
-                })
-            }
-
-            self.terminal
-                .upgrade(cx.app)
-                .map(|model_handle| {
-                    model_handle.update(cx.app, |term, cx| {
-                        term.try_keystroke(
-                            keystroke,
-                            cx.global::<Settings>()
-                                .terminal_overrides
-                                .option_as_meta
-                                .unwrap_or(false),
-                        )
-                    })
-                })
-                .unwrap_or(false)
-        } else {
-            false
-        }
-    }
-
     fn metadata(&self) -> Option<&dyn std::any::Any> {
         None
     }
diff --git a/crates/terminal/src/terminal_view.rs b/crates/terminal/src/terminal_view.rs
index 063d68d336367921750199c3eb0e71ebb8dd24f3..21e055319af62bfa42b168635fdbb5129c061492 100644
--- a/crates/terminal/src/terminal_view.rs
+++ b/crates/terminal/src/terminal_view.rs
@@ -38,18 +38,7 @@ pub struct SendKeystroke(String);
 
 actions!(
     terminal,
-    [
-        Up,
-        Down,
-        CtrlC,
-        Escape,
-        Enter,
-        Clear,
-        Copy,
-        Paste,
-        ShowCharacterPalette,
-        SearchTest
-    ]
+    [Clear, Copy, Paste, ShowCharacterPalette, SearchTest]
 );
 
 impl_actions!(terminal, [SendText, SendKeystroke]);
@@ -342,20 +331,35 @@ impl View for TerminalView {
             .boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         self.has_new_content = false;
         self.terminal.read(cx).focus_in();
         self.blink_cursors(self.blink_epoch, cx);
         cx.notify();
     }
 
-    fn on_focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         self.terminal.update(cx, |terminal, _| {
             terminal.focus_out();
         });
         cx.notify();
     }
 
+    fn key_down(&mut self, event: &gpui::KeyDownEvent, cx: &mut ViewContext<Self>) -> bool {
+        self.clear_bel(cx);
+        self.pause_cursor_blinking(cx);
+
+        self.terminal.update(cx, |term, cx| {
+            term.try_keystroke(
+                &event.keystroke,
+                cx.global::<Settings>()
+                    .terminal_overrides
+                    .option_as_meta
+                    .unwrap_or(false),
+            )
+        })
+    }
+
     //IME stuff
     fn selected_text_range(&self, cx: &AppContext) -> Option<std::ops::Range<usize>> {
         if self
diff --git a/crates/theme_selector/src/theme_selector.rs b/crates/theme_selector/src/theme_selector.rs
index 3236120857e229514eef37c251fa42aca8ec8b37..1caeae75f597050f145b8ebc36aa3a0b827261fc 100644
--- a/crates/theme_selector/src/theme_selector.rs
+++ b/crates/theme_selector/src/theme_selector.rs
@@ -266,7 +266,7 @@ impl View for ThemeSelector {
         ChildView::new(self.picker.clone(), cx).boxed()
     }
 
-    fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.picker);
         }
diff --git a/crates/vim/src/state.rs b/crates/vim/src/state.rs
index fef0da209996289ac1ac11171951918fe03ae9ee..b5acb50e7c04e945660187438096aa84be6405dc 100644
--- a/crates/vim/src/state.rs
+++ b/crates/vim/src/state.rs
@@ -1,5 +1,5 @@
-use editor::CursorShape;
 use gpui::keymap::Context;
+use language::CursorShape;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 81bafcf3e27f7f850aa89863c1c8f404a3e9b3f8..ce3a7e2366ae8279e877d94bf8e48bdcca6394b2 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -12,8 +12,9 @@ mod visual;
 
 use collections::HashMap;
 use command_palette::CommandPaletteFilter;
-use editor::{Bias, Cancel, CursorShape, Editor};
+use editor::{Bias, Cancel, Editor};
 use gpui::{impl_actions, MutableAppContext, Subscription, ViewContext, WeakViewHandle};
+use language::CursorShape;
 use serde::Deserialize;
 
 use settings::Settings;
diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index b7ae7f2ba0b867dd7b57b9c9ed77fd2a9077ef29..882b501d2e59c3414589713d17c6752a9f69351c 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1485,7 +1485,7 @@ impl View for Pane {
             .named("pane")
     }
 
-    fn on_focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if let Some(active_item) = self.active_item() {
             if cx.is_self_focused() {
                 // Pane was focused directly. We need to either focus a view inside the active item,
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index ece8cedfb1e516f8ff66fc8c76b3814c0fabd85b..b9155220f6d959a57ad9b9bd68fbadcb047cb632 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -927,6 +927,9 @@ impl From<&dyn NotificationHandle> for AnyViewHandle {
 impl AppState {
     #[cfg(any(test, feature = "test-support"))]
     pub fn test(cx: &mut MutableAppContext) -> Arc<Self> {
+        use fs::HomeDir;
+
+        cx.set_global(HomeDir(Path::new("/tmp/").to_path_buf()));
         let settings = Settings::test(cx);
         cx.set_global(settings);
 
@@ -2656,7 +2659,7 @@ impl View for Workspace {
             .named("workspace")
     }
 
-    fn on_focus_in(&mut self, view: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, view: AnyViewHandle, cx: &mut ViewContext<Self>) {
         if cx.is_self_focused() {
             cx.focus(&self.active_pane);
         } else {
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index cc0a3b62fb9fc6752753f16fce999ba309bf7a4d..a2214f7dec16a6fd00b3e006d2bd886908a35217 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathansobo@gmail.com>"]
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.60.4"
+version = "0.61.0"
 
 [lib]
 name = "zed"
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index e17cbe558a7aa5288d3cfce1d7e498b83c0ed06a..c85a894415072f01beed34b4276f719e1472fcb0 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -23,7 +23,7 @@ use isahc::{config::Configurable, Request};
 use language::LanguageRegistry;
 use log::LevelFilter;
 use parking_lot::Mutex;
-use project::{Fs, ProjectStore};
+use project::{Fs, HomeDir, ProjectStore};
 use serde_json::json;
 use settings::{
     self, settings_file::SettingsFile, KeymapFileContent, Settings, SettingsFileContent,
@@ -52,11 +52,9 @@ fn main() {
         .or_else(|| app.platform().app_version().ok())
         .map_or("dev".to_string(), |v| v.to_string());
     init_panic_hook(app_version, http.clone(), app.background());
-    let db = app.background().spawn(async move {
-        project::Db::open(&*zed::paths::DB)
-            .log_err()
-            .unwrap_or_else(project::Db::null)
-    });
+    let db = app
+        .background()
+        .spawn(async move { project::Db::open(&*zed::paths::DB_DIR) });
 
     load_embedded_fonts(&app);
 
@@ -99,6 +97,8 @@ fn main() {
 
         let (settings_file_content, keymap_file) = cx.background().block(config_files).unwrap();
 
+        cx.set_global(HomeDir(zed::paths::HOME.to_path_buf()));
+
         //Setup settings global before binding actions
         cx.set_global(SettingsFile::new(
             &*zed::paths::SETTINGS,
diff --git a/crates/zed/src/paths.rs b/crates/zed/src/paths.rs
index d6d99288c771f5260d5cd452fc97a04f15c87969..8698d6891e18e7e3e960a210ec7b3f23e308da72 100644
--- a/crates/zed/src/paths.rs
+++ b/crates/zed/src/paths.rs
@@ -1,12 +1,11 @@
 use std::path::PathBuf;
 
 lazy_static::lazy_static! {
-    static ref HOME: PathBuf = dirs::home_dir().expect("failed to determine home directory");
+    pub static ref HOME: PathBuf = dirs::home_dir().expect("failed to determine home directory");
     pub static ref CONFIG_DIR: PathBuf = HOME.join(".config").join("zed");
     pub static ref LOGS_DIR: PathBuf = HOME.join("Library/Logs/Zed");
     pub static ref LANGUAGES_DIR: PathBuf = HOME.join("Library/Application Support/Zed/languages");
     pub static ref DB_DIR: PathBuf = HOME.join("Library/Application Support/Zed/db");
-    pub static ref DB: PathBuf = DB_DIR.join("zed.db");
     pub static ref SETTINGS: PathBuf = CONFIG_DIR.join("settings.json");
     pub static ref KEYMAP: PathBuf = CONFIG_DIR.join("keymap.json");
     pub static ref LAST_USERNAME: PathBuf = CONFIG_DIR.join("last-username.txt");
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index ef0c84909a28e229945917a3daa8c2c730323f1d..3319aebd09953d89e44a89c0961cd275f7dd6915 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -63,6 +63,7 @@ actions!(
         DecreaseBufferFontSize,
         ResetBufferFontSize,
         InstallCommandLineInterface,
+        ResetDatabase,
     ]
 );
 
diff --git a/script/changes-since-last-release b/script/changes-since-last-release
index 5d0f94db1269fb5670f228b97af4ca2fcf8a662c..23a65143b26ec4ac71d28edbf68a7174f57897fd 100755
--- a/script/changes-since-last-release
+++ b/script/changes-since-last-release
@@ -67,7 +67,7 @@ async function main() {
     console.log("  URL:    ", webURL);
 
     // If the pull request contains a 'closes' line, print the closed issue.
-    const fixesMatch = pullRequest.body.match(FIXES_REGEX);
+    const fixesMatch = (pullRequest.body || '').match(FIXES_REGEX);
     if (fixesMatch) {
       const fixedIssueURL = fixesMatch[2];
       console.log("  Issue: ", fixedIssueURL);