# curs_color 3x 2025-08-16 ncurses 6.5 Library calls

    curs_color(3x)                   Library calls                  curs_color(3x)

## NAME

           start_color,   has_colors,   can_change_color,  init_pair,  init_color,
           init_extended_pair, init_extended_color,  color_content,  pair_content,
           extended_color_content,    extended_pair_content,    reset_color_pairs,
           COLOR_PAIR, PAIR_NUMBER, COLORS, COLOR_PAIRS,  COLOR_BLACK,  COLOR_RED,
           COLOR_GREEN,   COLOR_YELLOW,   COLOR_BLUE,  COLOR_MAGENTA,  COLOR_CYAN,
           COLOR_WHITE, A_COLOR - manipulate terminal colors with curses

## SYNOPSIS

           #include <curses.h>

           /* variables */
           int COLOR_PAIRS;
           int COLORS;

           int start_color(void);

           bool has_colors(void);
           bool can_change_color(void);

           int init_pair(short pair, short f, short b);
           int init_color(short color, short r, short g, short b);
           /* extensions */
           int init_extended_pair(int pair, int f, int b);
           int init_extended_color(int color, int r, int g, int b);

           int color_content(short color, short *r, short *g, short *b);
           int pair_content(short pair, short *f, short *b);
           /* extensions */
           int extended_color_content(int color, int *r, int *g, int *b);
           int extended_pair_content(int pair, int *f, int *b);

           /* extension */
           void reset_color_pairs(void);

           /* macros */
           int COLOR_PAIR(int n);
           PAIR_NUMBER(int attr);
           COLOR_BLACK
           COLOR_RED
           COLOR_GREEN
           COLOR_YELLOW
           COLOR_BLUE
           COLOR_MAGENTA
           COLOR_CYAN
           COLOR_WHITE
           A_COLOR

## DESCRIPTION

### Overview

           curses supports color attributes on  terminals  with  that  capability.
           Call  start_color  (typically  right  after initscr(3x)) to enable this
           feature.  Colors are always used in pairs.   A  color  pair  couples  a
           foreground  color  for characters with a background color for the blank
           field on which characters are rendered.  init_pair initializes a  color
           pair.   The  macro  COLOR_PAIR(n)  can then convert the pair to a video
           attribute.

           If  a  terminal  has  the  relevant  capability,   init_color   permits
           (re)definition of a color.  has_colors and can_change_color return TRUE
           or FALSE, depending on whether the terminal has  color  capability  and
           whether  the  programmer  can change the colors.  color_content permits
           extraction of the red, green, and blue  components  of  an  initialized
           color.   pair_content  permits  discovery  of  a  color  pair's current
           definition.

### Rendering

           curses combines the following data to render a character cell.  Any  of
           them can include color information.

           o   curses character attributes, as from waddch(3x) or wadd_wch(3x)

           o   window attributes, as from wattrset(3x) or wattr_set(3x)

           o   window  background  character  attributes,  as from wbkgdset(3x) or
               wbkgrndset(3x)

           Per-character and window attributes are usually set through a  function
           parameter  containing  attributes  including  a color pair value.  Some
           functions,  such  as  wattr_set,  use  a  separate  color  pair  number
           parameter.

           The  background  character  is  a special case: it includes a character
           code, just as if it were passed to waddch.

           The curses library does the actual work of combining these color  pairs
           in an internal function called from waddch:

           o   If the parameter passed to waddch is blank, and it uses the special
               color pair 0, curses next checks the window attribute.

               o   If the window attribute does not use color pair 0, curses  uses
                   the color pair from the window attribute.

               o   Otherwise, curses uses the background character.

           o   If  the parameter passed to waddch is not blank, or it does not use
               the special color pair 0, curses prefers the color  pair  from  the
               parameter,  if  it  is  nonzero.   Otherwise,  it  tries the window
               attribute next, and finally the background character.

           Some curses functions such  as  wprintw  call  waddch.   Those  do  not
           combine  its parameter with a color pair.  Consequently those calls use
           only the window attribute or the background character.

## CONSTANTS

           ISO 6429 and ECMA-48 define eight standard colors (also known as "ANSI"
           colors).   curses.h  defines object-like macros COLOR_BLACK, COLOR_RED,
           COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA,  COLOR_CYAN,  and
           COLOR_WHITE  accordingly.   curses  assumes  that  COLOR_BLACK  is  the
           default  background  color  for  all  terminals.   ncurses  offers   an
           extension  to  override that assumption; see assume_default_colors(3x).
           Some terminals support additional colors that lack standard names.

           A_COLOR is a bit mask  that,  when  bitwise  "and"-ed  with  a  chtype,
           extracts its color pair identifier.

## VARIABLES

### COLORS

           is  initialized  by  start_color  to  the  maximum number of colors the
           terminal can support.

### COLOR_PAIRS

           is initialized by start_color to the maximum number of color pairs  the
           terminal can support.  Often, its value is the product COLORS x COLORS,
           but this is not always true.

           o   A few terminals use the HLS color space  (see  start_color  below),
               ignoring this rule; and

           o   terminals  supporting  a  large number of colors are limited to the
               number of color pairs that a signed short value can represent.

## FUNCTIONS

### start_color

           The start_color routine requires no arguments.  It must  be  called  if
           the  programmer  wants  to  use  colors,  and  before  any  other color
           manipulation routine is called.  It  is  good  practice  to  call  this
           routine right after initscr.  start_color does this:

           o   It   initializes  two  global  variables,  COLORS  and  COLOR_PAIRS
               (respectively defining the maximum number of colors and color pairs
               the terminal can support).

           o   It  initializes  the special color pair 0 to the default foreground
               and background colors.  No other color pairs are initialized.

           o   It restores the colors on the terminal to the values they had  when
               the terminal was just turned on.

           o   If  the  terminal supports the initc (initialize_color) capability,
               start_color initializes its internal table  representing  the  red,
               green, and blue components of the color palette.

               The components depend on whether the terminal uses CGA (aka "ANSI")
               or HLS (i.e.,  the  hls  (hue_lightness_saturation)  capability  is
               set).   The  table  is  initialized  first  for  eight basic colors
               (black, red, green, yellow, blue, magenta, cyan, and white),  using
               weights that depend upon the CGA/HLS choice.  For "ANSI" colors the
               weights are 680 or 0 depending on whether  the  corresponding  red,
               green,  or  blue component is used or not.  That permits using 1000
               to represent bold/bright colors.  After the  initial  eight  colors
               (if  the  terminal  supports more than eight colors) the components
               are initialized using the same pattern, but with weights  of  1000.
               SVr4 uses a similar scheme, but uses 1000 for the components of the
               initial eight colors.

               start_color does not attempt to set the terminal's color palette to
               match  its  built-in  table.   An application may use init_color to
               alter the internal table along with the terminal's color.

           These limits apply to color values and  color  pairs.   Values  outside
           these limits are not valid, and may result in a runtime error:

           o   COLORS   corresponds   to   the   terminal   database's  max_colors
               capability, (see terminfo(5)).

           o   color values are expected  to  be  in  the  range  0  to  COLORS-1,
               inclusive (including 0 and COLORS-1).

           o   a  special  color value -1 is used in certain extended functions to
               denote the default color (see use_default_colors(3x)).

           o   COLOR_PAIRS  corresponds  to  the  terminal  database's   max_pairs
               capability, (see terminfo(5)).

           o   valid  color  pair  values  are  in  the  range 1 to COLOR_PAIRS-1,
               inclusive.

           o   color pair 0 is special; it denotes "no color".

               Color pair 0 is assumed to be  white  on  black,  but  is  actually
               whatever  the  terminal implements before color is initialized.  It
               cannot be modified by the application.

### has_colors

           has_colors returns TRUE if the terminal supports colors and FALSE if it
           does  not.   initscr(3x)  or  newterm(3x)  must  be  called  first, but
           start_color need not be.   An  application  might  call  has_colors  to
           decide  whether to use color or a video attribute like A_BOLD to render
           text.

           Color support in curses requires that  the  terminal  type  description
           support  the  capabilities  max_colors (colors), max_pairs (pairs), and
           any of

           o   set_foreground (setf) and set_background (setb);

           o   set_a_foreground (setaf) and set_a_background (setab); or

           o   set_color_pair (scp).

### can_change_color

           The can_change_color routine requires no arguments.  It returns TRUE if
           the  terminal  supports colors and can change their definitions; other,
           it  returns  FALSE.   This  routine   facilitates   writing   terminal-
           independent programs.

### init_pair

           The init_pair routine changes the definition of a color pair.  It takes
           three arguments: the number of  the  color  pair  to  be  changed,  the
           foreground color number, and the background color number.  For portable
           applications:

           o   The first argument must be a valid color pair  value.   If  default
               colors  are  used  (see  use_default_colors(3x)) the upper limit is
               adjusted to allow for extra pairs which  use  a  default  color  in
               foreground and/or background.

           o   The second and third arguments must be valid color values.

           If  the  color pair was previously initialized, the screen is refreshed
           and all  occurrences  of  that  color  pair  are  changed  to  the  new
           definition.

           As  an  extension,  ncurses  allows  you  to  set  color pair 0 via the
           assume_default_colors(3x) routine, or to specify  the  use  of  default
           colors (color number -1) if you first invoke the use_default_colors(3x)
           routine.

### init_extended_pair

           Because init_pair uses signed shorts for its  parameters,  that  limits
           color  pairs  and  color-values  to  32767  on  modern  hardware.   The
           extension init_extended_pair uses ints for the color  pair  and  color-
           value, allowing a larger number of colors to be supported.

### init_color

           The  init_color  routine  changes  the definition of a color.  It takes
           four arguments: the number of the color to be changed followed by three
           RGB values (for the amounts of red, green, and blue components).

           o   The  first argument must be a valid color value; default colors are
               not allowed here.  (See the section Colors for  the  default  color
               index.)

           o   Each  of  the  last  three arguments must be a value in the range 0
               through 1000.

           When init_color is used, all occurrences of that color  on  the  screen
           immediately change to the new definition.

### init_extended_color

           Because  init_color  uses signed shorts for its parameters, that limits
           color-values and their red, green, and  blue  components  to  32767  on
           modern  hardware.   The extension init_extended_color uses ints for the
           color value and for  setting  the  red,  green,  and  blue  components,
           allowing a larger number of colors to be supported.

### color_content

           The color_content routine gives programmers a way to find the intensity
           of the red, green, and blue (RGB) components in a color.   It  requires
           four  arguments:  the  color  number, and three addresses of shorts for
           storing the information about the  amounts  of  red,  green,  and  blue
           components in the given color.

           o   The  first  argument  must  be a valid color value, i.e., 0 through
               COLORS-1, inclusive.

           o   The values that are stored at the addresses pointed to by the  last
               three  arguments  are  in  the  range 0 (no component) through 1000
               (maximum amount of component), inclusive.

### extended_color_content

           Because color_content uses  signed  shorts  for  its  parameters,  that
           limits  color-values and their red, green, and blue components to 32767
           on modern hardware.  The extension extended_color_content uses ints for
           the  color value and for returning the red, green, and blue components,
           allowing a larger number of colors to be supported.

### pair_content

           The pair_content routine allows programmers to find out what  colors  a
           given  color  pair consists of.  It requires three arguments: the color
           pair number, and two addresses of shorts for storing the foreground and
           the background color numbers.

           o   The  first argument must be a valid color value, i.e., in the range
               1 through COLOR_PAIRS-1, inclusive.

           o   The values that are stored at  the  addresses  pointed  to  by  the
               second  and  third  arguments  are  in  the range 0 through COLORS,
               inclusive.

### extended_pair_content

           Because pair_content uses signed shorts for its parameters, that limits
           color pair and color-values to 32767 on modern hardware.  The extension
           extended_pair_content uses ints for the color pair  and  for  returning
           the  foreground  and  background  colors,  allowing  a larger number of
           colors to be supported.

### reset_color_pairs

           The extension reset_color_pairs tells ncurses to  discard  all  of  the
           color  pair  information which was set with init_pair.  It also touches
           the current- and standard-screens, allowing an  application  to  switch
           color palettes rapidly.

### COLOR_PAIR

           COLOR_PAIR(n) converts a color pair number to an attribute.  Attributes
           can hold color pairs in the range 0 to 255.  If you need a  color  pair
           larger  than  that, you must use functions such as attr_set (which pass
           the color  pair  as  a  separate  parameter)  rather  than  the  legacy
           functions such as attrset.

### PAIR_NUMBER

           PAIR_NUMBER(attr)   extracts   the  color  information  from  its  attr
           parameter and returns it as a color pair  number;  it  is  the  inverse
           operation of COLOR_PAIR.

## RETURN VALUE

           can_change_color  and  has_colors  return  TRUE  or  FALSE.   The other
           functions return OK on success and ERR on failure.

           In  ncurses,  functions  returning  an  int  recognize  several   error
           conditions.

           o   All  return  ERR  if  the  screen  has  not  been  initialized; see
               initscr(3x) or newterm(3x).

           o   All except start_color return  ERR  if  start_color  has  not  been
               called, or itself returned ERR.

           o   start_color  returns ERR if it cannot allocate memory for its color
               pair table.

           o   init_color returns ERR  if  the  terminal  type  does  not  support
               assignable  color  values; that is, if the initialize_color (initc)
               capability is absent from its description.

           o   init_color returns ERR if any of its r, g, b arguments  is  outside
               the range 0-1000 inclusive.

           o   init_pair,   init_color,  init_extended_pair,  init_extended_color,
               color_content,    pair_content,     extended_color_content,     and
               extended_pair_content return ERR on attempts to use

               o   color  identifiers  outside the range 0-COLORS-1 inclusive, the
                   default colors extension notwithstanding, or

               o   color  pair  identifiers  outside  the  range   0-COLOR_PAIRS-1
                   inclusive.

## NOTES

           In  ncurses, init_pair accepts negative foreground and background color
           arguments to support its  use_default_colors(3x)  extension,  but  only
           after the latter function has been called.

           The  assumption  that  COLOR_BLACK is the terminal's default background
           color  can  be  overridden  using  ncurses's  assume_default_colors(3x)
           extension.

           In  ncurses,  each pointer passed to color_content and pair_content can
           be  null,  in  which  case  the  library  ignores  it,  permitting  the
           application to disregard unnecessary information.

           In  ncurses,  each  screen  has a color activation flag, color palette,
           color  pair  table,  and  associated  COLORS  and  COLOR_PAIRS  values;
           start_color  affects  only  the  current  screen.   The SVr4 and X/Open
           Curses interface was not really designed with this in mind;  historical
           implementations may use a single shared color palette.

           Setting  an  implicit  background  color  via a color pair affects only
           character cells that a character write  operation  explicitly  touches.
           To  change the background color used when parts of a window are blanked
           by erasing or scrolling operations, see curs_bkgd(3x).

           Several caveats apply to IBM PC-compatible machines of  the  80486  era
           and earlier with CGA/EGA/VGA video.

           o   COLOR_YELLOW  was  frequently converted, in the analog domain, to a
               shade of brown if the intensity bit was not set.  To get yellow  on
               such  devices,  one  would  combine  COLOR_YELLOW  with  the A_BOLD
               attribute.

           o   The A_BLINK attribute should in theory make the background  bright.
               This  often  fails  to  work, and even VGA controllers for which it
               mostly works, such as those from Paradise and compatibles,  do  the
               wrong thing when you try to set a bright "yellow" background -- you
               get a blinking yellow foreground instead.

           o   Color RGB values are not configurable on  these  devices  (in  text
               mode).

## EXTENSIONS

           The  functions  marked as extensions originated in ncurses, and are not
           found in SVr4 curses, 4.4BSD  curses,  or  any  other  previous  curses
           implementation.

## PORTABILITY

           Applications employing ncurses extensions should condition their use on
           the visibility of the NCURSES_VERSION preprocessor macro.

           X/Open Curses Issue 4 describes these functions.  It specifies no error
           conditions for them.

           ncurses  satisfies  X/Open  Curses's  minimum  maximums  for COLORS and
           COLOR_PAIRS.

           X/Open Curses does not specify a limit for the  number  of  colors  and
           color pairs which a terminal can support.  However, in its use of short
           for the parameters, it carries over SVr4's  implementation  detail  for
           the  compiled  terminfo  database,  which  uses  signed 16-bit numbers.
           ncurses  provides  extended  versions  of  the  functions  using  short
           parameters,   allowing  applications  to  use  larger  color  and  pair
           identifiers.

           SVr4 curses returns ERR from pair_content if its pair argument was  not
           initialized  using  init_pairs,  and from color_content if the terminal
           does not support changing colors.  ncurses does neither.

## HISTORY

           SVr3.2 (1987) introduced color  support  to  curses  with  all  of  the
           symbols  in  the  synopsis above except those marked as extensions.  It
           reserved color pair 0 as the terminal's initial, "uncolored" state, and
           limited  the  number  of  possible color pairs to 64, because the color
           pair datum was encoded in six bits of a chtype.

           SVr4 made only internal changes, such as moving the  storage  of  color
           state  from  the  SCREEN  structure  (pointed to by SP) to the TERMINAL
           structure (pointed to by cur_term).

           Other curses implementations impose different limits on the  number  of
           colors and color pairs.

           o   PCCurses  (1987-1990)  provided  for  only  8 colors (and therefore
               required at most 8x8 = 64 color pairs).

           o   PDCurses  (1992-present)  inherited  the  8-color  limitation  from
               PCCurses,  but  changed  this  to  256  in  version 2.5 (2001), and
               widened its chtype from 16 to 32 bits.

           o   X/Open  Curses  (1992-present)  specified  a  new  structure  type,
               cchar_t,  to  store  the character code, attribute flags, and color
               pair identifier, allowing an increased range of  color  pairs.   It
               specifies  a  short  as  storing  identifiers  for colors and color
               pairs, limiting portable values to 15  bits;  negative  values  are
               invalid in System V.

           o   ncurses  (1992-present), in its non-wide configuration, uses 8 bits
               of chtype for the color pair identifier.

               Version 5.3 (2002) offered a wide-character interface, but  encoded
               the color pair identifier with attributes in the character type.

               Since  version  6 (2015), ncurses uses a separate int for the color
               pair identifier in a cchar_t, introducing  extension  functions  to
               manage  the  wider  type.   When a color pair value fits in 8 bits,
               ncurses permits color pair data to be manipulated via the functions
               taking  chtype  arguments,  even  when  a  curses window uses wide-
               character cells.

           o   NetBSD curses used 6 bits for the color pair identifier  from  2000
               (when  it  first  added  color support) until 2004.  At that point,
               NetBSD widened the color pair identifier to  use  9  bits.   As  of
               2025,  that  size is unchanged.  Like ncurses before version 6, the
               NetBSD color pair datum  is  stored  in  the  attributes  field  of
               cchar_t, limiting the number of color pairs.

## SEE ALSO

           curses(3x),    curs_attr(3x),   curs_initscr(3x),   curs_variables(3x),
           default_colors(3x)

    ncurses 6.5                       2025-08-16                    curs_color(3x)