The following article was updated in 2026 and added information about PHP 8.5.

Developers often require the ability to run multiple PHP versions in their development environment. This article provides a step-by-step guide on setting up a LAMP stack (Linux, Apache, MariaDB, PHP) with multiple PHP instances on Ubuntu/Kubuntu 23.10 Linux in the year 2024.

This guide covers the installation of LAMP for development or testing purposes. It is not a guide for setting up a LAMP for a production server, it does not deal at all with aspects such as security on a production server, etc.

In order to have multiple versions of PHP running simultaneously on Apache, you need the fcgid apache module, which helps us run PHP scripts using FASTCGI. At the same time, it can then run these scripts using different PHP versions. And we do this by creating a virtual host for each PHP version.

Install PHP 7.4, 8.2, 8.3

Prerequisites

Before beginning the installation process, ensure that your Ubuntu/Kubuntu system is up to date by running the following command:

sudo apt update

Installing Apache


Start by installing Apache version 2:

sudo apt install -y apache2 apache2-utils
Note: It is possible that our system is already running the latest Apache 2, then nothing is installed and everything is fine.

Check if the Apache service is running:

systemctl status apache2

Verify in your browser:

 

Since we'll be doing development, we'll set the rights and ownership for the server root folder right away (user: jan, group: jan):

sudo chown jan:jan /var/www/ -R

Installing MariaDB


Proceed with the installation of MariaDB:

sudo apt install mariadb-server mariadb-client

As with Apache, we can check if the service is running:

systemctl status mariadb

Now we will perform the initial setup of MariaDB, mainly setting the password for the root user. Run the following command and follow the questions:

sudo mysql_secure_installation

For example:

Switch to unix_socket authentication? ... Y
Change the root password? ... Y
Remove anonymous users? ... Y
Disallow root login remotely? ... Y
Remove test database and access to it? ... Y
Reload privilege tables now? ... Y

Installing Multiple PHP Versions

And now we will install multiple instances of PHP. There will be two oddities:

1) to avoid conflicting PHP libraries, we will uninstall all the PHP libraries already installed.

Be careful to do this step only if you are not using old PHP instances
sudo apt-get remove 'php*'
sudo apt-get purge 'php*'

2) Add a new specific repository to our system that will allow us to install the latest PHP versions

sudo apt install software-properties-common -y
sudo add-apt-repository ppa:ondrej/php -y
sudo apt update && sudo apt upgrade

After that, let's move on, install the apache module fcgid:

sudo apt install libapache2-mod-fcgid

And proceed to install PHP versions (along with PHP we list various modules here, go through the list of modules and you can delete the modules that are listed here and you don't need them)

PHP 7.4

sudo apt install php7.4 libapache2-mod-php7.4 php7.4-common php7.4-mysql php7.4-cli php7.4-opcache php7.4-readline php7.4-phpdbg php7.4-fpm php7.4-cgi libphp7.4-embed php7.4-xml php7.4-xmlrpc php7.4-curl php7.4-gd php7.4-dev php7.4-imap php7.4-mbstring php7.4-soap php7.4-zip php7.4-intl php7.4-ssh2 -y
Caution - for version 7.4 or 8.3 it is possible that the repository information is not ready for our system (repository ppa:ondrej/php), so we need to change this information

Open and edit following file: /etc/apt/sources.list.d/ondrej-ubuntu-php-mantic.sources

Change string "mantic" to "jammy"

then update the repository information:

sudo apt update

And then we can install version 7.4 or 8.3.

So we run the PHP 7.4 installation again (don't run it if everything was fine before).

And let's see an example of another problem, it may be that some library is in conflict, e.g:

The following packages have unmet dependencies: php7.4-intl : Depends on: libicu70 (>= 70.1-1~).

In such cases, you have to search the Internet for a solution and resolve the conflicts separately, in our case for the library: php7.4-intl we resolve them by reinstalling libicu70:

wget http://ftp.osuosl.org/pub/ubuntu/pool/main/i/icu/libicu70_70.1-2_amd64.deb
sudo dpkg -i libicu70_70.1-2_amd64.deb

And now, for the third time, install PHP 7.4 (don't do it if you managed to install it successfully before).

PHP 8.2

sudo apt install php8.2 libapache2-mod-php8.2 php8.2-common php8.2-mysql php8.2-cli php8.2-opcache php8.2-readline php8.2-phpdbg php8.2-fpm php8.2-cgi libphp8.2-embed php8.2-xml php8.2-xmlrpc php8.2-curl php8.2-gd php8.2-dev php8.2-imap php8.2-mbstring php8.2-soap php8.2-zip php8.2-intl php8.2-ssh2 -y

PHP 8.3

sudo apt install php8.3 libapache2-mod-php8.3 php8.3-common php8.3-mysql php8.3-cli php8.3-opcache php8.3-readline php8.3-phpdbg php8.3-fpm php8.3-cgi libphp8.3-embed php8.3-xml php8.3-xmlrpc php8.3-curl php8.3-gd php8.3-dev php8.3-imap php8.3-mbstring php8.3-soap php8.3-zip php8.3-intl php8.3-ssh2 -y
Update 2026

PHP 8.5

sudo apt install php8.5 libapache2-mod-php8.5 php8.5-common php8.5-mysql php8.5-cli php8.5-readline php8.5-phpdbg php8.5-fpm php8.5-cgi libphp8.5-embed php8.5-xml php8.5-xmlrpc php8.5-curl php8.5-gd php8.5-dev php8.5-imap php8.5-mbstring php8.5-soap php8.5-zip php8.5-intl php8.5-ssh2 -y

php8.5-opcache instruction was removed for PHP 8.5 because it is now included in core.

We can check if all PHP instances are installed:

ls -la /var/run/php/

The fpm service takes care of running all PHP instances. Before we start it or check its status, let's modify the user so that PHP scripts have the ownership and rights of the same user who creates folders on the server and uploads files to them.

Open and edit the following files, replace all occurrences of "www-data" in these files with the user (and group) name, in our case it is "jan":

/etc/php/7.4/fpm/pool.d/www.conf
/etc/php/8.2/fpm/pool.d/www.conf
/etc/php/8.3/fpm/pool.d/www.conf

Now start the fpm services (restart them if they are running):

sudo systemctl restart php7.4-fpm
sudo systemctl restart php8.2-fpm
sudo systemctl restart php8.3-fpm

By running the following command we can check the status of the service (e.g. for PHP 8.3)

sudo systemctl status php8.3-fpm

Let's enable some necessary apache modules:

sudo a2enmod actions fcgid alias proxy_fcgi rewrite

Restart Apache:

sudo systemctl restart apache2

Create Virtual Hosts

Now we will create virtual hosts, for all PHP versions we will create our own file in the folder:

/etc/apache2/sites-available/

we create the following files:

site74.test.conf
site82.test.conf
site83.test.conf

Each of them will contain the following instructions (PHP 8.3 example):

<VirtualHost *:80>
    ServerAdmin Site
    ServerName  site83.test
    ServerAlias www.site83.test
    DocumentRoot /var/www/site83.test
    <Directory /var/www/site83.test/>
            Options FollowSymLinks MultiViews
            AllowOverride All
            Order allow,deny
            allow from all
            Require all granted
    </Directory>
    <FilesMatch \.php>
        SetHandler "proxy:unix:/var/run/php/php8.3-fpm.sock|fcgi://localhost/"
    </FilesMatch>
</VirtualHost>

Once we have these files created and saved, then we enable all the pages:

sudo a2ensite site74.test.conf
sudo a2ensite site82.test.conf
sudo a2ensite site83.test.conf

And reload apache:

sudo systemctl reload apache2

To make sure that our system knows the names of our test pages, we will modify

/etc/hosts

and add this line:

127.0.0.1 localhost site74.test site82.test site83.test

In /var/www/ folder

create the following subfolders for our test domains:

mkdir /var/www/site74.test
mkdir /var/www/site82.test
mkdir /var/www/site83.test

We create them without sudo, using a user that also runs PHP scripts, in our case jan and insert a PHP file index.php into each of them, which will contain:

<?php
echo phpinfo();
?>

Every time we make a change to the settings (e.g. php.ini, etc.) we restart both apache and fpm

sudo systemctl restart php8.3-fpm
sudo systemctl restart apache2

Then enter the following URLs into the address bar one by one:

site74.test

site82.test

site83.test

Conclusion

By following these steps, you can successfully set up a LAMP stack with multiple PHP instances on Ubuntu/Kubuntu 23.10 Linux in 2024. This configuration allows developers to work on different PHP versions simultaneously for their development needs.

Starting a new translation for robust Joomla extensions like Phoca Cart can take dozens of hours. To help you get started faster, we offer the creation of a basic translation package generated by our specialized local AI models.
 
These models are designed to protect complex elements like HTML tags, email variables, and special characters that standard translation services often break. While the AI result isn't perfect, it provides a solid foundation for you to refine and finish.
 
If you need to translate a Phoca extension into a new language, watch the video for more details and contact us to prepare the initial translation base for you.
 

It is true that a modern one-page website can be generated in seconds using AI or static site generators. While this speed is impressive, we have chosen to use a Content Management System (CMS) for this project for critical reasons like future management and scalability.

In our latest video tutorial (embedded below), we demonstrate how to build a fully functional One-Page Website using Joomla CMS. We take a very simple and efficient approach: rather than complex coding, we build the entire structure using Joomla modules. This allows us to take a client’s raw text and turn it into a clean, easily editable website in just a few minutes.

The Problem with Static HTML

Last time, we explored how AI can generate websites instantly. But relying on static HTML brings significant challenges the moment a project is handed over to a client.

Static HTML is rigid. Updating content, adding new languages, or expanding a one-page site into a multi-page web application requires manual coding. If a client wants to change a paragraph or swap an image, they cannot do it without technical knowledge. As requirements grow, perhaps adding eCommerce or advanced user features, a static site faces limitations in its flexibility and capability.

Why Choose a CMS?

By choosing a Content Management System (CMS) over static files, we prioritize the future of the website. A CMS handles the heavy lifting, allowing for:

  • Easy editing and management in the future
  • Simple content updates for clients or non-technical users
  • Easy redesign and layout changes
  • Scalable and extendable with new features
  • Built-in tools for SEO, caching, security, and user management
  • Supports multilingual content out of the box
  • Reduces dependency on developers for everyday updates
  • Website can grow from one-page to full web application

Why Joomla?

For this project, we chose Joomla because it offers a perfect balance of power and flexibility. Unlike some platforms that rely heavily on bloated plugins, Joomla is a robust system built on modern code architecture.

Key advantages of using Joomla for this build include:

  • A real system built on modern code architecture
  • Template overrides: Customization without breaking the core
  • Menu architecture with full control over navigation and links
  • Modular extensions: Plugins, modules and components
  • Performance, SEO, and Accessibility: Optimized out of the box
  • Advanced access control levels (ACL)
  • Multilingual Support: Native and simple
  • A powerful system with flexibility at its core
  • Security: Designed with protection in mind
  • Community and development focus on best practices

What We Build in the Video

In the tutorial below, we guide you through the complete process step-by-step.

Since this is a one-page website, we take a slightly different approach than the standard "article-based" structure. Instead, we utilize modules to build distinct rows and containers.

To achieve a lightweight and responsive design, we utilize:

  1. Phoca Spectrum Template: A clean template that uses standard Joomla settings and Bootstrap classes without heavy frameworks, and allows us to easily add containers (rows) and columns.
  2. Phoca Particles Module: A tool designed specifically to create structured content blocks (like services, team members, and features) easily.
  3. Phoca Maps: For integrating a privacy-friendly map in the contact section.

We walk through setting up the Home banner with animations, an About Us section, Team profiles, References, and a Contact form. Finally, we demonstrate the power of Joomla's customization by using user.css to globally change the color scheme in seconds, proving that you can have a custom design with the stability of a CMS.

Watch the full tutorial below to see how we go from raw text to a finished Joomla website in minutes.

In this article, we’ll explore how artificial intelligence can be integrated into a CMS environment - specifically Joomla CMS - to create complete websites quickly and flexibly. We’ll also walk through a demonstration where AI is used to generate two different websites inside Joomla. This article is intended primarily as inspiration and as a starting point for discussion about the possible directions Joomla CMS could take when working with AI. The system shown here is just one of many potential ways AI and a CMS could collaborate.

Watch the video below to see how Joomla CMS, together with several specialized extensions, could be used to build two example websites from start to finish. 

 

As we mention in the video, an important aspect of combining AI with a CMS is that creating a website with AI is only the first step. We also need to be able to modify the site, make adjustments, add new features, or integrate ready-made solutions. This is where the CMS plays an irreplaceable role.

 

The Tools We’ll Use

Alongside Joomla CMS itself, we’ll be using three key extensions from Phoca:

  • Phoca AI Component - a component that connects Joomla to AI models and helps generate both content and design.
  • Phoca AI Template - a Joomla template serving as the base for all generated layouts.
  • Phoca Particles Module - a module for creating individual Joomla modules systematically.

The Test Prompts

For our demonstration, we’ll give AI two different prompts:

1. Software Developer Website

"Freelance software developer. There will be a comparison table with three main pricing plans: Basic, Standard, and Pro. The site should include menu links like Portfolio, Services, and Contact. The developer is called 'Spectrum' and offers software development. The page should contain bold colors."

2. Restaurant Website

"Restaurant website that specializes in selling pasta, pizza, fish, and salads. There should be menu links like Menu, Order Online, and Find Us."

In each case, the prompt is sent to the AI, which then generates the website directly inside Joomla - complete with initial layout, structure, and styling.

The Role of the CMS

AI gives us a strong starting point by generating the basic structure and design. The CMS - in this case Joomla - then takes over as the main platform for editing, expanding, and integrating specialized extensions for specific needs.

This collaboration between AI and CMS can take many forms:

  • Single Prompt for the Entire Website
    Simple to set up, but harder to fine-tune individual sections.
  • Chat-based Editing
    A conversational approach that allows precise control over each element, but requires more computing resources.
  • Multiple Prompts for Individual Sections
    Useful for Joomla page builders - each block or section could have its own tailored prompt for maximum flexibility.

Choosing the Right Environment

The environment in which the CMS runs plays a crucial role. The setup shown in our demo is best suited for a SaaS-type environment, because it relies on three different technologies working together:

  1. PHP, Apache, SQL, JavaScript (browser) - the CMS backbone.
  2. Node.js - server-side JavaScript, used here mainly for compiling and optimizing assets.
  3. Python with Flask - for communication with local AI models.

Such an environment is rarely available on typical shared hosting. However, all is not lost - Node.js could be replaced by PHP for certain tasks, and AI queries could be sent to external services. With the right adjustments, this system could run even on shared servers.

Technical Breakdown of the Demonstration Setup

To replicate what you see in the video, the following would be needed on a single server or machine:

  • Apache - serving PHP and MySQL.
  • PHP - core CMS logic.
  • MySQL/MariaDB - database storage.
  • JavaScript - a bridge between PHP and Python; PHP assembles prompts, sends them to JS, which forwards them to Python (Flask), then processes and stores responses.
  • Node.js - a simple tool for compiling SCSS and JavaScript, minifying files, gzipping, and generating RTL versions.
  • Python with Flask - handling communication with local AI model.

Design Flexibility

Design is one example where a CMS can help us be more flexible.
While AI tools might allow us to change the design only through prompts, combining AI with a CMS opens up more possibilities:

  • Not only through prompts
  • But also by adjusting SCSS variables and recompiling CSS files
  • Or overriding styles in a user.css file directly from the template
  • Or Using built-in template parameters (a common feature in Joomla templates)
  • And more.

All of this gives us a wider range of options and greater flexibility.

AI vs. Pre-Prepared Assets

A key decision is deciding what to let AI create from scratch and what to base on pre-prepared datasets.

Example: Color Schemes
Do we allow AI to generate colors freely, or do we supply professionally designed palettes and let AI choose the most appropriate one?

Example: Images
We can let AI generate them, or we can provide a curated dataset. However, in most real-world cases - such as restaurants - custom photography is essential. A restaurant will almost always want to feature images of its actual interior and dishes rather than entirely AI-generated visuals.

Conclusion

The integration of AI into a CMS like Joomla opens up exciting possibilities for rapid website creation. Whether you opt for fully automated generation or a hybrid approach with human-curated assets, the combination of AI’s creative speed and Joomla’s customization power can significantly accelerate the development process while maintaining full creative control.

Manage a Joomla website more efficiently and faster. We'll go through five helpful administration extensions - plugins and modules - that can make working in the Joomla admin area easier and more pleasant.

Phoca Top Menu Module


Let’s start with the Phoca Top Menu module. This module adds a top menu bar for desktop users, where an alternative Joomla menu can be displayed. For many users, this can offer a clearer and more structured navigation. Besides better structure, it also speeds up work on desktop, since the menu items are much easier to access.

See: Phoca Top Menu module

Phoca Filter Options Plugin

Next, let’s take a look at the Phoca Filter Options plugin. When working with long lists of settings in Joomla, finding a specific option can sometimes take a lot of time. This plugin makes that easier. It adds a filter that helps quickly locate parameters within larger configuration panels. This makes extension setup faster, as it’s possible to jump straight to the needed setting.

See: Phoca Filter Options plugin

Phoca Collapse Plugin

Then, there’s the Phoca Collapse plugin. It’s especially useful when working with settings that use subforms containing many fields. In such cases, it can be difficult to organize or reorder individual subform sections. This plugin allows less important details to be hidden, so the item becomes easier to manage. It makes it much simpler to sort or rearrange parts of the subform without being distracted by too much information.

See: Phoca Collapse plugin

Phoca Desktop Plugin

Now, let’s move on to the Phoca Desktop plugin. This plugin makes it possible to create custom shortcuts right on the Joomla administration dashboard. These shortcuts can point not only to main sections, but also to specific actions - for example, 'Add New Article' or 'Add New Menu Item'. It’s a great way to speed up access to frequently used tasks. This can be helpful for administrators, and also for clients, who can get direct access to the actions they use most, without needing to go through the full menu structure.

See: Phoca Desktop plugin

Phoca Redirects Dashboard Module

Finally, there’s the Phoca Redirects Dashboard module - a useful tool for situations where automatic features run in the background and are easy to forget. For example, Joomla’s Redirect plugin can be used to track 404 error URLs, but if it’s left active for a long time, it may collect large amounts of data - often from bots. This module adds a warning to the admin dashboard when the number of saved URLs reaches a set limit. It serves as a reminder that the Redirect plugin is active, and helps prevent the database from becoming overloaded, which could affect site performance.

See: Phoca Redirects Dashboard module

Be sure to try some of these extensions to make managing the Joomla administration easier, more efficient, and faster.

 

 

  1. Joomla - Feedback and Ideas For Improving The Work in the Administration In Future Versions For a More Efficient Experience
  2. Inkscape - Place Text Behind Object
  3. Inkscape - Remove Image Background (AI) Extension
  4. Optimizing Image Background Removal with AI Models
  5. Welcome to Joomla, Dear WordPress Users: A Comprehensive Guide to Joomla’s Strengths

Page 1 of 7

100+
GitHub Projects
Arctic Code
Vault Contributor
12 Million+
Downloads
70 000+
Answered Questions
2 700+
Planted Trees

Misc

Documentation

Download

Demo

© Phoca 2026
Phoca and this site is not affiliated with or endorsed by The Joomla! Project™.
Any products and services provided through this site are not supported or warrantied by The Joomla! Project or Open Source Matters, Inc.
Use of the Joomla!® name, symbol, logo and related trademarks is permitted under a limited license granted by Open Source Matters, Inc.