NoB (Noticeably Better): a compiled language that tries to stay out of your way

Most new languages promise the same things: performance, simplicity, better tooling. NoB is trying to hit those too—but the interesting part is how it actually does it.

At its core, NoB is a compiled language that targets C++20, with a second execution path through a bytecode VM. That split ends up being more practical than it sounds.

• Website: https://nob-lang.omni-flows.uk/
• Source: private / proprietary
• Platforms: macOS, Linux, Windows (via WSL2)

What NoB actually is

NoB compiles .nob code into C++20, then uses clang++ to produce a native binary.

There’s also a VM mode that skips compilation entirely and runs bytecode instead.

That gives you two very different workflows:

• Native pipeline → slower startup, fast runtime
• VM pipeline → instant startup, slower runtime

In practice, it feels like using two tools under one language.

The two pipelines (and when they matter)

Native (default)

nob file.nob
nob file.nob -o app

This is what you’d use for anything serious.
• Compiles via C++20
• Uses clang++
• Runs as a native binary
• Supports everything (networking, threads, async, etc.)

VM mode

nob --vm file.nob

This skips the compiler completely.

It’s useful for:
• quick scripts
• REPL work
• testing ideas

But it’s not feature-complete. Networking, threading, and some advanced features don’t work here.

The syntax (closer to Python than C++)

The syntax leans readable without being too loose.

set name to "Alice"

function greet(name)
  return "Hello, {name}"
end

print greet("Bob")

A few things stand out:
• set vs let (mutable vs immutable)
• 1-based indexing
• string interpolation built-in
• structured blocks without braces

It’s easy to pick up, especially if you’ve used Python or Lua.

Features that are actually interesting

1. Tail-call optimization

Recursive functions don’t blow the stack if written in tail form:

function sum_tail(n, acc)
  if n == 0 then return acc end
  return sum_tail(n - 1, acc + n)
end

This gets compiled into a loop automatically.

1. Pipe operator

words
  |> filter(function(w) return len(w) > 3 end)
  |> map(function(w) return upper(w) end)
  |> sort()

It makes chained transformations easier to read.

1. Macros (compile-time)

macro swap(a, b)
  set tmp to a
  a = b
  b = tmp
end

These run at compile time, not runtime.

1. Python backend

nob py file.nob -o file.py --run

This converts NoB into Python so you can use Python libraries like NumPy or OpenCV.

There are limits (no macros, no pipe operator), but it’s useful when you need the ecosystem.

1. Built-in concurrency (native only)

set t to thread_spawn(function()
  print "running"
end)

thread_join(t)

Includes threads, mutexes, channels, and async support.

Tooling (built-in)

NoB ships with a lot already included:

nob repl
nob check file.nob
nob profile file.nob
nob fmt file.nob
nob gui

Notable pieces:
• GUI REPL (nob gui)
• formatter and profiler included
• package manager (nob pkg)

You don’t need to assemble a separate toolchain.

Performance

From the official benchmarks:

What this means
• Big gains in loops and numeric work
• Smaller gains in recursive workloads
• Much faster than Python for CPU-heavy code

Compilation targets

nob file.nob --profile simd
nob file.nob --profile cuda
nob file.nob --profile wasm

Supports:
• SIMD optimized builds
• CUDA / OpenCL
• WebAssembly
• LLVM IR

Platform support

Platform Support
macOS Native
Linux Native
Windows WSL2

Pricing (indicative)

Where it fits

NoB makes sense if you want:
• something faster than Python
• something simpler than C++
• built-in tooling without extra setup

Less ideal if you need:
• a large ecosystem
• long-established tooling

Final thoughts

NoB isn’t trying to reinvent programming. It’s trying to remove friction.

The dual pipeline is the most practical part—you can prototype quickly in VM mode, then switch to native when performance matters.

It’s early, but the core design is solid. Worth keeping an eye on.