The same task, clearly expressed

A single idea, written with different levels of ceremony.

Bash

[ -f config.json ] && echo true || echo false

Python

python3 -c "import os;print(os.path.isfile('config.json'))"

Node.js

node -e "const fs=require('fs');console.log(fs.existsSync('config.json'))"

Nexo

nexo.nx

fs_exists("config.json") |> print

In Nexo, this is the program.

Scripting today is powerful, and painful.

Shell scripts are brittle

Small changes can have big effects. Error handling is often implicit.

Python scripts grow

A "quick script" often turns into hundreds of lines of imports, boilerplate and edge cases.

Tooling is bolted on

Linters, formatters, type checks. Set up separately, configured differently.

Nexo was designed to reduce this friction.

What is Nexo?

A compiled scripting language designed for automation, data flows and system tasks. Clean syntax. Built-in tooling. No ceremony.

Pipeline-first syntax

Chain operations with |> for clear, readable data flows.

Built-in linter & strict mode

Static analysis catches errors before runtime. No extra setup.

Made for glue code

File ops, shell commands, JSON, C FFI and Python. All built in.

Compiles to bytecode

Compile once to .nxbc, run anywhere with the Nexo VM.

Think in flows, not instructions.

The pipeline operator |> lets you chain transformations the way you actually think about data, step by step.

transform.nx

import fs

# Read a JSON config, filter active items, and save the result
data = fs.read("config.json")
    |> json_parse
    |> filter(fn(item): item.active)
    |> json_stringify

fs.write("active.json", data)
print("Done. Filtered and saved.")

This is how automation should read.

Catch problems early.

Nexo ships with static analysis and strict mode out of the box. No plugins to install, no configs to maintain.

Built-in linter catches errors before they run
Strict mode enforces cleaner, safer code
Explicit module imports make dependencies visible
Structured error handling with try/catch

"Write scripts you can trust."

terminal

$ nexo lint --strict deploy.nx

warning: unused variable 'tmp' (line 12)
error: unreachable code after return (line 24)

$ nexo run deploy.nx
Deploy complete.

What people build with Nexo

Real tasks, not toy examples.

File automation

List, read, write, rename and organize files with the fs module.

Data transformations

Parse JSON, filter, map and reduce data through clean pipelines.

System scripts

Run shell commands, check exit codes, and orchestrate processes with proc.

CLI tools

Build small command-line utilities that do one thing well.

Glue between tools

Call C libraries via FFI, run Python scripts, and bridge ecosystems.

Deploy scripts

Automate builds, deployments and repetitive ops tasks.

See it in action

Real examples. Runnable code. No fluff.

Pipeline Operator

Chain transformations with |>

# Transform data step by step
numbers = [1, 2, 3, 4, 5]

result = numbers
    |> filter(fn(x): x > 2)
    |> map(fn(x): x * 2)
    |> reduce(fn(a, b): a + b, 0)

print(result)  # 24

File Operations

Read, write, and list files

import fs

# Read file contents
content = fs.read("config.json")

# Write to file
fs.write("output.txt", "Hello, Nexo!")

# List and iterate
files = fs.list("./src")
for file in files:
    print(file)

Process Execution

Run shell commands and inspect results

import proc

# Run a command
result = proc.run("ls -la")
print(result.out)

# Check for errors
if result.code != 0:
    print("Error: " + result.err)

JSON Handling

Parse and stringify JSON natively

# Parse JSON string
data = json_parse('{"name": "Nexo", "v": 9}')
print(data.name)  # Nexo

# Create JSON output
obj = {"status": "ok", "count": 42}
print(json_stringify(obj))

C FFI

Call C libraries directly

# Load a shared library
lib = ffi_load("mymath.so")

# Call an exported C function
result = ffi_call(lib, "add", [10, 20])
print("10 + 20 = " + str(result))

Python Interop

Run Python scripts and get structured output

import py

# Run Python script with input
data = py.run("process.py", "input")

# Python returns JSON via stdout
print(data.result)
print(data.items)

Built to last.

Nexo is not a prototype. It's a language with its own compiler, VM and toolchain, written in Rust.

nexo run

Execute .nx source or .nxbc bytecode directly

nexo --emit

Compile to bytecode without executing. Portable and versioned

nexo lint

Static analysis with optional --strict mode

nexo repl

Interactive REPL with multiline support

nexo lsp

Language Server Protocol. Works with VS Code, Neovim and more

Design philosophy

One line should do real work

No setup, no boilerplate. Express intent directly.

Flow over ceremony

Pipelines are a first-class concept, not an afterthought.

Safety is not optional

Static analysis and strict mode ship with the language.

Fewer features, more composition

Small primitives that combine well beat large APIs.

Tooling is part of the language

Linter, REPL and LSP. Not third-party add-ons.

Interop over re-invention

Call C, run Python, pipe shell commands. Use what already works.

Get started

Pick your platform and start scripting with Nexo.

Current version: v1.0

Windows

x86_64

Installer (.exe) Recommended Portable (.zip) Manual PATH setup

macOS

Intel & Apple Silicon

Download .tar.gz

Linux