TTY vs PTY vs PTS in Linux: /dev/tty and /dev/pts Explained

TTY, PTY, and PTS are related Linux terminal concepts, but they do not represent the same thing.

• TTY is the general Linux terminal interface.
• PTY is a software-created pseudoterminal consisting of a master and slave.
• PTS normally refers to the slave side of a PTY, exposed as /dev/pts/N.
• /dev/tty refers to the controlling terminal of the current process.

For example, a shell opened on a Linux virtual console may use a device such as:

/dev/tty2

A shell opened in GNOME Terminal, inside tmux, through screen, or from script commonly uses a pseudoterminal slave such as:

/dev/pts/0

The number after /dev/pts/ changes with each tab, SSH session, or pane. Run tty on your current shell to print the device path connected to standard input:

tty

On an interactive shell attached to a pseudoterminal, sample output looks like this:

/dev/pts/4

When standard input is not a terminal, the same command prints:

not a tty

Tested on: Rocky Linux 10.2; kernel 6.12.0-211.28.1.el10_2.x86_64.

TTY vs PTY vs PTS at a Glance

A TTY is the general terminal abstraction. A PTY is a virtual TTY pair created by software, and /dev/pts/N is normally the slave endpoint used by the shell.

Understand Terminal, Shell, TTY, and Terminal Emulator

These four terms are often mixed together:

The diagram below shows the usual relationship in a graphical desktop session:

Clarify the roles like this:

• Bash is a shell, not a terminal.
• GNOME Terminal, Konsole, and xterm are terminal emulators.
• The terminal emulator normally controls the PTY master.
• The shell sees the PTY slave as its terminal.
• Closing the terminal emulator usually closes the PTY and affects the attached shell.

What Is a TTY in Linux?

TTY comes from teletypewriter. In modern Linux it means the kernel terminal layer that presents a character device with line discipline, job control, and signal delivery.

Depending on the device, a TTY may represent a virtual console, serial terminal, controlling terminal, or the slave side of a pseudoterminal.

Examples:

/dev/tty1       Linux virtual console
/dev/ttyS0      Serial terminal
/dev/pts/0      Pseudoterminal slave
/dev/tty        Current process's controlling terminal

Check a virtual console

From a text console, run:

tty

A possible result is:

/dev/tty2

Switching between virtual consoles may be possible with:

Ctrl+Alt+F2
Ctrl+Alt+F3

The exact keys and available consoles vary by distribution, desktop environment, and system configuration.

Understand /dev/tty

List the device node:

ls -l /dev/tty

Sample output:

crw-rw-rw-. 1 root tty 5, 0 Jul 14 01:21 /dev/tty

/dev/tty is not tied permanently to one numbered terminal. It refers to the controlling terminal of whichever process opens it. The kernel documents /dev/tty as a synonym for the calling process's controlling terminal, when one exists.

Compare the device reported by tty with the file descriptor behind standard input:

tty

Inside a pseudoterminal session:

/dev/pts/4

To inspect session, process group, and terminal columns together, use the ps command:

ps -o pid,ppid,sid,pgid,tpgid,tty,stat,cmd -p $$

Sample output on an interactive PTY:

PID    PPID     SID    PGID   TPGID TT       STAT CMD
 263840  263838  263840  263840  263840 pts/4    Ss   bash

The TT field shows the controlling terminal. TPGID shows the foreground process group for that terminal.

You can also confirm the stdin device path directly:

readlink /proc/$$/fd/0

Sample output:

/dev/pts/4

What Are PTY and PTS?

A pseudoterminal is a bidirectional pair of virtual character devices:

PTY master <---- bidirectional channel ----> PTY slave

• Data written to the master appears as input on the slave.
• Output written to the slave can be read from the master.
• The slave provides terminal behavior expected by shells and interactive programs.
• Control characters such as Ctrl+C can generate signals for the foreground process group.

PTY and PTS are not the same label:

• PTY: The complete pseudoterminal mechanism, including master and slave.
• PTY master: Used by a terminal emulator, SSH daemon, tmux, or another program.
• PTS: The pseudoterminal slave presented to the shell, usually as /dev/pts/N.

Linux exposes the devices like this:

/dev/ptmx       PTY master multiplexer
/dev/pts/0      First active PTY slave
/dev/pts/1      Another active PTY slave

Modern Linux programs open /dev/ptmx to allocate a UNIX 98 PTY and obtain a corresponding slave under /dev/pts. Opening /dev/ptmx returns a master file descriptor and creates an associated slave under /dev/pts; data written on either side is delivered through the other endpoint.

See TTY and PTY in Real Linux Sessions

Graphical terminal emulator

Open two terminal tabs and run tty in each one.

In the first tab:

tty

Sample output:

/dev/pts/4

In the second tab:

tty

Sample output:

/dev/pts/5

Each terminal tab normally receives a different /dev/pts/N slave. The who command displays recorded login sessions, such as virtual-console and SSH logins, but it may not list every graphical terminal tab.

SSH session

Connect with the ssh command:

ssh user@server

Then run:

tty

An interactive login commonly reports:

/dev/pts/0

For an interactive login, SSH normally requests a PTY when the local SSH client is itself attached to a terminal. OpenSSH documents that -T disables allocation, -t forces it, and repeated -t options can force allocation even when the client has no local TTY.

After connecting, list recorded SSH login sessions with who. To inspect broader connection state, see list and check active SSH connections in Linux.

who

Sample output showing SSH login records:

root     pts/0        2026-07-13 23:14 (10.0.2.2)
root     pts/1        2026-07-14 01:38 (10.0.2.2)

Compare a noninteractive remote command with a forced PTY:

ssh user@server tty

Sample output:

not a tty

ssh -t user@server tty

Sample output:

/dev/pts/5

The diagram below shows where the PTY is created in an SSH login:

tmux or screen

Terminal multiplexers such as tmux and screen allocate a separate PTY for each pane or window.

Start a tmux session:

tmux

Then run:

tty

Sample output:

/dev/pts/4

Opening another tmux window or pane normally creates another PTY slave with a different /dev/pts/N number.

Pipeline or redirected input

Run:

echo test | tty

Sample output:

not a tty

The tty command reports the terminal connected to standard input. When standard input is a pipe or file rather than a terminal, it reports that it is not a TTY.

Understand Controlling Terminals and Job Control

A Linux session may have one controlling terminal, shared by the processes in that session. At any moment, one process group is the terminal's foreground group, while the remaining process groups run in the background.

A typical interactive session looks like this:

Session
  |
  +-- Controlling terminal
  |       |
  |       `-- Current foreground process group
  |
  +-- Shell process group
  |
  `-- Command process groups

The terminal tracks the foreground process group. That enables actions such as:

Signal generation for Ctrl+C, Ctrl+Z, and Ctrl+\ depends on the terminal's termios settings such as ISIG.

Inspect session, process group, and terminal fields with ps:

ps -o user,pid,ppid,sid,pgid,tpgid,tty,stat,cmd

Read the columns like this:

• SID identifies the session.
• PGID identifies a process group.
• TPGID identifies the foreground process group associated with the process's terminal.
• TTY shows the controlling terminal.
• A daemon or noninteractive process may display ? because it has no controlling terminal.

Compare /dev/tty, /dev/ttyN, /dev/pts/N, and /dev/ptmx

These paths are frequently confused:

Show the devpts mount:

mount | grep devpts

Sample output:

devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,seclabel,gid=5,mode=620,ptmxmode=000)

List active PTY slave nodes:

ls -l /dev/pts

Sample output:

total 0
crw--w----. 1 root tty  136, 0 Jul 14 23:22 0
crw--w----. 1 root tty  136, 1 Jul 14 22:35 1
crw--w----. 1 root tty  136, 2 Jul 14 12:26 2
c---------. 1 root root   5, 2 Jul 13 22:48 ptmx

Inspect one slave device:

stat /dev/pts/0

Sample output:

File: /dev/pts/0
  Size: 0         	Blocks: 0          IO Block: 1024   character special file
Device: 0,25	Inode: 3           Links: 1     Device type: 136,0
Access: (0620/crw--w----)  Uid: (    0/    root)   Gid: (    5/     tty)

/dev/pts is a virtual filesystem containing active PTY slave device nodes. Entries appear and disappear as PTYs are allocated and released.

Compare other TTY-related device nodes:

ls -l /dev/tty1 /dev/ttyS0 /dev/console /dev/ptmx

Sample output:

crw--w----. 1 root tty     5,  1 Jul 13 22:48 /dev/console
crw-rw-rw-. 1 root tty     5,  2 Jul 14 22:35 /dev/ptmx
crw--w----. 1 gdm  tty     4,  1 Jul 13 22:48 /dev/tty1
crw-rw----. 1 root dialout 4, 64 Jul 13 22:48 /dev/ttyS0

Why Programs Need a PTY

Many programs behave differently when attached to a terminal.

Common PTY users include:

• Terminal emulators
• SSH interactive sessions
• tmux and screen
• script and scriptreplay
• expect
• sudo sessions when its policy or I/O logging uses a PTY — password prompts and terminal requirements are covered in the sudo command reference
• Interactive container sessions
• Test and automation tools that must emulate a user terminal

Check whether standard input is a terminal:

test -t 0 && echo "stdin is a terminal"

When standard input is not a terminal, the command prints nothing.

Allocate a pseudoterminal with script and run the same test:

script -q -c 'test -t 0 && echo "stdin is a terminal"' /dev/null

Sample output:

stdin is a terminal

Check standard output the same way:

test -t 1 && echo "stdout is a terminal"

Or:

[[ -t 1 ]] && echo "interactive output"

Terminal-aware programs may change:

• Colour output
• Progress bars
• Line buffering
• Password prompts
• Full-screen interfaces
• Signal handling
• Input editing

PTY in containers

Compare:

docker exec container command

docker exec -it container bash

• -i keeps standard input open.
• -t allocates a pseudo-TTY.
• Interactive shells normally need both.
• Do not allocate a TTY for pipelines carrying binary data unless required.

The same -i and -t pattern applies to Podman and other OCI runtimes.

Troubleshoot TTY and PTY Problems

Useful commands:

Print the terminal device connected to standard input:

tty

Show the current terminal line settings, including control characters and echo flags:

stty -a

When standard input is not a terminal, stty may report Inappropriate ioctl for device.

List processes with session, process group, foreground group, and controlling terminal columns:

ps -o pid,ppid,sid,pgid,tpgid,tty,stat,cmd

Show which device backs the shell's standard input:

readlink /proc/$$/fd/0

List every open file descriptor for the current shell, including sockets and terminal devices:

ls -l /proc/$$/fd/

List recorded login sessions and their TTY devices:

who

Show logged-in users, idle time, and the command each TTY is running:

w

Restore a broken terminal to a usable default state:

reset

Summary

• TTY is the general Linux terminal abstraction.
• /dev/ttyN usually represents a virtual console.
• /dev/ttyS* and /dev/ttyUSB* represent serial terminals.
• /dev/tty refers to the current process's controlling terminal.
• A PTY consists of a master and slave endpoint.
• /dev/pts/N is normally the PTY slave seen by the shell.
• Graphical terminal emulators, SSH, tmux, screen, and containers commonly allocate PTYs.
• Shells and terminals are separate components.
• PTYs provide terminal behavior, job control, signals, and interactive input to software-created sessions.

References

• tty(1)
• tty(4) — /dev/tty and controlling terminals
• pts(4) — /dev/ptmx and /dev/pts devices
• pty(7)
• termios(3)
• ssh(1)