by red

red / red

Red is a next-generation programming language strongly inspired by Rebol, but with a broader field o...

4.4K Stars 385 Forks Last release: almost 2 years ago (v0.6.4) Other 12.8K Commits 27 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

Join the chat at Windows build Windows build 2 macOS build Linux build ARMel build ARMhf build

Red Programming Language

Red is a new programming language strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting, while providing modern support for concurrency and multi-core CPUs.

Red has its own complete cross-platform toolchain, featuring two compilers, an interpreter and a linker, not depending on any third-party library, except for a Rebol2 interpreter, required during the bootstrap phase. Once complete, Red will be self-hosted.

The Red software stack also contains another language, Red/System, which is a low-level dialect of Red. It is a limited C-level language with a Red look'n feel, required to build Red's runtime library and be the target language of Red's compiler. More information at

Making a Red "Hello World"

The Red toolchain comes as a single one-megabyte executable file that you can download from here for the big-3 platforms.

  1. Put the downloaded red binary in the working folder.

  2. In a code or text editor, write the following Hello World program:

    Red [
        Title: "Simple hello world script"

    print "Hello World!"

  3. Save it under the name:

  4. From a terminal (works from DOS too), run it with:

    $ red
  5. You should see the Hello World! output.

  6. Want to generate a compiled executable from that program?

    $ red -c
    $ ./hello
  7. Want to generate a compiled executable from that program with no dependencies?

    $ red -r
    $ ./hello
  8. Want to cross-compile to another supported platform?

    $ red -t Windows
    $ red -t Darwin
    $ red -t Linux-ARM

The command-line syntax is:

red [command] [options] [file]

any Red or Red/System source file. If no file and no option is provided, the graphical interactive console will be launched. If a file with no option is provided, the file will be simply run by the interpreter (it is expected to be a Red script with no Red/System code).

Note: On Non-Windows platforms, the REPL runs by default in CLI mode. But on Windows, the default is to run in GUI mode. To run it in the command line mode, invoke the red binary with the option


-c, --compile                  : Generate an executable in the working
                                 folder, using libRedRT. (development mode)

-d, --debug, --debug-stabs : Compile source file in debug mode. STABS is supported for Linux targets.

-dlib, --dynamic-lib : Generate a shared library from the source file.

-e, --encap : Compile in encap mode, so code is interpreted at runtime. Avoids compiler issues. Required for some dynamic code.

-h, --help : Output this help text.

-o , --output : Specify a non-default [path/][name] for the generated binary file.

-r, --release : Compile in release mode, linking everything together (default: development mode).

-s, --show-expanded : Output result of Red source code expansion by the preprocessor.

-t , --target : Cross-compile to a different platform target than the current one (see targets table below).

-u, --update-libRedRT : Rebuild libRedRT and compile the input script (only for Red scripts with R/S code).

-v , --verbose : Set compilation verbosity level, 1-3 for Red, 4-11 for Red/System.

-V, --version : Output Red's executable version in x.y.z format.

--config [...] : Provides compilation settings as a block of name: value pairs.

--no-compress : Omit Redbin format compression.

--catch : Stay in the REPL after the script finishes.

--cli : Run the command-line REPL instead of the graphical console.

--no-console : Do not launch the REPL after console compilation.

--no-view : Do not include VIEW module in the CLI console and the libRedRT.

--no-runtime : Do not include runtime during Red/System source compilation.

--red-only : Stop just after Red-level compilation. Use higher verbose level to see compiler output. (internal debugging purpose)

--show-func-map : Output an address/name map of Red/System functions, for debugging purposes.

build libRed [stdcall]         : Builds libRed library and unpacks the
                                 libRed/ folder locally.

clear [] : Delete all temporary files from current or target folder.

Cross-compilation targets:

MSDOS        : Windows, x86, console (+ GUI) applications
Windows      : Windows, x86, GUI applications
WindowsXP    : Windows, x86, GUI applications, no touch API
Linux        : GNU/Linux, x86, console (+ GUI) applications
Linux-GTK    : GNU/Linux, x86, GUI only applications
Linux-musl   : GNU/Linux, x86, musl libc
Linux-ARM    : GNU/Linux, ARMv5, armel (soft-float)
RPi          : GNU/Linux, ARMv7, armhf (hard-float)
RPi-GTK      : GNU/Linux, ARMv7, armhf (hard-float), GUI only applications
Darwin       : macOS Intel, console-only applications
macOS        : macOS Intel, applications bundles
Syllable     : Syllable OS, x86
FreeBSD      : FreeBSD, x86
NetBSD       : NetBSD, x86
Android      : Android, ARMv5
Android-x86  : Android, x86

Note: Running the Red toolchain binary from a $PATH currently requires a wrapping shell script (see relevant tickets: #543 and #1547).

Running the Red REPL

  1. Just run the

    binary with no option to access the REPL.
    ---== Red 0.6.3 ==--
    Type HELP for starting information.


  2. You can use it to test rapidly some Red code:

    >> 1 + 2
    == 3

    >> inc: func [n][n + 1] == func [n][n + 1]

    >> inc 123 == 124


  • On Windows, the REPL runs by default in GUI mode. To run it in the command line, invoke the red binary as
    red --cli
  • Wine has some issues with the GUI-Console. Install the
    font to fix the problem.

Running Red from the sources (for contributors)

The compiler and linker are currently written in Rebol. Please follow the instructions for installing the compiler toolchain in order to run it from sources:

  1. Clone this git repository or download an archive (

    button above or from tagged packages).
  2. Download a Rebol interpreter suitable for your OS: Windows, Linux (or Linux), Mac OS X, FreeBSD, OpenBSD, Solaris.

  3. Extract the

    binary, put it in root folder, that's all!
  4. Let's test it: run

    , you'll see a
    prompt appear. Windows users need to double-click on the
    file to run it.
  5. From the REBOL console type:

    >> do/args %red.r "%tests/"

The compilation process should finish with a

...output file size
message. The resulting binary is in the working folder. Windows users need to open a DOS console and run
from there.

To see the intermediary Red/System code generated by the compiler, use:

    >> do/args %red.r "-v 2 %tests/"

You can also compile the Red console from source:

    >> do/args %red.r "-r %environment/console/CLI/"

To compile the Windows GUI console from source:

    >> do/args %red.r "-r -t Windows %environment/console/GUI/"

Note: the

argument is not necessary when launching the Red toolchain from sources, as the default action is to compile the input script (the toolchain in binary form default action is to run the input script through the interpreter). The
argument is needed when compiling the Red console to make additional runtime functions available.

Note: The red git repository does not include a

file. If you run the automated tests a number of files will be created that are not stored in the repository. Installing and renaming a copy of
file will ignore these generated files.


If you want to contribute code to the Red project be sure to read the guidelines first.

It is usually a good idea to inform the Red team about what changes you are going to make in order to ensure that someone is not already working on the same thing. You can reach us through our chat room.

Satisfied with the results of your change and want to issue a pull request on Github?

Make sure the changes pass all the existing tests, add relevant tests to the test-suite and please test on as many platforms as you can. You can run all the tests using (from Rebol console, at repository root):

    >> do %run-all.r

Git integration with console built from sources

If you want git version included in your Red console built from sources, use this command:

call/show ""                                              ;-- patch call bug on Windows
save %build/git.r do %build/git-version.r                 ;-- lookup git version if available
do/args %red.r "-r %environment/console/CLI/"  ;-- build Console
write %build/git.r "none^/"                               ;-- restore git repo status

Anti-virus false positive

Some anti-virus programs are a bit too sensitive and can wrongly report an alert on some binaries generated by Red (see here for the details). If that happens to you, please report it to your anti-virus vendor as a false positive.


Both Red and Red/System are published under BSD license, runtime is under BSL license. BSL is a bit more permissive license than BSD, more suitable for the runtime parts.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.