The Zenith Language

Zenith is a modern, high-performance interpreted language designed for simplicity, readability, and power. Built with Rust, it bridges the gap between easy-to-learn scripting languages and robust systems programming.

Why Zenith?

Quick Start

Here is a complete program that demonstrates the core features of Zenith.

// 1. Variables
set name = "Zenith User"
set level = 1

// 2. Functions
fn level_up(current) {
    return current + 1
}

// 3. Control Flow
if level less 10 {
    print("Beginner Mode")
    set level = level_up(level)
} else {
    print("Expert Mode")
}

// 4. Collections
set items = ["Sword", "Shield"]
array_push(items, "Potion")

set i = 0
while i less array_len(items) {
    print("Item: " + items[i])
    set i = i + 1
}

// 5. Structures
structure Hero with name, hp
set player = create Hero with name = name, hp = 100
print(player.name)

Installation

Zenith is distributed as a portable executable. No installation wizard required.

Steps

1. Download the latest release (`.zip`) for your OS (Windows/Linux/macOS).
2. Extract the folder to a location of your choice (e.g., `C:\Zenith`).
3. Add the folder to your system `PATH` if you want to use the CLI globally.

Running the IDE

Double-click `ide.exe` (Windows) or run `./ide` (Linux/Mac) to start the integrated environment.

Using the IDE

The Zenith IDE is a terminal-based tool designed for rapid prototyping.

Keyboard Shortcuts

Syntax Basics

Zenith syntax is minimal and whitespace-agnostic (mostly). It uses clear keywords to avoid ambiguity.

Comments

// This is a single-line comment.
// Multi-line comments are not supported yet.

Blocks

You can use C-style braces or Ruby-style keywords.

// Style 1: Braces (Recommended)
if true {
    print("Hello")
}

// Style 2: Keywords
if true then
    print("Hello")
end

Identifiers

Must start with a letter or underscore. Case-sensitive.

• Valid: userName, _id, item1
• Invalid: 1item, user-name (hyphens not allowed)

Variables & Types

Zenith is dynamically typed. Variables are declared with set.

Variable Naming Rules

Identifiers in Zenith must follow these rules:

• Must start with a letter (a-z, A-Z) or an underscore (_).
• Can contain letters, numbers (0-9), and underscores.
• Cannot contain hyphens (-) or other special characters.
• Case-sensitive: myVar is different from myvar.

Declaration

set x = 10        // Number
set _temp = 0     // Valid identifier
set user_id = 1   // Valid identifier
set 1st = "no"    // Invalid (starts with number)

Data Types

Operators

Arithmetic

Comparison

Zenith supports both symbols and words for readability.

Logic

and, or, not.

if (x greater 5) and (y is not null) { ... }

Control Flow

If / Else

if score greater 90 {
    print("A")
} elif score greater 80 {
    print("B")
} else {
    print("C")
}

While Loop

set count = 0
while count less 5 {
    print(count)
    set count = count + 1
}

Repeat Loop

A simplified loop for iterating N times.

repeat 3 times {
    print("Knock")
}

Functions

Functions are reusable blocks of code that perform specific tasks. In Zenith, functions are first-class citizens, meaning they can be assigned to variables, passed as arguments, and returned from other functions.

Basic Syntax

fn greet(name) {
    return "Hello, " + name
}

print(greet("Zenith")) // Output: Hello, Zenith

Parameters and Return Values

Functions can take any number of parameters. If a function does not explicitly return a value using the return keyword, it returns null by default.

fn add(a, b) {
    return a + b
}

fn log(msg) {
    print("[LOG] " + msg)
    // Returns null implicitly
}

Higher-Order Functions

Since functions are values, you can pass them to other functions. This is powerful for creating flexible APIs.

fn apply(func, value) {
    return func(value)
}

fn square(x) {
    return x * x
}

print(apply(square, 5)) // Output: 25

Closures

Functions defined inside other functions "capture" the variables from their surrounding scope. This allows for data privacy and factory patterns.

fn make_counter() {
    set count = 0
    
    fn increment() {
        set count = count + 1
        return count
    }
    
    return increment
}

set counter = make_counter()
print(counter()) // 1
print(counter()) // 2

Structures

Structs are lightweight data containers.

structure Point with x, y

set p1 = create Point with x = 10, y = 20
print(p1.x)

Imports (NOT FULLY IMPLIMENTED YET)

The import statement allows you to include other Zenith files.

import "utils.zen"

Currently, imports are shallow (copy-paste mechanism). Namespaces are not yet supported.

Input / Output

Math Library

All math functions accept and return numbers (64-bit floats).

Strings

Utilities for text manipulation.

File System

System & OS Library

OS Examples

// 1. Executing Shell Commands
set output = system("echo Hello")
print(output)

// 2. Environment Variables
set path = os_env("PATH")
if path is not null {
    print("PATH found")
}

// 3. System Info
print("OS: " + os_name())
print("Cores: " + os_cpu_count())

Type Conversion

Runtime Errors

Common errors you might encounter while running Zenith programs.

Troubleshooting

IDE not running?

Ensure you have `ide.exe` and `compiler.exe` in the same folder.

Known Bugs