Sommaire
À propos de Raku
Préambule
Raku est (devenu) bien trop « différent » de Perl 5. On peut à présent dire tout simplement « Perl » pour désigner Perl 5 ou Perl 7 et on préférera « Raku » en toutes circonstances pour parler de Perl 6. Il fut un temps où la communauté Perl 6 était plutôt contre le changement de nom, mais l’opinion générale a changé et le renommage a pu se faire en douceur entre 2018 et 2019 (voir plus loin pour les détails).
Vous pouvez suivre l’actualité du langage en vous abonnant à la newsletter Rakudo Weekly News.
Raku possède une petite communauté et quelques « killer apps » :
-
Cro, une boîte à outils pour le Web (applications, services) ;
-
Sparrow un cadriciel d’automatisation, ainsi que ses modules ;
- son IDE « Comma » ;
- un (petit) CPAN.
Avant d’aller plus loin, voici quelques liens vers des contenus LinuxFr.org autour du même sujet :
Une fois n’est pas coutume, parlons un peu de Raku, sa communauté et ses « news » :D.
Quelques personnalités importantes du monde Raku
Avant de rentrer plus en détail dans le processus de renommage et dans les versions de Raku, mettons à l’honneur quelques personnalités du monde Raku :
-
Jonathan Worthington : Lead développeur actuel de Rakudo (interview Jonathan Worthington)
-
Elizabeth Mattijsen : très impliquée dans Perl 6 ;
-
Patrick Michaud : ancien lead développeur de Rakudo, NQP, etc. ;
-
Audrey Tang : actuellement ministre du numérique à Taïwan (!), anciennement développeuse principale de Pugs (implémentation de Perl 6 en Haskell, voir vieille interview ou encore cette interview) ;
-
Damian Conway : enseignant, orateur, porte‑parole et développeur prolifique ;
-
Larry Wall : créateur de Perl (BDFL) et initiateur de Raku. Plus besoin de le présenter ! En 2020, plus vraiment impliqué ;
-
Moritz Lenz : écrivain et gros contributeur ;
-
Flavio S. Glock : développeur principal de Perlito.
Tous ne sont pas encore actifs et la liste n’est pas exhaustive !
La communauté Raku a décidé récemment de mettre en place un comité décisionnaire.
Le processus de changement de nom : Perl 6 → Raku
Un langage de programmation qui change de nom, ça n’arrive pas souvent !
Il y a peu, Raku a donc fêté sa première année (ou ses 21 ans !). Voici comment s’est déroulé le renommage :
- Larry Wall a tout d’abord proposé un alias ;
- alias demandé par des personnes de la communauté Perl 6 ;
- validé ensuite par Larry à la conférence Raku à Riga ;
- plus tard, une des membres de la core team (Elizabeth Mattijsen) ouvre un ticket sur le GitHub officiel de Raku pour un renommage :
- Elizabeth ouvre ensuite une demande d’intégration sur le dépôt Git officiel de Raku (avec demande de vote des mainteneurs) :
- les votes sont positifs (ou des abstentions), puis vient la « bénédiction » de Larry Wall :
- renommage entériné, souhaitons la bienvenue à Raku !
Le processus de renommage en liens :
Versions de Raku(do)
Depuis 2015, l’implémentation de Raku est « complète » et les travaux autour du compilateur et de la VM sont plus orientés vers les performances.
Raku a connu plusieurs versions officielles (dont la plus « marquante » était en 2015) :
- première version publique de Rakudo * en juillet 2010 (version majeure mais incomplète, encore basée sur Parrot donc Rakudo + Parrot) ;
- 6.c « Christmas » en 2015 (annonce) (Rakudo + MoarVM) ;
- 6.d « Diwali » en novembre 2019 (détails des nombreux changements) (Rakudo + MoarVM) ;
- 6.e sera la prochaine version majeure (Rakudo + MoarVM).
D’où provient ce schéma de versions ?
Tout simplement d’une blague récurrente sur la date de sortie de Raku. Il était coutume de répondre « ça sera prêt pour Noël » comme une blague ou une pirouette :D En plus de ces versions majeures, l’équipe derrière Raku produit des versions mineures mensuelles.
Quelques livres
Avant d’attaquer les détails du langage, voici quelques livres qui vous permettront d’en apprendre plus sur Raku :
La partie technique commence ici, vous êtes prêts ? :D
Les qualités intrinsèques de Raku
On ne se refait pas ! Grâce aux qualités de linguiste de son créateur Larry Wall, Raku est très influencé par le langage naturel. Raku est multi‑paradigmes (procédural, fonctionnel, programmation concurrente et orienté objet).
Comme son cousin Perl 5 :
- c’est un langage riche et qui a une notion de « contexte » ;
- ses expressions rationnelles sont très puissantes et il intègre même une gestion des grammaires directement dans le langage !
- il possède un CPAN.
Contrairement à lui :
- l’interfaçage avec le code natif est très simple ;
- la programmation orientée objet est native (cadriciel + types objets) ;
- le langage est résistant à la concurrence ;
- Unicode est pris en charge « par défaut ».
Pour des détails techniques supplémentaires, voici le glossaire de Raku mais également une comparaison des fonctionnalités entre les compilateurs (qui donne un bon aperçu des fonctionnalités du langage). Dans les prochains paragraphes, les qualités/fonctionnalités de Raku seront expliquées plus en détail.
Le typage
- Typage graduel (typage dynamique et statique) :
# Dynamique
my Cool $var = 42;
# Statique
my Str $var = "Raku";
- Annotation dans les signatures :
sub ab(Int $a, Int $b) { return $a+$b; };
say ab(1,1);
- Inférence de type
- Allomorphs (et évaluation polymorphique) :
IntStr $foo
- Les jonctions :
my $jonction = 1|2|3;
$jonction += 4; # jonction maintenant égale à 5|6|7
$jonction += (1&2); # jonction maintenant égale à (6|7|8)&(7|8|9)
-
Sous‑ensembles : permet d’étendre les classes isomorphes, servir de contrainte, tout en étant résolu à l’utilisation :
subset Even where * %% 2;
say 1 ~~ Even; # False
sub i-cast(Int() $n) { say $n.^name } ;
i-cast "42";
Contrainte + coercition (« je veux un objet chaîne et je caste en objet entier ») :
sub f(Int(Str) $want-int, Str() $want-str) { } ;
f '10', 10;
Ou contrainte conditionnelle (« mon argument doit être objet entier ou objet chaîne ») :
sub xyz($n where $_ ~~ Int | Str ) { say +$n }
my int8 $verysmall = 42;
say $verysmall;
- Auto‑boxing : conversion automatique de type natif vers les types objets
- Auto‑vivification dans les hash/arrays :
my %a;
%a{'autovivication'}++;
say %a{'autovivication'};
my @list = (1, 1, * + * ... *).grep({ $_.is-prime });
say @list[4]; # This generates elements 0..4.
# Elements 5..∞ haven't been generated yet
Routines
sub plus2($foo) { return $foo+2; }
sub mul3(Int $foo) { return $foo*3; }
- Avec attribut rw ou copy :
sub make42($foo is rw) { $foo = 42; }
multi sub sayit( Int $n ) { say "Number: $n"; }
multi sub sayit( Str $s ) { say "String: $s"; }
Le dispatch se base sur le nombre d’arguments, les types, les contraintes (on peut même en jouer avec les fonctions nextsame, nextwith, callsame, callwith). Voir aussi « Proper narrowness analysis » pour la résolution du meilleur candidat.
- Gobage gourmand des arguments restants et aplatissement des arguments (comme en Perl 5).
Opérateurs
- Raku possède une grande quantité d’opérateurs, voyez plutôt :
- Raku peut être facilement étendu (voir doc opérateurs) ;
- opérateurs natifs (inline optimisations ou explicite) ;
- les opérateurs peuvent être en UTF‑8 ;
-
opérateurs natifs.
Async, parallélisme et concurrence
Une boîte à outils plus que complète de fonctionnalités pour gérer l’asynchrone, le parallélisme et la concurrence :
Programmation Orientée Objet et Programmation Meta Objet
Possibilité de définir ses propres opérateurs (vu plus haut) et fonctionnalités. La prise en charge du meta object programming est gérée en partie dans la machine virtuelle :
Grammaires
Une gestion des grammaires (grammar, token, rule, regex) dans le langage !
grammar Calculator {
token TOP { }
proto rule calc-op {*}
rule calc-op:sym { '+' }
rule calc-op:sym { '-' }
token num { \d+ }
}
class Calculations {
method TOP ($/) { make $<calc-op>.made; }
method calc-op:sym ($/) { make [+] $<num>; }
method calc-op:sym ($/) { make [-] $<num>; }
}
say Calculator.parse('2 + 3', actions => Calculations).made;
Interfaçage
La prise en charge du langage natif est vraiment très facile !
- Interfaçage facile avec les langages natifs (Native Call) :
use NativeCall; sub fork() returns int32 is native {};
use Inline::Perl5;
my $p5 = Inline::Perl5.new;
$p5.call('print', 'Hello World');
$p5.use('Test::More');
$p5.call('Test::More::plan', tests => 1);
Unicode traité au niveau graphème
Très haut niveau de gestion d’Unicode, notamment grâce à des primitives dans la machine virtuelle MoarVM.
Les opérateurs du langage eux‑mêmes peuvent être en UTF‑8 (comme ceux que l’on crée).
Autres fonctionnalités en vrac
my $cube = -> $x {$x ** 3};
say $cube(3); # 27
Par ordre alphabétique :
my $pow = {$^x ** $^y};
say $pow(3, 4); # 81
Ou alors :
for 0..9 {
say "$^n2, $^n1";
}
Ou avec nommage :
my $pow = {$:base ** $:exp};
say $pow(:base(25), :exp(2)); # 625
Compilateurs, cadriciels et machines virtuelles
Dans cette seconde partie, nous allons détailler les mises en œuvre du langage Raku. Préparez‑vous, les acronymes arrivent !
Licence Creative Commons CC0 1.0
Quelle implémentation « officielle » ?
Réponse courte : Rakudo et MoarVM.
Au départ il fut décidé qu’aucune implémentation ne serait définie comme « officielle » pour Raku mais plutôt que « Raku est quelque chose qui réussit la suite de tests officiels ». En réalité, depuis 2012, il existe une implémentation officielle de facto qui est Rakudo + MoarVM.
Avant ça, il y eut le cadriciel Parrot (2002 - 2012) ainsi que Pugs (2005 - 2007) ou encore divers autres compilateurs et environnements d’exécution (Mildew, Niecza, Yapsi…). Cette partie technique et historique sera abordée en fin de dépêche. Mais revenons en arrière pour parler des débuts.
La toute première annonce de la création de Raku date du 19 juillet 2000. L’idée de Larry Wall était d’en faire un projet ultra communautaire jusque dans la conception du langage, et il commencera donc par demander de contribuer aux spécifications. Il en découlera en tout 361 RFC, dont Larry wall produira des apocalypses qui seront expliquées ensuite par Damian Conway dans les exégèses puis encore détaillées dans les synopses.
Des liens pour les historiens ou les curieux :
Parrot
Créés en 2002, le cadriciel et la machine virtuelle Parrot ont longtemps été au centre de l’implémentation de Raku (ce n’est plus le cas aujourd’hui). Parrot est né d’un poisson d’avril annonçant l’unification de Perl et Python et même la sortie prochaine d’un livre sur le sujet :
Pourquoi construire une nouvelle VM ?
La JVM fut étudiée en 2001, mais jugée peu adaptée aux langages dynamiques (elle ne l’était d’ailleurs toujours pas en 2010, quid de 2020 ?).
Compilation
Parrot offre bien plus d’une machine virtuelle, Parrot est un cadriciel de création, compilation et exécution de langage. Ce cadriciel permet de construire facilement et rapidement des langages de haut niveau (HLL). Il a été mis en pratique par Rakudo pendant longtemps.
PCT
PCT signifie Parrot Compiler Tools. Son but est de permettre la création de compilateur et d’environnement d’exécution de langages de haut niveau (HLL).
PCT est écrit en PIR (voir plus loin section assemblage).
PAST
PAST signifie Parrot Abstract Syntax Tree : représentation interne d’un arbre syntaxique.
HLL
HLL signifie High Level Language.
PGE
Au départ appelé P6GE, PGE signifie Perl Grammar Engine. Se base sur HLLCompiler. Une règle PGE ressemble à ça :
rule term { | \( \) }
rule number { \d+ }
rule expr { ( '+' )* }
PGE était utilisé par Pugs, un autre compilateur Raku (voir plus loin).
TGE
TGE signifie Tree Grammar Engine.
PACT
PACT signifie Parrot Alternate Compiler Toolkit. Une alternative à PCT qui était considéré comme trop limité.
Assemblage
PASM
PASM signifie Parrot assembly language (PASM). Le code bas niveau prêt à être converti et exécuté par Parrot VM. Du code PASM ressemble à ça :
set I1, 1
REDO:
gt I1, 10, END
print I1
print " "
inc I1
branch REDO
END:
print "\n"
end
Références :
IMCC
IMCC signifie Intermediate Code Compiler. C’est un outil alternatif pour créer et exécuter du bytecode Parrot.
IMCC apporte son propre langage, communément appelé Parrot Intermediate Language (PIR). IMCC embarque le l’environnement d’exécution Parrot, donc IMCC peut compiler du PIR vers PASM, puis du PASM vers PBC, puis exécuter ce bytecode. IMCC peut également faire des optimisations, même s’il ne le fait pas par défaut.
PIR
D’abord appelé IMC, PIR est une surcouche de PASM sans être pour autant un langage de haut niveau. Les fichiers contenant du code PIR portent le suffixe « .imc »
Voici à quoi ressemble PIR :
.sub loopy
.local int counter
counter = 0
LOOP: if counter > 10 goto DONE
print counter
print " "
inc counter
goto LOOP
DONE:
print "\n"
end
.end
Vous pouvez en apprendre plus grâce à cette intro IMCC ou cet article sur comment écrire du PIR. Voir ici des exemples PIR ou encore la documentation détaillée des mongueurs FR sur PIR.
Exécution
NCI
NCI signifie Native Call Interface.
PMC
PMC signifie PolyMorphic Container ou Parrot Magic Cookies (la façon de représenter les données dans la machine virtuelle).
PBC
BC signife Parrot Byte Code
La VM Parrot
La VM Parrot est une machine virtuelle à base de registre, ce qui n’est pas la « norme » (par exemple JVM).
Voici quelques fonctionnalités de la VM Parrot :
- capable de gérer les langages statiques et dynamiques ;
-
Copy On Write ;
- gère les continuations et closures ;
- peut être embarqué dans du code C ;
-
PolyMorphic Container (souplesse du stockage des types).
Il est facile d’inclure Parrot dans du code C ou d’appeler du C dans Parrot (Native Call Interface).
Implémentation Raku basée sur Parrot (2002 - 2012)
Ou avec une étape IMCC et Parrot fusionnée (plus tard car IMCC contient Parrot) :
Ci‑dessous un schéma encore plus détaillé/technique (tiré d’une documentation Parrot) :
De nombreux détails sont disponibles dans le Parrot Design Document.
Problèmes avec Parrot
Si au départ Parrot était au centre de Raku, cela a changé au cours du temps :
- 2008 : « While Parrot is the most solid solution to deploy Perl 6 in the long term, on the other hand, the challenges Parrot has accepted had proven to consume more time and resources than previously expected. » (Perl foundation news) ;
- 2013 : « The latest news is that Parrot Virtual Machine is no longer the only one enjoying Rakudo’s exclusivity. » (all about Perl 6) ;
- des problèmes de communication ;
- Parrot s’est petit à petit éloigné de Perl 6 (en devenant plus généraliste).
Petit à petit, le compilateur Rakudo s’est émancipé de Parrot et cible à présent une nouvelle machine virtuelle.
Rakudo Star (à partir de 2010)
La première version majeure de Rakudo Star (ou « Rakudo * ») se basait sur Parrot (PCT + ParrotVM), mais nous passerons sous silence cette version pour nous concentrer sur l’implémentation actuelle (Rakudo + MoarVM).
Compilation (Rakudo)
Rakudo est un compilateur pour Raku qui implémente la totalité du langage et peut cibler plusieurs différentes VM (la principale étant MoarVM). La majeure partie de Rakudo est écrite en Raku simplifié (NQP). Rakudo implémente également la précompilation pour optimiser ses performances. En plus de ça, Rakudo améliore l’arbre syntaxique à l’aide de plusieurs méthodes d’optimisations dont voici quelques exemples :
- les itérations range converties sont en boucles natives ;
- dé‑virtualisation de méthodes privées avec résolution à la compilation ;
- suppression de code (statiquement) mort ;
- anonymiser une variable ;
- réduire la portée d’une variable ;
- dépliage des jonctions.
NQP
NQP est un compilateur comme MiniPerl pour Perl 5. C’est un outil de bootstrapping qui aide à compiler les parties en Raku de Rakudo) et compiler les bibliothèques avant d’avoir compilé les bibliothèques. Contrairement à MiniPerl pour Perl 5 (qui est un interpréteur sans toutes les piles : c’est‑à‑dire sans les modules mélangeant code Perl et code natif), NQP ne sait compiler qu’un « Raku simplifié ». NQP designe aussi bien le compilateur que le code source contenu dans des fichiers portant l’extension « .nqp ». Du code NQP ressemble à ça :
method symtable() {
%!symbol := nqp::hash() if nqp::isnull(%!symbol);
%!symbol
}
method evaluate_unquotes(@unquotes) {
my $result := self.shallow_clone();
my $i := 0;
my $elems := nqp::elems(@(self));
while $i < $elems {
$result[$i] := self[$i].evaluate_unquotes(@unquotes);
$i := $i + 1;
}
$result
}
NQP fait partie de Rakudo et semble avoir été inspiré par MiniPerl6/KindaPerl6.
Exécution (MoarVM)
MoarVM signifie Metamodel On A Runtime VM (site officiel). C’est une machine virtuelle basée sur les registres comme Parrot. Jonathan Worthington est le fondateur et architecte de MoarVM.
Voici quelques caractéristiques de MoarVM :
- représentation interne plus proche de Raku (par rapport à Parrot) (« On the other hand, there are features that are hard to implement efficiently if the VM doesn’t support it. », d’après une interview de Flavio Glock) ;
- superbe gestion d’Unicode, avec les chaînes de caractères représentées au niveau graphème ;
- gestion de la programmation asynchrone et concurrente avec des structures de contrôles pour la programmation concurrente, les sockets synchrones, minuteurs, processus, sémaphores, files bloquantes, etc.
- ramasse‑miettes précis, générationnel (jeunes → semispace et vieux → gros buckets) et gérant la concurrence ;
- capable de gérer les continuations ;
-
bounded serialization, sérialiser le code des modules chargés pour plus tard et gagner du temps de démarrage en évitant de reconstruire les représentations intermédiaires de ce code ;
-
runtime loading of code ;
- optimisations : tail call éliminations (ne pas empiler dans la pile d’appel si le retour de fonction est dans l’appel), dispatch, élimination de code mort, on stack replacement (remplacement sur la pile de routine non optimisée par une routine optimisée), escape analysis (transformer des allocations de tas en allocation sur la pile ou même dans un registre) et scalar replacement (élimine des allocations mémoire) ;
- JIT compilation ;
- profilage de la pile d’appel et des allocations ;
-
heap snapshotting V : principalement pour analyses ultérieures (investigation et amélioration du ramasse‑miettes, par exemple).
Je conseille également la lecture de cette introduction de MoarVM.
MAST
MAST signifie MoarVM AST (arbre de syntaxe abstraite).
MBC
MBC signifie MoarVM Byte Code. Voici à quoi ressemble MBC :
; Grab value out of Scalar
decont r4, r1
; Grab type ; de-Scalar if needed
wval r5, 1, 34
decont r3, r5
; Ensure arg is an Int
istype r6, r4, r3
assertparamcheck r6
Implémentation basée sur Rakudo + MoarVM (depuis 2012)
MoarVM ne possède pas d’assembleur.
Ci‑dessous un autre schéma d’architecture tiré d’une présentation sur les optimisations Rakudo/MoarVM (2014) :
Pugs (2005 - 2007)
À partir d’ici on commence l’archéologie, la vraie.
Dans sa courte existence, Pugs a exploré de nombreux choix d’architecture. Pugs désigne l’interpréteur, le compilateur, l’environnement d’exécution et la suite de tests. Le compilateur peut compiler en Haskell, JavaScript, Perl 5 ou PIR (pour Parrot, donc, si vous vous souvenez).
Pugs est écrit en Haskell et tombe en sommeil après 2007.
Compilation
Voici les notions de compilations autour de l’implémentation Pugs.
PCR
PCR signifie Pugs Compiler Rules. C’est une implémentation en Perl 5 du moteur d’expressions rationnelles de Raku. PCR a remplacé PGE dans Pugs.
LREP
LREP a évolué en Pugs::Compiler, puis, plus tard, MiniPerl6.
Pugs::Compiler
Pugs::Compiler est un ensemble de modules Perl 5 pour compiler Raku.
MiniPerl6
Faisait partie de Pugs mais dans un répertoire séparé. MiniPerl6 est devenu KindaPerl6 puis Perlito6.
KindaPerl6
KindaPerl6 ou KP6 est une implémentation Raku de la grammaire en Raku avec un bootstrap en Perl 5. KindaPerl6 est construit à partir de MiniPerl6.
Exécution
PIL
PIL signifie Pugs Intermediate Langage. PIL n’est pas un format lisible par les humains mais plutôt un arbre syntaxique abstrait interne à Pugs.
PIL-Run
PIL-Run a été construit sur un ensemble de modules Perl 5 qui lisent et exécutent PIL. PIL-Run était le back‑end en Perl 5 de Pugs… au début.
Implémentations basées sur Pugs
Pugs + back‑ends variés
« Pugs compile et exécute »
« Pugs compile pour Parrot (PIR) »
La compilation vers PIR se fait en deux temps, petit zoom dessus :
« Pugs compile (transpile ?) vers du JavaScript »
« Perl compile (transpile ?) vers du Perl 5 »
v6
v6-pugs puis v6-alpha et à présent v6.pm est une réécriture complète de Pugs, utilisant un mélange de Raku (Pugs::Compiler et les modules associés) et Perl 5. Il réutilise du code de l’environnement d’exécution de PIL-Run et « la moitié du CPAN ». À présent v6 est distribué dans Perlito6. v6.pm est le frontal de Perlito et Pugs en Perl 5.
Perlito
Le projet Perlito est mené par Flavio S. Glock. Le projet Perlito contient en fait plusieurs compilateurs pour plusieurs langages dans plusieurs langages ciblant des back‑ends variés :
- compiler du Perl 5 vers du code source Java ;
- exécuter du Perl 5 directement dans la JVM ;
- compiler du Perl 5 vers du code source JavaScript, exécute Perl 5 directement dans le navigateur ou Node.js ;
- compiler du Raku vers du code source JavaScript, exécute Perl 6 directement dans le navigateur ou Node.js ;
- compiler du Perl 5 vers Perl 5 ;
- compiler du Raku vers Perl 5 ;
- compiler du Raku vers Python 2.6 ;
- compiler du Perl 5 vers Perl 6 (en cours) ;
- compiler du Raku vers Ruby 1.9 (en cours) ;
- compiler du Raku vers Go (en cours) ;
- compiler du Raku vers Common Lisp (SBCL) (en cours).
Une chose qu’il ne sait pas faire, c’est traduire du Perl 5 en Raku.
MiniPerl6 et KindaPerl6 forment Perlito6. Perlito5 est un portage de Perlito6 en Perl 5. C’est « Perl 5 implémenté en Perl 5 ». Perlito5 lui‑même est écrit en Perl. Perlito6, quant à lui, est écrit en Raku.
Perlito implémente seulement un sous‑ensemble de Raku nommé le « sous‑ensemble utile » et qui :
- nʼa pas de contexte de liste ;
- nʼa pas d’héritage ;
- nʼa pas de paresse ;
- a des closures mais pas de coroutines ou de continuations ;
- nʼa pas de multis.
Autres compilateurs, environnements d’exécution et machines virtuelles
Dans cette partie, nous allons continuer notre tour des initiatives autour des compilateurs, environnements d’exécution et machines virtuelles historiques.
STD et viv
STD et viv sont des œuvres de Larry Wall.
On trouve dans STD la grammaire de Raku… écrite en Raku (qui n’avait pas de compilateur à l’époque ! C’est le début des problèmes de bootstrapping :D).
VIV ou littéralement en chiffres romains « VI → V » (et donc « 6 vers 5 ») était un module capable de convertir du Perl 6 vers du Perl 5.
SMOP
D’abord appelé YAP6, SMOP signifie Simple Meta Object Programming.
SMOP est un compilateur et environnement d’exécution écrit en C pour Raku, mais on dit parfois SMOP pour désigner seulement l’environnement d’exécution (qui peut être ciblé par d’autres compilateurs).
SMOP n’est pas une machine virtuelle mais un environnement d’exécution qui ressemble à celui de Perl 5, tout en possédant des fonctionnalités pour gérer Raku.
Mildew
Mildew était un compilateur STD vers SMOP
Il utilise directement la grammaire STD.
Elf
Elf était un compilateur écrit en Raku avec une grammaire en Ruby. Il pouvait émettre du Perl 5 ou du Lis
