AltFLang Documentation

What is AltFLang?

AltFLang is a modern, high-performance conversational programming language designed with an intuitive desi-style syntax. It runs entirely inside your browser with a custom-built Lexer, Parser, AST, and Interpreter — zero external dependencies or server compilation required.

Key Syntax Rules

• Statements can end with a semicolon ; or newlines.
• Single-line comments start with // or #.
• Multi-line comments are enclosed in /* ... */.
• Blocks are enclosed with curly braces { ... }.
• Output is printed using bol(...) or chhap(...).

Variable Declaration (rakho)

Use rakho to declare mutable variables:

rakho aam = 10;
aam = 20; // Re-assignment is allowed
bol("Aam ki count:", aam);

Constant Declaration (pakka)

Use pakka to declare constants that cannot be reassigned:

pakka PI = 3.14159;
// Reassigning PI will throw a Runtime Error!

AltFLang supports standard dynamic primitives and compound data structures:

rakho Suchi = [10, 20, 30];
rakho Vastu = { chabi: "Moolya" };
bol("Array zero index:", Suchi[0]);
bol("Object property:", Vastu.chabi);

Arithmetic Operators

+ (addition / string concatenation), - (subtraction), * (multiplication), / (division), % (modulo).

Comparison Operators

== (equal), != (not equal), < (less than), > (greater than), <= (less than or equal), >= (greater than or equal).

Logical Operators

&& (AND), || (OR), ! (NOT).

rakho a = 15;
rakho b = 4;
bol("Modulo:", a % b); // 3
bol("Logical AND:", (a > 10) && (b < 5)); // sahi

Conditionals evaluate expressions and execute matching blocks:

rakho ank = 85;

agar (ank >= 90) {
  bol("A+ Grade!");
} warna agar (ank >= 75) {
  bol("First Division!");
} warna {
  bol("Pass");
}

While Loop (jab_tak)

rakho ginti = 0;
jab_tak (ginti < 5) {
  bol("Kram:", ginti);
  ginti = ginti + 1;
}

For Loop (chalo)

chalo (rakho i = 0; i < 3; i = i + 1) {
  agar (i == 1) {
    aage; // skip 1
  }
  bol("Loop index:", i);
}

Skip and Stop (aage / bhang)

aage skips to the next iteration; bhang leaves the loop entirely.

chalo (rakho i = 0; i < 5; i = i + 1) {
  agar (i == 3) {
    bhang; // stop the loop at 3
  }
  bol("Chal raha hai:", i);
}
// prints 0, 1, 2

Loops nest freely, and both keywords apply to the innermost loop:

chalo (rakho i = 0; i < 2; i = i + 1) {
  chalo (rakho j = 0; j < 2; j = j + 1) {
    bol(i, j);
  }
}

Functions are declared with karya and return with lautao:

karya guna_karo(x, y) {
  lautao x * y;
}

rakho uttar = guna_karo(6, 7);
bol("6 * 7 =", uttar);

Recursion

A function can call itself. lautao exits immediately, so the base case guards the recursion:

karya factorial(n) {
  agar (n <= 1) {
    lautao 1;
  }
  lautao n * factorial(n - 1);
}

bol("5! =", factorial(5)); // 120

First-class functions

Functions are values: pass them as arguments, return them, store them in variables. A returned function keeps access to the scope it was created in (a closure):

karya ginti_banao() {
  rakho ginti = 0;
  karya badhao() {
    ginti = ginti + 1;
    lautao ginti;
  }
  lautao badhao;
}

rakho counter = ginti_banao();
counter();
bol("Counter:", counter()); // 2

• bol(...args): Prints values to console output.
• chhap(...args): Alias for bol — identical behaviour.
• lambai(item): Returns length of array, string, or object keys.
• prakar(val): Returns type string ("sankhya", "shabd", "sahi_galat", "suchi", "vastu", "khali").
• jodo(array, item): Pushes item onto array.
• nikalo(array): Pops item from array.
• sankhya(val): Converts value to number.
• shabd(val): Converts value to string representation.
• samay(): Returns current epoch timestamp in milliseconds.
• ganit: Math object with abs, floor, ceil, round, random, pow, sqrt, min, max, PI, E.

bol("Math Random:", ganit.random());
bol("Square Root of 144:", ganit.sqrt(144));

Arrays are zero-indexed and mutable in place:

rakho suchi = [1, 2, 3];
suchi[0] = 99;          // assign by index
jodo(suchi, 4);         // push
rakho aakhri = nikalo(suchi); // pop, returns the removed item
bol(suchi, aakhri, lambai(suchi));

Objects support both dot and bracket access, and nest freely:

rakho vastu = { naam: "AltF", andar: { saal: 2026 } };
bol(vastu.naam);            // dot
bol(vastu["naam"]);         // bracket
bol(vastu.andar.saal);      // nested

lambai works on all three: arrays, strings, and object keys.

What counts as false

agar treats these as false — everything else is true:

agar (0) { bol("nahi chalega"); } warna { bol("0 is falsy"); }
agar ("") { bol("nahi chalega"); } warna { bol("empty string is falsy"); }

Error messages

Errors carry the exact line and column, and stop execution at that point:

pakka PI = 3.14159;
PI = 3;

Running that stops with:

[Line 2, Column 4] Runtime Error: Cannot reassign constant variable 'PI'

The playground highlights the offending line in the editor and prints the same message in the output console, so you can jump straight to it.