GetSimple CMS: a flat-file PHP CMS

Nothing here has been executed, and every statement comes only from the repository page supplied as the official source. Where that page is silent, this guide says unknown.

What GetSimple CMS is

The README describes GetSimple CMS as a flat-file CMS written in PHP. It says the project was created by Chris Cagle and is now supported and developed by a community. The repository is tagged with cms, file, flat, getsimple-cms, php and xml.

Its classification is a CMS product, meaning an application that runs on top of PHP. It is not a PHP runtime, not a framework and not a framework component library. It is also not part of PHP core. PHP supplies the language and extensions, and GetSimple is a site-management application built with them. It is unrelated to Drupal, which is a different CMS product. Do not transfer Drupal concepts such as modules, configuration management or Composer-based installs to GetSimple unless the project's own documentation says so.

Architecture and content model

The repository root lists these folders: admin, backups, data, plugins, theme and docs. It also holds a front-controller-style index.php, plus two template files named temp.gsconfig.php and temp.htaccess. From the names and the required extensions, the layout looks like this:

• admin is the back-end interface.
• theme holds the presentation layer.
• plugins is the extension point.
• data holds site content.
• backups holds backup copies.

The page does not describe the exact file formats, so treat the following as an inference to verify. The required extensions are SimpleXML, xml, json and dom, and the repository carries the topic xml. That suggests content and settings are stored as XML files rather than in a database. The page does not say whether a database is supported or required.

The execution model is the classic PHP request lifetime. A web server receives a request, PHP runs the application from the start, reads files, renders a page and ends. Nothing in the source describes a persistent worker mode.

Request lifetime versus persistent workers

In the classic model, each request starts with fresh PHP variables, so state does not accumulate in memory between requests. Persistent-worker systems keep the application booted and reuse it across requests. Examples are Swoole and Open Swoole, which are two separate projects despite similar names. The risk there is state leakage: static properties, globals, singletons, open handles and caches can carry one user's data into the next request. A worker setup must reset or isolate that state after every request.

The supplied source does not claim GetSimple works under any persistent-worker runtime. A CMS that reads and writes files and may rely on globals should be assumed to be written for the classic lifetime. Run it that way unless you can verify otherwise.

Practical use cases

The source says GetSimple is fast and efficient, but gives no measurements, so treat that as the project's own description. A flat-file CMS may suit small brochure sites, documentation pages or learning labs where you want to study a CMS without provisioning a database. Whether it suits your site depends on facts this source does not give.

Requirements

The README lists a build requirement of PHP 5.2 or newer and the extensions SimpleXML, xml, json and dom. The extensions curl and gd are optional. Browsers must have JavaScript enabled. Apache is required for out-of-the-box security through .htaccess. On other servers, the README says you get a non-Apache warning, because data files will not be protected automatically. You must secure the site yourself, and a configuration constant named GSNOAPACHECHECK disables the warning.

The PHP 5.2+ statement is a minimum, not a statement of modern compatibility. This course tracks PHP 8.4, with PHP 8.5 planned. Whether GetSimple runs correctly on either is unknown from this source. Check the project's current documentation and test on a throwaway host before relying on it.

Installation approach

The README points to installation and upgrade pages on the project website, so follow those as the authority. This guide does not reproduce the steps. From the repository you can clone the code and inspect its layout. The example below does that and runs a read-only preflight script that checks your CLI PHP for the documented extensions and the top-level folders.

Two cautions apply. The CLI may load different extensions than your web server, so repeat the check on the real host. The PHP built-in server is not Apache, so you should expect the non-Apache warning, and .htaccess protection will not apply. Use it only for local evaluation on 127.0.0.1, never on a public interface.

Strengths

• The project is open and licensed under GNU GPL v3, according to the README.
• Its footprint appears small: PHP plus a few common extensions.
• There is a plugin directory and a theme directory.
• The community is visible: about 417 stars and 120 forks at the time of the supplied snapshot.

Limitations and lifecycle

The lifecycle is unknown. The snapshot shows 3,039 commits, many open issues and open pull requests, but it does not show the latest commit date, a release version or a support policy. It does not say whether security fixes are still being issued. Do not infer either health or abandonment from the counts. Before choosing GetSimple for new work, check recent activity, the changelog file in the repository and the security reporting path.

Forks matter here. The page shows 120 forks, and the README refers to a forum and an official site. This guide cannot tell you which forks are maintained or compatible. Confirm that any download, plugin or theme comes from the repository you intend to use. Do not mix code from different forks without review.

Flat files have operational consequences. The web server needs write access to content and backup folders. Those folders must not be directly readable from the web. Concurrent editing, large sites and fine-grained access control are not covered by the source, so treat them as unknown.

Deployment notes

Prefer Apache with .htaccess honored, as the README recommends. If you use another server, write equivalent rules that deny direct access to the data and backup folders, and then verify them from outside. Never expose a development server publicly. Keep backups outside the web root where you can. Review the disclaimer: the maintainers state they cannot be held liable for data loss. The README directs bug and security reports to the project forum.

Next steps

Read the official installation and requirements documentation referenced by the README, then run the preflight on your intended host. After that, validate the whole flow on an isolated machine.

<?php
declare(strict_types=1);

// Read-only preflight for a GetSimple checkout. Usage: php tools/check-env.php [path]
$root = $argv[1] ?? __DIR__ . '/../site';
$failed = false;

echo 'PHP version: ' . PHP_VERSION . PHP_EOL;
echo 'Checking: ' . $root . PHP_EOL;

$required = ['SimpleXML', 'xml', 'json', 'dom'];
$optional = ['curl', 'gd'];

foreach ($required as $ext) {
    $ok = extension_loaded($ext);
    echo ($ok ? '[ok]      ' : '[missing] ') . 'required extension ' . $ext . PHP_EOL;
    if (!$ok) {
        $failed = true;
    }
}

foreach ($optional as $ext) {
    $ok = extension_loaded($ext);
    echo ($ok ? '[ok]      ' : '[absent]  ') . 'optional extension ' . $ext . PHP_EOL;
}

$dirs = ['admin', 'backups', 'data', 'plugins', 'theme'];
foreach ($dirs as $dir) {
    $ok = is_dir($root . '/' . $dir);
    echo ($ok ? '[ok]      ' : '[missing] ') . 'folder ' . $dir . PHP_EOL;
    if (!$ok) {
        $failed = true;
    }
}

$hasIndex = is_file($root . '/index.php');
echo ($hasIndex ? '[ok]      ' : '[missing] ') . 'index.php' . PHP_EOL;
if (!$hasIndex) {
    $failed = true;
}

foreach (['data', 'backups'] as $dir) {
    $writable = is_dir($root . '/' . $dir) && is_writable($root . '/' . $dir);
    echo '[info]    ' . $dir . ($writable ? ' is writable' : ' is not writable') . ' by this CLI user' . PHP_EOL;
}

exit($failed ? 1 : 0);

git clone https://github.com/GetSimpleCMS/GetSimpleCMS.git site
php tools/check-env.php site
php -S 127.0.0.1:8080 -t site