Reduz atrito cognitivo, permite que o foco seja a ideia.

A Basic Next (ou como chamamos carinhosamente, BN) é uma linguagem de programação para quem quer menos atrito cognitivo no processo de programação, seu foco vai para a lógica de programação e para a construção de soluções. Bem-vindo à versão 0.6.0.

Experimente ↗ Aprenda ↗

Na era da Inteligência Artificial, o Basic Next é uma linguagem para humanos. Foi criada para ser uma interface de comunicação de humanos com a máquina, com baixo atrito cognitivo. Permite construir aplicações com vibe coding, mas sem ficar difícil para humanos lerem. Leva em conta princípios de orientação a objetos, e foi feita para ser expansível e poderosa.

Ler o depoimento do autor

hello.bn
FUNCTION Start() AS VOID
  PRINT "Bem-vindo ao Basic Next"
  LET counter AS INTEGER = 0

  WHILE counter < 10
    PRINT "Basic Next: ", counter
    counter += 1
  END WHILE
END FUNCTION

Como começar rápido

Instale o bn. Escreva. Rode.

Linux e macOS: um comando instala a 0.6.0 em /opt/basicnext. Windows: clone + install.ps1 (instala em %LOCALAPPDATA%\Programs\BasicNext). Depois: bn run.

1 · Linux / macOS

Instalar em /opt/basicnext

Puxa o install.sh do GitHub, baixa a release v0.6.0 e instala o prefixo. Usa sudo se /opt não for gravável.

curl -fsSL https://raw.githubusercontent.com/cquintella/BasicNext/main/scripts/install.sh | BN_VERSION=v0.6.0 bash -s -- --prefix /opt/basicnext
export PATH="/opt/basicnext/bin:$PATH"

2 · Windows

PowerShell + install.ps1

Com Rust e Git, clone o repositório e rode o instalador. O padrão é %LOCALAPPDATA%\Programs\BasicNext (sem admin) e o bin entra no PATH do usuário.

git clone https://github.com/cquintella/BasicNext.git
cd BasicNext
powershell -ExecutionPolicy Bypass -File .\scripts\install.ps1

Prefixo customizado: -Prefix C:\Tools\BasicNext. Assets prontos também em GitHub Releases.

3 · Hello

Primeiro programa

Salve como hello.bn e execute. Há também um plugin em alpha para VS Code.

hello.bn
FUNCTION Start() AS VOID
  PRINT "Hello, Basic Next"
END FUNCTION
bn run hello.bn

Exemplos úteis

Código que se lê em voz alta.

Trechos curtos no estilo BN: FUNCTION Start, LET … AS TYPE, PRINT. Copie, adapte, rode.

Conversão

Fahrenheit → Celsius

Tipos explícitos e aritmética clara.

fahrenheit.bn
FUNCTION Start() AS VOID
  LET fahrenheit AS FLOAT = 98.6
  LET celsius AS FLOAT = (fahrenheit - 32.0) * 5.0 / 9.0
  PRINT "Celsius: ", celsius
END FUNCTION

Texto

Contador de palavras

Percorre a string, conta palavras sem mágica oculta.

words.bn
FUNCTION CountWords(text AS STRING) AS INTEGER
  LET words AS INTEGER = 0
  LET inWord AS BOOLEAN = FALSE
  LET i AS INTEGER = 0
  WHILE i < LEN(text)
    LET ch AS STRING = text[i]
    IF ch = " " THEN
      inWord = FALSE
    ELSE IF NOT inWord THEN
      inWord = TRUE
      words += 1
    END IF
    i += 1
  END WHILE
  RETURN words
END FUNCTION

FUNCTION Start() AS VOID
  LET phrase AS STRING = "Basic Next lowers friction"
  PRINT "Words: ", CountWords(phrase)
END FUNCTION

Recursão

Fatorial

O exemplo clássico do repositório.

factorial.bn
FUNCTION Factorial(value AS INTEGER) AS INTEGER
  IF value = 0 THEN
    RETURN 1
  ELSE
    RETURN value * Factorial(value - 1)
  END IF
END FUNCTION

FUNCTION Start() AS INTEGER
  LET value AS INTEGER = 10
  LET result AS INTEGER = Factorial(value)
  PRINT "Factorial of ", value, " is ", result
  RETURN 0
END FUNCTION

Loop

Soma de 1 até N

Acumulador explícito, intenção visível.

sum.bn
FUNCTION SumTo(n AS INTEGER) AS INTEGER
  LET total AS INTEGER = 0
  LET i AS INTEGER = 1
  WHILE i <= n
    total += i
    i += 1
  END WHILE
  RETURN total
END FUNCTION

FUNCTION Start() AS VOID
  PRINT "Sum 1..100 = ", SumTo(100)
END FUNCTION

Por que usar

Benefícios concretos, sem marketing vazio.

BN existe para reduzir atrito entre ideia e programa — e para ensinar com contratos visíveis.

Core Pequeno

Palavra reservada só pro fundamental. O resto entra por módulo importado.

Tipagem Explícita

Toda declaração diz o tipo. Sem mágica, sem surpresa na hora de rodar.

Host por Capability

O programa mira console, arquivos, rede — não Windows ou Linux.

Feita para Ensinar

Tipos, memória e fluxo ficam visíveis. Dá pra aprender de verdade sem sintaxe críptica.

Leia o documento de filosofia e o livro.

Depoimento do autor

Por que eu criei o Basic Next

Carlos Alvaro Quintela, no prefácio do livro.

Palavras do criador

Olá. Meu nome é Carlos Alvaro Quintela, e quero apresentar o Basic Next — uma linguagem que criei para resolver uma dor profundamente pessoal, e que sei que afeta muita gente: a perda de intuição, fluidez e alegria genuína ao transformar ideias em software.

Programar já foi divertido. Montar um sistema ou criar um jogo não era um exercício de exaustão mental, nem uma batalha contra frameworks complexos, configurações infinitas e verbosidade desnecessária.

Quando programamos no melhor de nós, entramos no que a psicologia chama de estado de Flow — aquele momento de foco absoluto em que a ferramenta some, a mente se conecta direto com o sistema, e as horas passam sem a gente perceber. Ideia → zero atrito sintático → programa.

Na carreira, trabalhei com dezenas de linguagens e paradigmas. Com o vibe coding, geramos volumes enormes de código — mas ficar preso quase só em Python, a linguagem que os modelos de IA favorecem, não é a experiência mais gratificante para quem viveu a era dourada do BASIC e do Pascal. Já o C continua entre as minhas favoritas, mas a carga cognitiva é altíssima: ponteiros e ponteiros de função quebram o Flow e drenam energia da criação.

Basic Next nasceu para eliminar essa perda de energia. É uma linguagem pensada para ser simples, poderosa, intuitiva e com curva de aprendizado baixa.

Pilares: KISS (núcleo pequeno e previsível); escrita direta, sem atrito; transparência absoluta (tipos obrigatórios, caminhos explícitos, sem mágica); modularidade; e uma camada de isolamento de hardware para portar sem reescrever a aplicação.

Absorve o melhor de várias tradições — BASIC (clareza e entusiasmo), Pascal (elegância e declarações explícitas), C (núcleo minimalista), C++ (OO prática), R (operações vetorizadas) — e deixa para trás o tipagem implícita e o atrito histórico do Python, e a burocracia de abstrações do Java.

Além de devolver o Flow a quem já programa, o compromisso central é ser uma ferramenta excepcional de ensino: alocação, tipos, fluxo e memória ficam compreensíveis, sem penalizar o aluno com sintaxe críptica. A análise semântica estrita pega erros cedo e mantém o aprendizado como descoberta.

Basic Next une engenharia rigorosa, facilidade de aprender e liberdade criativa. Foi feito para quem quer sistemas determinísticos, ensinar a essência da computação e, acima de tudo, entrar no Flow e se divertir programando de novo.

Obrigado!

Prefácio completo no livro ↗

Open source · MPL 2.0

0.6.0 para acompanhar hoje.

Leia o nosso documento de filosofia, rode os exemplos e pegue a versão grátis no GitHub.

Ver 0.6.0 no GitHub ↗ Releases ↗