Reduces cognitive friction, lets the focus be the idea.

Basic Next (or, as we fondly call it, BN) is a programming language for anyone who wants less cognitive friction in the programming process. Its focus is programming logic and building solutions. Welcome to version 0.6.0.

Try it ↗ Learn it ↗

In the age of Artificial Intelligence, Basic Next is a language for humans. It was built as a low-friction interface between people and the machine. You can vibe-code applications without making them hard for humans to read. It follows object-oriented principles, and it was designed to be extensible and powerful.

Read the author’s note

hello.bn
FUNCTION Start() AS VOID
  PRINT "Welcome to Basic Next"
  LET counter AS INTEGER = 0

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

How to start quickly

Install bn. Write. Run.

Linux and macOS: one command installs 0.6.0 under /opt/basicnext. Windows: clone + install.ps1 (default %LOCALAPPDATA%\Programs\BasicNext). Then: bn run.

1 · Linux / macOS

Install to /opt/basicnext

Fetches install.sh from GitHub, downloads the v0.6.0 release, and installs into that prefix. Uses sudo when /opt is not writable.

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

With Rust and Git, clone the repo and run the installer. Default prefix is %LOCALAPPDATA%\Programs\BasicNext (no admin) and bin is added to the user PATH.

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

Custom prefix: -Prefix C:\Tools\BasicNext. Ready-made assets also on GitHub Releases.

3 · Hello

First program

Save as hello.bn and run it. There is also a VS Code plugin in alpha.

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

Useful examples

Code you can read out loud.

Short BN-style snippets: FUNCTION Start, LET … AS TYPE, PRINT. Copy, adapt, run.

Conversion

Fahrenheit → Celsius

Explicit types and clear arithmetic.

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

Text

Word counter

Walk the string; count words with no hidden magic.

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

Recursion

Factorial

The classic example from the repository.

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

Sum 1 through N

Explicit accumulator, visible intent.

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

Why use it

Concrete benefits — no empty marketing.

BN exists to cut friction between idea and program — and to teach with visible contracts.

Small Core

Reserved words cover only the fundamentals. Everything else comes through imported modules.

Explicit Typing

Every declaration states its type. No magic, no runtime surprises.

Host by Capability

Programs target console, files, network — not Windows or Linux.

Built to Teach

Types, memory, and control flow stay visible. Real learning without cryptic syntax.

Read the philosophy document and the book.

Author’s note

Why I created Basic Next

Carlos Alvaro Quintela, from the book preface.

Words from the builder

Hello everyone. My name is Carlos Alvaro Quintela, and I want to introduce you to Basic Next—a programming language I created to solve a deeply personal pain point that I know affects many developers: the loss of intuition, fluidity, and genuine joy in turning ideas into software.

Programming used to be fun. For me, building a system or creating a game wasn’t an exercise in mental exhaustion, nor a battle against complex frameworks, endless configurations, and unnecessary verbosity.

When we program at our best, we enter what psychology calls the State of Flow—that moment of absolute focus where the tool vanishes, the mind connects directly with the system, and hours pass without us noticing. Idea → zero syntactic friction → program.

Throughout my career I’ve worked with dozens of languages and paradigms. With the rise of vibe coding we generate massive volumes of code—but staying trapped almost exclusively in Python, the language AI models tend to favor, doesn’t feel like the most rewarding experience for those who lived through the golden era of BASIC and Pascal. And while C remains one of my favorites, its cognitive load is extremely high: pointers and function pointers break Flow and drain energy away from creation.

Basic Next was born to eliminate that energy loss. It is engineered to be simple, powerful, intuitive, and to have an extremely low learning curve.

Core pillars: KISS (a small, predictable core); direct, frictionless writing; absolute transparency (mandatory types, explicit paths, no magic); modularity and extensibility; and a hardware isolation layer so you can port without rewriting the application.

It distills the best of several traditions—BASIC (clarity and excitement), Pascal (elegance and explicit declarations), C (minimalist core), C++ (practical OO), R (vectorized math)—and leaves behind Python’s implicit typing and historical friction, and Java’s bureaucracy of endless abstractions.

Beyond reclaiming Flow for experienced developers, the primary commitment is to be an exceptional educational tool: allocation, types, control flow, and memory stay understandable without cryptic syntax. Strict semantic analysis catches errors early and keeps learning as discovery rather than frustration.

Basic Next bridges rigorous software engineering, ease of learning, and pure creative freedom. It was built for those who want to create deterministic systems, teach the essence of computer science, and, above all, enter the Flow state and have fun programming again.

Thank you!

Full preface in the book ↗

Open source · MPL 2.0

0.6.0 to follow today.

Read our philosophy document, run the examples, and get the free version on GitHub.

See 0.6.0 on GitHub ↗ Releases ↗