Introducing tmux-rs

I love this attitude. We don’t necessarily need a reason to build new things. Who knows what will come out of a hobby project. Thanks to the author for the great write up!

Also, my gardening is full of segfaults, coding a new project is definitely safer to my yard.

I've been working on a Rust-based tmux session manager called rmuxinator (i.e. tmuxinator clone) for a few years now. It (mostly) works and been slow going because ... life but I've recently picked it back up to fix some bugs. One of the last new features I'd added was the ability to use rmuxinator as a library in other Rust programs. I'd like to try forking tmux-rs, adding rmuxinator as a dependency and seeing if it would ... just work as a way to start sessions using per-project config files. I'm definitely not advocating for adding rmuxinator upstream but it would be very nice to have this sort of session templating baked into the "terminal multiplexer" itself.

The other interesting possibility I could foresee is doing things the other way around and having rmuxinator use tmux-rs as a library in order to setup and manage sessions instead of just dumping out shell commands -- which is fraught with edge cases. (Not sure if this is currently possible with tmux-rs, though.)

Once I wrap up the bugfixes I'm currently working on, I may fork this project and give one or both of the above a try.

Regardless, nice work by richardscollin!

And as a result, you could be running the greatest / fastest / most feature rich desktop terminal … but if your multiplier doesn’t support something - it hinders your fancy desktop terminal.

Short 3 min video explained by Ghostty creator

https://youtu.be/o-qtso47ECk

It seems automatically translating Rust to C is not a very good idea: "I threw away all of the C2Rust output and decided I would translate all of the files into Rust manually from C.". Neither seems doing it manually: "I introduced many bugs while translating the code. I’d like to share the process of discovering and fixing a couple." Or using AI: "That’s because when using cursor to translate the code it would still occasionally insert bugs, just like me. So, I spent as much time reviewing the generated code as it would have taken me to write it myself."

As a hobby project, all power to you. But otherwise, maybe better not rewrite working code....

Love it. You definitively deserve your +350 points!

you want to re-implement a well known project, fine

call it something else

Here I want to call out zellij. Zellij is rust based terminal multiplexer.

I am user not creator. I love everything rust and finding and migrating to rust based solutions where feasible.

https://www.youtube.com/watch?v=rWMQ-g2QDsI

Some of that video is about stuff you have no use for if you're not a Rust developer, but, some of it is things that would be just as useful to anybody who is comfortable with, as it says, a command line interface.

Given the traction you got here and the advancements in AI, I'm sure this can become a very attractive hobby project for Rust beginners, there's probably a lot of easy bugs to fix. Fixing bugs, adding new features, and optimizing the code is all you need.

Here's an idea to get the ball rolling: Create a scratch buffer for Gemini CLI (or your favorite LLM) and enable it to interact with the various windows and panes of the tmux session.

Here's my use case, I use synchronized panes to send the commands into multiple servers, but some commands sometimes fail for various reasons. What if I can just ask the AI to send a series of commands and react based on the output and adjust along the way. It's like a dynamically generated custom shell script on the fly.

Which makes C2Rust seem pretty useless?

"I’ve recently reached a big milestone: the code base is now 100% (unsafe) Rust. I’d like to share the process of porting the original codebase from ~67,000 lines of C code to ~81,000 lines of Rust (excluding comments and empty lines)."

And yet somehow a hand-ported (and still unsafe) rewrite of a C program in Rust is still almost 20% larger?

If I recall, the Go gc compiler was automatically converted from 80K lines of C to 80K lines of Go. A hand-ported version would have been much smaller.

[1] https://github.com/zellij-org/zellij/issues/694

120 comments and nobody has mentioned the use-after-free triggered by closing a window. Rust truly is the safest language.

Sorry I know this is not the place to complain, but it would be so nice!

I have often executed `pkill -9 tmux` and saved my day. I hope the rust version can help a bit here?

Looking forward to check out tmux-rs.

Transitioning more software from C to Rust is a great idea.

Sounds to me that this was a C -> Rust transpiler. :D

Edit: I was right, they used c2rust.

And then there is "// generated Rust code".

As for the code snippets on https://richardscollin.github.io/tmux-rs/, I can read the C version better than the generated Rust code.

  // cmd-kill-session.c
  RB_FOREACH(wl, winlinks, &s->windows) {
    wl->window->flags &= ~WINDOW_ALERTFLAGS;
    wl->flags &= ~WINLINK_ALERTFLAGS;
  }

  // cmd_kill_session.rs
  for wl in rb_foreach(&raw mut (*s).windows).map(NonNull::as_ptr) {
      (*(*wl).window).flags &= !WINDOW_ALERTFLAGS;
      (*wl).flags &= !WINLINK_ALERTFLAGS;
  }

Edit: As pointed out below, I'm stupid, it's stated in the article and I didn't read that part

I was hoping for the announcement of a brand new bulletproof tmux-resurrect.

But no, it is (just) tmux-(recodedIn)rust.

In fact, I sometimes port code to another language and back just as a way to do code cleanup (or at least give ideas for things that could be cleaned up)

I wonder why OP didn't start from that as a starting point?

Now I really wonder how a good model like Sonnet 4 would have performed.