A Professional & Modern Programming Language Compiler

ProXPL - ProX Programming Language is a modern, Indian-origin programming language designed for speed, simplicity, and professional-grade development. It combines Python-like readability with C-level performance, focusing on clean syntax, scalable systems, and a growing native ecosystem.

• Clarity First: Familiar curly-brace syntax (similar to JavaScript/Go) ensures a low learning curve.
• Type Safety: A strong type system (Compile-time & Runtime) prevents common errors before they happen.
• Performance: Source code is compiled to bytecode and executed on a custom, optimized stack-based Virtual Machine.
• Batteries Included: A rich standard library allows you to build useful applications immediately without external dependencies.

ProXPL is a modern, general-purpose programming language designed for clarity, performance, and long-term maintainability.
It combines a clean, expressive syntax with a structured and strongly typed core, making it suitable for building reliable software systems at any scale.

ProXPL is implemented with a bytecode compiler and a C-based virtual machine, providing predictable execution and a solid foundation for performance-oriented workloads.

• Readable & Expressive Syntax
  A clear, modern syntax inspired by high-level languages, focused on developer productivity and code clarity.

• Strong Typing & Defined Semantics
  Explicit language rules and type safety to improve correctness and reduce runtime errors.

• Efficient Runtime
  Bytecode compilation executed on a custom virtual machine for consistent and optimized execution.

• Modular & Scalable Architecture
  Clean separation between lexer, parser, compiler, and VM, enabling maintainable and extensible implementations.

ProXPL is well-suited for:

• Command-line tools and system utilities
• Backend services and application logic
• Automation and scripting with production reliability
• Structured, long-lived software projects

ProXPL aims to provide a balanced programming model that emphasizes simplicity without sacrificing control or performance.

ProXPL bridges the gap between simplicity (Python-like syntax) and performance (C-based runtime). It combines:

• Familiar Syntax: Inspired by Python and JavaScript
• Strong Type System: Compile-time and runtime type checking
• Fast Runtime: Bytecode-compiled and executed on a custom VM
• Rich Standard Library: 75+ built-in functions for common tasks
• Modular Architecture: Clear separation of lexer, parser, compiler, and VM

Create a file named hello.prox:

// hello.prox
func main() {
    print("Welcome to ProXPL!");

    let name = input("Enter your name: ");
    print("Hello, " + name + "!");

    // Generate a random number using the standard library
    let lucky = random(1, 100);
    print("Your lucky number is: " + to_string(lucky));
}

main();

Using the CLI:

prox run hello.prox

Or using the legacy direct execution:

./proxpl hello.prox

Welcome to ProXPL!
Enter your name: Alice
Hello, Alice!
Your lucky number is: 42

The ProXPL CLI provides an enhanced experience with watch mode and better logging.

cd src/cli
npm install
npm link

Now you can use the prox command globally.

No compilation required. Download the latest release for your OS:

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

Add the executable to your system PATH to run it as proxpl.

Requirements: GCC/Clang (C99+), CMake 3.10+, Git.

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

# Create build directory
mkdir build && cd build

# Configure and build
cmake -DCMAKE_BUILD_TYPE=Release ..
make

# Install (Optional)
sudo make install

ProXPL supports 12 core data types, including Lists and Dictionaries.

let message = "System Active";
let count = 42;
let list = [1, 2, 3, 4];
let config = {"host": "localhost", "port": 8080};

push(list, 5);
print(config["host"]);

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

func main() {
    for (let i = 0; i < 10; i = i + 1) {
        print("fib(" + to_string(i) + ") = " + to_string(fibonacci(i)));
    }
}

ProXPL uses the use keyword for modularity. Circular imports are handled automatically.

use math;           // Import standard library
use utils/io;       // Import installed package
use local_helper;   // Import local file

print(math.sqrt(16));

Manage dependencies using the built-in ProX Repository Manager.

prm install utils/io      # Install a package
prm list                  # List installed packages
prm search http           # Search the registry

ProXPL follows a professional three-phase compiler architecture aimed at maintainability and performance.

graph LR
    A[Source Code] --> B[Lexer]
    B --> C[Parser / AST]
    C --> D[Type Checker]
    D --> E[Compiler]
    E --> F[Bytecode Chunk]
    F --> G[Virtual Machine]
    G --> H[Execution]

ProXPL/
├── include/              # Header files (Interfaces)
│   ├── vm.h
│   ├── compiler.h
│   └── stdlib_native.h
├── src/                  # Implementation Source
│   ├── main.c            # Entry point
│   ├── lexer/            # Tokenizer logic
│   ├── parser/           # AST and Type Checking
│   ├── runtime/          # VM and Garbage Collector
│   └── stdlib/           # Native Standard Library impl
├── cli/                  # PRM and CLI tools
├── examples/             # ProXPL code samples
├── docs/                 # Specifications and Guides
└── tests/                # Unit and Integration tests

Detailed documentation is available in the docs/ directory:

• Language Specification: Grammar, Keywords, and Operators.
• Standard Library Reference: Documentation for all 75+ built-in functions.
• Architecture Guide: Deep dive into the VM and Compiler internals.
• Build Guide: Platform-specific instructions (Windows/Linux/Mac).

• v0.1.0 (Current): Core language, VM, Stdlib, Basic I/O.
• v0.2.0: Class-based OOP, Advanced Error Handling.
• v0.3.0: Native Foreign Function Interface (FFI).
• v1.0.0: Production Stability, Async/Await Support.

We welcome contributors! ProXPL is an excellent project for learning compiler design.

1. Fork the repository.
2. Create a feature branch (git checkout -b feature/AmazingFeature).
3. Commit your changes following the Coding Standard.
4. Push to the branch and Open a Pull Request.

Please read CONTRIBUTING.md for details on our code of conduct.

This project is licensed under the ProX Professional License - see the LICENSE file for details.

Built with ❤️ by the ProXPL Community