I am trying to print a text in the terminal using echo command.

I want to print the text in a red color. How can I do that?

33 Answers

Black 0;30 Dark Gray 1;30 Red 0;31 Light Red 1;31 Green 0;32 Light Green 1;32 Brown/Orange 0;33 Yellow 1;33 Blue 0;34 Light Blue 1;34 Purple 0;35 Light Purple 1;35 Cyan 0;36 Light Cyan 1;36 Light Gray 0;37 White 1;37

And then use them like this in your script:

# .---------- constant part! # vvvv vvvv-- the code from above RED='\033[0;31m' NC='\033[0m' # No Color printf "I ${RED}love${NC} Stack Overflow\n"

which prints love in red.

From @james-lim's comment, if you are using the echo command, be sure to use the -e flag to allow backslash escapes.

# Continued from above example echo -e "I ${RED}love${NC} Stack Overflow"

(don't add "\n" when using echo unless you want to add an additional empty line)

some variables that you can use:

# Reset Color_Off='\033[0m' # Text Reset # Regular Colors Black='\033[0;30m' # Black Red='\033[0;31m' # Red Green='\033[0;32m' # Green Yellow='\033[0;33m' # Yellow Blue='\033[0;34m' # Blue Purple='\033[0;35m' # Purple Cyan='\033[0;36m' # Cyan White='\033[0;37m' # White # Bold BBlack='\033[1;30m' # Black BRed='\033[1;31m' # Red BGreen='\033[1;32m' # Green BYellow='\033[1;33m' # Yellow BBlue='\033[1;34m' # Blue BPurple='\033[1;35m' # Purple BCyan='\033[1;36m' # Cyan BWhite='\033[1;37m' # White # Underline UBlack='\033[4;30m' # Black URed='\033[4;31m' # Red UGreen='\033[4;32m' # Green UYellow='\033[4;33m' # Yellow UBlue='\033[4;34m' # Blue UPurple='\033[4;35m' # Purple UCyan='\033[4;36m' # Cyan UWhite='\033[4;37m' # White # Background On_Black='\033[40m' # Black On_Red='\033[41m' # Red On_Green='\033[42m' # Green On_Yellow='\033[43m' # Yellow On_Blue='\033[44m' # Blue On_Purple='\033[45m' # Purple On_Cyan='\033[46m' # Cyan On_White='\033[47m' # White # High Intensity IBlack='\033[0;90m' # Black IRed='\033[0;91m' # Red IGreen='\033[0;92m' # Green IYellow='\033[0;93m' # Yellow IBlue='\033[0;94m' # Blue IPurple='\033[0;95m' # Purple ICyan='\033[0;96m' # Cyan IWhite='\033[0;97m' # White # Bold High Intensity BIBlack='\033[1;90m' # Black BIRed='\033[1;91m' # Red BIGreen='\033[1;92m' # Green BIYellow='\033[1;93m' # Yellow BIBlue='\033[1;94m' # Blue BIPurple='\033[1;95m' # Purple BICyan='\033[1;96m' # Cyan BIWhite='\033[1;97m' # White # High Intensity backgrounds On_IBlack='\033[0;100m' # Black On_IRed='\033[0;101m' # Red On_IGreen='\033[0;102m' # Green On_IYellow='\033[0;103m' # Yellow On_IBlue='\033[0;104m' # Blue On_IPurple='\033[0;105m' # Purple On_ICyan='\033[0;106m' # Cyan On_IWhite='\033[0;107m' # White

the escape character in bash, hex and octal respectively:

| | bash | hex | octal | NOTE | |-------+-------+---------+---------+------------------------------| | start | \e | \x1b | \033 | | | start | \E | \x1B | - | x cannot be capital | | end | \e[0m | \x1b[0m | \033[0m | | | end | \e[m | \x1b[m | \033[m | 0 is appended if you omit it | | | | | | |

short example:

| color | bash | hex | octal | NOTE | |-------------+--------------+----------------+----------------+---------------------------------------| | start green | \e[32m<text> | \x1b[32m<text> | \033[32m<text> | m is NOT optional | | reset | <text>\e[0m | <text>\1xb[0m | <text>\033[om | o is optional (do it as best practice | | | | | | |

bash exception:

If you are going to use these codes in your special bash variables

PS0
PS1
PS2 (= this is for prompting)
PS4

you should add extra escape characters so that bash can interpret them correctly. Without this adding extra escape characters it works but you will face problems when you use Ctrl + r for search in your history.

exception rule for bash

You should add \[ before any starting ANSI code and add \] after any ending ones.
Example:
in regular usage: \033[32mThis is in green\033[0m
for PS0/1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[ is for start of a sequence of non-printable characters
\] is for end of a sequence of non-printable characters

Tip: for memorize it you can first add \[\] and then put your ANSI code between them:

\[start-ANSI-code\]
\[end-ANSI-code\]

type of color sequence:

3/4 bit
8 bit
24 bit

Before diving into these colors, you should know about 4 modes with these codes:

1. color-mode

It modifies the style of color NOT text. For example make the color bright or darker.

0 reset
1; lighter than normal
2; darker than normal

This mode is not supported widely. It is fully support on Gnome-Terminal.

2. text-mode

This mode is for modifying the style of text NOT color.

3; italic
4; underline
5; blinking (slow)
6; blinking (fast)
7; reverse
8; hide
9; cross-out

and are almost supported.
For example KDE-Konsole supports 5; but Gnome-Terminal does not and Gnome supports 8; but KDE does not.

3. foreground mode

This mode is for colorizing the foreground.

4. background mode

This mode is for colorizing the background.

The below table shows a summary of 3/4 bit version of ANSI-color

|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | color-mode | octal | hex | bash | description | example (= in octal) | NOTE | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 0 | \033[0m | \x1b[0m | \e[0m | reset any affect | echo -e "\033[0m" | 0m equals to m | | 1 | \033[1m | | | light (= bright) | echo -e "\033[1m####\033[m" | - | | 2 | \033[2m | | | dark (= fade) | echo -e "\033[2m####\033[m" | - | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | text-mode | ~ | | | ~ | ~ | ~ | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 3 | \033[3m | | | italic | echo -e "\033[3m####\033[m" | | | 4 | \033[4m | | | underline | echo -e "\033[4m####\033[m" | | | 5 | \033[5m | | | blink (slow) | echo -e "\033[3m####\033[m" | | | 6 | \033[6m | | | blink (fast) | ? | not wildly support | | 7 | \003[7m | | | reverse | echo -e "\033[7m####\033[m" | it affects the background/foreground | | 8 | \033[8m | | | hide | echo -e "\033[8m####\033[m" | it affects the background/foreground | | 9 | \033[9m | | | cross | echo -e "\033[9m####\033[m" | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | foreground | ~ | | | ~ | ~ | ~ | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 30 | \033[30m | | | black | echo -e "\033[30m####\033[m" | | | 31 | \033[31m | | | red | echo -e "\033[31m####\033[m" | | | 32 | \033[32m | | | green | echo -e "\033[32m####\033[m" | | | 33 | \033[33m | | | yellow | echo -e "\033[33m####\033[m" | | | 34 | \033[34m | | | blue | echo -e "\033[34m####\033[m" | | | 35 | \033[35m | | | purple | echo -e "\033[35m####\033[m" | real name: magenta = reddish-purple | | 36 | \033[36m | | | cyan | echo -e "\033[36m####\033[m" | | | 37 | \033[37m | | | white | echo -e "\033[37m####\033[m" | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 38 | 8/24 | This is for special use of 8-bit or 24-bit | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | background | ~ | | | ~ | ~ | ~ | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 40 | \033[40m | | | black | echo -e "\033[40m####\033[m" | | | 41 | \033[41m | | | red | echo -e "\033[41m####\033[m" | | | 42 | \033[42m | | | green | echo -e "\033[42m####\033[m" | | | 43 | \033[43m | | | yellow | echo -e "\033[43m####\033[m" | | | 44 | \033[44m | | | blue | echo -e "\033[44m####\033[m" | | | 45 | \033[45m | | | purple | echo -e "\033[45m####\033[m" | real name: magenta = reddish-purple | | 46 | \033[46m | | | cyan | echo -e "\033[46m####\033[m" | | | 47 | \033[47m | | | white | echo -e "\033[47m####\033[m" | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 48 | 8/24 | This is for special use of 8-bit or 24-bit | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

The below table shows a summary of 8 bit version of ANSI-color

|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | foreground | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | 0-7 | \033[38;5 | \x1b[38;5 | \e[38;5 | standard. normal | echo -e '\033[38;5;1m####\033[m' | | | 8-15 | | | | standard. light | echo -e '\033[38;5;9m####\033[m' | | | 16-231 | | | | more resolution | echo -e '\033[38;5;45m####\033[m' | has no specific pattern | | 232-255 | | | | | echo -e '\033[38;5;242m####\033[m' | from black to white | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | foreground | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | 0-7 | | | | standard. normal | echo -e '\033[48;5;1m####\033[m' | | | 8-15 | | | | standard. light | echo -e '\033[48;5;9m####\033[m' | | | 16-231 | | | | more resolution | echo -e '\033[48;5;45m####\033[m' | | | 232-255 | | | | | echo -e '\033[48;5;242m####\033[m' | from black to white | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|

The 8-bit fast test:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

The below table shows a summary of 24 bit version of ANSI-color

|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | foreground | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | 0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | R = red | echo -e '\033[38;2;255;0;02m####\033[m' | R=255, G=0, B=0 | | 0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | G = green | echo -e '\033[38;2;;0;255;02m####\033[m' | R=0, G=255, B=0 | | 0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | B = blue | echo -e '\033[38;2;0;0;2552m####\033[m' | R=0, G=0, B=255 | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | background | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | 0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | R = red | echo -e '\033[48;2;255;0;02m####\033[m' | R=255, G=0, B=0 | | 0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | G = green | echo -e '\033[48;2;;0;255;02m####\033[m' | R=0, G=255, B=0 | | 0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | B = blue | echo -e '\033[48;2;0;0;2552m####\033[m' | R=0, G=0, B=255 | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|

some screen-shots

foreground 8-bit summary in a .gif

background 8-bit summary in a .gif

color summary with their values

`blinking` on KDE-Terminal

a simple `C` code that shows you more

a more advanced tool that I developed to deal with these colors:

color-mode shot

text mode shot

combining is OK

more shots

Tips and Tricks for Advanced Users and Programmers:

Can we use these codes in a programming language?

Yes, you can. I experienced in bash, c, c++, d perl, python

Do they slow down the speed of a program?

I think, NO.

Can we use these on Windows?

3/4-bit Yes, if you compile the code with gcc
some screen-shots on Win-7

How to calculate the length of code?

\033[ = 2, other parts 1

Where can we use these codes?

Anywhere that has a tty interpreter
xterm, gnome-terminal, kde-terminal, mysql-client-CLI and so on.
For example if you want to colorize your output with mysql you can use Perl

#!/usr/bin/perl -n print "\033[1m\033[31m$1\033[36m$2\033[32m$3\033[33m$4\033[m" while /([|+-]+)|([0-9]+)|([a-zA-Z_]+)|([^\w])/g;

store this code in a file name: pcc (= Perl Colorize Character) and then put the file a in valid PATH then use it anywhere you like.

ls | pcc
df | pcc

inside mysql first register it for pager and then try:

[user2:db2] pager pcc PAGER set to 'pcc' [user2:db2] select * from table-name;

It does NOT handle Unicode.

Do these codes only do colorizing?

No, they can do a lot of interesting things. Try:

echo -e '\033[2K' # clear the screen and do not move the position

or:

echo -e '\033[2J\033[u' # clear the screen and reset the position

There are a lot of beginners that want to clear the screen with system( "clear" ) so you can use this instead of system(3) call

Are they available in Unicode?

Yes. \u001b

Which version of these colors is preferable?

It is easy to use 3/4-bit, but it is much accurate and beautiful to use 24-bit.
If you do not have experience with html so here is a quick tutorial:
24 bits means: 00000000 and 00000000 and 00000000. Each 8-bit is for a specific color.
1..8 is for and 9..16 for and 17..24 for
So in html #FF0000 means and here it is: 255;0;0
in html #00FF00 means which here is: 0;255;0
Does that make sense? what color you want combine it with these three 8-bit values.

reference:
Wikipedia
ANSI escape sequences
tldp.org
tldp.org
misc.flogisoft.com
some blogs/web-pages that I do not remember

You can use the awesome tput command (suggested in Ignacio's answer) to produce terminal control codes for all kinds of things.

Usage

Specific tput sub-commands are discussed later.

Direct

Call tput as part of a sequence of commands:

tput setaf 1; echo "this is red text"

Use ; instead of && so if tput errors the text still shows.

Shell variables

Another option is to use shell variables:

red=`tput setaf 1` green=`tput setaf 2` reset=`tput sgr0` echo "${red}red text ${green}green text${reset}"

tput produces character sequences that are interpreted by the terminal as having a special meaning. They will not be shown themselves. Note that they can still be saved into files or processed as input by programs other than the terminal.

Command substitution

It may be more convenient to insert tput's output directly into your echo strings using command substitution:

echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)"

Example

The above command produces this on Ubuntu:

Screenshot of colour terminal text

Foreground & background colour commands

tput setab [1-7] # Set the background colour using ANSI escape tput setaf [1-7] # Set the foreground colour using ANSI escape

Colours are as follows:

Num Colour #define R G B 0 black COLOR_BLACK 0,0,0 1 red COLOR_RED 1,0,0 2 green COLOR_GREEN 0,1,0 3 yellow COLOR_YELLOW 1,1,0 4 blue COLOR_BLUE 0,0,1 5 magenta COLOR_MAGENTA 1,0,1 6 cyan COLOR_CYAN 0,1,1 7 white COLOR_WHITE 1,1,1

There are also non-ANSI versions of the colour setting functions (setb instead of setab, and setf instead of setaf) which use different numbers, not given here.

Text mode commands

tput bold # Select bold mode tput dim # Select dim (half-bright) mode tput smul # Enable underline mode tput rmul # Disable underline mode tput rev # Turn on reverse video mode tput smso # Enter standout (bold) mode tput rmso # Exit standout mode

Cursor movement commands

tput cup Y X # Move cursor to screen postion X,Y (top left is 0,0) tput cuf N # Move N characters forward (right) tput cub N # Move N characters back (left) tput cuu N # Move N lines up tput ll # Move to last line, first column (if no cup) tput sc # Save the cursor position tput rc # Restore the cursor position tput lines # Output the number of lines of the terminal tput cols # Output the number of columns of the terminal

Clear and insert commands

tput ech N # Erase N characters tput clear # Clear screen and move the cursor to 0,0 tput el 1 # Clear to beginning of line tput el # Clear to end of line tput ed # Clear to end of screen tput ich N # Insert N characters (moves rest of line forward!) tput il N # Insert N lines

Other commands

tput sgr0 # Reset text format to the terminal's default tput bel # Play a bell

With compiz wobbly windows, the bel command makes the terminal wobble for a second to draw the user's attention.

Scripts

tput accepts scripts containing one command per line, which are executed in order before tput exits.

Avoid temporary files by echoing a multiline string and piping it:

echo -e "setf 7\nsetb 1" | tput -S # set fg white and bg red

Notes on portability of `tput`

First time tput(1) source code was uploaded in September 1986

tput(1) has been available in X/Open curses semantics in 1990s (1997 standard has the semantics mentioned below).

So, it's (quite) ubiquitous.

Thanks to @k-five for this answer

declare -A colors #curl # Reset colors[Color_Off]='\033[0m' # Text Reset # Regular Colors colors[Black]='\033[0;30m' # Black colors[Red]='\033[0;31m' # Red colors[Green]='\033[0;32m' # Green colors[Yellow]='\033[0;33m' # Yellow colors[Blue]='\033[0;34m' # Blue colors[Purple]='\033[0;35m' # Purple colors[Cyan]='\033[0;36m' # Cyan colors[White]='\033[0;37m' # White # Bold colors[BBlack]='\033[1;30m' # Black colors[BRed]='\033[1;31m' # Red colors[BGreen]='\033[1;32m' # Green colors[BYellow]='\033[1;33m' # Yellow colors[BBlue]='\033[1;34m' # Blue colors[BPurple]='\033[1;35m' # Purple colors[BCyan]='\033[1;36m' # Cyan colors[BWhite]='\033[1;37m' # White # Underline colors[UBlack]='\033[4;30m' # Black colors[URed]='\033[4;31m' # Red colors[UGreen]='\033[4;32m' # Green colors[UYellow]='\033[4;33m' # Yellow colors[UBlue]='\033[4;34m' # Blue colors[UPurple]='\033[4;35m' # Purple colors[UCyan]='\033[4;36m' # Cyan colors[UWhite]='\033[4;37m' # White # Background colors[On_Black]='\033[40m' # Black colors[On_Red]='\033[41m' # Red colors[On_Green]='\033[42m' # Green colors[On_Yellow]='\033[43m' # Yellow colors[On_Blue]='\033[44m' # Blue colors[On_Purple]='\033[45m' # Purple colors[On_Cyan]='\033[46m' # Cyan colors[On_White]='\033[47m' # White # High Intensity colors[IBlack]='\033[0;90m' # Black colors[IRed]='\033[0;91m' # Red colors[IGreen]='\033[0;92m' # Green colors[IYellow]='\033[0;93m' # Yellow colors[IBlue]='\033[0;94m' # Blue colors[IPurple]='\033[0;95m' # Purple colors[ICyan]='\033[0;96m' # Cyan colors[IWhite]='\033[0;97m' # White # Bold High Intensity colors[BIBlack]='\033[1;90m' # Black colors[BIRed]='\033[1;91m' # Red colors[BIGreen]='\033[1;92m' # Green colors[BIYellow]='\033[1;93m' # Yellow colors[BIBlue]='\033[1;94m' # Blue colors[BIPurple]='\033[1;95m' # Purple colors[BICyan]='\033[1;96m' # Cyan colors[BIWhite]='\033[1;97m' # White # High Intensity backgrounds colors[On_IBlack]='\033[0;100m' # Black colors[On_IRed]='\033[0;101m' # Red colors[On_IGreen]='\033[0;102m' # Green colors[On_IYellow]='\033[0;103m' # Yellow colors[On_IBlue]='\033[0;104m' # Blue colors[On_IPurple]='\033[0;105m' # Purple colors[On_ICyan]='\033[0;106m' # Cyan colors[On_IWhite]='\033[0;107m' # White color=${colors[$input_color]} white=${colors[White]} # echo $white for i in "${!colors[@]}" do echo -e "$i = ${colors[$i]}I love you$white" done

Result

Hope this image help you to pick your color for your bash :D

If you are using zsh or bash

black() { echo -e "\e[30m${1}\e[0m" } red() { echo -e "\e[31m${1}\e[0m" } green() { echo -e "\e[32m${1}\e[0m" } yellow() { echo -e "\e[33m${1}\e[0m" } blue() { echo -e "\e[34m${1}\e[0m" } magenta() { echo -e "\e[35m${1}\e[0m" } cyan() { echo -e "\e[36m${1}\e[0m" } gray() { echo -e "\e[90m${1}\e[0m" } black 'BLACK' red 'RED' green 'GREEN' yellow 'YELLOW' blue 'BLUE' magenta 'MAGENTA' cyan 'CYAN' gray 'GRAY'

Try online

We can use 24 Bits RGB true colors for both text and background!

 ESC[38;2;⟨r⟩;⟨g⟩;⟨b⟩m /*Foreground color*/ ESC[48;2;⟨r⟩;⟨g⟩;⟨b⟩m /*Background color*/

Example red text and closing tag:

 echo -e "\e[38;2;255;0;0mHello world\e[0m"

Generator:

text.addEventListener("input",update) back.addEventListener("input",update) function update(){ let a = text.value.substr(1).match(/.{1,2}/g) let b = back.value.substr(1).match(/.{1,2}/g) out1.textContent = "echo -e \"\\" + `033[38;2;${parseInt(a[0],16)};${parseInt(a[1],16)};${parseInt(a[2],16)}mHello\"` out2.textContent = "echo -e \"\\" + `033[48;2;${parseInt(b[0],16)};${parseInt(b[1],16)};${parseInt(b[2],16)}mWorld!\"` }

div {padding:1rem;font-size:larger}

TEXT COLOR: <input type="color" value="#23233"> <br><div></div> BACK COLOR: <input type="color" value="#FFFF00"> <br><div>

24-bit: As "true color" graphic cards with 16 to 24 bits of color became common, Xterm,KDE's Konsole, as well as all libvte based terminals (including GNOME Terminal) support 24-bit foreground and background color setting

Is it safe to use in my scripts?

Yes! 8 and 16 bits terminals will just display as fallback a color on the range of the available palette, keeping the best contrast, no breakages!

Also, nobody noticed the usefulness of the ANSI code 7 reversed video.

It stay readable on any terminal schemes colors, black or white backgrounds, or other fancies palettes, by swapping foreground and background colors.

Example, for a red background that works everywhere:

echo -e "\033[31;7mHello world\e[0m";

This is how it looks when changing the terminal built-in schemes:

This is the loop script used for the gif.

for i in {30..49};do echo -e "\033[$i;7mReversed color code $i\e[0m Hello world!";done

See (Select_Graphic_Rendition)_parameters

I instead of hard coding escape codes that are specific to your current terminal, you should use tput.

This is my favorite demo script:

#!/bin/bash tput init end=$(( $(tput colors)-1 )) w=8 for c in $(seq 0 $end); do eval "$(printf "tput setaf %3s " "$c")"; echo -n "$_" [[ $c -ge $(( w*2 )) ]] && offset=2 || offset=0 [[ $(((c+offset) % (w-offset))) -eq $(((w-offset)-1)) ]] && echo done tput init

These codes work on my Ubuntu box:

enter image description here

echo -e "\x1B[31m foobar \x1B[0m" echo -e "\x1B[32m foobar \x1B[0m" echo -e "\x1B[96m foobar \x1B[0m" echo -e "\x1B[01;96m foobar \x1B[0m" echo -e "\x1B[01;95m foobar \x1B[0m" echo -e "\x1B[01;94m foobar \x1B[0m" echo -e "\x1B[01;93m foobar \x1B[0m" echo -e "\x1B[01;91m foobar \x1B[0m" echo -e "\x1B[01;90m foobar \x1B[0m" echo -e "\x1B[01;89m foobar \x1B[0m" echo -e "\x1B[01;36m foobar \x1B[0m"

This prints the letters a b c d all in different colors:

echo -e "\x1B[0;93m a \x1B[0m b \x1B[0;92m c \x1B[0;93m d \x1B[0;94m"

For loop:

for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done

enter image description here

Emoji

one thing you can do that is not mentioned in the answer is to use emojis to color your output!

echo 📕: error message echo 📙: warning message echo 📗: ok status message echo 📘: action message echo 📔: Or anything you like and want to recognize immediately by color echo 💩: Or with a specific emoji

🎁 Bonus Added Value

This method is very useful especially when your source editor for the script supports displaying Unicode. Then you can also see the colorful script even before running it and directly in the source! :

VSCode demo _{Image of a script file inside the VSCode}

Note: You may need to pass the Unicode of the emoji directly:

echo $'\U0001f972' // this emoji: 🥲

_{Note the capital U for Unicode characters >= 10000}

Also, It's very rare but you may need to pass the code like this:

echo <0001f972>

Thanks to @joanis from comments for mentioning this

The other answers already give great explanations on how to do this. What I was still missing was a well-arranged overview over the color codes. The wikipedia article "ANSI escape code" is very helpful at that. However, since colors can often be configured and look differently in each terminal, I prefer to have a function that can be called in the terminal. For this purpose, I have created the following functions to show a color table and remind me of how to set them (with the arrangement being inspired by the wiki article). You could e.g. load them in your .bashrc/.zshrc or put them as a script somewhere.

256 colors

Generated by this bash/zsh script:

function showcolors256() { local row col blockrow blockcol red green blue local showcolor=_showcolor256_${1:-bg} local white="\033[1;37m" local reset="\033[0m" echo -e "Set foreground color: \\\\033[38;5;${white}NNN${reset}m" echo -e "Set background color: \\\\033[48;5;${white}NNN${reset}m" echo -e "Reset color & style: \\\\033[0m" echo echo 16 standard color codes: for row in {0..1}; do for col in {0..7}; do $showcolor $(( row*8 + col )) $row done echo done echo echo 6·6·6 RGB color codes: for blockrow in {0..2}; do for red in {0..5}; do for blockcol in {0..1}; do green=$(( blockrow*2 + blockcol )) for blue in {0..5}; do $showcolor $(( red*36 + green*6 + blue + 16 )) $green done echo -n " " done echo done echo done echo 24 grayscale color codes: for row in {0..1}; do for col in {0..11}; do $showcolor $(( row*12 + col + 232 )) $row done echo done echo } function _showcolor256_fg() { local code=$( printf %03d $1 ) echo -ne "\033[38;5;${code}m" echo -nE " $code " echo -ne "\033[0m" } function _showcolor256_bg() { if (( $2 % 2 == 0 )); then echo -ne "\033[1;37m" else echo -ne "\033[0;30m" fi local code=$( printf %03d $1 ) echo -ne "\033[48;5;${code}m" echo -nE " $code " echo -ne "\033[0m" }

16 colors

Generated by this bash/zsh script:

function showcolors16() { _showcolor "\033[0;30m" "\033[1;30m" "\033[40m" "\033[100m" _showcolor "\033[0;31m" "\033[1;31m" "\033[41m" "\033[101m" _showcolor "\033[0;32m" "\033[1;32m" "\033[42m" "\033[102m" _showcolor "\033[0;33m" "\033[1;33m" "\033[43m" "\033[103m" _showcolor "\033[0;34m" "\033[1;34m" "\033[44m" "\033[104m" _showcolor "\033[0;35m" "\033[1;35m" "\033[45m" "\033[105m" _showcolor "\033[0;36m" "\033[1;36m" "\033[46m" "\033[106m" _showcolor "\033[0;37m" "\033[1;37m" "\033[47m" "\033[107m" } function _showcolor() { for code in $@; do echo -ne "$code" echo -nE " $code" echo -ne " \033[0m " done echo }

For readability

If you want to improve the readability of the code, you can echo the string first then add the color later by using sed:

echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/'

to show the message output with diffrent color you can make :

echo -e "\033[31;1mYour Message\033[0m"

-Black 0;30 Dark Gray 1;30

-Red 0;31 Light Red 1;31

-Green 0;32 Light Green 1;32

-Brown/Orange 0;33 Yellow 1;33

-Blue 0;34 Light Blue 1;34

-Purple 0;35 Light Purple 1;35

-Cyan 0;36 Light Cyan 1;36

-Light Gray 0;37 White 1;37

My favourite answer so far is coloredEcho.

Just to post another option, you can check out this little tool xcol

you use it just like grep, and it will colorize its stdin with a different color for each argument, for instance

sudo netstat -putan | xcol httpd sshd dnsmasq pulseaudio conky tor Telegram firefox "[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+" ":[[:digit:]]+" "tcp." "udp." LISTEN ESTABLISHED TIME_WAIT

Note that it accepts any regular expression that sed will accept.

This tool uses the following definitions

#normal=$(tput sgr0) # normal text normal=$'\e[0m' # (works better sometimes) bold=$(tput bold) # make colors bold/bright red="$bold$(tput setaf 1)" # bright red text green=$(tput setaf 2) # dim green text fawn=$(tput setaf 3); beige="$fawn" # dark yellow text yellow="$bold$fawn" # bright yellow text darkblue=$(tput setaf 4) # dim blue text blue="$bold$darkblue" # bright blue text purple=$(tput setaf 5); magenta="$purple" # magenta text pink="$bold$purple" # bright magenta text darkcyan=$(tput setaf 6) # dim cyan text cyan="$bold$darkcyan" # bright cyan text gray=$(tput setaf 7) # dim white text darkgray="$bold"$(tput setaf 0) # bold black = dark gray text white="$bold$gray" # bright white text

I use these variables in my scripts like so

echo "${red}hello ${yellow}this is ${green}coloured${normal}"

I'm using this for color printing

#!/bin/bash #--------------------------------------------------------------------+ #Color picker, usage: printf $BLD$CUR$RED$BBLU'Hello World!'$DEF | #-------------------------+--------------------------------+---------+ # Text color | Background color | | #-----------+-------------+--------------+-----------------+ | # Base color|Lighter shade| Base color | Lighter shade | | #-----------+-------------+--------------+-----------------+ | BLK='\e[30m'; blk='\e[90m'; BBLK='\e[40m'; bblk='\e[100m' #| Black | RED='\e[31m'; red='\e[91m'; BRED='\e[41m'; bred='\e[101m' #| Red | GRN='\e[32m'; grn='\e[92m'; BGRN='\e[42m'; bgrn='\e[102m' #| Green | YLW='\e[33m'; ylw='\e[93m'; BYLW='\e[43m'; bylw='\e[103m' #| Yellow | BLU='\e[34m'; blu='\e[94m'; BBLU='\e[44m'; bblu='\e[104m' #| Blue | MGN='\e[35m'; mgn='\e[95m'; BMGN='\e[45m'; bmgn='\e[105m' #| Magenta | CYN='\e[36m'; cyn='\e[96m'; BCYN='\e[46m'; bcyn='\e[106m' #| Cyan | WHT='\e[37m'; wht='\e[97m'; BWHT='\e[47m'; bwht='\e[107m' #| White | #-------------------------{ Effects }----------------------+---------+ DEF='\e[0m' #Default color and effects | BLD='\e[1m' #Bold\brighter | DIM='\e[2m' #Dim\darker | CUR='\e[3m' #Italic font | UND='\e[4m' #Underline | INV='\e[7m' #Inverted | COF='\e[?25l' #Cursor Off | CON='\e[?25h' #Cursor On | #------------------------{ Functions }-------------------------------+ # Text positioning, usage: XY 10 10 'Hello World!' | XY () { printf "\e[$2;${1}H$3"; } #| # Print line, usage: line - 10 | line -= 20 | line 'Hello World!' 20 | line () { printf -v _L %$2s; printf -- "${_L// /$1}"; } #| # Create sequence like {0..(X-1)} | que () { printf -v _N %$1s; _N=(${_N// / 1}); printf "${!_N[*]}"; } #| #--------------------------------------------------------------------+

All basic colors set as vars and also there are some usefull functions: XY, line and que. Source this script in one of yours and use all color vars and functions.

You may "combined" colours and text-mode.

#!/bin/bash echo red text / black background \(Reverse\) echo "\033[31;7mHello world\e[0m"; echo -e "\033[31;7mHello world\e[0m"; echo echo yellow text / red background echo "\033[32;41mHello world\e[0m"; echo -e "\033[32;41mHello world\e[0m"; echo "\033[0;32;41mHello world\e[0m"; echo -e "\033[0;32;41mHello world\e[0m"; echo echo yellow BOLD text / red background echo "\033[1;32;41mHello world\e[0m"; echo -e "\033[1;32;41mHello world\e[0m"; echo echo yellow BOLD text underline / red background echo "\033[1;4;32;41mHello world\e[0m"; echo -e "\033[1;4;32;41mHello world\e[0m"; echo "\033[1;32;4;41mHello world\e[0m"; echo -e "\033[1;32;4;41mHello world\e[0m"; echo "\033[4;32;41;1mHello world\e[0m"; echo -e "\033[4;32;41;1mHello world\e[0m"; echo

To expand on this answer, for the lazy of us:

function echocolor() { # $1 = string COLOR='\033[1;33m' NC='\033[0m' printf "${COLOR}$1${NC}\n" } echo "This won't be colored" echocolor "This will be colorful"

You should definitely use tput over raw ANSI control sequences.

Because there's a large number of different terminal control languages, usually a system has an intermediate communication layer. The real codes are looked up in a database for the currently detected terminal type and you give standardized requests to an API or (from the shell) to a command.

One of these commands is tput . tput accepts a set of acronyms called capability names and any parameters, if appropriate, then looks up the correct escape sequences for the detected terminal in the terminfo database and prints the correct codes (the terminal hopefully understands).

from

That said, I wrote a small helper library called bash-tint, which adds another layer on top of tput, making it even simpler to use (imho):

Example: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

Would give the following result:

And this what I used to see all combination and decide which reads cool:

for (( i = 0; i < 8; i++ )); do for (( j = 0; j < 8; j++ )); do printf "$(tput setab $i)$(tput setaf $j)(b=$i, f=$j)$(tput sgr0)\n" done done

Heres what I ended up with using sed

echo " [timestamp] production.FATAL Some Message\n" \ "[timestamp] production.ERROR Some Message\n" \ "[timestamp] production.WARNING Some Message\n" \ "[timestamp] production.INFO Some Message\n" \ "[timestamp] production.DEBUG Some Message\n" | sed \ -e "s/FATAL/"$'\e[31m'"&"$'\e[m'"/" \ -e "s/ERROR/"$'\e[31m'"&"$'\e[m'"/" \ -e "s/WARNING/"$'\e[33m'"&"$'\e[m'"/" \ -e "s/INFO/"$'\e[32m'"&"$'\e[m'"/" \ -e "s/DEBUG/"$'\e[34m'"&"$'\e[m'"/"

Prints like this:

I've written swag to achieve just that.

You can just do

pip install swag

Now you can install all the escape commands as txt files to a given destination via:

swag install -d <colorsdir>

Or even easier via:

swag install

Which will install the colors to ~/.colors.

Either you use them like this:

echo $(cat ~/.colors/blue.txt) This will be blue

Or this way, which I find actually more interesting:

swag print -c red -t underline "I will turn red and be underlined"

Check it out on asciinema!

Inspired by @nachoparker's answer, I have this in my .bashrc:

#### colours source xcol.sh ### tput foreground export tpfn=$'\e[0m' # normal export tpfb=$(tput bold) ## normal colours export tpf0=$(tput setaf 0) # black export tpf1=$(tput setaf 1) # red export tpf2=$(tput setaf 2) # green export tpf3=$(tput setaf 3) # yellow export tpf4=$(tput setaf 4) # blue export tpf5=$(tput setaf 5) # magenta export tpf6=$(tput setaf 6) # cyan export tpf7=$(tput setaf 7) # white # echo "${tpf0}black ${tpf1}red ${tpf2}green ${tpf3}yellow ${tpf4}blue ${tpf5}magenta ${tpf6}cyan ${tpf7}white${tpfn}" ## bold colours export tpf0b="$tpfb$tpf0" # bold black export tpf1b="$tpfb$tpf1" # bold red export tpf2b="$tpfb$tpf2" # bold green export tpf3b="$tpfb$tpf3" # bold yellow export tpf4b="$tpfb$tpf4" # bold blue export tpf5b="$tpfb$tpf5" # bold magenta export tpf6b="$tpfb$tpf6" # bold cyan export tpf7b="$tpfb$tpf7" # bold white # echo "${tpf0b}black ${tpf1b}red ${tpf2b}green ${tpf3b}yellow ${tpf4b}blue ${tpf5b}magenta ${tpf6b}cyan ${tpf7b}white${tpfn}"

The export allows me to use those tpf.. in Bash scripts.

1 2 Next