Coloring Terminal Text: tput and ANSI Escape Sequences

C

A terminal with black-on-white text or vice versa is not very interesting or attractive or informative. Thankfully, modern terminal emulators offer a variety of text styling options as well as foreground and background colors. It’s just a matter of knowing how to apply them with ANSI escape sequences or the tput command. We will explore both methods in this article.

How a Terminal Formats Text

A terminal is an interface: its only function is to display text. It prints whatever it receives from the standard input, the standard output or the standard error. Typically, the shell provides a command prompt to print and as the user types a command, the terminal then prints each typed character. While the command executes, the terminal might receive an output to print from whatever program is currently running. A previous article explains the difference between a terminal, a console and a shell.

In order to be able to print anything, the terminal needs a font and a color that contrasts with its background. Plus, its users appreciate the option of displaying text in a different color or style. Being able to display a critical error message in red or to simply underline a link can be very useful.

In truth, the terminal doesn’t decide what font style or color to display on its own. It inherits them by default from a theme, its own or the operating system’s. The shell indicates which font style and color, if any, should be used to display the command prompt. All other colors come from either the shell or the programs that provide text to print.

Since the terminal only ever deals with text, programs that wish to specify the way a text should be printed must find a way to communicate the desired formatting in the text to be printed itself. That’s where ANSI escape sequences come in, as well as the tput command.

What is an ANSI Escape Sequence?

ANSI escape sequences are a standard that allows a terminal to receive information, not only about font styles and colors, but also the cursor’s position and many other terminal options. In order to encode this information, a distinct sequence of characters is directly embedded into the text it receives. The terminal interprets these sequences not as characters to print, but as commands.

An ANSI escape sequence always starts with an escape character, which can be written in one of three ways:

\e
\033
\x1BCode language: Shell Session (shell)

If we take a look at the ASCII table, we can see that these three notations all literally correspond to the 27th ASCII character, ESC (escape). The first is its textual notation, the second is its octal number, and the third, its hexadecimal number.

In most cases, the escape characters is followed up with an opened bracket “[“. Together, these two bytes constitute the CSI, the “control sequence introducer”.

Here is the complete ANSI control structure:

"\e" + "[" + <numbers separated with ";" (optional)> + <letter>Code language: Shell Session (shell)

We could think of a control sequence like this as a function call, where the letter at the end is the name of the function and the optional numbers in the middle are the parameters. With this interpretation, we could read a sequence like “\e[1;42m” like this:

\e[    # function call
1;42   # function parameters (1, 42)
m      # function nameCode language: Shell Session (shell)

These ANSI escape sequences can be used pretty much anywhere, in our programs, but also on the command line. To use an ANSI escape sequence in an echo command for example, we need to add the option -e so that the sequence can be interpreted:

$ echo -e "With -e, \e[1m<--this and that-->\e[0m is interpreted"Code language: Shell Session (shell)

We will later see which escape sequences allow us to control text display.

How Does the tput Command Work?

On the command line or in a Bash script, it might be preferable to use the tput command to indicate how a text should be displayed. This command uses the terminal’s terminfo to automatically find the correct escape sequence for a certain text effect. Terminfo is a database that describes all of the capabilities the terminal has: which operations it can do, how to perform them, and which initialization sequences it requires. To view the contents of terminfo, we can use the infocmp command.

Each one of the terminal’s capabilities has a name. For example, bold describes the terminal’s capability to apply the bold attribute to text. So through an echo command, we can emphasize a piece of text this way, for instance:

$ echo "This text is $(tput bold)important"Code language: Shell Session (shell)

The tput command will then find the right sequence in the terminfo to put the text in bold. Of course, these sequences are standardized thanks to ANSI escape sequences. However, tput does have two advantages: it can apply a capability even if the terminal does not comply with the ANSI standard, and it informs us if the terminal does not have the requested capability.

Indeed, each terminal is different and not all have the same capabilities. Most will be able to print text with basic font styles like in bold or italics, or with elementary colors like red, green and blue. But many do not support uncommon typographical attributes like strike-through or blink. Some don’t know any other color than black and white ! To see how many colors a terminal supports, we can use the tput colors command.

Styling Text in the Terminal

As we’ve seen, we can control the way in which the terminal displays text thanks to the tput command or ANSI escape codes. The following tables describe the codes for each method.

Regarding ANSI escape sequences, the letter to indicate at the end is “m”, which signals that we intend to control a graphics mode, i.e. text styling. If we wanted to control the cursor position, for example, we would use the “H” letter which corresponds to the cup capability in terminfo. Several other letters exist to control all sorts of other terminal options, but this article will concentrate only on text formatting.

Changing Text Attributes

There are several text attributes we can request to control a text’s font style. The following table shows both the ANSI code to add to the escape sequence as well as the terminfo capability name (“TermCap”) to pass to the tput command to achieve the described effect.

ANSI CodeTermCapDescriptionExample
0sgr0Reset all attributes or Normal
1boldBold or Bright
2dimDim
3sitmItalics
4smulUnderlined
5blinkBlinking
6blinkBlinking
7revInverted or Reversed
8invisInvisible
9smxxStrike-through

If we want a bold text, the full ANSI escape sequence will be: \e[1m. We can reproduce the same effect with the tput command in the following ways:

$ tput bold && echo hello
$ echo "$(tput bold) hello"Code language: Shell Session (shell)

So, does this mean we can combine all of these attributes to make text bold, dim, italics, blinking, inverted and crossed out? That’s a bit extreme, but the answer is yes, we can do all of that in one ANSI escape sequence if we separate each attribute with semicolons:

$ echo -e "\e[0;1;2;3;4;5;6;7;9mHello\e[0m"Code language: Shell Session (shell)

Needless to say, we can’t include the “invisible” attribute (8) if we want to see all the other effects. However, the invisible attribute (8) goes very well with the reverse attribute (7) in order to highlight the fact that there is text even though it is redacted, for example.

The order in which we provide the attributes does not matter, except for attribute 0. The 0 attribute resets all other style attributes and returns text to its default styling. Of course, if we put the 0 attribute at the end of our previous ANSI sequence, before the “m” and after all other attributes, the effects of those attributes will all be cancelled! That said, it is important to remember to add the \e[0m escape sequence at the end of our line or whenever we want the text to go back to normal. Otherwise, these style attributes will probably affect all of the following lines, until the terminal finds a \e[0m sequence.

The tput command has the same effect: we shouldn’t forget to add a tput sgr0 to cancel all of the previously set text attributes. However, setting several text attributes at once is a little more involved with tput. For example, to style a text with all of the attributes as we did earlier, we’ll have to call tput several times in a row:

$ tput bold && tput dim && tput sitm && tput smul && tput blink && tput rev && tput smxx && echo HelloCode language: Shell Session (shell)

In order to request several styling options in the same command call, we will have to use tput with the -S option. Then, we’ll have to input a list of capabilities, one per line, terminated with an exclamation mark, in the standard input in order to get the result we want:

$ echo "$(tput -S)Hello$(tput sgr0)"
> bold
> dim
> sitm
> smul
> blink
> rev
> smxx
> !Code language: Shell Session (shell)

Changing Foreground Text Colors

The following table presents the most common ANSI codes and terminfo capability names used to control the foreground color, the color of the text itself.

ANSI CodeTermCapColorExample
30setaf 0Black
31setaf 1Red
32setaf 2Green
33setaf 3Yellow or Brown
34setaf 4Blue
35setaf 5Purple or Pink
36setaf 6Cyan
37setaf 7Grey

These colors all have brighter variations. The ANSI codes for those variants go from 90 to 97, and their terminfo capability equivalents are setaf 8 to 15. This capability name, setaf, stands for “set a foreground”, meaning the text color.

Of course, we can combine a text color with a font style like bold or italics. It’s the same process that we saw earlier, all we need to do is add the color attribute to all of the other text attributes. For example, \e[34;4m (or \e[4;34m) will show the text in blue and underlined. While it is possible to specify several colors for the same text, only the last specified color will be applied. The \e[0m sequence cancels all color attributes as well.

The actual color a terminal displays varies, particularly with intermediary colors. Primary colors like red, green and blue are usually the same no matter the terminal. However, purple can often look more like pink and yellow might look brown.

However, with ANSI escape sequences, we can indicate a very specific RGB color, as long as the terminal is able to display 256 colors (check the terminal colors with tput colors or tput longname).

ANSI CodeDescription
38;2;r;g;bSets a text color with RGB values. For example: \e[38;2;255;0;255m

I haven’t found an equivalent to this in the terminfo capabilities, although it must exist. Please leave a comment if you know it, I’ll be happy to learn which capability allows us to specify RGB values with the tput command.

Displaying a Text Background Color

The method to apply background colors is the same as foreground colors. Here is the ANSI code and terminfo capability table for background colors.

ANSI CodeTermCapColorExample
40setab 0Black
41setab 1Red
42setab 2Green
43setab 3Yellow or Brown
44setab 4Blue
45setab 5Purple or Pink
46setab 6Cyan
47setab 7Grey

Just as text colors, there are more vivid versions of these background colors. For ANSI escape sequences, the codes for the brighter background colors range from 100 to 107, and their terminfo capability equivalents are setab 8 to 15. The name “setab” is also an abbreviation, this time for “set a background”.

As always, we can also combine background colors with foreground colors and other text attributes. For example, \e[1;34;3;43;4;5m will display bold, italic, underlined, blinking blue text on a yellow background. Splendid ! However, only the last specified background color will be displayed: it’s impossible to combine several background colors together. As with all other text attributes, a background color stops when another one replaces it or with the \e[0m escape sequence.

In the same way as foreground text colors, we can specify any RGB background color with this ANSI escape sequence:

ANSI CodeDescription
48;2;r;g;bSets a background color with RGB values.
For example: \e[48;2;255;0;255m

The name of the equivalent terminfo capability for this functionality eludes me as well.

Displaying the Styling Capabilities of a Terminal

As mentioned, terminal emulators don’t all have the same capabilities. Regarding colors, most terminals can display at least 8 basic colors for the foreground and background. Some offer up to 256 colors, while others cannot display anything other than black and white.

For font styling, most emulators are able to make a text bold, italic, invisible or reversed. However, ANSI escape sequences don’t always have the same exact effect in different terminals: what one terminal interprets as bold, another interprets as bright. Therefore, in the first terminal, bold and dim are compatible, whereas in the second, they are not.

So how can we see a terminal’s formatting capabilities and how it displays the different text attributes? In order to display the behavior of the same ANSI sequences in different terminals, all we need to do is write a small program, like this one in C:

#include <stdio.h>

int main(void)
{
	int n;
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			n = (10 * i) + j;
			printf("\e[%dm  %3d  \e[0m", n, n);
		}
		printf("\n");
	}
	return (0);
}
Code language: C++ (cpp)

The following images show the result of this little program in the GNOME terminal in Ubuntu. They illustrate the effects of all the ANSI escape sequences regarding text styling. Surprisingly, we’ve just discovered something new: in this terminal, the \e[21m sequence underlines the text twice!

Table illustrating the color and text attribute codes that may be used in an ANSI escape sequence, displayed in a dark-themed terminal on a black background.
Table of ANSI escape sequence codes in the GNOME terminal under Ubuntu (dark theme)
Table illustrating the color and text attribute codes that may be used in an ANSI escape sequence, displayed in a light-themed terminal on a white background.
Table of ANSI escape sequence codes in the GNOME terminal under Ubuntu (light theme)

If we compare these two results, we might notice that the theme of the terminal, light or dark, has a major effect on the legibility of certain color combinations. In a dark-themed terminal, the text with a black color (30) is totally invisible. In the light-themed terminal, the grey colors (37 and 97) are difficult to read. So we need to curb our coloring enthusiasm if we want to display specific colors in the outputs of programs we intend to distribute to other users. Not everyone uses the same theme we do!


That’s it for text styling in the terminal! If you know of other ways to control text display in the terminal, please let me know in the comments.

Sources and Further Reading

About the author

Mia Combeau

Student at 42Paris, digital world explorer. I code to the 42 school norm, which means for loops, switches, ternary operators and all kinds of other things are out of reach... for now!

4 comments

  • Thanks Mia!
    Using tput to colour my text was unknown to me before. Using ANSI colours was always too fiddly for me, your information made using tput immediately easy to understand.

    I ended up also putting tput into variables in order to make using it a breeze in the rest of my script:
    text_clr_red=$( tput setaf 11 )
    text_clr_end=$( tput srg0 )
    echo -e "${text_clr_red}URL not found${text_clr_end}"

    • Hi, I’m glad you found the tput information helpful. Great idea creating variables for each tput, they can be just as difficult to remember as the ANSI sequences ^^ Thanks for sharing !

  • Many Thank for the overview about these control sequences. Much easier to read than the numerous technical documents.
    You could drop the condition
    if (n > 109)
    break ;
    As soon as you are allowed to use for loops you might consider replacing the while loops.
    Thanks again.

By Mia Combeau
To Top