Nexus

Nexus has two kinds of variables. Use let to declare immutable variables -- once assigned, they cannot be changed. Use var for mutable variables that you intend to update later. This distinction helps catch bugs early: if a value should stay constant (a name, a config, a computed result), let ensures it is never accidentally overwritten.

-- IMMUTABLE: once you set it, it stays forever
let pi = 3.14159
let greeting = "Hello, Nexus!"
let is_ready = yes
let nothing_here = nothing

-- MUTABLE: you can reassign as many times as needed
var score = 0
score = score + 10       -- score is now 10
score = score * 2        -- score is now 20

-- Trying to reassign a let variable will cause an error
-- pi = 3.0   ERROR: cannot reassign immutable variable

The Seven Data Types

Nexus is dynamically typed -- you never write type annotations. The interpreter determines the type from the value you assign. Every value in Nexus belongs to one of these seven types:

Type Checking and Conversion

Use type(value) to check the type of any value at runtime. It returns the type name as a string. Use string(), int(), and float() to convert between types:

say type(42)           -- "Int"
say type(3.14)         -- "Float"
say type("Hello")      -- "Text"
say type(yes)          -- "Bool"
say type([1,2,3])     -- "List"
say type(nothing)      -- "Nothing"

-- Converting between types
let num = int("42")    -- text to integer: 42
let dec = float("3.14") -- text to float: 3.14
let txt = string(100)  -- number to text: "100"

-- String concatenation auto-converts numbers
say "Score: " + 42     -- "Score: 42"

Common Mistakes for New Users

If you are coming from Python, JavaScript, or other languages, watch out for these differences:

• Use yes / no instead of true / false
• Use nothing instead of null, None, or undefined
• Use is / isnt instead of == / !=
• Strings must use double quotes "..." -- single quotes are not supported

Functions in Nexus are defined by writing the function name followed by its parameters, with the body indented below (4 spaces). There is no def, func, or function keyword -- just the name. Functions must be defined before they are called.

Defining and Calling Functions

-- Define a function: name, then parameters, then indented body
greet name
    say "Hello, " + name + "!"

-- Call it (two styles -- both work)
greet("Alice")          -- parentheses style
greet "Bob"             -- bare call style (no parens)

-- Function with multiple parameters
add x, y
    return x + y

say add(10, 20)         -- 30

Return Values

Use return to send a value back to the caller. If you forget return, the function returns nothing by default. This is a common mistake -- always include return when you need a result.

-- WRONG: computes but does not return
bad_add x, y
    x + y                -- this value is lost!

-- CORRECT: explicitly returns the result
good_add x, y
    return x + y         -- caller receives the value

say bad_add(2, 3)      -- nothing
say good_add(2, 3)     -- 5

Recursion

Functions can call themselves. This is useful for problems that have a naturally recursive structure, like computing factorials, traversing trees, or generating Fibonacci numbers.

factorial n
    if n <= 1
        return 1
    return n * factorial(n - 1)

say factorial(5)        -- 120 (5*4*3*2*1)
say factorial(10)       -- 3628800

fib n
    if n <= 1
        return n
    return fib(n - 1) + fib(n - 2)

say fib(10)             -- 55

Nexus provides several ways to make decisions in your code. All block structures use 4-space indentation to define the body -- there are no curly braces or end keywords.

If / Elif / Else

The basic conditional. elif (short for "else if") lets you chain multiple conditions. The else block runs when no preceding condition was true.

let score = 85

if score >= 90
    say "Grade: A"
elif score >= 80
    say "Grade: B"       -- this runs (85 >= 80)
elif score >= 70
    say "Grade: C"
else
    say "Grade: F"

Unless

The opposite of if. The block runs only when the condition is false. Useful for guard clauses and negative checks.

let logged_in = no

unless logged_in
    say "Please log in first"    -- runs because logged_in is no

Match (Pattern Matching)

Like switch in other languages, but cleaner. Compares a value against multiple patterns. Use _ as the default/wildcard case that matches anything.

let status = 404

match status
    200 -> say "OK - Request succeeded"
    301 -> say "Moved permanently"
    404 -> say "Not Found"            -- this matches
    500 -> say "Server Error"
    _ -> say "Unknown status: " + status

-- Works with strings too
let fruit = "apple"
match fruit
    "apple"  -> say "Red or green"
    "banana" -> say "Yellow"
    _ -> say "Unknown fruit"

Comparison Operators

Nexus uses English words for equality: is (equals), isnt (not equals). Standard symbols work for ordering: <, >, <=, >=. Logical operators: and, or, not.

if x is 42               -- equality (NOT ==)
if x isnt 0              -- inequality (NOT !=)
if x > 10 and x < 100    -- logical AND
if x is 0 or x is 1     -- logical OR
if not done              -- logical NOT

Nexus offers four loop types, each suited to different situations. All loops use 4-space indentation for the body. Nexus includes a safety limit of 100,000 iterations to prevent infinite loops from freezing your program.

For Loop (Range)

Iterates over a numeric range. The range is inclusive on both ends (unlike Python). Use by to set a custom step.

-- Counts 1, 2, 3, 4, 5 (inclusive on both ends)
for i in 1 to 5
    say i

-- With a step: 0, 10, 20, 30, ..., 100
for i in 0 to 100 by 10
    say i

For Loop (List Iteration)

Iterates over every element in a list, string, or other collection. The variable takes each value in order.

let colors = ["crimson", "gold", "ivory"]
for color in colors
    say "Color: " + color

-- Iterate over characters in a string
for ch in "Nexus".chars
    say ch         -- N, e, x, u, s

While Loop

Repeats as long as a condition is true. Make sure the condition eventually becomes false, otherwise you will hit the 100,000 iteration safety limit.

var n = 1
while n < 1000
    say n          -- 1, 2, 4, 8, 16, ...
    n = n * 2

Repeat N Times

Runs a block exactly N times. Simpler than a for loop when you do not need the counter variable.

repeat 3 times
    say "Hip hip hooray!"

Skip and Stop (Continue and Break)

Use skip to jump to the next iteration (like continue in other languages). Use stop to exit the loop entirely (like break).

-- Print only odd numbers up to 10
for i in 1 to 20
    if i mod 2 is 0
        skip           -- skip even numbers
    if i > 10
        stop           -- stop at 10
    say i              -- 1, 3, 5, 7, 9

Nexus strings (type Text) support a rich set of properties and methods. Properties are accessed without parentheses and return a computed value. Methods take arguments and require parentheses. This distinction matters -- forgetting parentheses on a method will not call it.

Properties (No Parentheses)

Methods (Require Parentheses)

String Indexing

Access individual characters by index (0-based). Negative indices count from the end: -1 is the last character, -2 is second to last, etc.

let s = "Nexus"
say s[0]           -- "N" (first character)
say s[-1]          -- "s" (last character)
say s[-2]          -- "u" (second from end)

String Concatenation

Use + to join strings. Numbers are auto-converted when concatenated with a string:

let first = "Hello"
let last = "World"
say first + ", " + last + "!"    -- "Hello, World!"
say "Age: " + 25                  -- "Age: 25" (auto-converts)

Lists are ordered, mutable collections that can hold values of any type. They are created with square brackets [] and support indexing, slicing, and a wide range of built-in methods. Lists are zero-indexed (the first element is at index 0).

Creating and Accessing Lists

let nums = [10, 20, 30, 40, 50]
let mixed = [1, "two", yes, [3, 4]]  -- mixed types, nested lists
let empty = []                          -- empty list

-- Access by index (0-based)
say nums[0]          -- 10 (first element)
say nums[2]          -- 30 (third element)

-- Negative indexing (count from end)
say nums[-1]         -- 50 (last element)
say nums[-2]         -- 40 (second from end)

-- Properties
say nums.length      -- 5
say nums.first       -- 10
say nums.last        -- 50
say nums.is_empty    -- no

Mutation Methods

These methods modify the list in place. Use var (not let) if you plan to mutate the list.

Non-Mutating Built-in Functions

These return a new list/value without changing the original:

Higher-Order Functions

Pass functions to map, filter, and reduce for functional-style list processing:

double x
    return x * 2

say map(double, [1,2,3])    -- [2, 4, 6]

is_even x
    return x mod 2 is 0

say filter(is_even, [1,2,3,4])  -- [2, 4]

Tables are key-value collections, similar to dictionaries in Python, objects in JavaScript, or hashmaps in Java. Keys are always strings. Values can be any type, including other tables or lists.

Creating and Accessing Tables

let user = {
    name: "Alice",
    age: 30,
    role: "Engineer",
    active: yes
}

-- Access with dot notation
say user.name         -- "Alice"
say user.age          -- 30

Table Properties and Methods

Nested Tables

let config = {
    app: "Nexus",
    version: 1,
    settings: {
        theme: "dark",
        font_size: 14
    }
}

say config.settings.theme    -- "dark"

Structs let you define custom data types with named fields and methods. They are like lightweight classes. Define a struct with the struct keyword, list its fields with type annotations, and optionally add methods.

struct Point
    x: Float
    y: Float

    magnitude
        return sqrt(x * x + y * y)

    distance other
        let dx = x - other.x
        let dy = y - other.y
        return sqrt(dx * dx + dy * dy)

-- Create instances by calling the struct like a function
let a = Point(3, 4)
let b = Point(0, 0)

say a.x                -- 3
say a.y                -- 4
say a.magnitude()      -- 5.0
say a.distance(b)      -- 5.0

Example: A Rectangle Struct

struct Rectangle
    width: Float
    height: Float

    area
        return width * height

    perimeter
        return 2 * (width + height)

    is_square
        return width is height

let r = Rectangle(10, 5)
say "Area: " + r.area()            -- 50
say "Perimeter: " + r.perimeter()  -- 30
say "Square? " + r.is_square()     -- no

Nexus ships with 60+ built-in functions organized into categories. These are available everywhere without imports. Each function is listed below with its purpose and signature.

Math Functions

Constants: pi = 3.14159... and e = 2.71828... are available as global constants.

Aggregation Functions

I/O Functions

Random Functions

Date/Time and Misc

A complete reference of all operators in Nexus, from arithmetic to logic. Nexus uses English words for equality and boolean logic, making code read more naturally.

Operator Precedence (Highest to Lowest)

When multiple operators appear in one expression, higher-precedence operators bind first. Use parentheses to override:

-- ^ binds before *
say 2 + 3 * 4          -- 14 (not 20)
say (2 + 3) * 4        -- 20 (parentheses override)
say 2 ^ 3 ^ 2          -- 512 (2^(3^2) = 2^9)

You can download Nexus directly from this website using the buttons at the top of the page, or follow these platform-specific instructions. Nexus requires PowerShell (included on Windows, installable on Mac/Linux). No other dependencies are needed.

Option 1: Download from This Website

Click the Download Nexus (Universal) button in the header. Extract the downloaded `nexus.zip` folder. Open a terminal inside the extracted nexus folder, and run your .nx programs:

-- Windows (PowerShell)
.\nexus-lang.ps1 run examples\hello.nx

-- macOS / Linux (Bash)
chmod +x nexus.sh
./nexus.sh run examples/hello.nx

Option 2: Clone the Full Repository (includes examples)

-- All platforms:
git clone https://github.com/nexus-lang/nexus.git
cd nexus

Windows Setup

Windows comes with PowerShell pre-installed. Just open PowerShell or Terminal and run:

.\nexus-lang.ps1 run examples\hello.nx
.\nexus-lang.ps1 repl                    -- interactive mode

macOS Setup

Install PowerShell via Homebrew, then run:

brew install powershell/tap/powershell
chmod +x nexus.sh
./nexus.sh run examples/hello.nx

Linux Setup (Ubuntu/Debian)

sudo snap install powershell --classic
chmod +x nexus.sh
./nexus.sh run examples/hello.nx

Linux Setup (Fedora)

sudo dnf install powershell
chmod +x nexus.sh
./nexus.sh run examples/hello.nx

Linux Setup (Arch)

yay -S powershell-bin
chmod +x nexus.sh
./nexus.sh run examples/hello.nx

Writing Code (VS Code Extension)

Create files with the .nx extension in any text editor. For the best experience, install the official Nexus VS Code Extension included in your download:

1. Open VS Code.
2. Press Ctrl+Shift+X (or Cmd+Shift+X) to open the Extensions panel.
3. Click the ... menu at the top right of the Extensions panel and select "Install from VSIX..."
4. Select the nexus-lang-1.0.0.vsix file located inside your downloaded nexus-vscode folder!

This provides syntax highlighting, auto-indentation, and bracket matching for Nexus. Run programs from your terminal using the repl command for an interactive prompt.