diff --git a/src/term/frame.rs b/src/term/frame.rs
index c5c8b5c..d1d620c 100644
--- a/src/term/frame.rs
+++ b/src/term/frame.rs
@@ -84,7 +84,12 @@ impl Frame {
 }
 
 /// The screen as it shows now, scrolled back or not; `lit` matches wear their washes.
-pub fn frame<T: EventListener>(term: &Term<T>, ink: &Ink, lit: &[(Match, Hsla)]) -> Frame {
+pub fn frame<T: EventListener>(
+    term: &Term<T>,
+    ink: &Ink,
+    lit: &[(Match, Hsla)],
+    link: Option<&Match>,
+) -> Frame {
     let content = term.renderable_content();
     let offset = content.display_offset as i32;
     let mut rows = vec![Row::default(); term.screen_lines()];
@@ -117,6 +122,13 @@ pub fn frame<T: EventListener>(term: &Term<T>, ink: &Ink, lit: &[(Match, Hsla)])
             .intersects(Flags::WIDE_CHAR_SPACER | Flags::LEADING_WIDE_CHAR_SPACER);
         // A placeholder's image draws over its cell; its glyph never.
         let hidden = cell.flags.contains(Flags::HIDDEN) || cell.c == super::graphics::PLACEHOLDER;
+        if !hidden
+            && look.underline == Underline::None
+            && link.is_some_and(|link| covers(&|at| link.contains(&at)))
+        {
+            look.underline = Underline::Single;
+            look.underline_color = look.fg;
+        }
         let marks = cell.zerowidth().filter(|marks| !marks.is_empty());
         let alone = (!hidden && (marks.is_some() || boxes::drawn(cell.c))).then(|| {
             std::iter::once(cell.c)
@@ -204,6 +216,9 @@ fn style(cell: &Cell, ink: &Ink, set: &Colors) -> Style {
     }
 }
 
+#[cfg(test)]
+mod hover_tests;
+
 #[cfg(test)]
 mod tests {
     use alacritty_terminal::{
@@ -220,7 +235,7 @@ mod tests {
         let mut parser: Processor = Processor::new();
         parser.advance(&mut term, bytes);
         let ink = Ink::new(themes::find("dracula").expect("dracula"), term.colors());
-        (frame(&term, &ink, &[]), ink)
+        (frame(&term, &ink, &[], None), ink)
     }
 
     #[test]
@@ -338,7 +353,7 @@ mod tests {
         selection.update(Point::new(Line(0), Column(3)), Side::Left);
         term.selection = Some(selection);
         let ink = Ink::new(themes::find("dracula").expect("dracula"), term.colors());
-        let frame = frame(&term, &ink, &[]);
+        let frame = frame(&term, &ink, &[], None);
         let grounds: Vec<_> = frame.rows[0]
             .runs
             .iter()
@@ -369,7 +384,7 @@ mod tests {
                 .map(|(bytes, style)| (*bytes, style.bg))
                 .collect()
         };
-        let shown = frame(&term, &ink, &lit);
+        let shown = frame(&term, &ink, &lit, None);
         assert_eq!(
             &grounds(&shown)[..5],
             [
@@ -386,7 +401,7 @@ mod tests {
             .as_mut()
             .expect("a selection")
             .update(at(6), Side::Right);
-        let shown = frame(&term, &ink, &lit);
+        let shown = frame(&term, &ink, &lit, None);
         assert_eq!(
             grounds(&shown)[3],
             (1, Some(ink.selection)),
diff --git a/src/term/frame/hover_tests.rs b/src/term/frame/hover_tests.rs
new file mode 100644
index 0000000..3d907e2
--- /dev/null
+++ b/src/term/frame/hover_tests.rs
@@ -0,0 +1,86 @@
+use super::*;
+use crate::{term::links::hit_at, themes};
+use alacritty_terminal::{
+    event::VoidListener,
+    grid::Scroll,
+    index::{Column, Line},
+    term::{Config, test::TermSize},
+    vte::ansi::Processor,
+};
+
+fn term(text: &str) -> Term<VoidListener> {
+    let mut term = Term::new(Config::default(), &TermSize::new(12, 3), VoidListener);
+    <Processor>::new().advance(&mut term, text.as_bytes());
+    term
+}
+
+fn styles(frame: &Frame) -> Vec<Style> {
+    frame
+        .rows
+        .iter()
+        .flat_map(|row| {
+            row.runs
+                .iter()
+                .flat_map(|(bytes, style)| std::iter::repeat_n(*style, *bytes))
+        })
+        .collect()
+}
+
+fn shown(term: &Term<VoidListener>, hover: Option<Point>) -> Frame {
+    let ink = Ink::new(themes::find("dracula").expect("a theme"), term.colors());
+    let link = hover.and_then(|point| hit_at(term, point));
+    frame(term, &ink, &[], link.as_ref())
+}
+
+#[test]
+fn hover_underlines_the_whole_link_and_leaving_restores_its_style() {
+    let term = term("(https://a.b/c) ");
+    let hover = Point::new(Line(0), Column(4));
+    let painted = styles(&shown(&term, Some(hover)));
+    assert_eq!(painted[0].underline, Underline::None);
+    assert!(
+        painted[1..14]
+            .iter()
+            .all(|style| style.underline == Underline::Single)
+    );
+    assert_eq!(painted[14].underline, Underline::None);
+    assert!(
+        styles(&shown(&term, None))
+            .iter()
+            .all(|style| style.underline == Underline::None)
+    );
+    assert!(!term.grid()[hover].flags.contains(Flags::UNDERLINE));
+}
+
+#[test]
+fn hover_preserves_explicit_underlines_and_hidden_text() {
+    let term = term("\x1b[4:3m\x1b]8;;https://a.b\x07label\x1b]8;;\x07");
+    let hover = Point::new(Line(0), Column(2));
+    assert_eq!(shown(&term, Some(hover)).rows, shown(&term, None).rows);
+    let term = self::term("\x1b[8mhttps://a.b\x1b[0m");
+    assert!(
+        styles(&shown(&term, Some(hover)))
+            .iter()
+            .all(|style| style.underline == Underline::None)
+    );
+}
+
+#[test]
+fn hover_follows_history_and_output_changes_without_a_mouse_move() {
+    let mut term = term("https://a.b\r\nnext\r\nlast\r\nbottom");
+    term.scroll_display(Scroll::Top);
+    let hover = Point::new(Line(-1), Column(2));
+    assert!(
+        styles(&shown(&term, Some(hover)))[..11]
+            .iter()
+            .all(|style| style.underline == Underline::Single)
+    );
+    let mut term = self::term("https://a.b");
+    let hover = Point::new(Line(0), Column(2));
+    <Processor>::new().advance(&mut term, b"\r\x1b[2Kplain");
+    assert!(
+        styles(&shown(&term, Some(hover)))
+            .iter()
+            .all(|style| style.underline == Underline::None)
+    );
+}
diff --git a/src/term/links.rs b/src/term/links.rs
index 266297d..5aded05 100644
--- a/src/term/links.rs
+++ b/src/term/links.rs
@@ -1,36 +1,168 @@
+use std::ops::{Range, RangeInclusive};
+
 use alacritty_terminal::{
-    index::{Boundary, Point},
-    term::{Term, cell::Flags},
+    grid::Dimensions,
+    index::{Boundary, Column, Line, Point},
+    term::{
+        Term,
+        cell::{Cell, Flags},
+    },
 };
 use ely_gpui_component::terminal::{Target, links};
+use gpui::SharedString;
 
 use super::prompts;
 
+/// Auto-detected URLs need a complete token within both budgets.
+const URL_CELLS: usize = 4096;
+const URL_BYTES: usize = 16 * 1024;
+
 /// The OSC 8 target at `point`, else a URL in its wrapped line; a prompt's own link is no target.
-pub fn link_at<T>(term: &Term<T>, mut point: Point) -> Option<String> {
-    let grid = term.grid();
-    if grid[point].flags.contains(Flags::WIDE_CHAR_SPACER) {
+pub fn link_at<T>(term: &Term<T>, point: Point) -> Option<String> {
+    let point = character_at(term, point);
+    if let Some(link) = term.grid()[point]
+        .hyperlink()
+        .filter(|link| link.uri() != prompts::LINK)
+    {
+        return Some(link.uri().to_string());
+    }
+    url_at(term, point).map(|(url, _, _)| url.to_string())
+}
+
+fn character_at<T>(term: &Term<T>, mut point: Point) -> Point {
+    if term.grid()[point].flags.contains(Flags::WIDE_CHAR_SPACER) {
         point.column -= 1;
     }
+    point
+}
+
+pub(super) fn hit_at<T>(term: &Term<T>, point: Point) -> Option<RangeInclusive<Point>> {
+    let grid = term.grid();
+    let top = Line(-(grid.display_offset() as i32));
+    let first_visible = Point::new(top, Column(0));
+    let last_visible = Point::new(top + term.screen_lines() - 1, term.last_column());
+    if !(first_visible..=last_visible).contains(&point) {
+        return None;
+    }
+    let point = character_at(term, point);
     if let Some(link) = grid[point]
         .hyperlink()
         .filter(|link| link.uri() != prompts::LINK)
     {
-        return Some(link.uri().to_string());
+        let (mut first, mut last) = (point, point);
+        while first > first_visible {
+            let previous = first.sub(term, Boundary::Grid, 1);
+            if grid[previous].hyperlink().as_ref() != Some(&link) {
+                break;
+            }
+            first = previous;
+        }
+        while last < last_visible {
+            let next = last.add(term, Boundary::Grid, 1);
+            if grid[next].hyperlink().as_ref() != Some(&link) {
+                break;
+            }
+            last = next;
+        }
+        return Some(first..=last);
+    }
+    let (_, bytes, mut cell) = url_at(term, point)?;
+    let (mut byte, mut first) = (0, None);
+    for _ in 0..URL_CELLS {
+        let content = &grid[cell];
+        if !spacer(content) {
+            let end = byte
+                + content.c.len_utf8()
+                + content
+                    .zerowidth()
+                    .into_iter()
+                    .flatten()
+                    .map(|ch| ch.len_utf8())
+                    .sum::<usize>();
+            if end > bytes.start {
+                first.get_or_insert(cell);
+            }
+            if end >= bytes.end {
+                let last = if content.flags.contains(Flags::WIDE_CHAR) {
+                    cell.add(term, Boundary::Grid, 1)
+                } else {
+                    cell
+                };
+                return Some(first?..=last);
+            }
+            byte = end;
+        }
+        cell = cell.add(term, Boundary::Grid, 1);
+    }
+    None
+}
+
+fn spacer(cell: &Cell) -> bool {
+    cell.flags
+        .intersects(Flags::WIDE_CHAR_SPACER | Flags::LEADING_WIDE_CHAR_SPACER)
+}
+
+fn token<T>(term: &Term<T>, point: Point) -> Option<RangeInclusive<Point>> {
+    let grid = term.grid();
+    let separator = |point: Point| {
+        let cell = &grid[point];
+        !spacer(cell) && (cell.c.is_whitespace() || matches!(cell.c, '<' | '>' | '"' | '\'' | '`'))
+    };
+    if separator(point) {
+        return None;
+    }
+    let (mut first, mut last, mut count) = (point, point, 1);
+    loop {
+        let previous = first.sub(term, Boundary::Grid, 1);
+        if previous == first
+            || (first.column == Column(0) && !grid[previous].flags.contains(Flags::WRAPLINE))
+            || separator(previous)
+        {
+            break;
+        }
+        if count == URL_CELLS {
+            return None;
+        }
+        first = previous;
+        count += 1;
     }
-    let end = term.line_search_right(point);
-    let mut cell = term.line_search_left(point);
+    loop {
+        let next = last.add(term, Boundary::Grid, 1);
+        if next == last
+            || (last.column == term.last_column() && !grid[last].flags.contains(Flags::WRAPLINE))
+            || separator(next)
+        {
+            break;
+        }
+        if count == URL_CELLS {
+            return None;
+        }
+        last = next;
+        count += 1;
+    }
+    Some(first..=last)
+}
+
+fn url_at<T>(term: &Term<T>, point: Point) -> Option<(SharedString, Range<usize>, Point)> {
+    let grid = term.grid();
+    let token = token(term, point)?;
+    let mut cell = *token.start();
     let (mut text, mut at) = (String::new(), 0);
     loop {
         if cell == point {
             at = text.len();
         }
-        let spacer = Flags::WIDE_CHAR_SPACER | Flags::LEADING_WIDE_CHAR_SPACER;
-        if !grid[cell].flags.intersects(spacer) {
-            text.push(grid[cell].c);
-            text.extend(grid[cell].zerowidth().into_iter().flatten());
+        if !spacer(&grid[cell]) {
+            for ch in
+                std::iter::once(&grid[cell].c).chain(grid[cell].zerowidth().into_iter().flatten())
+            {
+                if text.len() + ch.len_utf8() > URL_BYTES {
+                    return None;
+                }
+                text.push(*ch);
+            }
         }
-        if cell == end {
+        if cell == *token.end() {
             break;
         }
         cell = cell.add(term, Boundary::Grid, 1);
@@ -38,7 +170,7 @@ pub fn link_at<T>(term: &Term<T>, mut point: Point) -> Option<String> {
     links(&text)
         .into_iter()
         .find_map(|(bytes, target)| match target {
-            Target::Url(url) if bytes.contains(&at) => Some(url.to_string()),
+            Target::Url(url) if bytes.contains(&at) => Some((url, bytes, *token.start())),
             _ => None,
         })
 }
@@ -102,4 +234,174 @@ mod tests {
             "a wide cell's spacer is its char"
         );
     }
+
+    fn hit(text: &str, line: i32, column: usize) -> RangeInclusive<Point> {
+        let mut term = Term::new(Config::default(), &TermSize::new(12, 4), VoidListener);
+        <Processor>::new().advance(&mut term, text.as_bytes());
+        hit_at(&term, at(line, column)).expect("a link")
+    }
+
+    fn at(line: i32, column: usize) -> Point {
+        Point::new(Line(line), Column(column))
+    }
+
+    #[test]
+    fn hover_covers_the_wrapped_url_without_its_punctuation() {
+        assert_eq!(hit("中 (http://a.b).", 0, 8), at(0, 4)..=at(1, 1));
+        assert_eq!(hit("file://a/中 x", 0, 10), at(0, 0)..=at(0, 10));
+        assert_eq!(
+            hit("https://e.test/cafe\u{301}/x", 1, 1),
+            at(0, 0)..=at(1, 8)
+        );
+    }
+
+    #[test]
+    fn osc_8_hover_covers_its_label_and_keeps_separate_links_apart() {
+        let text = "a \x1b]8;;https://a.b\x07abcdefghijklmn\x1b]8;;\x07 z";
+        assert_eq!(hit(text, 1, 1), at(0, 2)..=at(1, 3));
+        let text = "\x1b]8;;https://a.b\x07one\x1b]8;;\x07 \x1b]8;;https://a.b\x07two\x1b]8;;\x07";
+        assert_eq!(hit(text, 0, 1), at(0, 0)..=at(0, 2));
+        assert_eq!(hit(text, 0, 5), at(0, 4)..=at(0, 6));
+    }
+
+    #[test]
+    fn a_long_osc_8_link_is_searched_only_inside_the_viewport() {
+        use alacritty_terminal::grid::Scroll;
+
+        let mut term = Term::new(Config::default(), &TermSize::new(12, 4), VoidListener);
+        let text = format!(
+            "\x1b]8;;https://a.b\x07{}\x1b]8;;\x07",
+            "x".repeat(12 * 2048)
+        );
+        <Processor>::new().advance(&mut term, text.as_bytes());
+        assert!(term.grid().history_size() > 1000);
+        for scroll in [Scroll::Bottom, Scroll::Delta(100), Scroll::Top] {
+            term.scroll_display(scroll);
+            let top = -(term.grid().display_offset() as i32);
+            let hover = hit_at(&term, at(top + 1, 5)).expect("a visible link");
+            assert_eq!(hover, at(top, 0)..=at(top + 3, 11));
+            let outside = if top == 0 {
+                Point::new(term.grid().topmost_line(), Column(0))
+            } else {
+                Point::new(term.grid().bottommost_line(), Column(0))
+            };
+            assert!(hit_at(&term, outside).is_none());
+            assert_eq!(link_at(&term, outside).as_deref(), Some("https://a.b"));
+        }
+    }
+
+    fn parsed(text: &str) -> Term<VoidListener> {
+        let mut term = Term::new(Config::default(), &TermSize::new(12, 4), VoidListener);
+        <Processor>::new().advance(&mut term, text.as_bytes());
+        term
+    }
+
+    #[test]
+    fn a_long_plain_logical_line_stops_at_the_cell_budget() {
+        use alacritty_terminal::grid::Scroll;
+
+        let mut term = parsed(&"x".repeat(12 * 2048));
+        for scroll in [Scroll::Bottom, Scroll::Delta(100), Scroll::Top] {
+            term.scroll_display(scroll);
+            let point = at(-(term.grid().display_offset() as i32) + 1, 5);
+            assert!(token(&term, point).is_none());
+            assert!(hit_at(&term, point).is_none());
+            assert!(link_at(&term, point).is_none());
+        }
+    }
+
+    #[test]
+    fn an_oversized_url_is_not_opened_or_underlined_as_a_truncated_url() {
+        let url = format!("https://a.b/{}", "x".repeat(URL_CELLS));
+        let term = parsed(&url);
+        for point in [Point::new(term.grid().topmost_line(), Column(3)), at(2, 5)] {
+            assert!(link_at(&term, point).is_none());
+        }
+        assert!(hit_at(&term, at(2, 5)).is_none());
+        let url = format!("https://a.b/{}", "x".repeat(URL_CELLS - 12));
+        let term = parsed(&url);
+        assert_eq!(link_at(&term, at(2, 5)).as_deref(), Some(url.as_str()));
+    }
+
+    #[test]
+    fn a_short_wrapped_url_is_found_inside_a_long_logical_line() {
+        let url = "https://a.b/cafe\u{301}/中";
+        let term = parsed(&format!("{} ({url}).", "x".repeat(URL_CELLS * 2)));
+        let point = at(2, 0);
+        assert_eq!(link_at(&term, point).as_deref(), Some(url));
+        assert!(hit_at(&term, point).is_some());
+    }
+
+    #[test]
+    fn hard_newlines_do_not_join_url_fragments() {
+        let term = parsed("https://a.b/\r\npath");
+        assert!(link_at(&term, at(1, 1)).is_none());
+        assert_eq!(link_at(&term, at(0, 4)).as_deref(), Some("https://a.b/"));
+    }
+
+    #[test]
+    fn combining_marks_cannot_exceed_the_text_budget() {
+        let term = parsed(&format!("https://a.b/e{}", "\u{301}".repeat(URL_BYTES)));
+        assert!(token(&term, at(0, 5)).is_some());
+        assert!(url_at(&term, at(0, 5)).is_none());
+        assert!(link_at(&term, at(0, 5)).is_none());
+        assert!(hit_at(&term, at(0, 5)).is_none());
+    }
+
+    #[test]
+    fn a_short_url_in_compact_json_is_not_rejected_with_a_long_field() {
+        let term = parsed(&format!(
+            r#"{{"padding":"{}","url":"https://a.b"}}"#,
+            "中".repeat(5000)
+        ));
+        let point = term
+            .renderable_content()
+            .display_iter
+            .find(|cell| cell.cell.c == 'h')
+            .expect("the URL is visible")
+            .point;
+        assert_eq!(link_at(&term, point).as_deref(), Some("https://a.b"));
+        assert_eq!(
+            hit_at(&term, point),
+            Some(point..=point.add(&term, Boundary::Grid, 10))
+        );
+    }
+
+    #[test]
+    fn url_delimiters_isolate_long_neighbors_on_both_sides() {
+        use alacritty_terminal::grid::Scroll;
+
+        for delimiter in ['"', '\'', '<', '>', '`'] {
+            for trailing in [false, true] {
+                let padding = "x".repeat(5000);
+                let text = if trailing {
+                    format!("{delimiter}https://a.b{delimiter}{padding}")
+                } else {
+                    format!("{padding}{delimiter}https://a.b{delimiter}")
+                };
+                let mut term = parsed(&text);
+                if trailing {
+                    term.scroll_display(Scroll::Top);
+                }
+                let point = term
+                    .renderable_content()
+                    .display_iter
+                    .find(|cell| cell.cell.c == 'h')
+                    .expect("the URL is visible")
+                    .point;
+                assert_eq!(link_at(&term, point).as_deref(), Some("https://a.b"));
+                assert_eq!(
+                    hit_at(&term, point),
+                    Some(point..=point.add(&term, Boundary::Grid, 10))
+                );
+                for edge in [
+                    point.sub(&term, Boundary::Grid, 1),
+                    point.add(&term, Boundary::Grid, 11),
+                ] {
+                    assert!(link_at(&term, edge).is_none());
+                    assert!(hit_at(&term, edge).is_none());
+                }
+            }
+        }
+    }
 }
diff --git a/src/term/paint.rs b/src/term/paint.rs
index 7ebe6c8..04d57d0 100644
--- a/src/term/paint.rs
+++ b/src/term/paint.rs
@@ -60,6 +60,8 @@ pub fn grid(
             let lines = (bounds.size.height / cell.height).floor() as usize;
             let origin = snapped(bounds.origin, window);
             fit.update(cx, |view, cx| {
+                let moved = view.pointer.hover.is_some()
+                    && (view.pointer.origin != origin || view.pointer.cell != cell);
                 (view.pointer.origin, view.pointer.cell) = (origin, cell);
                 if let Some((row, column)) = at {
                     let corner =
@@ -70,7 +72,7 @@ pub fn grid(
                         view.caret = caret;
                     }
                 }
-                if view.fit(columns, lines, cx) {
+                if view.fit(columns, lines, cx) || moved {
                     cx.notify();
                     window.request_animation_frame();
                 }
diff --git a/src/term/pointer.rs b/src/term/pointer.rs
index 716fe5d..b333d06 100644
--- a/src/term/pointer.rs
+++ b/src/term/pointer.rs
@@ -21,6 +21,7 @@ use crate::settings::SettingsStore;
 /// Where the grid sits, and what the mouse is doing to it.
 #[derive(Default)]
 pub struct Pointer {
+    pub(super) hover: Option<Point<Pixels>>,
     /// The grid's top-left in the window, from the last layout.
     pub origin: Point<Pixels>,
     pub cell: Size<Pixels>,
@@ -36,6 +37,26 @@ pub struct Pointer {
     rest: f32,
 }
 
+impl Pointer {
+    pub(super) fn hovered(
+        &self,
+        position: Point<Pixels>,
+        size: (usize, usize),
+    ) -> Option<(usize, usize)> {
+        let delta = position - self.origin;
+        if self.cell.width <= Pixels::ZERO
+            || self.cell.height <= Pixels::ZERO
+            || delta.x < Pixels::ZERO
+            || delta.y < Pixels::ZERO
+        {
+            return None;
+        }
+        let column = (delta.x / self.cell.width) as usize;
+        let row = (delta.y / self.cell.height) as usize;
+        (column < size.0 && row < size.1).then_some((column, row))
+    }
+}
+
 fn button(button: MouseButton) -> Option<Button> {
     match button {
         MouseButton::Left => Some(Button::Left),
@@ -184,6 +205,14 @@ impl TerminalView {
         cx: &mut Context<Self>,
     ) {
         let (cell, point, side) = self.cell_at(event.position);
+        let previous = self
+            .pointer
+            .hover
+            .and_then(|position| self.pointer.hovered(position, self.size));
+        self.pointer.hover = Some(event.position);
+        if previous != self.pointer.hovered(event.position, self.size) {
+            cx.notify();
+        }
         if self.pointer.selecting && event.pressed_button == Some(MouseButton::Left) {
             if self.pointer.click.is_some_and(|click| click != point) {
                 self.pointer.click = None;
@@ -230,6 +259,7 @@ impl TerminalView {
 
     /// Ends the mouse's gesture as releases would: a hidden terminal hears none.
     pub fn let_go(&mut self, cx: &mut Context<Self>) {
+        self.pointer.hover = None;
         self.end_selection(cx);
         self.pointer.click = None;
         for held in self.pointer.pressed.clone() {
@@ -426,6 +456,9 @@ fn everything<T>(term: &Term<T>) -> Option<Selection> {
     Some(all)
 }
 
+#[cfg(test)]
+mod hover_tests;
+
 #[cfg(test)]
 mod tests {
     use alacritty_terminal::{
diff --git a/src/term/pointer/hover_tests.rs b/src/term/pointer/hover_tests.rs
new file mode 100644
index 0000000..13df88a
--- /dev/null
+++ b/src/term/pointer/hover_tests.rs
@@ -0,0 +1,26 @@
+use super::*;
+use gpui::{point, px, size};
+
+#[test]
+fn hover_uses_only_cells_inside_the_grid() {
+    let pointer = Pointer {
+        origin: point(px(10.), px(20.)),
+        cell: size(px(8.), px(16.)),
+        ..Pointer::default()
+    };
+    let grid = (12, 4);
+    assert_eq!(pointer.hovered(point(px(10.), px(20.)), grid), Some((0, 0)));
+    assert_eq!(pointer.hovered(point(px(25.), px(51.)), grid), Some((1, 1)));
+    for position in [
+        point(px(9.), px(20.)),
+        point(px(10.), px(19.)),
+        point(px(106.), px(20.)),
+        point(px(10.), px(84.)),
+    ] {
+        assert_eq!(pointer.hovered(position, grid), None);
+    }
+    assert_eq!(
+        Pointer::default().hovered(point(px(0.), px(0.)), grid),
+        None
+    );
+}
diff --git a/src/term/view.rs b/src/term/view.rs
index ef20c1f..01bf83c 100644
--- a/src/term/view.rs
+++ b/src/term/view.rs
@@ -346,7 +346,22 @@ impl Render for TerminalView {
         let lit = self.finder.as_ref().map_or_else(Vec::new, |finder| {
             finder.lit(&term, cx.theme().colors.warning)
         });
-        let shown = frame(&term, &ink, &lit);
+        let link = self
+            .pointer
+            .hover
+            .and_then(|_| self.pointer.hovered(window.mouse_position(), self.size))
+            .and_then(|(column, row)| {
+                super::links::hit_at(
+                    &term,
+                    alacritty_terminal::index::Point::new(
+                        alacritty_terminal::index::Line(
+                            row as i32 - term.grid().display_offset() as i32,
+                        ),
+                        alacritty_terminal::index::Column(column),
+                    ),
+                )
+            });
+        let shown = frame(&term, &ink, &lit, link.as_ref());
         let mut graphics = self.pty.graphics();
         // Only a drawn session ticks; a hidden one pauses.
         let next = graphics.tick(Instant::now());
@@ -405,6 +420,11 @@ impl Render for TerminalView {
             .on_action(cx.listener(|view, _: &NextPrompt, _, cx| view.scroll_to_prompt(false, cx)))
             .on_any_mouse_down(cx.listener(Self::mouse_down))
             .on_mouse_move(cx.listener(Self::mouse_move))
+            .hover_listener_mode(gpui::HoverListenerMode::InputModalityIndependent)
+            .on_hover(cx.listener(|view, hovered: &bool, window, cx| {
+                view.pointer.hover = hovered.then(|| window.mouse_position());
+                cx.notify();
+            }))
             .on_scroll_wheel(cx.listener(Self::wheel))
             .on_drop(cx.listener(|view, paths: &ExternalPaths, _, cx| view.drop_paths(paths, cx)))
             .on_drop(cx.listener(|view, drag: &TreeDrag, _, cx| view.dragged(drag, cx)))