ProXPL

<div align="center"><h1> ProXPL - ProX Programming Language </h1></div> <p align="center"> <b>A Modern, High-Performance Programming Language</b> </p> <div align="center">

Clean Syntax • Static Typing • Stack-Based VM • C-Level Performance

Quick Start • Installation • Documentation • Architecture • Contributing

</div>

---

📖 Introduction

ProXPL (ProX Programming Language) is a modern, statically-typed multi-paradigm systems programming language that seamlessly integrates Object-Oriented, Intent-Oriented, and Context-Oriented features for clarity, performance, and reliability. Born from a vision to combine Python's readability with C's execution speed, ProXPL features a professional compiler architecture, a custom stack-based bytecode VM, a robust static type system, and an integrated package manager (PRM).

ProXPL is implemented entirely in C/C++ with zero runtime dependencies, making it ideal for high-performance systems, embedded applications, game development, and backend services. It serves as an excellent reference for learning compiler design and interpreter implementation.

Why ProXPL?

• 🎯 Familiar Syntax: Clean, expressive syntax inspired by JavaScript and Python
• ⚡ True Performance: Bytecode compilation to a stack-based VM with LLVM backend for AOT compilation
• 🛡️ Type Safety: Static typing with intelligent type inference prevents entire classes of runtime errors
• 🔧 Batteries Included: 75+ built-in standard library functions covering I/O, math, strings, collections, and system operations
• 📦 Integrated Tooling: Built-in package manager (PRM), CLI tools, and LSP support
• 🏗️ Professional Architecture: Clean separation between lexer, parser, type checker, compiler, and VM

---

✨ Key Features

| Feature | Description | |---------|-------------| | 🔤 Modern Syntax | JavaScript-like syntax with curly braces, familiar control flow, and clean function definitions | | 🎨 ProXPL Icons | 1100+ File Icons support via the official extension (Material Icon Theme integration) | | ⚡ Fast Execution | Custom stack-based VM executing optimized bytecode with LLVM AOT compilation support | | 📦 Rich Standard Library | 75+ native functions for I/O, mathematics, string manipulation, collections, and system tasks | | 🛡️ Static Type System | Compile-time type checking with type inference reduces runtime errors | | 🧩 Module System | Robust use keyword for importing standard libraries, packages, and local files | | 🔧 PRM Package Manager | Integrated ProX Repository Manager for dependency management and project scaffolding | | 🏗️ Multi-Phase Compiler | Lexer → Parser (AST) → Type Checker → IR Optimizer → Bytecode/LLVM | | ⏩ Async/Await | Native asynchronous programming with LLVM Coroutines support | | 🔄 Multi-Paradigm | Native support for Object-Oriented, Intent-Oriented, and Context-Oriented programming | | 🔍 Developer Tools | CLI with watch mode, LSP for IDE integration, comprehensive error reporting | | 🎯 Memory Safety | Built-in garbage collector with mark-and-sweep algorithm | | 🌐 Cross-Platform | First-class support for Windows, Linux, and macOS |

🏛️ The 10 Operational Pillars (v1.3.0)

ProXPL introduces 10 revolutionary concepts that redefine modern systems programming:

1. Intent-Oriented Programming: Define what you want (intent), not just how to do it (resolver).
2. Context-Aware Polymorphism: Adapt function behavior dynamically based on execution context (context, layer, activate).
3. Autonomic Self-Healing (ASR): Built-in failure recovery with resilient and recovery blocks.
4. Intrinsic Security: Taint analysis and sanitize() primitives baked into the type system.
5. Chrono-Native Logic: Data with expiration dates (temporal, decay after).
6. Event-Driven Concurrency: Distributed nodes and types (distributed, node) as first-class citizens.
7. AI-Native Integration: Define, train, and run ML models (model, train, predict) natively.
8. Quantum-Ready Syntax: Future-proof syntax for quantum operations (quantum, superpose, entangle).
9. Hardware-Accelerated Math: GPU kernel offloading (gpu, kernel) and tensor math.
10. Zero-Trust Security: Mandatory identity verification blocks (verify identity) and crypto primitives.

---

⚡ Quick Start

Your First Program

Create a file named hello.prox:

// hello.prox
// Your first ProXPL program

func main() {
    print("Welcome to ProXPL!");
    
    let name = input("What is your name? ");
    print("Hello, " + name + "!");
    
    // Generate a random lucky number
    let lucky = random(1, 100);
    print("Here is a lucky number for you: " + to_string(lucky));
}

main();

Run It

Using the ProXPL CLI:

prm run hello.prox

Or using the compiled executable:

./proxpl hello.prox

Output

Welcome to ProXPL!
What is your name? Alice
Hello, Alice!
Here is a lucky number for you: 42

---

📥 Installation

Option 1: Pre-built Binaries (Recommended)

Download the latest release for your operating system:

• Windows: Download proxpl.exe
• Linux: Download proxpl
• macOS: Download proxpl-macos

Add the executable to your system PATH for global access.

Option 2: Build from Source

Requirements:

• C/C++ Compiler (GCC 9+, Clang 10+, or MSVC 2019+)
• CMake 3.15+
• LLVM 10+ (for AOT compilation support)
• Git

Build Instructions:

# Clone the repository
git clone https://github.com/ProgrammerKR/ProXPL.git
cd ProXPL

# Create build directory
mkdir build && cd build

# Configure with CMake
cmake -DCMAKE_BUILD_TYPE=Release ..

# Build the project
make

# Optional: Install system-wide
sudo make install

Windows (Visual Studio):

mkdir build && cd build
cmake -G "Visual Studio 16 2019" ..
cmake --build . --config Release

Option 3: CLI via Node.js (Enhanced Developer Experience)

The ProXPL CLI provides watch mode, better logging, and development conveniences:

cd src/cli
npm install
npm link

Now use the prox command globally with enhanced features.

---

💻 Language Tour

Variables & Data Types

ProXPL supports 12 core data types with static type checking:

// Primitives
let count = 42;              // Integer
let price = 19.99;           // Float
let active = true;           // Boolean
let message = "Hello!";      // String

// Collections
let numbers = [1, 2, 3, 4, 5];                    // List
let config = {"host": "localhost", "port": 8080}; // Dictionary

// Type inference works automatically
let auto = 100;  // Inferred as Integer

Functions & Control Flow

// Function definition
func fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Loops and iteration
func main() {
    for (let i = 0; i < 10; i = i + 1) {
        print("fib(" + to_string(i) + ") = " + to_string(fibonacci(i)));
    }
    
    // While loops
    let count = 0;
    while (count < 5) {
        print("Count: " + to_string(count));
        count = count + 1;
    }
}

main();

Working with Collections

func demonstrate_collections() {
    // Lists
    let items = [1, 2, 3];
    push(items, 4);           // Add element
    let first = items[0];     // Access by index
    let size = length(items); // Get size
    
    // Dictionaries
    let user = {"name": "Alice", "age": 30};
    user["email"] = "alice@example.com";  // Add key
    let name = user["name"];              // Access value
    
    // Iteration
    for (let i = 0; i < length(items); i = i + 1) {
        print(to_string(items[i]));
    }
}

Tensor Operations (AI/Math)

ProXPL supports native tensor operations for AI and scientific computing:

func tensor_demo() {
    // Define tensors using nested bracket syntax
    let matrix = [[1, 2], [3, 4]];
    let identity = [[1, 0], [0, 1]];
    
    // Matrix multiplication using @ operator
    let result = matrix @ identity;
    print(result);  // <tensor 2x2>
    
    // Dot product for 1D tensors
    let v1 = [1, 2, 3];
    let v2 = [4, 5, 6];
    let dot = v1 @ v2;
    print(dot);     // 32
}

Module System

ProXPL uses the use keyword for modular programming:

// Import standard library module
use std.math;

// Import from installed package
use http.client;

// Import local file (relative path)
use local_helper;

func main() {
    let result = std.math.sqrt(16);

    print("Square root of 16: " + to_string(result));
}

Async/Await

ProXPL supports native asynchronous programming:

async func