https://github.com/stechstudio/phpinfo
Parse, query, and display your PHP configuration with a clean API and a modern, searchable interface. Drop-in replacement for the default phpinfo() page.
https://github.com/stechstudio/phpinfo
info php phpinfo
Last synced: 21 days ago
JSON representation
Parse, query, and display your PHP configuration with a clean API and a modern, searchable interface. Drop-in replacement for the default phpinfo() page.
- Host: GitHub
- URL: https://github.com/stechstudio/phpinfo
- Owner: stechstudio
- License: mit
- Created: 2026-03-19T14:41:38.000Z (about 1 month ago)
- Default Branch: main
- Last Pushed: 2026-03-28T15:35:25.000Z (30 days ago)
- Last Synced: 2026-03-28T17:50:42.901Z (30 days ago)
- Topics: info, php, phpinfo
- Language: PHP
- Homepage: https://prettyphpinfo.com
- Size: 150 KB
- Stars: 5
- Watchers: 0
- Forks: 0
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Pretty PHP Info
[](https://packagist.org/packages/stechstudio/phpinfo)
[](https://packagist.org/packages/stechstudio/phpinfo)
[](LICENSE)
[](https://github.com/stechstudio/phpinfo/actions/workflows/tests.yml)
A beautiful, searchable replacement for `phpinfo()`. Query PHP configuration programmatically or browse it in a modern UI with dark mode, instant search, and click-to-copy.
## Requirements
- PHP 8.3+
- `ext-dom`
## Installation
```bash
composer require stechstudio/phpinfo
```
## Quickstart
The simplest way to use this package is the global `prettyphpinfo()` function — a drop-in replacement for `phpinfo()`:
```php
prettyphpinfo();
```
That's it. You'll get a pretty, searchable, dark-mode-ready page instead of the default `phpinfo()` output.
> If you're not using a framework with Composer autoloading, you'll need to add `require __DIR__ . '/vendor/autoload.php';` first.
Just like the native `phpinfo()`, you can pass `INFO_*` constants to control which sections are displayed:
```php
// Only show modules (excludes environment variables — useful for security)
prettyphpinfo(INFO_MODULES);
// Only general information
prettyphpinfo(INFO_GENERAL);
// Combine flags
prettyphpinfo(INFO_GENERAL | INFO_MODULES);
```
You can also use the class-based API directly:
```php
STS\Phpinfo\Info::render();
```
### Interact with `phpinfo()` configuration
If you're looking to directly inspect and interact with the configuration, capture it first:
```php
use STS\Phpinfo\Info;
$info = Info::capture();
// Or capture a subset
$info = Info::capture(INFO_MODULES);
```
If you have `phpinfo()` output that you've saved previously and want to load and parse:
```php
use STS\Phpinfo\Info;
// If you've saved the HTML output from phpinfo()
$info = Info::fromHtml($yourSavedHtmlOutput);
// If you've saved the CLI output from phpinfo()
$info = Info::fromText($yourSavedTextOutput);
// Or if you don't know the format, let the package detect it
$info = Info::detect($yourSavedOutput);
```
From here you can query base info, modules, and configs:
```php
// Your PHP version
$info->version(); // "8.5.4"
// Check for the presence of a specific module. Name is case-insensitive.
$info->hasModule('redis'); // true
// Check to see if a specific configuration key is present.
$info->hasConfig('ICU version'); // true
// Retrieve the value for a specific configuration key. If there is both
// a local and master value, the local is returned by default.
$info->config('max_file_uploads'); // "20"
// Pass 'master' to get the php.ini default instead of the effective local value.
$info->config('max_file_uploads', 'master'); // "100"
$info->config('BCMath support', 'master'); // null
// Convenience methods for common lookups
$info->os(); // "Linux"
$info->hostname(); // "my-server"
```
## Iterating over data structure
You can iterate over the full data structure to loop over your `phpinfo()` configuration. All lists (`modules()`, `groups()`, `configs()`) return iterable `Items` objects with `filter()`, `map()`, `first()`, `each()`, `count()`, and more.
```php
// Loop over defined modules
foreach($info->modules() as $module) {
$module->name(); // "session"
// Configs are grouped the same way phpinfo() groups them by table
foreach($module->groups() as $group) {
$group->headings(); // ["Directive", "Local Value", "Master Value"]
foreach($group->configs() as $config) {
$config->name(); // "session.gc_maxlifetime"
$config->localValue(); // "1440"
$config->hasMasterValue(); // true
$config->masterValue(); // "28800"
}
}
}
```
The data structure has four levels:
1. `PhpInfo` containing `modules()`
2. Modules with `name()`, containing `groups()`
3. Groups containing `configs()` and optionally `headings()`
4. Configs with `name()`, `value()`/`localValue()`, and optionally `masterValue()`
You can also access configs directly from the Module and PhpInfo levels:
```php
// Flatten grouped configs for a single module
$info->module('session')->configs();
// Flatten ALL configs across all modules
$info->configs();
```
### Modules and Groups
Look up a specific module and inspect it directly:
```php
// Case-insensitive lookup. Returns null if not found.
$module = $info->module('zend opcache');
// Retrieve the name as displayed in phpinfo()
$module->name(); // "Zend OPcache"
// Flatten all configs into one collection
$module->configs()->count(); // 59
// Query a specific config from this module
$module->config('Max keys'); // "16229"
$module->config('opcache.enable_file_override', 'master'); // "Off"
// Access individual groups
$group = $info->module('session')->groups()->first();
```
### Simple example
```php
foreach ($info->modules() as $module) {
echo '
' . $module->name() . '
';
echo '
- ';
- ';
echo $config->name() . ': ' . $config->value();
if($config->hasMasterValue()) {
echo ' (master: ' . $config->masterValue() . ')';
}
echo ' ';
foreach($module->configs() as $config) {
echo '
}
echo '
}
```
## Why not just use `ini_get()` or `extension_loaded()`?
PHP configuration is spread across a bunch of different functions, each with a narrow scope:
- `ini_get()` returns a single INI value, and only the local (effective) value
- `extension_loaded()` tells you if an extension is loaded, but nothing about its configuration
- `get_loaded_extensions()` gives you a list of names with no details
- `phpversion()` and `php_uname()` each return one thing
All of these require you to know exactly what you're looking for ahead of time. There's no way to discover what's available, iterate over all configuration, or search across modules.
Even if you combine all of them, there are things they simply can't tell you. The configure command PHP was compiled with, Zend extension details, stream wrappers, registered filters, and various per-extension metadata are only available through `phpinfo()`.
`phpinfo()` is the only function that gives you everything in one place. The problem is it dumps raw HTML (or plain text in CLI) with no API to work with.
This package parses that complete `phpinfo()` output and gives you:
- Iterate over all modules and configs without knowing what's installed
- Get both local and master values (`ini_get()` only returns the effective local value)
- Access phpinfo()-only data like compile options, stream wrappers, and registered filters
- One consistent API instead of juggling five different functions with different return types