More Frameworks
Other Frameworks Worth Listing
Grav
PHP Framework
Grav is a modern, open-source flat-file Content Management System (CMS). Because it does not rely on a traditional database, it is extremely fast, easy to set up, and perfect for version control. You create content in Markdown, configure it with YAML, and style it using the Twig templating engine.
More Information...
How Grav Works: A Page Example
To understand Grav, it helps to see how it structures its files. Unlike WordPress, which queries a database for every page visit, Grav translates your server's folder and file structure directly into website pages.
If you want to create an "About" page, you don't use a web dashboard to create a post; instead, you create a folder and a text file on your computer.
Inside your Grav directory, your user content lives in the user/pages/ folder. To make an "About" page that appears in your site's main menu, you create a folder named 02.about:
user/
└── pages/
├── 01.home/
│ └── default.md
└── 02.about/
└── default.md
(Note: The 02. tells Grav to place this page in the second position of your navigation menu, and the number will automatically be stripped out of the final URL).
- 2. The Content File (default.md)
Inside that 02.about folder, you create a text file named default.md. Inside this file, you define the settings at the top (frontmatter) using YAML and the page text using Markdown:
---
title: 'About Me'
menu: 'About Us'
body_classes: 'title-center'
---
# Welcome to my page!
This is an **example** of how easy it is to write content in [Grav](https://getgrav.org/).
* No database queries required.
* Lightning fast page loads.
* Written entirely in plain text.
Why Use Grav?
-
Zero Database: There is nothing to install. Simply upload the Grav files to your web hosting provider or extract them on your local machine, and your website is ready.
-
Safe Upgrades: Because all your personal content, themes, and plugins are kept in the user/ folder, you can safely update the Grav core files without worrying about breaking your site.
-
Highly Extensible: Even though it's a "flat-file" CMS, you can still add powerful features like contact forms, SEO plugins, or custom themes via the Grav Package Manager.
For full documentation visit getgrav.org.
Flask 
Python Framework
Flask is a lightweight, open-source micro web framework written in Python. It is considered a "micro-framework" because it doesn't include built-in tools like databases or form validation. Instead, it provides the core essentials—like URL routing and request handling—allowing you to easily scale and customize your application with extensions.
More Information...
Prerequisites
Before running Flask, ensure you have Python installed. You can install the Flask framework using your command-line interface or terminal:
pip install Flask
Minimal "Hello, World!" Example
This minimal Flask application creates a web server that listens for requests and displays a simple HTML string in the browser.
Create a file and name it app.py (avoid naming it flask.py to prevent conflicts).
Add the following code:
from flask import Flask
# Create an instance of the Flask class
app = Flask(__name__)
# Use the route decorator to bind the URL '/' to our function
@app.route("/")
def home():
return "<h1>Hello, World! Welcome to my Flask app!</h1>"
# Run the application
if __name__ == "__main__":
app.run(debug=True)
How to Run It
Open your terminal or command prompt.Tell Flask where your application is located and run it:
flask --app app run
Open your web browser and navigate to http://127.0.0.1:5000 to see your running app.
Handling Dynamic Routes
Flask makes it easy to capture variable data from URLs (e.g., /user/john).
@app.route("/user/<username>")
def profile(username):
return f"Hello there, {username}!"
If a user visits http://127.0.0.1:5000/user/alice, the page will output "Hello there, alice!".
For full documentation visit flask.palletsprojects.com.
Jinja 
Templating
Jinja is a fast, expressive, and highly popular template engine for Python that allows you to generate dynamic text-based formats like HTML, XML, CSV, or configuration files. It works by using special placeholder tags embedded in a text file, which are later replaced with actual data when the template is rendered by a Python script. It is a core component of frameworks like Flask and automation tools like Ansible and dbt.
More Information...
Core Syntax Types
Jinja uses unique delimiters to separate its code from regular text:
{{ ... }}: Expressions used to print variables or outputs.{% ... %}: Control structures used for logic like loops and conditionals.{# ... #}: Comments that are completely omitted from the final rendered text.
Code Example
This step-by-step example uses Python and Jinja to dynamically generate a user dashboard page.
- 1. The Template File (dashboard.html)
This file defines the layout. It uses a loop to build a list and a conditional statement to show a premium badge.
<!DOCTYPE html>
<html>
<head>
<title>User Profile</title>
</head>
<body>
<!-- 1. Variable Substitution -->
<h1>Welcome back, {{ user.name }}!</h1>
<!-- 2. Conditional Statement -->
{% if user.is_premium %}
<p class="badge">Premium Member Status: Active</p>
{% else %}
<p><a href="/upgrade">Upgrade to Premium today!</a></p>
{% endif %}
<!-- 3. For Loop and Filter Usage -->
<h3>Your Recent Activities:</h3>
<ul>
{% for activity in activities %}
<li>{{ activity | capitalize }}</li>
{% endfor %}
</ul>
</body>
</html>
- 2. The Python Script (render.py)
This script uses the Jinja Environment API to combine the HTML template with structural data dictionary objects.
from jinja2 import Environment, FileSystemLoader
# Set up the template engine to look inside the current directory
env = Environment(loader=FileSystemLoader('.'))
# Load the target template file
template = env.get_template('dashboard.html')
# Define the dynamic data payload
data_payload = {
"user": {
"name": "alice smith",
"is_premium": True
},
"activities": ["logged in", "updated profile", "downloaded report"]
}
# Process the template file with our data
final_output = template.render(data_payload)
# Print out the completed raw HTML string
print(final_output)
- 3. The Final Rendered Output
When run, the engine swaps variables, evaluates the true status of is_premium, and transforms the list strings via the capitalize filter.
<!DOCTYPE html>
<html>
<head>
<title>User Profile</title>
</head>
<body>
<!-- 1. Variable Substitution -->
<h1>Welcome back, alice smith!</h1>
<!-- 2. Conditional Statement -->
<p class="badge">Premium Member Status: Active</p>
<!-- 3. For Loop and Filter Usage -->
<h3>Your Recent Activities:</h3>
<ul>
<li>Logged in</li>
<li>Updated profile</li>
<li>Downloaded report</li>
</ul>
</body>
</html>
Key Features
-
Filters: Built-in pipe functions (|) to modify data format on the fly (e.g., {{ name|upper }} or {{ text|trim }}).
-
Template Inheritance: Allows you to create a base layout wrapper (like a universal footer and header) that child templates can easily extend.
-
Macros: Reusable code snippets similar to functions in Python programming.
-
Security: Includes integrated context-aware auto-escaping to block cross-site scripting (XSS) layout vulnerabilities.
For full documentation visit jinja.palletsprojects.com.
Twig 
PHP Template (Symfony)
Twig is the default, modern template engine for Symfony. It compiles templates down to plain, optimized PHP code to ensure maximum performance while keeping application logic strictly separated from the presentation layout.
More Information...
Core Syntax Types
Twig keeps its presentation clean by utilizing three distinct delimiter tags:
{{ ... }}: "Say something." Prints a variable value or expression output.{% ... %}: "Do something." Controls template logic like conditions, loops, and inheritance.{# ... #}: "Comment something." Adds developer comments that are omitted from final HTML.
Step-by-Step Implementation Example
Here is how a PHP Controller hands data over to a Twig view template using an example of a product list.
The backend controller prepares your data array and renders it into the designated template file.
<?php
// src/Controller/ProductController.php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
class ProductController extends AbstractController
{
#[Route('/products', name: 'product_list')]
public function list(): Response
{
$products = [
['name' => 'Wireless Mouse', 'price' => 29.99, 'available' => true],
['name' => 'Mechanical Keyboard', 'price' => 89.99, 'available' => false],
['name' => 'Gaming Monitor', 'price' => 249.99, 'available' => true],
];
// Pass the array to the Twig template
return $this->render('product/list.html.twig', [
'page_title' => 'Our Hardware Catalog',
'products' => $products,
]);
}
}
- 2. The Base Layout Template
Symfony establishes a central master layout file, typically named base.html.twig, where standard structural tags are defined globally.
{# templates/base.html.twig #}
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>{% block title %}Welcome!{% endblock %}</title>
</head>
<body>
<header>
<nav>My Cool Hardware Store</nav>
</header>
<main class="container">
{% block body %}{% endblock %}
</main>
</body>
</html>
- 3. The Child Template (Twig)
This child template extends the base structural layout via inheritance and handles looping, filters, and conditional syntax.
{# templates/product/list.html.twig #}
{% extends 'base.html.twig' %}
{% block title %}{{ page_title }}{% endblock %}
{% block body %}
<h1>{{ page_title|upper }}</h1> {# Using a filter to make text uppercase #}
<ul>
{% for product in products %}
<li>
<strong>{{ product.name }}</strong>
- ${{ product.price }}
{# Conditional statements #}
{% if product.available %}
<span style="color: green;">(In Stock)</span>
{% else %}
<span style="color: red;">(Out of Stock)</span>
{% endif %}
</li>
{% else %}
<li>No products found.</li>
{% endfor %}
</ul>
{% endblock %}
Core Twig Features Demonstrated
-
Template Inheritance: The {% extends %} tag pulls the shell structure from base.html.twig, while {% block %} sections overwrite specific placeholders with page-specific contents.
-
Filters: Pipes (|) transform variable outputs dynamically. In the example, {{ page_title|upper }} automatically converts strings into uppercase format.
-
Robust Loops: The {% for %} loop maps out array iterables effortlessly. The accompanying fallback {% else %} tag provides elegant recovery options if arrays return empty.
-
Automatic Escaping: Twig natively protects websites from Cross-Site Scripting (XSS) layout vulnerabilities by automatically escaping hazardous HTML syntax strings during rendering.
For full documentation visit twig.symfony.com.
Blade 
PHP Template (Laravel)
Blade is the simple, yet powerful templating engine provided natively with the Laravel Framework. Unlike other PHP templating engines, Blade does not restrict you from using plain PHP code in your views. All Blade views are compiled into plain PHP code and cached until they are modified, introducing zero performance overhead to your web application.
More Information...
Blade files use the .blade.php file extension and are saved inside the resources/views/ directory.
Key Features of Blade
-
Data Displaying: Uses clean {{ $variable }} syntax which automatically sanitizes data against XSS attacks.
-
Template Inheritance: Allows you to create a master layout and extend it across multiple sub-pages.
-
Control Structures: Replaces complex PHP blocks with elegant directives like @if, @foreach, and @auth.
-
Blade Components: Provides custom, reusable HTML-like tags for UI elements.
Step-by-Step Example
This practical example demonstrates how to build a layout, extend it into a view, pass data from a route, and use control structures.
- 1. Create a Master Layout
Save this file as resources/views/layouts/app.blade.php. This defines your skeleton structure.
<!-- resources/views/layouts/app.blade.php -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>My App - @yield('title')</title>
</head>
<body>
<header style="background: #eee; padding: 10px;">
<h1>Navigation Bar</h1>
</header>
<main>
<!-- This placeholder will hold content from child pages -->
@yield('content')
</main>
<footer>
<p>© 2026 My Application</p>
</footer>
</body>
</html>
Save this file as resources/views/dashboard.blade.php. It inherits the master layout using @extends and fulfills the defined regions using @section.
<!-- resources/views/dashboard.blade.php -->
@extends('layouts.app')
@section('title', 'User Dashboard')
@section('content')
<h2>Welcome to your Dashboard!</h2>
<!-- Displaying escaped data securely -->
<p>Hello, {{ $username }}</p>
<h3>Your Tasks For Today:</h3>
<!-- Conditional Statement Directive -->
@if(count($tasks) > 0)
<ul>
<!-- Loop Directive -->
@foreach($tasks as $task)
<li>{{ $task }}</li>
@endforeach
</ul>
@else
<p>No tasks left! Enjoy your day.</p>
@endif
@endsection
- 3. Return the View with Data from a Route
Inside your routes/web.php file, map a URL route to return this dashboard view along with a dataset.
<?php
// routes/web.php
use Illuminate\Support\Facades\Route;
Route::get('/dashboard', function () {
return view('dashboard', [
'username' => 'Alex',
'tasks' => ['Deploy application', 'Review pull requests', 'Write documentation']
]);
});
Core Syntax Cheat Sheet
-
{{ $variable }}: Safely prints escaped data using PHP's htmlspecialchars to prevent XSS attacks.
-
{!! $variable !!}: Prints raw, unescaped HTML data (only use for trusted content).
-
@if / @else / @endif: Clean alternative to standard PHP if statements.
-
@foreach / @endforeach: Loops over arrays or collections easily.
-
@forelse / @empty / @endforelse: A powerful loop that falls back to the @empty block if the provided array is empty, removing the need for a separate count() check.
For full documentation visit laravel.com/docs/13.x/blade.
SpringBoot 
JAVA Framework
Spring Boot is an open-source, Java-based framework used to build standalone, production-grade applications with minimal manual configuration. It acts as an opinionated extension of the foundational Spring Framework, favoring "convention over configuration" to eliminate the heavy boilerplate code and XML setup traditionally required in enterprise Java development.
More Information...
Key Core Features
-
Auto-Configuration: Dynamically sets up your application context based on the JAR dependencies present on your classpath.
-
Embedded Servers: Includes built-in servers like Apache Tomcat or Jetty, allowing you to run your application directly as a JAR file without installing external software.
-
Starter Dependencies: Bundles common combinations of libraries into single, easy-to-manage dependencies (e.g., spring-boot-starter-web).
Step-by-Step "Hello World" Example
This example demonstrates how to build a simple REST API endpoint using Maven that returns a text message when visited.
- 1. Define Project Dependencies (pom.xml)
The pom.xml file tells Maven to pull in Spring Boot's web capabilities.
<project xmlns="http://apache.org"
xmlns:xsi="http://w3.org"
xsi:schemaLocation="http://apache.org http://apache.org">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- Inherit defaults from Spring Boot -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.5</version>
</parent>
<dependencies>
<!-- Includes Tomcat and Spring MVC for web/REST support -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
- 2. Create the Application & Controller Code
Create a file named DemoApplication.java in your src/main/java/com/example/demo directory.
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication // Combines configuration, component scanning, and auto-configuration
@RestController // Tells Spring this class handles HTTP web requests
public class DemoApplication {
public static void main(String[] args) {
// Launches the embedded Tomcat web server
SpringApplication.run(DemoApplication.class, args);
}
@GetMapping("/hello") // Maps HTTP GET requests for "/hello" to this method
public String sayHello() {
return "Hello World, Spring Boot!";
}
}
- 3. Run and Test the Application
Run via Terminal: Navigate to your project root folder and execute:
mvn spring-boot:run
Verify Result: Open your web browser or command-line client and visit http://localhost:8080/hello.
Expected Output:
Hello World, Spring Boot!
For full documentation visit spring.io.
.NET Core 
ASP.NET Framework
.NET Core (now officially known as just .NET) is a free, open-source, and cross-platform software development framework created by Microsoft. It allows you to build modern, high-performance applications that run identically on Windows, macOS, and Linux.
ASP.NET Core is a free, open-source, cross-platform web development framework developed by Microsoft and the .NET open-source community. It serves as a comprehensive modernization of the original ASP.NET, designed to build cloud-ready, high-performance web applications, backend APIs, IoT applications, and mobile backends using C#.
More Information...
Why is it so popular?
Unlike the older, legacy .NET Framework which was restricted exclusively to Windows, .NET Core was built from scratch to be modular, lightweight, and fully optimized for cloud computing and containerized deployments like Docker.
Key Features of .NET Core
-
Cross-Platform: Write your code once and run it on Windows, Linux, and macOS.
-
Open Source: The entire platform runtime, libraries, and compiler are open source with active community contributions.
-
High Performance: Consistently ranks among the fastest web frameworks in independent benchmarks.
-
Flexible Deployment: Can be installed globally on a server or bundled directly inside your app (self-contained deployment).
Step-by-Step Example: Creating a Minimal Web API
You can build various applications like console apps, websites, or mobile backends with .NET Core. Below is a practical example of creating a lightweight Web API that returns a list of products in JSON format.
Open your command terminal and use the .NET CLI (Command Line Interface) to generate a new web application:
dotnet new web -o MyFirstApi
cd MyFirstApi
Open the generated Program.cs file. Replace its contents with this clean C# code utilizing Minimal APIs:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
// Define a simple data model
var products = new List<Product>
{
new Product(1, "Laptop", 999.99m),
new Product(2, "Smartphone", 599.99m),
new Product(3, "Wireless Headphones", 149.99m)
};
// Map a GET endpoint to return the list of products
app.MapGet("/api/products", () => products);
app.Run();
// Record definition for clean data structure
public record Product(int Id, string Name, decimal Price);
In your terminal, execute the following command to start the built-in Kestrel web server:
dotnet run
The terminal will display a local URL (e.g., http://localhost:5000). Open your browser or a tool like Postman and navigate to http://localhost:5000/api/products. You will instantly receive a raw JSON response managed entirely by the .NET Core runtime:
[
{"id":1,"name":"Laptop","price":999.99},
{"id":2,"name":"Smartphone","price":599.99},
{"id":3,"name":"Wireless Headphones","price":149.99}
]
For full documentation visit dotnet.microsoft.com.
CakePHP 
PHP Framework
CakePHP is an open-source web application framework written in PHP that simplifies and accelerates development by following the Model-View-Controller (MVC) architecture. It heavily relies on the "Convention over Configuration" paradigm, meaning that if you follow the framework's standard naming guidelines, it automatically configures itself. This cuts down on repetitive boilerplate code and setup time.
More Information...
Core Architecture (MVC)
-
Model: Handles data validation and directly interacts with the database using an Object-Relational Mapper (ORM).
-
View: Renders the presentation layer and outputs standard formats like HTML, JSON, or XML.
-
Controller: Processes user requests, coordinates model operations, and selects the correct view layer.
Primary Features
-
Bake Console: A powerful command-line tool that reads your database schema and automatically generates fully functional CRUD templates.
-
Built-in Security: Includes tools for input validation, CSRF protection, SQL injection prevention, and XSS filtering.
-
No Configuration Needed: Avoids complex XML or YAML setup configurations.
Code Example: Creating an Articles Component
Here is a practical look at how CakePHP elements work together when creating a feature to display an article list, following the standard CakePHP CMS Tutorial Guidelines.
Create a standard MySQL table named articles. CakePHP expects lowercase, plural table names.
CREATE TABLE articles (
id INT AUTO_INCREMENT PRIMARY KEY,
title VARCHAR(255) NOT NULL,
body TEXT,
created DATETIME,
modified DATETIME
);
- 2. The Model (src/Model/Table/ArticlesTable.php)
The model class uses the singular capitalized name followed by Table. The framework automatically maps this file to the articles database table.
<?php
namespace App\Model\Table;
use Cake\ORM\Table;
use Cake\Validation\Validator;
class ArticlesTable extends Table
{
public function initialize(array $config): void
{
// Automatically manages 'created' and 'modified' timestamp fields
$this->addBehavior('Timestamp');
}
public function validationDefault(Validator $validator): Validator
{
$validator
->notEmptyString('title', 'A title is required')
->notEmptyString('body', 'A body is required');
return $validator;
}
}
- 3. The Controller (src/Controller/ArticlesController.php)
The controller handles user requests and pulls records from the database through the ArticlesTable model.
<?php
namespace App\Controller;
class ArticlesController extends AppController
{
public function index()
{
// Fetch all articles from the database
$articles = $this->Articles->find()->all();
// Pass the data to the view template
$this->set(compact('articles'));
}
}
- 4. The View Template (templates/Articles/index.php)
This template iterates over the data passed by the controller and prints the HTML code.
<h1>Blog Articles</h1>
<table>
<tr>
<th>Title</th>
<th>Created</th>
</tr>
<!-- Loop through the articles array -->
<?php foreach ($articles as $article): ?>
<tr>
<td>
<?= h($article->title) ?>
</td>
<td>
<?= $article->created->format(DATE_RFC850) ?>
</td>
</tr>
<?php endforeach; ?>
</table>
For full documentation visit cakephp.org.
Development Frameworks
JS Frameworks
CSS Frameworks
More Frameworks
---
title: More Frameworks
text: Other Frameworks Worth Listing
image: /assets/svg/grav.svg
link:
target:
---
