NitroLISP Programming Language

S-expressions that compile to native executables

Lisp at the speed of thought -- AOT compiled to C++23 -- zero dependencies

.nls

➜

Tokenizer

➜

Parser

➜

Macros

➜

Analyzer

➜

C++23

➜

zig/clang

➜

.exe

Core complete

View on GitHub See it in action

The Language

Homoiconic Lisp, native output

Write S-expressions. The compiler expands macros, optimizes tail calls, emits C++23, and builds a standalone binary.

hello.nls

// A complete program in NitroLISP
(module exe hello
  (import testlib)

  (defn greet ((name : string) (times : int32)) : void
    (for (i 1 to times)
      (println "Hello, {}! ({})" name i)))

  (greet "NitroLISP" 3)
  (println "triple(7) = {}"
    (testlib.lib_triple 7)))

Terminal

$ NLC -s hello.nls -r

Hello, NitroLISP! (1)
Hello, NitroLISP! (2)
Hello, NitroLISP! (3)
triple(7) = 21

Features

Everything built in. Nothing to install.

Tokenizer, parser, macro expander, analyzer, C++ emitter, and zig/clang toolchain in one invocation.

⚙

Zero Dependencies

Pure Delphi engine, bundled zig/clang toolchain. One tool produces standalone native binaries.

⚡

AOT to C++23

S-expressions compile to clean, readable C++23. No interpreter, no VM, no bytecode layer in the output.

🧬

Real Macro System

defmacro with quasiquote, unquote, and splicing. Compile-time code transformation with gensym hygiene.

🎯

EXE, DLL, and LIB

Same source compiles to executables, dynamic libraries, or reusable library modules. Module declaration drives the output.

🐞

Built-in Debugger

Debug Adapter Protocol support provides breakpoints, stepping, call stacks, and variable inspection in VS Code.

🧠

Language Server

LSP integration delivers diagnostics, completion, hover, go-to-definition, and references in your editor.

🔄

Tail Call Optimization

Recursive algorithms that would blow the stack run in constant space. Verified at 1 million depth.

🌍

Cross-Platform

Target Win64 and Linux64 from the same source. Switch with one directive: @target linux64.

🔌

C++ Interop

Inline C++ passthrough, #include any header, declare external symbols. NitroLISP and C++ share one translation unit.

Use Cases

Built for people who ship native code

Whether you want Lisp expressiveness with native speed, or a scripting layer that compiles to machine code.

Game Developers

Scripting-language expressiveness with native compilation. Macros let you build domain-specific forms that compile away to zero overhead.

Systems Programmers

Records with bitfields and packed layout, typed pointers, inline C++ passthrough, and direct memory management. Lisp syntax, systems-level control.

Lisp Enthusiasts

A real Lisp with defmacro, quasiquote, closures, and tail-call optimization that compiles to native executables instead of running on a VM.

Embedding Scenarios

Compile NitroLISP modules as DLLs with a C-callable API, link library modules directly, or embed a NitroLISP-written interpreter for runtime scripting.

Media

See NitroLISP in action

Infographic, walkthroughs, and a deep dive into the compiler architecture.