Red Programming Language

Red is a 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 tackles the software building complexity using a DSL-oriented approach (we call them dialects) . The following dialects are built-in:

Red/System: a C-level system programming language compiled to native code
Parse: a powerful PEG parser
VID: a simple GUI layout creation dialect
Draw: a vector 2D drawing dialect
Rich-text: a rich-text description dialect

Red has its own complete cross-platform toolchain, featuring an encapper, a native compiler, an interpreter, and a linker, not depending on any third-party library, except for a Rebol2 interpreter, required during the alpha stage. Once 1.0 is reached, Red will be self-hosted. Currently, Red is still at alpha stage and 32-bit only.

Red's main features are:

Human-friendly syntax
Homoiconic (Red is its own meta-language and own data-format)
Functional, imperative, reactive and symbolic programming
Prototype-based object support
Multi-typing
Powerful pattern-matching Macros system
Rich set of built-in datatypes (50+)
Both statically and JIT-compiled(*) to native code
Cross-compilation done right
Produces executables of less than 1MB, with no dependencies
Concurrency and parallelism strong support (actors, parallel collections)(*)
Low-level system programming abilities through the built-in Red/System DSL
Powerful PEG parser DSL built-in
Fast and compacting Garbage Collector
Instrumentation built-in for the interpreter, lexer and parser.
Cross-platform native GUI system, with a UI layout DSL and a drawing DSL
Bridging to the JVM
High-level scripting and REPL GUI and CLI consoles included
Visual Studio Code plugin, with many helpful features
Highly embeddable
Low memory footprint
Single-file (~1MB) contains whole toolchain, full standard library and REPL (**)
No install, no setup
Fun guaranteed!

(*) Not implemented yet. (**) Temporarily split in two binaries

More information at red-lang.org.

Running the Red REPL

Download a GUI or CLI console binary suitable for your operating system, rename it at your convenience, then run it from shell or by double-clicking on it (Windows). You should see the following output:

    ---== Red 0.6.5 ==--
    Type HELP for starting information.

    >>

A simple Hello World would look like:

    >> print "Hello World!"
    Hello World!

If you are on the GUI console, a GUI Hello World (prompt omitted):

    view [text "Hello World!"]

A more sophisticated example that retrieves the last commits from this repo and displays their log messages in a scrollable list:

    view [
        text-list data collect [
            foreach event load https://api.github.com/repos/red/red/commits [
                keep event/commit/message
            ]
        ]
    ]

Note: check also the following improved version allowing you to click on a given commit log and open the commit page on github.

You can now head to see and try some showcasing scripts here and there. You can run those examples from the console directly using Github's "raw" link. E.g.:

    >> do https://raw.githubusercontent.com/red/code/master/Showcase/calculator.red

Note: If you are using the Wine emulator, it has some issues with the GUI-Console. Install the Consolas font to fix the problem.

Generating a standalone executable

The Red toolchain comes as a single executable file that you can download for the big-3 platforms (32-bit only for now). Rename the file to redc (or redc.exe under Windows).

Put the downloaded redc binary in the working folder.

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

 Red [
     Title: "Simple hello world script"
 ]

 print "Hello World!"

Save it under the name: hello.red
Generate a compiled executable from that program: (first run will pre-compile libRedRT library)
```
 $ redc -c hello.red
 $ ./hello
```
Want to generate a compiled executable from that program with no dependencies?
```
 $ redc -r hello.red
 $ ./hello
```

Want to cross-compile to another supported platform?

 $ redc -t Windows hello.red
 $ redc -t Darwin hello.red
 $ redc -t Linux-ARM hello.red

The full command-line syntax is:

redc [command] [options] [file]

[file] any Red or Red/System source file.

The -c, -r and -u options are mutually exclusive.

[options]

-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 <file>, --output <file>     : 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 <ID>, --target <ID>         : 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 <level>, --verbose <level>  : 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.

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

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

--view <engine>                : Select the VIEW engine (native, terminal, GTK, test)

--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.

[command]

bu

Red

Install / Use

README

Red Programming Language

Running the Red REPL

Generating a standalone executable