I'd like to write a script for opening multiple programs (servers) simultanously in separate terminals - doesn't matter which one - and assign different commands to different terminals with commands "landing" inside the correct terminal. Is this possible?
Maybe, something like this:

  1. open terminal1
  2. open terminal2 //simultanously with 1.
  3. command1 //execute in terminal1 without opening a new terminal window
  4. command2 //execute in terminal2 without opening a new terminal window
  5. ...

Can I somehow label terminal windows so commands are executed inside correct terminal?

I'd also like to watch all terminals while their programs are running - my programs have an argument for printing trace/debug to terminal. So I'd like to see what messages are exchanged between them.

NOTE: I'm less concerned about security of exchanged data since this script should serve as a "simulation". I've configured each server to run from an allocated port on localhost.

  • Check pssh ....
    – heemayl
    Jun 27, 2015 at 17:29
  • How accurate should the timing be; is a marge of let's say 2 seconds (per terminal) appropriate? Jun 27, 2015 at 17:34
  • @JacobVlijm: it's more important to me to assign commands correctly to according terminal "window" Jun 27, 2015 at 17:39
  • 1
    Can be done, especially when it is about simulation, will post back :) Jun 27, 2015 at 17:43
  • 1
    @JacomVlijm: actually my question is incidently solved: for sending a command to its correct instance each command must be prefixed with the datadir that instance starts upon! But for my luck this is implemented in bitcoin but i'll just leave the question unanswered .. perhaps someone comes up with a more general idea for any program!? :) But thanks though! Jun 27, 2015 at 21:53

2 Answers 2


Since you mention you solved the problem for your specific situation, below a solution for general purpose. Thanks to xdotool's --sync option, it works pretty reliable in the tests I ran; I could "send" commands to specific terminal windows and it ran perfectly without an exception.

How it works in practice

The solution exists from a script, which can be run with two options -set and -run:

  1. To set up (open) an arbitrary number of terminal windows, in this example 3:

    target_term -set 3

    Three new terminals will open up, their window id is remembered in a hidden file:

    enter image description here

    For clarity reasons I minimized the terminal window I ran the command from :)

  2. Now that I created three windows, I can send commands to either one of them with the run command (e.g.):

    target_term -run 2 echo "Monkey eats banana since it ran out of peanuts"

    As shown below, the command ran in the second terminal:

    enter image description here

    Subsequently, I can send a command to the first terminal:

     target_term -run 1 sudo apt-get update

    making sudo apt-get update run in terminal 1:

    enter image description here

    and so on...

How to set up

  1. The script needs both wmctrl and xdotool:

    sudo apt-get install wmctrl xdotool
  2. Copy the script below into an empty file, safe it as target_term (no extension!) in ~/bin (create the directory ~/bin if necessary.

  3. Make the script executable (don't forget) and either log out/in or run:

    source ~/.profile
  4. Now setup your terminal windows, with the number of required windows as an argument:

    target_term -set <number_of_windows>
  5. Now you can "send" commands to either one of your terminals with the command:

    target_term -run <terminal_number> <command_to_run>

The script

#!/usr/bin/env python3
import subprocess
import os
import sys
import time
#--- set your terminal below
application = "gnome-terminal"

option = sys.argv[1]
data = os.environ["HOME"]+"/.term_list"

def current_windows():
    w_list = subprocess.check_output(["wmctrl", "-lp"]).decode("utf-8")
    w_lines = [l for l in w_list.splitlines()]
        pid = subprocess.check_output(["pgrep", application]).decode("utf-8").strip()
        return [l for l in w_lines if str(pid) in l]
    except subprocess.CalledProcessError:
        return []

def arr_windows(n):
    w_count1 = current_windows()
    for requested in range(n):
    called = []
    while len(called) < n:
        w_count2 = current_windows()
        add = [w for w in w_count2 if not w in w_count1]
        [called.append(w.split()[0]) for w in add if not w in called]
        w_count1 = w_count2

    return called

def run_intterm(w, command):
    subprocess.call(["xdotool", "windowfocus", "--sync", w])
    subprocess.call(["xdotool", "type", command+"\n"]) 

if option == "-set":
    open(data, "w").write("")
    n = int(sys.argv[2])
    new = arr_windows(n)
    for w in new:
        open(data, "a").write(w+"\n")
elif option == "-run":
    t_term = open(data).read().splitlines()[int(sys.argv[2])-1]
    command = (" ").join(sys.argv[3:])
    run_intterm(t_term, command)


  • The script is set for gnome-terminal, but can be used for any terminal (or other program as well) by changing the application in the head section of the script:

    #--- set your terminal below
    application = "gnome-terminal"
  • The commands above can (of course) be run from a script as well in case you'd lile to use it for some kind of a simulation.
  • The script waits until both the targeted window has focus and the command is done typing, so the command will always land in the right terminal window.
  • No need to say that the script only works with the terminal setup (windows) that was called by the command:

    target_term -set

    The terminal windows will then be "labelled" by the script, like you mention in your question.

  • In case you start a new target_term session, the hidden file, created by the script will simply be overwritten, so there is no need to remove it otherwise.
  • 1
    Nice one, thanks! Should also be noted that python 3.x is also a requirement for this script to work.
    – pompalini
    Jun 6, 2019 at 12:52

After trying multiple methods without success, (even the script in the above answer wouldn't work for me), I installed tmux to get the job done.

  1. Install tmux sudo apt install tmux

  2. Open all terminals you want in your workspace and start a unique tmux session in each. You can name them simply "1" "2" and "3" for example if you want 3 terminals in your workspace. You do this by running tmux new-session -s <name-of-session>

  3. Whenever you want to run something in a specific terminal, run tmux send-keys -t <name-of-session> "desired-command" Enter from any terminal.

This works flawlessly for my case!

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .