ORION Language — VANTREL OS

01 // Overview

Overview

ORION is a powerful, modern programming language built from scratch for the Vantrel/ORIONos operating system. It features clean syntax inspired by Rust, Swift, and Python, with first-class support for systems programming, application development, and scripting.

Variables (let/var) Functions & Closures Classes & Inheritance Pattern Matching Error Handling (try/catch/throw) Generators (yield) String Interpolation Arrays, Maps, Tuples Module System Math Module Type Annotations FFI to Kernel

02 // Download

Get ORION

The ORION interpreter is built into Vantrel OS and available as a standalone binary for any x86-64 system. Choose your installation method below — everything is real, nothing is faked.

ORION Interpreter v1.0.0 — Direct Downloads

The complete ORION language interpreter, written in C11. Runs natively on Vantrel OS or as a standalone binary on any x86-64 system.

File	Platform	Size	Download
`orion-installer-v1.0.0.sh`	Linux / macOS / WSL (full installer)	~21 KB	Download
`orion-installer-v1.0.0.ps1`	Windows (full installer)	~15 KB	Download
`orn-pkg`	Package manager (pip-like, any)	~18 KB	Download
`orion.rb`	macOS (Homebrew formula)	~1.6 KB	Download
`Dockerfile`	Docker (containerized)	~2.9 KB	Download
`orion-interpreter-v1.0.0.ornpkg`	Vantrel OS (native)	~35 KB	Download
`orion-standalone-v1.0.0.tar.gz`	x86-64 Linux/Unix	~15 KB	Download
`orion-source-v1.0.0.tar.gz`	Source Code	~15 KB	Download
`orion-terminal-v1.0.0.sh`	Standalone Terminal/REPL	~11 KB	Download

Installation on Vantrel OS

# ORION is pre-installed in Vantrel OS # Just open a terminal and use it: orion println("Hello, Vantrel!") # Run a script file orionrun myscript.orn # Install packages orn-pkg install orion-crypto

SHA-256 Checksums

orion-installer-v1.0.0.sh : 6e556fc1768c1beec9094f231379cf973c0b3089cd5f02e5c53811f288fbc79a orion-installer-v1.0.0.ps1 : f3a4d653815e201ad5ef9c4fe67defb255104e3324f106208fcb14ab9619dfc4 orn-pkg (package manager) : 76c58472e0c4655ebe780f560af67a8b69029a7fdfb2f50fe1f6b0c8b07fff55 orion.rb (Homebrew) : be27b8154dc6deb1b20e9ce5a2415f641572d41d6dffb52a7ba4ced0f794f95a Dockerfile : a57462150c055c3c68953f0658f6f22cd56372bbf9d73efe17de7d532c864763 orion-interpreter-v1.0.0.ornpkg : 50fe2bd265e17a231637868336bd16cb1d14298f9ebaf770045d71d4250e74f8 orion-standalone-v1.0.0.tar.gz : 25ce38a63293d195208f4632a9148958b215521dacd46aa26d6ef43981f3ba30 orion-source-v1.0.0.tar.gz : 25ce38a63293d195208f4632a9148958b215521dacd46aa26d6ef43981f3ba30 orion-terminal-v1.0.0.sh : 498a0ed4f835efcc14a9c1f6b8fb4930a0b3f1c6c9720b8194b346d0c979d6ae

03 // Syntax Reference

Syntax Reference

ORION uses a clean, modern syntax with no semicolons required (optional). Indentation is not enforced — blocks use curly braces { }.

Hello World

println("Hello, Orion!")

Variables

let x = 42 # Immutable (constant) var name = "Vantrel" # Mutable var pi: Float = 3.14159 # With type annotation

Operators

let a = 10 + 3 # 13 (addition) let b = 10 - 3 # 7 (subtraction) let c = 10 * 3 # 30 (multiplication) let d = 10 / 3 # 3 (integer division) let e = 10 % 3 # 1 (modulo) let f = 2 ** 10 # 1024 (power) let g = "Hello" + " " + "World" # String concat

04 // Data Types

Data Types

Type	Description	Example
`Int`	64-bit signed integer	`42`
`Float`	64-bit floating point	`3.14159`
`Bool`	Boolean (true/false)	`true`
`String`	UTF-8 string	`"Vantrel"`
`Array`	Ordered collection	`[1, 2, 3]`
`Map`	Key-value dictionary	`{"key": "value"}`
`Tuple`	Fixed-size heterogeneous	`(1, "two", 3.0)`
`Null`	Null/None value	`null`
`Func`	Function reference	`fn(x) { return x }`

05 // Functions

Functions

fn greet(name: String) -> String { return "Hello, {name}!" } println(greet("Vantrel")) # Hello, Vantrel! # Lambda / anonymous function let square = fn(x) { return x * x } println(square(5)) # 25 # Closures capture variables var counter = 0 let increment = fn() { counter = counter + 1 return counter } println(increment()) # 1 println(increment()) # 2

06 // Classes & Objects

Classes & Objects

class Point { var x: Float var y: Float fn new(x: Float, y: Float) { self.x = x self.y = y } fn distance(other: Point) -> Float { let dx = self.x - other.x let dy = self.y - other.y return sqrt(dx * dx + dy * dy) } } let p1 = Point.new(0, 0) let p2 = Point.new(3, 4) println(p1.distance(p2)) # 5.0

07 // Control Flow

Control Flow

If / Else If / Else

var x = 10 if x > 100 { println("big") } elif x > 5 { println("medium") } else { println("small") }

While Loop

var i = 0 while i < 5 { println("i = {i}") i = i + 1 }

For Loop (iteration)

# Iterate over arrays for item in [1, 2, 3] { println(item) } # Range iteration for i in 0..10 { println(i) }

Break & Continue

for i in 0..100 { if i == 5 { break } if i % 2 == 0 { continue } println(i) }

Pattern Matching (match/when)

let color = "red" match color { when "red" => println("Stop") when "yellow" => println("Caution") when "green" => println("Go") else => println("Unknown") }

08 // Collections

Collections

Arrays

var fruits = ["apple", "banana", "cherry"] println(len(fruits)) # 3 println(fruits[0]) # apple fruits.push("date") println(fruits.reverse()) # [date, cherry, banana, apple]

Maps

var person = {"name": "Vantrel", "age": 25} println(person["name"]) # Vantrel println(keys(person)) # [name, age]

Tuples

let point = (3, 4) println(point[0]) # 3 println(point[1]) # 4

09 // Error Handling

Error Handling

fn divide(a: Int, b: Int) -> Int { if b == 0 { throw "Division by zero" } return a / b } try { let result = divide(10, 0) println(result) } catch e { println("Error: {e}") }

10 // Standard Library

Standard Library

Function	Description	Example
`print(x)`	Print without newline	`print("hi")`
`println(x)`	Print with newline	`println("hi")`
`len(x)`	Length of collection	`len([1,2,3])`
`str(x)`	Convert to string	`str(42)`
`int(x)`	Convert to integer	`int("42")`
`float(x)`	Convert to float	`float("3.14")`
`abs(x)`	Absolute value	`abs(-5)`
`max(a,b,...)`	Maximum value	`max(1,5,3)`
`min(a,b,...)`	Minimum value	`min(1,5,3)`
`sqrt(x)`	Square root	`sqrt(16)`
`pow(a,b)`	Power	`pow(2,10)`
`range(a,b)`	Create range array	`range(0,10)`
`type(x)`	Type name	`type(42)`
`keys(map)`	Map keys	`keys(m)`
`assert(x)`	Assert truthy	`assert(x > 0)`

Math Module

import Math println(Math.PI) # 3.14159265358979 println(Math.E) # 2.71828182845905 println(Math.sqrt(25)) # 5.0 println(Math.pow(2, 8)) # 256.0 println(Math.abs(-42)) # 42

11 // Complete Examples

Complete Examples

Fibonacci

fn fib(n: Int) -> Int { if n <= 1 { return n } return fib(n - 1) + fib(n - 2) } for i in 0..10 { println(fib(i)) } # Output: 0 1 1 2 3 5 8 13 21 34

String Manipulation

let greeting = "Hello" let name = "Vantrel" println("{greeting}, {name}!") # Hello, Vantrel! println(greeting.upper()) # HELLO println(greeting.lower()) # hello println(greeting.length()) # 5

Array Processing

let numbers = [1, 2, 3, 4, 5] var sum = 0 for n in numbers { sum = sum + n } println("Sum: {sum}") # Sum: 15 println("Max: {max(numbers)}") # Max: 5 println("Min: {min(numbers)}") # Min: 1

Class with Inheritance

class Animal { var name: String fn new(name: String) { self.name = name } fn speak() -> String { return "..." } } class Dog : Animal { fn speak() -> String { return "Woof!" } } let dog = Dog.new("Rex") println(dog.speak()) # Woof!

12 // Running Orion

Running Orion

# On Vantrel OS terminal: orion println("Hello!") orion let x = 42 orion fn add(a, b) { return a + b } println(add(3, 4)) # Run a script file (.orn extension): orionrun hello.orn # Interactive help: orion

13 // Package Registry

Orion Package Registry

Orion has a growing package registry with 31 packages covering networking, graphics, OS building, machine learning, databases, game development, and more. Install packages using the built-in package manager.

# Install packages orn-pkg install orion-net orn-pkg install orion-gfx orion-ui # List all packages orn-pkg list # Search packages orn-pkg search networking # Use in Orion code orion import Net from "orion-net" orion Net.http_get("https://duckduckgo.com")

Browse all 31 packages →