diff --git a/.cargo/config.toml b/.cargo/config.toml
index b016eca31aec5..ab4741fffe625 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,3 +1,17 @@
+# we use tokio_unstable to enable runtime::Handle::id so we can seperate
+# gloablsfrom mul1tiple parallel tests. If that function ever does get removed
+# its possible to replace (with some additional overhead and effort)
+# Annoyingly build.rustflags doesn't work here because it gets overwritten
+# if people have their own global target.<..> config (for examble to enable mold)
+# specificying flags this way is more robust as they get merged
+# This still gets overwritten by RUST_FLAGS tough, luckily it shouldn't be necessary
+# to set those most of the time. If downstream does overwrite this its not a huge
+# deal since it will only break tests anyway
+[target."cfg(all())"]
+rustflags = ["--cfg", "tokio_unstable", "-C", "target-feature=-crt-static"]
+
+
 [alias]
 xtask = "run --package xtask --"
 integration-test = "test --features integration --profile integration --workspace --test integration"
+
diff --git a/Cargo.lock b/Cargo.lock
index 8b8179f841e2d..34f3e7b9f6554 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1238,6 +1238,15 @@ dependencies = [
  "ahash 0.7.6",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+dependencies = [
+ "ahash 0.8.3",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.14.0"
@@ -1302,6 +1311,12 @@ dependencies = [
 name = "helix-event"
 version = "0.6.0"
 dependencies = [
+ "ahash 0.8.3",
+ "anyhow",
+ "futures-executor",
+ "hashbrown 0.13.2",
+ "log",
+ "once_cell",
  "parking_lot",
  "tokio",
 ]
diff --git a/helix-event/Cargo.toml b/helix-event/Cargo.toml
index 5cd955588960f..2065c114104b6 100644
--- a/helix-event/Cargo.toml
+++ b/helix-event/Cargo.toml
@@ -11,5 +11,18 @@ homepage = "https://helix-editor.com"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "parking_lot"] }
-parking_lot = { version = "0.12", features = ["send_guard"] }
+ahash = "0.8.3"
+hashbrown = "0.13.2"
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "parking_lot", "macros"] }
+# the event registry is essentially read only but must be an rwlock so we can
+# setup new events on intalization, hardware-lock-elision hugnly benefits this case
+# as is essentially makes the lock entirely free as long as there is no writes 
+parking_lot = { version = "0.12", features = ["hardware-lock-elision"] }
+once_cell = "1.18"
+
+anyhow = "1"
+log = "0.4"
+futures-executor = "0.3.28"
+
+[features]
+integration_test = []
diff --git a/helix-event/src/cancel.rs b/helix-event/src/cancel.rs
new file mode 100644
index 0000000000000..8af21fadf26cb
--- /dev/null
+++ b/helix-event/src/cancel.rs
@@ -0,0 +1,19 @@
+use std::future::Future;
+
+pub use oneshot::channel as cancelation;
+use tokio::sync::oneshot;
+
+pub type CancelTx = oneshot::Sender<()>;
+pub type CancelRx = oneshot::Receiver<()>;
+
+pub async fn canceable_future<T>(future: impl Future<Output = T>, cancel: CancelRx) -> Option<T> {
+    tokio::select! {
+        biased;
+        _ = cancel => {
+            None
+        }
+        res = future => {
+            Some(res)
+        }
+    }
+}
diff --git a/helix-event/src/debounce.rs b/helix-event/src/debounce.rs
new file mode 100644
index 0000000000000..435bed0429b67
--- /dev/null
+++ b/helix-event/src/debounce.rs
@@ -0,0 +1,62 @@
+//! Utilities for declaring an async (usually debounced) hook
+
+use std::time::Duration;
+
+use futures_executor::block_on;
+use tokio::sync::mpsc::{self, error::TrySendError, Sender};
+use tokio::time::Instant;
+
+/// Async hooks are the core of the event system, the m
+pub trait AsyncHook: Sync + Send + 'static + Sized {
+    type Event: Sync + Send + 'static;
+    /// Called immidietly whenever an event is received, this function can
+    /// consume the event immidietly or debounce it. In case of debouncing
+    /// it can either define a new debounce timeout or continue the current
+    fn handle_event(&mut self, event: Self::Event, timeout: Option<Instant>) -> Option<Instant>;
+
+    /// Called whenever the debounce timeline is searched
+    fn finish_debounce(&mut self);
+
+    fn spawn(self) -> mpsc::Sender<Self::Event> {
+        // the capaicity doesn't matter too much here, unless the cpu is totally overwhelmed
+        // the cap will never be reached sine we awalys immidietly drain the channel
+        // so is should only be reached in case of total CPU overload
+        // However, a bounded channel is much more efficient so its nice to use here
+        let (tx, rx) = mpsc::channel(128);
+        tokio::spawn(run(self, rx));
+        tx
+    }
+}
+
+async fn run<Hook: AsyncHook>(mut hook: Hook, mut rx: mpsc::Receiver<Hook::Event>) {
+    let mut deadline = None;
+    loop {
+        let event = match deadline {
+            Some(deadline_) => {
+                let res = tokio::time::timeout_at(deadline_, rx.recv()).await;
+                match res {
+                    Ok(event) => event,
+                    Err(_) => {
+                        hook.finish_debounce();
+                        deadline = None;
+                        continue;
+                    }
+                }
+            }
+            None => rx.recv().await,
+        };
+        let Some(event) = event else {
+            break;
+        };
+        deadline = hook.handle_event(event, deadline);
+    }
+}
+
+pub fn send_blocking<T>(tx: &Sender<T>, data: T) {
+    // block_on has some ovherhead and in practice the channel should basically
+    // never be full anyway so first try sending without blocking
+    if let Err(TrySendError::Full(data)) = tx.try_send(data) {
+        // set a timeout so that we just drop a message instead of freezing the editor in the worst case
+        block_on(tx.send_timeout(data, Duration::from_millis(10))).unwrap();
+    }
+}
diff --git a/helix-event/src/hook.rs b/helix-event/src/hook.rs
new file mode 100644
index 0000000000000..6727af3d8d85a
--- /dev/null
+++ b/helix-event/src/hook.rs
@@ -0,0 +1,86 @@
+//! rust dynamic dispatch is extremely limited so we have to build our
+//! own vtable implementation. Otherwise implementing the event system would not be possible
+//! A nice bonus of this approach is that we can optimize the vtable a bit more. Normally
+//! a dyn Trait fat pointer contains two pointers: A pointer to the data itself and a
+//! pointer to a global (static) vtable entry which itself contains multiple other pointers
+//! (the various functions of the trait, drop, size annd align). That makes dynamic
+//! dispatch pretty slow (double pointer indirections). However, we only have a single function
+//! in the hook trait and don't need adrop implementation (event system is global anyway
+//! and never dropped) so we can just store the entire vtable inline.
+
+use anyhow::Result;
+use std::ptr::{self, NonNull};
+
+use crate::{Event, Hook};
+
+/// Opaque handle type that represents an erased type parameter.
+///
+/// If extern types were stable, this could be implemented as `extern { pub type Opaque; }` but
+/// until then we can use this.
+///
+/// Care should be taken that we don't use a concrete instance of this. It should only be used
+/// through a reference, so we can maintain something else's lifetime.
+struct Opaque(());
+
+pub(crate) struct ErasedHook {
+    data: NonNull<Opaque>,
+    call: unsafe fn(NonNull<Opaque>, NonNull<Opaque>, NonNull<Opaque>),
+}
+
+impl ErasedHook {
+    pub(crate) fn new_dynamic<H: Fn() + Sync + Send + 'static>(hook: H) -> ErasedHook {
+        unsafe fn call<H: Fn()>(
+            hook: NonNull<Opaque>,
+            _event: NonNull<Opaque>,
+            _result: NonNull<Opaque>,
+        ) {
+            let hook: NonNull<H> = hook.cast();
+            let hook: &H = hook.as_ref();
+            (hook)()
+        }
+
+        unsafe {
+            ErasedHook {
+                data: NonNull::new_unchecked(Box::into_raw(Box::new(hook)) as *mut Opaque),
+                call: call::<H>,
+            }
+        }
+    }
+
+    pub(crate) fn new<H: Hook>(hook: H) -> ErasedHook {
+        unsafe fn call<H: Hook>(
+            hook: NonNull<Opaque>,
+            event: NonNull<Opaque>,
+            result: NonNull<Opaque>,
+        ) {
+            let hook: NonNull<H> = hook.cast();
+            let mut event: NonNull<H::Event<'static>> = event.cast();
+            let result: NonNull<Result<()>> = result.cast();
+            let res = H::run(hook.as_ref(), event.as_mut());
+            ptr::write(result.as_ptr(), res)
+        }
+
+        unsafe {
+            ErasedHook {
+                data: NonNull::new_unchecked(Box::into_raw(Box::new(hook)) as *mut Opaque),
+                call: call::<H>,
+            }
+        }
+    }
+
+    pub(crate) unsafe fn call<'a, E: Event<'a>>(&self, event: &mut E) -> Result<()> {
+        let mut res = Ok(());
+
+        unsafe {
+            (self.call)(
+                self.data,
+                NonNull::from(event).cast(),
+                NonNull::from(&mut res).cast(),
+            );
+        }
+        res
+    }
+}
+
+unsafe impl Sync for ErasedHook {}
+unsafe impl Send for ErasedHook {}
diff --git a/helix-event/src/lib.rs b/helix-event/src/lib.rs
index 9c082b93a4748..a1426e7cded03 100644
--- a/helix-event/src/lib.rs
+++ b/helix-event/src/lib.rs
@@ -1,8 +1,147 @@
 //! `helix-event` contains systems that allow (often async) communication between
-//! different editor components without strongly coupling them. Currently this
-//! crate only contains some smaller facilities but the intend is to add more
-//! functionality in the future ( like a generic hook system)
+//! different editor components without strongly coupling them. Specifically
+//! it allows defining synchronous hooks that run when certain editor events
+//! occurs.
+//!
+//! The core of the event system is the [`Hook`] trait. A hook is essentially
+//! just a closure `Fn(event: &mut impl Event) -> Result<()>`. This can currently
+//! not be represented in the rust type system with closures (it requires second
+//! order generics). Instead we use generic associated types to represent that
+//! invariant so a custom type is always required.
+//!
+//! The [`Event`] trait is unsafe because upon dispatch event lifetimes are
+//! essentially erased. To ensure safety all lifetime parameters of the event
+//! must oulife the lifetime Parameter of the event trait. To avoid worrying about
+//! that (and spreading unsafe everywhere) the [`events`] macro is provided which
+//! automatically declares event types.
+//!
+//! Hooks run synchronously which can be advantageous since they can modify the
+//! current editor state right away (for example to immidietly hide the completion
+//! popup). However, they can not contain their own state without locking since
+//! they only receive immutable references. For handler that want to track state, do
+//! expensive background computations or debouncing an [`AsyncHook`] is preferable.
+//! Async hooks are based around a channels that receive events specific to
+//! that `AsyncHook` (usually an enum). These events can be send by synchronous
+//! [`Hook`]s. Due to some limtations around tokio channels the [`send_blocking`]
+//! function exported in this crate should be used instead of the builtin
+//! `blocking_send`.
+//!
+//! In addition to the core event system, this crate contains some message queues
+//! that allow transfer of data back to the main event loop from async hooks and
+//! hooks that may not have access to all application data (for example in helix-view).
+//! This include the ability to control rendering ([`lock_frame`], [`request_redraw`]) and
+//! display status messages ([`status`]).
+//!
+//! Hooks declared in helix-term can furthermore dispatch synchronous jobs to be run on the
+//! main loop (including access to the compositor). Ideally that queue will be moved
+//! to helix-view in the future if we manage to detch the comositor from its rendering backgend.
 
+use anyhow::Result;
+pub use cancel::{canceable_future, cancelation, CancelRx, CancelTx};
+pub use debounce::{send_blocking, AsyncHook};
 pub use redraw::{lock_frame, redraw_requested, request_redraw, start_frame, RenderLockGuard};
+pub use registry::Event;
 
+mod cancel;
+mod debounce;
+mod hook;
 mod redraw;
+mod registry;
+#[doc(hidden)]
+pub mod runtime;
+pub mod status;
+
+#[cfg(test)]
+mod test;
+
+/// A hook is a colsure that will be automatically callen whenever
+/// an `Event` of the associated function is [dispatched](crate::dispatch)
+/// is called. The closure must be generic over the lifetime of the event.
+pub trait Hook: Sized + Sync + Send + 'static {
+    type Event<'a>: Event<'a>;
+    fn run(&self, _event: &mut Self::Event<'_>) -> Result<()>;
+}
+
+pub fn register_event<E: Event<'static>>() {
+    registry::with_mut(|registry| registry.register_event::<E>())
+}
+
+pub fn register_hook(hook: impl Hook) {
+    registry::with_mut(|registry| registry.register_hook(hook))
+}
+
+pub fn register_dynamic_hook<H: Fn() + Sync + Send + 'static>(hook: H, id: &str) -> Result<()> {
+    registry::with_mut(|reg| reg.register_dynamic_hook(hook, id))
+}
+
+pub fn dispatch<'a>(e: impl Event<'a>) {
+    registry::with(|registry| registry.dispatch(e));
+}
+
+/// Macro to delclare events
+///
+/// # Examples
+///
+/// ``` no-compile
+/// events! {
+///     FileWrite(&Path)
+///     ViewScrolled{ view: View, new_pos: ViewOffset }
+///     DocumentChanged<'a> { old_doc: &'a Rope, doc: &'a mut Document, changes: &'a ChangSet  }
+/// }
+///
+/// fn init() {
+///    register_event::<FileWrite>();
+///    register_event::<ViewScrolled>();
+///    register_event::<InsertChar>();
+///    register_event::<DocumentChanged>();
+/// }
+///
+/// fn save(path: &Path, content: &str){
+///     std::fs::write(path, content);
+///     dispach(FilWrite(path));
+/// }
+/// ```
+#[macro_export]
+macro_rules! events {
+    ($name: ident($($data: ty),*) $($rem:tt)*) => {
+        pub struct $name($(pub $data),*);
+        unsafe impl<'a>  $crate::Event<'a> for $name {
+            const ID: &'static str = stringify!($name);
+            type Static = Self;
+        }
+        $crate::events!{ $($rem)* }
+    };
+    ($name: ident<$lt: lifetime>($(pub $data: ty),*) $($rem:tt)*) => {
+        pub struct $name<$lt>($($data),*);
+        unsafe impl<$lt> $crate::Event<$lt> for $name<$lt> {
+            const ID: &'static str = stringify!($name);
+            type Static = $name<'static>;
+        }
+        $crate::events!{ $($rem)* }
+    };
+    ($name: ident<$lt: lifetime> { $($data:ident : $data_ty:ty),* } $($rem:tt)*) => {
+        pub struct $name<$lt> { $(pub $data: $data_ty),* }
+        unsafe impl<$lt> $crate::Event<$lt> for $name<$lt> {
+            const ID: &'static str = stringify!($name);
+            type Static = $name<'static>;
+        }
+        $crate::events!{ $($rem)* }
+    };
+   ($name: ident<$lt1: lifetime, $lt2: lifetime> { $($data:ident : $data_ty:ty),* } $($rem:tt)*) => {
+        pub struct $name<$lt1, $lt2> { $(pub $data: $data_ty),* }
+        unsafe impl<$lt1, $lt2: $lt1> $crate::Event<$lt1> for $name<$lt1, $lt2> {
+            const ID: &'static str = stringify!($name);
+            type Static = $name<'static, 'static>;
+        }
+        $crate::events!{ $($rem)* }
+    };
+    ($name: ident { $($data:ident : $data_ty:ty),* } $($rem:tt)*) => {
+        pub struct $name { $(pub $data: $data_ty),* }
+        unsafe impl<'a> $crate::Event<'a> for $name {
+            const ID: &'static str = stringify!($name);
+            type Static = Self;
+        }
+        $crate::events!{ $($rem)* }
+    };
+    () => {};
+}
diff --git a/helix-event/src/redraw.rs b/helix-event/src/redraw.rs
index a9915223887ba..72817d57c3ef4 100644
--- a/helix-event/src/redraw.rs
+++ b/helix-event/src/redraw.rs
@@ -5,16 +5,20 @@ use std::future::Future;
 use parking_lot::{RwLock, RwLockReadGuard};
 use tokio::sync::Notify;
 
-/// A `Notify` instance that can be used to (asynchronously) request
-/// the editor the render a new frame.
-static REDRAW_NOTIFY: Notify = Notify::const_new();
-
-/// A `RwLock` that prevents the next frame from being
-/// drawn until an exclusive (write) lock can be acquired.
-/// This allows asynchsonous tasks to acquire `non-exclusive`
-/// locks (read) to prevent the next frame from being drawn
-/// until a certain computation has finished.
-static RENDER_LOCK: RwLock<()> = RwLock::new(());
+use crate::runtime_local;
+
+runtime_local! {
+    /// A `Notify` instance that can be used to (asynchronously) request
+    /// the editor the render a new frame.
+    static REDRAW_NOTIFY: Notify = Notify::const_new();
+
+    /// A `RwLock` that prevents the next frame from being
+    /// drawn until an exclusive (write) lock can be acquired.
+    /// This allows asynchsonous tasks to acquire `non-exclusive`
+    /// locks (read) to prevent the next frame from being drawn
+    /// until a certain computation has finished.
+    static RENDER_LOCK: RwLock<()> = RwLock::new(());
+}
 
 pub type RenderLockGuard = RwLockReadGuard<'static, ()>;
 
diff --git a/helix-event/src/registry.rs b/helix-event/src/registry.rs
new file mode 100644
index 0000000000000..55ddd34e75efc
--- /dev/null
+++ b/helix-event/src/registry.rs
@@ -0,0 +1,118 @@
+//! A global registry where events are registered and can be
+//! subsribed to by registering hooks. The registry identifies event
+//! types using their type name so multiple event with the same type name
+//! may not be registered (will cause a panic to ensure soudness)
+
+use std::any::TypeId;
+
+use anyhow::{bail, Result};
+use hashbrown::hash_map::Entry;
+use hashbrown::HashMap;
+use parking_lot::RwLock;
+
+use crate::hook::ErasedHook;
+use crate::{runtime_local, Hook};
+
+pub struct Registry {
+    events: HashMap<&'static str, TypeId, ahash::RandomState>,
+    handlers: HashMap<&'static str, Vec<ErasedHook>, ahash::RandomState>,
+}
+
+impl Registry {
+    pub fn register_event<E: Event<'static>>(&mut self) {
+        let ty = TypeId::of::<E>();
+        assert_eq!(ty, TypeId::of::<E::Static>());
+        match self.events.entry(E::ID) {
+            Entry::Occupied(entry) => {
+                if entry.get() == &ty {
+                    // don't warn during tests to avoid log spam
+                    #[cfg(not(feature = "integration_test"))]
+                    log::warn!("Event {} was registered multiple times", E::ID);
+                } else {
+                    panic!("Multiple events with ID {} were registered", E::ID);
+                }
+            }
+            Entry::Vacant(ent) => {
+                ent.insert(ty);
+                self.handlers.insert(E::ID, Vec::new());
+            }
+        }
+    }
+
+    pub fn register_hook<H: Hook>(&mut self, hook: H) {
+        // ensure event type ids match so we can rely on them always matching
+        let id = H::Event::ID;
+        let Some(&event_id) = self.events.get(id) else {
+            panic!("Tried to register handler for unknown event {id}");
+        };
+        assert!(
+            TypeId::of::<H::Event<'static>>() == event_id,
+            "Tried to register invalid hook for event {id}"
+        );
+        let hook = ErasedHook::new(hook);
+        self.handlers.get_mut(id).unwrap().push(hook);
+    }
+
+    pub fn register_dynamic_hook<H: Fn() + Sync + Send + 'static>(
+        &mut self,
+        hook: H,
+        id: &str,
+    ) -> Result<()> {
+        // ensure event type ids match so we can rely on them always matching
+        if self.events.get(id).is_none() {
+            bail!("Tried to register handler for unknown event {id}");
+        };
+        let hook = ErasedHook::new_dynamic(hook);
+        self.handlers.get_mut(id).unwrap().push(hook);
+        Ok(())
+    }
+
+    pub fn dispatch<'a, E: Event<'a>>(&self, mut event: E) {
+        let Some(hooks) = self.handlers.get(E::ID) else {
+            log::error!("Dispatdhed unknown event {}", E::ID);
+            return;
+        };
+        let event_id = self.events[E::ID];
+
+        assert_eq!(
+            TypeId::of::<E::Static>(),
+            event_id,
+            "Tried to dispatch invalid event {}",
+            E::ID
+        );
+
+        for hook in hooks {
+            // safety: event type is the same
+            if let Err(err) = unsafe { hook.call(&mut event) } {
+                log::error!("{} hook failed: {err:#?}", E::ID);
+                crate::status::report_blocking(err);
+            }
+        }
+    }
+}
+
+runtime_local! {
+    static REGISTRY: RwLock<Registry> = RwLock::new(Registry {
+        // hardcoded random number is good enough here we don't care about DOS resistance
+        // and avoids the additional complexity of `Option<Registry>`
+        events: HashMap::with_hasher(ahash::RandomState::with_seeds(423, 9978, 38322, 3280080)),
+        handlers: HashMap::with_hasher(ahash::RandomState::with_seeds(423, 99078, 382322, 3282938)),
+    });
+}
+
+pub(crate) fn with<T>(f: impl FnOnce(&Registry) -> T) -> T {
+    f(&REGISTRY.read())
+}
+
+pub(crate) fn with_mut<T>(f: impl FnOnce(&mut Registry) -> T) -> T {
+    f(&mut REGISTRY.write())
+}
+
+/// # Safety
+/// This trait is safe to use but not safe to declare, use the events macro instead
+pub unsafe trait Event<'a>: Sized + 'a {
+    /// Globally unique (case sensitive)  sting that identifies this type.
+    /// A good candidate is the events type name
+    const ID: &'static str;
+    type Static: Event<'static>;
+}
diff --git a/helix-event/src/runtime.rs b/helix-event/src/runtime.rs
new file mode 100644
index 0000000000000..bbeabfa1f5b61
--- /dev/null
+++ b/helix-event/src/runtime.rs
@@ -0,0 +1,88 @@
+//! The event system makes use of global to decouple different systems.
+//! However, this can cause problems for the integration test system because
+//! it runs multiple helix applications in parallel. Making the globals
+//! thread-local does not work because a applications can/does have multiple
+//! runtime threads. Instead this crate implements a similar notion to a thread
+//! local but instead of being local to a single thread, the statics are local to
+//! a single tokio-runtime. The implementation requires locking so its not exactly efficient.
+//!
+//! Therefore this function is only enabled during integration tests and behaves like
+//! a normal static otherwise. I would prefer this module to be fully private and to only
+//! export the macro but the macro still need to construct these internals so its marked
+//! `doc(hidden)` instead
+
+use std::ops::Deref;
+
+#[cfg(not(feature = "integration_test"))]
+pub struct RuntimeLocal<T: 'static> {
+    /// inner API used in the macro, not part of public API
+    #[doc(hidden)]
+    pub __data: T,
+}
+
+#[cfg(not(feature = "integration_test"))]
+impl<T> Deref for RuntimeLocal<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.__data
+    }
+}
+
+#[cfg(not(feature = "integration_test"))]
+#[macro_export]
+macro_rules! runtime_local {
+    ($($(#[$attr:meta])* $vis: vis static $name:ident: $ty: ty = $init: expr;)*) => {
+        $($(#[$attr])* $vis static $name: $crate::runtime::RuntimeLocal<$ty> = $crate::runtime::RuntimeLocal {
+            __data: $init
+        };)*
+    };
+}
+
+#[cfg(feature = "integration_test")]
+pub struct RuntimeLocal<T: 'static> {
+    data:
+        parking_lot::RwLock<hashbrown::HashMap<tokio::runtime::Id, &'static T, ahash::RandomState>>,
+    init: fn() -> T,
+}
+
+#[cfg(feature = "integration_test")]
+impl<T> RuntimeLocal<T> {
+    /// inner API used in the macro, not part of public API
+    #[doc(hidden)]
+    pub const fn __new(init: fn() -> T) -> Self {
+        Self {
+            data: parking_lot::RwLock::new(hashbrown::HashMap::with_hasher(
+                ahash::RandomState::with_seeds(423, 9978, 38322, 3280080),
+            )),
+            init,
+        }
+    }
+}
+
+#[cfg(feature = "integration_test")]
+impl<T> Deref for RuntimeLocal<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        let id = tokio::runtime::Handle::current().id();
+        let guard = self.data.read();
+        match guard.get(&id) {
+            Some(res) => res,
+            None => {
+                drop(guard);
+                let data = Box::leak(Box::new((self.init)()));
+                let mut guard = self.data.write();
+                guard.insert(id, data);
+                data
+            }
+        }
+    }
+}
+
+#[cfg(feature = "integration_test")]
+#[macro_export]
+macro_rules! runtime_local {
+    ($($(#[$attr:meta])* $vis: vis static $name:ident: $ty: ty = $init: expr;)*) => {
+         $($(#[$attr])* $vis static $name: $crate::runtime::RuntimeLocal<$ty> = $crate::runtime::RuntimeLocal::__new(|| $init);)*
+    };
+}
diff --git a/helix-event/src/status.rs b/helix-event/src/status.rs
new file mode 100644
index 0000000000000..fdca676244cd2
--- /dev/null
+++ b/helix-event/src/status.rs
@@ -0,0 +1,68 @@
+//! A queue of async messages/errors that will be shown in the editor
+
+use std::borrow::Cow;
+use std::time::Duration;
+
+use crate::{runtime_local, send_blocking};
+use once_cell::sync::OnceCell;
+use tokio::sync::mpsc::{Receiver, Sender};
+
+/// Describes the severity level of a [`StatusMessage`].
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
+pub enum Severity {
+    Hint,
+    Info,
+    Warning,
+    Error,
+}
+
+pub struct StatusMessage {
+    pub severity: Severity,
+    pub message: Cow<'static, str>,
+}
+
+impl From<anyhow::Error> for StatusMessage {
+    fn from(err: anyhow::Error) -> Self {
+        StatusMessage {
+            severity: Severity::Error,
+            message: err.to_string().into(),
+        }
+    }
+}
+
+impl From<&'static str> for StatusMessage {
+    fn from(msg: &'static str) -> Self {
+        StatusMessage {
+            severity: Severity::Info,
+            message: msg.into(),
+        }
+    }
+}
+
+runtime_local! {
+    static MESSAGES: OnceCell<Sender<StatusMessage>> = OnceCell::new();
+}
+
+pub async fn report(msg: impl Into<StatusMessage>) {
+    // if the error channel overflows just ignore it
+    let _ = MESSAGES
+        .wait()
+        .send_timeout(msg.into(), Duration::from_millis(10))
+        .await;
+}
+
+pub fn report_blocking(msg: impl Into<StatusMessage>) {
+    let messages = MESSAGES.wait();
+    send_blocking(messages, msg.into())
+}
+
+/// Must be called once during editor startup exactly once
+/// before any of the messages in this module can be used
+///
+/// # Panics
+/// If called multiple times
+pub fn setup() -> Receiver<StatusMessage> {
+    let (tx, rx) = tokio::sync::mpsc::channel(128);
+    let _ = MESSAGES.set(tx);
+    rx
+}
diff --git a/helix-event/src/test.rs b/helix-event/src/test.rs
new file mode 100644
index 0000000000000..868d5e1153e92
--- /dev/null
+++ b/helix-event/src/test.rs
@@ -0,0 +1,113 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::Result;
+use parking_lot::Mutex;
+
+use crate::{dispatch, events, register_dynamic_hook, register_event, register_hook, Hook};
+#[test]
+fn smoke_test() {
+    events! {
+        Event1 {
+            content: String
+        }
+        Event2 {
+            content: usize
+        }
+    }
+
+    #[derive(Default, Clone)]
+    struct Hook1 {
+        acc: Arc<Mutex<String>>,
+    }
+    impl Hook for Hook1 {
+        type Event<'a> = Event1;
+        fn run(&self, event: &mut Event1) -> Result<()> {
+            self.acc.lock().push_str(&event.content);
+            Ok(())
+        }
+    }
+
+    #[derive(Default)]
+    struct Hook2 {
+        acc: Arc<AtomicUsize>,
+    }
+    impl Hook for Hook2 {
+        type Event<'a> = Event2;
+        fn run(&self, event: &mut Event2) -> Result<()> {
+            self.acc.fetch_add(event.content, Ordering::Relaxed);
+            Ok(())
+        }
+    }
+
+    // initial registry setup
+    register_event::<Event1>();
+    register_event::<Event2>();
+
+    // setup hooks
+    let hook1 = Hook1::default();
+    let res1 = hook1.acc.clone();
+    register_hook(hook1);
+    let hook2 = Hook2::default();
+    let res2 = hook2.acc.clone();
+    register_hook(hook2);
+
+    // trigges events
+    let thread = std::thread::spawn(|| {
+        for i in 0..1000 {
+            dispatch(Event2 { content: i });
+        }
+    });
+    std::thread::sleep(Duration::from_millis(1));
+    dispatch(Event1 {
+        content: "foo".to_owned(),
+    });
+    dispatch(Event2 { content: 42 });
+    dispatch(Event1 {
+        content: "bar".to_owned(),
+    });
+    dispatch(Event1 {
+        content: "hello world".to_owned(),
+    });
+    thread.join().unwrap();
+
+    // check output
+    assert_eq!(&**res1.lock(), "foobarhello world");
+    assert_eq!(
+        res2.load(Ordering::Relaxed),
+        42 + (0..1000usize).sum::<usize>()
+    );
+}
+
+#[test]
+fn dynamic() {
+    events! {
+        Event3 {}
+        Event4 (usize)
+    };
+    register_event::<Event3>();
+    register_event::<Event4>();
+
+    let count = Arc::new(AtomicUsize::new(0));
+    let count1 = count.clone();
+    let count2 = count.clone();
+    register_dynamic_hook(
+        move || {
+            count1.fetch_add(2, Ordering::Relaxed);
+        },
+        "Event3",
+    )
+    .unwrap();
+    register_dynamic_hook(
+        move || {
+            count2.fetch_add(3, Ordering::Relaxed);
+        },
+        "Event4",
+    )
+    .unwrap();
+    dispatch(Event3 {});
+    dispatch(Event4(0));
+    dispatch(Event3 {});
+    assert_eq!(count.load(Ordering::Relaxed), 7)
+}
diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml
index 17580bab5a201..8651fda8b7911 100644
--- a/helix-term/Cargo.toml
+++ b/helix-term/Cargo.toml
@@ -15,7 +15,7 @@ rust-version = "1.65"
 [features]
 default = ["git"]
 unicode-lines = ["helix-core/unicode-lines"]
-integration = []
+integration = ["helix-event/integration_test"]
 git = ["helix-vcs/git"]
 
 [[bin]]
diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index 51ad13daadc5d..cb80f7d7c6175 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -1,7 +1,7 @@
 use arc_swap::{access::Map, ArcSwap};
 use futures_util::Stream;
 use helix_core::{
-    diagnostic::{DiagnosticTag, NumberOrString},
+    diagnostic::{DiagnosticTag, NumberOrString, Severity},
     path::get_relative_path,
     pos_at_coords, syntax, Selection,
 };
@@ -27,6 +27,7 @@ use crate::{
     commands::apply_workspace_edit,
     compositor::{Compositor, Event},
     config::Config,
+    handlers,
     job::Jobs,
     keymap::Keymaps,
     ui::{self, overlay::overlaid},
@@ -141,6 +142,7 @@ impl Application {
         let area = terminal.size().expect("couldn't get terminal size");
         let mut compositor = Compositor::new(area);
         let config = Arc::new(ArcSwap::from_pointee(config));
+        let handlers = handlers::setup(config.clone());
         let mut editor = Editor::new(
             area,
             theme_loader.clone(),
@@ -148,6 +150,7 @@ impl Application {
             Arc::new(Map::new(Arc::clone(&config), |config: &Config| {
                 &config.editor
             })),
+            handlers,
         );
 
         let keys = Box::new(Map::new(Arc::clone(&config), |config: &Config| {
@@ -313,10 +316,21 @@ impl Application {
                 Some(event) = input_stream.next() => {
                     self.handle_terminal_events(event).await;
                 }
-                Some(callback) = self.jobs.futures.next() => {
-                    self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
+                Some(callback) = self.jobs.callbacks.recv() => {
+                    self.jobs.handle_callback(&mut self.editor, &mut self.compositor, Ok(Some(callback)));
                     self.render().await;
                 }
+                Some(msg) = self.jobs.status_messages.recv() => {
+                    let severity = match msg.severity{
+                        helix_event::status::Severity::Hint => Severity::Hint,
+                        helix_event::status::Severity::Info => Severity::Info,
+                        helix_event::status::Severity::Warning => Severity::Warning,
+                        helix_event::status::Severity::Error => Severity::Error,
+                    };
+                    // TODO: show multiple status messages at once to avoid clobbering
+                    self.editor.status_msg = Some((msg.message, severity));
+                    helix_event::request_redraw();
+                }
                 Some(callback) = self.jobs.wait_futures.next() => {
                     self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
                     self.render().await;
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 2bdbb2f417dae..e0f74e2cd7c5d 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -82,7 +82,7 @@ pub struct Context<'a> {
     pub count: Option<NonZeroUsize>,
     pub editor: &'a mut Editor,
 
-    pub callback: Option<crate::compositor::Callback>,
+    pub callback: Vec<crate::compositor::Callback>,
     pub on_next_key_callback: Option<OnKeyCallback>,
     pub jobs: &'a mut Jobs,
 }
@@ -90,16 +90,18 @@ pub struct Context<'a> {
 impl<'a> Context<'a> {
     /// Push a new component onto the compositor.
     pub fn push_layer(&mut self, component: Box<dyn Component>) {
-        self.callback = Some(Box::new(|compositor: &mut Compositor, _| {
-            compositor.push(component)
-        }));
+        self.callback
+            .push(Box::new(|compositor: &mut Compositor, _| {
+                compositor.push(component)
+            }));
     }
 
     /// Call `replace_or_push` on the Compositor
     pub fn replace_or_push_layer<T: Component>(&mut self, id: &'static str, component: T) {
-        self.callback = Some(Box::new(move |compositor: &mut Compositor, _| {
-            compositor.replace_or_push(id, component);
-        }));
+        self.callback
+            .push(Box::new(move |compositor: &mut Compositor, _| {
+                compositor.replace_or_push(id, component);
+            }));
     }
 
     #[inline]
@@ -2815,7 +2817,7 @@ pub fn command_palette(cx: &mut Context) {
     let register = cx.register;
     let count = cx.count;
 
-    cx.callback = Some(Box::new(
+    cx.callback.push(Box::new(
         move |compositor: &mut Compositor, cx: &mut compositor::Context| {
             let keymap = compositor.find::<ui::EditorView>().unwrap().keymaps.map()
                 [&cx.editor.mode]
@@ -2835,7 +2837,7 @@ pub fn command_palette(cx: &mut Context) {
                     register,
                     count,
                     editor: cx.editor,
-                    callback: None,
+                    callback: Vec::new(),
                     on_next_key_callback: None,
                     jobs: cx.jobs,
                 };
@@ -2863,7 +2865,7 @@ pub fn command_palette(cx: &mut Context) {
 
 fn last_picker(cx: &mut Context) {
     // TODO: last picker does not seem to work well with buffer_picker
-    cx.callback = Some(Box::new(|compositor, cx| {
+    cx.callback.push(Box::new(|compositor, cx| {
         if let Some(picker) = compositor.last_picker.take() {
             compositor.push(picker);
         } else {
@@ -3371,6 +3373,7 @@ fn hunk_range(hunk: Hunk, text: RopeSlice) -> Range {
 }
 
 pub mod insert {
+    use crate::events::PostInsertChar;
     use super::*;
     pub type Hook = fn(&Rope, &Selection, char) -> Option<Transaction>;
     pub type PostHook = fn(&mut Context, char);
@@ -3504,6 +3507,7 @@ pub mod insert {
         for hook in &[language_server_completion, signature_help] {
             hook(cx, c);
         }
+        helix_event::dispatch(PostInsertChar { c, cx });
     }
 
     pub fn smart_tab(cx: &mut Context) {
@@ -5670,7 +5674,7 @@ fn replay_macro(cx: &mut Context) {
     cx.editor.macro_replaying.push(reg);
 
     let count = cx.count();
-    cx.callback = Some(Box::new(move |compositor, cx| {
+    cx.callback.push(Box::new(move |compositor, cx| {
         for _ in 0..count {
             for &key in keys.iter() {
                 compositor.handle_event(&compositor::Event::Key(key), cx);
diff --git a/helix-term/src/events.rs b/helix-term/src/events.rs
new file mode 100644
index 0000000000000..49b44f775088b
--- /dev/null
+++ b/helix-term/src/events.rs
@@ -0,0 +1,20 @@
+use helix_event::{events, register_event};
+use helix_view::document::Mode;
+use helix_view::events::{DocumentDidChange, SelectionDidChange};
+
+use crate::commands;
+use crate::keymap::MappableCommand;
+
+events! {
+    OnModeSwitch<'a, 'cx> { old_mode: Mode, new_mode: Mode, cx: &'a mut commands::Context<'cx> }
+    PostInsertChar<'a, 'cx> { c: char, cx: &'a mut commands::Context<'cx> }
+    PostCommand<'a, 'cx> { command: & 'a MappableCommand, cx: &'a mut commands::Context<'cx> }
+}
+
+pub fn register() {
+    register_event::<OnModeSwitch>();
+    register_event::<PostInsertChar>();
+    register_event::<PostCommand>();
+    register_event::<DocumentDidChange>();
+    register_event::<SelectionDidChange>();
+}
diff --git a/helix-term/src/handlers.rs b/helix-term/src/handlers.rs
new file mode 100644
index 0000000000000..ab2d724ff3ec8
--- /dev/null
+++ b/helix-term/src/handlers.rs
@@ -0,0 +1,15 @@
+use std::sync::Arc;
+
+use arc_swap::ArcSwap;
+
+use crate::config::Config;
+use crate::events;
+
+
+    }
+pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
+    events::register();
+    let handlers = Handlers {
+    };
+    handlers
+}
diff --git a/helix-term/src/job.rs b/helix-term/src/job.rs
index 19f2521a5231d..bb85c3520d33a 100644
--- a/helix-term/src/job.rs
+++ b/helix-term/src/job.rs
@@ -1,13 +1,37 @@
+use helix_event::status::StatusMessage;
+use helix_event::{runtime_local, send_blocking};
 use helix_view::Editor;
+use once_cell::sync::OnceCell;
 
 use crate::compositor::Compositor;
 
 use futures_util::future::{BoxFuture, Future, FutureExt};
 use futures_util::stream::{FuturesUnordered, StreamExt};
+use tokio::sync::mpsc::{channel, Receiver, Sender};
 
 pub type EditorCompositorCallback = Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>;
 pub type EditorCallback = Box<dyn FnOnce(&mut Editor) + Send>;
 
+runtime_local! {
+    static JOB_QUEUE: OnceCell<Sender<Callback>> = OnceCell::new();
+}
+
+pub async fn dispatch_callback(job: Callback) {
+    let _ = JOB_QUEUE.wait().send(job).await;
+}
+
+pub async fn dispatch(job: impl FnOnce(&mut Editor, &mut Compositor) + Send + 'static) {
+    let _ = JOB_QUEUE
+        .wait()
+        .send(Callback::EditorCompositor(Box::new(job)))
+        .await;
+}
+
+pub fn dispatch_blocking(job: impl FnOnce(&mut Editor, &mut Compositor) + Send + 'static) {
+    let jobs = JOB_QUEUE.wait();
+    send_blocking(jobs, Callback::EditorCompositor(Box::new(job)))
+}
+
 pub enum Callback {
     EditorCompositor(EditorCompositorCallback),
     Editor(EditorCallback),
@@ -21,11 +45,11 @@ pub struct Job {
     pub wait: bool,
 }
 
-#[derive(Default)]
 pub struct Jobs {
-    pub futures: FuturesUnordered<JobFuture>,
-    /// These are the ones that need to complete before we exit.
+    /// jobs the ones that need to complete before we exit.
     pub wait_futures: FuturesUnordered<JobFuture>,
+    pub callbacks: Receiver<Callback>,
+    pub status_messages: Receiver<StatusMessage>,
 }
 
 impl Job {
@@ -52,8 +76,16 @@ impl Job {
 }
 
 impl Jobs {
+    #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
-        Self::default()
+        let (tx, rx) = channel(1024);
+        let _ = JOB_QUEUE.set(tx);
+        let status_messages = helix_event::status::setup();
+        Self {
+            wait_futures: FuturesUnordered::new(),
+            callbacks: rx,
+            status_messages,
+        }
     }
 
     pub fn spawn<F: Future<Output = anyhow::Result<()>> + Send + 'static>(&mut self, f: F) {
@@ -85,18 +117,17 @@ impl Jobs {
         }
     }
 
-    pub async fn next_job(&mut self) -> Option<anyhow::Result<Option<Callback>>> {
-        tokio::select! {
-            event = self.futures.next() => {  event }
-            event = self.wait_futures.next() => { event }
-        }
-    }
-
     pub fn add(&self, j: Job) {
         if j.wait {
             self.wait_futures.push(j.future);
         } else {
-            self.futures.push(j.future);
+            tokio::spawn(async move {
+                match j.future.await {
+                    Ok(Some(cb)) => dispatch_callback(cb).await,
+                    Ok(None) => (),
+                    Err(err) => helix_event::status::report(err).await,
+                }
+            });
         }
     }
 
diff --git a/helix-term/src/lib.rs b/helix-term/src/lib.rs
index 2f6ec12b13fd0..ddf5e168c6a3f 100644
--- a/helix-term/src/lib.rs
+++ b/helix-term/src/lib.rs
@@ -6,12 +6,16 @@ pub mod args;
 pub mod commands;
 pub mod compositor;
 pub mod config;
+pub mod events;
 pub mod health;
 pub mod job;
 pub mod keymap;
 pub mod ui;
+
 use std::path::Path;
 
+mod handlers;
+
 use ignore::DirEntry;
 pub use keymap::macros::*;
 
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index aa159d40dce50..908db796b5e49 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs
@@ -2,6 +2,7 @@ use crate::{
     commands::{self, OnKeyCallback},
     compositor::{Component, Context, Event, EventResult},
     job::{self, Callback},
+    events::{OnModeSwitch, PostCommand},
     key,
     keymap::{KeymapResult, Keymaps},
     ui::{
@@ -806,11 +807,18 @@ impl EditorView {
 
         let mut execute_command = |command: &commands::MappableCommand| {
             command.execute(cxt);
+            helix_event::dispatch(PostCommand { command, cx: cxt });
             let current_mode = cxt.editor.mode();
             match (last_mode, current_mode) {
                 (Mode::Normal, Mode::Insert) => {
                     // HAXX: if we just entered insert mode from normal, clear key buf
                     // and record the command that got us into this mode.
+            if current_mode != last_mode {
+                helix_event::dispatch(OnModeSwitch {
+                    old_mode: last_mode,
+                    new_mode: current_mode,
+                    cx: cxt,
+                });
 
                     // how we entered insert mode is important, and we should track that so
                     // we can repeat the side effect.
@@ -975,7 +983,7 @@ impl EditorView {
         }
 
         let area = completion.area(size, editor);
-        editor.last_completion = None;
+        editor.last_completion = Some(CompleteAction::Triggered);
         self.last_insert.1.push(InsertEvent::TriggerCompletion);
 
         // TODO : propagate required size on resize to completion too
@@ -1231,7 +1239,7 @@ impl Component for EditorView {
             editor: context.editor,
             count: None,
             register: None,
-            callback: None,
+            callback: Vec::new(),
             on_next_key_callback: None,
             jobs: context.jobs,
         };
@@ -1343,7 +1351,7 @@ impl Component for EditorView {
                 }
 
                 // appease borrowck
-                let callback = cx.callback.take();
+                let callbacks = take(&mut cx.callback);
 
                 // if the command consumed the last view, skip the render.
                 // on the next loop cycle the Application will then terminate.
@@ -1366,6 +1374,16 @@ impl Component for EditorView {
                         doc.append_changes_to_history(view);
                     }
                 }
+                let callback = if callbacks.is_empty() {
+                    None
+                } else {
+                    let callback: crate::compositor::Callback = Box::new(move |compositor, cx| {
+                        for callback in callbacks {
+                            callback(compositor, cx)
+                        }
+                    });
+                    Some(callback)
+                };
 
                 EventResult::Consumed(callback)
             }
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
index 19f37c711e68f..90e4b953e301c 100644
--- a/helix-view/src/document.rs
+++ b/helix-view/src/document.rs
@@ -34,6 +34,7 @@ use helix_core::{
 };
 
 use crate::editor::Config;
+use crate::events::{DocumentDidChange, SelectionDidChange};
 use crate::{DocumentId, Editor, Theme, View, ViewId};
 
 /// 8kB of buffer space for encoding and decoding `Rope`s.
@@ -1102,6 +1103,10 @@ impl Document {
         // TODO: use a transaction?
         self.selections
             .insert(view_id, selection.ensure_invariants(self.text().slice(..)));
+        helix_event::dispatch(SelectionDidChange {
+            doc: self,
+            view: view_id,
+        })
     }
 
     /// Find the origin selection of the text in a document, i.e. where
@@ -1155,6 +1160,14 @@ impl Document {
         let success = transaction.changes().apply(&mut self.text);
 
         if success {
+            if emit_lsp_notification {
+                helix_event::dispatch(DocumentDidChange {
+                    doc: self,
+                    view: view_id,
+                    old_text: &old_doc,
+                });
+            }
+
             for selection in self.selections.values_mut() {
                 *selection = selection
                     .clone()
@@ -1170,6 +1183,10 @@ impl Document {
                     view_id,
                     selection.clone().ensure_invariants(self.text.slice(..)),
                 );
+                helix_event::dispatch(SelectionDidChange {
+                    doc: self,
+                    view: view_id,
+                });
             }
 
             self.modified_since_accessed = true;
@@ -1260,6 +1277,7 @@ impl Document {
             }
 
             if emit_lsp_notification {
+                // TODO: move to hook
                 // emit lsp notification
                 for language_server in self.language_servers() {
                     let notify = language_server.text_document_did_change(
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
index cf05898af7a5d..64f6475ae5f8a 100644
--- a/helix-view/src/editor.rs
+++ b/helix-view/src/editor.rs
@@ -2,6 +2,7 @@ use crate::{
     align_view,
     document::{DocumentSavedEventFuture, DocumentSavedEventResult, Mode, SavePoint},
     graphics::{CursorKind, Rect},
+    handlers::Handlers,
     info::Info,
     input::KeyEvent,
     register::Registers,
@@ -946,6 +947,7 @@ pub struct Editor {
     /// field is set and any old requests are automatically
     /// canceled as a result
     pub completion_request_handle: Option<oneshot::Sender<()>>,
+    pub handlers: Handlers,
 }
 
 pub type Motion = Box<dyn Fn(&mut Editor)>;
diff --git a/helix-view/src/events.rs b/helix-view/src/events.rs
new file mode 100644
index 0000000000000..8b789cc0d21e0
--- /dev/null
+++ b/helix-view/src/events.rs
@@ -0,0 +1,9 @@
+use helix_core::Rope;
+use helix_event::events;
+
+use crate::{Document, ViewId};
+
+events! {
+    DocumentDidChange<'a> { doc: &'a mut Document, view: ViewId, old_text: &'a Rope  }
+    SelectionDidChange<'a> { doc: &'a mut Document, view: ViewId }
+}
diff --git a/helix-view/src/handlers.rs b/helix-view/src/handlers.rs
new file mode 100644
index 0000000000000..ae3eb545aea16
--- /dev/null
+++ b/helix-view/src/handlers.rs
@@ -0,0 +1,12 @@
+use std::sync::Arc;
+
+use helix_event::send_blocking;
+use tokio::sync::mpsc::Sender;
+
+use crate::handlers::lsp::SignatureHelpInvoked;
+use crate::Editor;
+
+pub mod dap;
+pub mod lsp;
+
+pub struct Handlers {}
diff --git a/helix-view/src/handlers/lsp.rs b/helix-view/src/handlers/lsp.rs
index 8b137891791fe..de9f7a4741df9 100644
--- a/helix-view/src/handlers/lsp.rs
+++ b/helix-view/src/handlers/lsp.rs
@@ -1 +1,40 @@
+use crate::{DocumentId, ViewId};
 
+#[derive(Debug, Clone, Copy)]
+pub struct CompletionTrigger {
+    /// The char position of the primary cursor when the
+    /// completion was triggered
+    pub trigger_pos: usize,
+    pub doc: DocumentId,
+    pub view: ViewId,
+    /// Whether the cause of the trigger was an automatic completion (any word
+    /// char for words longer than minimum word length).
+    /// This is false for trigger chars send by the LS
+    pub auto: bool,
+}
+
+pub enum CompletionEvent {
+    /// Auto completion was triggered by typing a word char
+    /// or a completion trigger
+    Trigger(CompletionTrigger),
+    /// A completion was manually requested (c-x)
+    Manual,
+    /// Some text was deleted and the cursor is now at `pos`
+    DeletText { pos: usize },
+    /// Invalidate the current auto completion trigger
+    Cancel,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum SignatureHelpInvoked {
+    Automatic,
+    Manual,
+}
+
+pub enum SignatureHelpEvent {
+    Invoked,
+    Trigger,
+    ReTrigger,
+    Cancel,
+    RequestComplete { open: bool },
+}
diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs
index 6a68e7d6f9bd0..82827b5d53dfb 100644
--- a/helix-view/src/lib.rs
+++ b/helix-view/src/lib.rs
@@ -1,17 +1,15 @@
 #[macro_use]
 pub mod macros;
 
+pub mod base64;
 pub mod clipboard;
 pub mod document;
 pub mod editor;
 pub mod env;
+pub mod events;
 pub mod graphics;
 pub mod gutter;
-pub mod handlers {
-    pub mod dap;
-    pub mod lsp;
-}
-pub mod base64;
+pub mod handlers;
 pub mod info;
 pub mod input;
 pub mod keyboard;