Build Web Apps Faster Than Ever

RAMPHP is the revolutionary low-code PHP framework with built-in PWA support, auto-routing, and drag-and-drop API builder. Focus on your ideas, not boilerplate code.

Get Started Live Demo

Why Choose RAMPHP?

Lightning Fast

Optimized for performance with smart caching and efficient routing. Benchmarked 3x faster than traditional PHP frameworks.

Modular Architecture

Component-based structure inspired by Angular. Build reusable modules that automatically handle routing and dependencies.

Low-Code Development

Visual API builder, auto-generated CRUD endpoints, and model-driven database design. Write less code, build more.

Built-in Security

VWT encryption, CSRF protection, and secure defaults. We handle security so you can focus on features.

PWA Ready

Progressive Web App support out of the box. Service workers, manifest generation, and offline capabilities included.

Extensible

Plugin system that lets you extend core functionality without modifying framework files. Keep your upgrades painless.

Getting Started with RAMPHP

System Requirements

PHP 7.4+ (8.1 recommended)
Composer 2.0+
MySQL 5.7+ or MariaDB 10.3+
Apache/Nginx/OpenResty

Installation

Install RAMPHP using Composer:

                    # Create new project
                    composer create-project ramphp/ramphp my-project
                    
                    # Navigate to project
                    cd my-project
                    
                    # Start development server
                    composer start
                    
                    # Access at http://localhost:5200

Project Structure

RAMPHP follows a modular structure:

ramphp/  
├── public/               # UI Components  
├── src/   
│   ├── Models/           # Database Models (Auto-Generated Tables)  
│   ├── Themes/           # Different Themes for UI  
│   ├── Plugins/          # Different Plugins support  
│   └── Storage/          # Storage for Cache for UI & Services  
│   
├── services/             # API Services  
├── lib/                  # Framework Classes, Controllers, Handlers & Kernels  
│   ├── Controllers/      
│   ├── Handlers/         
│   └── Kernels/         
│
├── public/               # Web Root  
└── vendor/               # Composer Dependencies

Core Documentation

Key Concepts

Modules: Self-contained feature units (like Angular modules)
Components: Reusable UI elements with automatic routing
Models: Class-based database definitions that auto-create tables
Services: API endpoints with built-in CRUD operations
VWT: Vital Web Token encryption for secure data

Creating a Module

                    # Generate a new module
                    from Admin/Developer UI Generate Module 
                    
                    # This creates:
                    BlogModule folder in public folder where it will generate 2 files mainly (css, js are optional)
                    
                    # Auto-routes:
                    # /blog -> BlogModule default component
                    

Database Models

                    // src/Models/Users.php
                    namespace Ramphp\Models;
use Ramphp\Controllers\ModelsController;
class UsersModel extends ModelsController {
    public $id;          // Auto Primary Key
    public $name;        // VARCHAR(255)
    public $email;       // VARCHAR(255), Unique
    public $created_at;  // TIMESTAMP
}
                    
                    // Auto-creates 'users' table
                

Module System

Module Structure

                    BlogModule/
                    ├── BlogModule.php      # Module definition and routing runner
                    ├── BlogModule.html     
                    └── BlogModule.css  
                

Component Routing

Automatic routing based on structure:

                    /blog               -> BlogModule default component
                    /blog/posts         -> BlogModule/PostsComponent
                    /blog/posts/{id}    -> Dynamic parameter handling
                

Module Configuration

                    // src/Modules/Blog/BlogModule.php
                    class BlogModule {
                        public function dependencies() {
                            return ['User']; // Requires UserModule
                        }
                        
                        public function routes() {
                            return [
                                'custom-route' => 'CustomController@method'
                            ];
                        }
                    }
                

Low-Code API Builder

Accessing the Builder

After starting your development server:

                    # Start server
                    composer start
                    
                    # Access API builder at:
                    http://localhost:5200/admin/api-builder
                

Creating an API Endpoint

Click "New Endpoint"
Define route (e.g., /api/products)
Select HTTP methods (GET, POST, etc.)
Map to model or custom logic
Set permissions and validation rules

Generated Code Example

                    // Generated in src/Services/ProductService.php
                    class ProductService {
                        public function get_products() {
                            return Product::all()->toArray();
                        }
                        
                        public function create_product($data) {
                            $product = new Product($data);
                            $product->save();
                            return $product;
                        }
                    }
                

Join Our Community

GitHub

Contribute to the open-source project, report issues, and request features.

Visit GitHub

Discord

Chat with other developers, get help, and share your projects.

Join Discord

Documentation

Comprehensive guides and API references for all features.

Read Docs

RAM PHP