# curs_color 3x 2025-08-23 ncurses 6.6 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-character 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.6                       2025-08-23                    curs_color(3x)