Pyro Documentation

Welcome to the official documentation for the Pyro programming language. Pyro is a compiled language with 23 keywords, 76 built-in modules, and native C++ speed.

Installation

Install Pyro on your system in under a minute. Pre-built binaries — no compilers or build tools needed.

Linux / macOS

Copycurl -fsSL https://aravindlabs.tech/pyro-lang/install.sh | bash

Windows (PowerShell)

Copyirm https://aravindlabs.tech/pyro-lang/install.ps1 | iex

Downloads Pyro + MinGW C++ toolchain automatically. No Visual Studio, no restarts, no admin needed.

Build from Source (advanced)

Copygit clone https://github.com/krish9219/pyro.git
cd pyro
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
sudo make install

Verify the installation:

Copypyro --version
# Pyro Programming Language v1.0.0

Hello World

Create a file called hello.ro:

Copy# No main() needed — just write code
print("Hello, World!")

Run it:

Copypyro run hello.ro

Or compile and run the binary:

Copypyro build hello.ro -o hello
./hello

Your First Program

Let's build a small program that reads a name and greets the user:

Copyimport io

print("What is your name?")
name = io.readline()
print("Hello, " + name + "! Welcome to Pyro.")

# Pipe operator example
squares = [1, 2, 3, 4, 5] |> map(|x| x * x)
big = squares |> filter(|x| x > 5)
big |> each(|x| print("Square: {x}"))

Using the REPL

Start the interactive REPL with:

Copypyro repl

Pyro 1.0.0 REPL — Type :help for commands, :quit to exit
>>> x = 42
>>> x * 2
84
>>> [1,2,3] |> map(|x| x + 10)
[11, 12, 13]

Variables & Types

Pyro is statically typed with type inference. Just assign values directly — no keyword needed. Use mut for mutable variables. The optional let keyword can enforce immutability explicitly.

Copy# Simple assignment (no keyword needed)
name = "Pyro"            # type inferred as str
age = 1                  # int
pi = 3.14159             # float
active = true            # bool
data = nil               # nil value

# Mutable (use mut when you need to reassign)
mut counter = 0
counter = counter + 1

# Optional: use let for explicit immutability
# let locked = 42  # compiler enforces no reassignment

# Collections
list = [1, 2, 3]                        # List<int>
map = { "a": 1, "b": 2 }               # Map<str, int>
tuple = (1, "hello", true)              # (int, str, bool)

Built-in Types

Functions

Functions are first-class citizens in Pyro. Declare them with fn.

Copy# Basic function
fn greet(name)
    return "Hello, " + name + "!"

# One-liner
fn add(a, b) = a + b

# Default parameters
fn power(base, exp = 2)
    mut result = 1
    for _ in 0..exp
        result = result * base
    return result

# Higher-order functions
fn apply_twice(f, val)
    return f(f(val))

print(greet("World"))
print(power(3))         # 9 (default exp=2)
print(power(2, 10))    # 1024
print(apply_twice(|x| x * 2, 3))  # 12

Control Flow

Copy# If / else
if score >= 90
    status = "A"
else if score >= 80
    status = "B"
else
    status = "C"

# For loops
for i in 0..10
    print(i)

for item in my_list
    print(item)

# While loop
mut n = 10
while n > 0
    print(n)
    n = n - 1

# While true with break
while true
    input = io.readline()
    if input == "quit"
        return
    print("You said: " + input)

Structs

Copyimport math

# Structs hold data
struct Point
    x = 0.0
    y = 0.0

# Use functions to operate on structs
fn distance(a, b)
    dx = a.x - b.x
    dy = a.y - b.y
    return math.sqrt(dx * dx + dy * dy)

mut a = Point()
a.x = 0.0
a.y = 0.0

mut b = Point()
b.x = 3.0
b.y = 4.0

print(distance(a, b))   # 5.0
print("Point: ({b.x}, {b.y})")

Enums

Copyenum Color
    Red
    Green
    Blue

fn describe(c)
    if c == Color.Red
        return "red"
    if c == Color.Green
        return "green"
    return "blue"

print(describe(Color.Red))    # "red"
print(describe(Color.Green))  # "green"

Pattern Matching

Copyfn classify(n)
    if n == 0
        return "zero"
    if n < 10
        return "small"
    if n < 100
        return "medium"
    if n < 1000
        return "large"
    return "huge"

print(classify(0))      # "zero"
print(classify(5))      # "small"
print(classify(50))     # "medium"
print(classify(500))    # "large"
print(classify(5000))   # "huge"

Structs & Functions

Copy# Structs are data containers; use functions to operate on them
import math

struct Circle
    radius = 0.0

fn circle_area(c)
    return math.PI * c.radius * c.radius

fn circle_info(c)
    return "Circle(r={c.radius})"

mut c = Circle()
c.radius = 5.0
print(circle_area(c))   # 78.539...
print(circle_info(c))   # Circle(r=5.0)

Pipe Operator

The pipe operator |> passes the result of the left expression as the first argument to the right function. This makes data transformations read naturally from left to right.

Copy# Without pipes (nested, hard to read)
print(join(sort(filter(map(data, square), is_even)), ", "))

# With pipes (clear, left to right)
result = data |> map(square) |> filter(is_even)
result = result |> sort |> join(", ")
print(result)

Closures

Copy# Closures capture their environment
fn make_adder(n)
    return |x| x + n  # captures 'n'

add5 = make_adder(5)
print(add5(10))  # 15

# Lambdas with pipe operator
data = [-3, 1, -1, 4, 2]
result = data |> filter(|x| x > 0) |> map(|x| x * 2) |> sort
print(result)  # [2, 4, 8]

Error Handling

Copyimport fs

# try/catch/finally — like Python but without colons
fn read_config(path)
    try
        content = fs.read(path)
        return content
    catch err
        print("Error: {err}")
        return nil

# throw to raise errors
fn divide(a, b)
    if b == 0
        throw "Division by zero!"
    return a / b

try
    result = divide(10, 0)
catch e
    print("Caught: {e}")
finally
    print("Cleanup done")

Async / Await

Pyro supports timing and scheduling with the time module. For concurrent tasks, use the thread module.

Copyimport time

# Measure execution time
start = time.now()

mut sum = 0
for i in 0..1000000
    sum = sum + i

elapsed = time.now() - start
print("Sum: {sum}")
print("Computed in {elapsed} ms")

Modules

Copy# Import a standard library module
import json
import http
import math

# Use dot notation to access module functions
print(math.PI)
print(math.sqrt(144))
data = json.parse("{\"key\": \"value\"}")

# Create a public module
# file: mylib.ro
pub fn hello()
    return "hello from mylib"

# file: main.ro
import mylib
print(mylib.hello())

Core Modules (12)

Data Modules (12)

Web Modules (10)

Security Modules (8)

Algorithm Modules (8)

Networking Modules (10)

System Modules (8)

Text Modules (8)

CLI Commands

All commands available in the Pyro CLI:

Keywords (23)

Pyro has exactly 23 reserved keywords:

Operators

Type System

Pyro uses a static type system with full type inference. The compiler infers types at compile time, but you can always annotate explicitly for clarity.

Copy# Type inference — just assign, no annotations needed
x = 42                    # int
y = 3.14                  # float
z = "hello"               # str
nums = [1, 2, 3]         # list

# mut for mutable variables
mut counter = 0
counter = counter + 1

# Functions work on any type
fn first(items)
    if items.len() == 0
        return nil
    return items[0]

print(first([10, 20, 30]))  # 10
print(first([]))             # nil

Grammar Summary

Pyro's grammar is intentionally small. The complete formal grammar fits on a single page:

program     = declaration*
declaration = fn_decl | struct_decl | enum_decl | import_decl | statement
fn_decl     = ["pub"] ["async"] "fn" IDENT "(" params? ")" block
struct_decl = ["pub"] "struct" IDENT NEWLINE INDENT fields
enum_decl   = ["pub"] "enum" IDENT NEWLINE INDENT variants
import_decl = "import" path
statement   = let_stmt | expr_stmt | return_stmt | for_stmt | while_stmt
expression  = assignment | pipe | logical | comparison | arithmetic | unary | call | primary
pipe        = expression "|>" expression