red: dialects, a native compiler and a whole toolchain in one 1MB file
Red is a next-generation 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 and cross-platform reactive GUI, while providing modern support for concurrency, all in a zero-install, zero-config, single ~1MB file!
At a glance
- What is it?
- red is a Rebol-inspired language that treats dialects as its unit of reuse and ships its own encapper, compiler, linker and interpreter with no third-party libraries. It is also still at the alpha stage, 32-bit only, and two of its headline features, actors and JIT compilation, are marked not implemented yet.
- Who is it for?
- red is worth a look for someone who wants a homoiconic language with its own compiler and a GUI that arrives in the same download as the REPL, and who can accept an alpha stage, 32-bit only, target. Before writing anything beyond a script, check the two markers in the feature list: the concurrency work is marked not implemented yet, and the single file claim is footnoted as temporarily split in two binaries.
- Can I use it commercially?
- Yes. BSL-1.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Red, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- red/red6,072 ★ · +30
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| red/red | 6k | 6.1k |
30 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Five dialects ship in the box and Red/System is the one that compiles
Red's answer to software complexity is a set of dialects rather than a set of libraries, and five of them are built in. Red/System is a C level system programming language compiled to native code, and it is the foundation the rest sits on. Parse is a PEG parser, reachable as a dialect rather than as a separate tool. VID creates GUI layouts declaratively, Draw does vector 2D drawing, and Rich-text describes formatted text in the same style.
That grouping is the design argument. Rather than a general purpose language with a standard library bolted on, each problem domain gets its own notation, and the PEG parser in particular is something you write in the language instead of importing.
The rest of the feature list follows from that shape. Red is homoiconic, meaning the language is its own meta language and its own data format, and it supports functional, imperative, reactive and symbolic programming together. On top of that sit prototype based objects, multi-typing, a macro system for pattern matching, and a set of built-in datatypes numbered at more than 50.
The toolchain is self-contained, except for Rebol2 while alpha lasts
Red carries its own cross platform toolchain rather than assembling one from outside: an encapper, a native compiler, an interpreter and a linker. The stated dependency rule is no third party library at all, with a single exception that is time limited. A Rebol2 interpreter is required during the alpha stage.
That exception has an end date attached. Once 1.0 is reached, the plan is for Red to be self-hosted, which means the language would compile its own compiler rather than lean on Rebol2 to bootstrap. Until then, an alpha build carries a runtime expectation on another interpreter being present.
The packaging claim is the one operators notice first: a single file of roughly 1MB that contains the whole toolchain, the full standard library and the REPL, with no install and no setup step. That claim carries a footnote. The single file entry is marked as temporarily split in two binaries, so the download you get today is not the one download the feature list describes.
Actors, parallel collections and JIT compilation are footnoted as unimplemented
Two entries in the feature list end in a marker that means not implemented yet, and they are not minor items. The line for compilation reads that Red is both statically and JIT-compiled to native code, and carries the same asterisk as the concurrency line, which promises strong support for concurrency and parallelism through actors and parallel collections.
So the language offers the reactive and parallel story in its documentation while marking the parallel machinery as unfinished. For a reader choosing a language today, the asterisk is the whole answer: the static compilation path is the one to plan around, and anything that assumes parallel collections needs checking before it is scheduled.
Other entries in the same list are complete rather than aspirational. The garbage collector is described as fast and compacting, with the release history carrying a tag named for a simple GC and a later one named for memory management improvements. Instrumentation is built into the interpreter, the lexer and the parser, which is what makes a homoiconic language debuggable at that level. There is also a bridge to the JVM, a Visual Studio Code plugin, and GUI and CLI consoles for the REPL.
redc has three mutually exclusive output modes and a cross-compile target list
The compiler is a separate executable, taken from the same toolchain and renamed to redc, or redc.exe on Windows. Its full syntax is given as `redc [command] [options] [file]`, where the file argument is any Red or Red/System source file. The first rule to know is that the -c, -r and -u options are mutually exclusive, so a build picks one output mode and cannot mix them.
The documented modes differ in what the result needs at run time. The -c, --compile option generates an executable in the working folder using libRedRT, and that is labelled development mode. The -r option generates an executable with no dependencies, which is the one to pick when the output has to travel on its own. Cross-compilation uses a target flag:
$ redc -c hello.red
$ ./hello
$ redc -r hello.red
$ ./hello
$ redc -t Windows hello.red
$ redc -t Darwin hello.red
$ redc -t Linux-ARM hello.redThe target list in the README covers Windows, Darwin and Linux-ARM, so a build made on one of the big three platforms can target another. Debug output has its own switch, -d, --debug, --debug-stabs, with STABS named as supported for Linux targets, and the option table also carries -dlib, --dynamic-lib for shared library output. The first compile of a session pre-compiles the libRedRT library, which the steps call out as a one time cost.
A first run begins at the console banner, with no install step
There is no installer to run. The documented path is to download a GUI or CLI console binary for your operating system from the project's download page, rename it to whatever you like, and run it from a shell or by double-clicking it on Windows. What you should see is this:
---== Red 0.6.5 ==--
Type HELP for starting information.
>>From that prompt the language is immediate. Printing a string needs no import and no setup:
print "Hello World!"The next step the project suggests is not more tutorial code but running an existing script, fetched straight from the Showcase directory of the red/code repository through the raw link:
do https://raw.githubusercontent.com/red/code/master/Showcase/calculator.redThat is the shape of the whole workflow for small programs: download once, then `do` a URL. It also means the Showcase and Scripts directories are the real documentation.
The GUI console runs view and text-list, and needs a font under Wine
On the GUI console the same hello world becomes a layout expression rather than a print call:
view [text "Hello World!"]The longer example in the README composes a layout, a data source and a loop into one expression, collecting commit messages from the GitHub API and dropping them into a scrollable list:
view [
text-list data collect [
foreach event load https://api.github.com/repos/red/red/commits [
keep event/commit/message
]
]
]The mechanics are worth noting because they explain the dialect approach. The layout is data, the collection is built by a word that keeps values from a loop, and the field access uses a slash path such as event/commit/message. A second version of that example is linked, where a click on a commit log opens the commit page.
The one rough edge named is running the GUI console under the Wine emulator, where it has known issues tracked as issue 1618. The fix given is not a rebuild but a font: install Consolas.
The newest tag is v0.6.6, while the documented banner still reads 0.6.5
The repository is not archived and its last push was on 2026-11-01, but the release history moves slowly. The newest tag is v0.6.6, named 0.6.6: Memory Management Improvements, published on 2025-03-19. Before it, v0.6.4 named Simple GC dates from 2018-11-22, and v0.6.3 named macOS GUI backend from 2017-07-18.
Those gaps set expectations. A gap of more than six years between v0.6.4 and v0.6.6 means a 32-bit alpha language with an unfinished concurrency story is the current state of the project, not a snapshot of an earlier one.
There is also a mismatch worth checking before you report a version anywhere: the console banner shown in the README reads Red 0.6.5, while the newest tag is v0.6.6. Treat 0.6.5 in that banner as documentation, not as the current release number.
Licensing follows the same honest pattern of dual files. The license identifier is BSL-1.0, and the tree carries BSL-License.txt next to BSD-3-License.txt, so read the text that matches your intended use rather than assuming either. The tree itself shows the pieces of the toolchain as directories, with encapper/, libRed/, runtime/, system/, modules/, environment/, bridges/, build/, utils/, quick-test/ and tests/, plus red.r and run-all-tests.r for running the suite.
Editorial conclusion
red is worth a look for someone who wants a homoiconic language with its own compiler and a GUI that arrives in the same download as the REPL, and who can accept an alpha stage, 32-bit only, target. Before writing anything beyond a script, check the two markers in the feature list: the concurrency work is marked not implemented yet, and the single file claim is footnoted as temporarily split in two binaries. Compile a throwaway hello.red with `redc -c` before committing to a workflow, and pick -r only when you need an executable with no dependencies.
Frequently asked questions
Is red a compiled language or an interpreted one?
Both are offered, and the feature list marks the JIT half as not implemented yet. The toolchain ships an interpreter and a native compiler, and redc compiles source with -c in development mode or with -r for an executable with no dependencies.
Do I need to install anything to run red?
No install and no setup is the stated design: a single file of roughly 1MB carries the whole toolchain, the standard library and the REPL, and you run it from a shell or by double-clicking it on Windows. That single file is currently footnoted as temporarily split in two binaries.
Can red do concurrent work with actors today?
The feature list promises concurrency and parallelism through actors and parallel collections, but that entry carries the marker for not implemented yet, so it should not be planned around in current versions.
How do I compile a red script into a standalone executable?
Rename the toolchain binary to redc, put it in the working folder, then run redc -c hello.red for an executable that uses libRedRT in development mode, or redc -r hello.red for one with no dependencies. The -c, -r and -u options are mutually exclusive, and cross-compilation uses -t with Windows, Darwin or Linux-ARM.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/red-red)Star history chart for your README
[](https://hysenlabs.com/projects/red-red)Was this useful?