What does HackerNews think of tmuxinator?

Manage complex tmux sessions easily

Language: Ruby

I once bought a 32 core ThreadRipper and tried to get along with using a cheap £200 Windows 10 laptop to remote into the threadripper while in coffee shops and use the ThreadRipper to do my work.

The £200 Windows 10 laptop wasn't powerful enough, it was too laggy. Even on Wifi.

I love the idea of the X11 protocol. And I still love the idea of a web desktop. Something that is supremely well integrated and allows me to move workloads between client and server seamlessly. This idea I really like. The ability to outsource computation and storage seamlessly. A process can be moved between machines seamlessly.

This could be modelled in Javascript and promises that can be sent around. Microservices in the desktop environment.

I looked at tools that would bring up tmux sessions with everything preloaded. (https://github.com/tmuxinator/tmuxinator)

ScrapScript has very good ideas in this area of distributing dependencies and storage. (https://scrapscript.org/) There is also val town.

I never use KDE Plasma widgets or the sidebar widgets that Mac provided.

There is so many exciting ideas that could be tried out but I worry they're all too big ideas to be implemented.

If you want to retain complicated window setups without running multiple sessions concurrently I really like tmuxinator [1]. It lets you declare everything about the session in a config file, and restart the session based only on the file.

1. https://github.com/tmuxinator/tmuxinator

I use https://github.com/tmuxinator/tmuxinator for my workspaces. Doesn't save ad-hoc layouts, but usually I find one layout that works per project, then create a tmuxinator config for it, so after reboot, it's a short "tmuxinator start $my-project" away to get back to how I want it to be.
I have not! I'll have to investigate more, because my little shell script is pretty basic (like 20 lines total, most of which was done for readability).

https://github.com/tmuxinator/tmuxinator

Needs more training data. Either the model can't understand the documentation ... oh wow, I have never tried scripting tmux.

https://stackoverflow.com/questions/5447278/bash-scripts-wit...

This looks like the best solution to your question https://github.com/tmuxinator/tmuxinator

I’ve become a huge fan of tmuxinator. Incredible tool for defining templates for tmux.

https://github.com/tmuxinator/tmuxinator

Lots of mentions of tmux but none yet of tmuxinator: https://github.com/tmuxinator/tmuxinator

Lets you predefine layouts and what will run in each pane.

tmuxinator

https://github.com/tmuxinator/tmuxinator

There are other solutions but I used this one for a while and liked it. Then stopped doing as much development at home (work is Windows) and haven't used it in a while. It's easy(ish) to create different configs for different needs. I basically had a Common Lisp IDE or a C++ IDE or whatever set of things I commonly used.

You might find tmuxinator (https://github.com/tmuxinator/tmuxinator) helpful. It doesn't do everything you describe, but I use it to spin up sessions configured per project.
Main feature for me is that I can have a few terminal windows/panes open, close the terminal, and open it back up later to the same tabs and panes still running. Or, I can open a terminal on any virtual desktop and get the same terminal on all of them.

I work with a few different hosts on SSH and having an active connection for each as a labelled window (tab) in the terminal itself that I can just open up a terminal anywhere to come back to is great.

Personally I use the `tmuxinator` helper tool[^1] that allows you to create configurations as json files to be launched/attached to with short aliases (eg `mux s myconfig`)

[1] https://github.com/tmuxinator/tmuxinator

Hey HN!

I've started this as a hobby project for practicing my Golang skills. Before it, I've been using tmuxinator[0], but I missed some features(like starting only some windows), so I decided to create my own utility. I would appreciate any feedback/code review.

[0] https://github.com/tmuxinator/tmuxinator

Rather than freeze them I have a tmuxinator[0] config per project that opens all of the panes and tools I tend to use. Usually something like: editor, extra (often my rails console or database prompt), git, tests, server, logs.

I know the numbers off by heart so can switch without looking.

[0] https://github.com/tmuxinator/tmuxinator

There’s also tmuxinator[1]. I setup profiles for my different development environments (panes for db/repl/vim).

Just a command away from it setting up the Tmux panes with the right sizes and processes running.

[1] https://github.com/tmuxinator/tmuxinator

Nice, good idea. I've tried similar things (saved layouts for a project) using Tmuxinator[1], but since I don't normally use Tmux it didn't stick.

[1] https://github.com/tmuxinator/tmuxinator

tmuxinator

Someone mentioned it a few months back and it greatly simplified my life. You specify your layouts (and tmux will give you the information to copy a current layout). You can then tell it what programs to run in each window of the layout.

So I have a window broken into 5 panes (as an example). The top left runs emacs (via emacsclient) and opens my ledger.org file. The other 4 show various reports I want to see: Current cleared balance, current uncleared balance, current uncleared transactions, future transactions (out to a month), and a running balance sheet across the past several months.

In another two windows I just have a shell and an emacsclient instance (because I live in emacs). Then as I come up with other things I want to see (weather information, summaries of my todos, email inbox (tally at least) I can add new window and pane configurations to my tmuxinator configuration. When I restart it, everything is back as I had it (if I put them in the config).

I haven't done as much coding at home as I'd like lately (and it's all Windows at the office). But I have a couple other tmuxinator configs that will layout several windows and panes for development. Like launch an editor, and have spaces laid out like I want for debuggers and test monitoring scripts. As appropriate to the language and task.

https://github.com/tmuxinator/tmuxinator

For the constantly refreshed display, it's mostly `watch -t ` (modifying the refresh rate if necessary. `-t` removes the title text from the top of watch so it only shows the command outputs. Which is something it took me way too many years to realize.

A while ago I saw comments here about tmuxinator. Which was a fantastic improvement to my tmux use. Create a layout manually, get the layout from tmux and then set it up to launch a custom set of windows, panes, and programs based on my project needs. Doing this easily and repeatedly makes it trivial for me to set aside a task and come back to it later and be confident I will have everything in view that I need.

https://github.com/tmuxinator/tmuxinator

I highly recommend https://github.com/tmuxinator/tmuxinator if you haven't tried it, I've actually used it to run whole microservice environments locally and works without a hitch
I've been using tmux for a while. What I like most is the copy mode and its scriptability.

Copy mode allows you to select and copy text using vi or emacs ( whatever you choose ) key bindings. This way, you can go completely mouse free in the terminal. This is also present in screen.

Then scriptability: tmux exposes lots of commands so you can interact with it from a script. There are quite a few plugins out there. https://github.com/tmux-plugins/

My personal favourites:

- https://github.com/morantron/tmux-fingers/ copy pasting using vimium-like hints, so you don't even have to enter copy mode ( this one I did it myself )

- https://github.com/tmuxinator/tmuxinator/ predefined user sessions. Solves repetitively opening the same services/commands every time you start a coding session.

I'm using https://github.com/tmuxinator/tmuxinator for quite some time and find it very convenient. Are there any advantages of Tmuxp?
Hi, thanks for your question. I'm going to cross-post this from a reddit comment that asked the same thing.

tmux[1] is oriented toward commandline users on posix-like systems. libtmux is a python library to help you script and automate tmux. it abstracts the concept of the server, its sessions, their windows and panes [2] into a herarchy you can easily navigate, even with a live tmux session.

I don't know if you use cli, tmux, or a tmux session manager (tmuxinator, teamocil, tmuxp) already, so its hard to tailor this answer specifically.

command line

a good deal of programmers, sysadmins, etc. use the terminal routinely throughout their day. some even go so far as to swear off a graphical IDE all together, and use screen or tmux with a combination of an editor like vim, emacs and others.

if you primarily use windows and don't use linux/bsd/os x terminal often, if you ever do, i highly recommend giving screen[3] or tmux a shot.

tmux

the benefit to using the terminal means tmux lets you do a couple things:

- split your terminal into multiple PTY's (panes) and windows, copy and paste between them. No GUI required - "detach" the tmux sesssion, sending it (and any shells/applications running in the panes) to the background, and come back later to reattach - it is also seamless to SSH into a server and work from there, since there's no GUI involved, you can use the same workflow on OS X, Linux or BSD machines.

I write in detail about tmux here: http://tmuxp.readthedocs.io/en/latest/about_tmux.html

tmux configuration

a good amount of developers use screen or tmux on a regular basis. over time, a variety of plugins have popped up. tmuxinator[4], teamocil[5] and tmuxp[6] (my own, written in python) being ways to load pre-configured sessions from a YAML file.

scripting / automating tmux with libtmux

so here is where libtmux comes in, it can be used to control tmux via python objects, which can be very handy in situations where you want to interface with tmux at a low level expressively.

it is possible to script things via shell, but there's no way to know the state or easily traverse through the tree of Server -> Sessions -> Windows -> Panes.

tmuxp uses libtmux under the hood a way to build sessions[7]. other developers have used tmuxp[8]* for scripting tmux to the workflow of their projects.

* note: I link to `import tmuxp` because the API would formerly be in that project for the past few years. libtmux decouples the core into its own library.

[1] https://tmux.github.io/ [2] http://libtmux.readthedocs.io/api.html [3] https://www.gnu.org/software/screen/ [4] https://github.com/tmuxinator/tmuxinator [5] https://github.com/remiprev/teamocil [6] https://github.com/tony/tmuxp [7] https://github.com/tony/tmuxp/blob/master/tmuxp/workspacebui... [8] https://github.com/search?utf8=%E2%9C%93&q=%22import+tmuxp%2...

I can only recommend tools like tmuxinator [1]. They make it really easy to start your development environment. Especially when you deal with multiple services that need to be started along with certain tasks (mostly watch tasks like build and test in my case).

[1]: https://github.com/tmuxinator/tmuxinator

Check out tmuxinator: https://github.com/tmuxinator/tmuxinator. You can create configurations for your projects that specify windows, panes, which apps to run, etc. It's great for starting all the servers/shells/workers required for a project.
I use tmuxinator to launch services I need, then I just kill the session when I'm done.

https://github.com/tmuxinator/tmuxinator

Thanks for the useful tip. I also really appreciate the power and utility of tmuxinator. [1]

[1] https://github.com/tmuxinator/tmuxinator