The Vyne Programming Language

Vyne is a hybrid interpreted language engineered for performance-critical algorithm testing and low-level memory control. Designed in Baku, it provides a clean, C-style syntax with advanced functional primitives.

Engine Rulesets

Vyne allows you to configure engine behavior at runtime using the ruleset block.

ruleset {
    warnings,       # Enable/Disable semantic warnings
    dynamic_casting # Control strictness of type conversions
};

Types & Variables

Vyne supports both implicit inference and strict explicit typing using the :: operator.

Control Flow & Logic

Vyne provides standard imperative control structures alongside advanced functional iteration patterns.

Conditionals (If/Else)

Vyne uses standard if, else if, and else blocks. Braces are mandatory for clarity.

score :: Int64 = 85;

if score >= 90 {
    out("Grade: A");
} else if score >= 80 {
    out("Grade: B");
} else {
    out("Grade: F");
}

Iterative Loops

Standard while loops are used for condition-based iteration. You can use break to exit early.

i = 0;
while i < 100 {
    if i == 50 { break; }
    out(i);
    i++;
}

Advanced Iteration: through

The through operator is Vyne's signature feature for data processing. It transforms or filters collections natively.

# Unique filter
raw_data = [1, 1, 2, 3, 3];
clean = through item :: raw_data -> unique;

# Fibonacci with through loop
through i :: 0..n -> loop {
    next = a + b;
    a = b;
    b = next;
};

Engine Control: ruleset

Unlike other languages, Vyne allows you to toggle engine-level features like warnings or dynamic_casting mid-script.

ruleset { 
    warnings: on, 
    dynamic_casting: off 
};

Iteration & Through Loops

While Vyne supports standard while loops, its true power lies in the through operator for functional-style data processing.

# Standard While
while i < 10 { i++; }

# Through: Filter and Unique
y = [1, 1, 2, 2, 3];
uniques = through item :: y -> unique;

# Through: Collect (Map)
doubled = through x :: [10, 20] -> collect { x * 2 };

Functions

Functions in Vyne are first-class citizens. They support explicit type checking, type inference, and can be scoped to specific modules using the :: operator.

Defining Functions

Vyne allows you to define functions with strict typing for parameters and return values, or you can let the engine infer the types dynamically.

# 1. Explicitly Typed Function
fn add(a :: Int64, b :: Int64) -> Int64 {
    return a + b;
}

# 2. Type Inference (Dynamic)
fn multiply(x, y) {
    return x * y;
}

# 3. Recursive Logic
fn factorial(n :: Int64) -> Int64 {
    if n <= 1 { return 1; }
    return n * factorial(n - 1);
}

Function Scoping (Namespacing)

To organize logic, you can bind functions directly to a module. This prevents naming collisions in large projects.

module MathUtils;

# Scoping a function to MathUtils
fn :: MathUtils square(x :: Int64) -> Int64 {
    return x * x;
}

out(MathUtils.square(7)); # Outputs: 49

Type Checking Table

Interfaces & Methods

Interfaces in Vyne are more than just structs; they support methods with self reference and pointer-based relationships.

interface Node {
    kind :: Int64,
    data :: Int64, 
    left :: Node&,  # Reference type
    right :: Node& 

    isValid() {
        if self.data == 0 { return false; }
        return true;
    }
}

Modular Architecture

Organize large projects using module and group. Use deploy to expose namespaced logic to the global scope.

module physics;

group Constants :: physics {
    pi :: Float64 = 3.1415;
};

deploy physics;
out(Constants.pi);

Linear Algebra (vlinalg)

The vlinalg module provides high-level abstractions for vector spaces and matrix operations, leveraging Vyne's functional primitives for heavy numerical computations.

Defining Architectures

Use interface to define custom mathematical structures. The vlinalg.Types group includes standard definitions for Matrices and Vectors.

interface Vector {
    x :: Int64,
    y :: Int64,

    magnitude() -> Float64 {
        return vmath.sqrt(self.x * self.x + self.y * self.y);
    }
}

Matrix Operations

Vyne excels at matrix transformations by combining through loops with collect or loop patterns.

Practical Usage: Matrix Multiplication

module vlinalg;
deploy vlinalg;

# Initialize a 2x2 Matrix
m1 = Types.Matrix(2, 2, [[1, 2], [3, 4]]);
m2 = Types.Matrix(2, 2, [[5, 6], [7, 8]]);

# Perform dot product
result = multiply(m1, m2);
out(result.data); # [[19, 22], [43, 50]]

VCore (System Standard)

The vcore module is the backbone of the Vyne runtime, providing essential utilities for I/O, process management, and environment introspection.

System Properties

VMath (Numerical Primitives)

Native C++ math implementations for heavy numerical tasks. vmath functions operate on 64-bit precision floats.

module vmath;
deploy vmath;

val = sin(3.14 / 2); # Approx 1.0
active = sigmoid(0.5); # High-perf activation
rand_val = random(1, 100);

Function Index

Mathematical Constants

vmem (Memory Engine)

The vmem module provides native introspection and raw memory manipulation capabilities. It allows Vyne to behave as a systems-level tool for debugging heap structures.

Core Functions

Example: Memory Manipulation

module vmem;
deploy vmem;

target = "Original";
addr = vmem.peek(target);

# Directly overwrite the value in memory
vmem.poke(addr, "Injected via vmem");

out(target); # Outputs: Injected via vmem