FrontLang

# Clone the repository
git clone https://github.com/Front-Terrain/FrontLang.git
cd FrontLang

# Build optimized release binary (target/release/frontlang)
cargo build --release

# Run full compiler and runtime regression test suite
cargo test

# hello.ft — First FrontLang program
let greeting: String = "Hello, FrontTerrain"

fn main() -> Int:
    show(greeting)
    return 0

frontlang run hello.ft
# Output:
Hello, FrontTerrain

[package]
name = "my_application"
version = "0.1.0"
entrypoint = "src/main.ft"
description = "A modern FrontLang application"

[dependencies]
vector_math = "^0.2.0"
my_physics = { git = "https://github.com/username/my_physics.git", tag = "v1.0.0" }
local_utils = { path = "../local_utils" }

frontlang run          # Runs entry file specified in frontlang.toml
frontlang check        # Static type-checks the project entrypoint
frontlang build        # Compiles entrypoint into portable .ftbc bytecode
frontlang compile      # Compiles Ahead-of-Time to standalone native executable (.exe)

# Initialize a new application project (src/main.ft)
frontlang init my_package

# Initialize a reusable library module (src/lib.ft)
frontlang init my_lib --lib

# Install a central registry package with SemVer resolution
frontlang add vector_math --version "^0.2.0"

# Add a decentralized Git package (pins exact commit in frontlang.lock)
frontlang add username/my_physics_engine

# Add a local path dependency
frontlang add ../local_utils --path

# Install all dependencies pinned in frontlang.lock into front_modules/
frontlang install

# Remove an installed dependency
frontlang remove vector_math

# Bundle project into an optimized, zero-dependency .ftpkg archive
frontlang pack

# Extract an archive for inspection
frontlang unpack dist/my_pkg-1.0.0.ftpkg -o inspected/

# frontlang.lock — Generated automatically by FrontLang
lockfile_version = 1

[[package]]
name = "vector_math"
version = "0.2.4"
source = "registry+https://fronthub.frontterrain.com"
checksum = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"

[[package]]
name = "my_physics"
source = "git+https://github.com/username/my_physics.git"
commit = "d3b07384d113edec49eaa6238ad5ff0012345678"
tag = "v1.0.0"

# List cached packages, versions, and disk sizes
frontlang cache list

# Clean global cache to reclaim disk space
frontlang cache clean

# Package with default Codrop adaptive compression
frontlang pack

# Package with Codrop compression AND dead-code tree-shaking
frontlang pack --tree-shake

# Publish with tree-shaking and Codrop compression to FrontHub
frontlang publish --tree-shake

# Produce an uncompressed legacy POSIX USTAR archive if needed
frontlang pack --no-compress

# 1. Authenticate with your FrontHub developer token
frontlang login ft_live_your_secret_token

# 2. Search for packages in the registry
frontlang search vector

# 3. View metadata, description, and SHA-256 checksum
frontlang info vector_math

# 4. Publish your module (verifies syntax, types, bundles with Codrop)
frontlang publish

# 5. Clear saved credentials from ~/.frontlang/credentials.toml
frontlang logout

# This is a full-line comment in FrontLang
let max_connections: Int = 1000 # Trailing comment

Program              ::= ( TopLevelItem )* EOF

TopLevelItem         ::= FunctionDecl
                       | ExternFunctionDecl
                       | StructDecl
                       | IncludeDecl
                       | Statement

IncludeDecl          ::= "include" StringLiteral Newline

StructDecl           ::= "struct" Identifier ":" Newline Indent ( StructField )+ Dedent
StructField          ::= Identifier ":" TypeAnnotation Newline

FunctionDecl         ::= "fn" Identifier "(" [ ParameterList ] ")" [ "->" TypeAnnotation ] ":" Suite
ExternFunctionDecl   ::= "extern" [ StringLiteral ] "fn" Identifier "(" [ ParameterList ] ")" [ "->" TypeAnnotation ] Newline

ParameterList        ::= Parameter ( "," Parameter )*
Parameter            ::= Identifier ":" TypeAnnotation

Suite                ::= Newline Indent Statement+ Dedent
                       | Statement

Statement            ::= LetStmt
                       | AssignStmt
                       | MemberAssignStmt
                       | IndexAssignStmt
                       | IfStmt
                       | WhileStmt
                       | ForStmt
                       | TryCatchStmt
                       | ThrowStmt
                       | ReturnStmt
                       | BreakStmt
                       | ContinueStmt
                       | ExprStmt

LetStmt              ::= "let" Identifier [ ":" TypeAnnotation ] "=" Expression Newline
AssignStmt           ::= Identifier "=" Expression Newline
MemberAssignStmt     ::= Expression "." Identifier "=" Expression Newline
IndexAssignStmt      ::= Expression "[" Expression "]" "=" Expression Newline

IfStmt               ::= "if" Expression ":" Suite 
                         ( "elif" Expression ":" Suite )* 
                         [ "else" ":" Suite ]

WhileStmt            ::= "while" Expression ":" Suite
ForStmt              ::= "for" Identifier "in" Expression ":" Suite

TryCatchStmt         ::= "try" ":" Suite "catch" [ Identifier ] ":" Suite
ThrowStmt            ::= "throw" Expression Newline

ReturnStmt           ::= "return" [ Expression ] Newline
BreakStmt            ::= "break" Newline
ContinueStmt         ::= "continue" Newline
ExprStmt             ::= Expression Newline

TypeAnnotation       ::= "Int" 
                       | "Float" 
                       | "Bool" 
                       | "String" 
                       | "Unit" 
                       | "[" TypeAnnotation "]"
                       | "Map" "[" TypeAnnotation "," TypeAnnotation "]"
                       | "(" TypeAnnotation ( "," TypeAnnotation )* ")"
                       | Identifier

Expression           ::= LogicalOrExpr

LogicalOrExpr        ::= LogicalAndExpr ( "or" LogicalAndExpr )*
LogicalAndExpr       ::= EqualityExpr ( "and" EqualityExpr )*
EqualityExpr         ::= RelationalExpr ( ( "==" | "!=" ) RelationalExpr )*
RelationalExpr       ::= AdditiveExpr ( ( "<" | "<=" | ">" | ">=" ) AdditiveExpr )*
AdditiveExpr         ::= MultiplicativeExpr ( ( "+" | "-" ) MultiplicativeExpr )*
MultiplicativeExpr   ::= UnaryExpr ( ( "*" | "/" | "%" ) UnaryExpr )*
UnaryExpr            ::= ( "-" | "not" ) UnaryExpr | PostfixExpr

PostfixExpr          ::= PrimaryExpr 
                         ( "(" [ ArgumentList ] ")" 
                         | "[" Expression "]" 
                         | "." Identifier 
                         )*

ArgumentList         ::= Expression ( "," Expression )*

PrimaryExpr          ::= IntegerLiteral
                       | FloatLiteral
                       | StringLiteral
                       | BooleanLiteral
                       | "null"
                       | ArrayLiteral
                       | MapLiteral
                       | TupleLiteral
                       | Identifier
                       | "(" Expression ")"

ArrayLiteral         ::= "[" [ Expression ( "," Expression )* ] "]"
MapLiteral           ::= "{" [ MapEntry ( "," MapEntry )* ] "}"
MapEntry             ::= Expression ":" Expression
TupleLiteral         ::= "(" Expression "," Expression ( "," Expression )* ")"

# Explicit type annotations
let username: String = "rishi"
let port: Int = 8080
let timeout: Float = 30.5
let is_active: Bool = true

# Inferred type annotations
let count = 100          # Inferred as Int
let ratio = 1.618        # Inferred as Float
let msg = "FrontTerrain" # Inferred as String

# Variable Reassignment
count = count + 1
port = 9000

# Standard function declaration
fn add(a: Int, b: Int) -> Int:
    return a + b

# Recursive Fibonacci calculation
fn fibonacci(n: Int) -> Int:
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# Main entrypoint
fn main() -> Int:
    show("Result of 15 + 27:", add(15, 27))
    show("Fibonacci(7):", fibonacci(7))
    return 0

let score: Int = 88

if score >= 90:
    show("Grade: Distinction")
elif score >= 80:
    show("Grade: Honors")
elif score >= 50:
    show("Grade: Pass")
else:
    show("Grade: Retake required")

# While loop with break and continue
let i: Int = 0
while i < 10:
    i = i + 1
    if i == 3:
        continue # Skip 3
    if i == 7:
        break    # Exit loop
    show("Iteration:", i)

fn safe_divide(a: Int, b: Int) -> Int:
    if b == 0:
        throw "Division by zero is undefined"
    return a / b

fn main() -> Int:
    # 1. Catching user-thrown exceptions with payload binding
    try:
        let result = safe_divide(10, 0)
        show(result)
    catch err:
        show("Handled gracefully:", err)

    # 2. Catching assertion failures and runtime panics
    try:
        assert(2 + 2 == 5, "Math verification failed")
    catch msg:
        show("Caught assertion failure:", msg)

    # 3. Anonymous catch (omitting error variable)
    try:
        throw "Silent internal fault"
    catch:
        show("An error occurred, but system recovered cleanly")

    return 0

# Dynamic integer list
let nums: List[Int] = [10, 20, 30]
nums[1] = 99           # Element mutation

show(nums[1])        # 99
show(len(nums))      # 3

let scores: Map[String, Int] = {"alice": 95, "bob": 80}
scores["charlie"] = 88

# Subscript access & length
show(scores["alice"])            # 95
show(len(scores))                # 3

# Expressive Map dot-call methods
show(scores.has("alice"))        # true
show(scores.get("dave", 0))      # 0 (fallback default)
show(scores.keys())              # ["alice", "bob", "charlie"]
show(scores.values())            # [95, 80, 88]

let removed = scores.remove("bob")
scores.clear()
show(len(scores))                # 0

let s = "  FrontLang Core  "
show(s.trim())                          # "FrontLang Core"
show(s.to_lower())                      # "  frontlang core  "
show(s.to_upper())                      # "  FRONTLANG CORE  "
show(s.contains("Lang"))                # true
show(s.starts_with("  Front"))          # true
show(s.ends_with("Core  "))             # true
show(s.replace("Core", "Ecosystem"))    # "  FrontLang Ecosystem  "
show(s.split(" "))                      # ["", "", "FrontLang", "Core", "", ""]
show(s.sub(2, 11))                      # "FrontLang"

fn get_user() -> (String, Int, Bool):
    return ("Rishi", 25, true)

let user = get_user()
show(user.0)         # "Rishi"
show(user.1)         # 25
show(user[2])        # true

# Recursive Linked List Node
struct Node:
    val: Int
    next: Node

fn list_sum(head: Node) -> Int:
    let curr = head
    let total = 0
    while curr != null:
        total = total + curr.val
        curr = curr.next
    return total

# Construct 10 -> 20 -> 30 -> null
let list = Node(10, Node(20, Node(30, null)))
show("Linked list sum:", list_sum(list))  # 60

struct Point:
    x: Int
    y: Int

# Method definition for Point
fn Point_manhattan(self: Point, other: Point) -> Int:
    let dx = self.x - other.x
    if dx < 0:
        dx = -dx
    let dy = self.y - other.y
    if dy < 0:
        dy = -dy
    return dx + dy

fn main() -> Int:
    let p1 = Point(10, 20)
    let p2 = Point(15, 30)

    # Invoked via OOP dot-call syntax
    show("Manhattan distance:", p1.manhattan(p2))  # 15
    return 0

# Standard library inclusions
include "std:gui"
include "std:ui"
include "std:animation"
include "std:net"

# Project-relative modular inclusions
include "src/models/user.ft"
include "src/services/auth.ft"

include "std:net"

fn main():
    # 1. High-Level HTTP Client
    let resp = http_get("http://127.0.0.1:8080/api/status")
    show(resp.status_code)
    show(resp.body)

    # 2. Object-Oriented TCP Client
    let client = tcp_connect("127.0.0.1", 8080)
    client.send("PING\n")
    let reply = client.recv(1024)
    show(reply)
    client.close()

    # 3. Object-Oriented TCP Server
    let srv = tcp_listen(9000)
    let conn = srv.accept()
    conn.send("HELLO CLIENT\n")
    conn.close()
    srv.close()

    # 4. UDP Sockets
    let sock = udp_bind(9001)
    sock.send_to("127.0.0.1", 9002, "UDP_PACKET")
    let packet = sock.recv_from(1024)
    show(packet.0) # Payload
    show(packet.1) # Sender IP
    show(packet.2) # Sender Port
    sock.close()

include "std:concurrency"

fn worker_task(channel_id: Int, item_id: Int) -> Int:
    sleep_ms(50)
    channel_send(channel_id, item_id * 10)
    return 0

fn main() -> Int:
    # 1. Channels (Message-Passing Concurrency)
    let ch = channel_new()
    let t1 = thread_spawn(worker_task, ch, 1)
    let t2 = thread_spawn(worker_task, ch, 2)

    show(channel_recv(ch))  # 10
    show(channel_recv(ch))  # 20

    thread_join(t1)
    thread_join(t2)

    # 2. Mutexes (Shared State Protection)
    let mtx = mutex_new()
    mutex_lock(mtx)
    # Safe critical section
    mutex_unlock(mtx)
    return 0

include "std:fs"

fn main() -> Int:
    let path = "logs/telemetry.txt"
    fs_create_dir("logs")
    fs_write_file(path, "FrontLang 2026 Engine\n")
    fs_append_file(path, "Build status: Verified OK\n")

    if fs_file_exists(path):
        let content = fs_read_file(path)
        show("File Contents:", content)

    let files = fs_read_dir("logs")
    show("Directory Listing:", files)
    return 0

include "std:hw"

# Standard x86 VGA Video Buffer is mapped to physical 0xB8000
let VGA_BUFFER = 0xB8000

fn vga_write_char(col: Int, row: Int, ch: Int, color_attr: Int):
    let offset = (row * 80 + col) * 2
    hw_write8(VGA_BUFFER + offset, ch)
    hw_write8(VGA_BUFFER + offset + 1, color_attr)

fn vga_clear(color_attr: Int):
    let row = 0
    while row < 25:
        let col = 0
        while col < 80:
            vga_write_char(col, row, 32, color_attr)
            col = col + 1
        row = row + 1

fn kmain():
    hw_cli()             # Disable interrupts during driver initialization
    vga_clear(0x1F)      # Clear screen with Blue background, White text
    vga_write_char(0, 0, 70, 0x1F) # 'F'
    vga_write_char(1, 0, 84, 0x1F) # 'T'
    hw_sti()             # Re-enable interrupts
    while true:
        hw_hlt()         # Low-power idle state until next interrupt

include "std:hw"

let COM1_PORT = 0x3F8

fn com1_init():
    hw_out8(COM1_PORT + 1, 0x00)    # Disable all interrupts
    hw_out8(COM1_PORT + 3, 0x80)    # Enable DLAB (set baud rate divisor)
    hw_out8(COM1_PORT + 0, 0x03)    # Set divisor to 3 (38400 baud) lo-byte
    hw_out8(COM1_PORT + 1, 0x00)    #                                hi-byte
    hw_out8(COM1_PORT + 3, 0x03)    # 8 bits, no parity, one stop bit
    hw_out8(COM1_PORT + 2, 0xC7)    # Enable FIFO, clear them, 14-byte threshold
    hw_out8(COM1_PORT + 4, 0x0B)    # IRQs enabled, RTS/DSR set

fn com1_putc(c: Int):
    while (hw_in8(COM1_PORT + 5) & 0x20) == 0:
        hw_hlt()
    hw_out8(COM1_PORT, c)

# Set vector font size dynamically in pixels (e.g. 14, 18, 24, 32, 48)
gui_set_font_size(20)

# Dynamically load external TrueType fonts from assets:
let font_inter    = gui_load_font("assets/fonts/inter.ttf")
let font_playfair = gui_load_font("assets/fonts/playfair.ttf")
let font_fira     = gui_load_font("assets/fonts/fira_code.ttf")

# Activate vector font globally:
gui_set_font_family(font_inter)

# Render with proportional kerning, baseline alignment, and smooth 8-bit alpha coverage:
gui_draw_text("Crisp Vector Typography", 100, 100, 1, Color(255, 255, 255, 255))
gui_draw_text_font("Luxury Editorial Serif", 100, 140, 1, font_playfair, Color(245, 158, 11, 255))

include "std:animation"
include "std:ui"
include "std:gui"

fn main() -> Int:
    gui_init_window(960, 640, "FrontLang Modern GUI")
    gui_set_font_size(18)

    let active = true
    let progress = 1.0

    while not gui_window_should_close():
        gui_poll_events()
        gui_begin_frame()

        let dt = gui_get_delta_time()
        
        # Smooth spring animation
        let target = 0.0
        if active:
            target = 1.0
        progress = lerp_float(progress, target, dt * 10.0)

        # Clear background with dark slate
        gui_clear(Color(15, 23, 42, 255))

        # Elevated card with soft drop shadow
        ui_card(40, 40, 400, 260, 14, 4, Color(30, 41, 59, 255), Color(51, 65, 85, 255))

        # Dynamic interactive button with hover and click state
        let clicked = ui_button_styled(60, 180, 160, 36, 18, 1, Color(79, 70, 229, 255), Color(129, 140, 248, 255), Color(255, 255, 255, 255), "Launch")

        # Smooth animated toggle switch
        active = ui_switch_animated(300, 184, 52, 28, active, progress)

        gui_end_frame()
    return 0

include "std:game"
include "std:gui"
include "std:audio"

fn main() -> Int:
    game_init_window("FrontLang Arcade", 800, 600)
    audio_init()

    let player_x = 400.0
    let player_y = 500.0
    let speed = 350.0

    while true:
        # Lock frame rate to 60 FPS and obtain precise delta time
        let dt = game_frame_pacing(60)
        game_poll_events()

        # Arrow key inputs
        if game_key_down(37): # Left Arrow
            player_x = player_x - speed * dt
        if game_key_down(39): # Right Arrow
            player_x = player_x + speed * dt

        # Spacebar triggers audio tone
        if game_key_down(32):
            audio_play_tone(523.25, 40, 0.5) # Note C5

        # Render 2D Scene with Anti-Aliasing
        gui_clear(Color(15, 23, 42, 255))
        gui_draw_circle_aa(player_x, player_y, 18.0, Color(249, 115, 22, 255))
        gui_draw_text("Move: ← / → | Fire: SPACE", 240, 560, 0, Color(148, 163, 184, 255))

    return 0

frontlang run script.ft

# Compile source file into portable .ftbc bytecode
frontlang build src/main.ft

# Directly execute compiled bytecode on FrontVM
frontlang run src/main.ftbc

# 1. Compile to native standalone binary (.exe) with -O2 optimization
frontlang compile src/main.ft -o my_app.exe

# 2. Emit readable ANSI C99 source code without compiling
frontlang compile src/main.ft --emit-c

# 3. Freestanding bare-metal kernel object compilation (no libc / no crt0)
frontlang compile --freestanding kernel.ft -o kernel.bin

# 4. Emit clean freestanding C99 kernel source
frontlang compile --emit-freestanding-c kernel.ft -o kernel.c

# Compile specifically for WebAssembly / HTML5 canvas
frontlang compile app.ft --target wasm

# Compile for Linux with custom output path
frontlang compile app.ft --target linux -o bin/app

# Emit portable ANSI C99 source for cross-compiling
frontlang compile app.ft --emit-c

# Package an Android NDK NativeActivity project with AndroidManifest.xml and Gradle build scripts
frontlang package app.ft --target android

# Package a Web distribution with standalone index.html runner and Emscripten scripts
frontlang package app.ft --target web

# Package a Windows application bundle
frontlang package app.ft --target windows

# Declare libc standard functions
extern fn puts(s: String) -> Int
extern fn abs(n: Int) -> Int
extern fn sqrt(x: Float) -> Float

# Explicit DLL specification for Windows Win32 API
extern "msvcrt.dll" fn printf(fmt: String) -> Int
extern "user32.dll" fn MessageBoxA(hwnd: Int, text: String, title: String, utype: Int) -> Int

fn main() -> Int:
    puts("Direct C ABI invocation from FrontLang")
    let root = sqrt(144.0)
    show(root)
    return 0

# tests/test_math.ft

fn test_addition():
    let sum = 10 + 20
    assert(sum == 30, "Addition arithmetic check")

fn test_string_prefix():
    let s = "FrontLang"
    assert(s.starts_with("Front"), "Prefix assertion failed")

fn test_boolean_logic():
    assert(true and not false, "Boolean logic check")

frontlang test
# Output:
running 3 tests across project...
test test_addition ... ok
test test_string_prefix ... ok
test test_boolean_logic ... ok

test result: ok. 3 passed; 0 failed; 0 ignored (time: 0.8ms)

# Launch Language Server Protocol over standard I/O (JSON-RPC 2.0)
frontlang lsp

code --install-extension frontlang-0.1.0.vsix