• grammar
  • 3-bit or 4-bit
  • 8-bit
  • 24-bit
    • RGB colors
    • RGB for both foreground and background
  • code output ( xterm )
    • echo
    • printf
    • tput
  • for PS1
• scripts
  • from rgb
  • from rgba
    • rgba to hex
  • from ansicolor
    • ansi to hex
    • xColorTable | original
    • 256color to hex
  • from hex
    • hex to rgba
    • hex to ansicolor
    • hex to rgb
• tools
  • fidian/ansi
  • bash-colors c()
  • say()
  • RGBcolor
  • terminal-colors
  • colored - python libs
  • topic: ansi-colors
  • color picker
    • iterm2-tab-set
  • other scripts
    • 256 color table
• color names
  • xterm 256 colors chart
  • 256 colors cheat sheet
• man page colors
  • settings
  • using vim as man pager
  • ansicolor issues in man page
• others
  • grep colors
  • generate color randomly
  • decolorize

[!TIP]

• * iMarslo : git config colors

• foreground colors

  ┏━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃ ### ┃ GNOME TERMINAL          ┃ XTERM                   ┃ NON-GUI TTY           ┃
  ┡━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━┩
  │  39 │ «reset this color»      │ «reset this color»      │ «reset this color»    │
  ├─────┼─────────────────────────┼─────────────────────────┼───────────────────────┤
  │  30 │ very dark grey          │ black                   │ black                 │
  │  31 │ dull red                │ red                     │ light red             │
  │  32 │ dull green              │ light green             │ light green           │
  │  33 │ dull yellow             │ yellow                  │ yellow                │
  │  34 │ greyish blue            │ dark blue               │ sky blue              │
  │  35 │ dull purple             │ purple                  │ purple                │
  │  36 │ teal                    │ cyan                    │ cyan                  │
  │  37 │ light grey              │ light grey              │ light grey            │
  ├─────┼─────────────────────────┼─────────────────────────┼───────────────────────┤
  │  90 │ dark grey               │ dull grey               │ dull grey             │
  │  91 │ red                     │ bright red              │ bright red            │
  │  92 │ lime green              │ bright green            │ bright green          │
  │  93 │ yellow                  │ bright yellow           │ pure yellow           │
  │  94 │ light greyish blue      │ dull blue               │ deep blue             │
  │  95 │ light purple            │ magenta                 │ magenta               │
  │  96 │ cyan                    │ bright cyan             │ bright cyan           │
  │  97 │ off white               │ white                   │ white                 │
  ├─────┴──────┬──────────────────┴─────────────────────────┴───────────────────────┤
  │ 38;2;ʀ;ɢ;ʙ │ replace ʀ, ɢ, and ʙ with RGB values from 0 to 255                  │
  │            │   for closest supported color (non-GUI TTY has only 16 colors!)    │
  │ 38;5;ɴ     │ replace ɴ with value from 256-color chart below                    │
  │            │   for closest supported color (non-GUI TTY has only 16 colors!)    │
  └────────────┴────────────────────────────────────────────────────────────────────┘
  

• background colors

  ┏━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃ ### ┃ GNOME TERMINAL          ┃ XTERM                   ┃ NON-GUI TTY           ┃
  ┡━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━┩
  │  49 │ «reset this color»      │ «reset this color»      │ «reset this color»    │
  ├─────┼─────────────────────────┼─────────────────────────┼───────────────────────┤
  │  40 │ very dark grey          │ black                   │ black                 │
  │  41 │ dull red                │ red                     │ light red             │
  │  42 │ dull green              │ light green             │ light green           │
  │  43 │ dull yellow             │ yellow                  │ yellow                │
  │  44 │ greyish blue            │ dark blue               │ sky blue              │
  │  45 │ dull purple             │ purple                  │ purple                │
  │  46 │ teal                    │ cyan                    │ cyan                  │
  │  47 │ light grey              │ light grey              │ light grey            │
  ├─────┼─────────────────────────┼─────────────────────────┼╶╴╶╴╶╴╶╴╶╴╶╴╶╴╶╴╶╴╶╴╶╴╶┤
  │ 100 │ dark grey               │ dull grey               │ black                 │
  │ 101 │ red                     │ bright red              │ light red             │
  │ 102 │ lime green              │ bright green            │ light green           │
  │ 103 │ yellow                  │ bright yellow           │ yellow                │
  │ 104 │ light greyish blue      │ dull blue               │ sky blue              │
  │ 105 │ light purple            │ magenta                 │ purple                │
  │ 106 │ cyan                    │ bright cyan             │ cyan                  │
  │ 107 │ off white               │ white                   │ light grey            │
  ├─────┴──────┬──────────────────┴─────────────────────────┴───────────────────────┤
  │ 48;2;ʀ;ɢ;ʙ │ replace ʀ, ɢ, and ʙ with RGB values from 0 to 255                  │
  │            │   for closest supported color (non-GUI TTY has only 8 colors!)     │
  │ 48;5;ɴ     │ replace ɴ with value from 256-color chart below                    │
  │            │   for closest supported color (non-GUI TTY has only 8 colors!)     │
  └────────────┴────────────────────────────────────────────────────────────────────┘
  

• text styling

  ┏━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃ ### ┃ GNOME TERMINAL          ┃ XTERM                   ┃ NON-GUI TTY           ┃
  ┡━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━┩
  │     │ «reset style+colors»    │ «reset style+colors»    │ «reset style+colors»  │
  │   0 │ «reset style+colors»    │ «reset style+colors»    │ «reset style+colors»  │
  ├─────┼─────────────────────────┼─────────────────────────┼───────────────────────┤
  │   1 │ +bold, +brighter color  │ +bold, +brighter color  │ +brighter color,      │
  │     │                         │                         │   -forced grey        │
  │   2 │ +fainter color          │ +fainter color          │ +forced grey          │
  │   3 │ +italic                 │ +italic                 │ +forced green         │
  │     │                         │                         │   ● overrides 2 and 4 │
  │   4 │ +underline              │ +underline              │ +forced cyan          │
  │     │                         │                         │   ● overrides 2       │
  │   5 │ «no effect»             │ +blink                  │ «no effect»           │
  │   7 │ +invert colors          │ +invert colors          │ +invert colors        │
  │   8 │ +invisible              │ +invisible              │ «no effect»           │
  │     │                         │   ● underline appears   │                       │
  │   9 │ +strikethrough          │ +strikethrough          │ «no effect»           │
  ├─────┼─────────────────────────┤                         ├───────────────────────┤
  │  21 │ -bold, -brighter color, │ +double underline       │ -brighter color,      │
  │     │   -fainter color        ├─────────────────────────┤   -forced grey        │
  │  22 │ -bold, -brighter color, │ -bold, -brighter color, │ -brighter color,      │
  │     │   -fainter color        │   -fainter color        │   -forced grey        │
  │  23 │ -italic                 │ -italic                 │ -forced green         │
  │  24 │ -underline              │ -underline,             │ -forced cyan          │
  │     │                         │   -double underline     │                       │
  │  25 │ «no effect»             │ -blink                  │ «no effect»           │
  │  27 │ -invert colors          │ -invert colors          │ -invert colors        │
  │  28 │ -invisible              │ -invisible              │ «no effect»           │
  │  29 │ -strikethrough          │ -strikethrough          │ «no effect»           │
  └─────┴─────────────────────────┴─────────────────────────┴───────────────────────┘
  

• Font Effects

  ┏━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃   Code  ┃            Effect            ┃                            Note                                        ┃
  ┡━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │    0    │ Reset / Normal               │ all attributes off                                                     │
  │    1    │ Bold or increased intensity  │                                                                        │
  │    2    │ Faint (decreased intensity)  │ Not widely supported.                                                  │
  │    3    │ Italic                       │ Not widely supported. Sometimes treated as inverse.                    │
  │    4    │ Underline                    │                                                                        │
  │    5    │ Slow Blink                   │ less than 150 per minute                                               │
  │    6    │ Rapid Blink                  │ MS-DOS ANSI.SYS; 150+ per minute; not widely supported                 │
  │    7    │ [[reverse video]]            │ swap foreground and background colors                                  │
  │    8    │ Conceal                      │ Not widely supported.                                                  │
  │    9    │ Crossed-out                  │ Characters legible, but marked for deletion. Not widely supported.     │
  │    10   │ Primary(default) font        │                                                                        │
  │  11–19  │ Alternate font               │ Select alternate font n-10                                             │
  │    20   │ Fraktur                      │ hardly ever supported                                                  │
  │    21   │ Bold off or Double Underline │ Bold off not widely supported; double underline hardly ever supported. │
  │    22   │ Normal color or intensity    │ Neither bold nor faint                                                 │
  │    23   │ Not italic, not Fraktur      │                                                                        │
  │    24   │ Underline off                │ Not singly or doubly underlined                                        │
  │    25   │ Blink off                    │                                                                        │
  │    27   │ Inverse off                  │                                                                        │
  │    28   │ Reveal                       │ conceal off                                                            │
  │    29   │ Not crossed out              │                                                                        │
  │  30–37  │ Set foreground color         │ See color table below                                                  │
  │    38   │ Set foreground color         │ Next arguments are 5;<n> or 2;<r>;<g>;<b>, see below                   │
  │    39   │ Default foreground color     │ implementation defined (according to standard)                         │
  │  40–47  │ Set background color         │ See color table below                                                  │
  │    48   │ Set background color         │ Next arguments are 5;<n> or 2;<r>;<g>;<b>, see below                   │
  │    49   │ Default background color     │ implementation defined (according to standard)                         │
  │    51   │ Framed                       │                                                                        │
  │    52   │ Encircled                    │                                                                        │
  │    53   │ Overlined                    │                                                                        │
  │    54   │ Not framed or encircled      │                                                                        │
  │    55   │ Not overlined                │                                                                        │
  │    60   │ ideogram underline           │ hardly ever supported                                                  │
  │    61   │ ideogram double underline    │ hardly ever supported                                                  │
  │    62   │ ideogram overline            │ hardly ever supported                                                  │
  │    63   │ ideogram double overline     │ hardly ever supported                                                  │
  │    64   │ ideogram stress marking      │ hardly ever supported                                                  │
  │    65   │ ideogram attributes off      │ reset the effects of all of 60-64                                      │
  │  90–97  │ Set bright foreground color  │ aixterm (not in standard)                                              │
  │ 100–107 │ Set bright background color  │                                                                        │
  └─────────┴──────────────────────────────┴────────────────────────────────────────────────────────────────────────┘
  

quick show colors sample:

  $ for i in {0..255}; do echo -e "\033[38;5;${i}m $i \033[0m"; done

grammar

[!NOTE|label:references:]

• termstandard/colors
• ANSI escape code
• * iMarslo: icolor.sh
• * iMarslo: marslo/color-utils.sh
• * fromhex() & tohex()

• escape sequence

• normal & bright

  $ for (( i = 30; i < 38; i++ )); do
    echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)";
  done
  

  

3-bit or 4-bit

[!TIP|label:format:]

ESC[3⟨n⟩m      # foreground
ESC[4⟨n⟩m      # background

$ echo -e "\033[31mHello World\033[0m"

#               ++ foreground - 31 - red
#               ++ ++ background - 43 - yellow
$ echo -e "\033[31;43mHello World\033[0m"

8-bit

[!TIP|label:format:]

       + flag `5` is necessary, `38;5` means it's a 8-bit ANSI SGR ( Select Graphic Rendition )
       v
ESC[38;5;⟨n⟩m  # foreground
ESC[48;5;⟨n⟩m  # background

• ⟨n⟩:
  • 0 - 7: standard colors (as in ESC [ 30–37 m)
  • 8 - 15: high intensity colors (as in ESC [ 90–97 m)
  • 16 - 231: 6 × 6 × 6 cube (216 colors): 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5)
  • 232 - 255: grayscale from dark to light in 24 steps

#             the 219th color
#                  v
#               +------+
$ echo -e "\033[38;5;219mHello\033[0m"

#               + 3: italic == `\033[3m`
#               | + 4: underline == `\033[4m`
#               | |    + the 219th color
#               | | +------+
$ echo -e "\033[3;4;38;5;219mHello\033[0m"
# == equal to ==
$ echo -e "\033[3m\033[4m\033[38;5;219mHello\033[0m"

24-bit

[!TIP|label:format:]

       + flag `2` is necessary, `38;2` means it's a 24-bit ANSI SGR ( Select Graphic Rendition )
       v
ESC[38;2;⟨r⟩;⟨g⟩;⟨b⟩m   # foreground
ESC[48;2;⟨r⟩;⟨g⟩;⟨b⟩m   # background

$ for i in {1..9} 21; do echo -e "\033[$i;38;2;128;255;128mfont-style: $i\033[0m"; done
font-style: 1         # bold or increased intensity
font-style: 2         # faint, decreased intensity, or dim
font-style: 3         # italic
font-style: 4         # underline
font-style: 5         # slow blink
font-style: 6         # -- rapid blink -- not widely supported
font-style: 7         # reverse or invert
font-style: 8         # conceal or hide or invisible
font-style: 9         # strike
font-style: 21        # doubly underlined; or: not bold

RGB colors

[!NOTE|label:references:]

• * iMarslo : git » config » colors
• * iMarslo: math » number conversion » to decimal

[!NOTE|label:references:]

• How to have multiple colors in a Windows batch file?
• How to get the RGB values of a 256-color palette terminal color
• kenny-kvibe/ansi_colors.sh
• * iMarslo: icolor.sh

echo

# #689d6a
#                       ╭─ R(decimal)         : 104 : `$ echo -n "obase=10;ibase=16; 68" | bc`
#                       ╷   ╭─ G(decimal)     : 157 : `$ echo -n "obase=10;ibase=16; 9D" | bc`
#                       ╷   ╷   ╭─ B(decimal) : 106 : `$ echo -n "obase=10;ibase=16; 6A" | bc`
#                      --- --- ---
$ echo -e '\x1b[3;38;2;104;157;106m hello world \x1b[m'
#               -      --- --- ---
#               ╵      68  9D  6A
#               ╰─ SGR (Select Graphic Rendition) parameters ( https://en.wikipedia.org/wiki/ANSI_escape_code ):
#                      0 reset/normal ; 1 bold      ; 2 dim/faint ;
#                      3 italic       ; 4 underline ; 5 blink     ;
#                      7 reverse      ; 8 hidden

# or
$ echo $(git config --get-color "" "#689d6a italic") color test $(git config --get-color "" reset) | command cat -A
^[[3;38;2;104;157;106m color test ^[[m$
#         --- --- ---
#         68  9D  6A   : hex
#         104 157 106  : decimal

printf

$ hextorgb '#6A5ACD'
106 90 205

#                        6A  5A CD
#                        --- -- ---
$ printf "%b" '\x1b[38;2;106;90;205m-hello world-\x1b[0m'

# omit %b
$ printf '\x1b[38;2;106;90;205m-hello world-\x1b[0m'

RGB for both foreground and background

# 38;2;R;G;B
# 48;2;R;G;B
$ echo -e "\033[38;2;255;100;100mhello world\033[0m"
$ echo -e "\033[48;2;255;100;100mhello world\033[0m"

#                 38;2;R;G;B     48;2;R;G;B
#               v------------v v-------------v
$ echo -e "\033[38;2;155;106;0;48;2;255;100;100mhello world\033[0m"

# https://web.archive.org/web/20131009193526/http://bitmote.com/index.php?post/2012/11/19/Using-ANSI-Color-Codes-to-Colorize-Your-Bash-Prompt-on-Linux
$ echo -e "testing \033[38;5;196;48;5;21mCOLOR1\033[38;5;208;48;5;159mCOLOR2\033[m"

code output ( xterm )

echo

#                 0 - 255
#                    v
$ echo -e "\033[38;5;3mhello world\033[0m"

# for all
$ for i in {0..255}; do echo -e "\033[38;5;${i}m $i \033[0m"; done

printf

#         ╭─ \b      Write a <backspace> character.
#         ╷            0 - 255
#         v               v
$ printf "%-10b" "\e[38;5;3m**text**\e[0m"

# or ignore `%b`
$ printf "\e[38;5;3m**text**\e[0m"

tput

[!NOTE|label:references::]

• * iMarslo: linux/nutshell
• * 256 colors
• Colours and Cursor Movement With tput
• tput: Portable Terminal Control
• use cases:
  • * iMarslo: fman()
  • * iMarslo: PS1

#          0 - 255                       reset
#            v                             v
$ tput setaf 30; echo "hello world"; tput sgr0
# or
$ echo -e "$(tput setaf 30)hello world$(tput sgr0)"

# more
$ tput setaf 30 | command cat -A
^[[38;5;30m

• background color

  $ echo $(tput setab 214)256 $(tput setab 202)colors
  

• to show color table

  $ for c in {0..255}; do tput setaf $c; tput setaf $c | command cat -v; echo =$c; done
  

• show current terminal support

  $ tput colors
  256
  

for PS1

[!NOTE|label:references:]

• Using ANSI Color Codes to Colorize Your Bash Prompt on Linux

# additioanl \[ and \] for PS1 only
#  ^                     ^
#  --                    --
R='\[\e[38;2;255;100;100m\]'
G='\[\e[38;2;100;255;100m\]'
B='\[\e[38;2;100;100;255m\]'
W='\[\e[0m\]'
PS1="[$R\u$W@$B\h$W:$G\w$W]\$ "

scripts

from rgb

[!NOTE|label:references:]

• rgbToAnsi256(r, g, b)

• rgb to hex

  # @author : Anthony Bourdain | https://stackoverflow.com/a/55073732/2940319
  # @usage  :
  # - `rgbtohex 17 0 26` ==> 1001A
  # - `rgbtohex -h 17 0 26` ==> #1001A
  function rgbtohex () {
    addleadingzero () { awk '{if(length($0)<2){printf "0";} print $0;}';}
    if [[ ${1} == "-h" ]]; then
      r=${2}; g=${3}; b=${4};h='#';
    else
      r=${1}; g=${2}; b=${3};h='';
    fi
    r=$(echo "obase=16; ${r}" | bc | addleadingzero)
    g=$(echo "obase=16; ${g}" | bc | addleadingzero)
    b=$(echo "obase=16; ${b}" | bc | addleadingzero)
    echo "${h}${r}${g}${b}"
  }
  

• rgb to 256colors

  # @author : Anthony Bourdain | https://stackoverflow.com/a/55073732/2940319
  # @usage  :
  # - `rgbto256 0 95, 135` ==> 22
  function rgbto256 () {
    echo "define trunc(x){auto os;os=scale;scale=0;x/=1;scale=os;return x;};" \
      "16 + 36 * trunc(${1}/51) + 6 * trunc(${2}/51) +" \
      " trunc(${3}/51)" | bc
    # XTerm Color Number = 16 + 36 * R + 6 * G + B | 0 <= R,G,B <= 5
  }
  

• rgb to hsv

from rgba

[!NOTE|label:references:]

• Convert RGBA color to RGB
• Convert RGBA to RGB taking background into consideration [duplicate]
• How to convert RGBA to Hex color code using javascript
• Convert RGB to RGBA over white
• Convert RGBA to RGB in Python
• Alpha compositing
• tools
  • Converter for rgba/hsla-colors into hexadecimal-value

rgba to hex

#!/usr/bin/env bash
# shellcheck source=/dev/null disable=SC2155
#=============================================================================
#     FileName : rgba2hex
#       Author : marslo.jiao@gmail.com
#      Created : 2025-04-02 22:02:37
#   LastChange : 2025-04-03 23:48:01
#=============================================================================

set -euo pipefail
source "${HOME}"/.marslo/bin/bash-color.sh
source "${HOME}"/.marslo/bin/rgba2hex-help

declare alpha=''
declare colorCode=''
# default background - #FFFFFF ( white )
declare bgR=255 bgG=255 bgB=255

function die() {
  echo -e "$(c Rsi)ERROR$(c) : $*. try $(c Gi)-h$(c)/$(c Gi)--help$(c). exit ..." >&2;
  exit 2;
}

# generate the hex color code: $1 - R, $2 - G, $3 - B
function toHex() { printf "#%02X%02X%02X" "$1" "$2" "$3"; }

function parseArguments() {
  while [[ $# -gt 0 ]]; do
    case "$1" in
      -a | --alpha      ) if ! awk -v a="$2" 'BEGIN{exit (a >= 0 && a <= 1) ? 0 : 1}' ; then
                            die "$(c Gi)--alpha$(c) value must be between $(c Bi)0.00$(c) and $(c Bi)1.00$(c). $(c Mi)'${2}'$(c) is invalid" >&2
                          fi
                          alpha="$2"
                          shift 2
                          ;;
      -b | --background ) local inputBG="$2"
                          local bgRGB
                          bgRGB=$(parseBackground "$inputBG")
                          IFS=' ' read -r bgR bgG bgB <<< "${bgRGB}"
                          shift 2
                          ;;
      -h | --help       ) showHelp; exit 0 ;;
      *                 ) if [[ -z "${colorCode}" ]]; then
                            colorCode="$1"
                            shift
                          else
                            die 'multiple color input arguments detected'
                          fi
                          ;;
    esac
  done
}

# background color analysis
function parseBackground() {
  local inputBG="$1"
  local r g b

  # numerical format checking
  if [[ "${inputBG}" =~ ^[0-9]+$ ]]; then
    r="${inputBG}"
    g="${inputBG}"
    b="${inputBG}"
  elif [[ "${inputBG}" =~ ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ ]]; then
    local hex=${inputBG#\#}
    if [ "${#hex}" -eq 3 ]; then
      hex="${hex:0:1}${hex:0:1}${hex:1:1}${hex:1:1}${hex:2:1}${hex:2:1}"
    fi
    r=$((16#${hex:0:2}))
    g=$((16#${hex:2:2}))
    b=$((16#${hex:4:2}))
  elif [[ "${inputBG}" =~ ^[0-9]+,[0-9]+,[0-9]+$ ]]; then
    IFS=',' read -r r g b <<< "${inputBG}"
  else
    die "invalid background format: ${inputBG}"
  fi

  verifyRange "${r}" "Background R" "${r}"
  verifyRange "${g}" "Background G" "${g}"
  verifyRange "${b}" "Background B" "${b}"

  echo "${r} ${g} ${b}"
}

function parseColor() {
  local input="$1"
  local trimmed=$(echo "${input}" | sed -E '
             s/^[^(]*\(([^)]+)\).*$/\1/;             # extract content within parentheses
             s/^[[:space:]]+//;                      # remove leading spaces
             s/[[:space:]]+$//;                      # remove trailing spaces
             s/[[:space:]]*,[[:space:]]*/,/g;        # remove spaces around commas (,)
             s/,+/,/g;                               # combine multiple/consecutive commas
             s/^,//; s/,$//;                         # remove leading/trailing commas
         ')

  IFS=',' read -ra parts <<< "${trimmed}"
  local pCount=${#parts[@]}

  # RGBA
  if [[ "$(awk -F ',' '{print NF-1}' <<< "${trimmed}")" -eq 3 ]];then
    if (( pCount != 4 )); then echo "INVALID_RGBA_FORMAT|4" >&2; return 1; fi

    # verify alpha value is numeric
    local alpha="${parts[3]}"
    if [[ ! "${alpha}" =~ ^-?[0-9]*\.?[0-9]+$ ]]; then echo "INVALID_ALPHA|${alpha}" >&2; return 1; fi

    # verify alpha value is in range [0.0-1.0]
    if awk -v a="${alpha}" 'BEGIN { if (a < 0 || a > 1) exit 1 }'; then
      :
    else
      echo "ALPHA_OUT_OF_RANGE|${alpha}" >&2
      return 1
    fi

  # RGB
  elif [[ "$(awk -F ',' '{print NF-1}' <<< "${trimmed}")" -eq 2 ]];then
    if (( pCount != 3 )); then echo "INVALID_RGB_FORMAT|3" >&2; return 1; fi
  fi

  # cleaned - remove non-numeric characters and trim spaces
  echo "${trimmed}" | sed -E 's/[^0-9.,-]//g; s/^[[:space:]]+//; s/[[:space:]]+$//;'
  return 0
}

# numeric processing (return decimal)
function formatNumber() {
  awk -v n="$1" 'BEGIN {
    n = (n == "" ? 0 : n)
    if (n ~ /\..*5$/) { printf "%.0f", n + 0.5 }
    else { printf "%.0f", n }
  }'
}

# verify the range of RGB ( 0 - 255 )
function verifyRange() {
  local value="$1"
  local name="$2"
  local original="$3"
  if [[ "${value}" -lt 0 || "${value}" -gt 255 ]]; then
    die "invalid ${name} value '${original}' (0-255)"
  fi
}

# verify alpha value range ( 0.00 ~ 1.00 )
function clampAlpha() {
  local alphaInput=$(parseColor "$1") || exit 2

  local numericValue
  numericValue=$(awk -v a="${alphaInput}" 'BEGIN { print a + 0 }')

  # clamp to range [0.0, 1.0]
  if (( $(echo "${numericValue} < 0.0" | bc -l) )); then
      numericValue=0.0
  elif (( $(echo "${numericValue} > 1.0" | bc -l) )); then
      numericValue=1.0
  fi

  # format to 2 decimal places
  printf "%.2f" "${numericValue}"
}

# mix channel: $1 - color, $2 - alpha, $3 - background
function mixChannel() {
  awk -v c="$1" -v a="$2" -v bg="$3" 'BEGIN {
    result = c * a + bg * (1 - a)
    printf "%d\n", (result < 0 ? 0 : (result > 255 ? 255 : result))
  }'
}

# show output with alpha mixing
function showOutput() {
  local inputA="$1"
  local r="$2" g="$3" b="$4"
  local bgR="$5" bgG="$6" bgB="$7"

  local a=$(clampAlpha "${inputA}")
  local mixedR=$(mixChannel "${r}" "${a}" "${bgR}")
  local mixedG=$(mixChannel "${g}" "${a}" "${bgG}")
  local mixedB=$(mixChannel "${b}" "${a}" "${bgB}")

  local hexCode=$(toHex "${mixedR}" "${mixedG}" "${mixedB}")
  local rgbDisplay="rgba(${r}, ${g}, ${b}, $(printf "%.2f" "${a}"))"
  local ansiStart="\033[38;2;${mixedR};${mixedG};${mixedB}m"
  local ansiReset="\033[0m"

  echo -e "${ansiStart}${rgbDisplay}${ansiReset} -> ${ansiStart}${hexCode}${ansiReset}"
}

function main() {
  # read input
  parseArguments "$@"
  [ -z "${colorCode}" ] && { die 'missing color input'; }

  # capture both errTag and errValue, to avoid `exit 1` cannot stop in subshell
  local parsedColor
  if ! parsedColor=$(parseColor "${colorCode}" 2>&1); then
    IFS='|' read -r errTag errValue <<< "$parsedColor"
    case "${errTag}" in
      INVALID_RGBA_FORMAT  ) die "invalid RGBA format: expected ${errValue:-4} components $(c Mi)rgba(R,G,B,A)$(c)" ;;
      INVALID_RGB_FORMAT   ) die "invalid rgb format: Expected ${errValue:-3} components $(c Mi)rgb(R,G,B)$(c)" ;;
      INVALID_ALPHA        ) die "invalid $(c ui)alpha$(c) value $(c Mi)'${errValue}'$(c) in R,G,B,$(c Mi)A$(c)" ;;
      ALPHA_OUT_OF_RANGE   ) die "invalid $(c ui)alpha$(c) value $(c Mi)${errValue}$(c), must be between $(c Bi)0.00$(c) and $(c Bi)1.00$(c)" ;;
      INVALID_COLOR_FORMAT ) die "Unrecognized color format" ;;
      *                    ) die "Unknown error in color parsing" ;;
    esac
  fi
  IFS=',' read -ra vals <<< "${parsedColor}"

  # input verify
  if [[ ${#vals[@]} -lt 3 || ${#vals[@]} -gt 4 ]]; then
    die "expected 3 or 4 values, got $(c Mi)${#vals[@]}$(c)"
  fi

  # format numbers
  local orgR="$(formatNumber "${vals[0]}")"
  local orgG="$(formatNumber "${vals[1]}")"
  local orgB="$(formatNumber "${vals[2]}")"

  verifyRange "${orgR}" "R" "${vals[0]}"
  verifyRange "${orgG}" "G" "${vals[1]}"
  verifyRange "${orgB}" "B" "${vals[2]}"

  # alpha
  if [[ ${#vals[@]} -eq 3 && -z "${alpha}" ]]; then
    for a in $(seq 0.0 0.1 1.0); do
      showOutput "${a}" \
                 "${orgR}" "${orgG}" "${orgB}" \
                 "${bgR}" "${bgG}" "${bgB}"
    done
  else
    local finalAlpha="${alpha:-${vals[3]:-1.0}}"
    showOutput "${finalAlpha}" \
               "${orgR}" "${orgG}" "${orgB}" \
               "${bgR}" "${bgG}" "${bgB}"
  fi
}

main "$@"

# vim:tabstop=2:softtabstop=2:shiftwidth=2:expandtab:filetype=sh

#!/usr/bin/env bash
# shellcheck source=/dev/null

source "${HOME}"/.marslo/bin/bash-color.sh

# shellcheck disable=SC2155
declare usage="""
NAME
  $(c Ys)rgba2hex$(c) - RGBA to HEX Converter with ANSI Color Preview

USAGE
  $(c Ys)rgba2hex$(c) $(c Gis)[OPTIONS]$(c) $(c Ms)'COLOR_INPUT'$(c)

OPTIONS
  $(c Gis)-a$(c), $(c Gis)--alpha$(c)       override alpha value ( $(c Wdi)0.00$(c)-$(c Wdi)1.00$(c) )
  $(c Gis)-b$(c), $(c Gis)--background$(c)  set background color ( $(c Wdi)0-255$(c)/$(c Wdi)R,G,B$(c)/$(c Wdi)#RGB/#RRGGBB$(c), default: $(c Wi)255,255,255$(c) )
  $(c Gis)-h$(c), $(c Gis)--help$(c)        show this help message

COLOR INPUT FORMATS
  • $(c Msi)'rgba(R, G, B, A)'$(c)
  • $(c Msi)'R, G, B, A'$(c)
  • $(c Msi)'rgb(R, G, B)'$(c)  $(c Wdi)generates alpha from 0.0 to 1.0 sequentially$(c)
  • $(c Msi)'R, G, B'$(c)       $(c Wdi)generates alpha from 0.0 to 1.0 sequentially$(c)

EXAMPLES
  $(c iu)WITH$(c) $(c Bs)ALPHA$(c) $(c i)- SHOW SINGLE HEX COLOR CODE$(c)
    $(c Wi)# show the HEX color code with given RGBA.$(c)
    \$ $(c Yis)rgba2hex$(c) $(c Ms)'rgba(255, 200.5, 100, 0.8)'$(c)
    \033[38;2;255;211;131mrgba(255, 200.5, 100, 0.80)\033[0m -> \033[38;2;255;211;131m#FFD383\033[0m

    $(c Wi)# show the HEX color code with alpha mixed background: $(c)\033[48;2;128;0;128m#800080\033[0m
    \$ $(c Yis)rgba2hex$(c) $(c Ms)'204 , 108 , 204 , 0.8'$(c) $(c Gis)-b 128,0,128$(c)
    \033[38;2;188;86;188mrgba(204, 108, 204, 0.80)\033[0m -> \033[38;2;188;86;188m#BC56BC\033[0m

  $(c iu)WITHOUT$(c) $(c Bs)ALPHA$(c) $(c i)- SHOW WITH ALPHA FROM 0.1 TO 1.0 SEQUENTIALLY$(c)
    $(c Wi)# show HEX color codes with default background: $(c) \033[48;2;255;255;255;3m#FFFFFF\033[0m
    \$ $(c Yis)rgba2hex$(c) $(c Ms)'250, 240, 170'$(c) == \$ $(c Yis)rgba2hex$(c) $(c Ms)'rgb(250, 240, 170)'$(c) $(c Gis)--background 255$(c)
    \033[38;2;255;255;255mrgba(250, 240, 170, 0.00)\033[0m -> \033[38;2;255;255;255m#FFFFFF\033[0m
    \033[38;2;254;253;246mrgba(250, 240, 170, 0.10)\033[0m -> \033[38;2;254;253;246m#FEFDF6\033[0m
    \033[38;2;254;252;238mrgba(250, 240, 170, 0.20)\033[0m -> \033[38;2;254;252;238m#FEFCEE\033[0m
    \033[38;2;253;250;229mrgba(250, 240, 170, 0.30)\033[0m -> \033[38;2;253;250;229m#FDFAE5\033[0m
    \033[38;2;253;249;221mrgba(250, 240, 170, 0.40)\033[0m -> \033[38;2;253;249;221m#FDF9DD\033[0m
    \033[38;2;252;247;212mrgba(250, 240, 170, 0.50)\033[0m -> \033[38;2;252;247;212m#FCF7D4\033[0m
    \033[38;2;252;246;204mrgba(250, 240, 170, 0.60)\033[0m -> \033[38;2;252;246;204m#FCF6CC\033[0m
    \033[38;2;251;244;195mrgba(250, 240, 170, 0.70)\033[0m -> \033[38;2;251;244;195m#FBF4C3\033[0m
    \033[38;2;251;243;187mrgba(250, 240, 170, 0.80)\033[0m -> \033[38;2;251;243;187m#FBF3BB\033[0m
    \033[38;2;250;241;178mrgba(250, 240, 170, 0.90)\033[0m -> \033[38;2;250;241;178m#FAF1B2\033[0m
    \033[38;2;250;240;170mrgba(250, 240, 170, 1.00)\033[0m -> \033[38;2;250;240;170m#FAF0AA\033[0m

    $(c Wi)# show HEX color codes with given background: $(c) \033[48;2;34;85;102;3m#225566\033[0m
    \$ $(c Yis)rgba2hex$(c) $(c Ms)'250,240,170'$(c) $(c Gis)--background '#256'$(c) == \$ $(c Yis)rgba2hex$(c) $(c Gis)--background '#256'$(c) $(c Ms)'rgb(250,240,170)'$(c)
    \033[38;2;34;85;102mrgba(250, 240, 170, 0.00)\033[0m -> \033[38;2;34;85;102m#225566\033[0m
    \033[38;2;55;100;93mrgba(250, 240, 170, 0.10)\033[0m -> \033[38;2;55;100;93m#37645D\033[0m
    \033[38;2;77;116;102mrgba(250, 240, 170, 0.20)\033[0m -> \033[38;2;77;116;102m#4D7466\033[0m
    \033[38;2;98;131;110mrgba(250, 240, 170, 0.30)\033[0m -> \033[38;2;98;131;110m#62836E\033[0m
    \033[38;2;120;147;119mrgba(250, 240, 170, 0.40)\033[0m -> \033[38;2;120;147;119m#789377\033[0m
    \033[38;2;142;162;127mrgba(250, 240, 170, 0.50)\033[0m -> \033[38;2;142;162;127m#8EA27F\033[0m
    \033[38;2;163;178;136mrgba(250, 240, 170, 0.60)\033[0m -> \033[38;2;163;178;136m#A3B288\033[0m
    \033[38;2;185;193;144mrgba(250, 240, 170, 0.70)\033[0m -> \033[38;2;185;193;144m#B9C190\033[0m
    \033[38;2;206;209;153mrgba(250, 240, 170, 0.80)\033[0m -> \033[38;2;206;209;153m#CED199\033[0m
    \033[38;2;228;224;161mrgba(250, 240, 170, 0.90)\033[0m -> \033[38;2;228;224;161m#E4E0A1\033[0m
    \033[38;2;250;240;170mrgba(250, 240, 170, 1.00)\033[0m -> \033[38;2;250;240;170m#FAF0AA\033[0m

NOTES
  • All color components clamp to [ $(c Gi)0$(c) ~ $(c Gi)255$(c) ]
  • Alpha values clamp to [ $(c Gi)0.00$(c) ~ $(c Gi)1.00$(c) ]
  • RGB values are rounded to nearest integer
  • ANSI preview requires truecolor terminal support
"""

function showHelp() { echo -e "$usage"; }

• to rgb

  [!NOTE|label:references:]

  alpha     = 1 - RGBA.alpha;
  RGB.red   = Math.round((RGBA.alpha * (RGBA.red / 255) + (alpha * (bg.red / 255))) * 255);
  RGB.green = Math.round((RGBA.alpha * (RGBA.green / 255) + (alpha * (bg.green / 255))) * 255);
  RGB.blue  = Math.round((RGBA.alpha * (RGBA.blue / 255) + (alpha * (bg.blue / 255))) * 255);
  

from ansicolor

ansi to hex

[!TIP|label:references:] the enhancement xColorTable

#!/usr/bin/env bash
# shellcheck source=/dev/null
#=============================================================================
#     FileName : ansi2hex
#       Author : marslo.jiao@gmail.com
#      Created : 2025-03-24 14:30:33
#   LastChange : 2025-03-31 11:22:01
#=============================================================================

source "${HOME}"/.marslo/bin/bash-color.sh

declare isPreview=false
declare noColor=false
declare showHelp=false
declare style=''
declare alpha=''
declare -a indices=()
# shellcheck disable=SC2155
declare help="""
NAME
  $(c Ys)ansi2hex$(c) - convert ANSI color index to HEX color code

SYNOPSIS
  $(c Ys)\$ ansi2hex$(c) $(c Gi)<index>...$(c) [$(c Gi)style$(c)] [$(c Gis)--alpha=$(c)$(c Mi)<float>$(c)] [$(c Gis)--no-color$(c)]
  $(c Ys)\$ ansi2hex$(c) $(c Gis)--preview$(c) [$(c Gi)style$(c)] [$(c Gis)--alpha=$(c)$(c Mi)<float>$(c)] [$(c Gis)--no-color$(c)]

ARGUMENTS
  $(c Gi)<index>$(c)              one or more ANSI color indices ($(c Wdi)0$(c) ~ $(c Wdi)255$(c))
  $(c Gi)style$(c)                optional color style: $(c Mi)normal$(c) (default), $(c Mi)dim$(c), $(c Mi)bright$(c), $(c Mi)bold$(c), $(c Mi)light$(c)
  $(c Gis)--alpha=$(c)$(c Mi)<float>$(c)      brightness adjustment factor (overrides style), e.g., $(c Wi)0.65$(c) ($(c Mi)dim$(c)), $(c Wi)1.35$(c) ($(c Mi)bright$(c))
  $(c Gis)--no-color$(c)           disable colorized output
  $(c Gis)--preview$(c)            show all 256 ANSI colors with the specified style and alpha
  $(c Gis)--help$(c), $(c Gis)-h$(c)           show this help message

VALIDATION
  - Each $(c Wd)<index>$(c) must be an integer between 0 and 255.
  - Unknown arguments will result in an error.
  - Multiple indices and options can be combined.

EXAMPLES
  $(c Yis)\$ ansi2hex$(c) $(c Gi)213$(c) $(c Gi)45$(c) $(c Gi)100$(c)
  $(c Yis)\$ ansi2hex$(c) $(c Gi)213$(c) $(c Mi)dim$(c)
  $(c Yis)\$ ansi2hex$(c) $(c Gi)213$(c) $(c Gi)45$(c) $(c Gi)--alpha=$(c)$(c Mi)1.15$(c)
  $(c Yis)\$ ansi2hex$(c) $(c Gi)--preview$(c) $(c Mi)dim$(c)
  $(c Yis)\$ ansi2hex$(c) $(c Gi)--preview$(c) $(c Gi)--alpha=$(c)$(c Wi)0.85$(c) $(c Gi)--no-color$(c)
"""

function isValidIndex() {
  [[ "$1" =~ ^[0-9]+$ && "$1" -ge 0 && "$1" -le 255 ]]
}

# parse args
while [[ $# -gt 0 ]]; do
  case "$1" in
    --alpha=*                    ) alpha="${1#--alpha=}" ;  shift ;;
    --preview                    ) isPreview=true        ;  shift ;;
    --no-color                   ) noColor=true          ;  shift ;;
    --help|-h                    ) showHelp=true         ;  shift ;;
    dim|bright|bold|light|normal ) style="$1"            ;  shift ;;
    [0-9]*                       ) if isValidIndex "$1"; then
                                     indices+=("$1")
                                   else
                                     echo "Invalid color index: $1" >&2
                                     exit 1
                                   fi
                                   shift
                                   ;;
    *                            ) showUsage             ; exit 0  ;;
  esac
done

# normalize style
case "$style" in
  bright|bold|light ) style="bright" ;;
  dim               ) style="dim"    ;;
  *                 ) style="normal" ;;
esac

# set default alpha if not provided
if [[ -z "$alpha" ]]; then
  case "$style" in
    dim    ) alpha=0.65 ;;
    bright ) alpha=1.35 ;;
    *      ) alpha=1.0  ;;
  esac
fi

# brightness adjustment
function adjust() {
  local val="$1"
  awk -v v="$val" -v a="$alpha" 'BEGIN {
    if (a < 1.0)
      printf "%d", v * a
    else if (a > 1.0)
      printf "%d", v + (255 - v) * (a - 1)
    else
      print v
  }'
}

# convert ansi index to rgb
function ansiToRgb() {
  local idx="$1"
  local r g b

  if (( idx < 16 )); then
    local colors=(
      0 0 0       128 0 0     0 128 0     128 128 0
      0 0 128     128 0 128   0 128 128   192 192 192
      128 128 128 255 0 0     0 255 0     255 255 0
      0 0 255     255 0 255   0 255 255   255 255 255
    )
    r=${colors[idx*3]}
    g=${colors[idx*3+1]}
    b=${colors[idx*3+2]}
  elif (( idx >= 16 && idx <= 231 )); then
    local base=$(( idx - 16 ))
    local r6=$(( base / 36 ))
    local g6=$(( (base % 36) / 6 ))
    local b6=$(( base % 6 ))

    r=$(( r6 == 0 ? 0 : r6 * 40 + 55 ))
    g=$(( g6 == 0 ? 0 : g6 * 40 + 55 ))
    b=$(( b6 == 0 ? 0 : b6 * 40 + 55 ))
  else
    local gray=$(( 8 + (idx - 232) * 10 ))
    r=$gray; g=$gray; b=$gray
  fi

  r=$(adjust "$r")
  g=$(adjust "$g")
  b=$(adjust "$b")

  echo "$r $g $b"
}

# RGB to HEX
function rgbToHex() { printf "#%02X%02X%02X\n" "$1" "$2" "$3"; }

# print function
function printColorInfo() {
  local idx="$1"
  read -r r g b <<< "$(ansiToRgb "$idx")"
  local hex
  hex=$(rgbToHex "$r" "$g" "$b")

  if ${noColor}; then
    printf "%3s => rgba(%3d, %3d, %3d, %.2f) => %s\n" "$idx" "$r" "$g" "$b" "$alpha" "$hex"
  else
    local ansi_color="\033[38;5;${idx}m"
    local truecolor="\033[38;2;${r};${g};${b}m"
    local reset="\033[0m"
    printf "${ansi_color}%3s${reset} => ${truecolor}rgba(%3d, %3d, %3d, %.2f)${reset} => ${truecolor}%s${reset}\n" \
      "$idx" "$r" "$g" "$b" "$alpha" "$hex"
  fi
}

showUsage() { echo -e "${help}"; exit 0; }

[[ "$showHelp" == true ]] && showUsage

if ${isPreview}; then
  for i in {0..255}; do printColorInfo "$i"; done
  exit 0
fi

# if no index provided
if [[ ${#indices[@]} -eq 0 ]]; then showUsage; fi

# loop over indices
for idx in "${indices[@]}"; do printColorInfo "${idx}"; done

# vim: tabstop=2:softtabstop=2:shiftwidth=2:expandtab:filetype=sh:

xColorTable | original

$ xColorTable 30 45 100
30  = rgb(0, 135, 135)   => #008787
45  = rgb(0, 215, 255)   => #00D7FF
100 = rgb(135, 135, 0)   => #878700

256color to hex

tohex(){
  dec=$(($1%256))   ### input must be a number in range 0-255.
  if [ "$dec" -lt "16" ]; then
    bas=$(( dec%16 ))
    mul=128
    [ "$bas" -eq "7" ] && mul=192
    [ "$bas" -eq "8" ] && bas=7
    [ "$bas" -gt "8" ] && mul=255
    a="$((  (bas&1)    *mul ))"
    b="$(( ((bas&2)>>1)*mul ))"
    c="$(( ((bas&4)>>2)*mul ))"
    printf 'dec= %3s basic= #%02x%02x%02x\n' "$dec" "$a" "$b" "$c"
  elif [ "$dec" -gt 15 ] && [ "$dec" -lt 232 ]; then
    b=$(( (dec-16)%6  )); b=$(( b==0?0: b*40 + 55 ))
    g=$(( (dec-16)/6%6)); g=$(( g==0?0: g*40 + 55 ))
    r=$(( (dec-16)/36 )); r=$(( r==0?0: r*40 + 55 ))
    printf 'dec= %3s color= #%02x%02x%02x\n' "$dec" "$r" "$g" "$b"
  else
    gray=$(( (dec-232)*10+8 ))
    printf 'dec= %3s  gray= #%02x%02x%02x\n' "$dec" "$gray" "$gray" "$gray"
  fi
}

for i in $(seq 0 255); do tohex ${i}; done

from hex

hex to rgba

#!/usr/bin/env bash
# shellcheck source=/dev/null disable=SC2155
#=============================================================================
#     FileName : hex2rgba
#       Author : marslo.jiao@gmail.com
#      Created : 2025-04-03 00:21:35
#   LastChange : 2025-04-04 00:07:47
#=============================================================================

set -euo pipefail
source "${HOME}"/.marslo/bin/bash-color.sh

# shellcheck disable=SC2155
declare usage="""
NAME
  $(c Ys)hex2rgba$(c) - HEX to RGBA Converter with ANSI Color Preview

USAGE
  $(c Ys)hex2rgba$(c) $(c Gis)[OPTIONS]$(c) $(c Ms)'HEX_COLOR_CODE'$(c)

OPTIONS
  $(c Gis)-a$(c), $(c Gis)--alpha$(c)       override alpha value ( $(c Wdi)0.00$(c) ~ $(c Wdi)1.00$(c) )
  $(c Gis)-b$(c), $(c Gis)--background$(c)  set background color ( $(c Wdi)#FFFFFF$(c)/$(c Wdi)#FFF$(c) or $(c Wdi)R,G,B$(c), default: $(c Wi)#FFFFFF$(c) )
  $(c Gis)-h$(c), $(c Gis)--help$(c)        show this help message

EXAMPLES
  $(c Wi)# show the RGBA values of alphas from 0.0 to 1.0 sequentially.$(c)
  \$ $(c Yis)hex2rgba$(c) $(c Ms)'#D3869B'$(c)

  $(c Wi)# show the RGBA values with alpha 0.5.$(c)
  \$ $(c Yis)hex2rgba$(c) $(c Ms)'#D3869B'$(c) $(c Gis)--alpha 0.5$(c)

  $(c Wi)# show the RGBA values for alphas from 0.1 to 1.0 sequentially with background color #000000.$(c)
  \$ $(c Yis)hex2rgba$(c) $(c Ms)'#D3869B'$(c) $(c Gis)--background '#000000'$(c)

  $(c Wi)# show the RGBA values with alpha 0.3 with background color red ( #FF0000 ).$(c)
  \$ $(c Yis)hex2rgba$(c) $(c Ms)D3869B$(c) $(c Gis)--background 255,0,0$(c) $(c Gis)--alpha 0.3$(c)

NOTES
  • Alpha values will clamp to [ $(c Gi)0.00$(c) ~ $(c Gi)1.00$(c) ]
  • The hex color code and background color code support both $(c Mi)with$(c) or $(c Mi)without hashtag$(c) ( $(c Wi)'#'$(c) )
  • Using $(c Mi)single quotes$(c) for color code with $(c Wi)'#'$(c) to avoid shell command line break
  • Output includes ANSI color preview (requires truecolor terminal support)
"""

function die() {
  echo -e "$(c Rsi)ERROR$(c) : $*. try $(c Gi)-h$(c)/$(c Gi)--help$(c). exit ..." >&2;
  exit 2;
}

function parseColor() {
  local input="$1"

  # for RGB format: R,G,B
  if [[ "$input" == *,*,* ]]; then
    IFS=',' read -ra parts <<< "$input"
    [[ ${#parts[@]} -ne 3 ]] && die "Invalid RGB format: $input"
    local r=${parts[0]} g=${parts[1]} b=${parts[2]}

    # verify the range of RGB values
    for c in $r $g $b; do
      if [[ ! $c =~ ^[0-9]+$ ]] || (( c < 0 || c > 255 )); then
        die "invalid RGB value: $c"
      fi
    done

    echo "${r} ${g} ${b}"
    return 0
  fi

  # for HEX format
  local hex="${input^^}"
  hex="${hex//#/}"
  local len=${#hex}

  # extend XYZ to XXYYZZ
  if [[ $len -eq 3 ]]; then
    hex="${hex:0:1}${hex:0:1}${hex:1:1}${hex:1:1}${hex:2:1}${hex:2:1}"
    len=6
  fi

  [[ $len -ne 6 ]] && die "invalid color format: ${input}" >&2

  local r="$(( 16#${hex:0:2} ))"
  local g="$(( 16#${hex:2:2} ))"
  local b="$(( 16#${hex:4:2} ))"

  echo "${r} ${g} ${b}"
}

function parseBackground() {
  local bg="$1"
  if ! IFS=' ' read -r bgR bgG bgB <<< "$(parseColor "${bg}")"; then
    exit 1
  fi
}

function getMixedRGB() {
  local fgR=$1
  local fgG=$2
  local fgB=$3
  local alpha=$4
  rMixed=$(echo "scale=0; (${fgR} * ${alpha} + ${bgR} * (1 - ${alpha})) / 1" | bc)
  gMixed=$(echo "scale=0; (${fgG} * ${alpha} + ${bgG} * (1 - ${alpha})) / 1" | bc)
  bMixed=$(echo "scale=0; (${fgB} * ${alpha} + ${bgB} * (1 - ${alpha})) / 1" | bc)
  rMixed=$(( rMixed < 0 ? 0 : ( rMixed > 255 ? 255 : rMixed ) ))
  gMixed=$(( gMixed < 0 ? 0 : ( gMixed > 255 ? 255 : gMixed ) ))
  bMixed=$(( bMixed < 0 ? 0 : ( bMixed > 255 ? 255 : bMixed ) ))
  echo "${rMixed} ${gMixed} ${bMixed}"
}

function rgbToHex() {
  printf "#%02X%02X%02X" "${1}" "${2}" "${3}"
}

function showOutput() {
  local alphaValue=$1
  local precision=$2

  # format alphaValue to 2 decimal places
  local formattedAlpha=$(printf "%.${precision}f" "${alphaValue}")

  # get mixed RGB values
  local rgbMixed=$(getMixedRGB "${r}" "${g}" "${b}" "${alphaValue}")

  # analysis the mixed RGB values with IFS
  IFS=' ' read -r rMixed gMixed bMixed <<< "${rgbMixed}"

  # generate HEX color code
  local hexResult=$(rgbToHex "${rMixed}" "${gMixed}" "${bMixed}")

  # generate ANSI color code
  local ansiMixed="\033[38;2;${rMixed};${gMixed};${bMixed}m"

  # output
  echo -e "${ansiHexOrg}#${hexOrg//#/}\033[0m -> ${ansiMixed}rgba(${r}, ${g}, ${b}, ${formattedAlpha})\033[0m -> ${ansiMixed}${hexResult}\033[0m"
}

main() {
  local hex=''
  local alpha=''
  local background='#FFFFFF'
  local hexOrg=''

  while [[ $# -gt 0 ]]; do
    case "$1" in
        -a | --alpha      ) alpha="$2"            ; shift 2 ;;
        -b | --background ) background="${2//#/}" ; shift 2 ;;
        -h | --help       ) echo -e "${usage}"    ; exit 0  ;;
        *                 ) if [[ -z "$hex" ]]; then
                              hexOrg="$1"
                              hex="${1//#/}"
                            else
                              echo "ERROR: Unexpected argument: $1" >&2
                              exit 1
                            fi
                            shift
                        ;;
    esac
  done

  if ! IFS=' ' read -r r g b <<< "$(parseColor "${hex}")"; then
    exit 1
  fi

  if [[ -n "${background}" ]]; then
    parseBackground "${background}"
  else
    bgR=255
    bgG=255
    bgB=255
  fi

  local ansiHexOrg="\033[38;2;${r};${g};${b}m"

  if [[ -n "${alpha}" ]]; then
    if ! [[ "${alpha}" =~ ^[0]?\.?[0-9]+$ ]] || (( $(echo "$alpha < 0.0 || $alpha > 1.0" | bc -l) )); then
      echo "Invalid alpha value: $alpha" >&2
      exit 1
    fi
    showOutput "${alpha}" 2
  else
    for alpha in $(seq 0 0.1 1.0); do
      showOutput "${alpha}" 1
    done
  fi
}

main "$@"

# vim:tabstop=2:softtabstop=2:shiftwidth=2:expandtab:filetype=sh:

hex to ansicolor

fromhex(){
  hex=${1#"#"}
  r=$(printf '0x%0.2s' "$hex")
  g=$(printf '0x%0.2s' ${hex#??})
  b=$(printf '0x%0.2s' ${hex#????})
  printf '%03d' "$(( (r<75?0:(r-35)/40)*6*6 +
                     (g<75?0:(g-35)/40)*6   +
                     (b<75?0:(b-35)/40)     + 16 ))"
}

# verify
$ xColorTable 30
30  = rgb(0, 135, 135)   => #008787

$ fromhex 008787
030
$ fromhex 008766
029
$ fromhex 008788
030

hex to rgb

# @author : Anthony Bourdain | https://stackoverflow.com/a/55073732/2940319
# @usage  :
# - `hexttorgb "11001A" ==> 17 0 26
# - `hexttorgb "#11001A" ==> 17 0 26
function hextorgb () {
  hexinput=$(echo "${1}" | tr '[:lower:]' '[:upper:]')           # uppercase-ing
  hexinput=$(echo "${hexinput}" | tr -d '#')                     # remove Hash if needed
  a=$(echo "${hexinput}" | cut -c-2)
  b=$(echo "${hexinput}" | cut -c3-4)
  c=$(echo "${hexinput}" | cut -c5-6)
  r=$(echo "ibase=16; ${a}" | bc)
  g=$(echo "ibase=16; ${b}" | bc)
  b=$(echo "ibase=16; ${c}" | bc)
  echo "${r} ${g} ${b}"
}

tools

fidian/ansi

# install
$ [[ ! -f /opt/ansi ]] && curl -sL git.io/ansi -o /opt/ansi
$ chmod +x /opt/ansi
$ ln -sf /opt/ansi /usr/local/bin/ansi

# usage
$ ansi --color-table
$ ansi --color-codes

bash-colors c()

# install
$ curl -o /opt/bash-colors.sh -fsSL https://github.com/ppo/bash-colors/blob/master/bash-colors.sh
$ echo "[[ -f \"/opt/bash-colors.sh\" ]] && source \"/opt/bash-colors.sh\" >> ~/.bashrc"

# or using source code directly
# shellcheck disable=SC2015,SC2059
c() { [ $# == 0 ] && printf "\e[0m" || printf "$1" | sed 's/\(.\)/\1;/g;s/\([SDIUFNHT]\)/2\1/g;s/\([KRGYBMCW]\)/3\1/g;s/\([krgybmcw]\)/4\1/g;y/SDIUFNHTsdiufnhtKRGYBMCWkrgybmcw/12345789123457890123456701234567/;s/^\(.*\);$/\\e[\1m/g'; }
# shellcheck disable=SC2086
cecho() { echo -e "$(c $1)${2}\e[0m"; }

# sample
$ echo -e "$(c Gs)bold green$(c) and $(c i)Italic$(c) and normal"

say()

say() {
 echo "$@" | sed \
       -e "s/\(\(@\(red\|green\|yellow\|blue\|magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\4@reset/g" \
       -e "s/@red/$(tput setaf 1)/g" \
       -e "s/@green/$(tput setaf 2)/g" \
       -e "s/@yellow/$(tput setaf 3)/g" \
       -e "s/@blue/$(tput setaf 4)/g" \
       -e "s/@magenta/$(tput setaf 5)/g" \
       -e "s/@cyan/$(tput setaf 6)/g" \
       -e "s/@white/$(tput setaf 7)/g" \
       -e "s/@reset/$(tput sgr0)/g" \
       -e "s/@b/$(tput bold)/g" \
       -e "s/@u/$(tput sgr 0 1)/g"
}

$ say @b@green[[Success]]
$ say @b@yellowWARNING @red..message..

RGBcolor

function RGBcolor {
  echo "16 + $1 * 36 + $2 * 6 + $3" | bc
}

fg=$(RGBcolor 1 0 2)  # Violet
bg=$(RGBcolor 5 3 0)  # Bright orange.

echo -e "\\033[1;38;5;$fg;48;5;${bg}mviolet on tangerine\\033[0m"

terminal-colors

[!NOTE]

• eikenb/terminal-colors

$ python3 -m pip install terminal-colors

# usage
$ terminal-colors -l
$ terminal-colors -n
$ terminal-colors -n -p

colored - python libs

# install
$ python3 -m pip install colored

# usage
$ colored --help
$ colored --color-codes

topic: ansi-colors

• trapd00r/colorcoke
• shakibamoshiri/bline

color picker

iterm2-tab-set

• installation

  $ npm i iterm2-tab-set
  

• usage

  $ tabset --pick
  

  

  function cpick() {
    if test tabset; then
      rgb=$(tabset -p | sed -nr "s:.*rgb\(([^)]+)\).*$:\1:p");
      hexc=$(for c in $(echo "${rgb}" | sed -re 's:,: :g'); do printf '%02x' "$c"; done);
      echo -e """\t$rgb ~~> $hexc""";
    fi
  }
  

• result

  $ cpick
    125,199,53 ~~> 7dc735
  

other scripts

256 color table

[!NOTE|label:references:]

• xterm 256color chart.svg
• color grid

• 256 colors

  

  256colors

  function 256colors() {
    local bar='█'                                          # ctrl+v -> u2588 ( full block )
    if uname -r | grep -q "microsoft"; then bar='▌'; fi    # ctrl+v -> u258c ( left half block )
    for i in {0..255}; do
      echo -e "\e[38;05;${i}m${bar}${i}";
    done | column -c 180 -s ' ';
    echo -e "\e[m"
  }
  

  

  256color

  #!/bin/bash
  
  # This program is free software. It comes without any warranty, to
  # the extent permitted by applicable law. You can redistribute it
  # and/or modify it under the terms of the Do What The Fuck You Want
  # To Public License, Version 2, as published by Sam Hocevar. See
  # http://sam.zoy.org/wtfpl/COPYING for more details.
  
  for fgbg in 38 48 ; do # Foreground / Background
    for color in {0..255} ; do # Colors
      # Display the color
      printf "\e[${fgbg};5;%sm  %3s  \e[0m" $color $color
      # Display 6 colors per lines
      if [ $((($color + 1) % 6)) == 4 ] ; then
        echo # New line
      fi
    done
    echo # New line
  done
  exit 0
  

• colors and formatting

  reference:

  • 256-colors.sh

  

  colors_and_formatting

  #!/bin/sh
  
  # From: https://misc.flogisoft.com/bash/tip_colors_and_formatting#colors2
  # Modified by steve.tarver@gmail.com to work in Alpine Linux ash
  
  # This program is free software. It comes without any warranty, to
  # the extent permitted by applicable law. You can redistribute it
  # and/or modify it under the terms of the Do What The Fuck You Want
  # To Public License, Version 2, as published by Sam Hocevar. See
  # http://sam.zoy.org/wtfpl/COPYING for more details.
  
  for clbg in {40..47} {100..107} 49 ; do   # background
    for clfg in {30..37} {90..97} 39 ; do   # foreground
      for attr in 0 1 2 3 4 5 7 ; do        # formatting
        #Print the result
        echo -en "\e[${attr};${clbg};${clfg}m ^[${attr};${clbg};${clfg}m \e[0m"
      done
      echo                                  # newline
    done
  done
  exit 0
  

  

  for attr in 0 1 2 3 4 5 6 7; do
    echo "------------------------------------------------"
    printf "ESC[%s;Foreground;Background - \n" $attr
    for fore in 30 31 32 33 34 35 36 37; do
        for back in 40 41 42 43 44 45 46 47; do
            printf '\033[%s;%s;%sm %02s;%02s\033[0m' $attr $fore $back $fore $back
        done
    printf '\n'
    done
    printf '\033[0m'
  done
  

• showColors

  

  showcolors

  # @author : https://stackoverflow.com/a/69648792/2940319
  # @usage  :
  #   - `showcolors fg` : default
  #   - `showcolors bg`
  # @alternative: `ansi --color-codes`
  function showcolors() {
    local row col blockrow blockcol red green blue
    local showcolor=_showcolor_${1:-fg}
    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 _showcolor_fg() {
    # shellcheck disable=SC2155
    local code=$( printf %03d "$1" )
    echo -ne "\033[38;5;${code}m"
    echo -nE " $code "
    echo -ne "\033[0m"
  }
  
  function _showcolor_bg() {
    if (( $2 % 2 == 0 )); then
      echo -ne "\033[1;37m"
    else
      echo -ne "\033[0;30m"
    fi
    # shellcheck disable=SC2155
    local code=$( printf %03d "$1" )
    echo -ne "\033[48;5;${code}m"
    echo -nE " $code "
    echo -ne "\033[0m"
  }
  

• colorgrid

  colorgrid

  function colorgrid() {
      iter=16
      while [ $iter -lt 52 ]
      do
          second=$[$iter+36]
          third=$[$second+36]
          four=$[$third+36]
          five=$[$four+36]
          six=$[$five+36]
          seven=$[$six+36]
          if [ $seven -gt 250 ];then seven=$[$seven-251]; fi
  
          echo -en "\033[38;5;$(echo $iter)m█ "
          printf "%03d" $iter
          echo -en "   \033[38;5;$(echo $second)m█ "
          printf "%03d" $second
          echo -en "   \033[38;5;$(echo $third)m█ "
          printf "%03d" $third
          echo -en "   \033[38;5;$(echo $four)m█ "
          printf "%03d" $four
          echo -en "   \033[38;5;$(echo $five)m█ "
          printf "%03d" $five
          echo -en "   \033[38;5;$(echo $six)m█ "
          printf "%03d" $six
          echo -en "   \033[38;5;$(echo $seven)m█ "
          printf "%03d" $seven
  
          iter=$[$iter+1]
          printf '\r\n'
      done
  }
  

• solarized color

  

  solarized-colors

  #!/bin/bash
  
  # solarized ansicolors (exporting for grins)
  export base03='\033[0;30;40m'
  export base02='\033[1;30;40m'
  export base01='\033[0;32;40m'
  export base00='\033[0;33;40m'
  export base0='\033[0;34;40m'
  export base1='\033[0;36;40m'
  export base2='\033[0;37;40m'
  export base3='\033[1;37;40m'
  export yellow='\033[1;33;40m'
  export orange='\033[0;31;40m'
  export red='\033[1;31;40m'
  export magenta='\033[1;35;40m'
  export violet='\033[0;35;40m'
  export blue='\033[1;34;40m'
  export cyan='\033[1;36;40m'
  export green='\033[1;32;40m'
  export reset='\033[0m'
  
  colors () {
    echo -e "base03  ${base03}Test$reset"
    echo -e "base02  ${base02}Test$reset"
    echo -e "base01  ${base01}Test$reset"
    echo -e "base00  ${base00}Test$reset"
    echo -e "base0   ${base0}Test$reset"
    echo -e "base1   ${base1}Test$reset"
    echo -e "base2   ${base2}Test$reset"
    echo -e "base3   ${base3}Test$reset"
    echo -e "yellow  ${yellow}Test$reset"
    echo -e "orange  ${orange}Test$reset"
    echo -e "red     ${red}Test$reset"
    echo -e "magenta ${magenta}Test$reset"
    echo -e "violet  ${violet}Test$reset"
    echo -e "blue    ${blue}Test$reset"
    echo -e "cyan    ${cyan}Test$reset"
    echo -e "green   ${green}Test$reset"
  }
  colors
  

• show 256 colors

  [!NOTE|label:references:]

  • Terminal colour highlights

  $ for c in `seq 0 255`; do t=5; [[ $c -lt 108 ]] && t=0; for i in `seq $t 5`; do echo -e "\e[0;48;$i;${c}m|| $i:$c `seq -s+0 $(($COLUMNS/2))|tr -d '[0-9]'`\e[0m"; done;done
  

color names

[!TIP|label:references:]

• Web colors
• The 256 color table and its partitioning

• blue

  

• brown

  

• cyan

  

• gray.black

  

• green

  

• orange

  

• pink

  

• purple.magenta

  

• red

  

• white

  

• yellow

  

xterm 256 colors chart

[!NOTE|label:references:]

• * Color names
• * Web colors

256 colors cheat sheet