UNA is a Community Management System. The core platform is a full-stack framework for independent community websites and apps. With UNA content management, collaboration, e-commerce, learning management, and social networking, you can build any online project you have in mind.
- Key Features
- Documentation
- Download
- Support & Development
- Setup Development Environment
- NEO web and mobile apps
- License
- Unlimited Scalability: Hundreds, thousands, or millions - get as many users as your hosting can handle. UNA won't limit you.
- Absolute Control: You own the data, you set the rules, you lead the community. We give you the tools and support.
- Permissive License: MIT - the license allowing unrestricted commercial and private use, distribution, and modification.
- Continuous Improvement: Regular security, performance, and feature updates for the core platform, apps, and integrations.
- Collective Innovation: Improvements and revisions initiated and co-funded by the platform users community.
- Integrations-Friendly: Integrate 3rd-party services as UNA apps or use UNA REST API to talk to your external apps.
- Secure-By-Design: Full-site SSL encryption, SPD development, regular service updates, and vulnerability audits.
- Compliance Readiness: We offer HIPAA, GDPR, CCPA (and any other regulations) compliance preparation service.
To install and run the UNA platform, you'll need a web-hosting server or you can use UNA Cloud hosting for an instant launch.
You can download the latest installable version of UNA Core and install it on your server. You will need to create an UNACMS.COM account to access all features.
UNA is managed by Yasko.Studio team and developed with the help of UNA Community.
- Free community support - Discussions
- Direct support and professional services - UNA Pro
The repository runs UNA locally with Docker Compose: nginx, PHP-FPM 8.3, a cron container, MariaDB, phpMyAdmin, Mailpit (catches all outgoing email) and the Jot sockets server.
This setup is for development only. It uses fixed passwords (root/root, una/una), plain HTTP and debug-friendly settings. To run a live site, follow the installation guide on a server you secure yourself, or use UNA Cloud.
- Docker with Docker Compose v2 (Docker Desktop, OrbStack, Colima, Podman with
docker compose, or another compatible engine). - Node.js 24 and Yarn 1.22, to build the JavaScript libraries.
- About 5 GB of free disk space: the checkout with its JavaScript and PHP dependencies takes about 3 GB, the Docker images and the database about 1.5 GB more.
- Git.
Clone the repository and go to its folder:
git clone https://github.com/unacms/UNA.git unacd unaInstall the JavaScript dependencies. This also builds plugins_public/ and Messenger's styles and emoji picker, and takes about 3 minutes:
yarnInstall the PHP dependencies into plugins/:
docker run --rm -v "$(pwd):/app" composer/composer:2 install --ignore-platform-reqsStart UNA and the other services:
docker compose up -dThe first start builds the PHP and cron images from source, which takes 5 to 15 minutes (about 14 minutes on an Apple Silicon Mac). Later starts take seconds.
Open http://localhost in your browser and follow the installer. On the database step enter:
| Field | Value |
|---|---|
| Database host name | mysql |
| Database name | una |
| Database user | una |
| Database password | una |
The installer preselects the starter apps; add or remove apps there, or later in Studio. It then installs them in batches and shows its progress, which takes about 3 minutes. Keep the page open until it reaches the finish page.
Port 80 is often taken (by another web server or your Docker app). Create a .env file next to docker-compose.yml:
UNA_PORT=8200Run docker compose up -d again and open http://localhost:8200. Install UNA at the address you will use: the installer saves it as the site URL. Any host name that points to 127.0.0.1 works the same way, for example http://una.localhost:8200.
All settings for .env:
| Variable | Default | What it does |
|---|---|---|
UNA_PORT |
80 |
Site port. Nginx listens on the same port inside the container, so UNA can reach its own URL from PHP (image transcoding needs this). |
PMA_PORT |
8080 |
phpMyAdmin |
MAILPIT_PORT |
8025 |
Mailpit |
MYSQL_PORT |
3306 |
MariaDB, for a database client on your computer |
JOT_PORT |
5555 |
Jot sockets server |
UNA_JOT_URL |
http://localhost:<JOT_PORT> |
Jot server address for Messenger, as the browser reaches it. Change it when you open the site from another device. |
PHP_DISPLAY_ERRORS |
0 |
1 prints PHP errors in pages. Errors are always in docker compose logs php. |
XDEBUG_MODE |
off |
debug turns Xdebug on, see below |
COMPOSE_PROJECT_NAME |
folder name | Set a different one to run a second copy of UNA side by side, with different ports |
Run docker compose up -d after you change .env.
phpMyAdmin, Mailpit, MariaDB and Jot listen on 127.0.0.1 only. The site port listens on all network interfaces.
The older address http://localhost.una.io still works on port 80: it is a public DNS name that points to 127.0.0.1, so it needs an internet connection.
The finish page lists three next steps. In this setup:
- Crontab line: skip it. Cron already runs every minute in the
croncontainer; anything UNA's cron prints shows indocker compose logs -f cron. - Remove the
installfolder: do it, from the repository folder:rm -rf install. Until then, every page of the site sends you to a page that asks you to remove it. - Go to Studio: you are already signed in with the operator account you created. Studio is at http://localhost/studio/ (with your port, if you set
UNA_PORT), where you add apps and change settings.
install is part of the repository, so in a git checkout git status lists its files as deleted. Don't commit that deletion. git checkout install brings the folder back when you need the installer again, for example after a reset (see below).
Other local services:
- Emails go to Mailpit: http://localhost:8025.
- Messenger delivers messages live through the Jot server in the
jotcontainer. Installing Messenger saves its address (UNA_JOT_URL) in Studio > Messenger > Settings > Jot Server URL; a site that already had Messenger needs it entered there. Without a Jot server URL, messages are still sent, and others see them when they reload the page. - Database: phpMyAdmin at http://localhost:8080 signs you in as MySQL
root(passwordroot).
| Command | What it does |
|---|---|
docker compose up -d |
Start, or apply changes to docker-compose.yml and .env |
docker compose stop |
Stop, keeping all data |
docker compose logs -f php |
PHP errors and the PHP-FPM log |
docker compose exec php bash |
Shell in the PHP container. The site is in /opt/una. |
docker compose build --pull |
Rebuild the PHP images, for example after a change to scripts/docker-compose/*.Dockerfile |
docker compose up -d --build --force-recreate web php cron |
After a git pull that changes scripts/docker-compose/. Those files are mounted into the containers or built into the images, and a plain docker compose up -d doesn't notice a change in them: nginx and PHP-FPM keep their old configuration until the containers are recreated. |
docker compose down -v |
Reset: delete the containers and the database. Then delete inc/header.inc.php, restore the install folder and run the installer again. Uploaded files in storage/ stay. |
Set XDEBUG_MODE=debug in .env and run docker compose up -d. Xdebug starts a session for requests that carry the XDEBUG_TRIGGER cookie or query parameter (a browser extension such as Xdebug Helper sets it). Visual Studio Code users have a ready launch configuration in .vscode/launch.json that listens on port 9003.
NEO is UNA's Next.js web client and its Expo app for iOS and Android. It lives in the neo/ folder. docker compose starts only UNA, not NEO: run NEO on your computer against the local UNA, with Node.js 24 and Yarn 1.22.
-
Install UNA as above, then in Studio → API:
- Settings: turn on Enable API, Allow access by origin and Allow access with API key.
- Keys: add a key.
- Origins: add
http://localhost:3000(the NEO web address).
-
In
neo/, runyarn(if it stops on a network error, run it again) and createneo/.env.local:UNA_URL=http://localhost NEXT_PUBLIC_UNA_URL=http://localhost UNA_API_KEY=the-key-from-studio APP_URL=http://localhost:3000 NEXT_PUBLIC_APP_URL=http://localhost:3000 NEO_IMAGES_ALLOW_LOCAL_IP=1
Use your UNA address, with the port if you set
UNA_PORT. -
Start the web app with
yarn web2inneo/and open http://localhost:3000. It runs the Next.js dev server with the variables fromneo/.env.local. For another port, runyarn web2 -p 3001and use that address inAPP_URL,NEXT_PUBLIC_APP_URLand the Studio origin. (yarn webis the same server behind theportlessproxy, which you would have to install separately.)
Good to know:
- The dev server compiles each page the first time you open it, so a first visit can take a minute or more, and later visits are quick. For a fast copy that you don't change, build it once and serve that:
yarn build, thenyarn prod2(add-p 3001for another port). - Messages in NEO's Messenger arrive live only with a sockets server: a Soketi server set in Studio → Settings → Sockets, and its address and key in
SOCKETS_HOST,SOCKETS_PORTandSOCKETS_KEYinneo/.env.local(seeneo/README.md). The Jot server indocker composeis for Messenger on the UNA site only. Without sockets, messages are still sent, and others see them when they reload. - Links in emails (confirm your email, notifications) open the UNA site. To open NEO instead, enter the NEO address in Studio → API → Site main URL in email notifications.
For the native apps, other variables, deployment and the rules for changing NEO, see neo/README.md and neo/AGENTS.md.
MIT
UNACMS on X @unacms
This project is tested with BrowserStack.