Abstract:

This article details the ambitious six-month endeavor of manually porting the tmux terminal multiplexer from approximately 67,000 lines of C code to 81,000 lines of "unsafe" Rust, a project undertaken primarily as a hobby. The author, Collin Richards, initially attempted automated translation with C2Rust, which proved unmaintainable despite functional output. The subsequent manual port involved systematically translating C patterns like raw pointers, goto statements, intrusive macros, and yacc parsers into their Rust equivalents. The process encountered notable bugs related to C's implicit function declarations and struct memory layouts. While the project is currently 100% unsafe Rust and functional, it is acknowledged to be buggy. The author's development workflow included heavy use of custom Vim macros and an evaluation of AI coding tools like Cursor, which ultimately did not accelerate the process due to bug introduction. The long-term goal is to refactor the codebase into "safe" Rust.

Summarizing tmux-rs and its Community Discussion:

• 0:00 Project Genesis & Scope: Collin Richards undertook a six-month hobby project to port the tmux terminal multiplexer from C to Rust, resulting in an ~81,000 line Rust codebase from ~67,000 lines of C.
• 0:40 Failed Automated Translation: The project began with C2Rust, an automated C-to-Rust transpiler. While C2Rust produced functional code, it was three times larger and unmaintainable due to issues like converting named constants into raw hexadecimal values. The author ultimately abandoned the C2Rust output for a manual translation.
• 4:00 Evolving Build Process: Initially, the C autotools build system was modified to link a static Rust library. As more code was translated, the process shifted to building a Rust binary that linked the remaining C code using the cc crate, streamlining development.
• 9:00 Key Bug Discoveries:
  • Implicit Declaration (Bug 1): A C function's implicit int return type declaration led to truncation of a returned 8-byte pointer to a 4-byte integer. Correcting the C prototype resolved this.
  • Mismatched Struct Layout (Bug 2): A forgotten * in a Rust struct's type declaration caused misinterpretation of memory layout and subsequent segfaults, highlighting challenges in direct type translation.
• 14:00 Adapting C Patterns to Rust:
  • Raw Pointers: Due to Rust's strict reference invariants (non-null, valid, single mutable owner), the initial port relies heavily on raw pointers (*mut T, *const T), which are semantically similar to C pointers but lack Rust's compile-time safety guarantees.
  • goto Emulation: C's goto statements were translated using Rust's labeled blocks with break (for forward jumps) and labeled loops with continue (for backward jumps), avoiding complex control flow algorithms.
  • Intrusive Macros: Custom Rust traits and iterators were developed to mimic C's intrusive red-black trees and linked lists, handling cases where data structures reside within the application's main structs.
  • 19:00 Yacc to Lalrpop: The tmux configuration parser, originally implemented with yacc, was successfully reimplemented in Rust using the lalrpop crate, allowing for a one-to-one translation of the grammar rules and enabling the complete removal of remaining C code.
• 21:00 Development Workflow & AI Tools: The author primarily used Neovim with custom macros for mechanical code transformations. An experiment with an AI coding assistant (Cursor) indicated it did not increase overall speed, as it introduced bugs requiring manual review equal to writing the code oneself.
• 25:00 Current Status & Future Goals: The tmux-rs codebase is currently 100% "unsafe" Rust, but the author acknowledges it is still buggy and not significantly better than a C2Rust output. The immediate next goal is to systematically convert the unsafe Rust code to "safe" Rust.
• Hacker News - Community Reception: The project received overwhelmingly positive feedback for its honesty, persistence, and detailed write-up, with many relating to the "hobby project, like gardening but with more segfaults" analogy.
• Hacker News - C2Rust & Porting Discussion: Commenters confirmed C2Rust's utility for initial feasibility while acknowledging its output is unidiomatic. The debate around manual vs. automated translation and the increase in Lines of Code (LOC) for the Rust version was also a recurring theme.
• Hacker News - Unsafe Rust & Safety: A significant portion of the discussion revolved around the use of "unsafe" Rust. While some questioned its benefit over C given the initial lack of safety, the author and others clarified that unsafe Rust is a necessary intermediate step towards a fully safe version, still offering benefits like better tooling and explicit marking of unsafe blocks. Specific bugs introduced in tmux-rs were also noted, highlighting its current v0.0.1 state.
• Hacker News - Project Justification: Many users strongly supported doing hobby projects "for fun" or "to learn," not requiring external justification or world-changing outcomes, contrasting with a common "why rewrite?" sentiment.
• Hacker News - Alternatives & Features: Discussions compared tmux-rs to other terminal multiplexers like zellij (Rust-based) and GNU screen, noting tmux's stable defaults and automation capabilities. Users also mentioned common tmux pain points, such as mouse support and memory usage with large scrollback buffers.
• Hacker News - AI Tools in Porting: The author's experience with Cursor sparked discussion on the current limitations and future potential of LLMs for large-scale code translation and refactoring.