Replace Crossterm with Termina

This change switches out the terminal manipulation library to one I've
been working on: Termina. It's somewhat similar to Crossterm API-wise
but is a bit lower-level. It's also influenced a lot by TermWiz - the
terminal manipulation library in WezTerm which we've considered
switching to a few times.

Termina is more verbose than Crossterm as it has a lower level interface
that exposes escape sequences and pushes handling to the application.
API-wise the important piece is that the equivalents of Crossterm's
`poll_internal` / `read_internal` are exposed. This is used for reading
the cursor position in both Crossterm and Termina, for example, but also
now can be used to detect features like the Kitty keyboard protocol and
synchronized output sequences simultaneously.

Author: the-mikedavis

Cargo.lock

@@ -51,6 +51,7 @@ futures-executor = "0.3"
 futures-util = { version = "0.3", features = ["std", "async-await"], default-features = false }
 tokio-stream = "0.1.17"
 toml = "0.9"
+termina = "0.1.0"
 
 [workspace.package]
 version = "25.7.1"

Cargo.toml

@@ -54,8 +54,8 @@ anyhow = "1"
 once_cell = "1.21"
 
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot"] }
-tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["crossterm"] }
-crossterm = { version = "0.28", features = ["event-stream"] }
+tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["termina"] }
+termina = { workspace = true, features = ["event-stream"] }
 signal-hook = "0.3"
 tokio-stream = "0.1"
 futures-util = { version = "0.3", features = ["std", "async-await"], default-features = false }
@@ -97,9 +97,6 @@ dashmap = "6.0"
 signal-hook-tokio = { version = "0.3", features = ["futures-v0_3"] }
 libc = "0.2.175"
 
-[target.'cfg(target_os = "macos")'.dependencies]
-crossterm = { version = "0.28", features = ["event-stream", "use-dev-tty", "libc"] }
-
 [build-dependencies]
 helix-loader = { path = "../helix-loader" }
 

helix-term/Cargo.toml

@@ -30,28 +30,27 @@ use crate::{
 };
 
 use log::{debug, error, info, warn};
-#[cfg(not(feature = "integration"))]
-use std::io::stdout;
-use std::{io::stdin, path::Path, sync::Arc};
+use std::{
+    io::{stdin, IsTerminal},
+    path::Path,
+    sync::Arc,
+};
 
-#[cfg(not(windows))]
-use anyhow::Context;
-use anyhow::Error;
+use anyhow::{Context, Error};
 
-use crossterm::{event::Event as CrosstermEvent, tty::IsTty};
 #[cfg(not(windows))]
 use {signal_hook::consts::signal, signal_hook_tokio::Signals};
 #[cfg(windows)]
 type Signals = futures_util::stream::Empty<()>;
 
 #[cfg(not(feature = "integration"))]
-use tui::backend::CrosstermBackend;
+use tui::backend::TerminaBackend;
 
 #[cfg(feature = "integration")]
 use tui::backend::TestBackend;
 
 #[cfg(not(feature = "integration"))]
-type TerminalBackend = CrosstermBackend<std::io::Stdout>;
+type TerminalBackend = TerminaBackend;
 
 #[cfg(feature = "integration")]
 type TerminalBackend = TestBackend;
@@ -104,7 +103,8 @@ impl Application {
         let theme_loader = theme::Loader::new(&theme_parent_dirs);
 
         #[cfg(not(feature = "integration"))]
-        let backend = CrosstermBackend::new(stdout(), (&config.editor).into());
+        let backend = TerminaBackend::new((&config.editor).into())
+            .context("failed to create terminal backend")?;
 
         #[cfg(feature = "integration")]
         let backend = TestBackend::new(120, 150);
@@ -123,7 +123,11 @@ impl Application {
             })),
             handlers,
         );
-        Self::load_configured_theme(&mut editor, &config.load());
+        Self::load_configured_theme(
+            &mut editor,
+            &config.load(),
+            terminal.backend().supports_true_color(),
+        );
 
         let keys = Box::new(Map::new(Arc::clone(&config), |config: &Config| {
             &config.keys
@@ -214,7 +218,7 @@ impl Application {
             } else {
                 editor.new_file(Action::VerticalSplit);
             }
-        } else if stdin().is_tty() || cfg!(feature = "integration") {
+        } else if stdin().is_terminal() || cfg!(feature = "integration") {
             editor.new_file(Action::VerticalSplit);
         } else {
             editor
@@ -282,7 +286,7 @@ impl Application {
 
     pub async fn event_loop<S>(&mut self, input_stream: &mut S)
     where
-        S: Stream<Item = std::io::Result<crossterm::event::Event>> + Unpin,
+        S: Stream<Item = std::io::Result<termina::Event>> + Unpin,
     {
         self.render().await;
 
@@ -295,7 +299,7 @@ impl Application {
 
     pub async fn event_loop_until_idle<S>(&mut self, input_stream: &mut S) -> bool
     where
-        S: Stream<Item = std::io::Result<crossterm::event::Event>> + Unpin,
+        S: Stream<Item = std::io::Result<termina::Event>> + Unpin,
     {
         loop {
             if self.editor.should_close() {
@@ -396,7 +400,11 @@ impl Application {
             // the sake of locals highlighting.
             let lang_loader = helix_core::config::user_lang_loader()?;
             self.editor.syn_loader.store(Arc::new(lang_loader));
-            Self::load_configured_theme(&mut self.editor, &default_config);
+            Self::load_configured_theme(
+                &mut self.editor,
+                &default_config,
+                self.terminal.backend().supports_true_color(),
+            );
 
             // Re-parse any open documents with the new language config.
             let lang_loader = self.editor.syn_loader.load();
@@ -429,8 +437,8 @@ impl Application {
     }
 
     /// Load the theme set in configuration
-    fn load_configured_theme(editor: &mut Editor, config: &Config) {
-        let true_color = config.editor.true_color || crate::true_color();
+    fn load_configured_theme(editor: &mut Editor, config: &Config, terminal_true_color: bool) {
+        let true_color = terminal_true_color || config.editor.true_color || crate::true_color();
         let theme = config
             .theme
             .as_ref()
@@ -634,29 +642,29 @@ impl Application {
         false
     }
 
-    pub async fn handle_terminal_events(&mut self, event: std::io::Result<CrosstermEvent>) {
+    pub async fn handle_terminal_events(&mut self, event: std::io::Result<termina::Event>) {
         let mut cx = crate::compositor::Context {
             editor: &mut self.editor,
             jobs: &mut self.jobs,
             scroll: None,
         };
         // Handle key events
         let should_redraw = match event.unwrap() {
-            CrosstermEvent::Resize(width, height) => {
+            termina::Event::WindowResized(termina::WindowSize { rows, cols, .. }) => {
                 self.terminal
-                    .resize(Rect::new(0, 0, width, height))
+                    .resize(Rect::new(0, 0, cols, rows))
                     .expect("Unable to resize terminal");
 
                 let area = self.terminal.size().expect("couldn't get terminal size");
 
                 self.compositor.resize(area);
 
                 self.compositor
-                    .handle_event(&Event::Resize(width, height), &mut cx)
+                    .handle_event(&Event::Resize(cols, rows), &mut cx)
             }
             // Ignore keyboard release events.
-            CrosstermEvent::Key(crossterm::event::KeyEvent {
-                kind: crossterm::event::KeyEventKind::Release,
+            termina::Event::Key(termina::event::KeyEvent {
+                kind: termina::event::KeyEventKind::Release,
                 ..
             }) => false,
             event => self.compositor.handle_event(&event.into(), &mut cx),
@@ -1107,22 +1115,40 @@ impl Application {
         self.terminal.restore()
     }
 
+    #[cfg(not(feature = "integration"))]
+    pub fn event_stream(&self) -> impl Stream<Item = std::io::Result<termina::Event>> + Unpin {
+        use termina::Terminal as _;
+        let reader = self.terminal.backend().terminal().event_reader();
+        termina::EventStream::new(reader, |event| !event.is_escape())
+    }
+
+    #[cfg(feature = "integration")]
+    pub fn event_stream(&self) -> impl Stream<Item = std::io::Result<termina::Event>> + Unpin {
+        use std::{
+            pin::Pin,
+            task::{Context, Poll},
+        };
+
+        /// A dummy stream that never polls as ready.
+        pub struct DummyEventStream;
+
+        impl Stream for DummyEventStream {
+            type Item = std::io::Result<termina::Event>;
+
+            fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+                Poll::Pending
+            }
+        }
+
+        DummyEventStream
+    }
+
     pub async fn run<S>(&mut self, input_stream: &mut S) -> Result<i32, Error>
     where
-        S: Stream<Item = std::io::Result<crossterm::event::Event>> + Unpin,
+        S: Stream<Item = std::io::Result<termina::Event>> + Unpin,
     {
         self.terminal.claim()?;
 
-        // Exit the alternate screen and disable raw mode before panicking
-        let hook = std::panic::take_hook();
-        std::panic::set_hook(Box::new(move |info| {
-            // We can't handle errors properly inside this closure.  And it's
-            // probably not a good idea to `unwrap()` inside a panic handler.
-            // So we just ignore the `Result`.
-            let _ = TerminalBackend::force_restore();
-            hook(info);
-        }));
-
         self.event_loop(input_stream).await;
 
         let close_errs = self.close().await;

helix-term/src/application.rs

@@ -1,11 +1,14 @@
 use crate::config::{Config, ConfigLoadError};
-use crossterm::{
-    style::{Color, StyledContent, Stylize},
-    tty::IsTty,
-};
 use helix_core::config::{default_lang_config, user_lang_config};
 use helix_loader::grammar::load_runtime_file;
-use std::{collections::HashSet, io::Write};
+use std::{
+    collections::HashSet,
+    io::{IsTerminal, Write},
+};
+use termina::{
+    style::{ColorSpec, StyleExt as _, Stylized},
+    Terminal as _,
+};
 
 #[derive(Copy, Clone)]
 pub enum TsFeature {
@@ -183,21 +186,24 @@ fn languages(selection: Option<HashSet<String>>) -> std::io::Result<()> {
         headings.push(feat.short_title())
     }
 
-    let terminal_cols = crossterm::terminal::size().map(|(c, _)| c).unwrap_or(80);
+    let terminal_cols = termina::PlatformTerminal::new()
+        .and_then(|terminal| terminal.get_dimensions())
+        .map(|size| size.cols)
+        .unwrap_or(80);
     let column_width = terminal_cols as usize / headings.len();
-    let is_terminal = std::io::stdout().is_tty();
+    let is_terminal = std::io::stdout().is_terminal();
 
-    let fit = |s: &str| -> StyledContent<String> {
+    let fit = |s: &str| -> Stylized<'static> {
         format!(
             "{:column_width$}",
             s.get(..column_width - 2)
                 .map(|s| format!("{}…", s))
                 .unwrap_or_else(|| s.to_string())
         )
-        .stylize()
+        .stylized()
     };
-    let color = |s: StyledContent<String>, c: Color| if is_terminal { s.with(c) } else { s };
-    let bold = |s: StyledContent<String>| if is_terminal { s.bold() } else { s };
+    let color = |s: Stylized<'static>, c: ColorSpec| if is_terminal { s.foreground(c) } else { s };
+    let bold = |s: Stylized<'static>| if is_terminal { s.bold() } else { s };
 
     for heading in headings {
         write!(stdout, "{}", bold(fit(heading)))?;
@@ -210,10 +216,10 @@ fn languages(selection: Option<HashSet<String>>) -> std::io::Result<()> {
 
     let check_binary_with_name = |cmd: Option<(&str, &str)>| match cmd {
         Some((name, cmd)) => match helix_stdx::env::which(cmd) {
-            Ok(_) => color(fit(&format!("✓ {}", name)), Color::Green),
-            Err(_) => color(fit(&format!("✘ {}", name)), Color::Red),
+            Ok(_) => color(fit(&format!("✓ {}", name)), ColorSpec::BRIGHT_GREEN),
+            Err(_) => color(fit(&format!("✘ {}", name)), ColorSpec::BRIGHT_RED),
         },
-        None => color(fit("None"), Color::Yellow),
+        None => color(fit("None"), ColorSpec::BRIGHT_YELLOW),
     };
 
     let check_binary = |cmd: Option<&str>| check_binary_with_name(cmd.map(|cmd| (cmd, cmd)));
@@ -247,8 +253,8 @@ fn languages(selection: Option<HashSet<String>>) -> std::io::Result<()> {
 
         for ts_feat in TsFeature::all() {
             match load_runtime_file(&lang.language_id, ts_feat.runtime_filename()).is_ok() {
-                true => write!(stdout, "{}", color(fit("✓"), Color::Green))?,
-                false => write!(stdout, "{}", color(fit("✘"), Color::Red))?,
+                true => write!(stdout, "{}", color(fit("✓"), ColorSpec::BRIGHT_GREEN))?,
+                false => write!(stdout, "{}", color(fit("✘"), ColorSpec::BRIGHT_RED))?,
             }
         }
 

helix-term/src/health.rs

@@ -1,5 +1,4 @@
 use anyhow::{Context, Error, Result};
-use crossterm::event::EventStream;
 use helix_loader::VERSION_AND_GIT_HASH;
 use helix_term::application::Application;
 use helix_term::args::Args;
@@ -151,8 +150,9 @@ FLAGS:
 
     // TODO: use the thread local executor to spawn the application task separately from the work pool
     let mut app = Application::new(args, config, lang_loader).context("unable to start Helix")?;
+    let mut events = app.event_stream();
 
-    let exit_code = app.run(&mut EventStream::new()).await?;
+    let exit_code = app.run(&mut events).await?;
 
     Ok(exit_code)
 }

helix-term/src/main.rs

@@ -538,15 +538,15 @@ impl EditorView {
                     };
                 spans.push((selection_scope, range.anchor..selection_end));
                 // add block cursors
-                // skip primary cursor if terminal is unfocused - crossterm cursor is used in that case
+                // skip primary cursor if terminal is unfocused - terminal cursor is used in that case
                 if !selection_is_primary || (cursor_is_block && is_terminal_focused) {
                     spans.push((cursor_scope, cursor_start..range.head));
                 }
             } else {
                 // Reverse case.
                 let cursor_end = next_grapheme_boundary(text, range.head);
                 // add block cursors
-                // skip primary cursor if terminal is unfocused - crossterm cursor is used in that case
+                // skip primary cursor if terminal is unfocused - terminal cursor is used in that case
                 if !selection_is_primary || (cursor_is_block && is_terminal_focused) {
                     spans.push((cursor_scope, range.head..cursor_end));
                 }
@@ -1631,7 +1631,7 @@ impl Component for EditorView {
                 if self.terminal_focused {
                     (pos, CursorKind::Hidden)
                 } else {
-                    // use crossterm cursor when terminal loses focus
+                    // use terminal cursor when terminal loses focus
                     (pos, CursorKind::Underline)
                 }
             }

helix-term/src/ui/editor.rs

@@ -6,11 +6,11 @@ use std::{
 };
 
 use anyhow::bail;
-use crossterm::event::{Event, KeyEvent};
 use helix_core::{diagnostic::Severity, test, Selection, Transaction};
 use helix_term::{application::Application, args::Args, config::Config, keymap::merge_keys};
 use helix_view::{current_ref, doc, editor::LspConfig, input::parse_macro, Editor};
 use tempfile::NamedTempFile;
+use termina::event::{Event, KeyEvent};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 
 /// Specify how to set up the input text with line feeds

helix-term/tests/test/helpers.rs

@@ -12,7 +12,7 @@ repository.workspace = true
 homepage.workspace = true
 
 [features]
-default = ["crossterm"]
+default = ["termina"]
 
 [dependencies]
 helix-view = { path = "../helix-view", features = ["term"] }
@@ -21,7 +21,7 @@ helix-core = { path = "../helix-core" }
 bitflags.workspace = true
 cassowary = "0.3"
 unicode-segmentation.workspace = true
-crossterm = { version = "0.28", optional = true }
+termina = { workspace = true, optional = true }
 termini = "1.0"
 once_cell = "1.21"
 log = "~0.4"