24 Awesome PHP Libraries Every Developer Should Know

As a PHP developer, you have a wealth of useful libraries available on GitHub. Below is a curated list of 24 of the coolest libraries, each with a brief description and example code.

1. Dispatch – Micro‑framework

Dispatch is a tiny PHP framework that lets you define URL rules and methods without a full MVC stack, making it ideal for APIs, simple sites, or prototypes.

include 'dispatch.php';

get('/greet', function () {
    render('greet-form');
});

post('/greet', function () {
    $name = from($_POST, 'name');
    render('greet-show', array('name' => $name));
});

dispatch();

It can match specific HTTP request types and paths, render views, and be combined with larger frameworks for more complex applications.

2. Klein – Fast PHP Router

Klein is a lightweight router for PHP 5.3+. It offers a concise syntax and supports method‑specific routes and regular‑expression paths.

respond('/[:name]', function ($request) {
    echo 'Hello ' . $request->name;
});

respond('GET', '/posts', $callback);
respond('POST', '/posts/create', $callback);
respond('PUT', '/posts/[i:id]', $callback);
respond('DELETE', '/posts/[i:id]', $callback);

// Multiple methods
respond(array('POST','GET'), $route, $callback);

// Custom action
respond('/posts/[create|edit:action]/[i:id]', function ($request, $response) {
    switch ($request->action) {
        // do something
    }
});

Great for small projects, but for larger applications you’ll likely pair it with a full‑featured framework like Laravel or CodeIgniter.

3. Ham – Cached Router

Ham is another lightweight router that caches I/O using XCache or APC for extra speed.

require '../ham/ham.php';

$app = new Ham('example');
$app->config_from_file('settings.php');

$app->route('/pork', function($app) {
    return "Delicious pork.";
});

$hello = function($app, $name='world') {
    return $app->render('hello.html', array('name' => $name));
};
$app->route('/hello/<string>', $hello);
$app->route('/', $hello);

$app->run();

Requires at least one of XCache or APC, which may not be available on shared hosting.

4. Assetic – Asset Management

Assetic merges and minifies CSS/JS assets, reducing download size and HTTP requests.

use Assetic\Asset\AssetCollection;
use Assetic\Asset\FileAsset;
use Assetic\Asset\GlobAsset;

$js = new AssetCollection(array(
    new GlobAsset('/path/to/js/*'),
    new FileAsset('/path/to/another.js'),
));

echo $js->dump();

This approach speeds up page loads by cutting total payload and request count.

5. ImageWorkshop – Layered Image Manipulation

ImageWorkshop lets you work with layered images: resize, crop, watermark, etc.

$norwayLayer = ImageWorkshop::initFromPath('/path/to/images/norway.jpg');
$watermarkLayer = ImageWorkshop::initFromPath('/path/to/images/watermark.png');

$image = $norwayLayer->getResult();
header('Content-type: image/jpeg');
imagejpeg($image, null, 95);
exit;

For more advanced needs, consider the Imagine library.

6. Snappy – Snapshot / PDF Generation

Snappy generates snapshots, HTML, and PDFs via the wkhtmltopdf binary.

require_once '/path/to/snappy/src/autoload.php';
use Knp\Snappy\Pdf;

$snappy = new Pdf('/usr/local/bin/wkhtmltopdf');
header('Content-Type: application/pdf');
header('Content-Disposition: attachment; filename="file.pdf"');

echo $snappy->getOutput('https://www.github.com');

Note that some hosts may block execution of external binaries.

7. Idiorm – Lightweight ORM

Idiorm is a thin ORM built on PDO, allowing you to write queries without raw SQL.

$user = ORM::for_table('user')
    ->where_equal('username', 'j4mie')
    ->find_one();

$user->first_name = 'Jamie';
$user->save();

$tweets = ORM::for_table('tweet')
    ->select('tweet.*')
    ->join('user', array('user.id', '=', 'tweet.user_id'))
    ->where_equal('user.username', 'j4mie')
    ->find_many();

foreach ($tweets as $tweet) {
    echo $tweet->text;
}

Its sister library, Paris, provides an Active Record implementation.

8. Underscore – PHP Utility Belt

Underscore brings the full power of Underscore.js to PHP.

__::each(array(1, 2, 3), function($num) { echo $num . ','; }); // 1,2,3,

$multiplier = 2;
__::each(array(1, 2, 3), function($num, $index) use ($multiplier) {
    echo $index . '=' . ($num * $multiplier) . ',';
}); // 0=2,1=4,2=6,

__::reduce(array(1, 2, 3), function($memo, $num) { return $memo + $num; }, 0); // 6
__::find(array(1, 2, 3, 4), function($num) { return $num % 2 === 0; }); // 2
__::filter(array(1, 2, 3, 4), function($num) { return $num % 2 === 0; }); // array(2, 4)

It also supports chainable syntax for more expressive code.

9. Requests – Simple HTTP Client

Requests simplifies making HTTP calls without remembering cURL options.

$headers = array('Accept' => 'application/json');
$options = array('auth' => array('user', 'pass'));
$request = Requests::get('https://api.github.com/gists', $headers, $options);

var_dump($request->status_code); // int(200)
var_dump($request->headers['content-type']); // "application/json; charset=utf-8"
var_dump($request->body); // response body

Supports HEAD, GET, POST, PUT, DELETE, PATCH, file uploads, and more.

10. Buzz – Simple HTTP Request Library

Buzz provides a minimal API for sending HTTP requests.

$request = new Buzz\Message\Request('HEAD', '/', 'http://google.com');
$response = new Buzz\Message\Response();

$client = new Buzz\Client\FileGetContents();
$client->send($request, $response);

echo $request;
echo $response;

Documentation is sparse, so you may need to read the source.

11. Goutte – Web Scraping

Goutte offers an elegant API for crawling and extracting data from web pages.

require_once '/path/to/goutte.phar';
use Goutte\Client;

$client = new Client();
$crawler = $client->request('GET', 'http://www.symfony-project.org/');
$link = $crawler->selectLink('Plugins')->link();
$crawler = $client->click($link);
$t = $crawler->filter('#data')->text();

echo "Here is the text: $t";

12. Carbon – DateTime Library

Carbon extends PHP's DateTime with a fluent API.

printf("Now: %s", Carbon::now()->toDateTimeString());
$tomorrow = Carbon::now()->addDay();
$lastWeek = Carbon::now()->subWeek();
$nextOlympics = Carbon::createFromDate(2012)->addYears(4);
if (Carbon::now()->gte($nextOlympics)) { die(); }
if (Carbon::now()->isWeekend()) { echo 'Party!'; }

echo Carbon::now()->subMinutes(2)->diffForHumans(); // "2 minutes ago"

13. Ubench – Micro Benchmarking

Ubench measures execution time and memory usage of PHP code.

use Ubench\Ubench;
$bench = new Ubench;
$bench->start();
// ... code to benchmark ...
$bench->end();

echo $bench->getTime(); // e.g., 156ms
echo $bench->getMemoryPeak(); // e.g., 15.23Mb

Running these checks during development is a good practice.

14. Validation – Input Validation Engine

Validation claims to be the most powerful PHP validation library.

use Respect\Validation\Validator as v;
$number = 123;
v::numeric()->validate($number); // true

$usernameValidator = v::alnum()->noWhitespace()->length(1,15);
$usernameValidator->validate('alganet'); // true

$user = new stdClass;
$user->name = 'Alexandre';
$user->birthdate = '1987-07-01';
$userValidator = v::attribute('name', v::string()->length(1,32))
    ->attribute('birthdate', v::date()->minimumAge(18));
$userValidator->validate($user); // true

It can validate forms, objects, and provides rich error handling.

15. Filterus – Filtering Library

Filterus validates and filters strings according to predefined patterns.

$f = Filter::factory('string,max:5');
$str = 'This is a test string';
$f->validate($str); // false
$f->filter($str); // 'This '

Supports chained rules and array element validation.

16. Faker – Fake Data Generator

Faker creates realistic fake data for testing databases and applications.

require_once '/path/to/Faker/src/autoload.php';
$faker = Faker\Factory::create();

echo $faker->name; // "Lucy Cechtelar"
echo $faker->address;
echo $faker->text;

Accessing properties continuously generates new random values.

17. Mustache.php – Templating Engine

Mustache provides a logic‑less templating language for PHP.

$m = new Mustache_Engine;
echo $m->render('Hello {{planet}}', array('planet' => 'World!'));
// Outputs: Hello World!

See the official Mustache docs for advanced usage.

18. Gaufrette – Filesystem Abstraction

Gaufrette abstracts local files, FTP, Amazon S3, and more behind a unified API.

use Gaufrette\Filesystem;
use Gaufrette\Adapter\Local as LocalAdapter;

$adapter = new LocalAdapter('/var/media');
$filesystem = new Filesystem($adapter);

$content = $filesystem->read('myFile');
$filesystem->write('myFile', 'Hello I am the new content');

Additional adapters for caching and memory are available.

19. Omnipay – Payment Processing Library

Omnipay offers a consistent API for dozens of payment gateways.

use Omnipay\GatewayFactory;
$gateway = GatewayFactory::create('Stripe');
$gateway->setApiKey('abc123');
$formData = ['number' => '4111111111111111', 'expiryMonth' => 6, 'expiryYear' => 2016];
$response = $gateway->purchase(['amount' => 1000, 'card' => $formData]);

if ($response->isSuccessful()) {
    // payment succeeded
    print_r($response);
} elseif ($response->isRedirect()) {
    $response->redirect();
} else {
    exit($response->getMessage());
}

The uniform API makes switching gateways straightforward.

20. Upload – File Upload Handling

Upload simplifies file uploads and validation of type and size.

$storage = new \Upload\Storage\FileSystem('/path/to/directory');
$file = new \Upload\File('foo', $storage);
$file->addValidations(array(
    new \Upload\Validation\Mimetype('image/png'),
    new \Upload\Validation\Size('5M')
));

try {
    $file->upload();
} catch (\Exception $e) {
    $errors = $file->getErrors();
}

Reduces boilerplate code for handling uploads.

21. HTMLPurifier – HTML XSS Protection

HTMLPurifier filters HTML to prevent XSS attacks and ensures standards‑compliant markup.

require_once '/path/to/HTMLPurifier.auto.php';
$config = HTMLPurifier_Config::createDefault();
$purifier = new HTMLPurifier($config);
$clean_html = $purifier->purify($dirty_html);

Use it whenever you allow users to submit raw HTML.

22. ColorJizz‑PHP – Color Manipulation

ColorJizz converts between color formats and performs simple color calculations.

use MischiefCollective\ColorJizz\Formats\Hex;
$red_hex = new Hex(0xFF0000);
$red_cmyk = $red_hex->toCMYK();

echo $red_cmyk; // 0,1,1,0

echo Hex::fromString('red')->hue(-20)->greyscale(); // 555555

Supports all major color formats.

23. PHP Geo – Geolocation Library

phpgeo calculates high‑precision distances between geographic coordinates.

use Location\Coordinate;
use Location\Distance\Vincenty;

$coord1 = new Coordinate(19.820664, -155.468066); // Mauna Kea
$coord2 = new Coordinate(20.709722, -156.253333); // Haleakala

$calculator = new Vincenty();
$distance = $calculator->getDistance($coord1, $coord2); // meters

Ideal for apps that need location‑based calculations.

24. ShellWrap – Elegant Command‑Line Wrapper

ShellWrap lets you run powerful Linux/Unix commands from PHP.

require 'ShellWrap.php';
use \MrRio\ShellWrap as sh;

// List files
echo sh::ls();

// Git checkout
sh::git('checkout', 'master');

// Pipe curl output to grep
echo sh::grep('html', sh::curl('http://example.com', array('location' => true)));

// Create and remove a file
sh::touch('file.html');
sh::rm('file.html');

try {
    sh::rm('file.html');
} catch (Exception $e) {
    echo 'Caught failing sh::rm() call';
}

Exceptions are thrown on command failures, allowing robust error handling.

Article translated from the original tutorialzine post and originally published on 伯乐在线.