# Brainfuck

Brainfuck est un langage de programmation exotique, inventé par Urban Müller en 1993. Il tire son nom de l’union de deux mots anglais, brain (« cerveau ») et fuck (« niquer »), et joue sur les mots, puisque ce langage est volontairement simpliste, et parce que l'expression Brain Fuck évoque, en argot, ce qui met le cerveau dans un état de confusion par sa complexité apparente. Ce vocabulaire peu flatteur lui a d'ailleurs valu d'être écrit sous d'autres orthographes plus prudes, telles que Brainf*ck, Brainf*** ou encore BF.

## Présentation du langage

L'objectif de Müller était de créer un langage de programmation simple, destiné à fonctionner sur une machine de Turing, et dont le compilateur aurait la taille la plus réduite possible. Le langage se satisfait en effet de seulement huit instructions. La version 2 du compilateur originel de Müller, écrit pour l'Amiga, ne pesait lui-même que 240 octets, la version actuelle se contentant de 171 octets. Le brainfuck est pourtant un langage Turing-complet, ce qui signifie que, malgré les apparences, il est théoriquement possible d'écrire n'importe quel programme informatique en brainfuck.
La contrepartie est que les programmes produits sont inefficaces et difficiles à comprendre. Il suit un modèle de machine simple, consistant en un tableau d'octets initialisés à 0, d'un pointeur sur le tableau (positionné sur le premier octet du tableau) et de deux files d'octets pour les entrées et sorties.

## Implémentation
### Structure du brainfuck

Le brainfuck utilise un tableau de 30 000 cases dans lequel il stocke des valeurs. Chacune de ces cases prend une valeur entière codée sur 8 bits, ce qui permet des valeurs entre 0 et 255 ou entre -128 et 127. Il utilise également un pointeur, c'est-à-dire une variable qui prend des valeurs entières positives indiquant l'indice de la case du tableau que l'on modifie actuellement. Par convention, on attribue en informatique l'indice 0 à la première case du tableau.
Au lancement du code brainfuck, le pointeur est initialisé à 0 et toutes les cases du tableau sont nulles.
Dans les nouvelles implémentations du brainfuck, la taille du tableau n'est pas restreinte à 30 000 cases et celles-ci peuvent prendre des valeurs plus élevées. Le pointeur, lui, peut prendre des valeurs négatives, c'est-à-dire que le tableau peut s'étendre à gauche de la case d'indice nul.

### Instructions

Les huit instructions du langage, chacune codée par un seul caractère, sont les suivantes :
| Caract. | Signification |
| > | incrémente (augmente de 1) le pointeur. |
| < | décrémente (diminue de 1) le pointeur. |
| + | incrémente l'octet du tableau sur lequel est positionné le pointeur (l'octet pointé). |
| - | décrémente l'octet pointé. |
| . | sortie de l'octet pointé (valeur ASCII). |
| , | entrée d'un octet dans le tableau à l'endroit où est positionné le pointeur (valeur ASCII). |
| [ | saute à l'instruction après le ] correspondant si l'octet pointé est à 0. |
| ] | retourne à l'instruction après le [ si l'octet pointé est différent de 0. |
(Alternativement, ] peut être défini par « retourne au [ correspondant ». La formulation est plus courte, mais moins symétrique et moins efficace en temps. Le choix de l'une ou l'autre de ces deux syntaxes n'influe pas sur le comportement final du programme.)
(Une troisième version équivalente, quoique moins considérée, est : [ signifie « saute à l'instruction ] correspondante », et ] signifie « retourne à l'instruction après le [ correspondant si l'octet pointé est différent de 0 ».)
Les programmes brainfuck peuvent être traduits en C en utilisant les substitutions suivantes, en considérant que ptr est du type unsigned char* :
| Brainfuck | C |
| > | ptr++; |
| < | ptr--; |
| + | ++(*ptr); |
| - | --(*ptr); |
| . | putchar(*ptr); |
| , | (*ptr) = getchar; |
| [ | while(*ptr) { |

### Traducteur de brainfuck en ligne

Lien pour traducteur:
https://www.dcode.fr/brainfuck-language
Lien pour explication:
https://www.codingame.com/playgrounds/50426/getting-started-with-brainfuck/welcome

### Entrées / Sorties
#### Entrées

Les différents interpréteurs de brainfuck gèrent les entrées différemment. Prenons pour exemple le programme suivant :
Celui-ci se charge d'inscrire les entrées les unes à la suite des autres dans le tableau jusqu'à ce qu'une des entrées soit 0.
Certains interpréteurs demanderont à l'utilisateur à chaque fois qu'ils rencontrent la commande "," une entrée. Par exemple, l'utilisateur rentrera 12, puis 15, puis 2, puis 36, puis 0, et obtiendra le tableau [12,15,2,36,0,0, etc.]
D'autres ne demanderont qu'une seule entrée à plusieurs chiffres, comme 1215236, et la découperont chiffre par chiffre pour obtenir toutes les entrées requises: 1, puis 2, puis 1, puis 5 ... Dès qu'il n'y a plus de chiffres à mettre en entrée, l'interpréteur les remplace automatiquement par des 0. Ainsi dans notre exemple, on obtiendra le tableau [1,2,1,5,2,3,6,0,0, etc.]. Si l'utilisateur rentre un nombre avec un 0 à l'intérieur, le programme s'arrêtera comme prévu à ce 0 sans copier le reste du nombre. Par exemple, 12150236 donnera [1,2,1,5,0,0, etc.]
En général, comme on vient de le faire, les entrées sont des nombres, mais peuvent être également des caractères ASCII, l'interpréteur se charge de les remplacer par leur code équivalent. Par exemple, si l'on rentre "Hello World" avec le code précédent, on obtient alors : [72,101,108,108,111,32,87,111,114,108,100,0,0,...].

#### Sorties

Comme pour les entrées, les sorties peuvent soit être exprimées en ASCII, soit directement numériquement.

## Exemples
### Hello World! - Exemple #1

Le programme suivant affiche le traditionnel « Hello World! » et une nouvelle ligne à l'écran :
Par souci de lisibilité, le code a été divisé en plusieurs lignes et des commentaires ont été ajoutés. Brainfuck considère comme étant des commentaires tous les caractères sauf +-<>,.. Le code effectivement compilé peut donc se réduire à la ligne suivante :
La première ligne initialise a[0] = 10 par de simples incréments successifs à partir de 0. La boucle des lignes 2 à 4 définit de façon effective les valeurs initiales du tableau : a[1] = 70 (proche de 72, le code ASCII du caractère 'H'), a[2] = 100 (proche de 101 ou 'e'), a[3] = 30 (proche de 32, espace) et a[4] = 10 (nouvelle ligne). La boucle fonctionne en multipliant les valeurs de a[0], 10, par 7, 10, 3, et 1, qu'elle stocke dans les cellules voisines. Quand la boucle s'achève, a[0] vaut zéro. >++. déplace alors le pointeur à a[1], qui contient 70, y ajoute 2 (72 étant le code ASCII de la lettre 'H' majuscule), et l'affiche.
La ligne suivante déplace le pointeur vers a[2] et l'incrémente de 1, le résultat, 101, correspondant à 'e', qui est alors affiché.
'l' étant la septième lettre de l'alphabet après 'e', pour obtenir 'll' il faut ajouter 7 (+++++++) à a[2] et l'afficher deux fois.
'o' est la troisième lettre de l'alphabet après 'l', on incrémente donc a[2] trois fois avant d'afficher le résultat.
Le reste du programme fonctionne selon le même principe. Pour les espaces et les lettres en majuscule, ce sont d'autres cellules du tableau qui sont sélectionnées et incrémentées.

### Exemple #2

Ce programme donne un texte, comme l'exemple précédent. Essayez de le faire fonctionner pour savoir ce qui est caché derrière ce texte.

### Remise à zéro de l'octet pointé

L'octet est décrémenté (boucle [ ]) jusqu'à ce que sa valeur ait atteint 0.

### Entrée/Sortie d'un caractère

Affiche à l'écran un caractère entré au clavier.

### Boucle simple

Boucle affichant les caractères entrés au clavier. La fin de la saisie est ici signalée par un 0 (les implémentations peuvent différer sur ce point).

### Manipulation de pointeur

* Enregistrer une chaîne de caractères
Une version améliorée de la boucle précédente, dans laquelle les caractères saisis par l'utilisateur sont stockés dans un tableau en vue d'une utilisation future, en déplaçant le pointeur à chaque fois.
* Utilisation de bloc de mémoire (taille quelconque, mais ne contenant pas de valeur nulle)
En notant P le pointeur, - - - - un bloc de données quelconques non nulles et 0 un octet dont la valeur est nulle, si la mémoire est organisée de la manière suivante :
Alors nous pouvons nous déplacer de bloc en bloc de la manière suivante (avec le pointeur initialement sur P ) :
Par exemple, si P=3, à chaque exécution de la boucle principale, la mémoire sera organisée de cette façon :
Arrivée à ce point, la boucle s'arrête, et nous sommes arrivés sur le bloc pointé. Cette technique permet de manipuler des blocs de taille quelconque, à condition qu'ils ne contiennent pas de valeurs nulles.
* Utilisation de bloc de mémoire (taille fixe, pouvant contenir des valeurs nulles)
En reprenant la technique précédente, mais cette fois avec des blocs de tailles constantes (par exemple 4, on obtient) :
Cette technique permet d'avoir des données nulles dans les blocs, mais est plus longue à écrire pour des blocs de grande taille.

### Copie d'un octet

On peut distinguer deux manières de copier le contenu d'un octet dans un autre : en effaçant les données de l'octet initial ou en les conservant. Le premier cas est plus simple, le second requérant une variable intermédiaire.
Pour la copie destructive d'un octet dans l'octet suivant, en supposant que le pointeur est sur l'octet à copier:
Pour une copie conservative d'un octet (pointé au départ) dans l'octet suivant, nous allons utiliser l'octet encore après comme variable temporaire. Encore une fois, la première ligne est facultative si on sait que les deux octets suivant l'octet à copier sont nuls.

### Instructions conditionnelles

Ce programme prend un caractère minuscule en entrée et le met en majuscule. La touche Entrée arrête la saisie (code 10 en brainfuck dans la plupart des compilateurs).
Au début, on récupère le premier caractère (, ) et on lui soustrait immédiatement 10 (10 fois -). Si l'utilisateur a appuyé sur Entrée, on a 0 dans l'octet pointé et l'instruction de boucle ( saute à la fin du programme. Si le caractère entré n'est pas 10, on considère que c'est une lettre minuscule et on entre dans la boucle, où on va lui soustraire le nombre 22 (22 fois -), ce qui va faire 32 en tout, 32 étant la différence numérique entre la lettre minuscule et la même lettre en majuscule en code ASCII.
Le caractère est affiché, puis un nouveau caractère est récupéré, et à nouveau on lui soustrait 10. Le programme revient alors au début de la boucle : si la touche qu'a validé l'utilisateur est Entrée (10), la boucle s'arrête, sinon elle se poursuit.

#### If

Voici un moyen simple d'écrire un bloc « if » en brainfuck :
Ce bloc d'instruction nécessite une mémoire de la forme :
Avec le curseur sur le « 0 », il exécute le code « code » si et seulement si $n$ est non nul, avec le curseur sur le « 0 » à l'état final comme initial.
Décomposons ce code en étapes :
">" : on met le pointeur sur n
Si n est égal à 0, la boucle ne s'exécute pas et le pointeur est toujours sur n, on revient alors en arrière ("<", on est alors sur le 2e octet) puis la boucle ne s'exécute pas puisque nous sommes sur le 0 ([>] revient à dire "va sur le premier octet nul en partant de l'octet pointé inclus").
Si n est différent de 0, la boucle s'exécute et le code aussi, le pointeur revient alors sur le 2e octet et la boucle s'arrête, puisque cet octet est égal à 0. Le pointeur est donc sur le 2e octet. On revient ensuite en arrière ("<"), donc sur le premier octet (égal à 1) puis, comme dit, la boucle [>] emmène le pointeur sur le premier octet nul suivant l'octet pointé inclus, or le premier est différent de 0 et le second égal à 0, ce qui amène le pointeur sur le deuxième octet.
Si on a besoin de faire une condition après laquelle le code s'arrête, on peut se contenter de ">[code<]" , puisque la partie "<[>]" sert uniquement à mettre le pointeur, à l'état final, sur le deuxième octet dans les deux cas.

#### If, else

Ce bloc d'instruction nécessite une mémoire de la forme :
Où V est la variable à tester, C est sa copie et T le témoin du passage dans le bloc if. Dans notre exemple, le pointeur de départ est sur V et celui d'arrivée est sur C. Dans chaque bloc de code (if et else), le pointeur de départ et d'arrivée est sur C. C et T sont nulles après exécution.
Soit en condensé
Une manière plus simple d'exécuter un bloc If, else est la suivante :
Pour exécuter cette structure, la mémoire doit être sous cette forme :
avec n l'octet à tester.
Les codes « code_if » et « code_else » ne doivent utiliser que les cases à droite de l'octet considéré et revenir à l'octet à la fin de leur exécution. Soit en totalité :

### Opérations
#### Addition

Ce bloc d'instruction nécessite une mémoire de la forme :
Où "V" est la variable de base "A" est la variable à additionner. À la fin du programme "A" est détruite et "V" contient le résultat de l'addition.
Ce code ajoute l'octet suivant (en le détruisant, il est donc remis à 0) à l'octet courant.
ou
Soit index[0] = 2 et index[1] = 8, « > » Se place sur index[1], « [ » débute la boucle, « - » et index[1] = 7, « < » on pointe sur index[0], « + » et index[0] = 3, « > » on pointe sur index[1], « ] » si index[1] != 0 on recommence. À la fin, on aura bien index[1] = 0 ce qui arrête la boucle, et index[0] = 10.

#### Addition (ASCII)

Ce programme additionne 2 nombres à un seul chiffre et affiche le résultat si celui-ci n'a aussi qu'un seul chiffre :
4+3
7
(Maintenant les choses vont être un peu plus compliquées. Nous allons nous référer aux octets du tableau ainsi : [0], [1], [2], etc.)
Le premier nombre est entré dans [0], et on lui soustrait 48 pour avoir sa valeur décimale (les codes ASCII pour les chiffres 0-9 sont 48-57). Cela est fait en mettant 6 dans [1] et en utilisant une boucle pour soustraire 8 de [0] autant de fois que dans [1], soit 6 × 8 = 48. C'est une méthode plus commode pour ajouter ou soustraire des grands nombres que de mettre 48 fois « - » dans le programme. Le code qui fait cela est :
>++++++ pour mettre 6 dans [1], puis on attaque la boucle, « < » pour revenir sur [0], on soustrait 8, « > » on repasse sur [1], qu'on décrémente et on retourne dans la boucle. La boucle est alors exécutée 6 fois, jusqu'à ce que [1] soit égal à 0.
Ensuite, on récupère le signe + qu'on met dans [1], puis le second chiffre qui écrase le signe +.
La boucle suivante [<+>-] ajoute effectivement le nombre de la seconde cellule dans la première cellule et remet [1] à zéro. À chaque boucle, il ajoute 1 dans [0] et retire 1 de [1] ; ainsi [1] finit par être à 0. Tout ce qui a été ajouté à [0] a été retiré de [1]. Ensuite la touche entrée est mise dans [1].
Puis le pointeur est remis sur [0], qui est affiché ([0] est maintenant a + (b + 48), puisqu'on n'a pas corrigé b ; ce qui est identique à (a + b) + 48, qui est ce que l'on veut). Le pointeur est ensuite déplacé sur [1], qui contient la touche entrée, que l'on affiche. L'exécution est terminée.

#### Soustraction

Cette opération nécessite une mémoire de la forme :
Où "V" est la variable de base "S" est la variable à soustraire. À la fin du programme "S" est détruite et "V" contient le résultat de la soustraction.
ou
Soit V = 8 et S = 4, « > » Se place sur S, « [ » débute la boucle, « - » et S = 3, « < » on pointe sur V, « - » et V = 7, « > » on pointe sur S, « ] » si S != 0 on recommence. À la fin, on aura bien S = 0 ce qui arrête la boucle, et V = 4.

#### Multiplication

Cette opération nécessite une mémoire de la forme :
Où "R" est le résultat, "T" est une variable temporaire, O est l'opérande et M le multiplicateur. Au début de l’exécution le pointeur est sur R et à la fin de l’exécution le pointeur est sur R.
Soit en condensé :

#### Multiplication (ASCII)

Comme le précédent, mais effectue une multiplication basée sur les caractères, pas sur des nombres enregistrés en mémoire.
Le premier nombre est entré dans [0], l'astérisque et le deuxième nombre dans [1] et les 2 nombres sont corrigés en leur soustrayant 48 (note : il y a une boucle de 16 itérations pour soustraire 3 aux deux nombres ainsi qu'ajouter 3 au futur résultat à chaque itération !).
Ensuite on entre dans la boucle de multiplication principale. L'idée de base est qu'à chaque boucle on soustrait 1 de [1] et on ajoute [0] dans le total cumulé gardé en [2] (3 * 2 = 2 + 2 + 2). En particulier : la première boucle cumule [0] dans [2] et [3], tout en remettant [0] à 0. (C'est la manière la plus simple de dupliquer un nombre.) La deuxième boucle remet [3] dans [0], en remettant à 0 [3]. Puis on décrémente [1] et on est à la fin de la boucle principale. À la sortie de cette boucle, [1] contient 0, [0] contient encore le deuxième nombre, et [2] contient le produit des 2 nombres (pour garder la valeur, il suffit de l'ajouter dans [4] à chaque itération de la boucle principale, puis de déplacer la valeur de [4] dans [1].)
Exemple : 3 * 2
| [0] | [1] | [2] | [3] |
| 3 | 2 | 0 | 0 |
| 1re boucle : >[>+>+<<-] ||||
| 3 | 1 | 1 | 1 |
| 3 | 0 | 2 | 2 |
| 2e boucle : >>[<<+>>-] ||||
| 3 | 1 | 2 | 1 |
| 3 | 2 | 2 | 0 |
| Fin boucle princ : <<<-] ||||
| 2 | 2 | 2 | 0 |
| 1re boucle : >[>+>+<<-] ||||
| 2 | 1 | 3 | 1 |
| 2 | 0 | 4 | 2 |
| 2e boucle : >>[<<+>>-] ||||
| 2 | 1 | 4 | 1 |
| 2 | 2 | 4 | 0 |
| Fin boucle princ : <<<-] ||||
| 1 | 2 | 4 | 0 |
| 1re boucle : >[>+>+<<-] ||||
| 1 | 1 | 5 | 1 |
| 1 | 0 | 6 | 2 |
| 2e boucle : >>[<<+>>-] ||||
| 1 | 1 | 6 | 1 |
| 1 | 2 | 6 | 0 |
| Fin boucle princ : <<<-] ||||
| 0 | 2 | 6 | 0 |
Ensuite, il ne reste plus qu'à ajouter 48 au produit, récupérer la touche entrée dans [3], et afficher le produit en ASCII et l'entrée qui vient juste d'être stockée.

#### Minimum

Cette section présente un code permettant de calculer le minimum de deux entiers, chose plus ardue qu'on pourrait le penser.
Il prend en argument une bande de la forme
Avec le curseur sur le $n$, et renvoie une bande de la forme
Avec le curseur sur le $M$ et $M=\min(n,m)$, $n'=n-M$ et $m'=m-M$
On peut ensuite ajouter du code de mise en forme.
Ainsi le code suivant prend en argument une bande du type
avec un curseur sur le $n$ et renvoie
avec le curseur sur le $M$.
Voici le code : (les lignes 2 et 4 sont des lignes de mise en forme, 1 et 5 des entrées sorties)

## Macro-définition brainfuck

Les macros-définitions ci-dessous définissent des techniques permettant de retrouver des structures ou des instructions utilisées habituellement en algorithmique ou dans les langages de programmation. Elles facilitent la création de programmes brainfuck. Il existe des implémentations de brainfuck acceptant la définition de macros.
Les symboles comme a, b ou s représentent chacun un octet différent dans le tableau mémoire. Le symbole t indique un octet utilisé temporairement pour les besoins de la macro. Le symbole s représente un octet utilisé comme source et d un octet utilisé comme destination.
* Déplacement du pointeur
La macro to(a) consiste à déplacer le pointeur dans le tableau mémoire au niveau de l'octet a. Elle s'obtient avec une série de < ou de >.
* Ajout d'une constante
La macro addCst(n) ajoute à l'octet pointé la valeur n. Elle s'obtient avec une série de + ou de - selon le signe de n.
* Mise à zéro d'un octet
    zero(m): to(m) [-]
* Déplacer un octet
    move(s d): to(s) [- to(d)+ to(s)]
* Déplacer un octet vers deux autres octets
    move2(s d1 d2): to(s) [- to(d1)+ to(d2)+ to(s)]
* Copie d'un octet vers un autre
    copy(s d t): move2(s d t) move(t s)
* Structure conditionnelle simple
    if(a) : to(a) [
    endif(a): zero(a) ]
* Structure conditionnelle avec alternative
    ifelse(a t): to(t)+ to(a) [ to(t)-
    else(a t) : zero(a) ] to(t) [
    endelse(t) : to(t)- ]
* Structure répétitive
    for(s) : to(s) [
    next(s): to(s)- ]
* Échange de deux octets
    swap(a b t): move(a t) move(b a) move(t b)

## Commentaire

On peut noter que, dans la version initiale, comme chaque cellule du tableau est un octet, l'instruction « - » est superflue et peut être remplacée par 255 « + ». De la même manière, les 30 000 cellules formant un tableau circulaire, « < » peut-être remplacé par 29 999 « > ». Cela réduirait le langage à six instructions.
Cependant, la taille du tableau, la taille des cellules et les possibilités de "wrapping" (i.e. que faire > sur la dernière case ramène à la première ou que + sur un octet plein le met à 0) ne font pas partie des spécifications du langage et sont laissées à la liberté des compilateurs. Ainsi, cette réduction à six instructions n'est pas toujours possible. Quand bien même, jouer sur le wrapping peut nuire à la portabilité du langage.
La seule contrainte imposée par le concepteur du langage est au moins 30 000 cellules et au moins un octet par cellule. Certaines implémentations proposent deux, quatre ou huit octets par cellule, voire aucune limitation !

## Variantes

Brainfuck a de nombreux descendants. La plupart se contentent de rendre le code encore plus inextricable (par exemple f*ckf*ck, le langage Pi, ou bien Ook! décrit ci-dessous) ; d'autres ajoutent de réelles fonctionnalités.

### Ook!

Le langage Ook est une variante de brainfuck. C'est un langage Turing-complet, conçu pour être parfaitement lisible par un orang-outan, en référence au personnage du bibliothécaire de l'univers du Disque-monde de Terry Pratchett.
| Ook | Brainfuck | Signification |
| Ook. Ook? | > | incrémente (augmente de 1) le pointeur. |
| Ook? Ook. | < | décrémente (diminue de 1) le pointeur. |
| Ook. Ook. | + | incrémente l'octet du tableau sur lequel est positionné le pointeur (l'octet pointé). |
| Ook! Ook! | - | décrémente l'octet pointé. |
| Ook! Ook. | . | sortie de l'octet pointé (valeur ASCII). |
| Ook. Ook! | , | entrée d'un octet dans le tableau à l'endroit où est positionné le pointeur (valeur ASCII). |
| Ook! Ook? | [ | saute à l'instruction après le Ook? Ook! correspondant si l'octet pointé est à 0. |
| Ook? Ook! | ] | retourne à l'instruction après le Ook! Ook? si l'octet pointé est différent de 0. |
| Ook? Ook? | | fin du programme. |
Hello World! en Ook :

### Spoon

Le langage spoon est équivalent au langage brainfuck mais avec des mots constitués de 0 et 1, utilisant un codage de Huffman.
| Spoon | Brainfuck | Signification |
| 010 | > | incrémente (augmente de 1) le pointeur. |
| 011 | < | décrémente (diminue de 1) le pointeur. |
| 1 | + | incrémente l'octet du tableau sur lequel est positionné le pointeur (l'octet pointé). |
| 000 | - | décrémente l'octet pointé. |
| 0010110 | , | entrée d'un octet dans le tableau à l'endroit où est positionné le pointeur (valeur ASCII). |
| 001010 | . | sortie de l'octet pointé (valeur ASCII). |
| 00100 | [ | saute à l'instruction après le 0011 correspondant si l'octet pointé est à 0. |
| 0011 | ] | retourne à l'instruction après le 00100 si l'octet pointé est différent de 0. |
De plus, il possède deux instructions supplémentaires non disponibles dans le langage brainfuck :
| Spoon | Signification |
| 00101110 | sortie de tout le tableau mémoire. |
| 00101111 | fin immédiate du programme. |
Hello world en spoon :
Les espaces peuvent être supprimés :
Hello world en spoon (sans espace)
Cela fait bien entendu référence à un fichier binaire (exécutable).

### SegFaultProg

Le langage Segfaultprog est une variante du brainfuck, enrichie, extensible, destinée à être exécutée en machine virtuelle, sur de petites architectures (AVR, PIC, MIPS...). Son développement a débuté en mai 2010. Ce langage propose une simplification de la syntaxe du brainfuck (par exemple, avec l'adressage direct, et en évitant les répétitions), et rétro-compatibilité avec celui-ci.
Hello world en SegFaultProg V1
Hello World en SegFaultProg V2

### Whitespace

Le langage Whitespace est équivalent au brainfuck mais n'utilise en tant qu'instructions que des tabulations, des espaces et des retours à la ligne, afin de générer un programme dont le code est invisible.
Hello World en Whitespace (lien):
https://github.com/rdebath/whitespace/blob/master/tests/rdebath/helloworld.ws