Vortex Lang v3

V8.1 Ascended Core — A compiled systems programming language powered by a Go frontend and an LLVM/Clang backend. AI-native, cross-platform.

⚠️ IMPORTANT NOTICE: Development Hiatus (2026 - 2028)

Hey everyone, Tanmaya here. I am taking a strict 2-year hiatus from active development on VORTEX-LANG to focus entirely on my higher secondary studies and competitive entrance exams. The repository will remain public, and the current cross-platform releases are fully stable for you to download, test, and use. Feel free to fork the project, study the source code, and leave issues or PRs—just be aware that I will not be actively reviewing or merging them until 2028. Thank you to everyone who has supported the project so far. See you on the other side! 🚀

🌍 Engine Compatibility & Status

VORTEX-LANG has been aggressively engineered for cross-platform compatibility. Below is the current deployment status of the nightly builds:

📚 Documentation

Explore the deep technical inner workings of the Vortex engine:

• Architecture Guide — Dive into the compiler design, lexer mechanics, and cross-platform architecture.

Installation & Verification

1. Install the VS Code Extension

Download Vortex Language Support from the VS Code Marketplace for syntax highlighting, snippets, and language assistance.

code --install-extension tanmaya2713.vortex-official

2. Install the Compiler

Linux / macOS / Android (Termux)

curl -sSL https://raw.githubusercontent.com/tanmaya2713/VORTEX-LANG/main/dist/install.sh | bash

Windows (PowerShell)

iwr -useb https://raw.githubusercontent.com/tanmaya2713/VORTEX-LANG/main/dist/install.ps1 | iex

Verify Installation

Confirm the compiler binary or extension is correctly installed and print the current version based on your specific environment:

1. Linux

source /home/$USER/.bashrc && vortex --version

Note: Replace $USER with your actual Linux username.

2. macOS

source ~/.bashrc && vortex --version

3. Windows

vortex --version

4. VS Code Extension

To verify the extension build, check the list of installed extensions. Run the following command and look for tanmaya2713.vortex-official@0.0.3.

You can filter the output by piping it into grep vortex (Linux/Mac) or findstr vortex (Windows):

Linux / macOS:

code --list-extensions --show-versions | grep vortex

Windows:

code --list-extensions --show-versions | findstr vortex

REPL Playground

Jump into the interactive terminal shell to test Vortex syntax instantly:

vortex -repl
# Vortex v0.1.0 — type :quit to exit
# vtx> let x = 42;
# vtx> print(x);
# vtx> :quit

Works identically on Windows (PowerShell / CMD), Linux, macOS, and Android (Termux).

Usage

# Build and run locally
vortex run main.vx

# Cross-compile for Android CLI
vortex build main.vx --target android

# Build .so shared library for Android Studio JNI integration
vortex build main.vx --target android --shared

Documentation

General

fn main() is the entry point for the program. The file must end with }. Anything outside fn main() is treated as global or ignored. Use import for external modules and assert for compile-time invariant checks.

// This is ignored or treated as global

fn main() {
    // Write code here
    assert(1 + 1 == 2);
}

// This too is ignored

Variables

Variables are declared using let. Use mut for mutable variables that can be reassigned.

fn main() {
    let a = 10;
    let b = "two";
    let c = 15;
    a = a + 1;
    b = "Vortex";
    c = c * 2;
}

Data Types

Numbers, strings, and booleans work like other languages. Tensor types are native for AI workloads. true and false are the boolean values. Structural types are defined with struct.

fn main() {
    let a = 10;                  // int
    let b = 10 + (15 * 20);      // int expression
    let c = "hello";             // string
    let d = 'ok';                // string (single quotes)
    let e = true;                // bool
    let f = false;               // bool
    let g: tensor<2,3> = [[1, 2, 3], [4, 5, 6]];  // tensor

    struct Point { x: i32; y: i32; }
    let p = Point { x: 10, y: 20 };
}

Built-ins & AI Power

Use print() to output anything to the console. Tensor operations are first-class citizens with native type syntax and runtime-accelerated math.

fn main() {
    print("Hello World");

    let a = 10;
    let b = 20;
    print(a + b);

    // Native tensor matrix multiplication (using overloaded * operator)
    let t: tensor<2,2> = [[1, 2], [3, 4]];
    let result = t * t;
    print(result);
}

Native AI constructs — model, layer, and train — enable declarative neural network definitions:

model MyNet {
    layer hidden = dense(128, relu);
    layer output = dense(10, sigmoid);
}

fn main() {
    train model=MyNet, data=dataset, epochs=10;
}

V2 Omniversal Core — OS & Web I/O

Vortex V2 introduces operating system level file interaction and live API data fetching — directly from your .vx scripts.

fn main() {
    // Save variables to disk
    let data = "Hello, file system!";
    save data into "output.txt";

    // Load JSON from disk
    load "config.json" into config;
    print(config);

    // Fetch live JSON from a REST API
    request "https://api.example.com/data" into response;
    print(response);
}

The save keyword writes any variable (including JSON objects) to a file. The load keyword reads files and auto-detects JSON vs plain text. The request keyword performs read-only HTTP GET requests and returns parsed JSON.

V3 Ascended Core — JSON, Arrays & Extended Math

V3 brings dictionary-style JSON parsing, native Arrays, and a powerful expanded standard library.

fn main() {
    // Native Arrays
    let arr = [1, 2, 3, 4, 5];

    // JSON dictionary access
    load "data.json" into obj;
    print(obj["key"]);

    // Extended math builtins
    let x = 2.0;
    print(sin(x));
    print(cos(x));
    print(tan(x));
    print(sqrt(x));
    print(pow(x));

    // Utility builtins
    print(length("hello"));   // → 5
    print(type_of(42));       // → "int"
    print(str(3.14));         // → "3.14"
}

Available builtins: random, sqrt, round, abs, pow, sin, cos, tan, length, type_of, str.

Conditionals

Vortex supports if, else if, and else blocks.

fn main() {
    let a = 10;

    if (a < 20) {
        print("a is less than 20");
    } else if (a < 25) {
        print("a is less than 25");
    } else {
        print("a is greater than or equal to 25");
    }
}

Loops

Statements inside a while block execute as long as the condition evaluates to true. Use break to exit the loop and continue to skip to the next iteration.

fn main() {
    let a = 0;

    while (a < 10) {
        a = a + 1;

        if (a == 5) {
            print("skipping five");
            continue;
        }

        if (a == 8) {
            break;
        }

        print(a);
    }

    print("done");
}

Vortex also supports for loops for iterating over array or tensor elements with an index variable:

fn main() {
    for i in [1, 2, 3, 4, 5] {
        print(i);
    }
}

Note: The for loop range expression must evaluate to an array or tensor type. Scalar literals are not valid ranges.

Roadmap & Future Updates 🚀

The Vortex Engine is constantly evolving. Here is a sneak peek at what is coming in future releases:

• Compiler Enhancements: We are bringing native tensor and neural net operations directly into the Python interpreter, adding multi-file import statements for massive projects, and building advanced stack traces for pinpoint error debugging.
• Visual GUI Environment: A dedicated Graphical User Interface (GUI) is in development to let you write, debug, and execute Vortex code visually, extending beyond the command-line CLI.
• Native Package Manager: A built-in package manager is coming! Soon you'll be able to easily install, publish, and share Vortex modules and ML models with the community.

About the Creator & Support

Vortex is engineered by Tanmaya Mahapatra (Retired Ame) under Drona Labs.

• GitHub: tanmaya2713
• Instagram: Retired Ame

Built with ❤️ using Go and LLVM