September 27, 2013

0.4.0: Red goes binary!

What's that?!

As we are getting closer to the end of the alpha period, we are now moving to a more convenient way to use and distribute the Red toolchain. So far, you needed to download a Rebol interpreter and the sources from Github separately, and run it using, a bit verbose, command-lines. This is fine for developping Red  with contributors that are interested in the inner workings of the toolchain, but for the end users, the goal has always been to provide a simpler and much more convenient way, like Rebol teached us in the past.

So, from now, you can get Red as a single binary (< 1 MB) from the new Download page. Yes, all of Red toolchain and runtime is packed in that small binary, even the REPL is built-in!

The Red repo landing page has been reworked to show Red usage in binary form, all previous command-line options are present, a new one (-c) has been introduced. Here is a short overview of the main options:

Launch the REPL:
    $ red 
Run a Red script directly (interpreted):
    $ red <script>
Compile a script as executable with default name in working path:
    $ red -c <script>
Compile a script as shared library with default name in working path:
    $ red -dlib <script>
Compile a script as executable with alternative name:
    $ red -o <new> <script>
Compile a script as executable with default name in other folder:
    $ red -o <path/> <script>
Compile a script as executable with new name in other folder:
    $ red  -o <path/new> <script>
Cross-compile to another platform:
    $ red -t Windows <script>
Display a description of all possible options:
    $ red -h
Notice that -c option is implied when -o or -t are used. It is designed to keep command-lines as simple and short as possible.

Moreover, for standalone Red/System programs, the Red binary will be able to compile them directly, no special option needed, they will be recognized automatically.

Thanks very much to Tamás Herman for helping with setting up the build farm and providing the Mac OSX machine, and thanks to the HackJam hackerspace group from Hong-Kong for the hosting!

Other changes

  • In addition to that new binary form, 17 issues have been fixed since the 0.3.3 release about a month ago (not counting regression tickets).
  • The work on objects support is half-done, objects are working fine with advanced semantics on the interpreter (see object branch), now the focus will be to support them at the Red compiler level.

What's next?

As we are moving closer to the beta state, version numbers will increase faster, e.g., once objects will be done, the release will be the 0.5.0, while 0.6.0 will bring full I/O support. Between these major versions, smaller versions should be still possible, this means that the release cycle should accelerate with at least one release each month from now on. So, what you should expect in the next ones?

  • Simple I/O support: (just read, write and exists? on files)
  • PARSE support
  • Pre-compiled runtime (much faster compilation times)
  • Full object support
  • VID-like cross-platform dialect binding to native widgets.
  • Mezzanine functions additions
  • Redbin (accurate Red values serialization in binary format)
  • Full errors management
  • Red-level exceptions handling



  1. Congratulations with this next big step!

  2. Nice!!
    It will be a huge progress after 0.4!

  3. Some pieces of both GC and concurrency support should be available before 0.7.

  4. Although I've only personally worked with Red/System so far, I'm excited about the advancements!

  5. Fantastic news. Congratulations Nenad.

  6. Gregg: thank you very much!

    Hi Jaime, long time no see! I'm glad that you are following the Red project. :-)

  7. Will you build Red-VID using Meta-DSL Framework? You mentioned Meta-DSL Framework in Recode Conference 2013.

  8. I would like to, but building the meta-DSL framework would delay the rest too much. I'll try to add a basic version of such framework for the 1.0 version, if time permits.

  9. In the next release of RED binary, have you planned to add some command like : help, etc... ?

  10. Will there be a run-time penalty for the meta-DSL capabilities? I have talked about REBOL in the past and learned that parse is not something that expands at read time(like LISP macros). You mentioned it will be higher level than parse so I was just wondering what ti would be like.

  11. @Jeannot: we have a prototype HELP command, but it's not ready for primetime yet and next release should happen tomorrow, so probably in one of the later releases. I'm getting in touch with the contributor working on those parts to see if it could be ready for tomorrow.

  12. @Jacob: DSLs in Red and Rebol do not have to run on PARSE. When you implement a DSL, you can choose to implement it as an interpreter (in which case you have PARSE running underneath), or as a compiler (PARSE just runs as a front-end then and generates Rebol or Red code that runs directly). The choice is in the hands of the programmer, but in both cases, currently, you have a significant work to do and not everyone is comfortable writing an interpreter or a compiler, even for a trivial DSL.

    The meta-DSL capabilities I have mentioned in my Red slides is a layer above PARSE dialect that aims at simplifying that part for programmers. It's not designed in details yet, but you can picture some higher-level commands for linking easily the grammar rules for parsing the DSL with the execution blocks (interpreted or compiled).


Fork me on GitHub