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

# 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

# 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

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

# Ahead-of-Time compile to native standalone binary (.exe)
frontlang compile src/main.ft -o my_app.exe

# Emit generated C99 source code without invoking system C compiler
frontlang compile src/main.ft --emit-c

# 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)

code --install-extension frontlang-0.1.0.vsix