Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/leocavalcante/vhp

VHP: Vibe-coded Hypertext Preprocessor - A PHP superset built in Rust through AI-assisted development
https://github.com/leocavalcante/vhp

ai-generated compiler interpreter language-implementation lexer parser php programming-language rust vibe-coding

Last synced: 5 days ago
JSON representation

VHP: Vibe-coded Hypertext Preprocessor - A PHP superset built in Rust through AI-assisted development

Awesome Lists containing this project

README 

          


  


  VHP Logo

  


  VHP

  





Vibe-coded Hypertext Preprocessor





  What if you could build an entire programming language... just by asking?






  CI

  License

  Stars






  Features •

  Installation •

  Usage •

  Examples •

  Roadmap




---



## 🚀 The Audacious Experiment



**VHP** isn't just another PHP implementation. It's a **groundbreaking experiment** in AI-assisted development: **Can an entire production-grade language runtime be built purely through conversation with AI?**



Every. Single. Line. Written through prompts to AI agents. Zero manual coding.



**The result?** A blazingly fast, memory-safe PHP 8.x bytecode VM written in pure Rust with **zero dependencies** — and it actually works.



### 💎 Why This Changes Everything



- **🔥 Blazingly Fast** — Stack-based bytecode VM compiled from Rust

- **🛡️ Rock-Solid Security** — Memory safety guaranteed by Rust's ownership model

- **🎯 Zero Dependencies** — Pure standard library, no external crates, no bloat

- **✨ PHP 8.x Compatible** — Run your existing PHP code unchanged

- **🔮 Modern Features** — Arrow functions, match expressions, fibers, attributes, pipe operator

- **📈 Battle-Tested** — Comprehensive test suite



## ⚡ Get Started in 60 Seconds



```bash

# Clone and build

git clone https://github.com/leocavalcante/vhp.git

cd vhp

cargo build --release



# Your first VHP program

./target/release/vhp -r 'echo "Hello from the future!";'



# Run any PHP file

./target/release/vhp script.php



# Run tests

make test



# Run performance benchmarks

make bench

```



**That's it.** You're now running PHP with Rust-level performance.



## ⚡ Performance



Run `make bench` to see performance characteristics:



```

Source Code → Lexer → Tokens → Parser → AST → Compiler → Bytecode → VM → Output

```



VHP uses a **stack-based bytecode VM** that compiles PHP to optimized bytecode. The compiler and VM are written in native Rust, providing:



- **Zero-cost abstractions** from Rust's ownership model

- **No garbage collection** overhead during execution

- **Optimized built-in functions** written in native Rust

- **Efficient memory management** with compile-time guarantees



The architecture follows a classic interpreter pipeline with compilation to bytecode for efficient execution.



## 🎨 The Power of Modern PHP + Rust Performance



VHP brings the **cutting-edge features** of PHP 8.x with the **raw speed** of Rust. Here's what you get:



### Functional Programming That Actually Feels Good



```php

 $x * 2, $numbers);



// First-class callables (PHP 8.1) - elegant function references

$formatter = strtoupper(...);

echo $formatter("hello"); // HELLO



// Method callables (PHP 8.1) - create closures from methods

class Calculator {

    public function add($a, $b) {

        return $a + $b;

    }

    

    public static function multiply($n) {

        return $n * 2;

    }

}



$calc = new Calculator();

$add = $calc->add(...);

echo $add(5, 3); // 8



$double = Calculator::multiply(...);

echo $double(7); // 14



// Pipe operator (PHP 8.5) - chain operations beautifully

$result = "hello world"

    |> strtoupper(...)

    |> str_replace("WORLD", "VHP", ...)

    |> strlen(...);

```



### Modern Language Features



```php

 "Success",

    404 => "Not Found",

    500, 503 => "Server Error",

    default => "Unknown"

};



// Enums (PHP 8.1) - type-safe choices

enum Status: string {

    case Active = "active";

    case Pending = "pending";

    case Closed = "closed";

}



// Named arguments (PHP 8.0) - crystal clear function calls

createUser(

    name: "Alice",

    email: "alice@example.com",

    verified: true

);

```



### Enterprise-Ready Concurrency



```php

start();

$fiber->resume(); // Non-blocking concurrent execution

```



### Full OOP Suite



- ✨ **Anonymous Classes** — Create objects on-the-fly without declaring classes

- 🏗️ **Constructor Property Promotion** — Less boilerplate, more productivity (PHP 8.0)

- 🔒 **Readonly Properties & Classes** — Immutability for safer code (PHP 8.1/8.2)

- 🎭 **Interfaces & Traits** — Flexible, composable design patterns

- 🛡️ **Attributes** — Metadata that doesn't suck (PHP 8.0)

- 🚫 **Exception Handling** — try/catch/finally with throw expressions

- ✅ **Runtime Type Validation** — Full parameter and return type checking (PHP 7.0+)



## 🔥 What Makes VHP Special



## 🤖 The "Vibe Coding" Revolution



Here's where it gets wild: **VHP is proof that AI can build production-grade systems.**



Every function, every test, every feature — built through **natural language conversations** with AI agents. No manual code writing. Just prompts, iteration, and AI doing the heavy lifting.



**This is the experiment:** Can you "vibe code" an entire programming language runtime into existence?



**The answer:** You're looking at it.



### Why Not Just Vibe Code Your Own Rust App?



Fair question. Here's the thing: **existing codebases**.



There are **millions** of PHP applications in production right now. WordPress powers 43% of the web. Laravel runs countless startups. Drupal backs major enterprises. Custom PHP systems everywhere.



**VHP gets you a new runtime for *all* of them** — without rewriting a single line of their code.



Vibe coding Rust gets you *one* new app. VHP gets you a platform for *all* PHP apps.



That's the difference between a tool and an ecosystem.



## 📊 Full Feature Checklist



**Core Language:**

- ✅ PHP tags (``, `=`) with mixed HTML/PHP

- ✅ Variables, operators, and expressions

- ✅ Control flow (if/else, while, for, foreach, switch)

- ✅ Arrays (indexed, associative, nested, with trailing commas)

- ✅ User-defined and recursive functions

- ✅ Variadic functions and argument unpacking



**Modern PHP Features:**

- ✅ Arrow functions with automatic capture (PHP 7.4)

- ✅ First-class callables (PHP 8.1)

- ✅ Match expressions (PHP 8.0)

- ✅ Named arguments (PHP 8.0)

- ✅ Attributes with reflection (PHP 8.0)

- ✅ Enums - pure and backed (PHP 8.1)

- ✅ Pipe operator (PHP 8.5)

- ✅ Fibers for concurrency (PHP 8.1)

- ✅ Generators with yield/yield from (PHP 5.5/7.0) - parsing complete, full execution in progress



**Object-Oriented Programming:**

- ✅ Classes & Objects (properties, methods, constructors, $this)

- ✅ Static properties with late static binding (PHP 5.0/5.3)

- ✅ Static methods

- ✅ Inheritance

- ✅ Anonymous classes (PHP 7.0)

- ✅ Interfaces and Traits

- ✅ Abstract classes and methods

- ✅ Final classes and methods

- ✅ Constructor Property Promotion (PHP 8.0)

- ✅ Readonly properties (PHP 8.1)

- ✅ Readonly classes (PHP 8.2)

- ✅ Property hooks with get/set (PHP 8.4)

- ✅ Asymmetric visibility (PHP 8.4)

- ✅ #[\Override] attribute (PHP 8.3)

- ✅ Object cloning with `clone` and `clone with` (PHP 8.4)

- ✅ Magic methods (__toString, __invoke, __get/__set, __call)



**Type System:**

- ✅ Runtime type validation for parameters and return types (PHP 7.0+)

- ✅ Simple types (int, string, float, bool, array, object, callable, iterable, mixed)

- ✅ Nullable types (?int, ?string, PHP 7.1)

- ✅ Union types (int|string, PHP 8.0)

- ✅ Intersection types (Iterator&Countable, PHP 8.1)

- ✅ DNF types ((A&B)|C, PHP 8.2)

- ✅ Class type hints

- ✅ void and never return types

- ✅ declare(strict_types=1) for strict type checking (PHP 7.0)



**PCRE Regex (PHP 4+):**

- ✅ preg_match - Perform a regular expression match

- ✅ preg_match_all - Perform a global regular expression match

- ✅ preg_split - Split string by a regular expression

- ✅ preg_replace - Perform a regular expression search and replace

- ✅ preg_replace_callback - Perform a search and replace with a callback

- ✅ preg_grep - Return array entries that match a pattern



**Date/Time Functions (PHP 4+):**

- ✅ time - Current Unix timestamp

- ✅ mktime - Get Unix timestamp from date components

- ✅ strtotime - Parse date string to Unix timestamp

- ✅ gmdate - Format GMT/UTC date

- ✅ gmstrftime - Format date with locale



**Namespaces:**

- ✅ Namespace declarations (braced and unbraced syntax, PHP 5.3)

- ✅ Qualified names (Foo\Bar, \Foo\Bar)

- ✅ Use statements with aliases

- ✅ Group use declarations (PHP 7.0)

- ✅ Namespace resolution for classes and interfaces



**Error Handling:**

- ✅ Exception handling (try/catch/finally)

- ✅ Throw expressions (PHP 8.0)

- ✅ Multi-catch blocks



**[→ See complete feature documentation](https://leocavalcante.github.io/vhp/features)**



## 🎯 What's Next



We're just getting started. Check out [roadmap](https://leocavalcante.github.io/vhp/roadmap) to see what's coming:



- More built-in functions (date/time, advanced array functions)

- Full generator execution with send/throw/return methods

- Complete Fiber support

- Composer compatibility

- Performance optimizations

- And much more...



## 🤝 Join the Revolution



**Want to be part of this experiment?**



- 🐛 **Found a bug?** Open an issue

- 💡 **Have an idea?** Submit a feature request

- 📝 **Improve docs?** PRs welcome

- ✅ **Add tests?** We love comprehensive coverage

- ⭐ **Show support?** Star the repo



Every contribution helps prove that AI-assisted development can build real, production-grade software.



**[→ Contributing Guidelines](https://leocavalcante.github.io/vhp/contributing)**



## 📜 License



BSD 3-Clause License - see [LICENSE](LICENSE) for details.



---





  Built with Rust 🦀 and AI 🤖

  



  An experiment in what's possible when humans and AI collaborate

  



  Don't just read about it. Try it now.