DEV Community: Andrew Shitov

Raku: a language that speaks Unicode

Andrew Shitov — Sun, 09 Aug 2026 17:58:02 +0000

Raku is by design a language that supports Unicode.

So, yes, Unicode is special for both Raku and Raku++. This all starts from the visible surface, like when you can type Greek letters and use math symbols — even easier than you do it in LaTeX (in case you know how to type in non-ASCII characters).

say τ;                       
say ∞ > 10⁹⁹;

my \φ = (1 + sqrt 5) ÷ 2;
say φ;

say 2⁵;
say 5 ∈ (2, 3, 5, 7);

sub prefix:<∑>(@a) { [+] @a }
say ∑(1, 2, 3);

You can run this program in your browser to see how it works using the Raku.js playground. You can also change it a bit to try other things.

The above program was mostly about the characters that are available in the source code. But behind it, Raku knows the internal rules of the Unicode datasets, and the current Raku++ version comes with the embedded UCD 17 tables (Unicode Character Database). They are simply built in the source code, so all happens naturally.

my $family = "👨‍👩‍👧‍👦";
say $family.chars;    # 1   — one grapheme
say $family.codes;    # 7   — seven code points
say "noël".flip;      # lëon — the ë survives reversal
say "🇺🇦🇵🇱".chars;    # 2   — flags don't split

The distinction between the number of codes and characters is mostly visible as soon as you leave the ASCII space. What's beyond it, it's the whole Universe of different rules, collations, normalisations, names, properties, etc.

The good thing is that you do not need to think about all those Unicode internals when just using Raku and when just working with text. For example, converting to upper case has no difference in the code for "street" and "straße".

say "straße".uc;  # STRASSE — one char becomes two
say "ﬃ".uc;      # FFI     — ligature expands
say "🐋".uniname; # WHALE

Diacritics are difficult because a single character (glyph) can be represented differently: say, as two distinct items for the letter and the accent, as well as as a single Unicode entry point. For Raku, it's not difficult at all.

say "e\x[0301]" eq "é"; # True — NFG normalizes on creation
say "é".NFD.list;       # (101 769)
say "é".NFC.list;       # (233)

If you know that Unicode has literally hundreds of characters marked as digits, you may also want to use similar nice characters in the programs. Unicode fractions, Roman numbers, all that has it's meaning and can even be used in place of Arabic digits.

say "½".unival + "⅓".unival;  # 0.833333
say "Ⅻ".unival;              # 12
say "五".unival;              # 5

If you ever learned Greek, you may remember that letter S looks differently depending on the position of the word. Raku knows it out of the box; the final lowercased sigma looks differently indeed:

"ΣΊΣΥΦΟΣ".lc.say # prints σίσυφος

Characters names and properties, even weird, are reachable with ease.

say "\c[ORCA]".uniprop("Age"); # 17.0

Regexes (and thus grammars) are no exception.

say "abc🐋def" ~~ /<:Emoji>/; # ｢🐋｣

A couple of words about Raku++. The first phase of its development was to target the compiler against Roast, which is a huge official test suite of the Raku programming language. In total, Roast includes about 90k tests in the Unicode sections. All of them pass under Raku++. Actually, having proper support of UCD 17 helped to jump from 57% to 82% of Raku coverage, just so huge it is.

And before wrapping up, some homework for you. Below are two variants of the program that solves quadratic equations and — what is important for us today — uses a lot of non-ASCII characters. Well, and some other useful Raku features such as custom operators and junctions.

Variant 1:

sub prefix:<√>($x) {
    $x.sqrt
}
sub infix:<±>($p, $q) is equiv(&infix:<+>) {
    ($p + $q), ($p - $q)
}

my (\a, \b, \c) = 1, -4, 3;
if (my $D = b² − 4 × a × c) ≥ 0 {
    my @roots = (−b ± √$D) »÷» (2 × a);
    say @roots;
}
else {
    say "There are no real solutions";
}

Variant 2:

sub prefix:<√>($x) {
    $x.sqrt
}
sub infix:<±>($p, $q) is equiv(&infix:<+>) {
    ($p + $q) | ($p - $q)
}

my (\a, \b, \c) = 1, -4, 3;
if (my $D = b² − 4 × a × c) ≥ 0 {
    my $roots = (−b ± √$D) ÷ (2 × a);
    say $roots;
}
else {
    say "There are no real solutions";
}

First try to understand what the programs will print, and then run them in the playground. The first variant uses regular arrays to save results, but the in the second program $root is a scalar and it's a junction that keep both roots at the same time.

Raku: a Language Where 0.1 + 0.2 is 0.3

Andrew Shitov — Sat, 18 Jul 2026 11:48:53 +0000

Programming languages are fascinating. Even if you think that these are the last days when you need to write code yourself, that only gives you more time to enjoy the beauty.

In this article I would like to showcase some of the small but astonishing features of Raku. Even if you never had a chance to install a compiler on your machine, you can run all the examples below in the online Raku playground straight away.

0.1 + 0.2 == 0.3

It is an obvious equation when written on paper, but when you employ floating-point arithmetic, you get a collection of various answers – the price of the trade-off between speed, compactness, and exactness.

In Raku, 0.1 + 0.2 equals 0.3 exactly:

say 0.1 + 0.2 == 0.3;   # True

Run it in the online playground to confirm. In the rest of the article, I will use links like this: 🦋▶ to point you to the playground with the code filled in. All you need is to press the Run button and see the magic.

Similarly, 0.1 + 0.2 - 0.3 is an exact zero. 🦋▶

All this is possible as Raku treats these numbers as belonging to the Rat (rational) type of numbers. 0.1 is a fraction 1/10. 0.2 is the same as 1/5. And while say 1/3 does print a rounded 0.333333, that is only the display: underneath lives the exact ⅓, with the numerator and the denominator in easy reach 🦋▶:

say ⅓.numerator;    # 1
say ⅓.denominator;  # 3

And yes, Unicode fractions are understood, together with any kind of digits 🦋▶:

say ⅷ + ٣;   # 11

The ⅷ here is a single Unicode character – the small Roman numeral eight – and ٣ is the Arabic-Indic digit three, the everyday three for hundreds of millions of people. Raku reads both as the numbers they are.

Superscripts are powers

Raise a number to a power the way your maths teacher wrote it 🦋▶:

say 2⁵;               # 32
say 5² + 12² == 13²;  # True

The second line is the 5–12–13 Pythagorean triple, checked in one readable line.

Integers have no ceiling

An integer in Raku is as long as it needs to be. There is no 64-bit cliff to fall off, no special "big integer" import – the numbers simply grow 🦋▶:

say 2¹⁰⁰;         # 1267650600228229401496703205376
say 10¹⁸ × 10¹⁸;  # 1 followed by 36 zeroes
say [*] 1 .. 100;

The square brackets in the last line are the reduction meta-operator: [*] places * between all the numbers of the range, so you get the factorial of 100 – all 158 digits of it:

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Primality included

Number theory is on board too 🦋▶:

say 97.is-prime;          # True
say (2¹²⁷ − 1).is-prime;  # True

The second number is a Mersenne prime of 39 digits, tested as casually as the small one. Notice the minus sign in 2¹²⁷ − 1: it is not the ASCII hyphen but the true Unicode minus, and Raku is perfectly happy with either.

Operators from the maths textbook

Superscripts are not the only notation rescued from the maths textbook. The multiplication and division signs, and the comparison signs with the slash already crossed through, are all ordinary Raku operators 🦋▶:

say 7 × 6;      # 42
say 10 ÷ 4;     # 2.5
say 1 ≤ 2 ≤ 3;  # True
say 2 ≠ 3;      # True

× and ÷ are the real multiplication and division operators (the ASCII * and / work too, of course). Comparisons chain the way they do in mathematics: 1 ≤ 2 ≤ 3 is a single condition, not a syntax error. And 10 ÷ 4 is the familiar Rat story again – the exact fraction 5/2, whose decimal display 2.5 this time needs no rounding at all.

Chaining also combines with the reduction meta-operator you met at the factorial: put ≤ between the square brackets, and [≤] chains it across every neighbouring pair of a list – a ready-made test that the list is sorted 🦋▶:

say [≤] 1, 2, 5, 9;  # True
say [≤] 3, 1, 2;     # False

π, τ, and ∞

The constants you know from school are predefined 🦋▶:

say π;           # 3.141592653589793
say τ == 2 × π;  # True

(Type pi and tau if the Greek letters are far from your keyboard.) Infinity is a value in its own right: you can compare things with it, and you can build a range of all positive integers and politely take the first five 🦋▶:

say ∞ > 10¹⁰⁰;     # True
say (1 .. ∞)[^5];  # (1 2 3 4 5)

The range is lazy, so nobody attempts to materialise the rest of it.

And when you do want floating point

Floats did not go anywhere – you ask for them with scientific notation 🦋▶:

say 0.1e0 + 0.2e0;  # 0.30000000000000004

0.1e0 is a Num, an honest IEEE double, and with it comes the famous constant from the beginning of this article. Floats remain the right tool for physics and simulations; Raku simply refuses to make them the default meaning of a decimal literal.

Where this runs

Every example above runs in the raku.online playground, which is powered by Raku++, an independent implementation of Raku compiled to WebAssembly – the interpreter works entirely in your browser page. The reference implementation of the language is Rakudo, and everything shown here prints exactly the same on both.

The next article in this series opens the second cabinet of curiosities: Unicode – strings that count a seven-codepoint emoji as one character, a variable named $Δ, and a file called café-☕.txt.

Sorting numbers in Raku with the help of ChatGPT

Andrew Shitov — Fri, 08 Sep 2023 07:57:21 +0000

In this post I will show you the solution to the Task 2 of this week’s Weekly Challenge 233. This time I was using the help of ChatGPT, which offered a very nice solution.

You are given an array of integers.
Write a script to sort the given array in increasing order based on the frequency of the values. If multiple values have the same frequency then sort them in decreasing order.

I asked ChatGPT the following: ‘Create a program. Here is the description of the task.’ To make sure the result is in the Raku programming language, I also added the following instruction in my local settings so that it knows which programming language I prefer by default.

The solution generated by ChatGPT was quite good with a small mistake.

ChatGPT: Sure, here’s a Raku program that implements the described sorting algorithm for the given task:

sub frequency-sort(@arr) {
    my %freq;

    %freq{$_}++ for @arr;
    my @sorted = @arr.sort: {
        %freq{$^b} <=> %freq{$^a} ||
        $^b <=> $^a
    };

    return @sorted;
}

my @ints = (1, 1, 2, 2, 2, 3);
my @sorted = frequency-sort(@ints);

say "Input:  @ints";
say "Output: @sorted";

First, Raku would not interpolate arrays, so say "Input: @ints" prints the string literary: Input: @ints. Second, in the sorting rule, sorting by frequency must be ascending rather than descending, so we need to switch the placeholder variables $^b and $^a.

In the rest, ChatGPT did a good work. It computed the frequency using a loop, and I especially liked how it addressed the requirement to sort by two dimensions.

Here is the full program with the above-mentioned corrections:

sub frequency-sort(@arr) {
    my %freq;
    %freq{$_}++ for @arr;

    my @sorted = @arr.sort: {
        %freq{$^a} <=> %freq{$^b} ||
        $^b <=> $^a
    };

    return @sorted;
}

my @tests =
    (1, 1, 2, 2, 2, 3),
    (2, 3, 1, 3, 2),
    (-1, 1, -6, 4, 5, -6, 1, 4, 1);

say frequency-sort($_) for @tests;

This program prints the following output for the given test cases:

$ raku ch-2.raku
[3 1 1 2 2 2]
[1 3 3 2 2]
[5 -1 4 4 -6 -6 1 1 1]