OSC8 Hyperlink Support

include/ghostty.h

@@ -452,6 +452,7 @@ typedef void (*ghostty_runtime_show_desktop_notification_cb)(void*,
                                                              const char*);
 typedef void (
     *ghostty_runtime_update_renderer_health)(void*, ghostty_renderer_health_e);
+typedef void (*ghostty_runtime_mouse_over_link_cb)(void*, const char*, size_t);
 
 typedef struct {
   void* userdata;
@@ -481,6 +482,7 @@ typedef struct {
   ghostty_runtime_set_cell_size_cb set_cell_size_cb;
   ghostty_runtime_show_desktop_notification_cb show_desktop_notification_cb;
   ghostty_runtime_update_renderer_health update_renderer_health_cb;
+  ghostty_runtime_mouse_over_link_cb mouse_over_link_cb;
 } ghostty_runtime_config_s;
 
 //-------------------------------------------------------------------

macos/Sources/Ghostty/Ghostty.App.swift

@@ -93,7 +93,8 @@ extension Ghostty {
                 set_cell_size_cb: { userdata, width, height in App.setCellSize(userdata, width: width, height: height) },
                 show_desktop_notification_cb: { userdata, title, body in
                     App.showUserNotification(userdata, title: title, body: body) },
-                update_renderer_health_cb: { userdata, health in App.updateRendererHealth(userdata, health: health) }
+                update_renderer_health_cb: { userdata, health in App.updateRendererHealth(userdata, health: health) },
+                mouse_over_link_cb: { userdata, ptr, len in App.mouseOverLink(userdata, uri: ptr, len: len) }
             )
 
             // Create the ghostty app.
@@ -290,6 +291,7 @@ extension Ghostty {
         static func setCellSize(_ userdata: UnsafeMutableRawPointer?, width: UInt32, height: UInt32) {}
         static func showUserNotification(_ userdata: UnsafeMutableRawPointer?, title: UnsafePointer<CChar>?, body: UnsafePointer<CChar>?) {}
         static func updateRendererHealth(_ userdata: UnsafeMutableRawPointer?, health: ghostty_renderer_health_e) {}
+        static func mouseOverLink(_ userdata: UnsafeMutableRawPointer?, uri: UnsafePointer<CChar>?, len: Int) {}
         #endif
 
         #if os(macOS)
@@ -523,6 +525,17 @@ extension Ghostty {
             let backingSize = NSSize(width: Double(width), height: Double(height))
             surfaceView.cellSize = surfaceView.convertFromBacking(backingSize)
         }
+
+        static func mouseOverLink(_ userdata: UnsafeMutableRawPointer?, uri: UnsafePointer<CChar>?, len: Int) {
+            let surfaceView = self.surfaceUserdata(from: userdata)
+            guard len > 0 else {
+                surfaceView.hoverUrl = nil
+                return
+            }
+
+            let buffer = Data(bytes: uri!, count: len)
+            surfaceView.hoverUrl = String(data: buffer, encoding: .utf8)
+        }
 
         static func showUserNotification(_ userdata: UnsafeMutableRawPointer?, title: UnsafePointer<CChar>?, body: UnsafePointer<CChar>?) {
             let surfaceView = self.surfaceUserdata(from: userdata)

macos/Sources/Ghostty/SurfaceView.swift

@@ -48,9 +48,12 @@ extension Ghostty {
 
         // Maintain whether our window has focus (is key) or not
         @State private var windowFocus: Bool = true
-
+
+        // True if we're hovering over the left URL view, so we can show it on the right.
+        @State private var isHoveringURLLeft: Bool = false
+
         @EnvironmentObject private var ghostty: Ghostty.App
-
+        
         var body: some View {
             let center = NotificationCenter.default
 
@@ -145,6 +148,39 @@ extension Ghostty {
                 }
                 .ghosttySurfaceView(surfaceView)
 
+                // If we have a URL from hovering a link, we show that.
+                if let url = surfaceView.hoverUrl {
+                    let padding: CGFloat = 3
+                    ZStack {
+                        HStack {
+                            VStack(alignment: .leading) {
+                                Spacer()
+
+                                Text(verbatim: url)
+                                    .padding(.init(top: padding, leading: padding, bottom: padding, trailing: padding))
+                                    .background(.background)
+                                    .opacity(isHoveringURLLeft ? 0 : 1)
+                                    .onHover(perform: { hovering in
+                                        isHoveringURLLeft = hovering
+                                    })
+                            }
+                            Spacer()
+                        }
+
+                        HStack {
+                            Spacer()
+                            VStack(alignment: .leading) {
+                                Spacer()
+
+                                Text(verbatim: url)
+                                    .padding(.init(top: padding, leading: padding, bottom: padding, trailing: padding))
+                                    .background(.background)
+                                    .opacity(isHoveringURLLeft ? 1 : 0)
+                            }
+                        }
+                    }
+                }
+
                 // If our surface is not healthy, then we render an error view over it.
                 if (!surfaceView.healthy) {
                     Rectangle().fill(ghostty.config.backgroundColor)

macos/Sources/Ghostty/SurfaceView_AppKit.swift

@@ -26,6 +26,9 @@ extension Ghostty {
 
         // Any error while initializing the surface.
         @Published var error: Error? = nil
+
+        // The hovered URL string
+        @Published var hoverUrl: String? = nil
 
         // An initial size to request for a window. This will only affect
         // then the view is moved to a new window.

macos/Sources/Ghostty/SurfaceView_UIKit.swift

@@ -25,6 +25,9 @@ extension Ghostty {
         // Any error while initializing the surface.
         @Published var error: Error? = nil
 
+        // The hovered URL
+        @Published var hoverUrl: String? = nil
+
         private(set) var surface: ghostty_surface_t?
 
         init(_ app: ghostty_app_t, baseConfig: SurfaceConfiguration? = nil, uuid: UUID? = nil) {

src/Surface.zig

@@ -2519,16 +2519,15 @@ fn clickMoveCursor(self: *Surface, to: terminal.Pin) !void {
 }
 
 /// Returns the link at the given cursor position, if any.
+///
+/// Requires the renderer mutex is held.
 fn linkAtPos(
     self: *Surface,
     pos: apprt.CursorPos,
 ) !?struct {
-    DerivedConfig.Link,
+    input.Link.Action,
     terminal.Selection,
 } {
-    // If we have no configured links we can save a lot of work
-    if (self.config.links.len == 0) return null;
-
     // Convert our cursor position to a screen point.
     const screen = &self.renderer_state.terminal.screen;
     const mouse_pin: terminal.Pin = mouse_pin: {
@@ -2543,6 +2542,19 @@ fn linkAtPos(
     // Get our comparison mods
     const mouse_mods = self.mouseModsWithCapture(self.mouse.mods);
 
+    // If we have the proper modifiers set then we can check for OSC8 links.
+    if (mouse_mods.equal(input.ctrlOrSuper(.{}))) hyperlink: {
+        const rac = mouse_pin.rowAndCell();
+        const cell = rac.cell;
+        if (!cell.hyperlink) break :hyperlink;
+        const sel = terminal.Selection.init(mouse_pin, mouse_pin, false);
+        return .{ ._open_osc8, sel };
+    }
+
+    // If we have no OSC8 links then we fallback to regex-based URL detection.
+    // If we have no configured links we can save a lot of work going forward.
+    if (self.config.links.len == 0) return null;
+
     // Get the line we're hovering over.
     const line = screen.selectLine(.{
         .pin = mouse_pin,
@@ -2571,7 +2583,7 @@ fn linkAtPos(
             defer match.deinit();
             const sel = match.selection();
             if (!sel.contains(screen, mouse_pin)) continue;
-            return .{ link, sel };
+            return .{ link.action, sel };
         }
     }
 
@@ -2602,8 +2614,8 @@ fn mouseModsWithCapture(self: *Surface, mods: input.Mods) input.Mods {
 ///
 /// Requires the renderer state mutex is held.
 fn processLinks(self: *Surface, pos: apprt.CursorPos) !bool {
-    const link, const sel = try self.linkAtPos(pos) orelse return false;
-    switch (link.action) {
+    const action, const sel = try self.linkAtPos(pos) orelse return false;
+    switch (action) {
         .open => {
             const str = try self.io.terminal.screen.selectionString(self.alloc, .{
                 .sel = sel,
@@ -2612,11 +2624,30 @@ fn processLinks(self: *Surface, pos: apprt.CursorPos) !bool {
             defer self.alloc.free(str);
             try internal_os.open(self.alloc, str);
         },
+
+        ._open_osc8 => {
+            const uri = self.osc8URI(sel.start()) orelse {
+                log.warn("failed to get URI for OSC8 hyperlink", .{});
+                return false;
+            };
+            try internal_os.open(self.alloc, uri);
+        },
     }
 
     return true;
 }
 
+/// Return the URI for an OSC8 hyperlink at the given position or null
+/// if there is no hyperlink.
+fn osc8URI(self: *Surface, pin: terminal.Pin) ?[]const u8 {
+    _ = self;
+    const page = &pin.page.data;
+    const cell = pin.rowAndCell().cell;
+    const link_id = page.lookupHyperlink(cell) orelse return null;
+    const entry = page.hyperlink_set.get(page.memory, link_id);
+    return entry.uri.offset.ptr(page.memory)[0..entry.uri.len];
+}
+
 pub fn mousePressureCallback(
     self: *Surface,
     stage: input.MousePressureStage,
@@ -2705,9 +2736,13 @@ pub fn cursorPosCallback(
 
         try self.mouseReport(button, .motion, self.mouse.mods, pos);
 
-        // If we were previously over a link, we need to queue a
-        // render to undo the link state.
-        if (over_link) try self.queueRender();
+        // If we were previously over a link, we need to undo the link state.
+        // We also queue a render so the renderer can undo the rendered link
+        // state.
+        if (over_link) {
+            self.rt_surface.mouseOverLink(null);
+            try self.queueRender();
+        }
 
         // If we're doing mouse motion tracking, we do not support text
         // selection.
@@ -2769,16 +2804,7 @@ pub fn cursorPosCallback(
     if (self.mouse.link_point) |last_vp| {
         // Mark the link's row as dirty.
         if (over_link) {
-            // TODO: This doesn't handle soft-wrapped links. Ideally this would
-            // be storing the link's start and end points and marking all rows
-            // between and including those as dirty, instead of just the row
-            // containing the part the cursor is hovering. This can result in
-            // a bit of jank.
-            if (self.renderer_state.terminal.screen.pages.pin(.{
-                .viewport = last_vp,
-            })) |pin| {
-                pin.markDirty();
-            }
+            self.renderer_state.terminal.screen.dirty.hyperlink_hover = true;
         }
 
         // If our last link viewport point is unchanged, then don't process
@@ -2796,17 +2822,37 @@ pub fn cursorPosCallback(
     }
     self.mouse.link_point = pos_vp;
 
-    if (try self.linkAtPos(pos)) |_| {
+    if (try self.linkAtPos(pos)) |link| {
         self.renderer_state.mouse.point = pos_vp;
         self.mouse.over_link = true;
-        // Mark the new link's row as dirty.
-        if (self.renderer_state.terminal.screen.pages.pin(.{ .viewport = pos_vp })) |pin| {
-            pin.markDirty();
-        }
+        self.renderer_state.terminal.screen.dirty.hyperlink_hover = true;
         try self.rt_surface.setMouseShape(.pointer);
+
+        switch (link[0]) {
+            .open => {
+                const str = try self.io.terminal.screen.selectionString(self.alloc, .{
+                    .sel = link[1],
+                    .trim = false,
+                });
+                defer self.alloc.free(str);
+                self.rt_surface.mouseOverLink(str);
+            },
+
+            ._open_osc8 => link: {
+                // Show the URL in the status bar
+                const pin = link[1].start();
+                const uri = self.osc8URI(pin) orelse {
+                    log.warn("failed to get URI for OSC8 hyperlink", .{});
+                    break :link;
+                };
+                self.rt_surface.mouseOverLink(uri);
+            },
+        }
+
         try self.queueRender();
     } else if (over_link) {
         try self.rt_surface.setMouseShape(self.io.terminal.mouse_shape);
+        self.rt_surface.mouseOverLink(null);
         try self.queueRender();
     }
 }

src/apprt/embedded.zig

@@ -128,6 +128,11 @@ pub const App = struct {
 
         /// Called when the health of the renderer changes.
         update_renderer_health: ?*const fn (SurfaceUD, renderer.Health) void = null,
+
+        /// Called when the mouse goes over a link. The link target is the
+        /// parameter. The link target will be null if the mouse is no longer
+        /// over a link.
+        mouse_over_link: ?*const fn (SurfaceUD, ?[*]const u8, usize) void = null,
     };
 
     /// Special values for the goto_tab callback.
@@ -1101,6 +1106,19 @@ pub const Surface = struct {
 
         func(self.userdata, health);
     }
+
+    pub fn mouseOverLink(self: *const Surface, uri: ?[]const u8) void {
+        const func = self.app.opts.mouse_over_link orelse {
+            log.info("runtime embedder does not support over_link", .{});
+            return;
+        };
+
+        if (uri) |v| {
+            func(self.userdata, v.ptr, v.len);
+        } else {
+            func(self.userdata, null, 0);
+        }
+    }
 };
 
 /// Inspector is the state required for the terminal inspector. A terminal

src/apprt/glfw.zig

@@ -649,6 +649,12 @@ pub const Surface = struct {
         self.cursor = new;
     }
 
+    pub fn mouseOverLink(self: *Surface, uri: ?[]const u8) void {
+        // We don't do anything in GLFW.
+        _ = self;
+        _ = uri;
+    }
+
     /// Set the visibility of the mouse cursor.
     pub fn setMouseVisibility(self: *Surface, visible: bool) void {
         self.window.setInputModeCursor(if (visible) .normal else .hidden);