Learn · 15 minutes

Getting started

By the end of this page you will have written a function with your hand, sent it to a coding agent and watched the checks come back. You need a Mac or Linux machine, an agent you already use, and a band. If you do not have a band yet, skip step 2: everything else works from the keyboard.

1. Install

The installer puts three binaries on your path: nl (the command-line tool), nlc (the compiler) and nld (the band daemon).

# macOS and Linux
curl -fsSL https://neuralang.org/install | sh

# or with Homebrew
brew install neuralang/tap/neuralang

nl --version
nl 0.3.1 (preview) · nlc 0.3.1 · nld 0.3.1

The toolchain is a single static binary per tool and has no runtime dependencies. Shell completions are generated with nl completions zsh.

2. Pair a band

The daemon listens for gesture events and writes them to a session file. Start it once; it stays resident.

nl band pair meta
→ open neuralang on your Meta Ray-Ban Display and accept the pairing prompt
✓ paired · meta.neural-band · 16 ch · gesture events over local socket

nl band test
pinch.index   0.99   ← pinch your index finger to your thumb
swipe.down    0.97   ← thumb down across the side of your index
roll.cw       0.95   ← roll your wrist clockwise
write         ok     ← write "hello" on the table in front of you

The Meta Neural Band talks only to Meta Ray-Ban Display today, so the pairing goes through a small web app on the glasses that forwards gesture events to nld. Other bands use an adapter; see Hardware.

Run nl band calibrate once if your handwriting decodes badly. It takes two minutes and typically improves recognition by about a sixth.

3. Your first program

Open a session in the directory of a project you want to change. From here, every gesture becomes a token in ship.nl, and the text form updates live in the terminal.

cd ~/code/uploader
nl session ship.nl

Now perform this sequence. The gesture is on the left, what it produces on the right.

Gesture	Token	Meaning
`tap.double`	`fn`	start a function
`write` “ship”	`ship`	its name
`pinch.index`	`{`	open the body
`swipe.down`	`intent`	an instruction follows
`write` “make no mistakes”	`"make no mistakes"`	the instruction, as a string
`swipe.up`	`verify`	a check follows
`write` “tests pass”	`tests.pass`	the check, as a name
`pinch.middle`	`}`	close the body

Your terminal now shows:

fn ship {
  intent "make no mistakes"
  verify tests.pass
}

Made a slip? roll.ccw removes the last token. Two rolls remove the whole statement.

4. Run it against an agent

Roll your wrist clockwise. That is run, and it compiles the function and sends the plan to whichever agent the session is configured for. Set the agent once per project:

nl agent use claude-code       # or: codex, cursor, gemini, stdin
✓ ship.nl · use agent claude-code

# roll.cw, or from the keyboard:
nl run ship
nlc 0.3.1 · ship.nl
✓ ship · 1 intent · 1 check · 38 ms
✓ sent to claude-code (stdin) · waiting on checks…
✓ tests.pass · 41 passed · 0 failed · 12.4 s
✓ ship done · branch nl/ship-2026-10-14

The agent's work lands on a branch named after the function. If a check fails, nlc reports which one and the branch stays where it is for you to look at.

5. The text form

Everything above is also just a file. This is the same program with a header, two more statements and a capability rule:

use band meta.neural-band
use agent claude-code

fn ship {
  intent "add retry with backoff to the upload client"
  intent "make no mistakes"
  verify tests.pass
  verify lint.clean
  deny net.write
}

run ship

use lines are the header. They are typed, not gestured, and are optional: nl fills them from your session and project settings.
Intents are passed to the agent in order, as one brief. Write them the way you would brief a colleague.
Checks are names the agent's environment knows how to run: tests.pass, lint.clean, build.ok, types.ok, or any script under .nl/checks/.
allow and deny set capabilities for the run. Deny wins. The defaults are in .nl/policy.nl.

6. Command reference

Command	What it does
`nl session FILE`	Open a live session writing to FILE. Gestures append tokens; the text form prints as it changes.
`nl run NAME`	Compile a function and send it to the configured agent. Same as `roll.cw`.
`nl band pair \| test \| calibrate`	Manage the band. `calibrate` builds the per-wearer handwriting profile.
`nl agent use NAME`	Choose the agent: `claude-code`, `codex`, `cursor`, `gemini` or `stdin`.
`nlc FILE`	Compile without running. Prints the plan and the checks it will enforce.
`nl fmt FILE`	Canonical formatting for the text form.
`nl log`	Show the gesture log for the current session with confidences.

What next

Read the language specification. It is short.
Put .nl files in your repository next to the code they describe. They review well.
Write intents you would be comfortable reading back in a month. The agent will take them literally.