Both terminal multiplexers (screen, tmux) and keyboard-driven tiling window managers (ratpoison, dwm, xmonad) provide similar functionality. Is there any benefit in using both at the same time? What about problems that may arise?

  • 1
    They do? The only feature I can think of that overlaps is the ability to split a window into many May 16, 2012 at 5:33
  • @MichaelMrozek I have 0 experience with either of them so I'm just going of some stuff I've read. It would be great if you could point out some differences.
    – Pubby
    May 16, 2012 at 5:52
  • 3
    Be aware that for a window manager, every window is just a window – and that's about it. Therefore lots of terminal-related things apart from window splitting are unavailable to the WM.
    – sr_
    May 16, 2012 at 8:21

5 Answers 5


The added benefit of terminal multiplexers is that your multiplexer sessions will still be alive and you can reconnect to them even if X (your desktop session) crashes, or you logged out of X.


I use dwm and tmux. Before learning to use tmux, I would have multiple terminals open for different things, and have them in different tags. Now I can run everything inside of one tmux session, under a single tag, and can detach and reattach without losing state if I need to restart X.


Use both: A tiling window manager, and a terminal multiplexer.

Combine both their capabilities and advantages to obtain an even better synergy. On my i3 setup I regularly display several terminals at the same time, but all of them connected to the same tmux session, so I can display all tmux windows in any of the terminals.

In effect, I use the tiling capabilities of i3 to replace/augment the window splitting/moving functionality of the terminal multiplexer to (imho) get the best of both worlds.

The below script is used here to manage session /detection connection and clean-up on terminal startup:

# This script attaches the terminal to a common session, where all
# terminals can show any window of the main tmux session independently
# This script also cleans up "old" sessions
# Todo: Cosmetic fix-ups. Make less verbose.

showRun(){ echo Will run: $@;test -z $DEBUG||read -n1 -p"Press ENTER";$@; }


if ! tmux has -t $SNAME; then
    echo -n "Session $SNAME not found, creating it: "
    showRun exec tmux new-session -s $SNAME;
    echo -n "Session $SNAME found: "
    MySESSION=$(tmux ls | grep -E "^$SNAME:.*\(attached\)$")
    echo $MySESSION;
    if [ -z "$MySESSION" ] ; then
        echo "Session $SNAME unattached, seizing it:"
        showRun exec tmux attach -t $SNAME \; new-window
        echo "Session $SNAME already attached, finding grouped Sessions:"
        REGEX="group ([^)]*)"
        [[ $MySESSION =~ $REGEX ]]
        GSESSIONS=$(tmux ls | grep "group $GNAME)" | grep -v $SNAME:)
        echo "$GSESSIONS"
        if [ -z "$GSESSIONS" ]; then
            echo "No sessions in group with $SNAME found, creating new one:"
            showRun exec tmux new-session -t $SNAME \; new-window
            FGSESSIONS=$(echo "$GSESSIONS" | grep -v attached )
            if [ -z "$FGSESSIONS" ]; then
                echo "No free sessions in group $GNAME found, creating new one:"
                showRun exec tmux new-session -t $SNAME \; new-window
                echo -e "Free grouped Sessions:\n $FGSESSIONS";
                if echo "$FGSESSIONS" | tail -n +2 | grep . > /dev/null; then
                    echo "Several detached Sessions found, cleaning up:"
                    echo "$FGSESSIONS" | while read SID x ; do
                        if [ -z $KEEPSID ]; then
                            echo "Keeping session $KEEPSID for takeover after cleanup"
                            echo "Cleaning up old detached session $SID"
                            tmux kill-session -t ${SID%:}
                    KEEPSID=$(tmux ls|grep "group $GNAME)" | grep -v attached);
                    KEEPSID=${KEEPSID%: *}
                    echo "Attaching to session $KEEPSID:"
                    showRun exec tmux attach -t $KEEPSID \; new-window
                    echo "Free session ( ${FGSESSIONS%: *} ) found, seizing it:"
                    showRun exec tmux attach -t ${FGSESSIONS%: *} \; new-window
                fi ;
            fi ;
        fi ;
    fi ;

Another useful aspect of a terminal multiplexer in this scenario is after connecting to remote servers. A typical use case I find is

  1. Open a terminal window on my local pc.
  2. ssh into a remote server.
  3. tmux/screen now provides multiplexing on the remote server, allowing easy opening of new terminals/shells on the remote server. Compared to opening a second terminal on local pc and re-connecting with a second ssh, this is one fewer step.

No. In those rare cases where screen inside of screen or tmux inside of tmux is useful, both programs provide a simple means of passing control to the nested instance.

Screen offers serial console capabilities, but I just use a dedicated app (miniterm.py distributed with python) when I need that. Otherwise I can't think of anything offhand that either can do and the other can't, but one might do it simpler than the other.

I would learn one or the other, and if you're curious or dissatisfied with what you picked, try the other. I prefer tmux, personally.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.