Raku++ An interpreter, a compiler and a toolchain for Raku

The shop floor

Five ways to run the same language

One implementation, five shapes, and the semantics do not change between them: the browser engine is the command-line interpreter compiled with Emscripten, and every standalone mode either carries that interpreter or transpiles the program it would have walked. Which one you want depends on what you are handing to whom.

The three standalone modes all shell out to a C++ compiler when you build, and none of them needs one afterwards. --bundle and --aot run at interpreted speed, since the interpreter is still what walks the program; --exe is the one that removes it.

The goods

What you get for learning it

Seven of them, anyway — the ones that fit on a page. Each is something Raku has in the language, where most others send you to a library, a code generator or a workaround, and each is runnable right here. The tour and the specification cover the rest.

multi greet(Int $n)              { "the number $n" }
multi greet(Str $s)              { "the string '$s'" }
multi greet(@list)               { "a list of {@list.elems}" }
multi greet(Int $n where $n < 0) { "a negative number" }

say greet($_) for 42, "hi", [1, 2, 3], -7;

grammar INI {
    token TOP     { \n* <section>+ }              # a blank line is only ever more
    token section { '[' <name> ']' \n+ <pair>* }  # newlines: \n* before the first
    token name    { <-[\]]>+ }                    # section, \n+ under a header,
    token pair    { <key> '=' <value> \n* }       # \n* after any pair
    token key     { \w+ }
    token value   { \N+ }
}

# a heredoc: the indentation of the terminator is stripped from every line
my $config = q:to/CONFIG/;
    [server]
    host=example.com

    port=8080

    [limits]
    timeout=30
    retries=3
    CONFIG

for @(INI.parse($config)<section>) -> $s {
    say "[$s<name>] " ~ $s<pair>.map({ "$_<key> = $_<value>" }).join(', ');
}

my @powers = 1, 2, 4 ... *;
say @powers[^10];

say (1..∞).grep(*.is-prime)[^8];

my @triangular = [\+] 1..*;         # running sums of an endless list
say @triangular[^8];

say 0.1 + 0.2 == 0.3;

say (1/3).nude;      # numerator and denominator, exactly
say 1/3 + 1/6;
say (2/3).raku;

my $n = 42;

say so $n == any(3, 42, 100);
say so $n  > all(1, 2, 3);
say so "camelia" ~~ all(/a/, /e/, /l/);

my @r = 1, 2, 4, 8;

say [+] @r;          # reduce with +
say @r »*» 2;        # apply * to each
say [\+] @r;         # running totals
say (1..5).map(* ** 2);

say "Zoë".chars;              # graphemes, not bytes or code points
say "👨‍👩‍👧".chars;              # one family, one character
say "ß".fc eq "SS".fc;        # real case folding
say "π".uniname;
say so "Ωμέγα" ~~ /^<:Script<Greek>>+$/;

And roles, phasers, custom operators with their own precedence, native types, a bignum tower, promises and channels, NativeCall into C. The tour walks through them in about an hour; the specification is the reference.

The party trick

Interpreters all the way down

The playground's dropdown carries five complete interpreters for other languages, each one written in Raku. Pick the Python one, put a Python program in the standard-input box and press Run: what answers you, in a second or so, is three interpreters stacked on top of each other inside a browser tab, with no server anywhere in the picture.

1. fizzbuzz.py your Python program, typed into the input box
2. is parsed and executed by
3. python.raku a Python 3 interpreter — 1,472 lines of Raku
4. which is itself parsed and executed by
5. Raku++ a Raku interpreter, written in C++17
6. compiled ahead of time to
7. WebAssembly running in the tab you are reading this in, with no server behind it

Every name above is a link: it opens the playground with that interpreter loaded and a program already in the input box, and runs it.

Run a Python program on it →

They are not toys built to look good on a landing page: each one is a mid-size program that exercises a different corner of Raku — grammars and a tree-walking evaluator, a full precedence ladder, sigil variables and context, an INDENT/DEDENT tokenizer — and each was written partly to find bugs in Raku++, which it duly did. The long version, with where every millisecond goes: Interpreters all the way down.

The numbers

What it costs to run

Cold start is about 2 ms — best of a 200-spawn loop, 1.8 ms — because there is no VM to bring up first. After that, the same program can be interpreted or compiled with --exe, and what compiling is worth depends entirely on what the program spends its time doing: nothing at all on one of the nine benchmarks, 9.6× on another. Best of six runs, process start included; lower is better.

Appending to a string with ~= appends in place in every mode, so building a large string is linear rather than quadratic work. The browser engine is the same interpreter again, and lands within 1.3–6.8× of the native interpreter on these kernels. All nine benchmarks, the machine they were measured on, and the method: BENCHMARKS.md.

More than one core

Threads that actually use them

start and await, promises, supplies, channels and react { whenever … } — the same shapes as the reference implementation. By default worker threads coordinate under a global lock, which keeps shared state honest; RAKUPP_PARALLEL=1 lifts it and lets independent work actually run at once.

my @results = await (^4).map: -> $n {
    start { (1 .. 300_000).map({ $_ * $n }).sum }
};
say @results.sum;

Speed-up over the same work in a plain loop, on a contention-free fan-out. Change the shape and the number changes with it: four threads hammering one shared counter give 1.45×, because the process is in the kernel arbitrating rather than computing — which is exactly why the method page insists you report the thread count beside the ratio. This is also the one section here you cannot try in the editors above: a browser tab runs the interpreter single-threaded.

What you can build with it

Servers, not just scripts

Asynchronous sockets are in the box: IO::Socket::Async for clients and servers, signal() for a shutdown that closes cleanly, and TLS through IO::Socket::Async::SSL when the system has an OpenSSL to talk to. A server is a react block.

react {
    whenever IO::Socket::Async.listen('127.0.0.1', 15480) -> $conn {
        whenever $conn.Supply(:bin) -> $data {
            await $conn.write("echo: ".encode ~ $data);
            $conn.close;
        }
    }
}

$ printf 'hello' | nc 127.0.0.1 15480
echo: hello

Each of these is a real program in the repository, and each compiles to a standalone binary with --exe. The tiles link to the source on GitHub — these are programs to read and run yourself, not demos running somewhere:

All of them, with what each one is meant to prove: the showcase directory. The networking guide — clients, servers, graceful shutdown, HTTPS — is NETWORKING.md.

What else is in the binary

It is a toolchain, not just a runtime

A linter, a syntax highlighter, an AST dump, a profiler and a native compiler — in the one executable, with no plugins to install and nothing to configure. Every transcript below is real output from this version.

$ rakupp --lint app.raku
app.raku:2: warning: '$n' is declared but never used [unused-variable]
app.raku:3: warning: condition is a constant; the branch never runs [constant-condition]
app.raku:4: note: 'return' as the final statement is redundant; the block's last value is returned automatically [redundant-return]
rakupp --lint: 2 warnings, 1 note in app.raku

$ rakupp --highlight --ansi -e 'my $x = 42; say "x is $x";'
my $x = 42; say "x is $x";

$ rakupp --highlight --html -e 'my $x = 42; say "x is $x";'
<div class="highlight"><pre><span></span><span class="k">my</span> <span class="nv">$x</span> = <span class="mi">42</span>; <span class="nb">say</span> <span class="s">&quot;x is $x&quot;</span>;</pre></div>

$ rakupp --ast -e 'say 1 + 2 * 3'
Program
  Call say
    Binary +
      IntLit 1
      Binary *
        IntLit 2
        IntLit 3

$ rakupp --exe hello.raku -o hello
Compiled (native) hello.raku -> hello

$ ls -lh hello
-rwxr-xr-x  9.3M  hello

Also in there: --profile, which prints a routine-level wall-time profile after the run (or JSON, for a tool to read); --bundle and --aot, which produce standalone binaries that carry the interpreter rather than replacing it; and the perl one-liner family — -n, -p, -a, -i.bak — which cluster the way you expect. CLI.md is the full list; the install page has the short one.

Take one home

Install it

One binary, no runtime to install beside it, no package manager required if you would rather not use one.

brew tap ash/rakupp
brew install rakupp

rakupp program.raku
rakupp -e 'say (1..100).grep(*.is-prime).sum'
rakupp -ne '.say if /error/' server.log

Self-contained archives for macOS (universal), Linux (x86-64, static) and Windows (x64, static CRT) are on the releases page; there are also Guix and Nix channels, and it builds from source with CMake and any C++17 compiler — no third-party libraries.

Other people's code

The ecosystem comes with it

Raku++ reads the same installation store zef populates. There is no separate registry, no re-packaging and no rakupp-flavoured fork of anything: a distribution installed once is what use picks up, unmodified. zef itself runs under Raku++ end to end, too.

zef install JSON::Fast

use JSON::Fast;
say to-json({ name => 'Ada' }, :!pretty);   # {"name":"Ada"}

use XML;
say from-xml('<r><i>hi</i></r>').elements[0].contents[0];   # hi

use MIME::Base64;
say MIME::Base64.encode-str('raku');        # cmFrdQ==

That set is also where a great many of this release's fixes came from: running other people's tests finds what a suite written alongside an implementation never will. The per-distribution picture, including what is still failing and why, is in the roadmap; the how-to is on the install page and in MODULES.md.

Take it with you

Put a running Raku editor on your own page

One script tag. Your readers get a real interpreter in their own browser, and you get nothing to run, host or pay for.

<script src="https://raku.online/raku.js"></script>

<pre data-raku>say "Hello from someone else's website!";</pre>

Which renders exactly this — and it runs:

say "Hello from someone else's website!";

Already have <pre><code class="language-raku"> blocks from a highlighter? Add data-auto to the script tag and they become runnable with no other change. The builder turns pasted code into a snippet to copy; the demo page shows every pattern side by side; the guide lists the options. The largest example is this site: the tour, the drills and the specification all run their examples through the same script.

The rest of the shop

Learn it, and look things up

Its code samples are syntax-highlighted by Raku++, and it sends its readers here to run them. What follows is the shorter material, on this site.

The label on the tin

What this is, and how it is counted

How each of those is counted, including what deliberately does not count: COUNTING.md. The live picture, release over release, is on the conformance pages and the dashboard. Where a feature behaves differently here than the specification describes, the page for that feature says so in as many words.

Open the playground Start the tour Install it