Predefined styles (as of 20251227)

The Rexx Highlighter is distributed with an extensive set of styles; the ones starting with "rgf" or contaning "vim" in their names were kindly provided by Rony Flatscher.

The following palette is created from a single base file by using the source= option and rotating the style.

We have activated support for Executor extensions and for TUTOR-flavored Unicode to be able to showcase several of the possibilities of the highlighter.

Dark styles

rexx {executor unicode}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=rgfdark}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-blue}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-darkblue}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-desert}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-elflord}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-evening}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-industry}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-koehler}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-murphy}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-pablo}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-ron}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-slate}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-dark-torte}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

Light styles

rexx {executor unicode style=light}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=rgflight}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-light-delek}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-light-morning}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-light-peachpuff}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-light-shine}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"

rexx {executor unicode style=vim-light-zellner}

Say -100.233 + .3e-44 + "-1.23E-567"    -- Numbers can have internal highlighting
Say "(Lobster)"U                        -- Low-level Unicode strings. Prints "🦞"
Say "नमस्ते"T                             -- UTF-8 Unicode strings (Sanskrit for "Namaste")
Say "Barcelona"                         -- String quotes may have a different color

/* After the Executor extension below, all strings will have a new method "Giraffe"     */

Say "abc"~giraffe(2)                    -- Prints "🦒"

/* Executor a higher-level function definition                                         */
compose = {  use arg f, g
             return {expose f g; use arg x; return f~(g~(x))}
          }

::Constant Ducks "🦆🦆🦆"G             -- A Graphemes TUTOR string

::Extension String                      -- We are extending the predefined String class

--- The Giraffe method. This is a doc-comment
--- @param optional Does nothing

::Method Giraffe                        -- Directive keywords can have their own highlighting
  Expose something                      -- "something" is an exposed variable
  Use Arg optional
  something = optional
  Return "🦒"