Foda-se

Brainfuck é uma linguagem de programação esotérica criada em 1993 por Urban Müller.

Notável por seu extremo minimalismo, a linguagem consiste em apenas oito comandos simples, um ponteiro de dados e um ponteiro de instrução. Embora seja totalmente Turing completo, não se destina ao uso prático, mas para desafiar e divertir os programadores. Brainfuck requer que alguém quebre os comandos em etapas microscópicas.

O nome do idioma é uma referência à gíria brainfuck, que se refere a coisas tão complicadas ou incomuns que ultrapassam os limites do entendimento de alguém, como era não foi concebido ou feito para projetar software real, mas para desafiar os limites da programação de computadores.

História

Em 1992, Urban Müller, um estudante de física suíço, assumiu um pequeno arquivo online para o software Amiga. O arquivo ficou mais popular e logo foi espelhado em todo o mundo. Hoje, é o maior arquivo Amiga do mundo, conhecido como Aminet.

Müller projetou o Brainfuck com o objetivo de implementar o menor compilador possível, inspirado no compilador de 1024 bytes para a linguagem de programação FALSE. O compilador original de Müller foi implementado em linguagem de máquina e compilado para um binário com tamanho de 296 bytes. Ele carregou o primeiro compilador Brainfuck para Aminet em 1993. O programa veio com um "Readme" arquivo, que descreveu brevemente o idioma e desafiou o leitor "Quem pode programar algo útil com ele?:)". Müller também incluiu um intérprete e alguns exemplos bastante elaborados. Uma segunda versão do compilador usava apenas 240 bytes. Atualmente, existem muitos compiladores brainfuck na web.

Com o crescimento do Aminet, o compilador tornou-se popular entre a comunidade Amiga e, com o tempo, foi implementado para outras plataformas.

P”: Brainfuck formal "linguagem parental"

Exceto por seus dois comandos I/O, Brainfuck é uma variação menor da linguagem de programação formal P′′ criada por Corrado Böhm em 1964, que por sua vez é explicitamente baseada na máquina de Turing. Na verdade, usando seis símbolos equivalentes aos respectivos comandos Brainfuck +, -, <, >, [, ], Böhm forneceu um programa explícito para cada uma das funções básicas que juntas servem para computar qualquer função computável. Então o primeiro "Brainfuck" programas aparecem no artigo de Böhm de 1964 - e foram suficientes para provar a completude de Turing.

O Ábaco Infinito: o 'avô' do Brainfuck; idioma

Uma versão com endereçamento de memória explícito (em vez de movimentos relativos em uma pilha) e um salto condicional (em vez de loops) foi introduzida por Joachim Lambek em 1961 sob o nome de Ábaco Infinito, consistindo em um número infinito de células e duas instruções:

• X+ (célula de entrada X)
• X- else jump T (decrement X se for positivo mais saltar para T)

Ele prova que o Ábaco Infinito pode computar qualquer função recursiva computável programando o conjunto Kleene da função μ-recursiva básica.

Sua máquina foi simulada pela computação de modelagem de máquina de Melzac por meio de aritmética (em vez de lógica binária), imitando um operador humano movendo pedras em um ábaco, daí a exigência de que todos os números devem ser positivos. Melzac, cujo computador com um conjunto de instruções é equivalente a um Ábaco Infinito, fornece programas para multiplicação, GCD, n^th número primo, representação na base b, classificação por magnitude e mostra como simular uma máquina de Turing arbitrária.

Design de linguagem

A linguagem consiste em oito comandos, listados abaixo. Um programa brainfuck é uma sequência desses comandos, possivelmente intercalados com outros caracteres (que são ignorados). Os comandos são executados sequencialmente, com algumas exceções: um ponteiro de instrução começa no primeiro comando e cada comando para o qual aponta é executado, após o que normalmente avança para o próximo comando. O programa termina quando o ponteiro de instrução passa do último comando.

A linguagem brainfuck usa um modelo de máquina simples que consiste no programa e no ponteiro de instrução, bem como uma matriz unidimensional de pelo menos 30.000 células de bytes inicializadas em zero; um ponteiro de dados móvel (inicializado para apontar para o byte mais à esquerda do array); e dois fluxos de bytes para entrada e saída (na maioria das vezes conectados a um teclado e um monitor, respectivamente, e usando a codificação de caracteres ASCII).

Comandos

Os oito comandos de linguagem consistem cada um em um único caractere:

(Como alternativa, o comando ] pode ser traduzido como um salto incondicional para o comando [ correspondente, ou vice-versa; os programas comportar-se da mesma forma, mas será executado mais lentamente, devido à pesquisa dupla desnecessária.)

[ e ] correspondem como os parênteses geralmente fazem: cada [ corresponde exatamente a um ] e vice-versa, o [ vem primeiro, e não pode haver nenhum [ ou ] incomparável entre os dois.

Os programas Brainfuck podem ser traduzidos para C usando as seguintes substituições, assumindo que ptr é do tipo char* e foi inicializado para apontar para uma matriz de bytes zerados:

Como o nome sugere, os programas Brainfuck tendem a ser difíceis de compreender. Isso ocorre em parte porque qualquer tarefa levemente complexa requer uma longa sequência de comandos e em parte porque o texto do programa não fornece indicações diretas sobre o estado do programa. Estes, bem como a ineficiência do Brainfuck e suas capacidades limitadas de entrada/saída, são algumas das razões pelas quais ele não é usado para programação séria. No entanto, como qualquer linguagem Turing completa, Brainfuck é teoricamente capaz de computar qualquer função computável ou simular qualquer outro modelo computacional, se tiver acesso a uma quantidade ilimitada de memória. Uma variedade de programas Brainfuck foram escritos. Embora os programas Brainfuck, especialmente os complicados, sejam difíceis de escrever, é bastante trivial escrever um interpretador para Brainfuck em uma linguagem mais típica como C devido à sua simplicidade. Existem até intérpretes Brainfuck escritos na própria linguagem Brainfuck.

Brainfuck é um exemplo do chamado tarpit de Turing: pode ser usado para escrever qualquer programa, mas não é prático fazê-lo, porque Brainfuck fornece tão pouca abstração que os programas ficam muito longo ou complicado.

Exemplos

Adicionando dois valores

Como primeiro exemplo simples, o trecho de código a seguir adicionará o valor da célula atual à próxima célula: Cada vez que o loop é executado, a célula atual é diminuída, o ponteiro de dados se move para a direita, a próxima célula é incrementada e o ponteiro de dados se move para a esquerda novamente. Essa sequência é repetida até que a célula inicial seja 0.

Não.- Não.>+<]

Isso pode ser incorporado em um programa de adição simples da seguinte forma:

++ C0 = 2> +++ C1 = 5Não. Comece seus loops com seu ponteiro de célula no contador de loop (c1 em nosso caso)< + Adicionar 1 a c0> - Não. Subtrair 1 de c1] Terminar seus loops com o ponteiro da célula no contador de loopNeste ponto nosso programa adicionou 5 a 2 deixando 7 em c0 e 0 em c1mas não podemos produzir este valor para o terminal, uma vez que não é ASCII codificadoPara exibir o caractere ASCII "7" devemos adicionar 48 ao valor 7Usamos um loop para calcular 48 = 6 * 8++ ++ c1 = 8 e este será o nosso contador de loop novamenteNão.< + ++ + ++ Adicionar 6 a c0> - Não. Subtrair 1 de c1]< . Imprima c0 que tem o valor 55 que se traduz em "7"!

Olá mundo!

O programa a seguir imprime "Hello World!" e uma nova linha na tela:

Não. Este programa imprime "Hello World!" e uma nova linha para a tela, a sua comprimento é 106 caracteres de comando ativos. Não.Não é o mais curto.] Este loop é um "loop de comentário inicial", uma maneira simples de adicionar um comentário para um programa BF tal que você não tem que se preocupar com qualquer comando caracteres. Qualquer ".", ",", "+", "- Não.", "<"e">" caracteres são simplesmente ignorado, o "Não."e"]" personagens só tem que ser equilibrado. Isto é... loop e os comandos que contém são ignorados porque a célula atual padrão para um valor de 0; o valor de 0 faz com que este loop seja ignorado.]++ ++ Definir célula #0 a 8Não. >++ Adicione 4 à célula #1; isso sempre definirá a célula #1 a 4 Não. como a célula será limpa pelo laço >++ Adicionar 2 à célula #2 >+ ++ Adicionar 3 à célula #3 >+ ++ Adicionar 3 à célula #4 >+ Adicionar 1 à célula #5 < < < < < < < < < < < < < < < < < < < < < < < <) < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <) < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <- Não. Decrementar o contador de loop na célula #1 ] Loop até Cell #1 é zero; o número de iterações é 4 >+ Adicionar 1 à célula #2 >+ Adicionar 1 à célula #3 >- Não. Subtrair 1 da célula #4 >+ Adicionar 1 à célula #6 Não.<] Volte para a primeira célula zero que você encontrar; isso vai ser Cell #1 que foi compensado pelo loop anterior <- Não. Decrementar o Contador de loop na célula #0] Loop até Cell #0 é zero; o número de iterações é 8O resultado disso é:Célula no: 0 1 2 3 4 5 6Conteúdo: 0 0 72 104 88 32 8Ponto:>. Cell #2 tem valor 72 que é 'H '>-.... Subtrair 3 da célula #3 para obter 101 que é 'e'+++...+ ++. Igualmente para 'llo' de Cell #3>. Cell #5 é 32 para o espaço<- Não.. Subtrair 1 da célula #4 para 87 para dar um 'W'<. A célula #3 foi definida como 'o' do final de 'Hello '+ ++.- Não..------. Célula #3 para 'rl' e 'd '>+. Adicionar 1 à célula #5 nos dá um ponto de exclamação>++. E finalmente uma nova linha da célula #6

Para "legibilidade", este código foi distribuído em muitas linhas e foram adicionados espaços em branco e comentários. Brainfuck ignora todos os caracteres, exceto os oito comandos +-<>[],. portanto, nenhuma sintaxe especial para comentários é necessária (desde que os comentários não contenham os caracteres de comando). O código poderia muito bem ter sido escrito como:

++ ++Não.>++Não.>++>+ ++>+ ++>+< < < < < < < < < < < < < < < < < < < < < < < <) < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <) < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <- Não.]>+>+>- Não.>+Não.<]<- Não.]>.>-....+++...+ ++.>.<- Não..<.+ ++.- Não..------.>+.>++.

ROT13

Este programa codifica sua entrada com a cifra ROT13. Para fazer isso, ele deve mapear os caracteres A-M (ASCII 65–77) para N-Z (78-90) e vice-versa. Também deve mapear a-m (97-109) para n-z (110-122) e vice-versa. Ele deve mapear todos os outros personagens para si mesmos; ele lê os caracteres um por vez e gera seus equivalentes codificados até ler um EOF (aqui assumido como representado como -1 ou "sem alteração"), ponto em que o programa termina.

A abordagem básica usada é a seguinte. Chamando o caractere de entrada x, divida x-1 por 32, mantendo quociente e resto. A menos que o quociente seja 2 ou 3, apenas imprima x, mantendo uma cópia dele durante a divisão. Se o quociente for 2 ou 3, divida o restante ((x-1) módulo 32) por 13; se o quociente aqui for 0, imprima x+13; se 1, saída x-13; se 2, imprima x.

Em relação ao algoritmo de divisão, ao dividir y por z para obter um quociente q e resto r, existe um loop externo que define q e r primeiro para o quociente e restante de 1/z, depois para aqueles de 2/z, e assim por diante; depois de ter executado y vezes, esse loop externo termina, deixando q e r definido como o quociente e o resto de y/z. (O dividendo y é usado como um contador decrescente que controla quantas vezes esse loop é executado.) Dentro do loop, há um código para incrementar r e decrementar y, que geralmente é suficiente; porém, a cada zésima vez pelo loop externo, é necessário zerar r e incrementar q. Isso é feito com um contador decrescente definido para o divisor z; cada vez que passa pelo loop externo, esse contador é decrementado e, quando chega a zero, é recarregado movendo o valor de r de volta para ele.

- Não.,+Não. Leia o primeiro caractere e comece o loop de leitura de caráter externo - Não.Não. Saltar para a frente se o personagem é 0 >++Não.>++ ++<- Não.] Configurar divisor (32) para loop de divisão (MEMORY LAYOUT: cópia de dividendo restante divisor quotient zero) <+<- Não.Não. Configurar dividendo (x minus 1) e entrar loop de divisão >+>+>- Não.Não.>] Aumentar cópia e restante / reduzir divisor / caso normal: pular para a frente <[>+<- Não.]>+>] Caso especial: mover o restante de volta para divisor e aumentar o quociente < < < < < < < < < < < < < < < < < < < < < < < < < < <) < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <- Não. Divórcio de decreção ] Fim de divisão loop ]>Não.- Não.]+ Fim pular loop; zero antigo divisor e reutilizar espaço para uma bandeira >-...Não.- Não.Não.<- Não.>+ ++Não.- Não.]]<Não. Zero que bandeira a menos que o quociente tenha sido 2 ou 3; zero quociente; check flag ++ ++ ++ ++<Não. Se a bandeira então configurar divisor (13) para segunda divisão loop (LAYOUT DE MEMÓRIA: zero cópia dividendo divisor restante quociente zero) >- Não.Não.>+>] Reduzir divisor; Caso normal: aumento restante >Não.+Não.<+>- Não.]>+>] Caso especial: aumentar o restante / movê-lo de volta para divisor / aumentar o quociente < < < < < < < < < < < < < < < < < < < < < < < < < < <) < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <- Não. Dividir decrescente ] Fim de divisão loop >Não.<+>- Não.] Adicione o restante de volta ao divisor para obter um útil 13 >Não. Skip forward if quotient was 0 - Não.Não. Quíciente de decremento e pular para a frente se o quociente foi 1 - Não.< <Não.- Não.]> quociente zero e divisor se quociente foi 2 ]< <Não.< <- Não.>- Não.]> Divisor zero e subtrato 13 da cópia se o quociente foi 1 ]< <Não.< <+>- Não.] Zero divisor e adicionar 13 para copiar se o quociente foi 0 ] End outer skip loop (jump to here if (caracter minus 1)/32) não foi 2 ou 3) <Não.- Não.] Resto claro da primeira divisão se a segunda divisão foi ignorada <.Não.- Não.] Saída ROT13ed personagem de cópia e limpá-lo <- Não.,+ Leia o próximo personagem] loop de leitura de caracteres finais

Problemas de portabilidade

Em parte porque Urban Müller não escreveu uma especificação de linguagem completa, os muitos interpretadores e compiladores brainfuck subsequentes implementaram dialetos ligeiramente diferentes de brainfuck.

Tamanho da célula

Na versão clássica, cada célula tem 1 byte (8 bits), e esse ainda é o tamanho mais comum. No entanto, para ler dados não textuais, um programa brainfuck pode precisar distinguir uma condição de fim de arquivo de qualquer valor de byte possível; assim células de 16 bits também foram usadas. Algumas versões usaram células de 32 bits, células de 64 bits, células de campo principal ou células com intervalo ilimitado. As implementações que usam esse intervalo extra são mais lentas, pois as instruções + e - apenas atualizam o valor em ±1.

Em todas essas variantes, os comandos , e . ainda leem e gravam dados em bytes. Na maioria deles, as células envolvem, ou seja, incrementar uma célula que contém seu valor máximo (com o comando +) a levará ao seu valor mínimo e vice-versa. As exceções são implementações distantes do hardware subjacente, implementações que usam bignums e implementações que tentam reforçar a portabilidade.

Normalmente é fácil escrever programas brainfuck que nunca causam quebra de inteiro ou estouro e, portanto, não dependem do tamanho da célula. Geralmente, isso significa evitar o incremento de +255 (envolvimento de 8 bits sem sinal) ou evitar ultrapassar os limites de [-128, +127] (envolvimento de 8 bits com sinal) (uma vez que não há operadores de comparação, um programa não pode distinguir entre um célula de tamanho de bit fixo com complemento de dois assinados e não assinados e negatividade de números é uma questão de interpretação). Para obter mais detalhes sobre wraparound de inteiro, consulte o artigo sobre estouro de inteiro.

Tamanho da matriz

Na distribuição clássica, a matriz tem 30.000 células e o ponteiro começa na célula mais à esquerda. Ainda mais células são necessárias para armazenar coisas como o milionésimo número de Fibonacci, e a maneira mais fácil de tornar a linguagem Turing completa é tornar a matriz ilimitada à direita.

Algumas implementações também estendem o array para a esquerda; este é um recurso incomum e, portanto, os programas portáteis de brainfuck não dependem dele.

Quando o ponteiro se move para fora dos limites do array, algumas implementações darão uma mensagem de erro, algumas tentarão estender o array dinamicamente, algumas não perceberão e produzirão um comportamento indefinido e algumas moverão o ponteiro para o extremidade oposta da matriz. Algumas compensações estão envolvidas: expandir a matriz dinamicamente para a direita é a abordagem mais amigável e é boa para programas com muita memória, mas acarreta uma penalidade de velocidade. Se uma matriz de tamanho fixo for usada, é útil torná-la muito grande ou, melhor ainda, permitir que o usuário defina o tamanho. Fornecer uma mensagem de erro para violações de limites é muito útil para depuração, mas mesmo isso acarreta uma penalidade de velocidade, a menos que possa ser tratado pelas proteções de memória do sistema operacional.

Código de fim de linha

Diferentes sistemas operacionais (e às vezes diferentes ambientes de programação) usam versões ligeiramente diferentes de ASCII. A diferença mais importante está no código usado para o final de uma linha de texto. O MS-DOS e o Microsoft Windows usam um CRLF, ou seja, um 13 seguido por um 10, na maioria dos contextos. UNIX e seus descendentes (incluindo Linux e macOS) e Amigas usam apenas 10, e Macs mais antigos usam apenas 13. Seria difícil se os programas brainfuck tivessem que ser reescritos para diferentes sistemas operacionais. No entanto, um padrão unificado foi fácil de criar. O compilador de Urban Müller e seus programas de exemplo usam 10, tanto na entrada quanto na saída; o mesmo acontece com a grande maioria dos programas de brainfuck existentes; e 10 também é mais conveniente de usar do que CRLF. Portanto, as implementações de brainfuck devem garantir que os programas de brainfuck que assumem nova linha = 10 sejam executados corretamente; muitos o fazem, mas alguns não.

Essa suposição também é consistente com a maioria dos códigos de amostra do mundo para C e outras linguagens, pois eles usam "n", ou 10, para suas novas linhas. Em sistemas que usam terminações de linha CRLF, a biblioteca padrão C remapeia transparentemente "n" para "rn" na saída e "rn" para "n" na entrada para fluxos não abertos no modo binário.

Comportamento de fim de arquivo

O comportamento do comando , quando uma condição de fim de arquivo é encontrada varia. Algumas implementações definem a célula no ponteiro como 0, algumas definem a constante C EOF (na prática, geralmente é -1), algumas deixam o valor da célula inalterado. Não há consenso real; argumentos para os três comportamentos são os seguintes.

Definir a célula como 0 evita o uso de números negativos e torna marginalmente mais conciso escrever um loop que lê caracteres até que ocorra EOF. Esta é uma extensão de linguagem desenvolvida por Panu Kalliokoski.

Definir a célula como -1 permite que o EOF seja distinguido de qualquer valor de byte (se as células forem maiores que bytes), o que é necessário para a leitura de dados não textuais; também, é o comportamento da tradução C de , fornecida no arquivo leia-me de Müller. No entanto, não é óbvio que essas traduções C devam ser tomadas como normativas.

Deixar o valor da célula inalterado é o comportamento do compilador brainfuck de Urban Müller. Esse comportamento pode coexistir facilmente com qualquer um dos outros; por exemplo, um programa que assume EOF = 0 pode definir a célula como 0 antes de cada comando , e funcionará corretamente em implementações que fazem EOF = 0 ou EOF = "sem alteração& #34;. É tão fácil acomodar o "sem mudança" comportamento que qualquer programador fodido interessado em portabilidade deveria fazer.

Implementações

Intérpretes simples de brainfuck podem ser feitos como um exercício. Fazer um compilador ou interpretador otimizador se torna um desafio maior, assim como escrever programas no próprio brainfuck é: para produzir resultados razoavelmente rápidos, o compilador precisa juntar as instruções fragmentárias forçadas pela linguagem. As possíveis otimizações variam de simples otimizações de olho mágico de comprimento de execução em comandos repetidos e padrões de loop comuns como [-], para eliminação de código morto e dobramento constante.

Além de fazer compiladores Brainfuck rápidos, outros tipos de interpretadores Brainfuck também foram escritos:

• Vários compiladores de brainfuck foram feitos menores que 200 bytes – um é apenas 100 bytes em x86 código de máquina.
• Um motor zk-STARK que prova criptograficamente a execução de um programa Brainfuck. Porque cada construção de linguagem precisa ser aritmética, ou seja, descrito em termos de equações, Brainfuck é uma boa linguagem para um sistema de prova de conceito, porque as instruções do Brainfuck são poucas e simples.

Aritmetização

Cada instrução do Brainfuck muda o estado de sua execução do programa de maneiras que podem ser descritas usando equações polinomiais. Por exemplo, quando + aumenta o valor da célula atual por um, isso pode ser descrito com uma equação como v)+1= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =v)+1Não. v_{t}+1=v_{t+1}}, onde a variável v)Não. v_{t}} representa o valor atual da memória a passo )Não.e v)+1{displaystyle v_{t+1}} no próximo passo da execução. E quando > aumenta o que a célula de memória é a corrente por um, isso pode ser descrito com a equação semelhante p)+1= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =p)+1Não. p_{t}+1=p_{t+1}}, onde p)Não. p_{t}} e p)+1Não. p_{t+1}} é o ponteiro de memória em etapas subseqüentes da execução do programa.

Com cada transição de estado de programa válida expressa como uma equação polinomial, onde cada variável representa uma parte do estado, uma tabela que descreve cada transição de estado pode ser compilada em uma prova criptográfica de execução correta, sem revelar a própria tabela. Provas de conhecimento zero da execução correta de programas são um campo ativo de pesquisa em criptografia. Brainfuck foi em 2022 a primeira linguagem Turing completa já existente a ser aritmetizada dessa maneira.

Derivados

Muitas pessoas criaram equivalentes de brainfuck (linguagens com comandos que mapeiam diretamente para brainfuck) ou derivados de brainfuck (linguagens que estendem seu comportamento ou alteram sua semântica).

Alguns exemplos:

• Pi, que mapeia a foda do cérebro em erros em dígitos individuais de Pi.
• Verbose, que parece uma linguagem de programação tradicional, apenas o que aparece como parâmetros ou expressões são realmente partes de comandos mais longos que não podem ser alterados.
• Mais informações, em que os comandos são substituídos por palavras como 'HERP', 'DERP', 'GIGITY', etc.
• Ook!, que mapeia oito comandos do brainfuck para combinações de duas palavras de "Ook.", "Ook?", e "Ook!", jokingly projetado para ser "escrutável e legível por orangotangos" de acordo com seu criador, uma referência ao orang-utan Bibliotecário nos romances de Terry Pratchett.
• Ternary, similar ao conceito de Ook! mas em vez disso consiste em permutações dos caracteres ASCII 0, 1 e 2.
• Corpo, uma implementação do BrainFuck baseada em um sistema controlado por gestos para que os movimentos do programador sejam capturados por uma câmera de vídeo e convertidos nos 8 possíveis caracteres.
• OooWee, comandos são variações de OooWee (por exemplo, ooo,ooe,wee etc.). Inspirado no personagem Rick e Morty Sr. PoopyButthole.
• Eu uso Arch btw, que mapeia brainfuck para as palavras encontradas na frase "I Use Arch btw". Inspirado por uma frase cunhada pela comunidade Arch Linux.
• Funk do cérebro, mapas brainfuck para amostras de voz, que são usados em uma pista de dança, cujas palavras codificam um programa de foda de cérebro.
• DNA é um superset baseado em moléculas de DNA, com comandos substituídos por Nucleobase. Uma forma usa a representação hélice da molécula de DNA.
• Foda-se!², "um derivado da porra do cérebro exceto desta vez realmente engraçado". Cada termo na linguagem é um nome de outro derivado do cérebro.
• Que se lixe., um derivado do brainfuck com "mais palavras-chave intuitivas", preempted com "fuck". Desenvolvido por adolescente, Josh Schiavone.
• Mãe!, um derivado do brainfuck com variedade de comandos úteis e princípios como macros, pilha, funções, I/O conveniente, booleanos e outros tipos de simulação. Desenvolvido por Pavel Voronin.