raphamorim/rio

Rio is a cross-platform terminal emulator built in Rust that provides a high-performance, GPU-accelerated rendering engine with support for Metal, Vulkan, and WebGPU. It features a modular architecture with a standalone terminal core for VT parsing and grid management, a custom event loop library for PTY I/O, and a dedicated windowing abstraction layer for macOS, Windows, and Linux (X11/Wayland). The system supports advanced features such as inline images, custom glyph protocols, touch gestures, and cross-platform desktop notifications, while also exposing its core logic via C APIs for embedding in other applications.

29 changes.

The project established a cross-platform foundation by extracting the Sugarloaf GPU rendering engine and the Teletypewriter PTY abstraction as standalone libraries, enabling support for Windows, macOS, and Linux. This period focused on implementing native backends for GPU acceleration and pseudo-terminals, while restructuring the codebase to support WebAssembly and comprehensive desktop integration.

33 changes.

The project established a new cross-platform windowing library, rio-window, with native implementations for macOS, Windows, Linux (X11/Wayland), and Web, replacing previous platform-specific code. Concurrently, the rioterm frontend was developed with a centralized router, advanced input handling via the Kitty protocol, and enhanced UI components like a command palette and touch gesture support.

20 changes.

This period focused on extracting Rio's terminal logic into a standalone, embeddable core via the librio C API and rio-vt crate, enabling integration into non-Rust hosts and web environments. Simultaneously, the Sugarloaf rendering backend underwent a major rewrite to support a persistent GPU grid, cross-platform shader backends, and advanced features like color fonts and VR presets.

This change introduces the Rioterm terminal frontend to the project, including its build script (build.rs) which handles Windows icon resource compilation and macOS CoreGraphics weak-linking to prevent launch failures on older systems. It also adds the necessary LICENSE files for both the rioterm and wasm frontend crates, and establishes the WebAssembly build tooling (Makefile, index.html) for compiling and running the terminal in a browser environment.

frontends · high confidence

The application now ships with two built-in shader presets: a 'newpixie-crt' filter that emulates retro CRT aesthetics (curvature, scanlines, vignette, ghosting) and a 'fubax\_vr' suite that enables VR headset usage for any game, featuring stereo vision, lens distortion correction, chromatic aberration adjustment, sharpening, and a virtual nose overlay to reduce motion sickness. These presets are embedded in the binary and loaded at runtime via the \builtin\ module, which writes the shader sources and configuration files to temporary directories before parsing them as \ShaderPreset\ objects.

sugarloaf/src/components/filters/builtin · high confidence

The rio-graphics crate now includes a new glyph protocol implementation, gated behind the \glyph\ feature. This adds a TrueType \glyf\ outline decoder that parses simple-glyph records into neutral outlines and path commands, enforcing a 64 KiB decoded-size budget per outline to prevent excessive memory usage. It also introduces a per-terminal \GlyphRegistry\ that stores client-registered glyphs (including monochrome \Glyf\ and color \ColrV0\/\ColrV1\ payloads) in a FIFO-limited glossary (1024 entries), allowing the renderer to resolve codepoints to custom glyph outlines without re-transmitting data. This change enables the terminal to render custom glyphs defined via the Glyph Protocol, expanding the range of supported character representations beyond standard system fonts.

rio-graphics · high confidence

Users can now access manual pages for the Rio terminal emulator, its TOML configuration file format, and its default key bindings. This change introduces new source files in the \extra/man\ directory (written in scdoc format) and a Makefile to build and install them to the system man directory, allowing users to view documentation via standard commands like \man rio\ and \man 5 rio\.

extra · high confidence

The rio-window crate now includes a suite of examples in the rio-window/examples directory that demonstrate core windowing capabilities. These include child window creation (child\_window.rs), various event loop control flow modes such as Wait, WaitUntil, and Poll (control\_flow.rs), manual event pumping (pump\_events.rs), and on-demand event loop execution (run\_on\_demand.rs). Additional examples showcase platform-specific features like X11 window embedding (x11\_embed.rs) and comprehensive window state management with custom cursors and icons (window.rs). Utility modules for window filling and tracing are also provided to support these demonstrations.

rio-window/examples · high confidence

The terminal now supports touch gestures on compatible devices, including tap-to-select, tap-to-scroll, and two-finger pinch-to-zoom for adjusting font size. Additionally, a new hint system has been introduced, allowing users to interact with terminal content via regex-based hints that can be triggered and clicked.

frontends/rioterm/src/screen · high confidence

The Wayland platform implementation now includes type definitions and dispatch handlers for several Wayland protocols. This adds support for custom cursor rendering via \wl\_shm\, fractional scaling via \wp-fractional-scaling-v1\, window viewporting via \wp-viewporter\, and user attention requests via \xdg-activation-v1\. It also introduces bindings for the \ext-background-effect-v1\ protocol (for background blur) and the KDE-specific \org\_kde\_kwin\_blur\ protocol, enabling compositor-specific blur effects on Linux.

_rio-window/src/platform\impl/linux/wayland/types · high confidence

This change introduces the Windows-specific implementation for the mio event library, located in \corcovado/src/sys/windows\. It adds the \Awakener\, \Selector\, and \Binding\ components necessary to map mio's readiness-based API onto Windows' completion-based IOCP model, enabling the library to function on Windows platforms.

corcovado/src/sys/windows · high confidence

The teletypewriter examples directory now includes two new Rust programs: \non\_blocking.rs\, which demonstrates how to read from stdin in a non-blocking manner using a separate thread and a channel, and \spawn.rs\, which shows how to create a pseudo-terminal (PTY) with a fork, write commands to it, and read the output byte-by-byte. These examples serve as practical guides for integrating teletypewriter's core PTY and I/O capabilities into applications.

teletypewriter/examples · high confidence

New utility scripts have been added to misc/scripts to help users and developers verify terminal capabilities. These include scripts for displaying ANSI color palettes (all-styles, background-colors, primary-colors), testing text formatting and various underline styles (text, underlines), and inspecting Unicode drawable characters like box-drawing and braille (drawable-chars). Additionally, test scripts for the iTerm2 image protocol (test-iterm2-image-protocol.sh) and OSC 9;4 progress bar handling (test-progress-bar.sh) are now available, along with the imgcat utility for inline image display.

misc/scripts · high confidence

The configuration system has been completely restructured into modular components, introducing several new user-facing capabilities. Users can now customize visual effects including a configurable cursor trail (with color, opacity, and decay settings) and window blur styles (including macOS liquid glass). The tab navigation system offers new controls such as hiding the strip for a single tab, setting maximum tab width, and adjusting unfocused split opacity. Platform-specific settings allow distinct configurations for Linux, Windows, and macOS, including per-platform shell and window properties. Additional features include configurable bell behavior (audio and tab indicators), enhanced hint system rules with custom regex and actions, and renderer options like CPU fallback and occluded render disabling. The layout system now supports granular margin and padding controls for panels and the main window.

rio-backend/src/config · high confidence

A new component named Corcovado has been added, serving as a maintained fork of mio 0.6.x (including mio-signal-hook and mio-extras) specifically tailored for Rio's PTY event loop. This fork retains core readiness polling capabilities via epoll, kqueue, and IOCP, along with cross-thread channels, user-space readiness, and Unix-domain sockets for signal handling. To reduce complexity, it removes networking types (TCP/UDP), timers, and the Fuchsia backend, while adopting the Rust 2021 edition and the standard library for network and I/O operations.

corcovado · high confidence

This change introduces the foundational Wayland backend for the Rio Window crate on Linux, replacing or supplementing the previous X11-only approach. It implements core window management via the XDG shell, including monitor enumeration, video mode handling, and input processing (pointer, keyboard, text input). The implementation also adds support for fractional scaling, custom cursors, and adaptive system themes (light/dark mode) by monitoring system color schemes. Additionally, it includes experimental support for background blur effects via the ext-background-effect-v1 and KWin blur protocols, and implements an input rate tracker to optimize presentation windows during high-frequency input events.

_rio-window/src/platform\impl/linux/wayland · high confidence

Teletypewriter now supports Windows by introducing a new ConPTY backend. This change adds Windows-specific modules (\child\, \conpty\, \pipes\, \spsc\) that handle pseudoconsole creation, asynchronous pipe I/O, and child process exit monitoring, enabling the terminal to run native shells on Windows.

teletypewriter/src/windows · high confidence

The rio-grid module now supports rendering IME (Input Method Editor) composition strings inline at the cursor position. This change introduces a \PreeditRow\ structure and associated logic to handle composition text layout, ensuring it stays on a single row by sliding left or dropping leading clusters if it exceeds the grid width. It correctly segments text into grapheme clusters, handles wide characters, and renders the IME caret (either as an underline on a composition cell or a beam on the following cell) while suppressing underlying cell ink to prevent visual artifacts. This allows users to see their IME input directly within the terminal grid before final submission.

rio-grid · high confidence

The rendering context now supports a CPU-based backend (via \softbuffer\) in addition to the existing GPU paths (Metal, Vulkan, WebGPU). This allows the terminal to render on systems where hardware acceleration is unavailable or disabled, ensuring basic functionality across all environments.

sugarloaf/src/context · high confidence

Added the core event loop infrastructure for Wayland on Linux, including the main \EventLoop\ struct, an \EventLoopProxy\ for cross-thread event sending, and an \EventSink\ for buffering and delivering window and device events to the application.

_rio-window/src/platform\_impl/linux/wayland/event\loop · high confidence

The librio crate now exposes a C-compatible API (capi.rs) that allows external hosts to embed and control a terminal instance. This interface provides functions to configure the terminal shell and working directory, handle key events with support for modern protocols like Kitty keyboard and modifyOtherKeys, manage selections, and retrieve render state including cell colors, cursor position, and Kitty image placements. It also exposes terminal actions such as title changes, bell rings, and progress updates, enabling embedders to integrate a fully featured terminal into their applications.

librio/src · high confidence

Adds a new \librio-wasm\ crate that compiles the \librio\ terminal engine (without PTY support) to WebAssembly and exposes a JavaScript API via \wasm-bindgen\ for the \rioterm\ npm package. This enables browser-based terminal embedders to drive the terminal by feeding output via \feed\ and receiving host events (key presses, mouse reports, clipboard, title changes) through JS callbacks, effectively bridging the Rust terminal core to web environments.

librio-wasm · high confidence

Adds libsugarloaf, a new C ABI library that exposes Rio's sugarloaf GPU renderer to host applications. It allows a host (such as a Swift/AppKit app) to provide an NSView, after which the library manages the CAMetalLayer, glyph atlas, and GPU compositing. The API requires the host to handle glyph rasterization and cell data preparation, passing them via plain pointers for efficient per-frame rendering.

libsugarloaf · high confidence

The new \rio-window\ crate provides a cross-platform API for window creation and event loop management, exposing core components such as \EventLoop\, \Window\, and \ApplicationHandler\ for handling user input and system events. This library supports multiple platforms including macOS, Windows, and Linux (via X11/Wayland), and includes features like custom cursors, keyboard input handling, monitor management, and platform-specific hooks (e.g., macOS quit confirmation, quake mode). It replaces or supplements previous windowing logic by offering a unified interface for building GUI applications with consistent behavior across operating systems.

rio-window/src · high confidence

The new rio-window crate provides platform-specific windowing implementations for Redox (orbital) and Web (Wasm). The Redox backend implements window creation, event handling, and socket-based communication with the orbital compositor. The Web backend provides a complete async event loop, window management, custom cursor support, and thread-safe dispatching mechanisms tailored for single-threaded Wasm environments.

_rio-window/src/platform\_impl/orbital, rio-window/src/platform\impl/web · high confidence

This change introduces the \rio-window\ crate, establishing a new platform abstraction layer that exposes native capabilities for macOS, Linux (X11/Wayland), Windows, and Web. On macOS, users gain access to wide color gamut support (Display P3), unified title bars, background color customization, and liquid-glass opacity effects. Linux users can now follow the system dark/light theme via the XDG Desktop Portal and utilize startup activation tokens for proper window focus. Windows users receive native backdrop materials (Mica, Acrylic), rounded corner preferences, and direct access to window handles. Additionally, the library provides cross-platform utilities for integrating with external event loops, handling raw scancodes, and managing modifier keys.

rio-window/src/platform · high confidence

The \teletypewriter\ library now provides a unified interface for managing pseudo-terminals (PTYs) across Unix and Windows platforms. This change introduces platform-specific modules (\unix\ and \windows\) that implement common traits like \ProcessReadWrite\ and \EventedPty\, allowing applications to handle terminal I/O, window resizing, and child process events (such as exit status) through a consistent API regardless of the underlying operating system.

teletypewriter/src · high confidence

The rio-window crate has been introduced as a fork of Winit, maintained specifically for the Rio terminal. This change adds the foundational build infrastructure, including a build script that configures platform-specific configuration aliases (such as x11, wayland, and macOS) and generates native dispatch bindings for macOS to support low-level display operations.

rio-window · high confidence

The Linux backend now includes a new common platform implementation module that provides XKB-based keyboard input handling and monitors for system-wide dark/light theme changes. The keyboard subsystem (in \xkb/\) maps raw scancodes to physical keys, manages XKB keymaps and compose states for input method support, and exposes modifier states, aligning scancode conversions with Firefox. Additionally, a background theme monitor (\theme\_monitor.rs\) listens to the XDG Desktop Portal for \color-scheme\ updates and emits \WindowEvent::ThemeChanged\ to keep the application's UI in sync with the system appearance.

_rio-window/src/platform\impl/linux/common · high confidence

The rio-notifier module now provides cross-platform desktop notifications. On macOS, it uses UNUserNotificationCenter to request permission and display alerts; on Linux, it sends notifications via D-Bus; and on Windows, it renders toast notifications. The send\_notification function operates on a background thread to avoid blocking the caller, and defaults the app name to 'Rio' if none is provided.

rio-notifier · high confidence

The renderer now includes several new UI components: an assistant overlay for displaying errors and warnings with actionable buttons, a command palette for executing terminal commands and navigation, a confirm-quit dialog, a custom pixel-art cursor, and a trail cursor with configurable easing and fade-out. Additionally, a font cache with a two-tier strategy (hot cache for ASCII and LRU for others) has been added to prevent unbounded memory growth and improve performance, and a shared scrollbar module with fade-in/out logic and geometry computation is now available for use across UI elements.

frontends/rioterm/src/renderer · high confidence

This change introduces the core Unix implementation components for the \corcovado\ event loop, including \epoll\ (Linux/Android) and \kqueue\ (BSD/macOS) selectors, a pipe-based \Awakener\ for cross-thread wakeup, and support for Unix domain sockets (\UnixSocket\) with file descriptor passing. It also adds \EventedFd\ to allow registering arbitrary file descriptors with the poller, \dlsym\ for dynamic loading of system calls like \epoll\_create1\ and \pipe2\, and \UnixReady\ to expose platform-specific readiness events like HUP and error states.

corcovado/src/sys/unix · high confidence

The filter rendering engine has been replaced with a new runtime built on the WGPU graphics API, ported from the librashader library. This change introduces a complete set of components for managing shader presets, including a filter chain loader, graphics pipeline creation, texture and sampler management, and mipmap generation. Users will now benefit from hardware-accelerated shader execution via WGPU, with support for features like pipeline caching and configurable filter options.

sugarloaf/src/components/filters/runtime · high confidence

The Wayland platform implementation for the rio-window crate now includes a complete seat input subsystem. This adds support for keyboard events (including keymap handling, focus changes, and key repeat timers), pointer events (mouse movement, clicks, and cursor shape management), touch input (multi-touch points with start, move, end, and cancel phases), relative pointer motion, and text input (IME preedit, commit, and enable/disable states). These changes provide the foundational input event routing for Wayland windows within the application.

_rio-window/src/platform\impl/linux/wayland/seat · high confidence

The rio-window crate now includes a complete native implementation for Windows, replacing previous platform-specific code. This new backend provides full support for high-DPI scaling across Windows versions, native dark mode integration that respects system settings, and proper handling of file drag-and-drop operations. It also features improved keyboard input processing with accurate scancode conversion, inline IME composition support for CJK input methods, and robust window management including taskbar integration and proper icon handling.

_rio-window/src/platform\_impl/linux/x11/ime, rio-window/src/platform\impl/windows · high confidence

The \rio-window\ crate on Linux now includes a new \platform\_impl/linux/x11/util\ module that provides core X11 integration utilities. This addition introduces helpers for managing X11 client messages, generic event cookies, and cursor handling (including custom cursor creation and caching). It also adds geometry utilities for calculating frame extents and coordinate translations, as well as support for EWMH and Motif window manager hints. Input handling is enhanced with XInput and XKB event selection, UTF-8 key lookup, and modifier key mapping. Additional utilities cover mouse delta filtering, RandR-based DPI calculation and screen configuration, window property retrieval, and window manager information caching.

_rio-window/src/platform\impl/linux/x11/util · high confidence

The core component module now includes foundational types for rendering, including a \Buffer\ wrapper for wgpu memory management, \Uniforms\ for shader data, and geometric primitives like \Rectangle\ and \Size\. It also introduces a new \image\ module that provides an \Handle\ and \Data\ enum for managing raster image assets via file paths, raw bytes, or decoded RGBA pixels, enabling the rendering of image backgrounds.

sugarloaf/src/components/core · high confidence

The librio/include directory now provides a curated C header (librio.h) and module map for RioKit, exposing an embeddable terminal core API. This allows non-Rust consumers (such as Swift or C hosts) to manage PTY spawning, VT parsing, and terminal state, and to pull render state (including cell colors, styles, cursor shape, and selection) via a host-pulled API with per-row dirty tracking. The header defines the C ABI structures and constants for actions, colors, keys, and styles that embedders use to integrate the terminal logic.

librio/include · high confidence

This change introduces the initial shader implementations for the grid renderer, adding \grid.metal\ and \grid.wgsl\ for Metal and WebGPU backends, and \grid\_bg.frag.glsl\, \grid\_bg.vert.glsl\, \grid\_text.frag.glsl\, \grid\_text.vert.glsl\, and \ui\_text.vert.glsl\ for the Vulkan backend. These files implement the background pass (cell colors, padding, and cursor overlay) and the text pass (glyph rendering with atlas sampling), ensuring consistent color space handling (sRGB, DisplayP3, Rec2020) and visual parity across all three graphics APIs.

sugarloaf/src/grid/shaders · high confidence

The \rio-window\ crate on macOS now includes a comprehensive set of safe bindings for the AppKit framework, replacing the previous legacy menu implementation. This change introduces modules for core application management (NSApplication), windowing (NSWindow), user interface elements (NSView, NSButton, NSControl), input handling (NSEvent, NSCursor), and system services (NSPasteboard, NSScreen). It also provides bindings for text input (NSTextInputContext), appearance management (NSAppearance), and version detection, enabling the application to interact directly with macOS native features.

_rio-window/src/platform\impl/macos/appkit · high confidence

The application now uses the new rioterm frontend, which introduces automatic shell integration for zsh, fish, and PowerShell to report the working directory and enable opening new tabs in the current directory. It also adds a Quake-style window that can be toggled via a system-wide global hotkey, and supports writing the configuration file via the new \--write-config\ CLI flag.

frontends/rioterm/src · high confidence

The terminal now uses the new sugarloaf rendering engine, which replaces the previous renderer. This change introduces native GPU backends for macOS (Metal) and Linux (Vulkan), with a unified wgpu backend for Windows and WebAssembly, alongside a CPU fallback. The new engine supports configurable input colorspace (sRGB, Display P3, Rec2020) for accurate color rendering, adds support for retroarch-style image filters (ported from librashader) via the wgpu backend, and implements the Kitty graphics protocol for inline images. It also includes a new font caching system using swash for cross-platform font resolution and improved text layout with proper line-height and scaling support.

sugarloaf/src · high confidence

The application now displays a welcome screen on startup, featuring an animated logo and configuration path, accessible via the new Welcome route. Additionally, a dedicated Assistant route has been added to display error reports from the backend.

frontends/rioterm/src/router/routes · high confidence

The repository has been initialized with the core project structure, including a Rust toolchain configuration (channel 1.96.1) and formatting rules. A Nix flake has been added to provide reproducible development environments and package definitions for Linux and macOS, supporting both X11 and Wayland backends. The release pipeline is configured via GoReleaser to build and distribute binaries for Windows, macOS, and Linux (deb/rpm), while the Makefile provides local build, test, and packaging targets.

(repo-wide) · high confidence

Rio now includes the necessary metadata and configuration files for Linux distribution packaging and improved terminal compatibility. A new AppStream metainfo file (\com.rioterm.Rio.metainfo.xml\) provides release history, branding colors, and screenshots for software centers, while a desktop entry file (\rio.desktop\) enables proper application launching. Additionally, terminfo and termcap definitions (\rio.terminfo\, \rio.termcap\) are added to support 256-color and truecolor modes, and a release preparation script (\prepare-release.sh\) automates version bumping and metainfo updates.

misc · high confidence

The Sugarloaf rendering engine, previously part of the Rio source code, is now available as a separate, standalone library. It supports Linux (via a Vulkan backend that compiles GLSL shaders to SPIR-V at build time using system tools like glslc or glslangValidator), Desktop, and WebAssembly targets. The extraction includes a new MIT license, a Makefile for building and testing (including WASM tests via wasm-bindgen), and documentation detailing build dependencies and test setup.

sugarloaf · high confidence

The filters component now supports applying RetroArch-style shader filters using the WGPU backend. Users can load custom filters from file paths or use built-in presets like 'newpixiecrt' and 'fubax\_vr'. The implementation manages a chain of filter passes, allocating intermediate textures for multi-filter rendering and handling source/destination texture copying to ensure compatibility with various shader requirements.

sugarloaf/src/components/filters · high confidence

The new \frontends/wasm/src/lib.rs\ file introduces a WASM-specific entry point that initializes \console\_tracing\ and sets up a web canvas. Crucially, it adds an in-page UI element (an unordered list) that displays a timestamped log of window events (such as keyboard input and redraw requests). This provides developers with a visible, browser-based alternative to console logs for debugging interactions in the WASM build.

frontends/wasm · high confidence

The Wayland window implementation now supports background blur effects on Linux. This is achieved by integrating with the \ext-background-effect-v1\ protocol and the KDE KWin blur protocol, allowing applications to request a blurred background for their windows when the compositor supports it.

_rio-window/src/platform\impl/linux/wayland/window · high confidence

The macOS application bundle (Info.plist) is now configured to declare support for opening URLs via the 'rio' scheme and provides Finder services for opening new tabs in the current directory. The bundle also includes usage descriptions for various system permissions (camera, microphone, local network, etc.) and sets the minimum system version to macOS 10.15.7.

misc/osx · high confidence

rio-vt is a new, standalone Rust crate that extracts Rio's terminal core (VT state machine, ANSI/escape parser, grid with scrollback, selection, search, and PTY-facing event model) into a dependency-light library. It carries no rendering, GPU, or font-shaping dependencies, allowing embedders to pair it with their own renderer or drive it purely from the pulled grid state. The crate includes a C ABI wrapper (librio) for non-Rust embedders, feature flags for optional capabilities like windowing and graphics, and example programs demonstrating headless usage, Sixel and Kitty image protocols, selection, and resizing.

rio-vt · high confidence

The application now uses a dedicated router module (\frontends/rioterm/src/router\) to manage navigation states, modal overlays (such as the command palette, assistant, and quit confirmation), and window lifecycle events. This change centralizes window creation and configuration logic, including platform-specific handling for macOS (unified titlebars, traffic light positioning), Windows (startup flash prevention via cloaking), and Linux (X11/Wayland application IDs). Users benefit from more stable window behavior, consistent title bar rendering, and improved input handling for modal UI elements.

frontends/rioterm/src/router · high confidence

The \rio-grapheme-width\ crate has been introduced to correctly handle Unicode emoji variation selectors (VS15 and VS16) at the terminal grid level. By integrating data tables from WezTerm's \wezterm-char-props\ (specifically \emoji\_presentation\ and \emoji\_variation\), Rio now determines whether a variation selector should promote or narrow the width of the preceding character. This ensures that emoji rendered with explicit text (VS15) or emoji (VS16) modifiers are sized correctly, preventing display inconsistencies in the terminal grid.

rio-grapheme-width · high confidence

The terminal now uses the Kitty keyboard protocol by default to encode key events, providing more precise key reporting (including event types and associated text) and fixing issues with modifier keys like Shift+Tab. This change introduces a new binding module (\frontends/rioterm/src/bindings\) that defines the key binding structures, modes (such as VI and SEARCH), and actions (including search navigation and font size adjustments), replacing the previous implementation to support these advanced input features.

frontends/rioterm/src/bindings · high confidence

The library has been renamed to Corcovado and is now a trimmed-down fork of mio 0.6.x, removing networking types, the timer, and the Fuchsia backend in favor of using std types. This location introduces a new asynchronous, thread-safe channel implementation (\channel.rs\) that integrates with the event loop, a benchmark suite using Criterion (\bench\_poll.rs\), and internal support for lazy initialization (\lazycell.rs\). The core polling logic (\poll.rs\) has been updated to use \Rc\ instead of \Arc\ for readiness tracking to satisfy \Sync\ trait requirements, and Unix socket handling (\socket.rs\, \stream.rs\) now includes \SO\_NOSIGPIPE\ configuration to prevent process termination on write errors.

corcovado/src · high confidence

The Unix terminal backend now uses a robust state machine to manage child process lifecycle, ensuring reliable termination and preventing zombie processes. It implements a graceful escalation sequence (SIGHUP followed by SIGKILL) with configurable grace periods, correctly handles process groups to signal child shells and their descendants, and fixes signal handling on macOS and BSD systems where \killpg\ may report EPERM even when signals are delivered. Additionally, it resets ignored signals before shell execution to ensure the shell inherits standard signal dispositions.

teletypewriter/src/unix · high confidence

The macOS platform module now implements a more robust locale detection mechanism. It attempts to use the system's language and country codes (available on macOS 10.12+) to construct a valid UTF-8 locale identifier, falling back to the full locale identifier or a hardcoded UTF-8 default if necessary. This ensures that environment variables like LC\_ALL and LC\_CTYPE are set correctly for proper text rendering and input handling.

frontends/rioterm/src/platform/macos · high confidence

The terminal now uses a 60% threshold for cell-side detection instead of the previous 50% midpoint, which reduces accidental half-cell snapping during selection. Additionally, a new 'hint click latch' mechanism ensures that opening links via modifier-clicks is robust: the system remembers the hint under the press, preventing drag leaks or stale highlights, and guarantees that the link opens only if the mouse release lands on the same hint.

frontends/rioterm/src/mouse · high confidence

The layout module now defines \CellMetrics\ as the canonical source of truth for cell dimensions, baseline, and face metrics, replacing previous ad-hoc calculations. \TextLayout\ and \RootStyle\ manage font size, line height, and scale factors, while \SpanStyle\ in the span module handles rich text attributes including colors, decorations (underline/strikethrough with shape support), and cursor styles. This refactoring establishes a more robust foundation for text layout and rendering consistency.

sugarloaf/src/layout · high confidence

The sugarloaf library now exposes a \components\ module that organizes core functionality and optional visual effects. This change introduces a \filters\ submodule, which integrates librashader for shader-based image processing. To ensure clean dependency management on Linux and macOS builds that do not enable the \wgpu\ feature, the filters module is conditionally compiled, allowing the dependency tree to drop cleanly when hardware-accelerated rendering is not required.

sugarloaf/src/components · medium confidence

The Linux platform implementation for window management has been restructured to support both X11 and Wayland backends via feature flags. This change introduces a unified \Backend\ enum to select between X11 and Wayland, adds specific window attributes for X11 (such as visual ID, screen ID, and override redirect), and implements error handling for both platforms. It also establishes the core types for window and device IDs, and sets up the necessary module structure for platform-specific event loops and window creation.

_rio-window/src/platform\impl/linux · high confidence

The \sugarloaf/src/renderer\ module has been completely replaced with a new rendering architecture. This change introduces a new batching and compositing system (\batch.rs\, \compositor.rs\) that supports instanced rendering for quads and non-quad geometry. It adds a new CPU rasterization pipeline (\cpu.rs\) for software rendering, and implements a new image handling system with dedicated shaders for Vulkan (\\.frag.glsl\, \\.vert.glsl\), Metal (\image.metal\), and WebGPU (\image.wgsl\). The new renderer also includes a CPU-based image cache and supports advanced visual features like SDF rounded corners, various underline styles (dashed, dotted, curly), and clipping rectangles.

sugarloaf/src/renderer · high confidence

The X11 backend for Rio Window has been rewritten from scratch, introducing support for system theme detection via XSettings, proper drag-and-drop handling, and startup notifications. To improve performance on high-refresh-rate displays, a new input-rate tracker replaces the previous single-timestamp logic, ensuring that the presentation window is only sustained during high-frequency input bursts rather than after every single keystroke.

_rio-window/src/platform\impl/linux/x11 · high confidence

The image cache module has been replaced with a new implementation that uses a shelf-based atlas allocator to improve texture space utilization for glyphs and images. This change introduces a CPU rasterization path for OpenType COLR v0/v1 color fonts using tiny-skia, allowing color glyphs to be rendered consistently across all backend targets (Wgpu, Metal, and CPU). The new cache manages separate mask and color atlases, handling both monochrome glyf outlines and complex color paint graphs, which ensures that rich text and grid renderer glyphs are cached and displayed correctly regardless of the underlying graphics API.

_sugarloaf/src/renderer/image\cache · high confidence

The terminal frontend now uses a new layout system in \frontends/rioterm/src/layout\ that supports resizing panels by dragging borders and applies margins scaled to the display scale factor. This change ensures that grid dimensions and cell calculations remain consistent with the renderer, fixing issues with stale terminal sizes, screen resolution bugs, and incorrect row counts during window resizes or margin changes.

frontends/rioterm/src/layout · high confidence

The macOS backend has been replaced with a new implementation that introduces hardware VSync synchronization via CVDisplayLink and Grand Central Dispatch for smoother rendering, adds support for the macOS 26 'Liquid Glass' visual effect, and fixes several input issues including proper handling of undocumented cursors, IME commit events, and key events when the Command modifier is held.

_rio-window/src/platform\impl/macos · high confidence

The terminal grid rendering path has been rewritten to use a persistent, row-indexed GPU cell buffer system, replacing the previous rich-text-based approach. This new architecture introduces dedicated backends for Metal, wgpu, Vulkan, and CPU (software) rendering, all sharing a common data layout defined by \CellBg\ and \CellText\ structs. The system manages glyph atlases for efficient texture sampling, supports per-row dirty updates to minimize GPU memory transfers, and handles cursor rendering and color spaces (including DisplayP3 and sRGB) consistently across all platforms.

sugarloaf/src/grid · high confidence

The sugarloaf rendering layer has been refactored to decouple graphic value types from the renderer by moving them to the rio-graphics crate, while introducing new primitives like Corners, Quad, and ImageProperties (with opacity support) and restructuring global state into SugarState to hold font libraries and root styles.

sugarloaf/src/sugarloaf · medium confidence

The terminal context logic has been reorganized into dedicated modules (\mod.rs\, \renderable.rs\, \title.rs\) to improve code structure and maintainability. This change introduces a new \RenderableContent\ struct that encapsulates all visual state required for rendering, including cursor state, selection ranges, hint labels, and damage tracking. Title handling has been updated to support template-based formatting with variables like \{{ title }}\, \{{ program }}\, \{{ absolute\_path }}\, and \{{ relative\_path }}\, allowing for more flexible and consistent tab/window titles. The refactoring also includes improvements to context creation, including support for dead contexts in tests and better handling of shell integration and working directory preservation.

frontends/rioterm/src/context · high confidence

The rio-backend crate now acts as a facade, re-exporting the terminal core (VT state machine, parser, grid, selection, search, PTY event model, colors) from the new rio-vt crate while retaining user-facing configuration and the sugarloaf renderer glue. This change ensures that downstream components like rioterm and tests continue to function without modification by maintaining the original module paths.

rio-backend/src · high confidence

The platform module now includes a \shell\_escape\ function that prefixes shell-sensitive characters (such as spaces, parentheses, and metacharacters) with backslashes. This ensures that file paths dropped into the terminal are safely escaped, preventing unintended command interpretation or errors when handling filenames with special characters.

frontends/rioterm/src/platform · high confidence

Rio now ensures that Powerline separators and icon glyphs (such as those from Font Awesome) render with consistent scaling, alignment, and padding across all renderers. This is achieved by porting the per-glyph constraint rules from Ghostty into a new shared \rio-fonts\ library, which applies specific sizing and positioning logic to match the appearance in Ghostty and Apple Terminal. Additionally, a symbols-only Nerd Font can be embedded directly into Rio via the \symbols-nerd-font\ feature, allowing icon glyphs to be displayed without requiring an external font file to be installed.

rio-fonts · high confidence

The font subsystem now uses a unified configuration structure (SugarloafFonts) that allows users to specify font family, size, hinting, features, and per-style overrides (regular, bold, italic, bold-italic) via TOML, with Cascadia Code Nerd Font as the new default. A consistent metrics approach ensures that CJK and Latin fonts share the same cell dimensions, preventing vertical misalignment between scripts. The implementation includes platform-specific font discovery (fontconfig on Linux, CoreText on macOS) and a new text run cache for improved rendering performance.

sugarloaf/src/font · high confidence

The rio-unicode library has been updated to support Unicode 17.0.0, regenerating the character width tables to reflect the latest standard. Additionally, a new grapheme cluster segmentation module has been introduced, implementing UAX \#29 rules to correctly handle complex text boundaries such as emoji ZWJ sequences, regional indicators, and Indic conjuncts, ensuring that text wrapping and cursor movement align with modern Unicode expectations.

rio-unicode · high confidence

The examples in sugarloaf/examples have been migrated to use the rio\_window crate for window management and event handling. New examples demonstrate specific rendering capabilities: draw\_order.rs illustrates the painter's algorithm for layering elements, image.rs shows how to set a background image, simple\_unified.rs demonstrates unified rich text and quad rendering, and transparent.rs shows how to create a transparent window. These changes reflect the underlying shift from winit to rio\_window and showcase the updated Sugarloaf API.

sugarloaf/examples · high confidence

The Windows platform implementation for rio-window has been replaced with a new event loop runner that synchronizes redraws to the display refresh rate using DwmFlush. This change introduces a dedicated vsync worker thread that manages per-window dirty flags, ensuring that repaints occur only when necessary or when the system is ready to compose a new frame. Additionally, an input-rate tracker prevents excessive redraw storms during high-frequency input bursts (such as rapid typing or mouse movement) by gating redraw requests for one second after sustained high-rate input, mirroring behavior found on macOS and Wayland. This results in smoother rendering and reduced CPU/GPU usage during intensive interaction.

_rio-window/src/platform\_impl/windows/event\loop · high confidence

The Windows installer (Wix) now registers a context menu entry that allows users to open the terminal in the current directory from the file explorer background. This is achieved by adding a registry key for 'Open Rio here' which launches rio.exe with the --working-dir parameter set to the selected folder path.

misc/windows · high confidence

Added WebAssembly integration tests and WGSL shader validation; Added X11 XSettings test fixture; Added compile-time Send/Sync safety tests for rio-window types; Added ctest to verify bracketed paste and shell-independent paste behavior; Added image comparison test utilities; Added test suite for corcovado polling and readiness mechanisms; Added tests for Kitty graphics protocol handling.

The Rio terminal project has been updated to version 0.5.28, with the minimum supported Rust version (MSRV) raised to 1.96.1. This release includes a comprehensive update of the dependency lock files and manifests across the workspace, incorporating newer versions of key libraries such as wgpu (30.0.1), image (0.25.10), and winit (via the rio-window fork).

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 61 → 68 (+7.4)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 82 → 82 (+0.1)
• Architecture 99 → 92 (-6.6)
• Maturity 50 → 65 (+15.1)
• Readiness 62 → 64 (+1.5)
• Security 65 → 69 (+4.3)
• Event Sourcing 100 → 100 (+0.0)
• Performance 100 (new)

• Boundary-crossing change coupling: assistant.rs ↔ sugarloaf.rs (frontends/rioterm/src/router/routes/assistant.rs)
• Change coupling: atlas.rs ↔ sugarloaf.rs (sugarloaf/src/renderer/image_cache/atlas.rs)
• Duplicated block (12–14 lines × 3) (frontends/rioterm/src/context/title.rs)
• Duplicated block (12–15 lines × 2) (frontends/rioterm/src/application.rs)
• Duplicated block (15–18 lines × 2) (frontends/rioterm/src/context/title.rs)
• Duplicated block (26 lines × 2) (frontends/rioterm/src/context/mod.rs)
• Hotspot: corcovado/src/poll.rs (corcovado/src/poll.rs)
• Hotspot: frontends/rioterm/src/context/title.rs (frontends/rioterm/src/context/title.rs)
• Hotspot: frontends/rioterm/src/global_hotkey.rs (frontends/rioterm/src/global_hotkey.rs)
• Hotspot: frontends/rioterm/src/hints.rs (frontends/rioterm/src/hints.rs)
• Hotspot: frontends/rioterm/src/layout/mod.rs (frontends/rioterm/src/layout/mod.rs)
• Hotspot: frontends/rioterm/src/renderer/trail_cursor.rs (frontends/rioterm/src/renderer/trail_cursor.rs)
• Hotspot: librio-wasm/src/lib.rs (librio-wasm/src/lib.rs)
• Hotspot: rio-graphics/src/lib.rs (rio-graphics/src/lib.rs)
• Hotspot: rio-unicode/src/grapheme.rs (rio-unicode/src/grapheme.rs)
• Hotspot: rio-vt/src/ansi/glyph_protocol.rs (rio-vt/src/ansi/glyph_protocol.rs)
• Hotspot: rio-vt/src/config/colors/mod.rs (rio-vt/src/config/colors/mod.rs)
• Hotspot: rio-vt/src/crosswords/pos.rs (rio-vt/src/crosswords/pos.rs)
• Hotspot: rio-vt/src/crosswords/vi_mode.rs (rio-vt/src/crosswords/vi_mode.rs)
• Hotspot: rio-vt/src/performer/parser/mod.rs (rio-vt/src/performer/parser/mod.rs)
• …and 9 more

• Ambiguous naming for interruptible behavior. While poll_interruptible is descriptive, the existence of two poll variants with different blocking behaviors (one potentially blocking indefinitely or on signal, one explicitly interruptible) can be confusing. However, this is a common pattern in async I/O.
• Duplicate accessors for the same property. readiness() and kind() both return the Ready state of an event.
• Duplicate deregistration logic. Both types expose deregister with identical intent but different parameter structures (one takes the poll, one takes the handle), causing confusion about ownership and lifecycle management.
• Duplicate method signatures with different return types or overloads? The list shows two entries for to_rio_window_colorspace with identical signatures but potentially different contexts or return types (one returns Colorspace, the other is ambiguous). If they are truly identical, it's a duplicate.
• Duplicate registration logic across types. Evented is a trait/interface that requires implementing register, while Poll is the concrete implementation that also exposes register. This creates a confusing API surface where users might call poll.register() directly or evented.register(poll, ...) depending on context, with identical signatures.
• Duplicate registration update logic. Similar to register, both Evented and Poll expose reregister with identical signatures, leading to ambiguity about which method performs the actual I/O or state update.
• Duplicated block (12–14 lines × 3) (frontends/rioterm/src/context/title.rs)
• Duplicated block (13–16 lines × 2) (frontends/rioterm/src/application.rs)
• Duplicated block (27 lines × 2) (frontends/rioterm/src/context/mod.rs)
• Duplicated block (6 lines × 2) (frontends/rioterm/src/application.rs)
• End-of-life runtime: Rust 1.96
• Inconsistent constructor naming. new2 is a non-descriptive name compared to new, suggesting a legacy or overloaded constructor without clear semantic distinction in the name.
• Inconsistent error handling patterns. load() likely panics or returns a default on error, while try_load() returns a Result. This is a common pattern but can be confusing if the behavior of load() is not explicitly documented as infallible or panic-on-error.
• Low cohesion: Graphics (LCOM4 4) (rio-vt/src/ansi/graphics.rs)
• Low cohesion: Poll (LCOM4 4) (corcovado/src/poll.rs)
• Machine::pty_read (cyclomatic 19) (rio-vt/src/performer/mod.rs)
• Machine::run (cognitive 50) (rio-vt/src/performer/mod.rs)
• Machine::run (cyclomatic 23) (rio-vt/src/performer/mod.rs)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (frontends/rioterm/src/layout/mod.rs)
• Members sharing a duplicated core (6 members, 50+ identical tokens) (frontends/rioterm/src/renderer/assistant.rs)
• …and 19 more

• 5 commits — 3 feature/other, 2 fixes

• frontends/rioterm — 4 commits
• (root) — 1 commit

• fix: fix: harden PTY quit delivery and lifecycle locking (#1942)
• fix: fix: preserve Unix PTY lifecycle and final output (#1930)
• change: Automatic shell integration for zsh, fish and PowerShell (#1923)
• change: Surface terminal bells on tabs, with a font-free indicator (#1922)
• change: prepare v0.5.28

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

raphamorim/rio was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.